2 * This file was generated automatically by gen-mterp.py for 'x86'.
7 /* File: x86/header.S */
9 * Copyright (C) 2008 The Android Open Source Project
11 * Licensed under the Apache License, Version 2.0 (the "License");
12 * you may not use this file except in compliance with the License.
13 * You may obtain a copy of the License at
15 * http://www.apache.org/licenses/LICENSE-2.0
17 * Unless required by applicable law or agreed to in writing, software
18 * distributed under the License is distributed on an "AS IS" BASIS,
19 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
20 * See the License for the specific language governing permissions and
21 * limitations under the License.
24 * 32-bit x86 definitions and declarations.
28 386 ABI general notes:
31 eax, edx, ecx, st(0)-st(7)
36 64-bit in edx:eax (low-order 32 in eax)
37 fp on top of fp stack st(0)
39 Parameters passed on stack, pushed right-to-left. On entry to target, first
40 parm is at 4(%esp). Traditional entry code is:
43 push %ebp # save old frame pointer
44 mov %ebp,%esp # establish new frame pointer
45 sub FrameSize,%esp # Allocate storage for spill, locals & outs
47 Once past the prologue, arguments are referenced at ((argno + 2)*4)(%ebp)
49 Alignment of stack not strictly required, but should be for performance. We'll
50 align frame sizes to 16-byte multiples.
52 If we're not doing variable stack allocation (alloca), the frame pointer can be
53 eliminated and all arg references adjusted to be esp relative.
57 Some key interpreter variables will be assigned to registers. Note that each
58 will also have an associated spill location (mostly useful for those assigned
59 to callee save registers).
62 rPC edi interpreted program counter, used for fetching instructions
63 rFP esi interpreted frame pointer, used for accessing locals and args
64 rINSTw bx first 16-bit code of current instruction
65 rINSTbl bl opcode portion of instruction word
66 rINSTbh bh high byte of inst word, usually contains src/tgt reg names
67 rIBASE edx base of instruction handler table
70 o High order 16 bits of ebx must be zero on entry to handler
71 o rPC, rFP, rINSTw/rINSTbl valid on handler entry and exit
72 o eax and ecx are scratch, rINSTw/ebx sometimes scratch
86 /* Frame diagram while executing dvmMterpStdRun, high to low addresses */
88 #define CALLER_RP ( 8)
90 #define rSELF_SPILL ( 0) /* <- dvmMterpStdRun ebp */
91 /* Spill offsets relative to %ebp */
92 #define EDI_SPILL ( -4)
93 #define ESI_SPILL ( -8)
94 #define EBX_SPILL (-12) /* <- esp following dmMterpStdRun header */
95 #define rPC_SPILL (-16)
96 #define rFP_SPILL (-20)
97 #define rINST_SPILL (-24)
98 #define rIBASE_SPILL (-28)
99 #define TMP_SPILL1 (-32)
100 #define TMP_SPILL2 (-36)
101 #define TMP_SPILL3 (-20)
102 #define LOCAL0_OFFSET (-44)
103 #define LOCAL1_OFFSET (-48)
104 #define LOCAL2_OFFSET (-52)
105 /* Out Arg offsets, relative to %sp */
106 #define OUT_ARG4 ( 16)
107 #define OUT_ARG3 ( 12)
108 #define OUT_ARG2 ( 8)
109 #define OUT_ARG1 ( 4)
110 #define OUT_ARG0 ( 0) /* <- dvmMterpStdRun esp */
111 #define FRAME_SIZE 80
113 #define SPILL(reg) movl reg##,reg##_SPILL(%ebp)
114 #define UNSPILL(reg) movl reg##_SPILL(%ebp),reg
115 #define SPILL_TMP1(reg) movl reg,TMP_SPILL1(%ebp)
116 #define UNSPILL_TMP1(reg) movl TMP_SPILL1(%ebp),reg
117 #define SPILL_TMP2(reg) movl reg,TMP_SPILL2(%ebp)
118 #define UNSPILL_TMP2(reg) movl TMP_SPILL2(%ebp),reg
119 #define SPILL_TMP3(reg) movl reg,TMP_SPILL3(%ebp)
120 #define UNSPILL_TMP3(reg) movl TMP_SPILL3(%ebp),reg
122 #if defined(WITH_JIT)
123 .macro GET_JIT_PROF_TABLE _self _reg
124 movl offThread_pJitProfTable(\_self),\_reg
126 .macro GET_JIT_THRESHOLD _self _reg
127 movl offThread_jitThreshold(\_self),\_reg
131 /* save/restore the PC and/or FP from the self struct */
132 .macro SAVE_PC_FP_TO_SELF _reg
134 movl rPC,offThread_pc(\_reg)
135 movl rFP,offThread_fp(\_reg)
138 .macro LOAD_PC_FP_FROM_SELF
140 movl offThread_pc(rFP),rPC
141 movl offThread_fp(rFP),rFP
144 /* The interpreter assumes a properly aligned stack on entry, and
145 * will preserve 16-byte alignment.
149 * "export" the PC to the interpreted stack frame, f/b/o future exception
150 * objects. Must be done *before* something throws.
152 * In C this is "SAVEAREA_FROM_FP(fp)->xtra.currentPc = pc", i.e.
153 * fp - sizeof(StackSaveArea) + offsetof(SaveArea, xtra.currentPc)
155 * It's okay to do this more than once.
158 movl rPC, (-sizeofStackSaveArea + offStackSaveArea_currentPc)(rFP)
162 * Given a frame pointer, find the stack save area.
164 * In C this is "((StackSaveArea*)(_fp) -1)".
166 .macro SAVEAREA_FROM_FP _reg
167 leal -sizeofStackSaveArea(rFP), \_reg
171 * Fetch the next instruction from rPC into rINSTw. Does not advance rPC.
178 * Fetch the opcode byte and zero-extend it into _reg. Must be used
179 * in conjunction with GOTO_NEXT_R
181 .macro FETCH_INST_R _reg
186 * Fetch the opcode byte at _count words offset from rPC and zero-extend
187 * it into _reg. Must be used in conjunction with GOTO_NEXT_R
189 .macro FETCH_INST_OPCODE _count _reg
190 movzbl \_count*2(rPC),\_reg
194 * Fetch the nth instruction word from rPC into rINSTw. Does not advance
195 * rPC, and _count is in words
197 .macro FETCH_INST_WORD _count
198 movzwl \_count*2(rPC),rINST
202 * Fetch instruction word indexed (used for branching).
203 * Index is in instruction word units.
205 .macro FETCH_INST_INDEXED _reg
206 movzwl (rPC,\_reg,2),rINST
210 * Advance rPC by instruction count
212 .macro ADVANCE_PC _count
213 leal 2*\_count(rPC),rPC
217 * Advance rPC by branch offset in register
219 .macro ADVANCE_PC_INDEXED _reg
220 leal (rPC,\_reg,2),rPC
230 * Version of GOTO_NEXT that assumes _reg preloaded with opcode.
231 * Should be paired with FETCH_INST_R
233 .macro GOTO_NEXT_R _reg
235 jmp *(rIBASE,\_reg,4)
239 * Jumbo version of GOTO_NEXT that assumes _reg preloaded with table
240 * offset of the jumbo instruction, which is the top half of the extended
241 * opcode + 0x100. Loads rINST with BBBB field, similar to GOTO_NEXT_R
243 .macro GOTO_NEXT_JUMBO_R _reg
245 jmp *(rIBASE,\_reg,4)
249 * Get/set the 32-bit value from a Dalvik register.
251 .macro GET_VREG_R _reg _vreg
252 movl (rFP,\_vreg,4),\_reg
255 .macro SET_VREG _reg _vreg
256 movl \_reg,(rFP,\_vreg,4)
259 .macro GET_VREG_WORD _reg _vreg _offset
260 movl 4*(\_offset)(rFP,\_vreg,4),\_reg
263 .macro SET_VREG_WORD _reg _vreg _offset
264 movl \_reg,4*(\_offset)(rFP,\_vreg,4)
267 #define sReg0 LOCAL0_OFFSET(%ebp)
268 #define sReg1 LOCAL1_OFFSET(%ebp)
269 #define sReg2 LOCAL2_OFFSET(%ebp)
272 * Hard coded helper values.
278 .quad 0x8000000000000000
281 .quad 0xFFFFFFFFFFFFFFFF
284 .quad 0x0000000000000000
286 .quad 0x000000000000003F
289 .quad 0x0000000000000040
292 .quad 0x7FFFFFFFFFFFFFFF
295 .quad 0x8000000000000000
298 .quad 0x0000000000000000
308 * This is a #include, not a %include, because we want the C pre-processor
309 * to expand the macros into assembler assignment statements.
311 #include "../common/asm-constants.h"
313 #if defined(WITH_JIT)
314 #include "../common/jit-config.h"
318 .global dvmAsmInstructionStartCode
319 .type dvmAsmInstructionStartCode, %function
320 dvmAsmInstructionStartCode = .L_OP_NOP
323 /* ------------------------------ */
324 .L_OP_NOP: /* 0x00 */
325 /* File: x86/OP_NOP.S */
326 FETCH_INST_OPCODE 1 %ecx
330 /* ------------------------------ */
331 .L_OP_MOVE: /* 0x01 */
332 /* File: x86/OP_MOVE.S */
333 /* for move, move-object, long-to-int */
335 movzbl rINSTbl,%eax # eax<- BA
336 andb $0xf,%al # eax<- A
337 shrl $4,rINST # rINST<- B
338 GET_VREG_R rINST rINST
339 FETCH_INST_OPCODE 1 %ecx
341 SET_VREG rINST %eax # fp[A]<-fp[B]
344 /* ------------------------------ */
345 .L_OP_MOVE_FROM16: /* 0x02 */
346 /* File: x86/OP_MOVE_FROM16.S */
347 /* for: move/from16, move-object/from16 */
349 movzx rINSTbl,%eax # eax <= AA
350 movw 2(rPC),rINSTw # rINSTw <= BBBB
351 GET_VREG_R rINST rINST # rINST- fp[BBBB]
352 FETCH_INST_OPCODE 2 %ecx
354 SET_VREG rINST %eax # fp[AA]<- ecx]
357 /* ------------------------------ */
358 .L_OP_MOVE_16: /* 0x03 */
359 /* File: x86/OP_MOVE_16.S */
360 /* for: move/16, move-object/16 */
361 /* op vAAAA, vBBBB */
362 movzwl 4(rPC),%ecx # ecx<- BBBB
363 movzwl 2(rPC),%eax # eax<- AAAA
364 GET_VREG_R rINST %ecx
365 FETCH_INST_OPCODE 3 %ecx
370 /* ------------------------------ */
371 .L_OP_MOVE_WIDE: /* 0x04 */
372 /* File: x86/OP_MOVE_WIDE.S */
373 /* move-wide vA, vB */
374 /* NOTE: regs can overlap, e.g. "move v6,v7" or "move v7,v6" */
375 movzbl rINSTbl,%ecx # ecx <- BA
376 sarl $4,rINST # rINST<- B
377 GET_VREG_WORD %eax rINST 0 # eax<- v[B+0]
378 GET_VREG_WORD rINST rINST 1 # rINST<- v[B+1]
379 andb $0xf,%cl # ecx <- A
380 SET_VREG_WORD rINST %ecx 1 # v[A+1]<- rINST
381 SET_VREG_WORD %eax %ecx 0 # v[A+0]<- eax
382 FETCH_INST_OPCODE 1 %ecx
386 /* ------------------------------ */
387 .L_OP_MOVE_WIDE_FROM16: /* 0x05 */
388 /* File: x86/OP_MOVE_WIDE_FROM16.S */
389 /* move-wide/from16 vAA, vBBBB */
390 /* NOTE: regs can overlap, e.g. "move v6,v7" or "move v7,v6" */
391 movzwl 2(rPC),%ecx # ecx<- BBBB
392 movzbl rINSTbl,%eax # eax<- AAAA
393 GET_VREG_WORD rINST %ecx 0 # rINST<- v[BBBB+0]
394 GET_VREG_WORD %ecx %ecx 1 # ecx<- v[BBBB+1]
395 SET_VREG_WORD rINST %eax 0 # v[AAAA+0]<- rINST
396 SET_VREG_WORD %ecx %eax 1 # v[AAAA+1]<- eax
397 FETCH_INST_OPCODE 2 %ecx
401 /* ------------------------------ */
402 .L_OP_MOVE_WIDE_16: /* 0x06 */
403 /* File: x86/OP_MOVE_WIDE_16.S */
404 /* move-wide/16 vAAAA, vBBBB */
405 /* NOTE: regs can overlap, e.g. "move v6,v7" or "move v7,v6" */
406 movzwl 4(rPC),%ecx # ecx<- BBBB
407 movzwl 2(rPC),%eax # eax<- AAAA
408 GET_VREG_WORD rINST %ecx 0 # rINSTw_WORD<- v[BBBB+0]
409 GET_VREG_WORD %ecx %ecx 1 # ecx<- v[BBBB+1]
410 SET_VREG_WORD rINST %eax 0 # v[AAAA+0]<- rINST
411 SET_VREG_WORD %ecx %eax 1 # v[AAAA+1]<- ecx
412 FETCH_INST_OPCODE 3 %ecx
416 /* ------------------------------ */
417 .L_OP_MOVE_OBJECT: /* 0x07 */
418 /* File: x86/OP_MOVE_OBJECT.S */
419 /* File: x86/OP_MOVE.S */
420 /* for move, move-object, long-to-int */
422 movzbl rINSTbl,%eax # eax<- BA
423 andb $0xf,%al # eax<- A
424 shrl $4,rINST # rINST<- B
425 GET_VREG_R rINST rINST
426 FETCH_INST_OPCODE 1 %ecx
428 SET_VREG rINST %eax # fp[A]<-fp[B]
432 /* ------------------------------ */
433 .L_OP_MOVE_OBJECT_FROM16: /* 0x08 */
434 /* File: x86/OP_MOVE_OBJECT_FROM16.S */
435 /* File: x86/OP_MOVE_FROM16.S */
436 /* for: move/from16, move-object/from16 */
438 movzx rINSTbl,%eax # eax <= AA
439 movw 2(rPC),rINSTw # rINSTw <= BBBB
440 GET_VREG_R rINST rINST # rINST- fp[BBBB]
441 FETCH_INST_OPCODE 2 %ecx
443 SET_VREG rINST %eax # fp[AA]<- ecx]
447 /* ------------------------------ */
448 .L_OP_MOVE_OBJECT_16: /* 0x09 */
449 /* File: x86/OP_MOVE_OBJECT_16.S */
450 /* File: x86/OP_MOVE_16.S */
451 /* for: move/16, move-object/16 */
452 /* op vAAAA, vBBBB */
453 movzwl 4(rPC),%ecx # ecx<- BBBB
454 movzwl 2(rPC),%eax # eax<- AAAA
455 GET_VREG_R rINST %ecx
456 FETCH_INST_OPCODE 3 %ecx
462 /* ------------------------------ */
463 .L_OP_MOVE_RESULT: /* 0x0a */
464 /* File: x86/OP_MOVE_RESULT.S */
465 /* for: move-result, move-result-object */
467 movl rSELF,%eax # eax<- rSELF
468 movl offThread_retval(%eax),%eax # eax<- self->retval.l
469 FETCH_INST_OPCODE 1 %ecx
471 SET_VREG %eax rINST # fp[AA]<- retval.l
474 /* ------------------------------ */
475 .L_OP_MOVE_RESULT_WIDE: /* 0x0b */
476 /* File: x86/OP_MOVE_RESULT_WIDE.S */
477 /* move-result-wide vAA */
479 movl offThread_retval(%ecx),%eax
480 movl 4+offThread_retval(%ecx),%ecx
481 SET_VREG_WORD %eax rINST 0 # v[AA+0] <- eax
482 SET_VREG_WORD %ecx rINST 1 # v[AA+1] <- ecx
483 FETCH_INST_OPCODE 1 %ecx
487 /* ------------------------------ */
488 .L_OP_MOVE_RESULT_OBJECT: /* 0x0c */
489 /* File: x86/OP_MOVE_RESULT_OBJECT.S */
490 /* File: x86/OP_MOVE_RESULT.S */
491 /* for: move-result, move-result-object */
493 movl rSELF,%eax # eax<- rSELF
494 movl offThread_retval(%eax),%eax # eax<- self->retval.l
495 FETCH_INST_OPCODE 1 %ecx
497 SET_VREG %eax rINST # fp[AA]<- retval.l
501 /* ------------------------------ */
502 .L_OP_MOVE_EXCEPTION: /* 0x0d */
503 /* File: x86/OP_MOVE_EXCEPTION.S */
504 /* move-exception vAA */
506 movl offThread_exception(%ecx),%eax # eax<- dvmGetException bypass
507 SET_VREG %eax rINST # fp[AA]<- exception object
508 FETCH_INST_OPCODE 1 %eax
510 movl $0,offThread_exception(%ecx) # dvmClearException bypass
513 /* ------------------------------ */
514 .L_OP_RETURN_VOID: /* 0x0e */
515 /* File: x86/OP_RETURN_VOID.S */
516 jmp common_returnFromMethod
518 /* ------------------------------ */
519 .L_OP_RETURN: /* 0x0f */
520 /* File: x86/OP_RETURN.S */
522 * Return a 32-bit value. Copies the return value into the "self"
523 * structure, then jumps to the return handler.
525 * for: return, return-object
529 GET_VREG_R %eax rINST # eax<- vAA
530 movl %eax,offThread_retval(%ecx) # retval.i <- AA
531 jmp common_returnFromMethod
533 /* ------------------------------ */
534 .L_OP_RETURN_WIDE: /* 0x10 */
535 /* File: x86/OP_RETURN_WIDE.S */
537 * Return a 64-bit value. Copies the return value into the "self"
538 * structure, then jumps to the return handler.
540 /* return-wide vAA */
542 GET_VREG_WORD %eax rINST 0 # eax<- v[AA+0]
543 GET_VREG_WORD rINST rINST 1 # rINST<- v[AA+1]
544 movl %eax,offThread_retval(%ecx)
545 movl rINST,4+offThread_retval(%ecx)
546 jmp common_returnFromMethod
548 /* ------------------------------ */
549 .L_OP_RETURN_OBJECT: /* 0x11 */
550 /* File: x86/OP_RETURN_OBJECT.S */
551 /* File: x86/OP_RETURN.S */
553 * Return a 32-bit value. Copies the return value into the "self"
554 * structure, then jumps to the return handler.
556 * for: return, return-object
560 GET_VREG_R %eax rINST # eax<- vAA
561 movl %eax,offThread_retval(%ecx) # retval.i <- AA
562 jmp common_returnFromMethod
565 /* ------------------------------ */
566 .L_OP_CONST_4: /* 0x12 */
567 /* File: x86/OP_CONST_4.S */
568 /* const/4 vA, #+B */
569 movsx rINSTbl,%eax # eax<-ssssssBx
571 andl %eax,rINST # rINST<- A
572 FETCH_INST_OPCODE 1 %ecx
578 /* ------------------------------ */
579 .L_OP_CONST_16: /* 0x13 */
580 /* File: x86/OP_CONST_16.S */
581 /* const/16 vAA, #+BBBB */
582 movswl 2(rPC),%ecx # ecx<- ssssBBBB
583 FETCH_INST_OPCODE 2 %eax
585 SET_VREG %ecx rINST # vAA<- ssssBBBB
588 /* ------------------------------ */
589 .L_OP_CONST: /* 0x14 */
590 /* File: x86/OP_CONST.S */
591 /* const vAA, #+BBBBbbbb */
592 movl 2(rPC),%eax # grab all 32 bits at once
593 movl rINST,rINST # rINST<- AA
594 FETCH_INST_OPCODE 3 %ecx
596 SET_VREG %eax rINST # vAA<- eax
599 /* ------------------------------ */
600 .L_OP_CONST_HIGH16: /* 0x15 */
601 /* File: x86/OP_CONST_HIGH16.S */
602 /* const/high16 vAA, #+BBBB0000 */
603 movzwl 2(rPC),%eax # eax<- 0000BBBB
604 FETCH_INST_OPCODE 2 %ecx
606 sall $16,%eax # eax<- BBBB0000
607 SET_VREG %eax rINST # vAA<- eax
610 /* ------------------------------ */
611 .L_OP_CONST_WIDE_16: /* 0x16 */
612 /* File: x86/OP_CONST_WIDE_16.S */
613 /* const-wide/16 vAA, #+BBBB */
614 movswl 2(rPC),%eax # eax<- ssssBBBB
615 SPILL(rIBASE) # preserve rIBASE (cltd trashes it)
616 cltd # rIBASE:eax<- ssssssssssssBBBB
617 SET_VREG_WORD rIBASE rINST 1 # store msw
618 FETCH_INST_OPCODE 2 %ecx
619 UNSPILL(rIBASE) # restore rIBASE
620 SET_VREG_WORD %eax rINST 0 # store lsw
624 /* ------------------------------ */
625 .L_OP_CONST_WIDE_32: /* 0x17 */
626 /* File: x86/OP_CONST_WIDE_32.S */
627 /* const-wide/32 vAA, #+BBBBbbbb */
628 movl 2(rPC),%eax # eax<- BBBBbbbb
629 SPILL(rIBASE) # save rIBASE (cltd trashes it)
630 cltd # rIBASE:eax<- ssssssssssssBBBB
631 SET_VREG_WORD rIBASE rINST,1 # store msw
632 FETCH_INST_OPCODE 3 %ecx
633 UNSPILL(rIBASE) # restore rIBASE
634 SET_VREG_WORD %eax rINST 0 # store lsw
638 /* ------------------------------ */
639 .L_OP_CONST_WIDE: /* 0x18 */
640 /* File: x86/OP_CONST_WIDE.S */
641 /* const-wide vAA, #+HHHHhhhhBBBBbbbb */
642 movl 2(rPC),%eax # eax<- lsw
643 movzbl rINSTbl,%ecx # ecx<- AA
644 movl 6(rPC),rINST # rINST<- msw
645 leal (rFP,%ecx,4),%ecx # dst addr
648 FETCH_INST_OPCODE 5 %ecx
652 /* ------------------------------ */
653 .L_OP_CONST_WIDE_HIGH16: /* 0x19 */
654 /* File: x86/OP_CONST_WIDE_HIGH16.S */
655 /* const-wide/high16 vAA, #+BBBB000000000000 */
656 movzwl 2(rPC),%eax # eax<- 0000BBBB
657 FETCH_INST_OPCODE 2 %ecx
659 sall $16,%eax # eax<- BBBB0000
660 SET_VREG_WORD %eax rINST 1 # v[AA+1]<- eax
662 SET_VREG_WORD %eax rINST 0 # v[AA+0]<- eax
665 /* ------------------------------ */
666 .L_OP_CONST_STRING: /* 0x1a */
667 /* File: x86/OP_CONST_STRING.S */
669 /* const/string vAA, String@BBBB */
671 movzwl 2(rPC),%eax # eax<- BBBB
672 movl offThread_methodClassDex(%ecx),%ecx# ecx<- self->methodClassDex
673 movl offDvmDex_pResStrings(%ecx),%ecx # ecx<- dvmDex->pResStrings
674 movl (%ecx,%eax,4),%eax # eax<- rResString[BBBB]
675 FETCH_INST_OPCODE 2 %ecx
676 testl %eax,%eax # resolved yet?
677 je .LOP_CONST_STRING_resolve
678 SET_VREG %eax rINST # vAA<- rResString[BBBB]
682 /* This is the less common path, so we'll redo some work
683 here rather than force spills on the common path */
684 .LOP_CONST_STRING_resolve:
687 movl offThread_method(%eax),%eax # eax<- self->method
688 movzwl 2(rPC),%ecx # ecx<- BBBB
689 movl offMethod_clazz(%eax),%eax
690 movl %ecx,OUT_ARG1(%esp)
691 movl %eax,OUT_ARG0(%esp)
693 call dvmResolveString # go resolve
695 testl %eax,%eax # failed?
696 je common_exceptionThrown
697 FETCH_INST_OPCODE 2 %ecx
702 /* ------------------------------ */
703 .L_OP_CONST_STRING_JUMBO: /* 0x1b */
704 /* File: x86/OP_CONST_STRING_JUMBO.S */
706 /* const/string vAA, String@BBBBBBBB */
708 movl 2(rPC),%eax # eax<- BBBBBBBB
709 movl offThread_methodClassDex(%ecx),%ecx# ecx<- self->methodClassDex
710 movl offDvmDex_pResStrings(%ecx),%ecx # ecx<- dvmDex->pResStrings
711 movl (%ecx,%eax,4),%eax # eax<- rResString[BBBB]
712 FETCH_INST_OPCODE 3 %ecx
713 testl %eax,%eax # resolved yet?
714 je .LOP_CONST_STRING_JUMBO_resolve
715 SET_VREG %eax rINST # vAA<- rResString[BBBB]
719 /* This is the less common path, so we'll redo some work
720 here rather than force spills on the common path */
721 .LOP_CONST_STRING_JUMBO_resolve:
724 movl offThread_method(%eax),%eax # eax<- self->method
725 movl 2(rPC),%ecx # ecx<- BBBBBBBB
726 movl offMethod_clazz(%eax),%eax
727 movl %ecx,OUT_ARG1(%esp)
728 movl %eax,OUT_ARG0(%esp)
730 call dvmResolveString # go resolve
732 testl %eax,%eax # failed?
733 je common_exceptionThrown
734 FETCH_INST_OPCODE 3 %ecx
739 /* ------------------------------ */
740 .L_OP_CONST_CLASS: /* 0x1c */
741 /* File: x86/OP_CONST_CLASS.S */
743 /* const/class vAA, Class@BBBB */
745 movzwl 2(rPC),%eax # eax<- BBBB
746 movl offThread_methodClassDex(%ecx),%ecx# ecx<- self->methodClassDex
747 movl offDvmDex_pResClasses(%ecx),%ecx # ecx<- dvmDex->pResClasses
748 movl (%ecx,%eax,4),%eax # eax<- rResClasses[BBBB]
749 testl %eax,%eax # resolved yet?
750 je .LOP_CONST_CLASS_resolve
751 FETCH_INST_OPCODE 2 %ecx
752 SET_VREG %eax rINST # vAA<- rResClasses[BBBB]
756 /* This is the less common path, so we'll redo some work
757 here rather than force spills on the common path */
758 .LOP_CONST_CLASS_resolve:
761 movl offThread_method(%eax),%eax # eax<- self->method
762 movl $1,OUT_ARG2(%esp) # true
763 movzwl 2(rPC),%ecx # ecx<- BBBB
764 movl offMethod_clazz(%eax),%eax
765 movl %ecx,OUT_ARG1(%esp)
766 movl %eax,OUT_ARG0(%esp)
768 call dvmResolveClass # go resolve
770 testl %eax,%eax # failed?
771 je common_exceptionThrown
772 FETCH_INST_OPCODE 2 %ecx
777 /* ------------------------------ */
778 .L_OP_MONITOR_ENTER: /* 0x1d */
779 /* File: x86/OP_MONITOR_ENTER.S */
781 * Synchronize on an object.
783 /* monitor-enter vAA */
785 GET_VREG_R %eax rINST # eax<- vAA
787 testl %eax,%eax # null object?
788 EXPORT_PC # need for precise GC
789 je common_errNullObject
790 movl %ecx,OUT_ARG0(%esp)
791 movl %eax,OUT_ARG1(%esp)
793 call dvmLockObject # dvmLockObject(self,object)
795 FETCH_INST_OPCODE 1 %ecx
799 /* ------------------------------ */
800 .L_OP_MONITOR_EXIT: /* 0x1e */
801 /* File: x86/OP_MONITOR_EXIT.S */
805 * Exceptions that occur when unlocking a monitor need to appear as
806 * if they happened at the following instruction. See the Dalvik
809 /* monitor-exit vAA */
810 GET_VREG_R %eax rINST
813 testl %eax,%eax # null object?
814 je .LOP_MONITOR_EXIT_errNullObject # go if so
815 movl %eax,OUT_ARG1(%esp)
816 movl %ecx,OUT_ARG0(%esp)
818 call dvmUnlockObject # unlock(self,obj)
820 FETCH_INST_OPCODE 1 %ecx
821 testl %eax,%eax # success?
823 je common_exceptionThrown # no, exception pending
825 .LOP_MONITOR_EXIT_errNullObject:
826 ADVANCE_PC 1 # advance before throw
827 jmp common_errNullObject
829 /* ------------------------------ */
830 .L_OP_CHECK_CAST: /* 0x1f */
831 /* File: x86/OP_CHECK_CAST.S */
833 * Check to see if a cast from one class to another is allowed.
835 /* check-cast vAA, class@BBBB */
837 GET_VREG_R rINST,rINST # rINST<- vAA (object)
838 movzwl 2(rPC),%eax # eax<- BBBB
839 movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex
840 testl rINST,rINST # is oject null?
841 movl offDvmDex_pResClasses(%ecx),%ecx # ecx<- pDvmDex->pResClasses
842 je .LOP_CHECK_CAST_okay # null obj, cast always succeeds
843 movl (%ecx,%eax,4),%eax # eax<- resolved class
844 movl offObject_clazz(rINST),%ecx # ecx<- obj->clazz
845 testl %eax,%eax # have we resolved this before?
846 je .LOP_CHECK_CAST_resolve # no, go do it now
847 .LOP_CHECK_CAST_resolved:
848 cmpl %eax,%ecx # same class (trivial success)?
849 jne .LOP_CHECK_CAST_fullcheck # no, do full check
850 .LOP_CHECK_CAST_okay:
851 FETCH_INST_OPCODE 2 %ecx
856 * Trivial test failed, need to perform full check. This is common.
857 * ecx holds obj->clazz
858 * eax holds class resolved from BBBB
861 .LOP_CHECK_CAST_fullcheck:
862 movl %eax,sReg0 # we'll need the desired class on failure
863 movl %eax,OUT_ARG1(%esp)
864 movl %ecx,OUT_ARG0(%esp)
866 call dvmInstanceofNonTrivial # eax<- boolean result
868 testl %eax,%eax # failed?
869 jne .LOP_CHECK_CAST_okay # no, success
871 # A cast has failed. We need to throw a ClassCastException.
873 movl offObject_clazz(rINST),%eax
874 movl %eax,OUT_ARG0(%esp) # arg0<- obj->clazz
876 movl %ecx,OUT_ARG1(%esp) # arg1<- desired class
877 call dvmThrowClassCastException
878 jmp common_exceptionThrown
881 * Resolution required. This is the least-likely path, and we're
882 * going to have to recreate some data.
886 .LOP_CHECK_CAST_resolve:
889 movzwl 2(rPC),%eax # eax<- BBBB
890 movl offThread_method(%ecx),%ecx # ecx<- self->method
891 movl %eax,OUT_ARG1(%esp) # arg1<- BBBB
892 movl offMethod_clazz(%ecx),%ecx # ecx<- metho->clazz
893 movl $0,OUT_ARG2(%esp) # arg2<- false
894 movl %ecx,OUT_ARG0(%esp) # arg0<- method->clazz
896 call dvmResolveClass # eax<- resolved ClassObject ptr
898 testl %eax,%eax # got null?
899 je common_exceptionThrown # yes, handle exception
900 movl offObject_clazz(rINST),%ecx # ecx<- obj->clazz
901 jmp .LOP_CHECK_CAST_resolved # pick up where we left off
903 /* ------------------------------ */
904 .L_OP_INSTANCE_OF: /* 0x20 */
905 /* File: x86/OP_INSTANCE_OF.S */
907 * Check to see if an object reference is an instance of a class.
909 * Most common situation is a non-null object, being compared against
910 * an already-resolved class.
912 /* instance-of vA, vB, class@CCCC */
913 movl rINST,%eax # eax<- BA
914 sarl $4,%eax # eax<- B
915 GET_VREG_R %eax %eax # eax<- vB (obj)
917 testl %eax,%eax # object null?
918 movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex
919 SPILL(rIBASE) # preserve rIBASE
920 je .LOP_INSTANCE_OF_store # null obj, not instance, store it
921 movzwl 2(rPC),rIBASE # rIBASE<- CCCC
922 movl offDvmDex_pResClasses(%ecx),%ecx # ecx<- pDvmDex->pResClasses
923 movl (%ecx,rIBASE,4),%ecx # ecx<- resolved class
924 movl offObject_clazz(%eax),%eax # eax<- obj->clazz
925 testl %ecx,%ecx # have we resolved this before?
926 je .LOP_INSTANCE_OF_resolve # not resolved, do it now
927 .LOP_INSTANCE_OF_resolved: # eax<- obj->clazz, ecx<- resolved class
928 cmpl %eax,%ecx # same class (trivial success)?
929 je .LOP_INSTANCE_OF_trivial # yes, trivial finish
931 * Trivial test failed, need to perform full check. This is common.
932 * eax holds obj->clazz
933 * ecx holds class resolved from BBBB
936 movl %eax,OUT_ARG0(%esp)
937 movl %ecx,OUT_ARG1(%esp)
938 call dvmInstanceofNonTrivial # eax<- boolean result
939 # fall through to OP_INSTANCE_OF_store
942 * eax holds boolean result
945 .LOP_INSTANCE_OF_store:
946 FETCH_INST_OPCODE 2 %ecx
948 andb $0xf,rINSTbl # <- A
950 SET_VREG %eax rINST # vA<- eax
954 * Trivial test succeeded, save and bail.
957 .LOP_INSTANCE_OF_trivial:
958 FETCH_INST_OPCODE 2 %ecx
960 andb $0xf,rINSTbl # <- A
963 SET_VREG %eax rINST # vA<- true
967 * Resolution required. This is the least-likely path.
972 .LOP_INSTANCE_OF_resolve:
973 movl rIBASE,OUT_ARG1(%esp) # arg1<- BBBB
975 movl offThread_method(%ecx),%ecx
976 movl $1,OUT_ARG2(%esp) # arg2<- true
977 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz
979 movl %ecx,OUT_ARG0(%esp) # arg0<- method->clazz
980 call dvmResolveClass # eax<- resolved ClassObject ptr
981 testl %eax,%eax # success?
982 je common_exceptionThrown # no, handle exception
983 /* Now, we need to sync up with fast path. We need eax to
984 * hold the obj->clazz, and ecx to hold the resolved class
986 movl %eax,%ecx # ecx<- resolved class
987 movl rINST,%eax # eax<- BA
988 sarl $4,%eax # eax<- B
989 GET_VREG_R %eax %eax # eax<- vB (obj)
990 movl offObject_clazz(%eax),%eax # eax<- obj->clazz
991 jmp .LOP_INSTANCE_OF_resolved
993 /* ------------------------------ */
994 .L_OP_ARRAY_LENGTH: /* 0x21 */
995 /* File: x86/OP_ARRAY_LENGTH.S */
997 * Return the length of an array.
999 mov rINST,%eax # eax<- BA
1000 sarl $4,rINST # rINST<- B
1001 GET_VREG_R %ecx rINST # ecx<- vB (object ref)
1002 andb $0xf,%al # eax<- A
1003 testl %ecx,%ecx # is null?
1004 je common_errNullObject
1005 movl offArrayObject_length(%ecx),rINST
1006 FETCH_INST_OPCODE 1 %ecx
1011 /* ------------------------------ */
1012 .L_OP_NEW_INSTANCE: /* 0x22 */
1013 /* File: x86/OP_NEW_INSTANCE.S */
1015 * Create a new instance of a class.
1017 /* new-instance vAA, class@BBBB */
1019 movzwl 2(rPC),%eax # eax<- BBBB
1020 movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex
1022 movl offDvmDex_pResClasses(%ecx),%ecx # ecx<- pDvmDex->pResClasses
1024 movl (%ecx,%eax,4),%ecx # ecx<- resolved class
1025 testl %ecx,%ecx # resolved?
1026 je .LOP_NEW_INSTANCE_resolve # no, go do it
1027 .LOP_NEW_INSTANCE_resolved: # on entry, ecx<- class
1028 cmpb $CLASS_INITIALIZED,offClassObject_status(%ecx)
1029 jne .LOP_NEW_INSTANCE_needinit
1030 .LOP_NEW_INSTANCE_initialized: # on entry, ecx<- class
1031 movl $ALLOC_DONT_TRACK,OUT_ARG1(%esp)
1032 movl %ecx,OUT_ARG0(%esp)
1033 call dvmAllocObject # eax<- new object
1034 FETCH_INST_OPCODE 2 %ecx
1036 testl %eax,%eax # success?
1037 je common_exceptionThrown # no, bail out
1043 * Class initialization required.
1045 * ecx holds class object
1047 .LOP_NEW_INSTANCE_needinit:
1048 SPILL_TMP1(%ecx) # save object
1049 movl %ecx,OUT_ARG0(%esp)
1050 call dvmInitClass # initialize class
1051 UNSPILL_TMP1(%ecx) # restore object
1052 testl %eax,%eax # success?
1053 jne .LOP_NEW_INSTANCE_initialized # success, continue
1054 jmp common_exceptionThrown # go deal with init exception
1057 * Resolution required. This is the least-likely path.
1060 .LOP_NEW_INSTANCE_resolve:
1063 movl offThread_method(%ecx),%ecx # ecx<- self->method
1064 movl %eax,OUT_ARG1(%esp)
1065 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz
1066 movl $0,OUT_ARG2(%esp)
1067 movl %ecx,OUT_ARG0(%esp)
1068 call dvmResolveClass # call(clazz,off,flags)
1069 movl %eax,%ecx # ecx<- resolved ClassObject ptr
1070 testl %ecx,%ecx # success?
1071 jne .LOP_NEW_INSTANCE_resolved # good to go
1072 jmp common_exceptionThrown # no, handle exception
1074 /* ------------------------------ */
1075 .L_OP_NEW_ARRAY: /* 0x23 */
1076 /* File: x86/OP_NEW_ARRAY.S */
1078 * Allocate an array of objects, specified with the array class
1081 * The verifier guarantees that this is an array class, so we don't
1082 * check for it here.
1084 /* new-array vA, vB, class@CCCC */
1087 movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex
1088 movzwl 2(rPC),%eax # eax<- CCCC
1089 movl offDvmDex_pResClasses(%ecx),%ecx # ecx<- pDvmDex->pResClasses
1091 movl (%ecx,%eax,4),%ecx # ecx<- resolved class
1093 sarl $4,%eax # eax<- B
1094 GET_VREG_R %eax %eax # eax<- vB (array length)
1095 andb $0xf,rINSTbl # rINST<- A
1097 js common_errNegativeArraySize # bail, passing len in eax
1098 testl %ecx,%ecx # already resolved?
1099 jne .LOP_NEW_ARRAY_finish # yes, fast path
1101 * Resolve class. (This is an uncommon case.)
1102 * ecx holds class (null here)
1103 * eax holds array length (vB)
1106 SPILL_TMP1(%eax) # save array length
1107 movl offThread_method(%ecx),%ecx # ecx<- self->method
1108 movzwl 2(rPC),%eax # eax<- CCCC
1109 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz
1110 movl %eax,OUT_ARG1(%esp)
1111 movl $0,OUT_ARG2(%esp)
1112 movl %ecx,OUT_ARG0(%esp)
1113 call dvmResolveClass # eax<- call(clazz,ref,flag)
1116 testl %ecx,%ecx # successful resolution?
1117 je common_exceptionThrown # no, bail.
1118 # fall through to OP_NEW_ARRAY_finish
1124 * eax holds array length (vB)
1126 .LOP_NEW_ARRAY_finish:
1127 movl %ecx,OUT_ARG0(%esp)
1128 movl %eax,OUT_ARG1(%esp)
1129 movl $ALLOC_DONT_TRACK,OUT_ARG2(%esp)
1130 call dvmAllocArrayByClass # eax<- call(clazz,length,flags)
1131 FETCH_INST_OPCODE 2 %ecx
1133 testl %eax,%eax # failed?
1134 je common_exceptionThrown # yup - go handle
1139 /* ------------------------------ */
1140 .L_OP_FILLED_NEW_ARRAY: /* 0x24 */
1141 /* File: x86/OP_FILLED_NEW_ARRAY.S */
1143 * Create a new array with elements filled from registers.
1145 * for: filled-new-array, filled-new-array/range
1147 /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */
1148 /* op {vCCCC..v(CCCC+AA-1)}, type@BBBB */
1150 movl offThread_methodClassDex(%eax),%eax # eax<- pDvmDex
1151 movzwl 2(rPC),%ecx # ecx<- BBBB
1152 movl offDvmDex_pResClasses(%eax),%eax # eax<- pDvmDex->pResClasses
1153 SPILL(rIBASE) # preserve rIBASE
1154 movl (%eax,%ecx,4),%eax # eax<- resolved class
1156 testl %eax,%eax # already resolved?
1157 jne .LOP_FILLED_NEW_ARRAY_continue # yes, continue
1158 # less frequent path, so we'll redo some work
1160 movl $0,OUT_ARG2(%esp) # arg2<- false
1161 movl %ecx,OUT_ARG1(%esp) # arg1<- BBBB
1162 movl offThread_method(%eax),%eax # eax<- self->method
1163 movl offMethod_clazz(%eax),%eax # eax<- method->clazz
1164 movl %eax,OUT_ARG0(%esp) # arg0<- clazz
1165 call dvmResolveClass # eax<- call(clazz,ref,flag)
1166 testl %eax,%eax # null?
1167 je common_exceptionThrown # yes, handle it
1169 # note: fall through to .LOP_FILLED_NEW_ARRAY_continue
1173 * eax holds array class [r0]
1174 * rINST holds AA or BB [r10]
1177 .LOP_FILLED_NEW_ARRAY_continue:
1178 movl offClassObject_descriptor(%eax),%ecx # ecx<- arrayClass->descriptor
1179 movl $ALLOC_DONT_TRACK,OUT_ARG2(%esp) # arg2<- flags
1180 movzbl 1(%ecx),%ecx # ecx<- descriptor[1]
1181 movl %eax,OUT_ARG0(%esp) # arg0<- arrayClass
1183 cmpb $'I',%cl # supported?
1188 jne .LOP_FILLED_NEW_ARRAY_notimpl # no, not handled yet
1190 movl %ecx,offThread_retval+4(%eax) # save type
1192 SPILL_TMP1(rINST) # save copy, need "B" later
1195 movl rINST,OUT_ARG1(%esp) # arg1<- A or AA (length)
1196 call dvmAllocArrayByClass # eax<- call(arrayClass, length, flags)
1198 testl %eax,%eax # alloc successful?
1199 je common_exceptionThrown # no, handle exception
1200 movl %eax,offThread_retval(%ecx) # retval.l<- new array
1201 movzwl 4(rPC),%ecx # ecx<- FEDC or CCCC
1202 leal offArrayObject_contents(%eax),%eax # eax<- newArray->contents
1205 * eax is pointer to tgt
1207 * ecx is FEDC or CCCC
1209 * We now need to copy values from registers into the array
1213 # set up src pointer
1216 leal (rFP,%ecx,4),%esi # set up src ptr
1217 movl %eax,%edi # set up dst ptr
1218 movl rINST,%ecx # load count register
1224 movl offThread_retval+4(%ecx),%eax # eax<- type
1228 UNSPILL_TMP1(rIBASE) # restore "BA"
1229 andl $0x0f,rIBASE # rIBASE<- 0000000A
1230 sall $16,rIBASE # rIBASE<- 000A0000
1231 orl %ecx,rIBASE # rIBASE<- 000AFEDC
1234 andl rIBASE,%ecx # ecx<- next reg to load
1235 GET_VREG_R %ecx %ecx
1243 movl offThread_retval+4(%ecx),%eax # eax<- type
1246 cmpb $'I',%al # Int array?
1247 je 5f # skip card mark if so
1248 movl offThread_retval(%ecx),%eax # eax<- object head
1249 movl offThread_cardTable(%ecx),%ecx # card table base
1250 shrl $GC_CARD_SHIFT,%eax # convert to card num
1251 movb %cl,(%ecx,%eax) # mark card based on object head
1253 UNSPILL(rIBASE) # restore rIBASE
1254 FETCH_INST_OPCODE 3 %ecx
1260 * Throw an exception indicating that we have not implemented this
1261 * mode of filled-new-array.
1263 .LOP_FILLED_NEW_ARRAY_notimpl:
1264 movl $.LstrFilledNewArrayNotImplA,%eax
1265 movl %eax,OUT_ARG0(%esp)
1266 call dvmThrowInternalError
1267 jmp common_exceptionThrown
1269 /* ------------------------------ */
1270 .L_OP_FILLED_NEW_ARRAY_RANGE: /* 0x25 */
1271 /* File: x86/OP_FILLED_NEW_ARRAY_RANGE.S */
1272 /* File: x86/OP_FILLED_NEW_ARRAY.S */
1274 * Create a new array with elements filled from registers.
1276 * for: filled-new-array, filled-new-array/range
1278 /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */
1279 /* op {vCCCC..v(CCCC+AA-1)}, type@BBBB */
1281 movl offThread_methodClassDex(%eax),%eax # eax<- pDvmDex
1282 movzwl 2(rPC),%ecx # ecx<- BBBB
1283 movl offDvmDex_pResClasses(%eax),%eax # eax<- pDvmDex->pResClasses
1284 SPILL(rIBASE) # preserve rIBASE
1285 movl (%eax,%ecx,4),%eax # eax<- resolved class
1287 testl %eax,%eax # already resolved?
1288 jne .LOP_FILLED_NEW_ARRAY_RANGE_continue # yes, continue
1289 # less frequent path, so we'll redo some work
1291 movl $0,OUT_ARG2(%esp) # arg2<- false
1292 movl %ecx,OUT_ARG1(%esp) # arg1<- BBBB
1293 movl offThread_method(%eax),%eax # eax<- self->method
1294 movl offMethod_clazz(%eax),%eax # eax<- method->clazz
1295 movl %eax,OUT_ARG0(%esp) # arg0<- clazz
1296 call dvmResolveClass # eax<- call(clazz,ref,flag)
1297 testl %eax,%eax # null?
1298 je common_exceptionThrown # yes, handle it
1300 # note: fall through to .LOP_FILLED_NEW_ARRAY_RANGE_continue
1304 * eax holds array class [r0]
1305 * rINST holds AA or BB [r10]
1308 .LOP_FILLED_NEW_ARRAY_RANGE_continue:
1309 movl offClassObject_descriptor(%eax),%ecx # ecx<- arrayClass->descriptor
1310 movl $ALLOC_DONT_TRACK,OUT_ARG2(%esp) # arg2<- flags
1311 movzbl 1(%ecx),%ecx # ecx<- descriptor[1]
1312 movl %eax,OUT_ARG0(%esp) # arg0<- arrayClass
1314 cmpb $'I',%cl # supported?
1319 jne .LOP_FILLED_NEW_ARRAY_RANGE_notimpl # no, not handled yet
1321 movl %ecx,offThread_retval+4(%eax) # save type
1323 SPILL_TMP1(rINST) # save copy, need "B" later
1326 movl rINST,OUT_ARG1(%esp) # arg1<- A or AA (length)
1327 call dvmAllocArrayByClass # eax<- call(arrayClass, length, flags)
1329 testl %eax,%eax # alloc successful?
1330 je common_exceptionThrown # no, handle exception
1331 movl %eax,offThread_retval(%ecx) # retval.l<- new array
1332 movzwl 4(rPC),%ecx # ecx<- FEDC or CCCC
1333 leal offArrayObject_contents(%eax),%eax # eax<- newArray->contents
1336 * eax is pointer to tgt
1338 * ecx is FEDC or CCCC
1340 * We now need to copy values from registers into the array
1344 # set up src pointer
1347 leal (rFP,%ecx,4),%esi # set up src ptr
1348 movl %eax,%edi # set up dst ptr
1349 movl rINST,%ecx # load count register
1355 movl offThread_retval+4(%ecx),%eax # eax<- type
1359 UNSPILL_TMP1(rIBASE) # restore "BA"
1360 andl $0x0f,rIBASE # rIBASE<- 0000000A
1361 sall $16,rIBASE # rIBASE<- 000A0000
1362 orl %ecx,rIBASE # rIBASE<- 000AFEDC
1365 andl rIBASE,%ecx # ecx<- next reg to load
1366 GET_VREG_R %ecx %ecx
1374 movl offThread_retval+4(%ecx),%eax # eax<- type
1377 cmpb $'I',%al # Int array?
1378 je 5f # skip card mark if so
1379 movl offThread_retval(%ecx),%eax # eax<- object head
1380 movl offThread_cardTable(%ecx),%ecx # card table base
1381 shrl $GC_CARD_SHIFT,%eax # convert to card num
1382 movb %cl,(%ecx,%eax) # mark card based on object head
1384 UNSPILL(rIBASE) # restore rIBASE
1385 FETCH_INST_OPCODE 3 %ecx
1391 * Throw an exception indicating that we have not implemented this
1392 * mode of filled-new-array.
1394 .LOP_FILLED_NEW_ARRAY_RANGE_notimpl:
1395 movl $.LstrFilledNewArrayNotImplA,%eax
1396 movl %eax,OUT_ARG0(%esp)
1397 call dvmThrowInternalError
1398 jmp common_exceptionThrown
1401 /* ------------------------------ */
1402 .L_OP_FILL_ARRAY_DATA: /* 0x26 */
1403 /* File: x86/OP_FILL_ARRAY_DATA.S */
1404 /* fill-array-data vAA, +BBBBBBBB */
1405 movl 2(rPC),%ecx # ecx<- BBBBbbbb
1406 leal (rPC,%ecx,2),%ecx # ecx<- PC + BBBBbbbb*2
1407 GET_VREG_R %eax rINST
1409 movl %eax,OUT_ARG0(%esp)
1410 movl %ecx,OUT_ARG1(%esp)
1412 call dvmInterpHandleFillArrayData
1414 FETCH_INST_OPCODE 3 %ecx
1415 testl %eax,%eax # exception thrown?
1416 je common_exceptionThrown
1420 /* ------------------------------ */
1421 .L_OP_THROW: /* 0x27 */
1422 /* File: x86/OP_THROW.S */
1424 * Throw an exception object in the current thread.
1428 GET_VREG_R %eax rINST # eax<- exception object
1429 movl rSELF,%ecx # ecx<- self
1430 testl %eax,%eax # null object?
1431 je common_errNullObject
1432 movl %eax,offThread_exception(%ecx) # thread->exception<- obj
1433 jmp common_exceptionThrown
1435 /* ------------------------------ */
1436 .L_OP_GOTO: /* 0x28 */
1437 /* File: x86/OP_GOTO.S */
1439 * Unconditional branch, 8-bit offset.
1441 * The branch distance is a signed code-unit offset, which we need to
1442 * double to get a byte offset.
1445 movsbl rINSTbl,rINST # ebx<- ssssssAA
1446 testl rINST,rINST # test for <0
1447 js common_backwardBranch
1449 FETCH_INST_INDEXED %eax
1450 ADVANCE_PC_INDEXED %eax
1453 /* ------------------------------ */
1454 .L_OP_GOTO_16: /* 0x29 */
1455 /* File: x86/OP_GOTO_16.S */
1457 * Unconditional branch, 16-bit offset.
1459 * The branch distance is a signed code-unit offset
1462 movswl 2(rPC),rINST # rINST<- ssssAAAA
1463 testl rINST,rINST # test for <0
1464 js common_backwardBranch
1466 FETCH_INST_INDEXED %eax
1467 ADVANCE_PC_INDEXED %eax
1470 /* ------------------------------ */
1471 .L_OP_GOTO_32: /* 0x2a */
1472 /* File: x86/OP_GOTO_32.S */
1474 * Unconditional branch, 32-bit offset.
1476 * The branch distance is a signed code-unit offset.
1478 * Unlike most opcodes, this one is allowed to branch to itself, so
1479 * our "backward branch" test must be "<=0" instead of "<0".
1481 /* goto/32 AAAAAAAA */
1482 movl 2(rPC),rINST # rINST<- AAAAAAAA
1483 cmpl $0,rINST # test for <= 0
1484 jle common_backwardBranch
1486 FETCH_INST_INDEXED %eax
1487 ADVANCE_PC_INDEXED %eax
1490 /* ------------------------------ */
1491 .L_OP_PACKED_SWITCH: /* 0x2b */
1492 /* File: x86/OP_PACKED_SWITCH.S */
1494 * Handle a packed-switch or sparse-switch instruction. In both cases
1495 * we decode it and hand it off to a helper function.
1497 * We don't really expect backward branches in a switch statement, but
1498 * they're perfectly legal, so we check for them here.
1500 * for: packed-switch, sparse-switch
1503 movl 2(rPC),%ecx # ecx<- BBBBbbbb
1504 GET_VREG_R %eax rINST # eax<- vAA
1505 leal (rPC,%ecx,2),%ecx # ecx<- PC + BBBBbbbb*2
1506 movl %eax,OUT_ARG1(%esp) # ARG1<- vAA
1507 movl %ecx,OUT_ARG0(%esp) # ARG0<- switchData
1509 call dvmInterpHandlePackedSwitch
1512 movl %eax,rINST # set up word offset
1513 jle common_backwardBranch # check on special actions
1514 ADVANCE_PC_INDEXED rINST
1518 /* ------------------------------ */
1519 .L_OP_SPARSE_SWITCH: /* 0x2c */
1520 /* File: x86/OP_SPARSE_SWITCH.S */
1521 /* File: x86/OP_PACKED_SWITCH.S */
1523 * Handle a packed-switch or sparse-switch instruction. In both cases
1524 * we decode it and hand it off to a helper function.
1526 * We don't really expect backward branches in a switch statement, but
1527 * they're perfectly legal, so we check for them here.
1529 * for: packed-switch, sparse-switch
1532 movl 2(rPC),%ecx # ecx<- BBBBbbbb
1533 GET_VREG_R %eax rINST # eax<- vAA
1534 leal (rPC,%ecx,2),%ecx # ecx<- PC + BBBBbbbb*2
1535 movl %eax,OUT_ARG1(%esp) # ARG1<- vAA
1536 movl %ecx,OUT_ARG0(%esp) # ARG0<- switchData
1538 call dvmInterpHandleSparseSwitch
1541 movl %eax,rINST # set up word offset
1542 jle common_backwardBranch # check on special actions
1543 ADVANCE_PC_INDEXED rINST
1548 /* ------------------------------ */
1549 .L_OP_CMPL_FLOAT: /* 0x2d */
1550 /* File: x86/OP_CMPL_FLOAT.S */
1551 /* File: x86/OP_CMPG_DOUBLE.S */
1552 /* float/double_cmp[gl] vAA, vBB, vCC */
1553 movzbl 3(rPC),%eax # eax<- CC
1554 movzbl 2(rPC),%ecx # ecx<- BB
1563 fucompp # z if equal, p set if NaN, c set if st0 < st1
1566 FETCH_INST_OPCODE 2 %eax
1567 jp .LOP_CMPL_FLOAT_isNaN
1568 je .LOP_CMPL_FLOAT_finish
1570 jb .LOP_CMPL_FLOAT_finish
1572 .LOP_CMPL_FLOAT_finish:
1577 .LOP_CMPL_FLOAT_isNaN:
1579 jmp .LOP_CMPL_FLOAT_finish
1582 /* ------------------------------ */
1583 .L_OP_CMPG_FLOAT: /* 0x2e */
1584 /* File: x86/OP_CMPG_FLOAT.S */
1585 /* File: x86/OP_CMPG_DOUBLE.S */
1586 /* float/double_cmp[gl] vAA, vBB, vCC */
1587 movzbl 3(rPC),%eax # eax<- CC
1588 movzbl 2(rPC),%ecx # ecx<- BB
1597 fucompp # z if equal, p set if NaN, c set if st0 < st1
1600 FETCH_INST_OPCODE 2 %eax
1601 jp .LOP_CMPG_FLOAT_isNaN
1602 je .LOP_CMPG_FLOAT_finish
1604 jb .LOP_CMPG_FLOAT_finish
1606 .LOP_CMPG_FLOAT_finish:
1611 .LOP_CMPG_FLOAT_isNaN:
1613 jmp .LOP_CMPG_FLOAT_finish
1616 /* ------------------------------ */
1617 .L_OP_CMPL_DOUBLE: /* 0x2f */
1618 /* File: x86/OP_CMPL_DOUBLE.S */
1619 /* File: x86/OP_CMPG_DOUBLE.S */
1620 /* float/double_cmp[gl] vAA, vBB, vCC */
1621 movzbl 3(rPC),%eax # eax<- CC
1622 movzbl 2(rPC),%ecx # ecx<- BB
1631 fucompp # z if equal, p set if NaN, c set if st0 < st1
1634 FETCH_INST_OPCODE 2 %eax
1635 jp .LOP_CMPL_DOUBLE_isNaN
1636 je .LOP_CMPL_DOUBLE_finish
1638 jb .LOP_CMPL_DOUBLE_finish
1640 .LOP_CMPL_DOUBLE_finish:
1645 .LOP_CMPL_DOUBLE_isNaN:
1647 jmp .LOP_CMPL_DOUBLE_finish
1650 /* ------------------------------ */
1651 .L_OP_CMPG_DOUBLE: /* 0x30 */
1652 /* File: x86/OP_CMPG_DOUBLE.S */
1653 /* float/double_cmp[gl] vAA, vBB, vCC */
1654 movzbl 3(rPC),%eax # eax<- CC
1655 movzbl 2(rPC),%ecx # ecx<- BB
1664 fucompp # z if equal, p set if NaN, c set if st0 < st1
1667 FETCH_INST_OPCODE 2 %eax
1668 jp .LOP_CMPG_DOUBLE_isNaN
1669 je .LOP_CMPG_DOUBLE_finish
1671 jb .LOP_CMPG_DOUBLE_finish
1673 .LOP_CMPG_DOUBLE_finish:
1678 .LOP_CMPG_DOUBLE_isNaN:
1680 jmp .LOP_CMPG_DOUBLE_finish
1682 /* ------------------------------ */
1683 .L_OP_CMP_LONG: /* 0x31 */
1684 /* File: x86/OP_CMP_LONG.S */
1686 * Compare two 64-bit values. Puts 0, 1, or -1 into the destination
1687 * register based on the results of the comparison.
1689 // TUNING: rework to avoid rIBASE spill
1690 /* cmp-long vAA, vBB, vCC */
1691 movzbl 2(rPC),%ecx # ecx<- BB
1693 movzbl 3(rPC),rIBASE # rIBASE- CC
1694 GET_VREG_WORD %eax %ecx,1 # eax<- v[BB+1]
1695 GET_VREG_WORD %ecx %ecx 0 # ecx<- v[BB+0]
1696 cmpl 4(rFP,rIBASE,4),%eax
1697 jl .LOP_CMP_LONG_smaller
1698 jg .LOP_CMP_LONG_bigger
1699 sub (rFP,rIBASE,4),%ecx
1700 ja .LOP_CMP_LONG_bigger
1701 jb .LOP_CMP_LONG_smaller
1703 FETCH_INST_OPCODE 2 %ecx
1708 .LOP_CMP_LONG_bigger:
1711 FETCH_INST_OPCODE 2 %ecx
1716 .LOP_CMP_LONG_smaller:
1719 FETCH_INST_OPCODE 2 %ecx
1724 /* ------------------------------ */
1725 .L_OP_IF_EQ: /* 0x32 */
1726 /* File: x86/OP_IF_EQ.S */
1727 /* File: x86/bincmp.S */
1729 * Generic two-operand compare-and-branch operation. Provide a "revcmp"
1730 * fragment that specifies the *reverse* comparison to perform, e.g.
1731 * for "if-le" you would use "gt".
1733 * For: if-eq, if-ne, if-lt, if-ge, if-gt, if-le
1735 /* if-cmp vA, vB, +CCCC */
1736 movzx rINSTbl,%ecx # ecx <- A+
1737 andb $0xf,%cl # ecx <- A
1738 GET_VREG_R %eax %ecx # eax <- vA
1739 sarl $4,rINST # rINST<- B
1740 cmpl (rFP,rINST,4),%eax # compare (vA, vB)
1741 movswl 2(rPC),rINST # Get signed branch offset
1742 movl $2,%eax # assume not taken
1745 js common_backwardBranch
1748 FETCH_INST_INDEXED %eax
1749 ADVANCE_PC_INDEXED %eax
1753 /* ------------------------------ */
1754 .L_OP_IF_NE: /* 0x33 */
1755 /* File: x86/OP_IF_NE.S */
1756 /* File: x86/bincmp.S */
1758 * Generic two-operand compare-and-branch operation. Provide a "revcmp"
1759 * fragment that specifies the *reverse* comparison to perform, e.g.
1760 * for "if-le" you would use "gt".
1762 * For: if-eq, if-ne, if-lt, if-ge, if-gt, if-le
1764 /* if-cmp vA, vB, +CCCC */
1765 movzx rINSTbl,%ecx # ecx <- A+
1766 andb $0xf,%cl # ecx <- A
1767 GET_VREG_R %eax %ecx # eax <- vA
1768 sarl $4,rINST # rINST<- B
1769 cmpl (rFP,rINST,4),%eax # compare (vA, vB)
1770 movswl 2(rPC),rINST # Get signed branch offset
1771 movl $2,%eax # assume not taken
1774 js common_backwardBranch
1777 FETCH_INST_INDEXED %eax
1778 ADVANCE_PC_INDEXED %eax
1782 /* ------------------------------ */
1783 .L_OP_IF_LT: /* 0x34 */
1784 /* File: x86/OP_IF_LT.S */
1785 /* File: x86/bincmp.S */
1787 * Generic two-operand compare-and-branch operation. Provide a "revcmp"
1788 * fragment that specifies the *reverse* comparison to perform, e.g.
1789 * for "if-le" you would use "gt".
1791 * For: if-eq, if-ne, if-lt, if-ge, if-gt, if-le
1793 /* if-cmp vA, vB, +CCCC */
1794 movzx rINSTbl,%ecx # ecx <- A+
1795 andb $0xf,%cl # ecx <- A
1796 GET_VREG_R %eax %ecx # eax <- vA
1797 sarl $4,rINST # rINST<- B
1798 cmpl (rFP,rINST,4),%eax # compare (vA, vB)
1799 movswl 2(rPC),rINST # Get signed branch offset
1800 movl $2,%eax # assume not taken
1803 js common_backwardBranch
1806 FETCH_INST_INDEXED %eax
1807 ADVANCE_PC_INDEXED %eax
1811 /* ------------------------------ */
1812 .L_OP_IF_GE: /* 0x35 */
1813 /* File: x86/OP_IF_GE.S */
1814 /* File: x86/bincmp.S */
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".
1820 * For: if-eq, if-ne, if-lt, if-ge, if-gt, if-le
1822 /* if-cmp vA, vB, +CCCC */
1823 movzx rINSTbl,%ecx # ecx <- A+
1824 andb $0xf,%cl # ecx <- A
1825 GET_VREG_R %eax %ecx # eax <- vA
1826 sarl $4,rINST # rINST<- B
1827 cmpl (rFP,rINST,4),%eax # compare (vA, vB)
1828 movswl 2(rPC),rINST # Get signed branch offset
1829 movl $2,%eax # assume not taken
1832 js common_backwardBranch
1835 FETCH_INST_INDEXED %eax
1836 ADVANCE_PC_INDEXED %eax
1840 /* ------------------------------ */
1841 .L_OP_IF_GT: /* 0x36 */
1842 /* File: x86/OP_IF_GT.S */
1843 /* File: x86/bincmp.S */
1845 * Generic two-operand compare-and-branch operation. Provide a "revcmp"
1846 * fragment that specifies the *reverse* comparison to perform, e.g.
1847 * for "if-le" you would use "gt".
1849 * For: if-eq, if-ne, if-lt, if-ge, if-gt, if-le
1851 /* if-cmp vA, vB, +CCCC */
1852 movzx rINSTbl,%ecx # ecx <- A+
1853 andb $0xf,%cl # ecx <- A
1854 GET_VREG_R %eax %ecx # eax <- vA
1855 sarl $4,rINST # rINST<- B
1856 cmpl (rFP,rINST,4),%eax # compare (vA, vB)
1857 movswl 2(rPC),rINST # Get signed branch offset
1858 movl $2,%eax # assume not taken
1861 js common_backwardBranch
1864 FETCH_INST_INDEXED %eax
1865 ADVANCE_PC_INDEXED %eax
1869 /* ------------------------------ */
1870 .L_OP_IF_LE: /* 0x37 */
1871 /* File: x86/OP_IF_LE.S */
1872 /* File: x86/bincmp.S */
1874 * Generic two-operand compare-and-branch operation. Provide a "revcmp"
1875 * fragment that specifies the *reverse* comparison to perform, e.g.
1876 * for "if-le" you would use "gt".
1878 * For: if-eq, if-ne, if-lt, if-ge, if-gt, if-le
1880 /* if-cmp vA, vB, +CCCC */
1881 movzx rINSTbl,%ecx # ecx <- A+
1882 andb $0xf,%cl # ecx <- A
1883 GET_VREG_R %eax %ecx # eax <- vA
1884 sarl $4,rINST # rINST<- B
1885 cmpl (rFP,rINST,4),%eax # compare (vA, vB)
1886 movswl 2(rPC),rINST # Get signed branch offset
1887 movl $2,%eax # assume not taken
1890 js common_backwardBranch
1893 FETCH_INST_INDEXED %eax
1894 ADVANCE_PC_INDEXED %eax
1898 /* ------------------------------ */
1899 .L_OP_IF_EQZ: /* 0x38 */
1900 /* File: x86/OP_IF_EQZ.S */
1901 /* File: x86/zcmp.S */
1903 * Generic one-operand compare-and-branch operation. Provide a "revcmp"
1904 * fragment that specifies the *reverse* comparison to perform, e.g.
1905 * for "if-le" you would use "gt".
1907 * for: if-eqz, if-nez, if-ltz, if-gez, if-gtz, if-lez
1909 /* if-cmp vAA, +BBBB */
1910 cmpl $0,(rFP,rINST,4) # compare (vA, 0)
1911 movswl 2(rPC),rINST # fetch signed displacement
1912 movl $2,%eax # assume branch not taken
1915 js common_backwardBranch
1918 FETCH_INST_INDEXED %eax
1919 ADVANCE_PC_INDEXED %eax
1923 /* ------------------------------ */
1924 .L_OP_IF_NEZ: /* 0x39 */
1925 /* File: x86/OP_IF_NEZ.S */
1926 /* File: x86/zcmp.S */
1928 * Generic one-operand compare-and-branch operation. Provide a "revcmp"
1929 * fragment that specifies the *reverse* comparison to perform, e.g.
1930 * for "if-le" you would use "gt".
1932 * for: if-eqz, if-nez, if-ltz, if-gez, if-gtz, if-lez
1934 /* if-cmp vAA, +BBBB */
1935 cmpl $0,(rFP,rINST,4) # compare (vA, 0)
1936 movswl 2(rPC),rINST # fetch signed displacement
1937 movl $2,%eax # assume branch not taken
1940 js common_backwardBranch
1943 FETCH_INST_INDEXED %eax
1944 ADVANCE_PC_INDEXED %eax
1948 /* ------------------------------ */
1949 .L_OP_IF_LTZ: /* 0x3a */
1950 /* File: x86/OP_IF_LTZ.S */
1951 /* File: x86/zcmp.S */
1953 * Generic one-operand compare-and-branch operation. Provide a "revcmp"
1954 * fragment that specifies the *reverse* comparison to perform, e.g.
1955 * for "if-le" you would use "gt".
1957 * for: if-eqz, if-nez, if-ltz, if-gez, if-gtz, if-lez
1959 /* if-cmp vAA, +BBBB */
1960 cmpl $0,(rFP,rINST,4) # compare (vA, 0)
1961 movswl 2(rPC),rINST # fetch signed displacement
1962 movl $2,%eax # assume branch not taken
1965 js common_backwardBranch
1968 FETCH_INST_INDEXED %eax
1969 ADVANCE_PC_INDEXED %eax
1973 /* ------------------------------ */
1974 .L_OP_IF_GEZ: /* 0x3b */
1975 /* File: x86/OP_IF_GEZ.S */
1976 /* File: x86/zcmp.S */
1978 * Generic one-operand compare-and-branch operation. Provide a "revcmp"
1979 * fragment that specifies the *reverse* comparison to perform, e.g.
1980 * for "if-le" you would use "gt".
1982 * for: if-eqz, if-nez, if-ltz, if-gez, if-gtz, if-lez
1984 /* if-cmp vAA, +BBBB */
1985 cmpl $0,(rFP,rINST,4) # compare (vA, 0)
1986 movswl 2(rPC),rINST # fetch signed displacement
1987 movl $2,%eax # assume branch not taken
1990 js common_backwardBranch
1993 FETCH_INST_INDEXED %eax
1994 ADVANCE_PC_INDEXED %eax
1998 /* ------------------------------ */
1999 .L_OP_IF_GTZ: /* 0x3c */
2000 /* File: x86/OP_IF_GTZ.S */
2001 /* File: x86/zcmp.S */
2003 * Generic one-operand compare-and-branch operation. Provide a "revcmp"
2004 * fragment that specifies the *reverse* comparison to perform, e.g.
2005 * for "if-le" you would use "gt".
2007 * for: if-eqz, if-nez, if-ltz, if-gez, if-gtz, if-lez
2009 /* if-cmp vAA, +BBBB */
2010 cmpl $0,(rFP,rINST,4) # compare (vA, 0)
2011 movswl 2(rPC),rINST # fetch signed displacement
2012 movl $2,%eax # assume branch not taken
2015 js common_backwardBranch
2018 FETCH_INST_INDEXED %eax
2019 ADVANCE_PC_INDEXED %eax
2023 /* ------------------------------ */
2024 .L_OP_IF_LEZ: /* 0x3d */
2025 /* File: x86/OP_IF_LEZ.S */
2026 /* File: x86/zcmp.S */
2028 * Generic one-operand compare-and-branch operation. Provide a "revcmp"
2029 * fragment that specifies the *reverse* comparison to perform, e.g.
2030 * for "if-le" you would use "gt".
2032 * for: if-eqz, if-nez, if-ltz, if-gez, if-gtz, if-lez
2034 /* if-cmp vAA, +BBBB */
2035 cmpl $0,(rFP,rINST,4) # compare (vA, 0)
2036 movswl 2(rPC),rINST # fetch signed displacement
2037 movl $2,%eax # assume branch not taken
2040 js common_backwardBranch
2043 FETCH_INST_INDEXED %eax
2044 ADVANCE_PC_INDEXED %eax
2048 /* ------------------------------ */
2049 .L_OP_UNUSED_3E: /* 0x3e */
2050 /* File: x86/OP_UNUSED_3E.S */
2051 /* File: x86/unused.S */
2055 /* ------------------------------ */
2056 .L_OP_UNUSED_3F: /* 0x3f */
2057 /* File: x86/OP_UNUSED_3F.S */
2058 /* File: x86/unused.S */
2062 /* ------------------------------ */
2063 .L_OP_UNUSED_40: /* 0x40 */
2064 /* File: x86/OP_UNUSED_40.S */
2065 /* File: x86/unused.S */
2069 /* ------------------------------ */
2070 .L_OP_UNUSED_41: /* 0x41 */
2071 /* File: x86/OP_UNUSED_41.S */
2072 /* File: x86/unused.S */
2076 /* ------------------------------ */
2077 .L_OP_UNUSED_42: /* 0x42 */
2078 /* File: x86/OP_UNUSED_42.S */
2079 /* File: x86/unused.S */
2083 /* ------------------------------ */
2084 .L_OP_UNUSED_43: /* 0x43 */
2085 /* File: x86/OP_UNUSED_43.S */
2086 /* File: x86/unused.S */
2090 /* ------------------------------ */
2091 .L_OP_AGET: /* 0x44 */
2092 /* File: x86/OP_AGET.S */
2094 * Array get, 32 bits or less. vAA <- vBB[vCC].
2096 * for: aget, aget-object, aget-boolean, aget-byte, aget-char, aget-short
2098 /* op vAA, vBB, vCC */
2099 movzbl 2(rPC),%eax # eax<- BB
2100 movzbl 3(rPC),%ecx # ecx<- CC
2101 GET_VREG_R %eax %eax # eax<- vBB (array object)
2102 GET_VREG_R %ecx %ecx # ecs<- vCC (requested index)
2103 testl %eax,%eax # null array object?
2104 je common_errNullObject # bail if so
2105 cmpl offArrayObject_length(%eax),%ecx
2106 jae common_errArrayIndex # index >= length, bail. Expects
2109 movl offArrayObject_contents(%eax,%ecx,4),%eax
2111 FETCH_INST_OPCODE 2 %ecx
2116 /* ------------------------------ */
2117 .L_OP_AGET_WIDE: /* 0x45 */
2118 /* File: x86/OP_AGET_WIDE.S */
2120 * Array get, 64 bits. vAA <- vBB[vCC].
2123 /* op vAA, vBB, vCC */
2124 movzbl 2(rPC),%eax # eax<- BB
2125 movzbl 3(rPC),%ecx # ecx<- CC
2126 GET_VREG_R %eax %eax # eax<- vBB (array object)
2127 GET_VREG_R %ecx %ecx # ecs<- vCC (requested index)
2128 testl %eax,%eax # null array object?
2129 je common_errNullObject # bail if so
2130 cmpl offArrayObject_length(%eax),%ecx
2131 jae common_errArrayIndex # index >= length, bail. Expects
2134 leal offArrayObject_contents(%eax,%ecx,8),%eax
2137 SET_VREG_WORD %ecx rINST 0
2138 SET_VREG_WORD %eax rINST 1
2139 FETCH_INST_OPCODE 2 %ecx
2143 /* ------------------------------ */
2144 .L_OP_AGET_OBJECT: /* 0x46 */
2145 /* File: x86/OP_AGET_OBJECT.S */
2146 /* File: x86/OP_AGET.S */
2148 * Array get, 32 bits or less. vAA <- vBB[vCC].
2150 * for: aget, aget-object, aget-boolean, aget-byte, aget-char, aget-short
2152 /* op vAA, vBB, vCC */
2153 movzbl 2(rPC),%eax # eax<- BB
2154 movzbl 3(rPC),%ecx # ecx<- CC
2155 GET_VREG_R %eax %eax # eax<- vBB (array object)
2156 GET_VREG_R %ecx %ecx # ecs<- vCC (requested index)
2157 testl %eax,%eax # null array object?
2158 je common_errNullObject # bail if so
2159 cmpl offArrayObject_length(%eax),%ecx
2160 jae common_errArrayIndex # index >= length, bail. Expects
2163 movl offArrayObject_contents(%eax,%ecx,4),%eax
2164 .LOP_AGET_OBJECT_finish:
2165 FETCH_INST_OPCODE 2 %ecx
2171 /* ------------------------------ */
2172 .L_OP_AGET_BOOLEAN: /* 0x47 */
2173 /* File: x86/OP_AGET_BOOLEAN.S */
2174 /* File: x86/OP_AGET.S */
2176 * Array get, 32 bits or less. vAA <- vBB[vCC].
2178 * for: aget, aget-object, aget-boolean, aget-byte, aget-char, aget-short
2180 /* op vAA, vBB, vCC */
2181 movzbl 2(rPC),%eax # eax<- BB
2182 movzbl 3(rPC),%ecx # ecx<- CC
2183 GET_VREG_R %eax %eax # eax<- vBB (array object)
2184 GET_VREG_R %ecx %ecx # ecs<- vCC (requested index)
2185 testl %eax,%eax # null array object?
2186 je common_errNullObject # bail if so
2187 cmpl offArrayObject_length(%eax),%ecx
2188 jae common_errArrayIndex # index >= length, bail. Expects
2191 movzbl offArrayObject_contents(%eax,%ecx,1),%eax
2192 .LOP_AGET_BOOLEAN_finish:
2193 FETCH_INST_OPCODE 2 %ecx
2199 /* ------------------------------ */
2200 .L_OP_AGET_BYTE: /* 0x48 */
2201 /* File: x86/OP_AGET_BYTE.S */
2202 /* File: x86/OP_AGET.S */
2204 * Array get, 32 bits or less. vAA <- vBB[vCC].
2206 * for: aget, aget-object, aget-boolean, aget-byte, aget-char, aget-short
2208 /* op vAA, vBB, vCC */
2209 movzbl 2(rPC),%eax # eax<- BB
2210 movzbl 3(rPC),%ecx # ecx<- CC
2211 GET_VREG_R %eax %eax # eax<- vBB (array object)
2212 GET_VREG_R %ecx %ecx # ecs<- vCC (requested index)
2213 testl %eax,%eax # null array object?
2214 je common_errNullObject # bail if so
2215 cmpl offArrayObject_length(%eax),%ecx
2216 jae common_errArrayIndex # index >= length, bail. Expects
2219 movsbl offArrayObject_contents(%eax,%ecx,1),%eax
2220 .LOP_AGET_BYTE_finish:
2221 FETCH_INST_OPCODE 2 %ecx
2227 /* ------------------------------ */
2228 .L_OP_AGET_CHAR: /* 0x49 */
2229 /* File: x86/OP_AGET_CHAR.S */
2230 /* File: x86/OP_AGET.S */
2232 * Array get, 32 bits or less. vAA <- vBB[vCC].
2234 * for: aget, aget-object, aget-boolean, aget-byte, aget-char, aget-short
2236 /* op vAA, vBB, vCC */
2237 movzbl 2(rPC),%eax # eax<- BB
2238 movzbl 3(rPC),%ecx # ecx<- CC
2239 GET_VREG_R %eax %eax # eax<- vBB (array object)
2240 GET_VREG_R %ecx %ecx # ecs<- vCC (requested index)
2241 testl %eax,%eax # null array object?
2242 je common_errNullObject # bail if so
2243 cmpl offArrayObject_length(%eax),%ecx
2244 jae common_errArrayIndex # index >= length, bail. Expects
2247 movzwl offArrayObject_contents(%eax,%ecx,2),%eax
2248 .LOP_AGET_CHAR_finish:
2249 FETCH_INST_OPCODE 2 %ecx
2255 /* ------------------------------ */
2256 .L_OP_AGET_SHORT: /* 0x4a */
2257 /* File: x86/OP_AGET_SHORT.S */
2258 /* File: x86/OP_AGET.S */
2260 * Array get, 32 bits or less. vAA <- vBB[vCC].
2262 * for: aget, aget-object, aget-boolean, aget-byte, aget-char, aget-short
2264 /* op vAA, vBB, vCC */
2265 movzbl 2(rPC),%eax # eax<- BB
2266 movzbl 3(rPC),%ecx # ecx<- CC
2267 GET_VREG_R %eax %eax # eax<- vBB (array object)
2268 GET_VREG_R %ecx %ecx # ecs<- vCC (requested index)
2269 testl %eax,%eax # null array object?
2270 je common_errNullObject # bail if so
2271 cmpl offArrayObject_length(%eax),%ecx
2272 jae common_errArrayIndex # index >= length, bail. Expects
2275 movswl offArrayObject_contents(%eax,%ecx,2),%eax
2276 .LOP_AGET_SHORT_finish:
2277 FETCH_INST_OPCODE 2 %ecx
2283 /* ------------------------------ */
2284 .L_OP_APUT: /* 0x4b */
2285 /* File: x86/OP_APUT.S */
2287 * Array put, 32 bits or less. vBB[vCC] <- vAA
2289 * for: aput, aput-object, aput-boolean, aput-byte, aput-char, aput-short
2291 /* op vAA, vBB, vCC */
2292 movzbl 2(rPC),%eax # eax<- BB
2293 movzbl 3(rPC),%ecx # ecx<- CC
2294 GET_VREG_R %eax %eax # eax<- vBB (array object)
2295 GET_VREG_R %ecx %ecx # ecs<- vCC (requested index)
2296 testl %eax,%eax # null array object?
2297 je common_errNullObject # bail if so
2298 cmpl offArrayObject_length(%eax),%ecx
2299 jae common_errArrayIndex # index >= length, bail. Expects:
2302 leal offArrayObject_contents(%eax,%ecx,4),%eax
2304 GET_VREG_R rINST rINST
2305 FETCH_INST_OPCODE 2 %ecx
2310 /* ------------------------------ */
2311 .L_OP_APUT_WIDE: /* 0x4c */
2312 /* File: x86/OP_APUT_WIDE.S */
2314 * Array put, 64 bits. vBB[vCC]<-vAA.
2317 /* op vAA, vBB, vCC */
2318 movzbl 2(rPC),%eax # eax<- BB
2319 movzbl 3(rPC),%ecx # ecx<- CC
2320 GET_VREG_R %eax %eax # eax<- vBB (array object)
2321 GET_VREG_R %ecx %ecx # ecs<- vCC (requested index)
2322 testl %eax,%eax # null array object?
2323 je common_errNullObject # bail if so
2324 cmpl offArrayObject_length(%eax),%ecx
2325 jae common_errArrayIndex # index >= length, bail. Expects:
2328 leal offArrayObject_contents(%eax,%ecx,8),%eax
2329 GET_VREG_WORD %ecx rINST 0
2330 GET_VREG_WORD rINST rINST 1
2332 FETCH_INST_OPCODE 2 %ecx
2337 /* ------------------------------ */
2338 .L_OP_APUT_OBJECT: /* 0x4d */
2339 /* File: x86/OP_APUT_OBJECT.S */
2341 * Array put, 32 bits or less. vBB[vCC] <- vAA
2343 * for: aput, aput-object, aput-boolean, aput-byte, aput-char, aput-short
2345 /* op vAA, vBB, vCC */
2346 movzbl 2(rPC),%eax # eax<- BB
2347 movzbl 3(rPC),%ecx # ecx<- CC
2348 GET_VREG_R %eax %eax # eax<- vBB (array object)
2349 GET_VREG_R %ecx %ecx # ecs<- vCC (requested index)
2350 GET_VREG_R rINST rINST # rINST<- vAA
2351 testl %eax,%eax # null array object?
2352 je common_errNullObject # bail if so
2353 cmpl offArrayObject_length(%eax),%ecx
2354 jae common_errArrayIndex # index >= length, bail. Expects
2358 * eax<- array object
2362 leal offArrayObject_contents(%eax,%ecx,4),%ecx
2363 testl rINST,rINST # storing null reference?
2364 je .LOP_APUT_OBJECT_skip_check
2365 SPILL_TMP1(%ecx) # save target address
2366 SPILL_TMP2(%eax) # save object head
2367 movl offObject_clazz(%eax),%eax # eax<- arrayObj->clazz
2368 movl offObject_clazz(rINST),%ecx # ecx<- obj->clazz
2369 movl %eax,OUT_ARG1(%esp)
2370 movl %ecx,OUT_ARG0(%esp)
2371 movl %ecx,sReg0 # store the two classes for later
2374 call dvmCanPutArrayElement # test object type vs. array type
2376 UNSPILL_TMP1(%ecx) # recover target address
2379 jne .LOP_APUT_OBJECT_types_okay
2381 # The types don't match. We need to throw an ArrayStoreException.
2383 movl sReg0,%eax # restore the two classes...
2384 movl %eax,OUT_ARG0(%esp)
2386 movl %ecx,OUT_ARG1(%esp)
2387 call dvmThrowArrayStoreException # ...and throw
2388 jmp common_exceptionThrown
2390 .LOP_APUT_OBJECT_types_okay:
2391 movl offThread_cardTable(%eax),%eax # get card table base
2392 movl rINST,(%ecx) # store into array
2393 UNSPILL_TMP2(rINST) # recover object head
2394 FETCH_INST_OPCODE 2 %ecx
2395 shrl $GC_CARD_SHIFT,rINST # object head to card number
2396 movb %al,(%eax,rINST) # mark card using object head
2400 .LOP_APUT_OBJECT_skip_check:
2402 FETCH_INST_OPCODE 2 %ecx
2406 /* ------------------------------ */
2407 .L_OP_APUT_BOOLEAN: /* 0x4e */
2408 /* File: x86/OP_APUT_BOOLEAN.S */
2409 /* File: x86/OP_APUT.S */
2411 * Array put, 32 bits or less. vBB[vCC] <- vAA
2413 * for: aput, aput-object, aput-boolean, aput-byte, aput-char, aput-short
2415 /* op vAA, vBB, vCC */
2416 movzbl 2(rPC),%eax # eax<- BB
2417 movzbl 3(rPC),%ecx # ecx<- CC
2418 GET_VREG_R %eax %eax # eax<- vBB (array object)
2419 GET_VREG_R %ecx %ecx # ecs<- vCC (requested index)
2420 testl %eax,%eax # null array object?
2421 je common_errNullObject # bail if so
2422 cmpl offArrayObject_length(%eax),%ecx
2423 jae common_errArrayIndex # index >= length, bail. Expects:
2426 leal offArrayObject_contents(%eax,%ecx,1),%eax
2427 .LOP_APUT_BOOLEAN_finish:
2428 GET_VREG_R rINST rINST
2429 FETCH_INST_OPCODE 2 %ecx
2435 /* ------------------------------ */
2436 .L_OP_APUT_BYTE: /* 0x4f */
2437 /* File: x86/OP_APUT_BYTE.S */
2438 /* File: x86/OP_APUT.S */
2440 * Array put, 32 bits or less. vBB[vCC] <- vAA
2442 * for: aput, aput-object, aput-boolean, aput-byte, aput-char, aput-short
2444 /* op vAA, vBB, vCC */
2445 movzbl 2(rPC),%eax # eax<- BB
2446 movzbl 3(rPC),%ecx # ecx<- CC
2447 GET_VREG_R %eax %eax # eax<- vBB (array object)
2448 GET_VREG_R %ecx %ecx # ecs<- vCC (requested index)
2449 testl %eax,%eax # null array object?
2450 je common_errNullObject # bail if so
2451 cmpl offArrayObject_length(%eax),%ecx
2452 jae common_errArrayIndex # index >= length, bail. Expects:
2455 leal offArrayObject_contents(%eax,%ecx,1),%eax
2456 .LOP_APUT_BYTE_finish:
2457 GET_VREG_R rINST rINST
2458 FETCH_INST_OPCODE 2 %ecx
2464 /* ------------------------------ */
2465 .L_OP_APUT_CHAR: /* 0x50 */
2466 /* File: x86/OP_APUT_CHAR.S */
2467 /* File: x86/OP_APUT.S */
2469 * Array put, 32 bits or less. vBB[vCC] <- vAA
2471 * for: aput, aput-object, aput-boolean, aput-byte, aput-char, aput-short
2473 /* op vAA, vBB, vCC */
2474 movzbl 2(rPC),%eax # eax<- BB
2475 movzbl 3(rPC),%ecx # ecx<- CC
2476 GET_VREG_R %eax %eax # eax<- vBB (array object)
2477 GET_VREG_R %ecx %ecx # ecs<- vCC (requested index)
2478 testl %eax,%eax # null array object?
2479 je common_errNullObject # bail if so
2480 cmpl offArrayObject_length(%eax),%ecx
2481 jae common_errArrayIndex # index >= length, bail. Expects:
2484 leal offArrayObject_contents(%eax,%ecx,2),%eax
2485 .LOP_APUT_CHAR_finish:
2486 GET_VREG_R rINST rINST
2487 FETCH_INST_OPCODE 2 %ecx
2493 /* ------------------------------ */
2494 .L_OP_APUT_SHORT: /* 0x51 */
2495 /* File: x86/OP_APUT_SHORT.S */
2496 /* File: x86/OP_APUT.S */
2498 * Array put, 32 bits or less. vBB[vCC] <- vAA
2500 * for: aput, aput-object, aput-boolean, aput-byte, aput-char, aput-short
2502 /* op vAA, vBB, vCC */
2503 movzbl 2(rPC),%eax # eax<- BB
2504 movzbl 3(rPC),%ecx # ecx<- CC
2505 GET_VREG_R %eax %eax # eax<- vBB (array object)
2506 GET_VREG_R %ecx %ecx # ecs<- vCC (requested index)
2507 testl %eax,%eax # null array object?
2508 je common_errNullObject # bail if so
2509 cmpl offArrayObject_length(%eax),%ecx
2510 jae common_errArrayIndex # index >= length, bail. Expects:
2513 leal offArrayObject_contents(%eax,%ecx,2),%eax
2514 .LOP_APUT_SHORT_finish:
2515 GET_VREG_R rINST rINST
2516 FETCH_INST_OPCODE 2 %ecx
2522 /* ------------------------------ */
2523 .L_OP_IGET: /* 0x52 */
2524 /* File: x86/OP_IGET.S */
2526 * General 32-bit instance field get.
2528 * for: iget, iget-object, iget-boolean, iget-byte, iget-char, iget-short
2530 /* op vA, vB, field@CCCC */
2532 SPILL(rIBASE) # preserve rIBASE
2533 movzwl 2(rPC),rIBASE # rIBASE<- 0000CCCC
2534 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex
2535 movzbl rINSTbl,%ecx # ecx<- BA
2536 sarl $4,%ecx # ecx<- B
2537 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields
2538 andb $0xf,rINSTbl # rINST<- A
2539 GET_VREG_R %ecx %ecx # ecx<- fp[B], the object ptr
2540 movl (%eax,rIBASE,4),%eax # resolved entry
2541 testl %eax,%eax # is resolved entry null?
2542 jne .LOP_IGET_finish # no, already resolved
2543 movl rIBASE,OUT_ARG1(%esp) # needed by dvmResolveInstField
2546 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method
2547 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz
2548 SPILL_TMP1(%ecx) # save obj pointer across call
2549 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz
2550 call dvmResolveInstField # ... to dvmResolveInstField
2552 testl %eax,%eax # returns InstrField ptr
2553 jne .LOP_IGET_finish
2554 jmp common_exceptionThrown
2559 * eax holds resolved field
2563 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field
2564 testl %ecx,%ecx # object null?
2565 je common_errNullObject # object was null
2566 movl (%ecx,%eax,1),%ecx # ecx<- obj.field (8/16/32 bits)
2567 FETCH_INST_OPCODE 2 %eax
2573 /* ------------------------------ */
2574 .L_OP_IGET_WIDE: /* 0x53 */
2575 /* File: x86/OP_IGET_WIDE.S */
2577 * 64-bit instance field get.
2580 /* op vA, vB, field@CCCC */
2582 SPILL(rIBASE) # preserve rIBASE
2583 movzwl 2(rPC),rIBASE # rIBASE<- 0000CCCC
2584 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex
2585 movzbl rINSTbl,%ecx # ecx<- BA
2586 sarl $4,%ecx # ecx<- B
2587 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields
2588 andb $0xf,rINSTbl # rINST<- A
2589 GET_VREG_R %ecx %ecx # ecx<- fp[B], the object ptr
2590 movl (%eax,rIBASE,4),%eax # resolved entry
2591 testl %eax,%eax # is resolved entry null?
2592 jne .LOP_IGET_WIDE_finish # no, already resolved
2593 movl rIBASE,OUT_ARG1(%esp) # for dvmResolveInstField
2596 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method
2597 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz
2598 SPILL_TMP1(%ecx) # save objpointer across call
2599 movl rPC,OUT_ARG0(%esp) # pass in method->clazz
2600 call dvmResolveInstField # ... to dvmResolveInstField
2602 testl %eax,%eax # returns InstrField ptr
2603 jne .LOP_IGET_WIDE_finish
2604 jmp common_exceptionThrown
2606 .LOP_IGET_WIDE_finish:
2609 * eax holds resolved field
2613 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field
2614 testl %ecx,%ecx # object null?
2615 je common_errNullObject # object was null
2616 leal (%ecx,%eax,1),%eax # eax<- address of field
2617 movl (%eax),%ecx # ecx<- lsw
2618 movl 4(%eax),%eax # eax<- msw
2619 SET_VREG_WORD %ecx rINST 0
2620 FETCH_INST_OPCODE 2 %ecx
2621 UNSPILL(rIBASE) # restore rIBASE
2622 SET_VREG_WORD %eax rINST 1
2626 /* ------------------------------ */
2627 .L_OP_IGET_OBJECT: /* 0x54 */
2628 /* File: x86/OP_IGET_OBJECT.S */
2629 /* File: x86/OP_IGET.S */
2631 * General 32-bit instance field get.
2633 * for: iget, iget-object, iget-boolean, iget-byte, iget-char, iget-short
2635 /* op vA, vB, field@CCCC */
2637 SPILL(rIBASE) # preserve rIBASE
2638 movzwl 2(rPC),rIBASE # rIBASE<- 0000CCCC
2639 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex
2640 movzbl rINSTbl,%ecx # ecx<- BA
2641 sarl $4,%ecx # ecx<- B
2642 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields
2643 andb $0xf,rINSTbl # rINST<- A
2644 GET_VREG_R %ecx %ecx # ecx<- fp[B], the object ptr
2645 movl (%eax,rIBASE,4),%eax # resolved entry
2646 testl %eax,%eax # is resolved entry null?
2647 jne .LOP_IGET_OBJECT_finish # no, already resolved
2648 movl rIBASE,OUT_ARG1(%esp) # needed by dvmResolveInstField
2651 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method
2652 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz
2653 SPILL_TMP1(%ecx) # save obj pointer across call
2654 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz
2655 call dvmResolveInstField # ... to dvmResolveInstField
2657 testl %eax,%eax # returns InstrField ptr
2658 jne .LOP_IGET_OBJECT_finish
2659 jmp common_exceptionThrown
2661 .LOP_IGET_OBJECT_finish:
2664 * eax holds resolved field
2668 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field
2669 testl %ecx,%ecx # object null?
2670 je common_errNullObject # object was null
2671 movl (%ecx,%eax,1),%ecx # ecx<- obj.field (8/16/32 bits)
2672 FETCH_INST_OPCODE 2 %eax
2679 /* ------------------------------ */
2680 .L_OP_IGET_BOOLEAN: /* 0x55 */
2681 /* File: x86/OP_IGET_BOOLEAN.S */
2682 /* File: x86/OP_IGET.S */
2684 * General 32-bit instance field get.
2686 * for: iget, iget-object, iget-boolean, iget-byte, iget-char, iget-short
2688 /* op vA, vB, field@CCCC */
2690 SPILL(rIBASE) # preserve rIBASE
2691 movzwl 2(rPC),rIBASE # rIBASE<- 0000CCCC
2692 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex
2693 movzbl rINSTbl,%ecx # ecx<- BA
2694 sarl $4,%ecx # ecx<- B
2695 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields
2696 andb $0xf,rINSTbl # rINST<- A
2697 GET_VREG_R %ecx %ecx # ecx<- fp[B], the object ptr
2698 movl (%eax,rIBASE,4),%eax # resolved entry
2699 testl %eax,%eax # is resolved entry null?
2700 jne .LOP_IGET_BOOLEAN_finish # no, already resolved
2701 movl rIBASE,OUT_ARG1(%esp) # needed by dvmResolveInstField
2704 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method
2705 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz
2706 SPILL_TMP1(%ecx) # save obj pointer across call
2707 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz
2708 call dvmResolveInstField # ... to dvmResolveInstField
2710 testl %eax,%eax # returns InstrField ptr
2711 jne .LOP_IGET_BOOLEAN_finish
2712 jmp common_exceptionThrown
2714 .LOP_IGET_BOOLEAN_finish:
2717 * eax holds resolved field
2721 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field
2722 testl %ecx,%ecx # object null?
2723 je common_errNullObject # object was null
2724 movzbl (%ecx,%eax,1),%ecx # ecx<- obj.field (8/16/32 bits)
2725 FETCH_INST_OPCODE 2 %eax
2732 /* ------------------------------ */
2733 .L_OP_IGET_BYTE: /* 0x56 */
2734 /* File: x86/OP_IGET_BYTE.S */
2735 /* File: x86/OP_IGET.S */
2737 * General 32-bit instance field get.
2739 * for: iget, iget-object, iget-boolean, iget-byte, iget-char, iget-short
2741 /* op vA, vB, field@CCCC */
2743 SPILL(rIBASE) # preserve rIBASE
2744 movzwl 2(rPC),rIBASE # rIBASE<- 0000CCCC
2745 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex
2746 movzbl rINSTbl,%ecx # ecx<- BA
2747 sarl $4,%ecx # ecx<- B
2748 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields
2749 andb $0xf,rINSTbl # rINST<- A
2750 GET_VREG_R %ecx %ecx # ecx<- fp[B], the object ptr
2751 movl (%eax,rIBASE,4),%eax # resolved entry
2752 testl %eax,%eax # is resolved entry null?
2753 jne .LOP_IGET_BYTE_finish # no, already resolved
2754 movl rIBASE,OUT_ARG1(%esp) # needed by dvmResolveInstField
2757 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method
2758 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz
2759 SPILL_TMP1(%ecx) # save obj pointer across call
2760 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz
2761 call dvmResolveInstField # ... to dvmResolveInstField
2763 testl %eax,%eax # returns InstrField ptr
2764 jne .LOP_IGET_BYTE_finish
2765 jmp common_exceptionThrown
2767 .LOP_IGET_BYTE_finish:
2770 * eax holds resolved field
2774 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field
2775 testl %ecx,%ecx # object null?
2776 je common_errNullObject # object was null
2777 movsbl (%ecx,%eax,1),%ecx # ecx<- obj.field (8/16/32 bits)
2778 FETCH_INST_OPCODE 2 %eax
2785 /* ------------------------------ */
2786 .L_OP_IGET_CHAR: /* 0x57 */
2787 /* File: x86/OP_IGET_CHAR.S */
2788 /* File: x86/OP_IGET.S */
2790 * General 32-bit instance field get.
2792 * for: iget, iget-object, iget-boolean, iget-byte, iget-char, iget-short
2794 /* op vA, vB, field@CCCC */
2796 SPILL(rIBASE) # preserve rIBASE
2797 movzwl 2(rPC),rIBASE # rIBASE<- 0000CCCC
2798 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex
2799 movzbl rINSTbl,%ecx # ecx<- BA
2800 sarl $4,%ecx # ecx<- B
2801 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields
2802 andb $0xf,rINSTbl # rINST<- A
2803 GET_VREG_R %ecx %ecx # ecx<- fp[B], the object ptr
2804 movl (%eax,rIBASE,4),%eax # resolved entry
2805 testl %eax,%eax # is resolved entry null?
2806 jne .LOP_IGET_CHAR_finish # no, already resolved
2807 movl rIBASE,OUT_ARG1(%esp) # needed by dvmResolveInstField
2810 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method
2811 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz
2812 SPILL_TMP1(%ecx) # save obj pointer across call
2813 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz
2814 call dvmResolveInstField # ... to dvmResolveInstField
2816 testl %eax,%eax # returns InstrField ptr
2817 jne .LOP_IGET_CHAR_finish
2818 jmp common_exceptionThrown
2820 .LOP_IGET_CHAR_finish:
2823 * eax holds resolved field
2827 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field
2828 testl %ecx,%ecx # object null?
2829 je common_errNullObject # object was null
2830 movzwl (%ecx,%eax,1),%ecx # ecx<- obj.field (8/16/32 bits)
2831 FETCH_INST_OPCODE 2 %eax
2838 /* ------------------------------ */
2839 .L_OP_IGET_SHORT: /* 0x58 */
2840 /* File: x86/OP_IGET_SHORT.S */
2841 /* File: x86/OP_IGET.S */
2843 * General 32-bit instance field get.
2845 * for: iget, iget-object, iget-boolean, iget-byte, iget-char, iget-short
2847 /* op vA, vB, field@CCCC */
2849 SPILL(rIBASE) # preserve rIBASE
2850 movzwl 2(rPC),rIBASE # rIBASE<- 0000CCCC
2851 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex
2852 movzbl rINSTbl,%ecx # ecx<- BA
2853 sarl $4,%ecx # ecx<- B
2854 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields
2855 andb $0xf,rINSTbl # rINST<- A
2856 GET_VREG_R %ecx %ecx # ecx<- fp[B], the object ptr
2857 movl (%eax,rIBASE,4),%eax # resolved entry
2858 testl %eax,%eax # is resolved entry null?
2859 jne .LOP_IGET_SHORT_finish # no, already resolved
2860 movl rIBASE,OUT_ARG1(%esp) # needed by dvmResolveInstField
2863 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method
2864 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz
2865 SPILL_TMP1(%ecx) # save obj pointer across call
2866 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz
2867 call dvmResolveInstField # ... to dvmResolveInstField
2869 testl %eax,%eax # returns InstrField ptr
2870 jne .LOP_IGET_SHORT_finish
2871 jmp common_exceptionThrown
2873 .LOP_IGET_SHORT_finish:
2876 * eax holds resolved field
2880 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field
2881 testl %ecx,%ecx # object null?
2882 je common_errNullObject # object was null
2883 movswl (%ecx,%eax,1),%ecx # ecx<- obj.field (8/16/32 bits)
2884 FETCH_INST_OPCODE 2 %eax
2891 /* ------------------------------ */
2892 .L_OP_IPUT: /* 0x59 */
2893 /* File: x86/OP_IPUT.S */
2896 * General 32-bit instance field put.
2898 * for: iput, iput-object, iput-boolean, iput-byte, iput-char, iput-short
2900 /* op vA, vB, field@CCCC */
2903 movzwl 2(rPC),rIBASE # rIBASE<- 0000CCCC
2904 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex
2905 movzbl rINSTbl,%ecx # ecx<- BA
2906 sarl $4,%ecx # ecx<- B
2907 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields
2908 andb $0xf,rINSTbl # rINST<- A
2909 GET_VREG_R %ecx %ecx # ecx<- fp[B], the object ptr
2910 movl (%eax,rIBASE,4),%eax # resolved entry
2911 testl %eax,%eax # is resolved entry null?
2912 jne .LOP_IPUT_finish # no, already resolved
2913 movl rIBASE,OUT_ARG1(%esp)
2916 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method
2917 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz
2918 SPILL_TMP1(%ecx) # save obj pointer across call
2919 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz
2920 call dvmResolveInstField # ... to dvmResolveInstField
2922 testl %eax,%eax # returns InstrField ptr
2923 jne .LOP_IPUT_finish
2924 jmp common_exceptionThrown
2929 * eax holds resolved field
2933 GET_VREG_R rINST rINST # rINST<- v[A]
2934 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field
2935 testl %ecx,%ecx # object null?
2936 je common_errNullObject # object was null
2937 movl rINST,(%ecx,%eax,1) # obj.field <- v[A](8/16/32 bits)
2938 FETCH_INST_OPCODE 2 %ecx
2943 /* ------------------------------ */
2944 .L_OP_IPUT_WIDE: /* 0x5a */
2945 /* File: x86/OP_IPUT_WIDE.S */
2947 * 64-bit instance field put.
2950 /* op vA, vB, field@CCCC */
2953 movzwl 2(rPC),rIBASE # rIBASE<- 0000CCCC
2954 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex
2955 movzbl rINSTbl,%ecx # ecx<- BA
2956 sarl $4,%ecx # ecx<- B
2957 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields
2958 andb $0xf,rINSTbl # rINST<- A
2959 GET_VREG_R %ecx %ecx # ecx<- fp[B], the object ptr
2960 movl (%eax,rIBASE,4),%eax # resolved entry
2961 testl %eax,%eax # is resolved entry null?
2962 jne .LOP_IPUT_WIDE_finish # no, already resolved
2963 movl rIBASE,OUT_ARG1(%esp)
2966 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method
2967 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz
2968 SPILL_TMP1(%ecx) # save obj pointer across call
2969 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz
2970 call dvmResolveInstField # ... to dvmResolveInstField
2972 testl %eax,%eax # ... which returns InstrField ptr
2973 jne .LOP_IPUT_WIDE_finish
2974 jmp common_exceptionThrown
2976 .LOP_IPUT_WIDE_finish:
2979 * eax holds resolved field
2981 * rIBASE is scratch, but needs to be unspilled
2984 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field
2985 testl %ecx,%ecx # object null?
2986 je common_errNullObject # object was null
2987 leal (%ecx,%eax,1),%eax # eax<- address of field
2988 GET_VREG_WORD %ecx rINST 0 # ecx<- lsw
2989 GET_VREG_WORD rINST rINST 1 # rINST<- msw
2992 FETCH_INST_OPCODE 2 %ecx
2997 /* ------------------------------ */
2998 .L_OP_IPUT_OBJECT: /* 0x5b */
2999 /* File: x86/OP_IPUT_OBJECT.S */
3005 /* op vA, vB, field@CCCC */
3008 movzwl 2(rPC),rIBASE # rIBASE<- 0000CCCC
3009 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex
3010 movzbl rINSTbl,%ecx # ecx<- BA
3011 sarl $4,%ecx # ecx<- B
3012 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields
3013 andb $0xf,rINSTbl # rINST<- A
3014 GET_VREG_R %ecx %ecx # ecx<- fp[B], the object ptr
3015 movl (%eax,rIBASE,4),%eax # resolved entry
3016 testl %eax,%eax # is resolved entry null?
3017 jne .LOP_IPUT_OBJECT_finish # no, already resolved
3018 movl rIBASE,OUT_ARG1(%esp)
3021 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method
3022 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz
3023 SPILL_TMP1(%ecx) # save obj pointer across call
3024 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz
3025 call dvmResolveInstField # ... to dvmResolveInstField
3027 testl %eax,%eax # returns InstrField ptr
3028 jne .LOP_IPUT_OBJECT_finish
3029 jmp common_exceptionThrown
3031 .LOP_IPUT_OBJECT_finish:
3034 * eax holds resolved field
3036 * rIBASE is scratch, but needs to be unspilled
3039 GET_VREG_R rINST rINST # rINST<- v[A]
3040 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field
3041 testl %ecx,%ecx # object null?
3042 je common_errNullObject # object was null
3043 movl rINST,(%ecx,%eax) # obj.field <- v[A](8/16/32 bits)
3045 testl rINST,rINST # stored a NULL?
3046 movl offThread_cardTable(%eax),%eax # get card table base
3047 je 1f # skip card mark if null store
3048 shrl $GC_CARD_SHIFT,%ecx # object head to card number
3049 movb %al,(%eax,%ecx) # mark card using object head
3052 FETCH_INST_OPCODE 2 %ecx
3056 /* ------------------------------ */
3057 .L_OP_IPUT_BOOLEAN: /* 0x5c */
3058 /* File: x86/OP_IPUT_BOOLEAN.S */
3059 /* File: x86/OP_IPUT.S */
3062 * General 32-bit instance field put.
3064 * for: iput, iput-object, iput-boolean, iput-byte, iput-char, iput-short
3066 /* op vA, vB, field@CCCC */
3069 movzwl 2(rPC),rIBASE # rIBASE<- 0000CCCC
3070 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex
3071 movzbl rINSTbl,%ecx # ecx<- BA
3072 sarl $4,%ecx # ecx<- B
3073 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields
3074 andb $0xf,rINSTbl # rINST<- A
3075 GET_VREG_R %ecx %ecx # ecx<- fp[B], the object ptr
3076 movl (%eax,rIBASE,4),%eax # resolved entry
3077 testl %eax,%eax # is resolved entry null?
3078 jne .LOP_IPUT_BOOLEAN_finish # no, already resolved
3079 movl rIBASE,OUT_ARG1(%esp)
3082 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method
3083 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz
3084 SPILL_TMP1(%ecx) # save obj pointer across call
3085 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz
3086 call dvmResolveInstField # ... to dvmResolveInstField
3088 testl %eax,%eax # returns InstrField ptr
3089 jne .LOP_IPUT_BOOLEAN_finish
3090 jmp common_exceptionThrown
3092 .LOP_IPUT_BOOLEAN_finish:
3095 * eax holds resolved field
3099 GET_VREG_R rINST rINST # rINST<- v[A]
3100 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field
3101 testl %ecx,%ecx # object null?
3102 je common_errNullObject # object was null
3103 movb rINSTbl,(%ecx,%eax,1) # obj.field <- v[A](8/16/32 bits)
3104 FETCH_INST_OPCODE 2 %ecx
3110 /* ------------------------------ */
3111 .L_OP_IPUT_BYTE: /* 0x5d */
3112 /* File: x86/OP_IPUT_BYTE.S */
3113 /* File: x86/OP_IPUT.S */
3116 * General 32-bit instance field put.
3118 * for: iput, iput-object, iput-boolean, iput-byte, iput-char, iput-short
3120 /* op vA, vB, field@CCCC */
3123 movzwl 2(rPC),rIBASE # rIBASE<- 0000CCCC
3124 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex
3125 movzbl rINSTbl,%ecx # ecx<- BA
3126 sarl $4,%ecx # ecx<- B
3127 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields
3128 andb $0xf,rINSTbl # rINST<- A
3129 GET_VREG_R %ecx %ecx # ecx<- fp[B], the object ptr
3130 movl (%eax,rIBASE,4),%eax # resolved entry
3131 testl %eax,%eax # is resolved entry null?
3132 jne .LOP_IPUT_BYTE_finish # no, already resolved
3133 movl rIBASE,OUT_ARG1(%esp)
3136 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method
3137 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz
3138 SPILL_TMP1(%ecx) # save obj pointer across call
3139 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz
3140 call dvmResolveInstField # ... to dvmResolveInstField
3142 testl %eax,%eax # returns InstrField ptr
3143 jne .LOP_IPUT_BYTE_finish
3144 jmp common_exceptionThrown
3146 .LOP_IPUT_BYTE_finish:
3149 * eax holds resolved field
3153 GET_VREG_R rINST rINST # rINST<- v[A]
3154 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field
3155 testl %ecx,%ecx # object null?
3156 je common_errNullObject # object was null
3157 movb rINSTbl,(%ecx,%eax,1) # obj.field <- v[A](8/16/32 bits)
3158 FETCH_INST_OPCODE 2 %ecx
3164 /* ------------------------------ */
3165 .L_OP_IPUT_CHAR: /* 0x5e */
3166 /* File: x86/OP_IPUT_CHAR.S */
3167 /* File: x86/OP_IPUT.S */
3170 * General 32-bit instance field put.
3172 * for: iput, iput-object, iput-boolean, iput-byte, iput-char, iput-short
3174 /* op vA, vB, field@CCCC */
3177 movzwl 2(rPC),rIBASE # rIBASE<- 0000CCCC
3178 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex
3179 movzbl rINSTbl,%ecx # ecx<- BA
3180 sarl $4,%ecx # ecx<- B
3181 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields
3182 andb $0xf,rINSTbl # rINST<- A
3183 GET_VREG_R %ecx %ecx # ecx<- fp[B], the object ptr
3184 movl (%eax,rIBASE,4),%eax # resolved entry
3185 testl %eax,%eax # is resolved entry null?
3186 jne .LOP_IPUT_CHAR_finish # no, already resolved
3187 movl rIBASE,OUT_ARG1(%esp)
3190 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method
3191 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz
3192 SPILL_TMP1(%ecx) # save obj pointer across call
3193 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz
3194 call dvmResolveInstField # ... to dvmResolveInstField
3196 testl %eax,%eax # returns InstrField ptr
3197 jne .LOP_IPUT_CHAR_finish
3198 jmp common_exceptionThrown
3200 .LOP_IPUT_CHAR_finish:
3203 * eax holds resolved field
3207 GET_VREG_R rINST rINST # rINST<- v[A]
3208 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field
3209 testl %ecx,%ecx # object null?
3210 je common_errNullObject # object was null
3211 movw rINSTw,(%ecx,%eax,1) # obj.field <- v[A](8/16/32 bits)
3212 FETCH_INST_OPCODE 2 %ecx
3218 /* ------------------------------ */
3219 .L_OP_IPUT_SHORT: /* 0x5f */
3220 /* File: x86/OP_IPUT_SHORT.S */
3221 /* File: x86/OP_IPUT.S */
3224 * General 32-bit instance field put.
3226 * for: iput, iput-object, iput-boolean, iput-byte, iput-char, iput-short
3228 /* op vA, vB, field@CCCC */
3231 movzwl 2(rPC),rIBASE # rIBASE<- 0000CCCC
3232 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex
3233 movzbl rINSTbl,%ecx # ecx<- BA
3234 sarl $4,%ecx # ecx<- B
3235 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields
3236 andb $0xf,rINSTbl # rINST<- A
3237 GET_VREG_R %ecx %ecx # ecx<- fp[B], the object ptr
3238 movl (%eax,rIBASE,4),%eax # resolved entry
3239 testl %eax,%eax # is resolved entry null?
3240 jne .LOP_IPUT_SHORT_finish # no, already resolved
3241 movl rIBASE,OUT_ARG1(%esp)
3244 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method
3245 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz
3246 SPILL_TMP1(%ecx) # save obj pointer across call
3247 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz
3248 call dvmResolveInstField # ... to dvmResolveInstField
3250 testl %eax,%eax # returns InstrField ptr
3251 jne .LOP_IPUT_SHORT_finish
3252 jmp common_exceptionThrown
3254 .LOP_IPUT_SHORT_finish:
3257 * eax holds resolved field
3261 GET_VREG_R rINST rINST # rINST<- v[A]
3262 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field
3263 testl %ecx,%ecx # object null?
3264 je common_errNullObject # object was null
3265 movw rINSTw,(%ecx,%eax,1) # obj.field <- v[A](8/16/32 bits)
3266 FETCH_INST_OPCODE 2 %ecx
3272 /* ------------------------------ */
3273 .L_OP_SGET: /* 0x60 */
3274 /* File: x86/OP_SGET.S */
3276 * General 32-bit SGET handler.
3278 * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short
3280 /* op vAA, field@BBBB */
3282 movzwl 2(rPC),%eax # eax<- field ref BBBB
3283 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex
3284 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields
3285 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr
3286 testl %eax,%eax # resolved entry null?
3287 je .LOP_SGET_resolve # if not, make it so
3288 .LOP_SGET_finish: # field ptr in eax
3289 movl offStaticField_value(%eax),%eax
3290 FETCH_INST_OPCODE 2 %ecx
3296 * Go resolve the field
3300 movzwl 2(rPC),%eax # eax<- field ref BBBB
3301 movl offThread_method(%ecx),%ecx # ecx<- current method
3302 EXPORT_PC # could throw, need to export
3303 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz
3304 movl %eax,OUT_ARG1(%esp)
3305 movl %ecx,OUT_ARG0(%esp)
3307 call dvmResolveStaticField # eax<- resolved StaticField ptr
3310 jne .LOP_SGET_finish # success, continue
3311 jmp common_exceptionThrown # no, handle exception
3313 /* ------------------------------ */
3314 .L_OP_SGET_WIDE: /* 0x61 */
3315 /* File: x86/OP_SGET_WIDE.S */
3317 * 64-bit SGET handler.
3320 /* sget-wide vAA, field@BBBB */
3322 movzwl 2(rPC),%eax # eax<- field ref BBBB
3323 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex
3324 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields
3325 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr
3326 testl %eax,%eax # resolved entry null?
3327 je .LOP_SGET_WIDE_resolve # if not, make it so
3328 .LOP_SGET_WIDE_finish: # field ptr in eax
3329 movl offStaticField_value(%eax),%ecx # ecx<- lsw
3330 movl 4+offStaticField_value(%eax),%eax # eax<- msw
3331 SET_VREG_WORD %ecx rINST 0
3332 FETCH_INST_OPCODE 2 %ecx
3333 SET_VREG_WORD %eax rINST 1
3338 * Go resolve the field
3340 .LOP_SGET_WIDE_resolve:
3342 movzwl 2(rPC),%eax # eax<- field ref BBBB
3343 movl offThread_method(%ecx),%ecx # ecx<- current method
3344 EXPORT_PC # could throw, need to export
3345 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz
3346 movl %eax,OUT_ARG1(%esp)
3347 movl %ecx,OUT_ARG0(%esp)
3349 call dvmResolveStaticField # eax<- resolved StaticField ptr
3352 jne .LOP_SGET_WIDE_finish # success, continue
3353 jmp common_exceptionThrown # no, handle exception
3355 /* ------------------------------ */
3356 .L_OP_SGET_OBJECT: /* 0x62 */
3357 /* File: x86/OP_SGET_OBJECT.S */
3358 /* File: x86/OP_SGET.S */
3360 * General 32-bit SGET handler.
3362 * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short
3364 /* op vAA, field@BBBB */
3366 movzwl 2(rPC),%eax # eax<- field ref BBBB
3367 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex
3368 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields
3369 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr
3370 testl %eax,%eax # resolved entry null?
3371 je .LOP_SGET_OBJECT_resolve # if not, make it so
3372 .LOP_SGET_OBJECT_finish: # field ptr in eax
3373 movl offStaticField_value(%eax),%eax
3374 FETCH_INST_OPCODE 2 %ecx
3380 * Go resolve the field
3382 .LOP_SGET_OBJECT_resolve:
3384 movzwl 2(rPC),%eax # eax<- field ref BBBB
3385 movl offThread_method(%ecx),%ecx # ecx<- current method
3386 EXPORT_PC # could throw, need to export
3387 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz
3388 movl %eax,OUT_ARG1(%esp)
3389 movl %ecx,OUT_ARG0(%esp)
3391 call dvmResolveStaticField # eax<- resolved StaticField ptr
3394 jne .LOP_SGET_OBJECT_finish # success, continue
3395 jmp common_exceptionThrown # no, handle exception
3398 /* ------------------------------ */
3399 .L_OP_SGET_BOOLEAN: /* 0x63 */
3400 /* File: x86/OP_SGET_BOOLEAN.S */
3401 /* File: x86/OP_SGET.S */
3403 * General 32-bit SGET handler.
3405 * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short
3407 /* op vAA, field@BBBB */
3409 movzwl 2(rPC),%eax # eax<- field ref BBBB
3410 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex
3411 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields
3412 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr
3413 testl %eax,%eax # resolved entry null?
3414 je .LOP_SGET_BOOLEAN_resolve # if not, make it so
3415 .LOP_SGET_BOOLEAN_finish: # field ptr in eax
3416 movl offStaticField_value(%eax),%eax
3417 FETCH_INST_OPCODE 2 %ecx
3423 * Go resolve the field
3425 .LOP_SGET_BOOLEAN_resolve:
3427 movzwl 2(rPC),%eax # eax<- field ref BBBB
3428 movl offThread_method(%ecx),%ecx # ecx<- current method
3429 EXPORT_PC # could throw, need to export
3430 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz
3431 movl %eax,OUT_ARG1(%esp)
3432 movl %ecx,OUT_ARG0(%esp)
3434 call dvmResolveStaticField # eax<- resolved StaticField ptr
3437 jne .LOP_SGET_BOOLEAN_finish # success, continue
3438 jmp common_exceptionThrown # no, handle exception
3441 /* ------------------------------ */
3442 .L_OP_SGET_BYTE: /* 0x64 */
3443 /* File: x86/OP_SGET_BYTE.S */
3444 /* File: x86/OP_SGET.S */
3446 * General 32-bit SGET handler.
3448 * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short
3450 /* op vAA, field@BBBB */
3452 movzwl 2(rPC),%eax # eax<- field ref BBBB
3453 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex
3454 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields
3455 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr
3456 testl %eax,%eax # resolved entry null?
3457 je .LOP_SGET_BYTE_resolve # if not, make it so
3458 .LOP_SGET_BYTE_finish: # field ptr in eax
3459 movl offStaticField_value(%eax),%eax
3460 FETCH_INST_OPCODE 2 %ecx
3466 * Go resolve the field
3468 .LOP_SGET_BYTE_resolve:
3470 movzwl 2(rPC),%eax # eax<- field ref BBBB
3471 movl offThread_method(%ecx),%ecx # ecx<- current method
3472 EXPORT_PC # could throw, need to export
3473 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz
3474 movl %eax,OUT_ARG1(%esp)
3475 movl %ecx,OUT_ARG0(%esp)
3477 call dvmResolveStaticField # eax<- resolved StaticField ptr
3480 jne .LOP_SGET_BYTE_finish # success, continue
3481 jmp common_exceptionThrown # no, handle exception
3484 /* ------------------------------ */
3485 .L_OP_SGET_CHAR: /* 0x65 */
3486 /* File: x86/OP_SGET_CHAR.S */
3487 /* File: x86/OP_SGET.S */
3489 * General 32-bit SGET handler.
3491 * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short
3493 /* op vAA, field@BBBB */
3495 movzwl 2(rPC),%eax # eax<- field ref BBBB
3496 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex
3497 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields
3498 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr
3499 testl %eax,%eax # resolved entry null?
3500 je .LOP_SGET_CHAR_resolve # if not, make it so
3501 .LOP_SGET_CHAR_finish: # field ptr in eax
3502 movl offStaticField_value(%eax),%eax
3503 FETCH_INST_OPCODE 2 %ecx
3509 * Go resolve the field
3511 .LOP_SGET_CHAR_resolve:
3513 movzwl 2(rPC),%eax # eax<- field ref BBBB
3514 movl offThread_method(%ecx),%ecx # ecx<- current method
3515 EXPORT_PC # could throw, need to export
3516 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz
3517 movl %eax,OUT_ARG1(%esp)
3518 movl %ecx,OUT_ARG0(%esp)
3520 call dvmResolveStaticField # eax<- resolved StaticField ptr
3523 jne .LOP_SGET_CHAR_finish # success, continue
3524 jmp common_exceptionThrown # no, handle exception
3527 /* ------------------------------ */
3528 .L_OP_SGET_SHORT: /* 0x66 */
3529 /* File: x86/OP_SGET_SHORT.S */
3530 /* File: x86/OP_SGET.S */
3532 * General 32-bit SGET handler.
3534 * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short
3536 /* op vAA, field@BBBB */
3538 movzwl 2(rPC),%eax # eax<- field ref BBBB
3539 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex
3540 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields
3541 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr
3542 testl %eax,%eax # resolved entry null?
3543 je .LOP_SGET_SHORT_resolve # if not, make it so
3544 .LOP_SGET_SHORT_finish: # field ptr in eax
3545 movl offStaticField_value(%eax),%eax
3546 FETCH_INST_OPCODE 2 %ecx
3552 * Go resolve the field
3554 .LOP_SGET_SHORT_resolve:
3556 movzwl 2(rPC),%eax # eax<- field ref BBBB
3557 movl offThread_method(%ecx),%ecx # ecx<- current method
3558 EXPORT_PC # could throw, need to export
3559 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz
3560 movl %eax,OUT_ARG1(%esp)
3561 movl %ecx,OUT_ARG0(%esp)
3563 call dvmResolveStaticField # eax<- resolved StaticField ptr
3566 jne .LOP_SGET_SHORT_finish # success, continue
3567 jmp common_exceptionThrown # no, handle exception
3570 /* ------------------------------ */
3571 .L_OP_SPUT: /* 0x67 */
3572 /* File: x86/OP_SPUT.S */
3574 * General 32-bit SPUT handler.
3576 * for: sput, sput-boolean, sput-byte, sput-char, sput-short
3578 /* op vAA, field@BBBB */
3580 movzwl 2(rPC),%eax # eax<- field ref BBBB
3581 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex
3582 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields
3583 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr
3584 testl %eax,%eax # resolved entry null?
3585 je .LOP_SPUT_resolve # if not, make it so
3586 .LOP_SPUT_finish: # field ptr in eax
3587 GET_VREG_R rINST rINST
3588 FETCH_INST_OPCODE 2 %ecx
3590 movl rINST,offStaticField_value(%eax)
3594 * Go resolve the field
3598 movzwl 2(rPC),%eax # eax<- field ref BBBB
3599 movl offThread_method(%ecx),%ecx # ecx<- current method
3600 EXPORT_PC # could throw, need to export
3601 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz
3602 movl %eax,OUT_ARG1(%esp)
3603 movl %ecx,OUT_ARG0(%esp)
3605 call dvmResolveStaticField # eax<- resolved StaticField ptr
3608 jne .LOP_SPUT_finish # success, continue
3609 jmp common_exceptionThrown # no, handle exception
3611 /* ------------------------------ */
3612 .L_OP_SPUT_WIDE: /* 0x68 */
3613 /* File: x86/OP_SPUT_WIDE.S */
3615 * General 32-bit SPUT handler.
3617 * for: sput, sput-object, sput-boolean, sput-byte, sput-char, sput-short
3619 /* op vAA, field@BBBB */
3621 movzwl 2(rPC),%eax # eax<- field ref BBBB
3622 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex
3623 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields
3624 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr
3625 testl %eax,%eax # resolved entry null?
3626 je .LOP_SPUT_WIDE_resolve # if not, make it so
3627 .LOP_SPUT_WIDE_finish: # field ptr in eax
3628 GET_VREG_WORD %ecx rINST 0 # rINST<- lsw
3629 GET_VREG_WORD rINST rINST 1 # ecx<- msw
3630 movl %ecx,offStaticField_value(%eax)
3631 FETCH_INST_OPCODE 2 %ecx
3632 movl rINST,4+offStaticField_value(%eax)
3637 * Go resolve the field
3639 .LOP_SPUT_WIDE_resolve:
3641 movzwl 2(rPC),%eax # eax<- field ref BBBB
3642 movl offThread_method(%ecx),%ecx # ecx<- current method
3643 EXPORT_PC # could throw, need to export
3644 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz
3645 movl %eax,OUT_ARG1(%esp)
3646 movl %ecx,OUT_ARG0(%esp)
3648 call dvmResolveStaticField # eax<- resolved StaticField ptr
3651 jne .LOP_SPUT_WIDE_finish # success, continue
3652 jmp common_exceptionThrown # no, handle exception
3654 /* ------------------------------ */
3655 .L_OP_SPUT_OBJECT: /* 0x69 */
3656 /* File: x86/OP_SPUT_OBJECT.S */
3658 * SPUT object handler.
3660 /* op vAA, field@BBBB */
3662 movzwl 2(rPC),%eax # eax<- field ref BBBB
3663 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex
3664 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields
3665 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField
3666 testl %eax,%eax # resolved entry null?
3667 je .LOP_SPUT_OBJECT_resolve # if not, make it so
3668 .LOP_SPUT_OBJECT_finish: # field ptr in eax
3669 movzbl rINSTbl,%ecx # ecx<- AA
3670 GET_VREG_R %ecx %ecx
3671 movl %ecx,offStaticField_value(%eax) # do the store
3672 testl %ecx,%ecx # stored null object ptr?
3673 je 1f # skip card mark if null
3675 movl offField_clazz(%eax),%eax # eax<- method->clazz
3676 movl offThread_cardTable(%ecx),%ecx # get card table base
3677 shrl $GC_CARD_SHIFT,%eax # head to card number
3678 movb %cl,(%ecx,%eax) # mark card
3680 FETCH_INST_OPCODE 2 %ecx
3684 .LOP_SPUT_OBJECT_resolve:
3686 movzwl 2(rPC),%eax # eax<- field ref BBBB
3687 movl offThread_method(%ecx),%ecx # ecx<- current method
3688 EXPORT_PC # could throw, need to export
3689 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz
3690 movl %eax,OUT_ARG1(%esp)
3691 movl %ecx,OUT_ARG0(%esp)
3693 call dvmResolveStaticField # eax<- resolved StaticField ptr
3696 jne .LOP_SPUT_OBJECT_finish # success, continue
3697 jmp common_exceptionThrown # no, handle exception
3699 /* ------------------------------ */
3700 .L_OP_SPUT_BOOLEAN: /* 0x6a */
3701 /* File: x86/OP_SPUT_BOOLEAN.S */
3702 /* File: x86/OP_SPUT.S */
3704 * General 32-bit SPUT handler.
3706 * for: sput, sput-boolean, sput-byte, sput-char, sput-short
3708 /* op vAA, field@BBBB */
3710 movzwl 2(rPC),%eax # eax<- field ref BBBB
3711 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex
3712 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields
3713 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr
3714 testl %eax,%eax # resolved entry null?
3715 je .LOP_SPUT_BOOLEAN_resolve # if not, make it so
3716 .LOP_SPUT_BOOLEAN_finish: # field ptr in eax
3717 GET_VREG_R rINST rINST
3718 FETCH_INST_OPCODE 2 %ecx
3720 movl rINST,offStaticField_value(%eax)
3724 * Go resolve the field
3726 .LOP_SPUT_BOOLEAN_resolve:
3728 movzwl 2(rPC),%eax # eax<- field ref BBBB
3729 movl offThread_method(%ecx),%ecx # ecx<- current method
3730 EXPORT_PC # could throw, need to export
3731 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz
3732 movl %eax,OUT_ARG1(%esp)
3733 movl %ecx,OUT_ARG0(%esp)
3735 call dvmResolveStaticField # eax<- resolved StaticField ptr
3738 jne .LOP_SPUT_BOOLEAN_finish # success, continue
3739 jmp common_exceptionThrown # no, handle exception
3742 /* ------------------------------ */
3743 .L_OP_SPUT_BYTE: /* 0x6b */
3744 /* File: x86/OP_SPUT_BYTE.S */
3745 /* File: x86/OP_SPUT.S */
3747 * General 32-bit SPUT handler.
3749 * for: sput, sput-boolean, sput-byte, sput-char, sput-short
3751 /* op vAA, field@BBBB */
3753 movzwl 2(rPC),%eax # eax<- field ref BBBB
3754 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex
3755 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields
3756 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr
3757 testl %eax,%eax # resolved entry null?
3758 je .LOP_SPUT_BYTE_resolve # if not, make it so
3759 .LOP_SPUT_BYTE_finish: # field ptr in eax
3760 GET_VREG_R rINST rINST
3761 FETCH_INST_OPCODE 2 %ecx
3763 movl rINST,offStaticField_value(%eax)
3767 * Go resolve the field
3769 .LOP_SPUT_BYTE_resolve:
3771 movzwl 2(rPC),%eax # eax<- field ref BBBB
3772 movl offThread_method(%ecx),%ecx # ecx<- current method
3773 EXPORT_PC # could throw, need to export
3774 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz
3775 movl %eax,OUT_ARG1(%esp)
3776 movl %ecx,OUT_ARG0(%esp)
3778 call dvmResolveStaticField # eax<- resolved StaticField ptr
3781 jne .LOP_SPUT_BYTE_finish # success, continue
3782 jmp common_exceptionThrown # no, handle exception
3785 /* ------------------------------ */
3786 .L_OP_SPUT_CHAR: /* 0x6c */
3787 /* File: x86/OP_SPUT_CHAR.S */
3788 /* File: x86/OP_SPUT.S */
3790 * General 32-bit SPUT handler.
3792 * for: sput, sput-boolean, sput-byte, sput-char, sput-short
3794 /* op vAA, field@BBBB */
3796 movzwl 2(rPC),%eax # eax<- field ref BBBB
3797 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex
3798 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields
3799 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr
3800 testl %eax,%eax # resolved entry null?
3801 je .LOP_SPUT_CHAR_resolve # if not, make it so
3802 .LOP_SPUT_CHAR_finish: # field ptr in eax
3803 GET_VREG_R rINST rINST
3804 FETCH_INST_OPCODE 2 %ecx
3806 movl rINST,offStaticField_value(%eax)
3810 * Go resolve the field
3812 .LOP_SPUT_CHAR_resolve:
3814 movzwl 2(rPC),%eax # eax<- field ref BBBB
3815 movl offThread_method(%ecx),%ecx # ecx<- current method
3816 EXPORT_PC # could throw, need to export
3817 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz
3818 movl %eax,OUT_ARG1(%esp)
3819 movl %ecx,OUT_ARG0(%esp)
3821 call dvmResolveStaticField # eax<- resolved StaticField ptr
3824 jne .LOP_SPUT_CHAR_finish # success, continue
3825 jmp common_exceptionThrown # no, handle exception
3828 /* ------------------------------ */
3829 .L_OP_SPUT_SHORT: /* 0x6d */
3830 /* File: x86/OP_SPUT_SHORT.S */
3831 /* File: x86/OP_SPUT.S */
3833 * General 32-bit SPUT handler.
3835 * for: sput, sput-boolean, sput-byte, sput-char, sput-short
3837 /* op vAA, field@BBBB */
3839 movzwl 2(rPC),%eax # eax<- field ref BBBB
3840 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex
3841 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields
3842 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr
3843 testl %eax,%eax # resolved entry null?
3844 je .LOP_SPUT_SHORT_resolve # if not, make it so
3845 .LOP_SPUT_SHORT_finish: # field ptr in eax
3846 GET_VREG_R rINST rINST
3847 FETCH_INST_OPCODE 2 %ecx
3849 movl rINST,offStaticField_value(%eax)
3853 * Go resolve the field
3855 .LOP_SPUT_SHORT_resolve:
3857 movzwl 2(rPC),%eax # eax<- field ref BBBB
3858 movl offThread_method(%ecx),%ecx # ecx<- current method
3859 EXPORT_PC # could throw, need to export
3860 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz
3861 movl %eax,OUT_ARG1(%esp)
3862 movl %ecx,OUT_ARG0(%esp)
3864 call dvmResolveStaticField # eax<- resolved StaticField ptr
3867 jne .LOP_SPUT_SHORT_finish # success, continue
3868 jmp common_exceptionThrown # no, handle exception
3871 /* ------------------------------ */
3872 .L_OP_INVOKE_VIRTUAL: /* 0x6e */
3873 /* File: x86/OP_INVOKE_VIRTUAL.S */
3876 * Handle a virtual method call.
3878 * for: invoke-virtual, invoke-virtual/range
3880 /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */
3881 /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */
3883 movzwl 2(rPC),%ecx # ecx<- BBBB
3884 movl offThread_methodClassDex(%eax),%eax # eax<- pDvmDex
3886 movl offDvmDex_pResMethods(%eax),%eax # eax<- pDvmDex->pResMethods
3887 movl (%eax,%ecx,4),%eax # eax<- resolved baseMethod
3888 testl %eax,%eax # already resolved?
3889 jne .LOP_INVOKE_VIRTUAL_continue # yes, continue
3891 movl %ecx,OUT_ARG1(%esp) # arg1<- ref
3892 movl offThread_method(%eax),%eax # eax<- self->method
3893 movl offMethod_clazz(%eax),%eax # ecx<- method->clazz
3894 movl %eax,OUT_ARG0(%esp) # arg0<- clazz
3895 movl $METHOD_VIRTUAL,OUT_ARG2(%esp) # arg2<- flags
3896 call dvmResolveMethod # eax<- call(clazz, ref, flags)
3897 testl %eax,%eax # got null?
3898 jne .LOP_INVOKE_VIRTUAL_continue # no, continue
3899 jmp common_exceptionThrown # yes, handle exception
3902 * eax = resolved base method
3905 .LOP_INVOKE_VIRTUAL_continue:
3906 movzwl 4(rPC),%ecx # ecx<- GFED or CCCC
3908 andl $0xf,%ecx # ecx<- D (or stays CCCC)
3910 GET_VREG_R %ecx %ecx # ecx<- "this"
3911 movzwl offMethod_methodIndex(%eax),%eax # eax<- baseMethod->methodIndex
3912 testl %ecx,%ecx # null this?
3913 je common_errNullObject # go if so
3914 movl offObject_clazz(%ecx),%ecx # ecx<- thisPtr->clazz
3915 movl offClassObject_vtable(%ecx),%ecx # ecx<- thisPtr->clazz->vtable
3916 movl (%ecx,%eax,4),%eax # eax<- vtable[methodIndex]
3917 jmp common_invokeMethodNoRange
3919 /* ------------------------------ */
3920 .L_OP_INVOKE_SUPER: /* 0x6f */
3921 /* File: x86/OP_INVOKE_SUPER.S */
3923 * Handle a "super" method call.
3925 * for: invoke-super, invoke-super/range
3927 /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */
3928 /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */
3930 movzwl 2(rPC),%eax # eax<- BBBB
3931 movl offThread_methodClassDex(rINST),%ecx # ecx<- pDvmDex
3933 movl offDvmDex_pResMethods(%ecx),%ecx # ecx<- pDvmDex->pResMethods
3934 movl (%ecx,%eax,4),%ecx # ecx<- resolved baseMethod
3935 movl offThread_method(rINST),%eax # eax<- method
3936 movzwl 4(rPC),rINST # rINST<- GFED or CCCC
3938 andl $0xf,rINST # rINST<- D (or stays CCCC)
3940 GET_VREG_R rINST rINST # rINST<- "this" ptr
3941 testl rINST,rINST # null "this"?
3942 je common_errNullObject # yes, throw
3943 movl offMethod_clazz(%eax),%eax # eax<- method->clazz
3944 testl %ecx,%ecx # already resolved?
3945 je .LOP_INVOKE_SUPER_resolve
3948 * ecx = resolved base method [r0]
3949 * eax = method->clazz [r9]
3951 .LOP_INVOKE_SUPER_continue:
3952 movl offClassObject_super(%eax),%eax # eax<- method->clazz->super
3953 movzwl offMethod_methodIndex(%ecx),%ecx # ecx<- baseMthod->methodIndex
3954 cmpl offClassObject_vtableCount(%eax),%ecx # compare(methodIndex,vtableCount)
3955 jae .LOP_INVOKE_SUPER_nsm # method not present in superclass
3956 movl offClassObject_vtable(%eax),%eax # eax<- ...clazz->super->vtable
3957 movl (%eax,%ecx,4),%eax # eax<- vtable[methodIndex]
3958 jmp common_invokeMethodNoRange
3962 * ecx = null (needs to be resolved base method)
3963 * eax = method->clazz
3965 .LOP_INVOKE_SUPER_resolve:
3966 SPILL_TMP1(%eax) # method->clazz
3967 movl %eax,OUT_ARG0(%esp) # arg0<- method->clazz
3968 movzwl 2(rPC),%ecx # ecx<- BBBB
3969 movl $METHOD_VIRTUAL,OUT_ARG2(%esp) # arg2<- resolver method type
3970 movl %ecx,OUT_ARG1(%esp) # arg1<- ref
3971 call dvmResolveMethod # eax<- call(clazz, ref, flags)
3972 testl %eax,%eax # got null?
3973 movl %eax,%ecx # ecx<- resolved base method
3974 UNSPILL_TMP1(%eax) # restore method->clazz
3975 jne .LOP_INVOKE_SUPER_continue # good to go - continue
3976 jmp common_exceptionThrown # handle exception
3979 * Throw a NoSuchMethodError with the method name as the message.
3980 * ecx = resolved base method
3982 .LOP_INVOKE_SUPER_nsm:
3983 movl offMethod_name(%ecx),%eax
3984 jmp common_errNoSuchMethod
3986 /* ------------------------------ */
3987 .L_OP_INVOKE_DIRECT: /* 0x70 */
3988 /* File: x86/OP_INVOKE_DIRECT.S */
3990 * Handle a direct method call.
3992 * (We could defer the "is 'this' pointer null" test to the common
3993 * method invocation code, and use a flag to indicate that static
3994 * calls don't count. If we do this as part of copying the arguments
3995 * out we could avoiding loading the first arg twice.)
3997 * for: invoke-direct, invoke-direct/range
3999 /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */
4000 /* op {vCCCC..v(CCCC+AA-1)}, meth@BBBB */
4002 movzwl 2(rPC),%eax # eax<- BBBB
4003 movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex
4005 movl offDvmDex_pResMethods(%ecx),%ecx # ecx<- pDvmDex->pResMethods
4006 movzwl 4(rPC),rIBASE # rIBASE<- GFED or CCCC
4007 movl (%ecx,%eax,4),%eax # eax<- resolved methodToCall
4009 andl $0xf,rIBASE # rIBASE<- D (or stays CCCC)
4011 testl %eax,%eax # already resolved?
4012 GET_VREG_R %ecx rIBASE # ecx<- "this" ptr
4013 je .LOP_INVOKE_DIRECT_resolve # not resolved, do it now
4014 .LOP_INVOKE_DIRECT_finish:
4015 testl %ecx,%ecx # null "this"?
4016 jne common_invokeMethodNoRange # no, continue on
4017 jmp common_errNullObject
4021 * TMP_SPILL <- "this" register
4022 * Things a bit ugly on this path, but it's the less
4023 * frequent one. We'll have to do some reloading.
4025 .LOP_INVOKE_DIRECT_resolve:
4028 movl offThread_method(%ecx),%ecx # ecx<- self->method
4029 movzwl 2(rPC),%eax # reference (BBBB or CCCC)
4030 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz
4031 movl $METHOD_DIRECT,OUT_ARG2(%esp)
4032 movl %eax,OUT_ARG1(%esp)
4033 movl %ecx,OUT_ARG0(%esp)
4034 call dvmResolveMethod # eax<- call(clazz, ref, flags)
4037 jne .LOP_INVOKE_DIRECT_finish
4038 jmp common_exceptionThrown
4040 /* ------------------------------ */
4041 .L_OP_INVOKE_STATIC: /* 0x71 */
4042 /* File: x86/OP_INVOKE_STATIC.S */
4044 * Handle a static method call.
4046 * for: invoke-static, invoke-static/range
4048 /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */
4049 /* op {vCCCC..v(CCCC+AA-1)}, meth@BBBB */
4051 movzwl 2(rPC),%eax # eax<- BBBB
4052 movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex
4054 movl offDvmDex_pResMethods(%ecx),%ecx # ecx<- pDvmDex->pResMethods
4055 movl (%ecx,%eax,4),%eax # eax<- resolved methodToCall
4057 jne common_invokeMethodNoRange
4059 movl offThread_method(%ecx),%ecx # ecx<- self->method
4061 movl offMethod_clazz(%ecx),%ecx# ecx<- method->clazz
4062 movl %eax,OUT_ARG1(%esp) # arg1<- BBBB
4063 movl %ecx,OUT_ARG0(%esp) # arg0<- clazz
4064 movl $METHOD_STATIC,%eax
4065 movl %eax,OUT_ARG2(%esp) # arg2<- flags
4066 call dvmResolveMethod # call(clazz,ref,flags)
4067 testl %eax,%eax # got null?
4068 jne common_invokeMethodNoRange
4069 jmp common_exceptionThrown
4071 /* ------------------------------ */
4072 .L_OP_INVOKE_INTERFACE: /* 0x72 */
4073 /* File: x86/OP_INVOKE_INTERFACE.S */
4075 * Handle an interface method call.
4077 * for: invoke-interface, invoke-interface/range
4079 /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */
4080 /* op {vCCCC..v(CCCC+AA-1)}, meth@BBBB */
4081 movzwl 4(rPC),%eax # eax<- FEDC or CCCC
4084 andl $0xf,%eax # eax<- C (or stays CCCC)
4086 GET_VREG_R %eax %eax # eax<- "this"
4088 testl %eax,%eax # null this?
4089 je common_errNullObject # yes, fail
4090 movl offObject_clazz(%eax),%eax# eax<- thisPtr->clazz
4091 movl %eax,OUT_ARG0(%esp) # arg0<- class
4092 movl offThread_methodClassDex(%ecx),%eax # eax<- methodClassDex
4093 movl offThread_method(%ecx),%ecx # ecx<- method
4094 movl %eax,OUT_ARG3(%esp) # arg3<- dex
4095 movzwl 2(rPC),%eax # eax<- BBBB
4096 movl %ecx,OUT_ARG2(%esp) # arg2<- method
4097 movl %eax,OUT_ARG1(%esp) # arg1<- BBBB
4098 call dvmFindInterfaceMethodInCache # eax<- call(class, ref, method, dex)
4100 je common_exceptionThrown
4101 jmp common_invokeMethodNoRange
4103 /* ------------------------------ */
4104 .L_OP_UNUSED_73: /* 0x73 */
4105 /* File: x86/OP_UNUSED_73.S */
4106 /* File: x86/unused.S */
4110 /* ------------------------------ */
4111 .L_OP_INVOKE_VIRTUAL_RANGE: /* 0x74 */
4112 /* File: x86/OP_INVOKE_VIRTUAL_RANGE.S */
4113 /* File: x86/OP_INVOKE_VIRTUAL.S */
4116 * Handle a virtual method call.
4118 * for: invoke-virtual, invoke-virtual/range
4120 /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */
4121 /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */
4123 movzwl 2(rPC),%ecx # ecx<- BBBB
4124 movl offThread_methodClassDex(%eax),%eax # eax<- pDvmDex
4126 movl offDvmDex_pResMethods(%eax),%eax # eax<- pDvmDex->pResMethods
4127 movl (%eax,%ecx,4),%eax # eax<- resolved baseMethod
4128 testl %eax,%eax # already resolved?
4129 jne .LOP_INVOKE_VIRTUAL_RANGE_continue # yes, continue
4131 movl %ecx,OUT_ARG1(%esp) # arg1<- ref
4132 movl offThread_method(%eax),%eax # eax<- self->method
4133 movl offMethod_clazz(%eax),%eax # ecx<- method->clazz
4134 movl %eax,OUT_ARG0(%esp) # arg0<- clazz
4135 movl $METHOD_VIRTUAL,OUT_ARG2(%esp) # arg2<- flags
4136 call dvmResolveMethod # eax<- call(clazz, ref, flags)
4137 testl %eax,%eax # got null?
4138 jne .LOP_INVOKE_VIRTUAL_RANGE_continue # no, continue
4139 jmp common_exceptionThrown # yes, handle exception
4142 * eax = resolved base method
4145 .LOP_INVOKE_VIRTUAL_RANGE_continue:
4146 movzwl 4(rPC),%ecx # ecx<- GFED or CCCC
4148 andl $0xf,%ecx # ecx<- D (or stays CCCC)
4150 GET_VREG_R %ecx %ecx # ecx<- "this"
4151 movzwl offMethod_methodIndex(%eax),%eax # eax<- baseMethod->methodIndex
4152 testl %ecx,%ecx # null this?
4153 je common_errNullObject # go if so
4154 movl offObject_clazz(%ecx),%ecx # ecx<- thisPtr->clazz
4155 movl offClassObject_vtable(%ecx),%ecx # ecx<- thisPtr->clazz->vtable
4156 movl (%ecx,%eax,4),%eax # eax<- vtable[methodIndex]
4157 jmp common_invokeMethodRange
4160 /* ------------------------------ */
4161 .L_OP_INVOKE_SUPER_RANGE: /* 0x75 */
4162 /* File: x86/OP_INVOKE_SUPER_RANGE.S */
4163 /* File: x86/OP_INVOKE_SUPER.S */
4165 * Handle a "super" method call.
4167 * for: invoke-super, invoke-super/range
4169 /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */
4170 /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */
4172 movzwl 2(rPC),%eax # eax<- BBBB
4173 movl offThread_methodClassDex(rINST),%ecx # ecx<- pDvmDex
4175 movl offDvmDex_pResMethods(%ecx),%ecx # ecx<- pDvmDex->pResMethods
4176 movl (%ecx,%eax,4),%ecx # ecx<- resolved baseMethod
4177 movl offThread_method(rINST),%eax # eax<- method
4178 movzwl 4(rPC),rINST # rINST<- GFED or CCCC
4180 andl $0xf,rINST # rINST<- D (or stays CCCC)
4182 GET_VREG_R rINST rINST # rINST<- "this" ptr
4183 testl rINST,rINST # null "this"?
4184 je common_errNullObject # yes, throw
4185 movl offMethod_clazz(%eax),%eax # eax<- method->clazz
4186 testl %ecx,%ecx # already resolved?
4187 je .LOP_INVOKE_SUPER_RANGE_resolve
4190 * ecx = resolved base method [r0]
4191 * eax = method->clazz [r9]
4193 .LOP_INVOKE_SUPER_RANGE_continue:
4194 movl offClassObject_super(%eax),%eax # eax<- method->clazz->super
4195 movzwl offMethod_methodIndex(%ecx),%ecx # ecx<- baseMthod->methodIndex
4196 cmpl offClassObject_vtableCount(%eax),%ecx # compare(methodIndex,vtableCount)
4197 jae .LOP_INVOKE_SUPER_RANGE_nsm # method not present in superclass
4198 movl offClassObject_vtable(%eax),%eax # eax<- ...clazz->super->vtable
4199 movl (%eax,%ecx,4),%eax # eax<- vtable[methodIndex]
4200 jmp common_invokeMethodRange
4204 * ecx = null (needs to be resolved base method)
4205 * eax = method->clazz
4207 .LOP_INVOKE_SUPER_RANGE_resolve:
4208 SPILL_TMP1(%eax) # method->clazz
4209 movl %eax,OUT_ARG0(%esp) # arg0<- method->clazz
4210 movzwl 2(rPC),%ecx # ecx<- BBBB
4211 movl $METHOD_VIRTUAL,OUT_ARG2(%esp) # arg2<- resolver method type
4212 movl %ecx,OUT_ARG1(%esp) # arg1<- ref
4213 call dvmResolveMethod # eax<- call(clazz, ref, flags)
4214 testl %eax,%eax # got null?
4215 movl %eax,%ecx # ecx<- resolved base method
4216 UNSPILL_TMP1(%eax) # restore method->clazz
4217 jne .LOP_INVOKE_SUPER_RANGE_continue # good to go - continue
4218 jmp common_exceptionThrown # handle exception
4221 * Throw a NoSuchMethodError with the method name as the message.
4222 * ecx = resolved base method
4224 .LOP_INVOKE_SUPER_RANGE_nsm:
4225 movl offMethod_name(%ecx),%eax
4226 jmp common_errNoSuchMethod
4229 /* ------------------------------ */
4230 .L_OP_INVOKE_DIRECT_RANGE: /* 0x76 */
4231 /* File: x86/OP_INVOKE_DIRECT_RANGE.S */
4232 /* File: x86/OP_INVOKE_DIRECT.S */
4234 * Handle a direct method call.
4236 * (We could defer the "is 'this' pointer null" test to the common
4237 * method invocation code, and use a flag to indicate that static
4238 * calls don't count. If we do this as part of copying the arguments
4239 * out we could avoiding loading the first arg twice.)
4241 * for: invoke-direct, invoke-direct/range
4243 /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */
4244 /* op {vCCCC..v(CCCC+AA-1)}, meth@BBBB */
4246 movzwl 2(rPC),%eax # eax<- BBBB
4247 movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex
4249 movl offDvmDex_pResMethods(%ecx),%ecx # ecx<- pDvmDex->pResMethods
4250 movzwl 4(rPC),rIBASE # rIBASE<- GFED or CCCC
4251 movl (%ecx,%eax,4),%eax # eax<- resolved methodToCall
4253 andl $0xf,rIBASE # rIBASE<- D (or stays CCCC)
4255 testl %eax,%eax # already resolved?
4256 GET_VREG_R %ecx rIBASE # ecx<- "this" ptr
4257 je .LOP_INVOKE_DIRECT_RANGE_resolve # not resolved, do it now
4258 .LOP_INVOKE_DIRECT_RANGE_finish:
4259 testl %ecx,%ecx # null "this"?
4260 jne common_invokeMethodRange # no, continue on
4261 jmp common_errNullObject
4265 * TMP_SPILL <- "this" register
4266 * Things a bit ugly on this path, but it's the less
4267 * frequent one. We'll have to do some reloading.
4269 .LOP_INVOKE_DIRECT_RANGE_resolve:
4272 movl offThread_method(%ecx),%ecx # ecx<- self->method
4273 movzwl 2(rPC),%eax # reference (BBBB or CCCC)
4274 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz
4275 movl $METHOD_DIRECT,OUT_ARG2(%esp)
4276 movl %eax,OUT_ARG1(%esp)
4277 movl %ecx,OUT_ARG0(%esp)
4278 call dvmResolveMethod # eax<- call(clazz, ref, flags)
4281 jne .LOP_INVOKE_DIRECT_RANGE_finish
4282 jmp common_exceptionThrown
4285 /* ------------------------------ */
4286 .L_OP_INVOKE_STATIC_RANGE: /* 0x77 */
4287 /* File: x86/OP_INVOKE_STATIC_RANGE.S */
4288 /* File: x86/OP_INVOKE_STATIC.S */
4290 * Handle a static method call.
4292 * for: invoke-static, invoke-static/range
4294 /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */
4295 /* op {vCCCC..v(CCCC+AA-1)}, meth@BBBB */
4297 movzwl 2(rPC),%eax # eax<- BBBB
4298 movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex
4300 movl offDvmDex_pResMethods(%ecx),%ecx # ecx<- pDvmDex->pResMethods
4301 movl (%ecx,%eax,4),%eax # eax<- resolved methodToCall
4303 jne common_invokeMethodRange
4305 movl offThread_method(%ecx),%ecx # ecx<- self->method
4307 movl offMethod_clazz(%ecx),%ecx# ecx<- method->clazz
4308 movl %eax,OUT_ARG1(%esp) # arg1<- BBBB
4309 movl %ecx,OUT_ARG0(%esp) # arg0<- clazz
4310 movl $METHOD_STATIC,%eax
4311 movl %eax,OUT_ARG2(%esp) # arg2<- flags
4312 call dvmResolveMethod # call(clazz,ref,flags)
4313 testl %eax,%eax # got null?
4314 jne common_invokeMethodRange
4315 jmp common_exceptionThrown
4318 /* ------------------------------ */
4319 .L_OP_INVOKE_INTERFACE_RANGE: /* 0x78 */
4320 /* File: x86/OP_INVOKE_INTERFACE_RANGE.S */
4321 /* File: x86/OP_INVOKE_INTERFACE.S */
4323 * Handle an interface method call.
4325 * for: invoke-interface, invoke-interface/range
4327 /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */
4328 /* op {vCCCC..v(CCCC+AA-1)}, meth@BBBB */
4329 movzwl 4(rPC),%eax # eax<- FEDC or CCCC
4332 andl $0xf,%eax # eax<- C (or stays CCCC)
4334 GET_VREG_R %eax %eax # eax<- "this"
4336 testl %eax,%eax # null this?
4337 je common_errNullObject # yes, fail
4338 movl offObject_clazz(%eax),%eax# eax<- thisPtr->clazz
4339 movl %eax,OUT_ARG0(%esp) # arg0<- class
4340 movl offThread_methodClassDex(%ecx),%eax # eax<- methodClassDex
4341 movl offThread_method(%ecx),%ecx # ecx<- method
4342 movl %eax,OUT_ARG3(%esp) # arg3<- dex
4343 movzwl 2(rPC),%eax # eax<- BBBB
4344 movl %ecx,OUT_ARG2(%esp) # arg2<- method
4345 movl %eax,OUT_ARG1(%esp) # arg1<- BBBB
4346 call dvmFindInterfaceMethodInCache # eax<- call(class, ref, method, dex)
4348 je common_exceptionThrown
4349 jmp common_invokeMethodRange
4352 /* ------------------------------ */
4353 .L_OP_UNUSED_79: /* 0x79 */
4354 /* File: x86/OP_UNUSED_79.S */
4355 /* File: x86/unused.S */
4359 /* ------------------------------ */
4360 .L_OP_UNUSED_7A: /* 0x7a */
4361 /* File: x86/OP_UNUSED_7A.S */
4362 /* File: x86/unused.S */
4366 /* ------------------------------ */
4367 .L_OP_NEG_INT: /* 0x7b */
4368 /* File: x86/OP_NEG_INT.S */
4369 /* File: x86/unop.S */
4371 * Generic 32-bit unary operation. Provide an "instr" line that
4372 * specifies an instruction that performs "result = op eax".
4375 movzbl rINSTbl,%ecx # ecx<- A+
4376 sarl $4,rINST # rINST<- B
4377 GET_VREG_R %eax rINST # eax<- vB
4378 andb $0xf,%cl # ecx<- A
4383 FETCH_INST_OPCODE 1 %ecx
4388 /* ------------------------------ */
4389 .L_OP_NOT_INT: /* 0x7c */
4390 /* File: x86/OP_NOT_INT.S */
4391 /* File: x86/unop.S */
4393 * Generic 32-bit unary operation. Provide an "instr" line that
4394 * specifies an instruction that performs "result = op eax".
4397 movzbl rINSTbl,%ecx # ecx<- A+
4398 sarl $4,rINST # rINST<- B
4399 GET_VREG_R %eax rINST # eax<- vB
4400 andb $0xf,%cl # ecx<- A
4405 FETCH_INST_OPCODE 1 %ecx
4410 /* ------------------------------ */
4411 .L_OP_NEG_LONG: /* 0x7d */
4412 /* File: x86/OP_NEG_LONG.S */
4414 movzbl rINSTbl,%ecx # ecx<- BA
4415 sarl $4,%ecx # ecx<- B
4416 andb $0xf,rINSTbl # rINST<- A
4417 GET_VREG_WORD %eax %ecx 0 # eax<- v[B+0]
4418 GET_VREG_WORD %ecx %ecx 1 # ecx<- v[B+1]
4422 SET_VREG_WORD %eax rINST 0 # v[A+0]<- eax
4423 FETCH_INST_OPCODE 1 %eax
4424 SET_VREG_WORD %ecx rINST 1 # v[A+1]<- ecx
4428 /* ------------------------------ */
4429 .L_OP_NOT_LONG: /* 0x7e */
4430 /* File: x86/OP_NOT_LONG.S */
4432 movzbl rINSTbl,%ecx # ecx<- BA
4433 sarl $4,%ecx # ecx<- B
4434 andb $0xf,rINSTbl # rINST<- A
4435 GET_VREG_WORD %eax %ecx 0 # eax<- v[B+0]
4436 GET_VREG_WORD %ecx %ecx 1 # ecx<- v[B+1]
4439 SET_VREG_WORD %eax rINST 0 # v[A+0]<- eax
4440 FETCH_INST_OPCODE 1 %eax
4441 SET_VREG_WORD %ecx rINST 1 # v[A+1]<- ecx
4445 /* ------------------------------ */
4446 .L_OP_NEG_FLOAT: /* 0x7f */
4447 /* File: x86/OP_NEG_FLOAT.S */
4448 /* File: x86/fpcvt.S */
4450 * Generic 32-bit FP conversion operation.
4453 movzbl rINSTbl,%ecx # ecx<- A+
4454 sarl $4,rINST # rINST<- B
4455 flds (rFP,rINST,4) # %st0<- vB
4456 andb $0xf,%cl # ecx<- A
4458 fstps (rFP,%ecx,4) # vA<- %st0
4459 FETCH_INST_OPCODE 1 %ecx
4464 /* ------------------------------ */
4465 .L_OP_NEG_DOUBLE: /* 0x80 */
4466 /* File: x86/OP_NEG_DOUBLE.S */
4467 /* File: x86/fpcvt.S */
4469 * Generic 32-bit FP conversion operation.
4472 movzbl rINSTbl,%ecx # ecx<- A+
4473 sarl $4,rINST # rINST<- B
4474 fldl (rFP,rINST,4) # %st0<- vB
4475 andb $0xf,%cl # ecx<- A
4477 fstpl (rFP,%ecx,4) # vA<- %st0
4478 FETCH_INST_OPCODE 1 %ecx
4483 /* ------------------------------ */
4484 .L_OP_INT_TO_LONG: /* 0x81 */
4485 /* File: x86/OP_INT_TO_LONG.S */
4486 /* int to long vA, vB */
4487 movzbl rINSTbl,%eax # eax<- +A
4488 sarl $4,%eax # eax<- B
4489 GET_VREG_R %eax %eax # eax<- vB
4490 andb $0xf,rINSTbl # rINST<- A
4491 SPILL(rIBASE) # cltd trashes rIBASE/edx
4492 cltd # rINST:eax<- sssssssBBBBBBBB
4493 SET_VREG_WORD rIBASE rINST 1 # v[A+1]<- rIBASE/rPC
4494 FETCH_INST_OPCODE 1 %ecx
4496 SET_VREG_WORD %eax rINST 0 # v[A+0]<- %eax
4500 /* ------------------------------ */
4501 .L_OP_INT_TO_FLOAT: /* 0x82 */
4502 /* File: x86/OP_INT_TO_FLOAT.S */
4503 /* File: x86/fpcvt.S */
4505 * Generic 32-bit FP conversion operation.
4508 movzbl rINSTbl,%ecx # ecx<- A+
4509 sarl $4,rINST # rINST<- B
4510 fildl (rFP,rINST,4) # %st0<- vB
4511 andb $0xf,%cl # ecx<- A
4513 fstps (rFP,%ecx,4) # vA<- %st0
4514 FETCH_INST_OPCODE 1 %ecx
4519 /* ------------------------------ */
4520 .L_OP_INT_TO_DOUBLE: /* 0x83 */
4521 /* File: x86/OP_INT_TO_DOUBLE.S */
4522 /* File: x86/fpcvt.S */
4524 * Generic 32-bit FP conversion operation.
4527 movzbl rINSTbl,%ecx # ecx<- A+
4528 sarl $4,rINST # rINST<- B
4529 fildl (rFP,rINST,4) # %st0<- vB
4530 andb $0xf,%cl # ecx<- A
4532 fstpl (rFP,%ecx,4) # vA<- %st0
4533 FETCH_INST_OPCODE 1 %ecx
4538 /* ------------------------------ */
4539 .L_OP_LONG_TO_INT: /* 0x84 */
4540 /* File: x86/OP_LONG_TO_INT.S */
4541 /* we ignore the high word, making this equivalent to a 32-bit reg move */
4542 /* File: x86/OP_MOVE.S */
4543 /* for move, move-object, long-to-int */
4545 movzbl rINSTbl,%eax # eax<- BA
4546 andb $0xf,%al # eax<- A
4547 shrl $4,rINST # rINST<- B
4548 GET_VREG_R rINST rINST
4549 FETCH_INST_OPCODE 1 %ecx
4551 SET_VREG rINST %eax # fp[A]<-fp[B]
4555 /* ------------------------------ */
4556 .L_OP_LONG_TO_FLOAT: /* 0x85 */
4557 /* File: x86/OP_LONG_TO_FLOAT.S */
4558 /* File: x86/fpcvt.S */
4560 * Generic 32-bit FP conversion operation.
4563 movzbl rINSTbl,%ecx # ecx<- A+
4564 sarl $4,rINST # rINST<- B
4565 fildll (rFP,rINST,4) # %st0<- vB
4566 andb $0xf,%cl # ecx<- A
4568 fstps (rFP,%ecx,4) # vA<- %st0
4569 FETCH_INST_OPCODE 1 %ecx
4574 /* ------------------------------ */
4575 .L_OP_LONG_TO_DOUBLE: /* 0x86 */
4576 /* File: x86/OP_LONG_TO_DOUBLE.S */
4577 /* File: x86/fpcvt.S */
4579 * Generic 32-bit FP conversion operation.
4582 movzbl rINSTbl,%ecx # ecx<- A+
4583 sarl $4,rINST # rINST<- B
4584 fildll (rFP,rINST,4) # %st0<- vB
4585 andb $0xf,%cl # ecx<- A
4587 fstpl (rFP,%ecx,4) # vA<- %st0
4588 FETCH_INST_OPCODE 1 %ecx
4593 /* ------------------------------ */
4594 .L_OP_FLOAT_TO_INT: /* 0x87 */
4595 /* File: x86/OP_FLOAT_TO_INT.S */
4596 /* File: x86/cvtfp_int.S */
4597 /* On fp to int conversions, Java requires that
4598 * if the result > maxint, it should be clamped to maxint. If it is less
4599 * than minint, it should be clamped to minint. If it is a nan, the result
4600 * should be zero. Further, the rounding mode is to truncate. This model
4601 * differs from what is delivered normally via the x86 fpu, so we have
4602 * to play some games.
4604 /* float/double to int/long vA, vB */
4605 movzbl rINSTbl,%ecx # ecx<- A+
4606 sarl $4,rINST # rINST<- B
4608 fldl (rFP,rINST,4) # %st0<- vB
4610 flds (rFP,rINST,4) # %st0<- vB
4613 fnstcw LOCAL0_OFFSET(%ebp) # remember original rounding mode
4614 movzwl LOCAL0_OFFSET(%ebp),%eax
4616 movw %ax,LOCAL0_OFFSET+2(%ebp)
4617 fldcw LOCAL0_OFFSET+2(%ebp) # set "to zero" rounding mode
4618 andb $0xf,%cl # ecx<- A
4620 fistpll (rFP,%ecx,4) # convert and store
4622 fistpl (rFP,%ecx,4) # convert and store
4624 fldcw LOCAL0_OFFSET(%ebp) # restore previous rounding mode
4626 movl $0x80000000,%eax
4627 xorl 4(rFP,%ecx,4),%eax
4628 orl (rFP,%ecx,4),%eax
4630 cmpl $0x80000000,(rFP,%ecx,4)
4632 je .LOP_FLOAT_TO_INT_special_case # fix up result
4634 .LOP_FLOAT_TO_INT_finish:
4635 FETCH_INST_OPCODE 1 %ecx
4639 .LOP_FLOAT_TO_INT_special_case:
4642 jp .LOP_FLOAT_TO_INT_isNaN
4643 adcl $-1,(rFP,%ecx,4)
4645 adcl $-1,4(rFP,%ecx,4)
4647 jmp .LOP_FLOAT_TO_INT_finish
4648 .LOP_FLOAT_TO_INT_isNaN:
4649 movl $0,(rFP,%ecx,4)
4651 movl $0,4(rFP,%ecx,4)
4653 jmp .LOP_FLOAT_TO_INT_finish
4656 /* ------------------------------ */
4657 .L_OP_FLOAT_TO_LONG: /* 0x88 */
4658 /* File: x86/OP_FLOAT_TO_LONG.S */
4659 /* File: x86/cvtfp_int.S */
4660 /* On fp to int conversions, Java requires that
4661 * if the result > maxint, it should be clamped to maxint. If it is less
4662 * than minint, it should be clamped to minint. If it is a nan, the result
4663 * should be zero. Further, the rounding mode is to truncate. This model
4664 * differs from what is delivered normally via the x86 fpu, so we have
4665 * to play some games.
4667 /* float/double to int/long vA, vB */
4668 movzbl rINSTbl,%ecx # ecx<- A+
4669 sarl $4,rINST # rINST<- B
4671 fldl (rFP,rINST,4) # %st0<- vB
4673 flds (rFP,rINST,4) # %st0<- vB
4676 fnstcw LOCAL0_OFFSET(%ebp) # remember original rounding mode
4677 movzwl LOCAL0_OFFSET(%ebp),%eax
4679 movw %ax,LOCAL0_OFFSET+2(%ebp)
4680 fldcw LOCAL0_OFFSET+2(%ebp) # set "to zero" rounding mode
4681 andb $0xf,%cl # ecx<- A
4683 fistpll (rFP,%ecx,4) # convert and store
4685 fistpl (rFP,%ecx,4) # convert and store
4687 fldcw LOCAL0_OFFSET(%ebp) # restore previous rounding mode
4689 movl $0x80000000,%eax
4690 xorl 4(rFP,%ecx,4),%eax
4691 orl (rFP,%ecx,4),%eax
4693 cmpl $0x80000000,(rFP,%ecx,4)
4695 je .LOP_FLOAT_TO_LONG_special_case # fix up result
4697 .LOP_FLOAT_TO_LONG_finish:
4698 FETCH_INST_OPCODE 1 %ecx
4702 .LOP_FLOAT_TO_LONG_special_case:
4705 jp .LOP_FLOAT_TO_LONG_isNaN
4706 adcl $-1,(rFP,%ecx,4)
4708 adcl $-1,4(rFP,%ecx,4)
4710 jmp .LOP_FLOAT_TO_LONG_finish
4711 .LOP_FLOAT_TO_LONG_isNaN:
4712 movl $0,(rFP,%ecx,4)
4714 movl $0,4(rFP,%ecx,4)
4716 jmp .LOP_FLOAT_TO_LONG_finish
4719 /* ------------------------------ */
4720 .L_OP_FLOAT_TO_DOUBLE: /* 0x89 */
4721 /* File: x86/OP_FLOAT_TO_DOUBLE.S */
4722 /* File: x86/fpcvt.S */
4724 * Generic 32-bit FP conversion operation.
4727 movzbl rINSTbl,%ecx # ecx<- A+
4728 sarl $4,rINST # rINST<- B
4729 flds (rFP,rINST,4) # %st0<- vB
4730 andb $0xf,%cl # ecx<- A
4732 fstpl (rFP,%ecx,4) # vA<- %st0
4733 FETCH_INST_OPCODE 1 %ecx
4738 /* ------------------------------ */
4739 .L_OP_DOUBLE_TO_INT: /* 0x8a */
4740 /* File: x86/OP_DOUBLE_TO_INT.S */
4741 /* File: x86/cvtfp_int.S */
4742 /* On fp to int conversions, Java requires that
4743 * if the result > maxint, it should be clamped to maxint. If it is less
4744 * than minint, it should be clamped to minint. If it is a nan, the result
4745 * should be zero. Further, the rounding mode is to truncate. This model
4746 * differs from what is delivered normally via the x86 fpu, so we have
4747 * to play some games.
4749 /* float/double to int/long vA, vB */
4750 movzbl rINSTbl,%ecx # ecx<- A+
4751 sarl $4,rINST # rINST<- B
4753 fldl (rFP,rINST,4) # %st0<- vB
4755 flds (rFP,rINST,4) # %st0<- vB
4758 fnstcw LOCAL0_OFFSET(%ebp) # remember original rounding mode
4759 movzwl LOCAL0_OFFSET(%ebp),%eax
4761 movw %ax,LOCAL0_OFFSET+2(%ebp)
4762 fldcw LOCAL0_OFFSET+2(%ebp) # set "to zero" rounding mode
4763 andb $0xf,%cl # ecx<- A
4765 fistpll (rFP,%ecx,4) # convert and store
4767 fistpl (rFP,%ecx,4) # convert and store
4769 fldcw LOCAL0_OFFSET(%ebp) # restore previous rounding mode
4771 movl $0x80000000,%eax
4772 xorl 4(rFP,%ecx,4),%eax
4773 orl (rFP,%ecx,4),%eax
4775 cmpl $0x80000000,(rFP,%ecx,4)
4777 je .LOP_DOUBLE_TO_INT_special_case # fix up result
4779 .LOP_DOUBLE_TO_INT_finish:
4780 FETCH_INST_OPCODE 1 %ecx
4784 .LOP_DOUBLE_TO_INT_special_case:
4787 jp .LOP_DOUBLE_TO_INT_isNaN
4788 adcl $-1,(rFP,%ecx,4)
4790 adcl $-1,4(rFP,%ecx,4)
4792 jmp .LOP_DOUBLE_TO_INT_finish
4793 .LOP_DOUBLE_TO_INT_isNaN:
4794 movl $0,(rFP,%ecx,4)
4796 movl $0,4(rFP,%ecx,4)
4798 jmp .LOP_DOUBLE_TO_INT_finish
4801 /* ------------------------------ */
4802 .L_OP_DOUBLE_TO_LONG: /* 0x8b */
4803 /* File: x86/OP_DOUBLE_TO_LONG.S */
4804 /* File: x86/cvtfp_int.S */
4805 /* On fp to int conversions, Java requires that
4806 * if the result > maxint, it should be clamped to maxint. If it is less
4807 * than minint, it should be clamped to minint. If it is a nan, the result
4808 * should be zero. Further, the rounding mode is to truncate. This model
4809 * differs from what is delivered normally via the x86 fpu, so we have
4810 * to play some games.
4812 /* float/double to int/long vA, vB */
4813 movzbl rINSTbl,%ecx # ecx<- A+
4814 sarl $4,rINST # rINST<- B
4816 fldl (rFP,rINST,4) # %st0<- vB
4818 flds (rFP,rINST,4) # %st0<- vB
4821 fnstcw LOCAL0_OFFSET(%ebp) # remember original rounding mode
4822 movzwl LOCAL0_OFFSET(%ebp),%eax
4824 movw %ax,LOCAL0_OFFSET+2(%ebp)
4825 fldcw LOCAL0_OFFSET+2(%ebp) # set "to zero" rounding mode
4826 andb $0xf,%cl # ecx<- A
4828 fistpll (rFP,%ecx,4) # convert and store
4830 fistpl (rFP,%ecx,4) # convert and store
4832 fldcw LOCAL0_OFFSET(%ebp) # restore previous rounding mode
4834 movl $0x80000000,%eax
4835 xorl 4(rFP,%ecx,4),%eax
4836 orl (rFP,%ecx,4),%eax
4838 cmpl $0x80000000,(rFP,%ecx,4)
4840 je .LOP_DOUBLE_TO_LONG_special_case # fix up result
4842 .LOP_DOUBLE_TO_LONG_finish:
4843 FETCH_INST_OPCODE 1 %ecx
4847 .LOP_DOUBLE_TO_LONG_special_case:
4850 jp .LOP_DOUBLE_TO_LONG_isNaN
4851 adcl $-1,(rFP,%ecx,4)
4853 adcl $-1,4(rFP,%ecx,4)
4855 jmp .LOP_DOUBLE_TO_LONG_finish
4856 .LOP_DOUBLE_TO_LONG_isNaN:
4857 movl $0,(rFP,%ecx,4)
4859 movl $0,4(rFP,%ecx,4)
4861 jmp .LOP_DOUBLE_TO_LONG_finish
4864 /* ------------------------------ */
4865 .L_OP_DOUBLE_TO_FLOAT: /* 0x8c */
4866 /* File: x86/OP_DOUBLE_TO_FLOAT.S */
4867 /* File: x86/fpcvt.S */
4869 * Generic 32-bit FP conversion operation.
4872 movzbl rINSTbl,%ecx # ecx<- A+
4873 sarl $4,rINST # rINST<- B
4874 fldl (rFP,rINST,4) # %st0<- vB
4875 andb $0xf,%cl # ecx<- A
4877 fstps (rFP,%ecx,4) # vA<- %st0
4878 FETCH_INST_OPCODE 1 %ecx
4883 /* ------------------------------ */
4884 .L_OP_INT_TO_BYTE: /* 0x8d */
4885 /* File: x86/OP_INT_TO_BYTE.S */
4886 /* File: x86/unop.S */
4888 * Generic 32-bit unary operation. Provide an "instr" line that
4889 * specifies an instruction that performs "result = op eax".
4892 movzbl rINSTbl,%ecx # ecx<- A+
4893 sarl $4,rINST # rINST<- B
4894 GET_VREG_R %eax rINST # eax<- vB
4895 andb $0xf,%cl # ecx<- A
4900 FETCH_INST_OPCODE 1 %ecx
4905 /* ------------------------------ */
4906 .L_OP_INT_TO_CHAR: /* 0x8e */
4907 /* File: x86/OP_INT_TO_CHAR.S */
4908 /* File: x86/unop.S */
4910 * Generic 32-bit unary operation. Provide an "instr" line that
4911 * specifies an instruction that performs "result = op eax".
4914 movzbl rINSTbl,%ecx # ecx<- A+
4915 sarl $4,rINST # rINST<- B
4916 GET_VREG_R %eax rINST # eax<- vB
4917 andb $0xf,%cl # ecx<- A
4922 FETCH_INST_OPCODE 1 %ecx
4927 /* ------------------------------ */
4928 .L_OP_INT_TO_SHORT: /* 0x8f */
4929 /* File: x86/OP_INT_TO_SHORT.S */
4930 /* File: x86/unop.S */
4932 * Generic 32-bit unary operation. Provide an "instr" line that
4933 * specifies an instruction that performs "result = op eax".
4936 movzbl rINSTbl,%ecx # ecx<- A+
4937 sarl $4,rINST # rINST<- B
4938 GET_VREG_R %eax rINST # eax<- vB
4939 andb $0xf,%cl # ecx<- A
4944 FETCH_INST_OPCODE 1 %ecx
4949 /* ------------------------------ */
4950 .L_OP_ADD_INT: /* 0x90 */
4951 /* File: x86/OP_ADD_INT.S */
4952 /* File: x86/binop.S */
4954 * Generic 32-bit binary operation. Provide an "instr" line that
4955 * specifies an instruction that performs "result = eax op (rFP,%ecx,4)".
4956 * This could be an x86 instruction or a function call. (If the result
4957 * comes back in a register other than eax, you can override "result".)
4959 * For: add-int, sub-int, and-int, or-int,
4960 * xor-int, shl-int, shr-int, ushr-int
4962 /* binop vAA, vBB, vCC */
4963 movzbl 2(rPC),%eax # eax<- BB
4964 movzbl 3(rPC),%ecx # ecx<- CC
4965 GET_VREG_R %eax %eax # eax<- vBB
4966 addl (rFP,%ecx,4),%eax # ex: addl (rFP,%ecx,4),%eax
4968 FETCH_INST_OPCODE 2 %ecx
4973 /* ------------------------------ */
4974 .L_OP_SUB_INT: /* 0x91 */
4975 /* File: x86/OP_SUB_INT.S */
4976 /* File: x86/binop.S */
4978 * Generic 32-bit binary operation. Provide an "instr" line that
4979 * specifies an instruction that performs "result = eax op (rFP,%ecx,4)".
4980 * This could be an x86 instruction or a function call. (If the result
4981 * comes back in a register other than eax, you can override "result".)
4983 * For: add-int, sub-int, and-int, or-int,
4984 * xor-int, shl-int, shr-int, ushr-int
4986 /* binop vAA, vBB, vCC */
4987 movzbl 2(rPC),%eax # eax<- BB
4988 movzbl 3(rPC),%ecx # ecx<- CC
4989 GET_VREG_R %eax %eax # eax<- vBB
4990 subl (rFP,%ecx,4),%eax # ex: addl (rFP,%ecx,4),%eax
4992 FETCH_INST_OPCODE 2 %ecx
4997 /* ------------------------------ */
4998 .L_OP_MUL_INT: /* 0x92 */
4999 /* File: x86/OP_MUL_INT.S */
5001 * 32-bit binary multiplication.
5003 /* mul vAA, vBB, vCC */
5004 movzbl 2(rPC),%eax # eax<- BB
5005 movzbl 3(rPC),%ecx # ecx<- CC
5006 GET_VREG_R %eax %eax # eax<- vBB
5008 imull (rFP,%ecx,4),%eax # trashes rIBASE/edx
5010 FETCH_INST_OPCODE 2 %ecx
5015 /* ------------------------------ */
5016 .L_OP_DIV_INT: /* 0x93 */
5017 /* File: x86/OP_DIV_INT.S */
5018 /* File: x86/bindiv.S */
5021 * 32-bit binary div/rem operation. Handles special case of op0=minint and
5024 /* binop vAA, vBB, vCC */
5025 movzbl 2(rPC),%eax # eax<- BB
5026 movzbl 3(rPC),%ecx # ecx<- CC
5027 GET_VREG_R %eax %eax # eax<- vBB
5028 GET_VREG_R %ecx %ecx # eax<- vBB
5031 je common_errDivideByZero
5033 jne .LOP_DIV_INT_continue_div
5034 cmpl $0x80000000,%eax
5035 jne .LOP_DIV_INT_continue_div
5036 movl $0x80000000,%eax
5039 FETCH_INST_OPCODE 2 %ecx
5043 .LOP_DIV_INT_continue_div:
5048 FETCH_INST_OPCODE 2 %ecx
5053 /* ------------------------------ */
5054 .L_OP_REM_INT: /* 0x94 */
5055 /* File: x86/OP_REM_INT.S */
5056 /* File: x86/bindiv.S */
5059 * 32-bit binary div/rem operation. Handles special case of op0=minint and
5062 /* binop vAA, vBB, vCC */
5063 movzbl 2(rPC),%eax # eax<- BB
5064 movzbl 3(rPC),%ecx # ecx<- CC
5065 GET_VREG_R %eax %eax # eax<- vBB
5066 GET_VREG_R %ecx %ecx # eax<- vBB
5069 je common_errDivideByZero
5071 jne .LOP_REM_INT_continue_div
5072 cmpl $0x80000000,%eax
5073 jne .LOP_REM_INT_continue_div
5075 SET_VREG rIBASE rINST
5077 FETCH_INST_OPCODE 2 %ecx
5081 .LOP_REM_INT_continue_div:
5084 SET_VREG rIBASE rINST
5086 FETCH_INST_OPCODE 2 %ecx
5091 /* ------------------------------ */
5092 .L_OP_AND_INT: /* 0x95 */
5093 /* File: x86/OP_AND_INT.S */
5094 /* File: x86/binop.S */
5096 * Generic 32-bit binary operation. Provide an "instr" line that
5097 * specifies an instruction that performs "result = eax op (rFP,%ecx,4)".
5098 * This could be an x86 instruction or a function call. (If the result
5099 * comes back in a register other than eax, you can override "result".)
5101 * For: add-int, sub-int, and-int, or-int,
5102 * xor-int, shl-int, shr-int, ushr-int
5104 /* binop vAA, vBB, vCC */
5105 movzbl 2(rPC),%eax # eax<- BB
5106 movzbl 3(rPC),%ecx # ecx<- CC
5107 GET_VREG_R %eax %eax # eax<- vBB
5108 andl (rFP,%ecx,4),%eax # ex: addl (rFP,%ecx,4),%eax
5110 FETCH_INST_OPCODE 2 %ecx
5115 /* ------------------------------ */
5116 .L_OP_OR_INT: /* 0x96 */
5117 /* File: x86/OP_OR_INT.S */
5118 /* File: x86/binop.S */
5120 * Generic 32-bit binary operation. Provide an "instr" line that
5121 * specifies an instruction that performs "result = eax op (rFP,%ecx,4)".
5122 * This could be an x86 instruction or a function call. (If the result
5123 * comes back in a register other than eax, you can override "result".)
5125 * For: add-int, sub-int, and-int, or-int,
5126 * xor-int, shl-int, shr-int, ushr-int
5128 /* binop vAA, vBB, vCC */
5129 movzbl 2(rPC),%eax # eax<- BB
5130 movzbl 3(rPC),%ecx # ecx<- CC
5131 GET_VREG_R %eax %eax # eax<- vBB
5132 orl (rFP,%ecx,4),%eax # ex: addl (rFP,%ecx,4),%eax
5134 FETCH_INST_OPCODE 2 %ecx
5139 /* ------------------------------ */
5140 .L_OP_XOR_INT: /* 0x97 */
5141 /* File: x86/OP_XOR_INT.S */
5142 /* File: x86/binop.S */
5144 * Generic 32-bit binary operation. Provide an "instr" line that
5145 * specifies an instruction that performs "result = eax op (rFP,%ecx,4)".
5146 * This could be an x86 instruction or a function call. (If the result
5147 * comes back in a register other than eax, you can override "result".)
5149 * For: add-int, sub-int, and-int, or-int,
5150 * xor-int, shl-int, shr-int, ushr-int
5152 /* binop vAA, vBB, vCC */
5153 movzbl 2(rPC),%eax # eax<- BB
5154 movzbl 3(rPC),%ecx # ecx<- CC
5155 GET_VREG_R %eax %eax # eax<- vBB
5156 xorl (rFP,%ecx,4),%eax # ex: addl (rFP,%ecx,4),%eax
5158 FETCH_INST_OPCODE 2 %ecx
5163 /* ------------------------------ */
5164 .L_OP_SHL_INT: /* 0x98 */
5165 /* File: x86/OP_SHL_INT.S */
5166 /* File: x86/binop1.S */
5168 * Generic 32-bit binary operation in which both operands loaded to
5169 * registers (op0 in eax, op1 in ecx).
5171 /* binop vAA, vBB, vCC */
5172 movzbl 2(rPC),%eax # eax<- BB
5173 movzbl 3(rPC),%ecx # ecx<- CC
5174 GET_VREG_R %eax %eax # eax<- vBB
5175 GET_VREG_R %ecx %ecx # eax<- vBB
5176 sall %cl,%eax # ex: addl %ecx,%eax
5178 FETCH_INST_OPCODE 2 %ecx
5183 /* ------------------------------ */
5184 .L_OP_SHR_INT: /* 0x99 */
5185 /* File: x86/OP_SHR_INT.S */
5186 /* File: x86/binop1.S */
5188 * Generic 32-bit binary operation in which both operands loaded to
5189 * registers (op0 in eax, op1 in ecx).
5191 /* binop vAA, vBB, vCC */
5192 movzbl 2(rPC),%eax # eax<- BB
5193 movzbl 3(rPC),%ecx # ecx<- CC
5194 GET_VREG_R %eax %eax # eax<- vBB
5195 GET_VREG_R %ecx %ecx # eax<- vBB
5196 sarl %cl,%eax # ex: addl %ecx,%eax
5198 FETCH_INST_OPCODE 2 %ecx
5203 /* ------------------------------ */
5204 .L_OP_USHR_INT: /* 0x9a */
5205 /* File: x86/OP_USHR_INT.S */
5206 /* File: x86/binop1.S */
5208 * Generic 32-bit binary operation in which both operands loaded to
5209 * registers (op0 in eax, op1 in ecx).
5211 /* binop vAA, vBB, vCC */
5212 movzbl 2(rPC),%eax # eax<- BB
5213 movzbl 3(rPC),%ecx # ecx<- CC
5214 GET_VREG_R %eax %eax # eax<- vBB
5215 GET_VREG_R %ecx %ecx # eax<- vBB
5216 shrl %cl,%eax # ex: addl %ecx,%eax
5218 FETCH_INST_OPCODE 2 %ecx
5223 /* ------------------------------ */
5224 .L_OP_ADD_LONG: /* 0x9b */
5225 /* File: x86/OP_ADD_LONG.S */
5226 /* File: x86/binopWide.S */
5228 * Generic 64-bit binary operation.
5230 /* binop vAA, vBB, vCC */
5232 movzbl 2(rPC),%eax # eax<- BB
5233 movzbl 3(rPC),%ecx # ecx<- CC
5234 SPILL(rIBASE) # save rIBASE
5235 GET_VREG_WORD rIBASE %eax 0 # rIBASE<- v[BB+0]
5236 GET_VREG_WORD %eax %eax 1 # eax<- v[BB+1]
5237 addl (rFP,%ecx,4),rIBASE # ex: addl (rFP,%ecx,4),rIBASE
5238 adcl 4(rFP,%ecx,4),%eax # ex: adcl 4(rFP,%ecx,4),%eax
5239 SET_VREG_WORD rIBASE rINST 0 # v[AA+0] <- rIBASE
5240 FETCH_INST_OPCODE 2 %ecx
5241 UNSPILL(rIBASE) # restore rIBASE
5242 SET_VREG_WORD %eax rINST 1 # v[AA+1] <- eax
5247 /* ------------------------------ */
5248 .L_OP_SUB_LONG: /* 0x9c */
5249 /* File: x86/OP_SUB_LONG.S */
5250 /* File: x86/binopWide.S */
5252 * Generic 64-bit binary operation.
5254 /* binop vAA, vBB, vCC */
5256 movzbl 2(rPC),%eax # eax<- BB
5257 movzbl 3(rPC),%ecx # ecx<- CC
5258 SPILL(rIBASE) # save rIBASE
5259 GET_VREG_WORD rIBASE %eax 0 # rIBASE<- v[BB+0]
5260 GET_VREG_WORD %eax %eax 1 # eax<- v[BB+1]
5261 subl (rFP,%ecx,4),rIBASE # ex: addl (rFP,%ecx,4),rIBASE
5262 sbbl 4(rFP,%ecx,4),%eax # ex: adcl 4(rFP,%ecx,4),%eax
5263 SET_VREG_WORD rIBASE rINST 0 # v[AA+0] <- rIBASE
5264 FETCH_INST_OPCODE 2 %ecx
5265 UNSPILL(rIBASE) # restore rIBASE
5266 SET_VREG_WORD %eax rINST 1 # v[AA+1] <- eax
5271 /* ------------------------------ */
5272 .L_OP_MUL_LONG: /* 0x9d */
5273 /* File: x86/OP_MUL_LONG.S */
5275 * Signed 64-bit integer multiply.
5277 * We could definately use more free registers for
5278 * this code. We spill rINSTw (ebx),
5279 * giving us eax, ebc, ecx and edx as computational
5280 * temps. On top of that, we'll spill edi (rFP)
5281 * for use as the vB pointer and esi (rPC) for use
5282 * as the vC pointer. Yuck.
5284 /* mul-long vAA, vBB, vCC */
5285 movzbl 2(rPC),%eax # eax<- B
5286 movzbl 3(rPC),%ecx # ecx<- C
5287 SPILL_TMP2(%esi) # save Dalvik PC
5291 leal (rFP,%eax,4),%esi # esi<- &v[B]
5292 leal (rFP,%ecx,4),rFP # rFP<- &v[C]
5293 movl 4(%esi),%ecx # ecx<- Bmsw
5294 imull (rFP),%ecx # ecx<- (Bmsw*Clsw)
5295 movl 4(rFP),%eax # eax<- Cmsw
5296 imull (%esi),%eax # eax<- (Cmsw*Blsw)
5297 addl %eax,%ecx # ecx<- (Bmsw*Clsw)+(Cmsw*Blsw)
5298 movl (rFP),%eax # eax<- Clsw
5299 mull (%esi) # eax<- (Clsw*Alsw)
5302 leal (%ecx,rIBASE),rIBASE # full result now in rIBASE:%eax
5303 UNSPILL_TMP2(%esi) # Restore Dalvik PC
5304 FETCH_INST_OPCODE 2 %ecx # Fetch next instruction
5305 movl rIBASE,4(rFP,rINST,4)# v[B+1]<- rIBASE
5307 movl %eax,(rFP,rINST,4) # v[B]<- %eax
5311 /* ------------------------------ */
5312 .L_OP_DIV_LONG: /* 0x9e */
5313 /* File: x86/OP_DIV_LONG.S */
5314 /* div vAA, vBB, vCC */
5315 movzbl 3(rPC),%eax # eax<- CC
5316 movzbl 2(rPC),%ecx # ecx<- BB
5317 SPILL(rIBASE) # save rIBASE/%edx
5318 GET_VREG_WORD rIBASE %eax 0
5319 GET_VREG_WORD %eax %eax 1
5320 movl rIBASE,OUT_ARG2(%esp)
5322 je .LOP_DIV_LONG_check_zero
5324 je .LOP_DIV_LONG_check_neg1
5325 .LOP_DIV_LONG_notSpecial:
5326 GET_VREG_WORD rIBASE %ecx 0
5327 GET_VREG_WORD %ecx %ecx 1
5328 .LOP_DIV_LONG_notSpecial1:
5329 movl %eax,OUT_ARG3(%esp)
5330 movl rIBASE,OUT_ARG0(%esp)
5331 movl %ecx,OUT_ARG1(%esp)
5333 .LOP_DIV_LONG_finish:
5334 SET_VREG_WORD rIBASE rINST 1
5335 UNSPILL(rIBASE) # restore rIBASE/%edx
5336 SET_VREG_WORD %eax rINST 0
5337 FETCH_INST_OPCODE 2 %ecx
5341 .LOP_DIV_LONG_check_zero:
5343 jne .LOP_DIV_LONG_notSpecial
5344 jmp common_errDivideByZero
5345 .LOP_DIV_LONG_check_neg1:
5347 jne .LOP_DIV_LONG_notSpecial
5348 GET_VREG_WORD rIBASE %ecx 0
5349 GET_VREG_WORD %ecx %ecx 1
5351 jne .LOP_DIV_LONG_notSpecial1
5352 cmpl $0x80000000,%ecx
5353 jne .LOP_DIV_LONG_notSpecial1
5354 /* minint / -1, return minint on div, 0 on rem */
5356 movl $0x80000000,rIBASE
5357 jmp .LOP_DIV_LONG_finish
5359 /* ------------------------------ */
5360 .L_OP_REM_LONG: /* 0x9f */
5361 /* File: x86/OP_REM_LONG.S */
5362 /* File: x86/OP_DIV_LONG.S */
5363 /* div vAA, vBB, vCC */
5364 movzbl 3(rPC),%eax # eax<- CC
5365 movzbl 2(rPC),%ecx # ecx<- BB
5366 SPILL(rIBASE) # save rIBASE/%edx
5367 GET_VREG_WORD rIBASE %eax 0
5368 GET_VREG_WORD %eax %eax 1
5369 movl rIBASE,OUT_ARG2(%esp)
5371 je .LOP_REM_LONG_check_zero
5373 je .LOP_REM_LONG_check_neg1
5374 .LOP_REM_LONG_notSpecial:
5375 GET_VREG_WORD rIBASE %ecx 0
5376 GET_VREG_WORD %ecx %ecx 1
5377 .LOP_REM_LONG_notSpecial1:
5378 movl %eax,OUT_ARG3(%esp)
5379 movl rIBASE,OUT_ARG0(%esp)
5380 movl %ecx,OUT_ARG1(%esp)
5382 .LOP_REM_LONG_finish:
5383 SET_VREG_WORD rIBASE rINST 1
5384 UNSPILL(rIBASE) # restore rIBASE/%edx
5385 SET_VREG_WORD %eax rINST 0
5386 FETCH_INST_OPCODE 2 %ecx
5390 .LOP_REM_LONG_check_zero:
5392 jne .LOP_REM_LONG_notSpecial
5393 jmp common_errDivideByZero
5394 .LOP_REM_LONG_check_neg1:
5396 jne .LOP_REM_LONG_notSpecial
5397 GET_VREG_WORD rIBASE %ecx 0
5398 GET_VREG_WORD %ecx %ecx 1
5400 jne .LOP_REM_LONG_notSpecial1
5401 cmpl $0x80000000,%ecx
5402 jne .LOP_REM_LONG_notSpecial1
5403 /* minint / -1, return minint on div, 0 on rem */
5406 jmp .LOP_REM_LONG_finish
5409 /* ------------------------------ */
5410 .L_OP_AND_LONG: /* 0xa0 */
5411 /* File: x86/OP_AND_LONG.S */
5412 /* File: x86/binopWide.S */
5414 * Generic 64-bit binary operation.
5416 /* binop vAA, vBB, vCC */
5418 movzbl 2(rPC),%eax # eax<- BB
5419 movzbl 3(rPC),%ecx # ecx<- CC
5420 SPILL(rIBASE) # save rIBASE
5421 GET_VREG_WORD rIBASE %eax 0 # rIBASE<- v[BB+0]
5422 GET_VREG_WORD %eax %eax 1 # eax<- v[BB+1]
5423 andl (rFP,%ecx,4),rIBASE # ex: addl (rFP,%ecx,4),rIBASE
5424 andl 4(rFP,%ecx,4),%eax # ex: adcl 4(rFP,%ecx,4),%eax
5425 SET_VREG_WORD rIBASE rINST 0 # v[AA+0] <- rIBASE
5426 FETCH_INST_OPCODE 2 %ecx
5427 UNSPILL(rIBASE) # restore rIBASE
5428 SET_VREG_WORD %eax rINST 1 # v[AA+1] <- eax
5433 /* ------------------------------ */
5434 .L_OP_OR_LONG: /* 0xa1 */
5435 /* File: x86/OP_OR_LONG.S */
5436 /* File: x86/binopWide.S */
5438 * Generic 64-bit binary operation.
5440 /* binop vAA, vBB, vCC */
5442 movzbl 2(rPC),%eax # eax<- BB
5443 movzbl 3(rPC),%ecx # ecx<- CC
5444 SPILL(rIBASE) # save rIBASE
5445 GET_VREG_WORD rIBASE %eax 0 # rIBASE<- v[BB+0]
5446 GET_VREG_WORD %eax %eax 1 # eax<- v[BB+1]
5447 orl (rFP,%ecx,4),rIBASE # ex: addl (rFP,%ecx,4),rIBASE
5448 orl 4(rFP,%ecx,4),%eax # ex: adcl 4(rFP,%ecx,4),%eax
5449 SET_VREG_WORD rIBASE rINST 0 # v[AA+0] <- rIBASE
5450 FETCH_INST_OPCODE 2 %ecx
5451 UNSPILL(rIBASE) # restore rIBASE
5452 SET_VREG_WORD %eax rINST 1 # v[AA+1] <- eax
5457 /* ------------------------------ */
5458 .L_OP_XOR_LONG: /* 0xa2 */
5459 /* File: x86/OP_XOR_LONG.S */
5460 /* File: x86/binopWide.S */
5462 * Generic 64-bit binary operation.
5464 /* binop vAA, vBB, vCC */
5466 movzbl 2(rPC),%eax # eax<- BB
5467 movzbl 3(rPC),%ecx # ecx<- CC
5468 SPILL(rIBASE) # save rIBASE
5469 GET_VREG_WORD rIBASE %eax 0 # rIBASE<- v[BB+0]
5470 GET_VREG_WORD %eax %eax 1 # eax<- v[BB+1]
5471 xorl (rFP,%ecx,4),rIBASE # ex: addl (rFP,%ecx,4),rIBASE
5472 xorl 4(rFP,%ecx,4),%eax # ex: adcl 4(rFP,%ecx,4),%eax
5473 SET_VREG_WORD rIBASE rINST 0 # v[AA+0] <- rIBASE
5474 FETCH_INST_OPCODE 2 %ecx
5475 UNSPILL(rIBASE) # restore rIBASE
5476 SET_VREG_WORD %eax rINST 1 # v[AA+1] <- eax
5481 /* ------------------------------ */
5482 .L_OP_SHL_LONG: /* 0xa3 */
5483 /* File: x86/OP_SHL_LONG.S */
5485 * Long integer shift. This is different from the generic 32/64-bit
5486 * binary operations because vAA/vBB are 64-bit but vCC (the shift
5487 * distance) is 32-bit. Also, Dalvik requires us to mask off the low
5488 * 6 bits of the shift distance. x86 shifts automatically mask off
5489 * the low 5 bits of %cl, so have to handle the 64 > shiftcount > 31
5492 /* shl-long vAA, vBB, vCC */
5493 /* ecx gets shift count */
5494 /* Need to spill rINST */
5495 /* rINSTw gets AA */
5496 movzbl 2(rPC),%eax # eax<- BB
5497 movzbl 3(rPC),%ecx # ecx<- CC
5499 GET_VREG_WORD rIBASE %eax 1 # ecx<- v[BB+1]
5500 GET_VREG_R %ecx %ecx # ecx<- vCC
5501 GET_VREG_WORD %eax %eax 0 # eax<- v[BB+0]
5509 SET_VREG_WORD rIBASE rINST 1 # v[AA+1]<- rIBASE
5510 FETCH_INST_OPCODE 2 %ecx
5512 SET_VREG_WORD %eax rINST 0 # v[AA+0]<- %eax
5516 /* ------------------------------ */
5517 .L_OP_SHR_LONG: /* 0xa4 */
5518 /* File: x86/OP_SHR_LONG.S */
5520 * Long integer shift. This is different from the generic 32/64-bit
5521 * binary operations because vAA/vBB are 64-bit but vCC (the shift
5522 * distance) is 32-bit. Also, Dalvik requires us to mask off the low
5523 * 6 bits of the shift distance. x86 shifts automatically mask off
5524 * the low 5 bits of %cl, so have to handle the 64 > shiftcount > 31
5527 /* shr-long vAA, vBB, vCC */
5528 /* ecx gets shift count */
5529 /* Need to spill rIBASE */
5530 /* rINSTw gets AA */
5531 movzbl 2(rPC),%eax # eax<- BB
5532 movzbl 3(rPC),%ecx # ecx<- CC
5534 GET_VREG_WORD rIBASE %eax 1 # rIBASE<- v[BB+1]
5535 GET_VREG_R %ecx %ecx # ecx<- vCC
5536 GET_VREG_WORD %eax %eax 0 # eax<- v[BB+0]
5544 SET_VREG_WORD rIBASE rINST 1 # v[AA+1]<- rIBASE
5545 FETCH_INST_OPCODE 2 %ecx
5547 SET_VREG_WORD %eax rINST 0 # v[AA+0]<- eax
5551 /* ------------------------------ */
5552 .L_OP_USHR_LONG: /* 0xa5 */
5553 /* File: x86/OP_USHR_LONG.S */
5555 * Long integer shift. This is different from the generic 32/64-bit
5556 * binary operations because vAA/vBB are 64-bit but vCC (the shift
5557 * distance) is 32-bit. Also, Dalvik requires us to mask off the low
5558 * 6 bits of the shift distance. x86 shifts automatically mask off
5559 * the low 5 bits of %cl, so have to handle the 64 > shiftcount > 31
5562 /* shr-long vAA, vBB, vCC */
5563 /* ecx gets shift count */
5564 /* Need to spill rIBASE */
5565 /* rINSTw gets AA */
5566 movzbl 2(rPC),%eax # eax<- BB
5567 movzbl 3(rPC),%ecx # ecx<- CC
5569 GET_VREG_WORD rIBASE %eax 1 # rIBASE<- v[BB+1]
5570 GET_VREG_R %ecx %ecx # ecx<- vCC
5571 GET_VREG_WORD %eax %eax 0 # eax<- v[BB+0]
5579 SET_VREG_WORD rIBASE rINST 1 # v[AA+1]<- rIBASE
5580 FETCH_INST_OPCODE 2 %ecx
5582 SET_VREG_WORD %eax rINST 0 # v[BB+0]<- eax
5586 /* ------------------------------ */
5587 .L_OP_ADD_FLOAT: /* 0xa6 */
5588 /* File: x86/OP_ADD_FLOAT.S */
5589 /* File: x86/binflop.S */
5591 * Generic 32-bit binary float operation.
5593 * For: add-fp, sub-fp, mul-fp, div-fp
5595 /* binop vAA, vBB, vCC */
5596 movzbl 2(rPC),%eax # eax<- CC
5597 movzbl 3(rPC),%ecx # ecx<- BB
5598 flds (rFP,%eax,4) # vCC to fp stack
5599 fadds (rFP,%ecx,4) # ex: faddp
5600 FETCH_INST_OPCODE 2 %ecx
5602 fstps (rFP,rINST,4) # %st to vAA
5606 /* ------------------------------ */
5607 .L_OP_SUB_FLOAT: /* 0xa7 */
5608 /* File: x86/OP_SUB_FLOAT.S */
5609 /* File: x86/binflop.S */
5611 * Generic 32-bit binary float operation.
5613 * For: add-fp, sub-fp, mul-fp, div-fp
5615 /* binop vAA, vBB, vCC */
5616 movzbl 2(rPC),%eax # eax<- CC
5617 movzbl 3(rPC),%ecx # ecx<- BB
5618 flds (rFP,%eax,4) # vCC to fp stack
5619 fsubs (rFP,%ecx,4) # ex: faddp
5620 FETCH_INST_OPCODE 2 %ecx
5622 fstps (rFP,rINST,4) # %st to vAA
5626 /* ------------------------------ */
5627 .L_OP_MUL_FLOAT: /* 0xa8 */
5628 /* File: x86/OP_MUL_FLOAT.S */
5629 /* File: x86/binflop.S */
5631 * Generic 32-bit binary float operation.
5633 * For: add-fp, sub-fp, mul-fp, div-fp
5635 /* binop vAA, vBB, vCC */
5636 movzbl 2(rPC),%eax # eax<- CC
5637 movzbl 3(rPC),%ecx # ecx<- BB
5638 flds (rFP,%eax,4) # vCC to fp stack
5639 fmuls (rFP,%ecx,4) # ex: faddp
5640 FETCH_INST_OPCODE 2 %ecx
5642 fstps (rFP,rINST,4) # %st to vAA
5646 /* ------------------------------ */
5647 .L_OP_DIV_FLOAT: /* 0xa9 */
5648 /* File: x86/OP_DIV_FLOAT.S */
5649 /* File: x86/binflop.S */
5651 * Generic 32-bit binary float operation.
5653 * For: add-fp, sub-fp, mul-fp, div-fp
5655 /* binop vAA, vBB, vCC */
5656 movzbl 2(rPC),%eax # eax<- CC
5657 movzbl 3(rPC),%ecx # ecx<- BB
5658 flds (rFP,%eax,4) # vCC to fp stack
5659 fdivs (rFP,%ecx,4) # ex: faddp
5660 FETCH_INST_OPCODE 2 %ecx
5662 fstps (rFP,rINST,4) # %st to vAA
5666 /* ------------------------------ */
5667 .L_OP_REM_FLOAT: /* 0xaa */
5668 /* File: x86/OP_REM_FLOAT.S */
5669 /* rem_float vAA, vBB, vCC */
5670 movzbl 3(rPC),%ecx # ecx<- BB
5671 movzbl 2(rPC),%eax # eax<- CC
5672 flds (rFP,%ecx,4) # vCC to fp stack
5673 flds (rFP,%eax,4) # vCC to fp stack
5674 movzbl rINSTbl,%ecx # ecx<- AA
5681 FETCH_INST_OPCODE 2 %eax
5683 fstps (rFP,%ecx,4) # %st to vAA
5686 /* ------------------------------ */
5687 .L_OP_ADD_DOUBLE: /* 0xab */
5688 /* File: x86/OP_ADD_DOUBLE.S */
5689 /* File: x86/binflop.S */
5691 * Generic 32-bit binary float operation.
5693 * For: add-fp, sub-fp, mul-fp, div-fp
5695 /* binop vAA, vBB, vCC */
5696 movzbl 2(rPC),%eax # eax<- CC
5697 movzbl 3(rPC),%ecx # ecx<- BB
5698 fldl (rFP,%eax,4) # vCC to fp stack
5699 faddl (rFP,%ecx,4) # ex: faddp
5700 FETCH_INST_OPCODE 2 %ecx
5702 fstpl (rFP,rINST,4) # %st to vAA
5706 /* ------------------------------ */
5707 .L_OP_SUB_DOUBLE: /* 0xac */
5708 /* File: x86/OP_SUB_DOUBLE.S */
5709 /* File: x86/binflop.S */
5711 * Generic 32-bit binary float operation.
5713 * For: add-fp, sub-fp, mul-fp, div-fp
5715 /* binop vAA, vBB, vCC */
5716 movzbl 2(rPC),%eax # eax<- CC
5717 movzbl 3(rPC),%ecx # ecx<- BB
5718 fldl (rFP,%eax,4) # vCC to fp stack
5719 fsubl (rFP,%ecx,4) # ex: faddp
5720 FETCH_INST_OPCODE 2 %ecx
5722 fstpl (rFP,rINST,4) # %st to vAA
5726 /* ------------------------------ */
5727 .L_OP_MUL_DOUBLE: /* 0xad */
5728 /* File: x86/OP_MUL_DOUBLE.S */
5729 /* File: x86/binflop.S */
5731 * Generic 32-bit binary float operation.
5733 * For: add-fp, sub-fp, mul-fp, div-fp
5735 /* binop vAA, vBB, vCC */
5736 movzbl 2(rPC),%eax # eax<- CC
5737 movzbl 3(rPC),%ecx # ecx<- BB
5738 fldl (rFP,%eax,4) # vCC to fp stack
5739 fmull (rFP,%ecx,4) # ex: faddp
5740 FETCH_INST_OPCODE 2 %ecx
5742 fstpl (rFP,rINST,4) # %st to vAA
5746 /* ------------------------------ */
5747 .L_OP_DIV_DOUBLE: /* 0xae */
5748 /* File: x86/OP_DIV_DOUBLE.S */
5749 /* File: x86/binflop.S */
5751 * Generic 32-bit binary float operation.
5753 * For: add-fp, sub-fp, mul-fp, div-fp
5755 /* binop vAA, vBB, vCC */
5756 movzbl 2(rPC),%eax # eax<- CC
5757 movzbl 3(rPC),%ecx # ecx<- BB
5758 fldl (rFP,%eax,4) # vCC to fp stack
5759 fdivl (rFP,%ecx,4) # ex: faddp
5760 FETCH_INST_OPCODE 2 %ecx
5762 fstpl (rFP,rINST,4) # %st to vAA
5766 /* ------------------------------ */
5767 .L_OP_REM_DOUBLE: /* 0xaf */
5768 /* File: x86/OP_REM_DOUBLE.S */
5769 /* rem_float vAA, vBB, vCC */
5770 movzbl 3(rPC),%ecx # ecx<- BB
5771 movzbl 2(rPC),%eax # eax<- CC
5772 fldl (rFP,%ecx,4) # vCC to fp stack
5773 fldl (rFP,%eax,4) # vCC to fp stack
5774 FETCH_INST_OPCODE 2 %ecx
5782 fstpl (rFP,rINST,4) # %st to vAA
5785 /* ------------------------------ */
5786 .L_OP_ADD_INT_2ADDR: /* 0xb0 */
5787 /* File: x86/OP_ADD_INT_2ADDR.S */
5788 /* File: x86/binop2addr.S */
5790 * Generic 32-bit "/2addr" binary operation. Provide an "instr" line
5791 * that specifies an instruction that performs "result = r0 op r1".
5792 * This could be an ARM instruction or a function call. (If the result
5793 * comes back in a register other than r0, you can override "result".)
5795 * If "chkzero" is set to 1, we perform a divide-by-zero check on
5796 * vCC (r1). Useful for integer division and modulus.
5798 * For: add-int/2addr, sub-int/2addr, mul-int/2addr, div-int/2addr,
5799 * rem-int/2addr, and-int/2addr, or-int/2addr, xor-int/2addr,
5800 * shl-int/2addr, shr-int/2addr, ushr-int/2addr, add-float/2addr,
5801 * sub-float/2addr, mul-float/2addr, div-float/2addr, rem-float/2addr
5803 /* binop/2addr vA, vB */
5804 movzx rINSTbl,%ecx # ecx<- A+
5805 sarl $4,rINST # rINST<- B
5806 GET_VREG_R %eax rINST # eax<- vB
5807 andb $0xf,%cl # ecx<- A
5808 addl %eax,(rFP,%ecx,4) # for ex: addl %eax,(rFP,%ecx,4)
5809 FETCH_INST_OPCODE 1 %ecx
5814 /* ------------------------------ */
5815 .L_OP_SUB_INT_2ADDR: /* 0xb1 */
5816 /* File: x86/OP_SUB_INT_2ADDR.S */
5817 /* File: x86/binop2addr.S */
5819 * Generic 32-bit "/2addr" binary operation. Provide an "instr" line
5820 * that specifies an instruction that performs "result = r0 op r1".
5821 * This could be an ARM instruction or a function call. (If the result
5822 * comes back in a register other than r0, you can override "result".)
5824 * If "chkzero" is set to 1, we perform a divide-by-zero check on
5825 * vCC (r1). Useful for integer division and modulus.
5827 * For: add-int/2addr, sub-int/2addr, mul-int/2addr, div-int/2addr,
5828 * rem-int/2addr, and-int/2addr, or-int/2addr, xor-int/2addr,
5829 * shl-int/2addr, shr-int/2addr, ushr-int/2addr, add-float/2addr,
5830 * sub-float/2addr, mul-float/2addr, div-float/2addr, rem-float/2addr
5832 /* binop/2addr vA, vB */
5833 movzx rINSTbl,%ecx # ecx<- A+
5834 sarl $4,rINST # rINST<- B
5835 GET_VREG_R %eax rINST # eax<- vB
5836 andb $0xf,%cl # ecx<- A
5837 subl %eax,(rFP,%ecx,4) # for ex: addl %eax,(rFP,%ecx,4)
5838 FETCH_INST_OPCODE 1 %ecx
5843 /* ------------------------------ */
5844 .L_OP_MUL_INT_2ADDR: /* 0xb2 */
5845 /* File: x86/OP_MUL_INT_2ADDR.S */
5847 movzx rINSTbl,%ecx # ecx<- A+
5848 sarl $4,rINST # rINST<- B
5849 GET_VREG_R %eax rINST # eax<- vB
5850 andb $0xf,%cl # ecx<- A
5852 imull (rFP,%ecx,4),%eax # trashes rIBASE/edx
5855 FETCH_INST_OPCODE 1 %ecx
5859 /* ------------------------------ */
5860 .L_OP_DIV_INT_2ADDR: /* 0xb3 */
5861 /* File: x86/OP_DIV_INT_2ADDR.S */
5862 /* File: x86/bindiv2addr.S */
5864 * 32-bit binary div/rem operation. Handles special case of op0=minint and
5867 /* div/rem/2addr vA, vB */
5868 movzx rINSTbl,%ecx # eax<- BA
5870 sarl $4,%ecx # ecx<- B
5871 GET_VREG_R %ecx %ecx # eax<- vBB
5872 andb $0xf,rINSTbl # rINST<- A
5873 GET_VREG_R %eax rINST # eax<- vBB
5875 je common_errDivideByZero
5877 jne .LOP_DIV_INT_2ADDR_continue_div2addr
5878 cmpl $0x80000000,%eax
5879 jne .LOP_DIV_INT_2ADDR_continue_div2addr
5880 movl $0x80000000,%eax
5883 FETCH_INST_OPCODE 1 %ecx
5887 .LOP_DIV_INT_2ADDR_continue_div2addr:
5892 FETCH_INST_OPCODE 1 %ecx
5897 /* ------------------------------ */
5898 .L_OP_REM_INT_2ADDR: /* 0xb4 */
5899 /* File: x86/OP_REM_INT_2ADDR.S */
5900 /* File: x86/bindiv2addr.S */
5902 * 32-bit binary div/rem operation. Handles special case of op0=minint and
5905 /* div/rem/2addr vA, vB */
5906 movzx rINSTbl,%ecx # eax<- BA
5908 sarl $4,%ecx # ecx<- B
5909 GET_VREG_R %ecx %ecx # eax<- vBB
5910 andb $0xf,rINSTbl # rINST<- A
5911 GET_VREG_R %eax rINST # eax<- vBB
5913 je common_errDivideByZero
5915 jne .LOP_REM_INT_2ADDR_continue_div2addr
5916 cmpl $0x80000000,%eax
5917 jne .LOP_REM_INT_2ADDR_continue_div2addr
5919 SET_VREG rIBASE rINST
5921 FETCH_INST_OPCODE 1 %ecx
5925 .LOP_REM_INT_2ADDR_continue_div2addr:
5928 SET_VREG rIBASE rINST
5930 FETCH_INST_OPCODE 1 %ecx
5935 /* ------------------------------ */
5936 .L_OP_AND_INT_2ADDR: /* 0xb5 */
5937 /* File: x86/OP_AND_INT_2ADDR.S */
5938 /* File: x86/binop2addr.S */
5940 * Generic 32-bit "/2addr" binary operation. Provide an "instr" line
5941 * that specifies an instruction that performs "result = r0 op r1".
5942 * This could be an ARM instruction or a function call. (If the result
5943 * comes back in a register other than r0, you can override "result".)
5945 * If "chkzero" is set to 1, we perform a divide-by-zero check on
5946 * vCC (r1). Useful for integer division and modulus.
5948 * For: add-int/2addr, sub-int/2addr, mul-int/2addr, div-int/2addr,
5949 * rem-int/2addr, and-int/2addr, or-int/2addr, xor-int/2addr,
5950 * shl-int/2addr, shr-int/2addr, ushr-int/2addr, add-float/2addr,
5951 * sub-float/2addr, mul-float/2addr, div-float/2addr, rem-float/2addr
5953 /* binop/2addr vA, vB */
5954 movzx rINSTbl,%ecx # ecx<- A+
5955 sarl $4,rINST # rINST<- B
5956 GET_VREG_R %eax rINST # eax<- vB
5957 andb $0xf,%cl # ecx<- A
5958 andl %eax,(rFP,%ecx,4) # for ex: addl %eax,(rFP,%ecx,4)
5959 FETCH_INST_OPCODE 1 %ecx
5964 /* ------------------------------ */
5965 .L_OP_OR_INT_2ADDR: /* 0xb6 */
5966 /* File: x86/OP_OR_INT_2ADDR.S */
5967 /* File: x86/binop2addr.S */
5969 * Generic 32-bit "/2addr" binary operation. Provide an "instr" line
5970 * that specifies an instruction that performs "result = r0 op r1".
5971 * This could be an ARM instruction or a function call. (If the result
5972 * comes back in a register other than r0, you can override "result".)
5974 * If "chkzero" is set to 1, we perform a divide-by-zero check on
5975 * vCC (r1). Useful for integer division and modulus.
5977 * For: add-int/2addr, sub-int/2addr, mul-int/2addr, div-int/2addr,
5978 * rem-int/2addr, and-int/2addr, or-int/2addr, xor-int/2addr,
5979 * shl-int/2addr, shr-int/2addr, ushr-int/2addr, add-float/2addr,
5980 * sub-float/2addr, mul-float/2addr, div-float/2addr, rem-float/2addr
5982 /* binop/2addr vA, vB */
5983 movzx rINSTbl,%ecx # ecx<- A+
5984 sarl $4,rINST # rINST<- B
5985 GET_VREG_R %eax rINST # eax<- vB
5986 andb $0xf,%cl # ecx<- A
5987 orl %eax,(rFP,%ecx,4) # for ex: addl %eax,(rFP,%ecx,4)
5988 FETCH_INST_OPCODE 1 %ecx
5993 /* ------------------------------ */
5994 .L_OP_XOR_INT_2ADDR: /* 0xb7 */
5995 /* File: x86/OP_XOR_INT_2ADDR.S */
5996 /* File: x86/binop2addr.S */
5998 * Generic 32-bit "/2addr" binary operation. Provide an "instr" line
5999 * that specifies an instruction that performs "result = r0 op r1".
6000 * This could be an ARM instruction or a function call. (If the result
6001 * comes back in a register other than r0, you can override "result".)
6003 * If "chkzero" is set to 1, we perform a divide-by-zero check on
6004 * vCC (r1). Useful for integer division and modulus.
6006 * For: add-int/2addr, sub-int/2addr, mul-int/2addr, div-int/2addr,
6007 * rem-int/2addr, and-int/2addr, or-int/2addr, xor-int/2addr,
6008 * shl-int/2addr, shr-int/2addr, ushr-int/2addr, add-float/2addr,
6009 * sub-float/2addr, mul-float/2addr, div-float/2addr, rem-float/2addr
6011 /* binop/2addr vA, vB */
6012 movzx rINSTbl,%ecx # ecx<- A+
6013 sarl $4,rINST # rINST<- B
6014 GET_VREG_R %eax rINST # eax<- vB
6015 andb $0xf,%cl # ecx<- A
6016 xorl %eax,(rFP,%ecx,4) # for ex: addl %eax,(rFP,%ecx,4)
6017 FETCH_INST_OPCODE 1 %ecx
6022 /* ------------------------------ */
6023 .L_OP_SHL_INT_2ADDR: /* 0xb8 */
6024 /* File: x86/OP_SHL_INT_2ADDR.S */
6025 /* File: x86/shop2addr.S */
6027 * Generic 32-bit "shift/2addr" operation.
6029 /* shift/2addr vA, vB */
6030 movzx rINSTbl,%ecx # eax<- BA
6031 sarl $4,%ecx # ecx<- B
6032 GET_VREG_R %ecx %ecx # eax<- vBB
6033 andb $0xf,rINSTbl # rINST<- A
6034 GET_VREG_R %eax rINST # eax<- vAA
6035 sall %cl,%eax # ex: sarl %cl,%eax
6036 FETCH_INST_OPCODE 1 %ecx
6042 /* ------------------------------ */
6043 .L_OP_SHR_INT_2ADDR: /* 0xb9 */
6044 /* File: x86/OP_SHR_INT_2ADDR.S */
6045 /* File: x86/shop2addr.S */
6047 * Generic 32-bit "shift/2addr" operation.
6049 /* shift/2addr vA, vB */
6050 movzx rINSTbl,%ecx # eax<- BA
6051 sarl $4,%ecx # ecx<- B
6052 GET_VREG_R %ecx %ecx # eax<- vBB
6053 andb $0xf,rINSTbl # rINST<- A
6054 GET_VREG_R %eax rINST # eax<- vAA
6055 sarl %cl,%eax # ex: sarl %cl,%eax
6056 FETCH_INST_OPCODE 1 %ecx
6062 /* ------------------------------ */
6063 .L_OP_USHR_INT_2ADDR: /* 0xba */
6064 /* File: x86/OP_USHR_INT_2ADDR.S */
6065 /* File: x86/shop2addr.S */
6067 * Generic 32-bit "shift/2addr" operation.
6069 /* shift/2addr vA, vB */
6070 movzx rINSTbl,%ecx # eax<- BA
6071 sarl $4,%ecx # ecx<- B
6072 GET_VREG_R %ecx %ecx # eax<- vBB
6073 andb $0xf,rINSTbl # rINST<- A
6074 GET_VREG_R %eax rINST # eax<- vAA
6075 shrl %cl,%eax # ex: sarl %cl,%eax
6076 FETCH_INST_OPCODE 1 %ecx
6082 /* ------------------------------ */
6083 .L_OP_ADD_LONG_2ADDR: /* 0xbb */
6084 /* File: x86/OP_ADD_LONG_2ADDR.S */
6085 /* File: x86/binopWide2addr.S */
6087 * Generic 64-bit binary operation.
6089 /* binop/2addr vA, vB */
6090 movzbl rINSTbl,%ecx # ecx<- BA
6091 sarl $4,%ecx # ecx<- B
6092 GET_VREG_WORD %eax %ecx 0 # eax<- v[B+0]
6093 GET_VREG_WORD %ecx %ecx 1 # eax<- v[B+1]
6094 andb $0xF,rINSTbl # rINST<- A
6095 addl %eax,(rFP,rINST,4) # example: addl %eax,(rFP,rINST,4)
6096 adcl %ecx,4(rFP,rINST,4) # example: adcl %ecx,4(rFP,rINST,4)
6097 FETCH_INST_OPCODE 1 %ecx
6102 /* ------------------------------ */
6103 .L_OP_SUB_LONG_2ADDR: /* 0xbc */
6104 /* File: x86/OP_SUB_LONG_2ADDR.S */
6105 /* File: x86/binopWide2addr.S */
6107 * Generic 64-bit binary operation.
6109 /* binop/2addr vA, vB */
6110 movzbl rINSTbl,%ecx # ecx<- BA
6111 sarl $4,%ecx # ecx<- B
6112 GET_VREG_WORD %eax %ecx 0 # eax<- v[B+0]
6113 GET_VREG_WORD %ecx %ecx 1 # eax<- v[B+1]
6114 andb $0xF,rINSTbl # rINST<- A
6115 subl %eax,(rFP,rINST,4) # example: addl %eax,(rFP,rINST,4)
6116 sbbl %ecx,4(rFP,rINST,4) # example: adcl %ecx,4(rFP,rINST,4)
6117 FETCH_INST_OPCODE 1 %ecx
6122 /* ------------------------------ */
6123 .L_OP_MUL_LONG_2ADDR: /* 0xbd */
6124 /* File: x86/OP_MUL_LONG_2ADDR.S */
6126 * Signed 64-bit integer multiply, 2-addr version
6128 * We could definately use more free registers for
6129 * this code. We must spill %edx (rIBASE) because it
6130 * is used by imul. We'll also spill rINST (ebx),
6131 * giving us eax, ebc, ecx and rIBASE as computational
6132 * temps. On top of that, we'll spill %esi (edi)
6133 * for use as the vA pointer and rFP (esi) for use
6134 * as the vB pointer. Yuck.
6136 /* mul-long/2addr vA, vB */
6137 movzbl rINSTbl,%eax # eax<- BA
6138 andb $0xf,%al # eax<- A
6139 sarl $4,rINST # rINST<- B
6143 leal (rFP,%eax,4),%esi # %esi<- &v[A]
6144 leal (rFP,rINST,4),rFP # rFP<- &v[B]
6145 movl 4(%esi),%ecx # ecx<- Amsw
6146 imull (rFP),%ecx # ecx<- (Amsw*Blsw)
6147 movl 4(rFP),%eax # eax<- Bmsw
6148 imull (%esi),%eax # eax<- (Bmsw*Alsw)
6149 addl %eax,%ecx # ecx<- (Amsw*Blsw)+(Bmsw*Alsw)
6150 movl (rFP),%eax # eax<- Blsw
6151 mull (%esi) # eax<- (Blsw*Alsw)
6152 leal (%ecx,rIBASE),rIBASE # full result now in %edx:%eax
6153 movl rIBASE,4(%esi) # v[A+1]<- rIBASE
6154 movl %eax,(%esi) # v[A]<- %eax
6156 FETCH_INST_OPCODE 1 %ecx
6162 /* ------------------------------ */
6163 .L_OP_DIV_LONG_2ADDR: /* 0xbe */
6164 /* File: x86/OP_DIV_LONG_2ADDR.S */
6165 /* div/2addr vA, vB */
6167 shrl $4,%eax # eax<- B
6168 andb $0xf,rINSTbl # rINST<- A
6169 SPILL(rIBASE) # save rIBASE/%edx
6170 GET_VREG_WORD rIBASE %eax 0
6171 GET_VREG_WORD %eax %eax 1
6172 movl rIBASE,OUT_ARG2(%esp)
6174 je .LOP_DIV_LONG_2ADDR_check_zero
6176 je .LOP_DIV_LONG_2ADDR_check_neg1
6177 .LOP_DIV_LONG_2ADDR_notSpecial:
6178 GET_VREG_WORD rIBASE rINST 0
6179 GET_VREG_WORD %ecx rINST 1
6180 .LOP_DIV_LONG_2ADDR_notSpecial1:
6181 movl %eax,OUT_ARG3(%esp)
6182 movl rIBASE,OUT_ARG0(%esp)
6183 movl %ecx,OUT_ARG1(%esp)
6185 .LOP_DIV_LONG_2ADDR_finish:
6186 SET_VREG_WORD rIBASE rINST 1
6187 UNSPILL(rIBASE) # restore rIBASE/%edx
6188 SET_VREG_WORD %eax rINST 0
6189 FETCH_INST_OPCODE 1 %ecx
6193 .LOP_DIV_LONG_2ADDR_check_zero:
6195 jne .LOP_DIV_LONG_2ADDR_notSpecial
6196 jmp common_errDivideByZero
6197 .LOP_DIV_LONG_2ADDR_check_neg1:
6199 jne .LOP_DIV_LONG_2ADDR_notSpecial
6200 GET_VREG_WORD rIBASE rINST 0
6201 GET_VREG_WORD %ecx rINST 1
6203 jne .LOP_DIV_LONG_2ADDR_notSpecial1
6204 cmpl $0x80000000,%ecx
6205 jne .LOP_DIV_LONG_2ADDR_notSpecial1
6206 /* minint / -1, return minint on div, 0 on rem */
6208 movl $0x80000000,rIBASE
6209 jmp .LOP_DIV_LONG_2ADDR_finish
6211 /* ------------------------------ */
6212 .L_OP_REM_LONG_2ADDR: /* 0xbf */
6213 /* File: x86/OP_REM_LONG_2ADDR.S */
6214 /* File: x86/OP_DIV_LONG_2ADDR.S */
6215 /* div/2addr vA, vB */
6217 shrl $4,%eax # eax<- B
6218 andb $0xf,rINSTbl # rINST<- A
6219 SPILL(rIBASE) # save rIBASE/%edx
6220 GET_VREG_WORD rIBASE %eax 0
6221 GET_VREG_WORD %eax %eax 1
6222 movl rIBASE,OUT_ARG2(%esp)
6224 je .LOP_REM_LONG_2ADDR_check_zero
6226 je .LOP_REM_LONG_2ADDR_check_neg1
6227 .LOP_REM_LONG_2ADDR_notSpecial:
6228 GET_VREG_WORD rIBASE rINST 0
6229 GET_VREG_WORD %ecx rINST 1
6230 .LOP_REM_LONG_2ADDR_notSpecial1:
6231 movl %eax,OUT_ARG3(%esp)
6232 movl rIBASE,OUT_ARG0(%esp)
6233 movl %ecx,OUT_ARG1(%esp)
6235 .LOP_REM_LONG_2ADDR_finish:
6236 SET_VREG_WORD rIBASE rINST 1
6237 UNSPILL(rIBASE) # restore rIBASE/%edx
6238 SET_VREG_WORD %eax rINST 0
6239 FETCH_INST_OPCODE 1 %ecx
6243 .LOP_REM_LONG_2ADDR_check_zero:
6245 jne .LOP_REM_LONG_2ADDR_notSpecial
6246 jmp common_errDivideByZero
6247 .LOP_REM_LONG_2ADDR_check_neg1:
6249 jne .LOP_REM_LONG_2ADDR_notSpecial
6250 GET_VREG_WORD rIBASE rINST 0
6251 GET_VREG_WORD %ecx rINST 1
6253 jne .LOP_REM_LONG_2ADDR_notSpecial1
6254 cmpl $0x80000000,%ecx
6255 jne .LOP_REM_LONG_2ADDR_notSpecial1
6256 /* minint / -1, return minint on div, 0 on rem */
6259 jmp .LOP_REM_LONG_2ADDR_finish
6262 /* ------------------------------ */
6263 .L_OP_AND_LONG_2ADDR: /* 0xc0 */
6264 /* File: x86/OP_AND_LONG_2ADDR.S */
6265 /* File: x86/binopWide2addr.S */
6267 * Generic 64-bit binary operation.
6269 /* binop/2addr vA, vB */
6270 movzbl rINSTbl,%ecx # ecx<- BA
6271 sarl $4,%ecx # ecx<- B
6272 GET_VREG_WORD %eax %ecx 0 # eax<- v[B+0]
6273 GET_VREG_WORD %ecx %ecx 1 # eax<- v[B+1]
6274 andb $0xF,rINSTbl # rINST<- A
6275 andl %eax,(rFP,rINST,4) # example: addl %eax,(rFP,rINST,4)
6276 andl %ecx,4(rFP,rINST,4) # example: adcl %ecx,4(rFP,rINST,4)
6277 FETCH_INST_OPCODE 1 %ecx
6282 /* ------------------------------ */
6283 .L_OP_OR_LONG_2ADDR: /* 0xc1 */
6284 /* File: x86/OP_OR_LONG_2ADDR.S */
6285 /* File: x86/binopWide2addr.S */
6287 * Generic 64-bit binary operation.
6289 /* binop/2addr vA, vB */
6290 movzbl rINSTbl,%ecx # ecx<- BA
6291 sarl $4,%ecx # ecx<- B
6292 GET_VREG_WORD %eax %ecx 0 # eax<- v[B+0]
6293 GET_VREG_WORD %ecx %ecx 1 # eax<- v[B+1]
6294 andb $0xF,rINSTbl # rINST<- A
6295 orl %eax,(rFP,rINST,4) # example: addl %eax,(rFP,rINST,4)
6296 orl %ecx,4(rFP,rINST,4) # example: adcl %ecx,4(rFP,rINST,4)
6297 FETCH_INST_OPCODE 1 %ecx
6302 /* ------------------------------ */
6303 .L_OP_XOR_LONG_2ADDR: /* 0xc2 */
6304 /* File: x86/OP_XOR_LONG_2ADDR.S */
6305 /* File: x86/binopWide2addr.S */
6307 * Generic 64-bit binary operation.
6309 /* binop/2addr vA, vB */
6310 movzbl rINSTbl,%ecx # ecx<- BA
6311 sarl $4,%ecx # ecx<- B
6312 GET_VREG_WORD %eax %ecx 0 # eax<- v[B+0]
6313 GET_VREG_WORD %ecx %ecx 1 # eax<- v[B+1]
6314 andb $0xF,rINSTbl # rINST<- A
6315 xorl %eax,(rFP,rINST,4) # example: addl %eax,(rFP,rINST,4)
6316 xorl %ecx,4(rFP,rINST,4) # example: adcl %ecx,4(rFP,rINST,4)
6317 FETCH_INST_OPCODE 1 %ecx
6322 /* ------------------------------ */
6323 .L_OP_SHL_LONG_2ADDR: /* 0xc3 */
6324 /* File: x86/OP_SHL_LONG_2ADDR.S */
6326 * Long integer shift, 2addr version. vA is 64-bit value/result, vB is
6327 * 32-bit shift distance.
6329 /* shl-long/2addr vA, vB */
6330 /* ecx gets shift count */
6331 /* Need to spill rIBASE */
6332 /* rINSTw gets AA */
6333 movzbl rINSTbl,%ecx # ecx<- BA
6334 andb $0xf,rINSTbl # rINST<- A
6335 GET_VREG_WORD %eax rINST 0 # eax<- v[AA+0]
6336 sarl $4,%ecx # ecx<- B
6338 GET_VREG_WORD rIBASE rINST 1 # rIBASE<- v[AA+1]
6339 GET_VREG_R %ecx %ecx # ecx<- vBB
6347 SET_VREG_WORD rIBASE rINST 1 # v[AA+1]<- rIBASE
6349 FETCH_INST_OPCODE 1 %ecx
6350 SET_VREG_WORD %eax rINST 0 # v[AA+0]<- eax
6354 /* ------------------------------ */
6355 .L_OP_SHR_LONG_2ADDR: /* 0xc4 */
6356 /* File: x86/OP_SHR_LONG_2ADDR.S */
6358 * Long integer shift, 2addr version. vA is 64-bit value/result, vB is
6359 * 32-bit shift distance.
6361 /* shl-long/2addr vA, vB */
6362 /* ecx gets shift count */
6363 /* Need to spill rIBASE */
6364 /* rINSTw gets AA */
6365 movzbl rINSTbl,%ecx # ecx<- BA
6366 andb $0xf,rINSTbl # rINST<- A
6367 GET_VREG_WORD %eax rINST 0 # eax<- v[AA+0]
6368 sarl $4,%ecx # ecx<- B
6370 GET_VREG_WORD rIBASE rINST 1 # rIBASE<- v[AA+1]
6371 GET_VREG_R %ecx %ecx # ecx<- vBB
6379 SET_VREG_WORD rIBASE rINST 1 # v[AA+1]<- rIBASE
6381 FETCH_INST_OPCODE 1 %ecx
6382 SET_VREG_WORD %eax rINST 0 # v[AA+0]<- eax
6386 /* ------------------------------ */
6387 .L_OP_USHR_LONG_2ADDR: /* 0xc5 */
6388 /* File: x86/OP_USHR_LONG_2ADDR.S */
6390 * Long integer shift, 2addr version. vA is 64-bit value/result, vB is
6391 * 32-bit shift distance.
6393 /* shl-long/2addr vA, vB */
6394 /* ecx gets shift count */
6395 /* Need to spill rIBASE */
6396 /* rINSTw gets AA */
6397 movzbl rINSTbl,%ecx # ecx<- BA
6398 andb $0xf,rINSTbl # rINST<- A
6399 GET_VREG_WORD %eax rINST 0 # eax<- v[AA+0]
6400 sarl $4,%ecx # ecx<- B
6402 GET_VREG_WORD rIBASE rINST 1 # rIBASE<- v[AA+1]
6403 GET_VREG_R %ecx %ecx # ecx<- vBB
6411 SET_VREG_WORD rIBASE rINST 1 # v[AA+1]<- rIBASE
6412 FETCH_INST_OPCODE 1 %ecx
6414 SET_VREG_WORD %eax rINST 0 # v[AA+0]<- eax
6418 /* ------------------------------ */
6419 .L_OP_ADD_FLOAT_2ADDR: /* 0xc6 */
6420 /* File: x86/OP_ADD_FLOAT_2ADDR.S */
6421 /* File: x86/binflop2addr.S */
6423 * Generic 32-bit binary float operation.
6425 * For: add-fp, sub-fp, mul-fp, div-fp
6428 /* binop/2addr vA, vB */
6429 movzx rINSTbl,%ecx # ecx<- A+
6430 andb $0xf,%cl # ecx<- A
6431 flds (rFP,%ecx,4) # vAA to fp stack
6432 sarl $4,rINST # rINST<- B
6433 fadds (rFP,rINST,4) # ex: faddp
6434 FETCH_INST_OPCODE 1 %eax
6436 fstps (rFP,%ecx,4) # %st to vA
6440 /* ------------------------------ */
6441 .L_OP_SUB_FLOAT_2ADDR: /* 0xc7 */
6442 /* File: x86/OP_SUB_FLOAT_2ADDR.S */
6443 /* File: x86/binflop2addr.S */
6445 * Generic 32-bit binary float operation.
6447 * For: add-fp, sub-fp, mul-fp, div-fp
6450 /* binop/2addr vA, vB */
6451 movzx rINSTbl,%ecx # ecx<- A+
6452 andb $0xf,%cl # ecx<- A
6453 flds (rFP,%ecx,4) # vAA to fp stack
6454 sarl $4,rINST # rINST<- B
6455 fsubs (rFP,rINST,4) # ex: faddp
6456 FETCH_INST_OPCODE 1 %eax
6458 fstps (rFP,%ecx,4) # %st to vA
6462 /* ------------------------------ */
6463 .L_OP_MUL_FLOAT_2ADDR: /* 0xc8 */
6464 /* File: x86/OP_MUL_FLOAT_2ADDR.S */
6465 /* File: x86/binflop2addr.S */
6467 * Generic 32-bit binary float operation.
6469 * For: add-fp, sub-fp, mul-fp, div-fp
6472 /* binop/2addr vA, vB */
6473 movzx rINSTbl,%ecx # ecx<- A+
6474 andb $0xf,%cl # ecx<- A
6475 flds (rFP,%ecx,4) # vAA to fp stack
6476 sarl $4,rINST # rINST<- B
6477 fmuls (rFP,rINST,4) # ex: faddp
6478 FETCH_INST_OPCODE 1 %eax
6480 fstps (rFP,%ecx,4) # %st to vA
6484 /* ------------------------------ */
6485 .L_OP_DIV_FLOAT_2ADDR: /* 0xc9 */
6486 /* File: x86/OP_DIV_FLOAT_2ADDR.S */
6487 /* File: x86/binflop2addr.S */
6489 * Generic 32-bit binary float operation.
6491 * For: add-fp, sub-fp, mul-fp, div-fp
6494 /* binop/2addr vA, vB */
6495 movzx rINSTbl,%ecx # ecx<- A+
6496 andb $0xf,%cl # ecx<- A
6497 flds (rFP,%ecx,4) # vAA to fp stack
6498 sarl $4,rINST # rINST<- B
6499 fdivs (rFP,rINST,4) # ex: faddp
6500 FETCH_INST_OPCODE 1 %eax
6502 fstps (rFP,%ecx,4) # %st to vA
6506 /* ------------------------------ */
6507 .L_OP_REM_FLOAT_2ADDR: /* 0xca */
6508 /* File: x86/OP_REM_FLOAT_2ADDR.S */
6509 /* rem_float/2addr vA, vB */
6510 movzx rINSTbl,%ecx # ecx<- A+
6511 sarl $4,rINST # rINST<- B
6512 flds (rFP,rINST,4) # vBB to fp stack
6513 andb $0xf,%cl # ecx<- A
6514 flds (rFP,%ecx,4) # vAA to fp stack
6521 FETCH_INST_OPCODE 1 %eax
6523 fstps (rFP,%ecx,4) # %st to vA
6526 /* ------------------------------ */
6527 .L_OP_ADD_DOUBLE_2ADDR: /* 0xcb */
6528 /* File: x86/OP_ADD_DOUBLE_2ADDR.S */
6529 /* File: x86/binflop2addr.S */
6531 * Generic 32-bit binary float operation.
6533 * For: add-fp, sub-fp, mul-fp, div-fp
6536 /* binop/2addr vA, vB */
6537 movzx rINSTbl,%ecx # ecx<- A+
6538 andb $0xf,%cl # ecx<- A
6539 fldl (rFP,%ecx,4) # vAA to fp stack
6540 sarl $4,rINST # rINST<- B
6541 faddl (rFP,rINST,4) # ex: faddp
6542 FETCH_INST_OPCODE 1 %eax
6544 fstpl (rFP,%ecx,4) # %st to vA
6548 /* ------------------------------ */
6549 .L_OP_SUB_DOUBLE_2ADDR: /* 0xcc */
6550 /* File: x86/OP_SUB_DOUBLE_2ADDR.S */
6551 /* File: x86/binflop2addr.S */
6553 * Generic 32-bit binary float operation.
6555 * For: add-fp, sub-fp, mul-fp, div-fp
6558 /* binop/2addr vA, vB */
6559 movzx rINSTbl,%ecx # ecx<- A+
6560 andb $0xf,%cl # ecx<- A
6561 fldl (rFP,%ecx,4) # vAA to fp stack
6562 sarl $4,rINST # rINST<- B
6563 fsubl (rFP,rINST,4) # ex: faddp
6564 FETCH_INST_OPCODE 1 %eax
6566 fstpl (rFP,%ecx,4) # %st to vA
6570 /* ------------------------------ */
6571 .L_OP_MUL_DOUBLE_2ADDR: /* 0xcd */
6572 /* File: x86/OP_MUL_DOUBLE_2ADDR.S */
6573 /* File: x86/binflop2addr.S */
6575 * Generic 32-bit binary float operation.
6577 * For: add-fp, sub-fp, mul-fp, div-fp
6580 /* binop/2addr vA, vB */
6581 movzx rINSTbl,%ecx # ecx<- A+
6582 andb $0xf,%cl # ecx<- A
6583 fldl (rFP,%ecx,4) # vAA to fp stack
6584 sarl $4,rINST # rINST<- B
6585 fmull (rFP,rINST,4) # ex: faddp
6586 FETCH_INST_OPCODE 1 %eax
6588 fstpl (rFP,%ecx,4) # %st to vA
6592 /* ------------------------------ */
6593 .L_OP_DIV_DOUBLE_2ADDR: /* 0xce */
6594 /* File: x86/OP_DIV_DOUBLE_2ADDR.S */
6595 /* File: x86/binflop2addr.S */
6597 * Generic 32-bit binary float operation.
6599 * For: add-fp, sub-fp, mul-fp, div-fp
6602 /* binop/2addr vA, vB */
6603 movzx rINSTbl,%ecx # ecx<- A+
6604 andb $0xf,%cl # ecx<- A
6605 fldl (rFP,%ecx,4) # vAA to fp stack
6606 sarl $4,rINST # rINST<- B
6607 fdivl (rFP,rINST,4) # ex: faddp
6608 FETCH_INST_OPCODE 1 %eax
6610 fstpl (rFP,%ecx,4) # %st to vA
6614 /* ------------------------------ */
6615 .L_OP_REM_DOUBLE_2ADDR: /* 0xcf */
6616 /* File: x86/OP_REM_DOUBLE_2ADDR.S */
6617 /* rem_float/2addr vA, vB */
6618 movzx rINSTbl,%ecx # ecx<- A+
6619 sarl $4,rINST # rINST<- B
6620 fldl (rFP,rINST,4) # vBB to fp stack
6621 andb $0xf,%cl # ecx<- A
6622 fldl (rFP,%ecx,4) # vAA to fp stack
6629 FETCH_INST_OPCODE 1 %eax
6631 fstpl (rFP,%ecx,4) # %st to vA
6634 /* ------------------------------ */
6635 .L_OP_ADD_INT_LIT16: /* 0xd0 */
6636 /* File: x86/OP_ADD_INT_LIT16.S */
6637 /* File: x86/binopLit16.S */
6639 * Generic 32-bit "lit16" binary operation. Provide an "instr" line
6640 * that specifies an instruction that performs "result = eax op ecx".
6641 * This could be an x86 instruction or a function call. (If the result
6642 * comes back in a register other than eax, you can override "result".)
6644 * For: add-int/lit16, rsub-int,
6645 * and-int/lit16, or-int/lit16, xor-int/lit16
6647 /* binop/lit16 vA, vB, #+CCCC */
6648 movzbl rINSTbl,%eax # eax<- 000000BA
6649 sarl $4,%eax # eax<- B
6650 GET_VREG_R %eax %eax # eax<- vB
6651 movswl 2(rPC),%ecx # ecx<- ssssCCCC
6652 andb $0xf,rINSTbl # rINST<- A
6653 addl %ecx,%eax # for example: addl %ecx, %eax
6655 FETCH_INST_OPCODE 2 %ecx
6660 /* ------------------------------ */
6661 .L_OP_RSUB_INT: /* 0xd1 */
6662 /* File: x86/OP_RSUB_INT.S */
6663 /* File: x86/binopLit16.S */
6665 * Generic 32-bit "lit16" binary operation. Provide an "instr" line
6666 * that specifies an instruction that performs "result = eax op ecx".
6667 * This could be an x86 instruction or a function call. (If the result
6668 * comes back in a register other than eax, you can override "result".)
6670 * For: add-int/lit16, rsub-int,
6671 * and-int/lit16, or-int/lit16, xor-int/lit16
6673 /* binop/lit16 vA, vB, #+CCCC */
6674 movzbl rINSTbl,%eax # eax<- 000000BA
6675 sarl $4,%eax # eax<- B
6676 GET_VREG_R %eax %eax # eax<- vB
6677 movswl 2(rPC),%ecx # ecx<- ssssCCCC
6678 andb $0xf,rINSTbl # rINST<- A
6679 subl %eax,%ecx # for example: addl %ecx, %eax
6681 FETCH_INST_OPCODE 2 %ecx
6686 /* ------------------------------ */
6687 .L_OP_MUL_INT_LIT16: /* 0xd2 */
6688 /* File: x86/OP_MUL_INT_LIT16.S */
6689 /* mul/lit16 vA, vB, #+CCCC */
6690 /* Need A in rINST, ssssCCCC in ecx, vB in eax */
6691 movzbl rINSTbl,%eax # eax<- 000000BA
6692 sarl $4,%eax # eax<- B
6693 GET_VREG_R %eax %eax # eax<- vB
6694 movswl 2(rPC),%ecx # ecx<- ssssCCCC
6695 andb $0xf,rINSTbl # rINST<- A
6697 imull %ecx,%eax # trashes rIBASE/edx
6699 FETCH_INST_OPCODE 2 %ecx
6704 /* ------------------------------ */
6705 .L_OP_DIV_INT_LIT16: /* 0xd3 */
6706 /* File: x86/OP_DIV_INT_LIT16.S */
6707 /* File: x86/bindivLit16.S */
6709 * 32-bit binary div/rem operation. Handles special case of op0=minint and
6712 /* div/rem/lit16 vA, vB, #+CCCC */
6713 /* Need A in rINST, ssssCCCC in ecx, vB in eax */
6714 movzbl rINSTbl,%eax # eax<- 000000BA
6716 sarl $4,%eax # eax<- B
6717 GET_VREG_R %eax %eax # eax<- vB
6718 movswl 2(rPC),%ecx # ecx<- ssssCCCC
6719 andb $0xf,rINSTbl # rINST<- A
6721 je common_errDivideByZero
6723 jne .LOP_DIV_INT_LIT16_continue_div
6724 cmpl $0x80000000,%eax
6725 jne .LOP_DIV_INT_LIT16_continue_div
6726 movl $0x80000000,%eax
6729 FETCH_INST_OPCODE 2 %ecx
6733 .LOP_DIV_INT_LIT16_continue_div:
6738 FETCH_INST_OPCODE 2 %ecx
6743 /* ------------------------------ */
6744 .L_OP_REM_INT_LIT16: /* 0xd4 */
6745 /* File: x86/OP_REM_INT_LIT16.S */
6746 /* File: x86/bindivLit16.S */
6748 * 32-bit binary div/rem operation. Handles special case of op0=minint and
6751 /* div/rem/lit16 vA, vB, #+CCCC */
6752 /* Need A in rINST, ssssCCCC in ecx, vB in eax */
6753 movzbl rINSTbl,%eax # eax<- 000000BA
6755 sarl $4,%eax # eax<- B
6756 GET_VREG_R %eax %eax # eax<- vB
6757 movswl 2(rPC),%ecx # ecx<- ssssCCCC
6758 andb $0xf,rINSTbl # rINST<- A
6760 je common_errDivideByZero
6762 jne .LOP_REM_INT_LIT16_continue_div
6763 cmpl $0x80000000,%eax
6764 jne .LOP_REM_INT_LIT16_continue_div
6766 SET_VREG rIBASE rINST
6768 FETCH_INST_OPCODE 2 %ecx
6772 .LOP_REM_INT_LIT16_continue_div:
6775 SET_VREG rIBASE rINST
6777 FETCH_INST_OPCODE 2 %ecx
6782 /* ------------------------------ */
6783 .L_OP_AND_INT_LIT16: /* 0xd5 */
6784 /* File: x86/OP_AND_INT_LIT16.S */
6785 /* File: x86/binopLit16.S */
6787 * Generic 32-bit "lit16" binary operation. Provide an "instr" line
6788 * that specifies an instruction that performs "result = eax op ecx".
6789 * This could be an x86 instruction or a function call. (If the result
6790 * comes back in a register other than eax, you can override "result".)
6792 * For: add-int/lit16, rsub-int,
6793 * and-int/lit16, or-int/lit16, xor-int/lit16
6795 /* binop/lit16 vA, vB, #+CCCC */
6796 movzbl rINSTbl,%eax # eax<- 000000BA
6797 sarl $4,%eax # eax<- B
6798 GET_VREG_R %eax %eax # eax<- vB
6799 movswl 2(rPC),%ecx # ecx<- ssssCCCC
6800 andb $0xf,rINSTbl # rINST<- A
6801 andl %ecx,%eax # for example: addl %ecx, %eax
6803 FETCH_INST_OPCODE 2 %ecx
6808 /* ------------------------------ */
6809 .L_OP_OR_INT_LIT16: /* 0xd6 */
6810 /* File: x86/OP_OR_INT_LIT16.S */
6811 /* File: x86/binopLit16.S */
6813 * Generic 32-bit "lit16" binary operation. Provide an "instr" line
6814 * that specifies an instruction that performs "result = eax op ecx".
6815 * This could be an x86 instruction or a function call. (If the result
6816 * comes back in a register other than eax, you can override "result".)
6818 * For: add-int/lit16, rsub-int,
6819 * and-int/lit16, or-int/lit16, xor-int/lit16
6821 /* binop/lit16 vA, vB, #+CCCC */
6822 movzbl rINSTbl,%eax # eax<- 000000BA
6823 sarl $4,%eax # eax<- B
6824 GET_VREG_R %eax %eax # eax<- vB
6825 movswl 2(rPC),%ecx # ecx<- ssssCCCC
6826 andb $0xf,rINSTbl # rINST<- A
6827 orl %ecx,%eax # for example: addl %ecx, %eax
6829 FETCH_INST_OPCODE 2 %ecx
6834 /* ------------------------------ */
6835 .L_OP_XOR_INT_LIT16: /* 0xd7 */
6836 /* File: x86/OP_XOR_INT_LIT16.S */
6837 /* File: x86/binopLit16.S */
6839 * Generic 32-bit "lit16" binary operation. Provide an "instr" line
6840 * that specifies an instruction that performs "result = eax op ecx".
6841 * This could be an x86 instruction or a function call. (If the result
6842 * comes back in a register other than eax, you can override "result".)
6844 * For: add-int/lit16, rsub-int,
6845 * and-int/lit16, or-int/lit16, xor-int/lit16
6847 /* binop/lit16 vA, vB, #+CCCC */
6848 movzbl rINSTbl,%eax # eax<- 000000BA
6849 sarl $4,%eax # eax<- B
6850 GET_VREG_R %eax %eax # eax<- vB
6851 movswl 2(rPC),%ecx # ecx<- ssssCCCC
6852 andb $0xf,rINSTbl # rINST<- A
6853 xor %ecx,%eax # for example: addl %ecx, %eax
6855 FETCH_INST_OPCODE 2 %ecx
6860 /* ------------------------------ */
6861 .L_OP_ADD_INT_LIT8: /* 0xd8 */
6862 /* File: x86/OP_ADD_INT_LIT8.S */
6863 /* File: x86/binopLit8.S */
6865 * Generic 32-bit "lit8" binary operation. Provide an "instr" line
6866 * that specifies an instruction that performs "result = eax op ecx".
6867 * This could be an x86 instruction or a function call. (If the result
6868 * comes back in a register other than r0, you can override "result".)
6870 * For: add-int/lit8, rsub-int/lit8
6871 * and-int/lit8, or-int/lit8, xor-int/lit8,
6872 * shl-int/lit8, shr-int/lit8, ushr-int/lit8
6874 /* binop/lit8 vAA, vBB, #+CC */
6875 movzbl 2(rPC),%eax # eax<- BB
6876 movsbl 3(rPC),%ecx # ecx<- ssssssCC
6877 GET_VREG_R %eax %eax # eax<- rBB
6878 addl %ecx,%eax # ex: addl %ecx,%eax
6880 FETCH_INST_OPCODE 2 %ecx
6885 /* ------------------------------ */
6886 .L_OP_RSUB_INT_LIT8: /* 0xd9 */
6887 /* File: x86/OP_RSUB_INT_LIT8.S */
6888 /* File: x86/binopLit8.S */
6890 * Generic 32-bit "lit8" binary operation. Provide an "instr" line
6891 * that specifies an instruction that performs "result = eax op ecx".
6892 * This could be an x86 instruction or a function call. (If the result
6893 * comes back in a register other than r0, you can override "result".)
6895 * For: add-int/lit8, rsub-int/lit8
6896 * and-int/lit8, or-int/lit8, xor-int/lit8,
6897 * shl-int/lit8, shr-int/lit8, ushr-int/lit8
6899 /* binop/lit8 vAA, vBB, #+CC */
6900 movzbl 2(rPC),%eax # eax<- BB
6901 movsbl 3(rPC),%ecx # ecx<- ssssssCC
6902 GET_VREG_R %eax %eax # eax<- rBB
6903 subl %eax,%ecx # ex: addl %ecx,%eax
6905 FETCH_INST_OPCODE 2 %ecx
6910 /* ------------------------------ */
6911 .L_OP_MUL_INT_LIT8: /* 0xda */
6912 /* File: x86/OP_MUL_INT_LIT8.S */
6913 /* mul/lit8 vAA, vBB, #+CC */
6914 movzbl 2(rPC),%eax # eax<- BB
6915 movsbl 3(rPC),%ecx # ecx<- ssssssCC
6916 GET_VREG_R %eax %eax # eax<- rBB
6918 imull %ecx,%eax # trashes rIBASE/edx
6920 FETCH_INST_OPCODE 2 %ecx
6925 /* ------------------------------ */
6926 .L_OP_DIV_INT_LIT8: /* 0xdb */
6927 /* File: x86/OP_DIV_INT_LIT8.S */
6928 /* File: x86/bindivLit8.S */
6930 * 32-bit div/rem "lit8" binary operation. Handles special case of
6931 * op0=minint & op1=-1
6933 /* div/rem/lit8 vAA, vBB, #+CC */
6934 movzbl 2(rPC),%eax # eax<- BB
6935 movsbl 3(rPC),%ecx # ecx<- ssssssCC
6937 GET_VREG_R %eax %eax # eax<- rBB
6939 je common_errDivideByZero
6940 cmpl $0x80000000,%eax
6941 jne .LOP_DIV_INT_LIT8_continue_div
6943 jne .LOP_DIV_INT_LIT8_continue_div
6944 movl $0x80000000,%eax
6947 FETCH_INST_OPCODE 2 %ecx
6951 .LOP_DIV_INT_LIT8_continue_div:
6956 FETCH_INST_OPCODE 2 %ecx
6961 /* ------------------------------ */
6962 .L_OP_REM_INT_LIT8: /* 0xdc */
6963 /* File: x86/OP_REM_INT_LIT8.S */
6964 /* File: x86/bindivLit8.S */
6966 * 32-bit div/rem "lit8" binary operation. Handles special case of
6967 * op0=minint & op1=-1
6969 /* div/rem/lit8 vAA, vBB, #+CC */
6970 movzbl 2(rPC),%eax # eax<- BB
6971 movsbl 3(rPC),%ecx # ecx<- ssssssCC
6973 GET_VREG_R %eax %eax # eax<- rBB
6975 je common_errDivideByZero
6976 cmpl $0x80000000,%eax
6977 jne .LOP_REM_INT_LIT8_continue_div
6979 jne .LOP_REM_INT_LIT8_continue_div
6981 SET_VREG rIBASE rINST
6983 FETCH_INST_OPCODE 2 %ecx
6987 .LOP_REM_INT_LIT8_continue_div:
6990 SET_VREG rIBASE rINST
6992 FETCH_INST_OPCODE 2 %ecx
6997 /* ------------------------------ */
6998 .L_OP_AND_INT_LIT8: /* 0xdd */
6999 /* File: x86/OP_AND_INT_LIT8.S */
7000 /* File: x86/binopLit8.S */
7002 * Generic 32-bit "lit8" binary operation. Provide an "instr" line
7003 * that specifies an instruction that performs "result = eax op ecx".
7004 * This could be an x86 instruction or a function call. (If the result
7005 * comes back in a register other than r0, you can override "result".)
7007 * For: add-int/lit8, rsub-int/lit8
7008 * and-int/lit8, or-int/lit8, xor-int/lit8,
7009 * shl-int/lit8, shr-int/lit8, ushr-int/lit8
7011 /* binop/lit8 vAA, vBB, #+CC */
7012 movzbl 2(rPC),%eax # eax<- BB
7013 movsbl 3(rPC),%ecx # ecx<- ssssssCC
7014 GET_VREG_R %eax %eax # eax<- rBB
7015 andl %ecx,%eax # ex: addl %ecx,%eax
7017 FETCH_INST_OPCODE 2 %ecx
7022 /* ------------------------------ */
7023 .L_OP_OR_INT_LIT8: /* 0xde */
7024 /* File: x86/OP_OR_INT_LIT8.S */
7025 /* File: x86/binopLit8.S */
7027 * Generic 32-bit "lit8" binary operation. Provide an "instr" line
7028 * that specifies an instruction that performs "result = eax op ecx".
7029 * This could be an x86 instruction or a function call. (If the result
7030 * comes back in a register other than r0, you can override "result".)
7032 * For: add-int/lit8, rsub-int/lit8
7033 * and-int/lit8, or-int/lit8, xor-int/lit8,
7034 * shl-int/lit8, shr-int/lit8, ushr-int/lit8
7036 /* binop/lit8 vAA, vBB, #+CC */
7037 movzbl 2(rPC),%eax # eax<- BB
7038 movsbl 3(rPC),%ecx # ecx<- ssssssCC
7039 GET_VREG_R %eax %eax # eax<- rBB
7040 orl %ecx,%eax # ex: addl %ecx,%eax
7042 FETCH_INST_OPCODE 2 %ecx
7047 /* ------------------------------ */
7048 .L_OP_XOR_INT_LIT8: /* 0xdf */
7049 /* File: x86/OP_XOR_INT_LIT8.S */
7050 /* File: x86/binopLit8.S */
7052 * Generic 32-bit "lit8" binary operation. Provide an "instr" line
7053 * that specifies an instruction that performs "result = eax op ecx".
7054 * This could be an x86 instruction or a function call. (If the result
7055 * comes back in a register other than r0, you can override "result".)
7057 * For: add-int/lit8, rsub-int/lit8
7058 * and-int/lit8, or-int/lit8, xor-int/lit8,
7059 * shl-int/lit8, shr-int/lit8, ushr-int/lit8
7061 /* binop/lit8 vAA, vBB, #+CC */
7062 movzbl 2(rPC),%eax # eax<- BB
7063 movsbl 3(rPC),%ecx # ecx<- ssssssCC
7064 GET_VREG_R %eax %eax # eax<- rBB
7065 xor %ecx,%eax # ex: addl %ecx,%eax
7067 FETCH_INST_OPCODE 2 %ecx
7072 /* ------------------------------ */
7073 .L_OP_SHL_INT_LIT8: /* 0xe0 */
7074 /* File: x86/OP_SHL_INT_LIT8.S */
7075 /* File: x86/binopLit8.S */
7077 * Generic 32-bit "lit8" binary operation. Provide an "instr" line
7078 * that specifies an instruction that performs "result = eax op ecx".
7079 * This could be an x86 instruction or a function call. (If the result
7080 * comes back in a register other than r0, you can override "result".)
7082 * For: add-int/lit8, rsub-int/lit8
7083 * and-int/lit8, or-int/lit8, xor-int/lit8,
7084 * shl-int/lit8, shr-int/lit8, ushr-int/lit8
7086 /* binop/lit8 vAA, vBB, #+CC */
7087 movzbl 2(rPC),%eax # eax<- BB
7088 movsbl 3(rPC),%ecx # ecx<- ssssssCC
7089 GET_VREG_R %eax %eax # eax<- rBB
7090 sall %cl,%eax # ex: addl %ecx,%eax
7092 FETCH_INST_OPCODE 2 %ecx
7097 /* ------------------------------ */
7098 .L_OP_SHR_INT_LIT8: /* 0xe1 */
7099 /* File: x86/OP_SHR_INT_LIT8.S */
7100 /* File: x86/binopLit8.S */
7102 * Generic 32-bit "lit8" binary operation. Provide an "instr" line
7103 * that specifies an instruction that performs "result = eax op ecx".
7104 * This could be an x86 instruction or a function call. (If the result
7105 * comes back in a register other than r0, you can override "result".)
7107 * For: add-int/lit8, rsub-int/lit8
7108 * and-int/lit8, or-int/lit8, xor-int/lit8,
7109 * shl-int/lit8, shr-int/lit8, ushr-int/lit8
7111 /* binop/lit8 vAA, vBB, #+CC */
7112 movzbl 2(rPC),%eax # eax<- BB
7113 movsbl 3(rPC),%ecx # ecx<- ssssssCC
7114 GET_VREG_R %eax %eax # eax<- rBB
7115 sarl %cl,%eax # ex: addl %ecx,%eax
7117 FETCH_INST_OPCODE 2 %ecx
7122 /* ------------------------------ */
7123 .L_OP_USHR_INT_LIT8: /* 0xe2 */
7124 /* File: x86/OP_USHR_INT_LIT8.S */
7125 /* File: x86/binopLit8.S */
7127 * Generic 32-bit "lit8" binary operation. Provide an "instr" line
7128 * that specifies an instruction that performs "result = eax op ecx".
7129 * This could be an x86 instruction or a function call. (If the result
7130 * comes back in a register other than r0, you can override "result".)
7132 * For: add-int/lit8, rsub-int/lit8
7133 * and-int/lit8, or-int/lit8, xor-int/lit8,
7134 * shl-int/lit8, shr-int/lit8, ushr-int/lit8
7136 /* binop/lit8 vAA, vBB, #+CC */
7137 movzbl 2(rPC),%eax # eax<- BB
7138 movsbl 3(rPC),%ecx # ecx<- ssssssCC
7139 GET_VREG_R %eax %eax # eax<- rBB
7140 shrl %cl,%eax # ex: addl %ecx,%eax
7142 FETCH_INST_OPCODE 2 %ecx
7147 /* ------------------------------ */
7148 .L_OP_IGET_VOLATILE: /* 0xe3 */
7149 /* File: x86/OP_IGET_VOLATILE.S */
7150 /* File: x86/OP_IGET.S */
7152 * General 32-bit instance field get.
7154 * for: iget, iget-object, iget-boolean, iget-byte, iget-char, iget-short
7156 /* op vA, vB, field@CCCC */
7158 SPILL(rIBASE) # preserve rIBASE
7159 movzwl 2(rPC),rIBASE # rIBASE<- 0000CCCC
7160 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex
7161 movzbl rINSTbl,%ecx # ecx<- BA
7162 sarl $4,%ecx # ecx<- B
7163 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields
7164 andb $0xf,rINSTbl # rINST<- A
7165 GET_VREG_R %ecx %ecx # ecx<- fp[B], the object ptr
7166 movl (%eax,rIBASE,4),%eax # resolved entry
7167 testl %eax,%eax # is resolved entry null?
7168 jne .LOP_IGET_VOLATILE_finish # no, already resolved
7169 movl rIBASE,OUT_ARG1(%esp) # needed by dvmResolveInstField
7172 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method
7173 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz
7174 SPILL_TMP1(%ecx) # save obj pointer across call
7175 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz
7176 call dvmResolveInstField # ... to dvmResolveInstField
7178 testl %eax,%eax # returns InstrField ptr
7179 jne .LOP_IGET_VOLATILE_finish
7180 jmp common_exceptionThrown
7182 .LOP_IGET_VOLATILE_finish:
7185 * eax holds resolved field
7189 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field
7190 testl %ecx,%ecx # object null?
7191 je common_errNullObject # object was null
7192 movl (%ecx,%eax,1),%ecx # ecx<- obj.field (8/16/32 bits)
7193 FETCH_INST_OPCODE 2 %eax
7200 /* ------------------------------ */
7201 .L_OP_IPUT_VOLATILE: /* 0xe4 */
7202 /* File: x86/OP_IPUT_VOLATILE.S */
7203 /* File: x86/OP_IPUT.S */
7206 * General 32-bit instance field put.
7208 * for: iput, iput-object, iput-boolean, iput-byte, iput-char, iput-short
7210 /* op vA, vB, field@CCCC */
7213 movzwl 2(rPC),rIBASE # rIBASE<- 0000CCCC
7214 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex
7215 movzbl rINSTbl,%ecx # ecx<- BA
7216 sarl $4,%ecx # ecx<- B
7217 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields
7218 andb $0xf,rINSTbl # rINST<- A
7219 GET_VREG_R %ecx %ecx # ecx<- fp[B], the object ptr
7220 movl (%eax,rIBASE,4),%eax # resolved entry
7221 testl %eax,%eax # is resolved entry null?
7222 jne .LOP_IPUT_VOLATILE_finish # no, already resolved
7223 movl rIBASE,OUT_ARG1(%esp)
7226 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method
7227 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz
7228 SPILL_TMP1(%ecx) # save obj pointer across call
7229 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz
7230 call dvmResolveInstField # ... to dvmResolveInstField
7232 testl %eax,%eax # returns InstrField ptr
7233 jne .LOP_IPUT_VOLATILE_finish
7234 jmp common_exceptionThrown
7236 .LOP_IPUT_VOLATILE_finish:
7239 * eax holds resolved field
7243 GET_VREG_R rINST rINST # rINST<- v[A]
7244 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field
7245 testl %ecx,%ecx # object null?
7246 je common_errNullObject # object was null
7247 movl rINST,(%ecx,%eax,1) # obj.field <- v[A](8/16/32 bits)
7248 FETCH_INST_OPCODE 2 %ecx
7254 /* ------------------------------ */
7255 .L_OP_SGET_VOLATILE: /* 0xe5 */
7256 /* File: x86/OP_SGET_VOLATILE.S */
7257 /* File: x86/OP_SGET.S */
7259 * General 32-bit SGET handler.
7261 * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short
7263 /* op vAA, field@BBBB */
7265 movzwl 2(rPC),%eax # eax<- field ref BBBB
7266 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex
7267 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields
7268 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr
7269 testl %eax,%eax # resolved entry null?
7270 je .LOP_SGET_VOLATILE_resolve # if not, make it so
7271 .LOP_SGET_VOLATILE_finish: # field ptr in eax
7272 movl offStaticField_value(%eax),%eax
7273 FETCH_INST_OPCODE 2 %ecx
7279 * Go resolve the field
7281 .LOP_SGET_VOLATILE_resolve:
7283 movzwl 2(rPC),%eax # eax<- field ref BBBB
7284 movl offThread_method(%ecx),%ecx # ecx<- current method
7285 EXPORT_PC # could throw, need to export
7286 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz
7287 movl %eax,OUT_ARG1(%esp)
7288 movl %ecx,OUT_ARG0(%esp)
7290 call dvmResolveStaticField # eax<- resolved StaticField ptr
7293 jne .LOP_SGET_VOLATILE_finish # success, continue
7294 jmp common_exceptionThrown # no, handle exception
7297 /* ------------------------------ */
7298 .L_OP_SPUT_VOLATILE: /* 0xe6 */
7299 /* File: x86/OP_SPUT_VOLATILE.S */
7300 /* File: x86/OP_SPUT.S */
7302 * General 32-bit SPUT handler.
7304 * for: sput, sput-boolean, sput-byte, sput-char, sput-short
7306 /* op vAA, field@BBBB */
7308 movzwl 2(rPC),%eax # eax<- field ref BBBB
7309 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex
7310 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields
7311 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr
7312 testl %eax,%eax # resolved entry null?
7313 je .LOP_SPUT_VOLATILE_resolve # if not, make it so
7314 .LOP_SPUT_VOLATILE_finish: # field ptr in eax
7315 GET_VREG_R rINST rINST
7316 FETCH_INST_OPCODE 2 %ecx
7318 movl rINST,offStaticField_value(%eax)
7322 * Go resolve the field
7324 .LOP_SPUT_VOLATILE_resolve:
7326 movzwl 2(rPC),%eax # eax<- field ref BBBB
7327 movl offThread_method(%ecx),%ecx # ecx<- current method
7328 EXPORT_PC # could throw, need to export
7329 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz
7330 movl %eax,OUT_ARG1(%esp)
7331 movl %ecx,OUT_ARG0(%esp)
7333 call dvmResolveStaticField # eax<- resolved StaticField ptr
7336 jne .LOP_SPUT_VOLATILE_finish # success, continue
7337 jmp common_exceptionThrown # no, handle exception
7340 /* ------------------------------ */
7341 .L_OP_IGET_OBJECT_VOLATILE: /* 0xe7 */
7342 /* File: x86/OP_IGET_OBJECT_VOLATILE.S */
7343 /* File: x86/OP_IGET.S */
7345 * General 32-bit instance field get.
7347 * for: iget, iget-object, iget-boolean, iget-byte, iget-char, iget-short
7349 /* op vA, vB, field@CCCC */
7351 SPILL(rIBASE) # preserve rIBASE
7352 movzwl 2(rPC),rIBASE # rIBASE<- 0000CCCC
7353 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex
7354 movzbl rINSTbl,%ecx # ecx<- BA
7355 sarl $4,%ecx # ecx<- B
7356 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields
7357 andb $0xf,rINSTbl # rINST<- A
7358 GET_VREG_R %ecx %ecx # ecx<- fp[B], the object ptr
7359 movl (%eax,rIBASE,4),%eax # resolved entry
7360 testl %eax,%eax # is resolved entry null?
7361 jne .LOP_IGET_OBJECT_VOLATILE_finish # no, already resolved
7362 movl rIBASE,OUT_ARG1(%esp) # needed by dvmResolveInstField
7365 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method
7366 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz
7367 SPILL_TMP1(%ecx) # save obj pointer across call
7368 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz
7369 call dvmResolveInstField # ... to dvmResolveInstField
7371 testl %eax,%eax # returns InstrField ptr
7372 jne .LOP_IGET_OBJECT_VOLATILE_finish
7373 jmp common_exceptionThrown
7375 .LOP_IGET_OBJECT_VOLATILE_finish:
7378 * eax holds resolved field
7382 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field
7383 testl %ecx,%ecx # object null?
7384 je common_errNullObject # object was null
7385 movl (%ecx,%eax,1),%ecx # ecx<- obj.field (8/16/32 bits)
7386 FETCH_INST_OPCODE 2 %eax
7393 /* ------------------------------ */
7394 .L_OP_IGET_WIDE_VOLATILE: /* 0xe8 */
7396 SAVE_PC_FP_TO_SELF %ecx # leaves rSELF in %ecx
7397 movl %ecx,OUT_ARG0(%esp) # self is first arg to function
7398 call dvmMterp_OP_IGET_WIDE_VOLATILE # do the real work
7400 LOAD_PC_FP_FROM_SELF # retrieve updated values
7401 movl offThread_curHandlerTable(%ecx),rIBASE # set up rIBASE
7404 /* ------------------------------ */
7405 .L_OP_IPUT_WIDE_VOLATILE: /* 0xe9 */
7407 SAVE_PC_FP_TO_SELF %ecx # leaves rSELF in %ecx
7408 movl %ecx,OUT_ARG0(%esp) # self is first arg to function
7409 call dvmMterp_OP_IPUT_WIDE_VOLATILE # do the real work
7411 LOAD_PC_FP_FROM_SELF # retrieve updated values
7412 movl offThread_curHandlerTable(%ecx),rIBASE # set up rIBASE
7415 /* ------------------------------ */
7416 .L_OP_SGET_WIDE_VOLATILE: /* 0xea */
7418 SAVE_PC_FP_TO_SELF %ecx # leaves rSELF in %ecx
7419 movl %ecx,OUT_ARG0(%esp) # self is first arg to function
7420 call dvmMterp_OP_SGET_WIDE_VOLATILE # do the real work
7422 LOAD_PC_FP_FROM_SELF # retrieve updated values
7423 movl offThread_curHandlerTable(%ecx),rIBASE # set up rIBASE
7426 /* ------------------------------ */
7427 .L_OP_SPUT_WIDE_VOLATILE: /* 0xeb */
7429 SAVE_PC_FP_TO_SELF %ecx # leaves rSELF in %ecx
7430 movl %ecx,OUT_ARG0(%esp) # self is first arg to function
7431 call dvmMterp_OP_SPUT_WIDE_VOLATILE # do the real work
7433 LOAD_PC_FP_FROM_SELF # retrieve updated values
7434 movl offThread_curHandlerTable(%ecx),rIBASE # set up rIBASE
7437 /* ------------------------------ */
7438 .L_OP_BREAKPOINT: /* 0xec */
7439 /* File: x86/OP_BREAKPOINT.S */
7440 /* File: x86/unused.S */
7444 /* ------------------------------ */
7445 .L_OP_THROW_VERIFICATION_ERROR: /* 0xed */
7446 /* File: x86/OP_THROW_VERIFICATION_ERROR.S */
7448 * Handle a throw-verification-error instruction. This throws an
7449 * exception for an error discovered during verification. The
7450 * exception is indicated by AA, with some detail provided by BBBB.
7452 /* op AA, ref@BBBB */
7454 movzwl 2(rPC),%eax # eax<- BBBB
7455 movl offThread_method(%ecx),%ecx # ecx<- self->method
7457 movl %eax,OUT_ARG2(%esp) # arg2<- BBBB
7458 movl rINST,OUT_ARG1(%esp) # arg1<- AA
7459 movl %ecx,OUT_ARG0(%esp) # arg0<- method
7460 call dvmThrowVerificationError # call(method, kind, ref)
7461 jmp common_exceptionThrown # handle exception
7463 /* ------------------------------ */
7464 .L_OP_EXECUTE_INLINE: /* 0xee */
7465 /* File: x86/OP_EXECUTE_INLINE.S */
7467 * Execute a "native inline" instruction.
7469 * We will be calling through a function table:
7471 * (*gDvmInlineOpsTable[opIndex].func)(arg0, arg1, arg2, arg3, pResult)
7473 * Ignores argument count - always loads 4.
7476 /* [opt] execute-inline vAA, {vC, vD, vE, vF}, inline@BBBB */
7479 movzwl 2(rPC),%eax # eax<- BBBB
7480 leal offThread_retval(%ecx),%ecx # ecx<- & self->retval
7481 SPILL(rIBASE) # preserve rIBASE
7482 movl %ecx,OUT_ARG4(%esp)
7483 call .LOP_EXECUTE_INLINE_continue # make call; will return after
7484 UNSPILL(rIBASE) # restore rIBASE
7485 testl %eax,%eax # successful?
7486 FETCH_INST_OPCODE 3 %ecx
7487 je common_exceptionThrown # no, handle exception
7491 .LOP_EXECUTE_INLINE_continue:
7493 * Extract args, call function.
7494 * ecx = #of args (0-4)
7496 * @esp = return addr
7497 * esp is -4 from normal
7499 * Go ahead and load all 4 args, even if not used.
7501 movzwl 4(rPC),rIBASE
7505 GET_VREG_R %ecx %ecx
7507 movl %ecx,4+OUT_ARG0(%esp)
7511 GET_VREG_R %ecx %ecx
7513 movl %ecx,4+OUT_ARG1(%esp)
7517 GET_VREG_R %ecx %ecx
7519 movl %ecx,4+OUT_ARG2(%esp)
7523 GET_VREG_R %ecx %ecx
7525 movl %ecx,4+OUT_ARG3(%esp)
7527 sall $4,%eax # index *= sizeof(table entry)
7528 jmp *gDvmInlineOpsTable(%eax)
7529 # will return to caller of .LOP_EXECUTE_INLINE_continue
7531 /* ------------------------------ */
7532 .L_OP_EXECUTE_INLINE_RANGE: /* 0xef */
7534 SAVE_PC_FP_TO_SELF %ecx # leaves rSELF in %ecx
7535 movl %ecx,OUT_ARG0(%esp) # self is first arg to function
7536 call dvmMterp_OP_EXECUTE_INLINE_RANGE # do the real work
7538 LOAD_PC_FP_FROM_SELF # retrieve updated values
7539 movl offThread_curHandlerTable(%ecx),rIBASE # set up rIBASE
7542 /* ------------------------------ */
7543 .L_OP_INVOKE_OBJECT_INIT_RANGE: /* 0xf0 */
7545 SAVE_PC_FP_TO_SELF %ecx # leaves rSELF in %ecx
7546 movl %ecx,OUT_ARG0(%esp) # self is first arg to function
7547 call dvmMterp_OP_INVOKE_OBJECT_INIT_RANGE # do the real work
7549 LOAD_PC_FP_FROM_SELF # retrieve updated values
7550 movl offThread_curHandlerTable(%ecx),rIBASE # set up rIBASE
7553 /* ------------------------------ */
7554 .L_OP_RETURN_VOID_BARRIER: /* 0xf1 */
7556 SAVE_PC_FP_TO_SELF %ecx # leaves rSELF in %ecx
7557 movl %ecx,OUT_ARG0(%esp) # self is first arg to function
7558 call dvmMterp_OP_RETURN_VOID_BARRIER # do the real work
7560 LOAD_PC_FP_FROM_SELF # retrieve updated values
7561 movl offThread_curHandlerTable(%ecx),rIBASE # set up rIBASE
7564 /* ------------------------------ */
7565 .L_OP_IGET_QUICK: /* 0xf2 */
7566 /* File: x86/OP_IGET_QUICK.S */
7567 /* For: iget-quick, iget-object-quick */
7568 /* op vA, vB, offset@CCCC */
7569 movzbl rINSTbl,%ecx # ecx<- BA
7570 sarl $4,%ecx # ecx<- B
7571 GET_VREG_R %ecx %ecx # vB (object we're operating on)
7572 movzwl 2(rPC),%eax # eax<- field byte offset
7573 cmpl $0,%ecx # is object null?
7574 je common_errNullObject
7575 movl (%ecx,%eax,1),%eax
7576 FETCH_INST_OPCODE 2 %ecx
7578 andb $0xf,rINSTbl # rINST<- A
7579 SET_VREG %eax rINST # fp[A]<- result
7582 /* ------------------------------ */
7583 .L_OP_IGET_WIDE_QUICK: /* 0xf3 */
7584 /* File: x86/OP_IGET_WIDE_QUICK.S */
7585 /* For: iget-wide-quick */
7586 /* op vA, vB, offset@CCCC */
7587 movzbl rINSTbl,%ecx # ecx<- BA
7588 sarl $4,%ecx # ecx<- B
7589 GET_VREG_R %ecx %ecx # vB (object we're operating on)
7590 movzwl 2(rPC),%eax # eax<- field byte offset
7591 cmpl $0,%ecx # is object null?
7592 je common_errNullObject
7593 leal (%ecx,%eax,1),%eax # eax<- address of 64-bit source
7594 movl (%eax),%ecx # ecx<- lsw
7595 movl 4(%eax),%eax # eax<- msw
7596 andb $0xf,rINSTbl # rINST<- A
7597 SET_VREG_WORD %ecx rINST 0 # v[A+0]<- lsw
7598 FETCH_INST_OPCODE 2 %ecx
7599 SET_VREG_WORD %eax rINST 1 # v[A+1]<- msw
7603 /* ------------------------------ */
7604 .L_OP_IGET_OBJECT_QUICK: /* 0xf4 */
7605 /* File: x86/OP_IGET_OBJECT_QUICK.S */
7606 /* File: x86/OP_IGET_QUICK.S */
7607 /* For: iget-quick, iget-object-quick */
7608 /* op vA, vB, offset@CCCC */
7609 movzbl rINSTbl,%ecx # ecx<- BA
7610 sarl $4,%ecx # ecx<- B
7611 GET_VREG_R %ecx %ecx # vB (object we're operating on)
7612 movzwl 2(rPC),%eax # eax<- field byte offset
7613 cmpl $0,%ecx # is object null?
7614 je common_errNullObject
7615 movl (%ecx,%eax,1),%eax
7616 FETCH_INST_OPCODE 2 %ecx
7618 andb $0xf,rINSTbl # rINST<- A
7619 SET_VREG %eax rINST # fp[A]<- result
7623 /* ------------------------------ */
7624 .L_OP_IPUT_QUICK: /* 0xf5 */
7625 /* File: x86/OP_IPUT_QUICK.S */
7626 /* For: iput-quick */
7627 /* op vA, vB, offset@CCCC */
7628 movzbl rINSTbl,%ecx # ecx<- BA
7629 sarl $4,%ecx # ecx<- B
7630 GET_VREG_R %ecx %ecx # vB (object we're operating on)
7631 andb $0xf,rINSTbl # rINST<- A
7632 GET_VREG_R rINST,rINST # rINST<- v[A]
7633 movzwl 2(rPC),%eax # eax<- field byte offset
7634 testl %ecx,%ecx # is object null?
7635 je common_errNullObject
7636 movl rINST,(%ecx,%eax,1)
7637 FETCH_INST_OPCODE 2 %ecx
7641 /* ------------------------------ */
7642 .L_OP_IPUT_WIDE_QUICK: /* 0xf6 */
7643 /* File: x86/OP_IPUT_WIDE_QUICK.S */
7644 /* For: iput-wide-quick */
7645 /* op vA, vB, offset@CCCC */
7646 movzbl rINSTbl,%ecx # ecx<- BA
7647 sarl $4,%ecx # ecx<- B
7648 GET_VREG_R %ecx %ecx # vB (object we're operating on)
7649 movzwl 2(rPC),%eax # eax<- field byte offset
7650 testl %ecx,%ecx # is object null?
7651 je common_errNullObject
7652 leal (%ecx,%eax,1),%ecx # ecx<- Address of 64-bit target
7653 andb $0xf,rINSTbl # rINST<- A
7654 GET_VREG_WORD %eax rINST 0 # eax<- lsw
7655 GET_VREG_WORD rINST rINST 1 # rINST<- msw
7658 FETCH_INST_OPCODE 2 %ecx
7662 /* ------------------------------ */
7663 .L_OP_IPUT_OBJECT_QUICK: /* 0xf7 */
7664 /* File: x86/OP_IPUT_OBJECT_QUICK.S */
7665 /* For: iput-object-quick */
7666 /* op vA, vB, offset@CCCC */
7667 movzbl rINSTbl,%ecx # ecx<- BA
7668 sarl $4,%ecx # ecx<- B
7669 GET_VREG_R %ecx %ecx # vB (object we're operating on)
7670 andb $0xf,rINSTbl # rINST<- A
7671 GET_VREG_R rINST rINST # rINST<- v[A]
7672 movzwl 2(rPC),%eax # eax<- field byte offset
7673 testl %ecx,%ecx # is object null?
7674 je common_errNullObject
7675 movl rINST,(%ecx,%eax,1)
7677 testl rINST,rINST # did we store null?
7678 movl offThread_cardTable(%eax),%eax # get card table base
7679 je 1f # skip card mark if null store
7680 shrl $GC_CARD_SHIFT,%ecx # object head to card number
7681 movb %al,(%eax,%ecx) # mark card based on object head
7683 FETCH_INST_OPCODE 2 %ecx
7687 /* ------------------------------ */
7688 .L_OP_INVOKE_VIRTUAL_QUICK: /* 0xf8 */
7689 /* File: x86/OP_INVOKE_VIRTUAL_QUICK.S */
7691 * Handle an optimized virtual method call.
7693 * for: [opt] invoke-virtual-quick, invoke-virtual-quick/range
7695 /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */
7696 /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */
7697 movzwl 4(rPC),%eax # eax<- FEDC or CCCC
7698 movzwl 2(rPC),%ecx # ecx<- BBBB
7700 andl $0xf,%eax # eax<- C (or stays CCCC)
7702 GET_VREG_R %eax %eax # eax<- vC ("this" ptr)
7703 testl %eax,%eax # null?
7704 je common_errNullObject # yep, throw exception
7705 movl offObject_clazz(%eax),%eax # eax<- thisPtr->clazz
7706 movl offClassObject_vtable(%eax),%eax # eax<- thisPtr->clazz->vtable
7707 EXPORT_PC # might throw later - get ready
7708 movl (%eax,%ecx,4),%eax # eax<- vtable[BBBB]
7709 jmp common_invokeMethodNoRange
7711 /* ------------------------------ */
7712 .L_OP_INVOKE_VIRTUAL_QUICK_RANGE: /* 0xf9 */
7713 /* File: x86/OP_INVOKE_VIRTUAL_QUICK_RANGE.S */
7714 /* File: x86/OP_INVOKE_VIRTUAL_QUICK.S */
7716 * Handle an optimized virtual method call.
7718 * for: [opt] invoke-virtual-quick, invoke-virtual-quick/range
7720 /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */
7721 /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */
7722 movzwl 4(rPC),%eax # eax<- FEDC or CCCC
7723 movzwl 2(rPC),%ecx # ecx<- BBBB
7725 andl $0xf,%eax # eax<- C (or stays CCCC)
7727 GET_VREG_R %eax %eax # eax<- vC ("this" ptr)
7728 testl %eax,%eax # null?
7729 je common_errNullObject # yep, throw exception
7730 movl offObject_clazz(%eax),%eax # eax<- thisPtr->clazz
7731 movl offClassObject_vtable(%eax),%eax # eax<- thisPtr->clazz->vtable
7732 EXPORT_PC # might throw later - get ready
7733 movl (%eax,%ecx,4),%eax # eax<- vtable[BBBB]
7734 jmp common_invokeMethodRange
7737 /* ------------------------------ */
7738 .L_OP_INVOKE_SUPER_QUICK: /* 0xfa */
7739 /* File: x86/OP_INVOKE_SUPER_QUICK.S */
7741 * Handle an optimized "super" method call.
7743 * for: [opt] invoke-super-quick, invoke-super-quick/range
7745 /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */
7746 /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */
7748 movzwl 4(rPC),%eax # eax<- GFED or CCCC
7749 movl offThread_method(%ecx),%ecx # ecx<- current method
7751 andl $0xf,%eax # eax<- D (or stays CCCC)
7753 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz
7754 GET_VREG_R %eax %eax # eax<- "this"
7755 movl offClassObject_super(%ecx),%ecx # ecx<- method->clazz->super
7756 testl %eax,%eax # null "this"?
7757 je common_errNullObject # "this" is null, throw exception
7758 movzwl 2(rPC),%eax # eax<- BBBB
7759 movl offClassObject_vtable(%ecx),%ecx # ecx<- vtable
7761 movl (%ecx,%eax,4),%eax # eax<- super->vtable[BBBB]
7762 jmp common_invokeMethodNoRange
7764 /* ------------------------------ */
7765 .L_OP_INVOKE_SUPER_QUICK_RANGE: /* 0xfb */
7766 /* File: x86/OP_INVOKE_SUPER_QUICK_RANGE.S */
7767 /* File: x86/OP_INVOKE_SUPER_QUICK.S */
7769 * Handle an optimized "super" method call.
7771 * for: [opt] invoke-super-quick, invoke-super-quick/range
7773 /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */
7774 /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */
7776 movzwl 4(rPC),%eax # eax<- GFED or CCCC
7777 movl offThread_method(%ecx),%ecx # ecx<- current method
7779 andl $0xf,%eax # eax<- D (or stays CCCC)
7781 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz
7782 GET_VREG_R %eax %eax # eax<- "this"
7783 movl offClassObject_super(%ecx),%ecx # ecx<- method->clazz->super
7784 testl %eax,%eax # null "this"?
7785 je common_errNullObject # "this" is null, throw exception
7786 movzwl 2(rPC),%eax # eax<- BBBB
7787 movl offClassObject_vtable(%ecx),%ecx # ecx<- vtable
7789 movl (%ecx,%eax,4),%eax # eax<- super->vtable[BBBB]
7790 jmp common_invokeMethodRange
7793 /* ------------------------------ */
7794 .L_OP_IPUT_OBJECT_VOLATILE: /* 0xfc */
7795 /* File: x86/OP_IPUT_OBJECT_VOLATILE.S */
7796 /* File: x86/OP_IPUT_OBJECT.S */
7802 /* op vA, vB, field@CCCC */
7805 movzwl 2(rPC),rIBASE # rIBASE<- 0000CCCC
7806 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex
7807 movzbl rINSTbl,%ecx # ecx<- BA
7808 sarl $4,%ecx # ecx<- B
7809 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields
7810 andb $0xf,rINSTbl # rINST<- A
7811 GET_VREG_R %ecx %ecx # ecx<- fp[B], the object ptr
7812 movl (%eax,rIBASE,4),%eax # resolved entry
7813 testl %eax,%eax # is resolved entry null?
7814 jne .LOP_IPUT_OBJECT_VOLATILE_finish # no, already resolved
7815 movl rIBASE,OUT_ARG1(%esp)
7818 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method
7819 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz
7820 SPILL_TMP1(%ecx) # save obj pointer across call
7821 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz
7822 call dvmResolveInstField # ... to dvmResolveInstField
7824 testl %eax,%eax # returns InstrField ptr
7825 jne .LOP_IPUT_OBJECT_VOLATILE_finish
7826 jmp common_exceptionThrown
7828 .LOP_IPUT_OBJECT_VOLATILE_finish:
7831 * eax holds resolved field
7833 * rIBASE is scratch, but needs to be unspilled
7836 GET_VREG_R rINST rINST # rINST<- v[A]
7837 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field
7838 testl %ecx,%ecx # object null?
7839 je common_errNullObject # object was null
7840 movl rINST,(%ecx,%eax) # obj.field <- v[A](8/16/32 bits)
7842 testl rINST,rINST # stored a NULL?
7843 movl offThread_cardTable(%eax),%eax # get card table base
7844 je 1f # skip card mark if null store
7845 shrl $GC_CARD_SHIFT,%ecx # object head to card number
7846 movb %al,(%eax,%ecx) # mark card using object head
7849 FETCH_INST_OPCODE 2 %ecx
7854 /* ------------------------------ */
7855 .L_OP_SGET_OBJECT_VOLATILE: /* 0xfd */
7856 /* File: x86/OP_SGET_OBJECT_VOLATILE.S */
7857 /* File: x86/OP_SGET.S */
7859 * General 32-bit SGET handler.
7861 * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short
7863 /* op vAA, field@BBBB */
7865 movzwl 2(rPC),%eax # eax<- field ref BBBB
7866 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex
7867 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields
7868 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr
7869 testl %eax,%eax # resolved entry null?
7870 je .LOP_SGET_OBJECT_VOLATILE_resolve # if not, make it so
7871 .LOP_SGET_OBJECT_VOLATILE_finish: # field ptr in eax
7872 movl offStaticField_value(%eax),%eax
7873 FETCH_INST_OPCODE 2 %ecx
7879 * Go resolve the field
7881 .LOP_SGET_OBJECT_VOLATILE_resolve:
7883 movzwl 2(rPC),%eax # eax<- field ref BBBB
7884 movl offThread_method(%ecx),%ecx # ecx<- current method
7885 EXPORT_PC # could throw, need to export
7886 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz
7887 movl %eax,OUT_ARG1(%esp)
7888 movl %ecx,OUT_ARG0(%esp)
7890 call dvmResolveStaticField # eax<- resolved StaticField ptr
7893 jne .LOP_SGET_OBJECT_VOLATILE_finish # success, continue
7894 jmp common_exceptionThrown # no, handle exception
7897 /* ------------------------------ */
7898 .L_OP_SPUT_OBJECT_VOLATILE: /* 0xfe */
7899 /* File: x86/OP_SPUT_OBJECT_VOLATILE.S */
7900 /* File: x86/OP_SPUT_OBJECT.S */
7902 * SPUT object handler.
7904 /* op vAA, field@BBBB */
7906 movzwl 2(rPC),%eax # eax<- field ref BBBB
7907 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex
7908 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields
7909 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField
7910 testl %eax,%eax # resolved entry null?
7911 je .LOP_SPUT_OBJECT_VOLATILE_resolve # if not, make it so
7912 .LOP_SPUT_OBJECT_VOLATILE_finish: # field ptr in eax
7913 movzbl rINSTbl,%ecx # ecx<- AA
7914 GET_VREG_R %ecx %ecx
7915 movl %ecx,offStaticField_value(%eax) # do the store
7916 testl %ecx,%ecx # stored null object ptr?
7917 je 1f # skip card mark if null
7919 movl offField_clazz(%eax),%eax # eax<- method->clazz
7920 movl offThread_cardTable(%ecx),%ecx # get card table base
7921 shrl $GC_CARD_SHIFT,%eax # head to card number
7922 movb %cl,(%ecx,%eax) # mark card
7924 FETCH_INST_OPCODE 2 %ecx
7928 .LOP_SPUT_OBJECT_VOLATILE_resolve:
7930 movzwl 2(rPC),%eax # eax<- field ref BBBB
7931 movl offThread_method(%ecx),%ecx # ecx<- current method
7932 EXPORT_PC # could throw, need to export
7933 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz
7934 movl %eax,OUT_ARG1(%esp)
7935 movl %ecx,OUT_ARG0(%esp)
7937 call dvmResolveStaticField # eax<- resolved StaticField ptr
7940 jne .LOP_SPUT_OBJECT_VOLATILE_finish # success, continue
7941 jmp common_exceptionThrown # no, handle exception
7944 /* ------------------------------ */
7945 .L_OP_DISPATCH_FF: /* 0xff */
7946 /* File: x86/OP_DISPATCH_FF.S */
7947 leal 256(rINST),%ecx
7948 GOTO_NEXT_JUMBO_R %ecx
7950 /* ------------------------------ */
7951 .L_OP_CONST_CLASS_JUMBO: /* 0x100 */
7952 /* File: x86/OP_CONST_CLASS_JUMBO.S */
7953 /* const-class/jumbo vBBBB, Class@AAAAAAAA */
7955 movl 2(rPC),%eax # eax<- AAAAAAAA
7956 movl offThread_methodClassDex(%ecx),%ecx# ecx<- self->methodClassDex
7957 movl offDvmDex_pResClasses(%ecx),%ecx # ecx<- dvmDex->pResClasses
7958 FETCH_INST_OPCODE 4 %ecx
7959 movl (%ecx,%eax,4),%eax # eax<- rResClasses[AAAAAAAA]
7960 testl %eax,%eax # resolved yet?
7961 je .LOP_CONST_CLASS_JUMBO_resolve
7962 SET_VREG %eax rINST # vBBBB<- rResClasses[AAAAAAAA]
7966 /* This is the less common path, so we'll redo some work
7967 here rather than force spills on the common path */
7968 .LOP_CONST_CLASS_JUMBO_resolve:
7971 movl offThread_method(%eax),%eax # eax<- self->method
7972 movl $1,OUT_ARG2(%esp) # true
7973 movl 2(rPC),%ecx # ecx<- AAAAAAAA
7974 movl offMethod_clazz(%eax),%eax
7975 movl %ecx,OUT_ARG1(%esp)
7976 movl %eax,OUT_ARG0(%esp)
7978 call dvmResolveClass # go resolve
7980 testl %eax,%eax # failed?
7981 je common_exceptionThrown
7982 FETCH_INST_OPCODE 4 %ecx
7987 /* ------------------------------ */
7988 .L_OP_CHECK_CAST_JUMBO: /* 0x101 */
7989 /* File: x86/OP_CHECK_CAST_JUMBO.S */
7991 * Check to see if a cast from one class to another is allowed.
7993 /* check-cast/jumbo vBBBB, class@AAAAAAAA */
7995 GET_VREG_R rINST,rINST # rINST<- vBBBB (object)
7996 movl 2(rPC),%eax # eax<- AAAAAAAA
7997 movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex
7998 testl rINST,rINST # is oject null?
7999 movl offDvmDex_pResClasses(%ecx),%ecx # ecx<- pDvmDex->pResClasses
8000 je .LOP_CHECK_CAST_JUMBO_okay # null obj, cast always succeeds
8001 movl (%ecx,%eax,4),%eax # eax<- resolved class
8002 movl offObject_clazz(rINST),%ecx # ecx<- obj->clazz
8003 testl %eax,%eax # have we resolved this before?
8004 je .LOP_CHECK_CAST_JUMBO_resolve # no, go do it now
8005 .LOP_CHECK_CAST_JUMBO_resolved:
8006 cmpl %eax,%ecx # same class (trivial success)?
8007 jne .LOP_CHECK_CAST_JUMBO_fullcheck # no, do full check
8008 .LOP_CHECK_CAST_JUMBO_okay:
8009 FETCH_INST_OPCODE 4 %ecx
8014 * Trivial test failed, need to perform full check. This is common.
8015 * ecx holds obj->clazz
8016 * eax holds class resolved from AAAAAAAA
8017 * rINST holds object
8019 .LOP_CHECK_CAST_JUMBO_fullcheck:
8020 movl %eax,sReg0 # we'll need the desired class on failure
8021 movl %eax,OUT_ARG1(%esp)
8022 movl %ecx,OUT_ARG0(%esp)
8024 call dvmInstanceofNonTrivial # eax<- boolean result
8026 testl %eax,%eax # failed?
8027 jne .LOP_CHECK_CAST_JUMBO_okay # no, success
8029 # A cast has failed. We need to throw a ClassCastException.
8031 movl offObject_clazz(rINST),%eax
8032 movl %eax,OUT_ARG0(%esp) # arg0<- obj->clazz
8034 movl %ecx,OUT_ARG1(%esp) # arg1<- desired class
8035 call dvmThrowClassCastException
8036 jmp common_exceptionThrown
8039 * Resolution required. This is the least-likely path, and we're
8040 * going to have to recreate some data.
8042 * rINST holds object
8044 .LOP_CHECK_CAST_JUMBO_resolve:
8047 movl 2(rPC),%eax # eax<- AAAAAAAA
8048 movl offThread_method(%ecx),%ecx # ecx<- self->method
8049 movl %eax,OUT_ARG1(%esp) # arg1<- AAAAAAAA
8050 movl offMethod_clazz(%ecx),%ecx # ecx<- metho->clazz
8051 movl $0,OUT_ARG2(%esp) # arg2<- false
8052 movl %ecx,OUT_ARG0(%esp) # arg0<- method->clazz
8054 call dvmResolveClass # eax<- resolved ClassObject ptr
8056 testl %eax,%eax # got null?
8057 je common_exceptionThrown # yes, handle exception
8058 movl offObject_clazz(rINST),%ecx # ecx<- obj->clazz
8059 jmp .LOP_CHECK_CAST_JUMBO_resolved # pick up where we left off
8061 /* ------------------------------ */
8062 .L_OP_INSTANCE_OF_JUMBO: /* 0x102 */
8063 /* File: x86/OP_INSTANCE_OF_JUMBO.S */
8065 * Check to see if an object reference is an instance of a class.
8067 * Most common situation is a non-null object, being compared against
8068 * an already-resolved class.
8070 /* instance-of/jumbo vBBBB, vCCCC, class@AAAAAAAA */
8071 movzwl 8(rPC),%eax # eax<- CCCC
8072 GET_VREG_R %eax %eax # eax<- vCCCC (obj)
8074 testl %eax,%eax # object null?
8075 movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex
8076 SPILL(rIBASE) # preserve rIBASE
8077 je .LOP_INSTANCE_OF_JUMBO_store # null obj, not instance, store it
8078 movl 2(rPC),rIBASE # edx<- AAAAAAAA
8079 movl offDvmDex_pResClasses(%ecx),%ecx # ecx<- pDvmDex->pResClasses
8080 movl (%ecx,rIBASE,4),%ecx # ecx<- resolved class
8081 movl offObject_clazz(%eax),%eax # eax<- obj->clazz
8082 testl %ecx,%ecx # have we resolved this before?
8083 je .LOP_INSTANCE_OF_JUMBO_resolve # not resolved, do it now
8084 .LOP_INSTANCE_OF_JUMBO_resolved: # eax<- obj->clazz, ecx<- resolved class
8085 cmpl %eax,%ecx # same class (trivial success)?
8086 je .LOP_INSTANCE_OF_JUMBO_trivial # yes, trivial finish
8088 * Trivial test failed, need to perform full check. This is common.
8089 * eax holds obj->clazz
8090 * ecx holds class resolved from BBBB
8093 movl %eax,OUT_ARG0(%esp)
8094 movl %ecx,OUT_ARG1(%esp)
8095 call dvmInstanceofNonTrivial # eax<- boolean result
8096 # fall through to OP_INSTANCE_OF_JUMBO_store
8099 * eax holds boolean result
8102 .LOP_INSTANCE_OF_JUMBO_store:
8103 FETCH_INST_OPCODE 5 %ecx
8106 SET_VREG %eax rINST # vBBBB<- eax
8110 * Trivial test succeeded, save and bail.
8113 .LOP_INSTANCE_OF_JUMBO_trivial:
8114 FETCH_INST_OPCODE 5 %ecx
8118 SET_VREG %eax rINST # vBBBB<- true
8122 * Resolution required. This is the least-likely path.
8124 * edx holds AAAAAAAA
8126 .LOP_INSTANCE_OF_JUMBO_resolve:
8127 movl rIBASE,OUT_ARG1(%esp) # arg1<- AAAAAAAA
8129 movl offThread_method(%ecx),%ecx
8130 movl $1,OUT_ARG2(%esp) # arg2<- true
8131 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz
8133 movl %ecx,OUT_ARG0(%esp) # arg0<- method->clazz
8134 call dvmResolveClass # eax<- resolved ClassObject ptr
8135 testl %eax,%eax # success?
8136 je common_exceptionThrown # no, handle exception
8137 /* Now, we need to sync up with fast path. We need eax to
8138 * hold the obj->clazz, and ecx to hold the resolved class
8140 movl %eax,%ecx # ecx<- resolved class
8141 movzwl 8(rPC),%eax # eax<- CCCC
8142 GET_VREG_R %eax %eax # eax<- vCCCC (obj)
8143 movl offObject_clazz(%eax),%eax # eax<- obj->clazz
8144 jmp .LOP_INSTANCE_OF_JUMBO_resolved
8146 /* ------------------------------ */
8147 .L_OP_NEW_INSTANCE_JUMBO: /* 0x103 */
8148 /* File: x86/OP_NEW_INSTANCE_JUMBO.S */
8150 * Create a new instance of a class.
8152 /* new-instance/jumbo vBBBB, class@AAAAAAAA */
8154 movl 2(rPC),%eax # eax<- AAAAAAAA
8155 movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex
8156 movl offDvmDex_pResClasses(%ecx),%ecx # ecx<- pDvmDex->pResClasses
8158 movl (%ecx,%eax,4),%ecx # ecx<- resolved class
8160 testl %ecx,%ecx # resolved?
8161 je .LOP_NEW_INSTANCE_JUMBO_resolve # no, go do it
8162 .LOP_NEW_INSTANCE_JUMBO_resolved: # on entry, ecx<- class
8163 cmpb $CLASS_INITIALIZED,offClassObject_status(%ecx)
8164 jne .LOP_NEW_INSTANCE_JUMBO_needinit
8165 .LOP_NEW_INSTANCE_JUMBO_initialized: # on entry, ecx<- class
8166 movl $ALLOC_DONT_TRACK,OUT_ARG1(%esp)
8167 movl %ecx,OUT_ARG0(%esp)
8168 call dvmAllocObject # eax<- new object
8170 FETCH_INST_OPCODE 4 %ecx
8171 testl %eax,%eax # success?
8172 je common_exceptionThrown # no, bail out
8178 * Class initialization required.
8180 * ecx holds class object
8182 .LOP_NEW_INSTANCE_JUMBO_needinit:
8183 SPILL_TMP1(%ecx) # save object
8184 movl %ecx,OUT_ARG0(%esp)
8185 call dvmInitClass # initialize class
8186 UNSPILL_TMP1(%ecx) # restore object
8187 testl %eax,%eax # success?
8188 jne .LOP_NEW_INSTANCE_JUMBO_initialized # success, continue
8189 jmp common_exceptionThrown # go deal with init exception
8192 * Resolution required. This is the least-likely path.
8195 .LOP_NEW_INSTANCE_JUMBO_resolve:
8197 movl 2(rPC),%eax # eax<- AAAAAAAA
8198 movl offThread_method(%ecx),%ecx # ecx<- self->method
8199 movl %eax,OUT_ARG1(%esp)
8200 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz
8201 movl $0,OUT_ARG2(%esp)
8202 movl %ecx,OUT_ARG0(%esp)
8203 call dvmResolveClass # call(clazz,off,flags)
8204 movl %eax,%ecx # ecx<- resolved ClassObject ptr
8205 testl %ecx,%ecx # success?
8206 jne .LOP_NEW_INSTANCE_JUMBO_resolved # good to go
8207 jmp common_exceptionThrown # no, handle exception
8209 /* ------------------------------ */
8210 .L_OP_NEW_ARRAY_JUMBO: /* 0x104 */
8211 /* File: x86/OP_NEW_ARRAY_JUMBO.S */
8213 * Allocate an array of objects, specified with the array class
8216 * The verifier guarantees that this is an array class, so we don't
8217 * check for it here.
8219 /* new-array/jumbo vBBBB, vCCCC, class@AAAAAAAA */
8222 movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex
8223 movl 2(rPC),%eax # eax<- AAAAAAAA
8224 movl offDvmDex_pResClasses(%ecx),%ecx # ecx<- pDvmDex->pResClasses
8226 movl (%ecx,%eax,4),%ecx # ecx<- resolved class
8227 movzwl 8(rPC),%eax # eax<- CCCC
8228 GET_VREG_R %eax %eax # eax<- vCCCC (array length)
8230 js common_errNegativeArraySize # bail, passing len in eax
8231 testl %ecx,%ecx # already resolved?
8232 jne .LOP_NEW_ARRAY_JUMBO_finish # yes, fast path
8234 * Resolve class. (This is an uncommon case.)
8235 * ecx holds class (null here)
8236 * eax holds array length (vCCCC)
8239 SPILL_TMP1(%eax) # save array length
8240 movl offThread_method(%ecx),%ecx # ecx<- self->method
8241 movl 2(rPC),%eax # eax<- AAAAAAAA
8242 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz
8243 movl %eax,OUT_ARG1(%esp)
8244 movl $0,OUT_ARG2(%esp)
8245 movl %ecx,OUT_ARG0(%esp)
8246 call dvmResolveClass # eax<- call(clazz,ref,flag)
8249 testl %ecx,%ecx # successful resolution?
8250 je common_exceptionThrown # no, bail.
8251 # fall through to OP_NEW_ARRAY_JUMBO_finish
8257 * eax holds array length (vCCCC)
8259 .LOP_NEW_ARRAY_JUMBO_finish:
8260 movl %ecx,OUT_ARG0(%esp)
8261 movl %eax,OUT_ARG1(%esp)
8262 movl $ALLOC_DONT_TRACK,OUT_ARG2(%esp)
8263 call dvmAllocArrayByClass # eax<- call(clazz,length,flags)
8265 FETCH_INST_OPCODE 5 %ecx
8266 testl %eax,%eax # failed?
8267 je common_exceptionThrown # yup - go handle
8272 /* ------------------------------ */
8273 .L_OP_FILLED_NEW_ARRAY_JUMBO: /* 0x105 */
8274 /* File: x86/OP_FILLED_NEW_ARRAY_JUMBO.S */
8276 * Create a new array with elements filled from registers.
8278 /* filled-new-array/jumbo {vCCCC..v(CCCC+BBBB-1)}, type@AAAAAAAA */
8280 movl offThread_methodClassDex(%eax),%eax # eax<- pDvmDex
8281 movl 2(rPC),%ecx # ecx<- AAAAAAAA
8282 movl offDvmDex_pResClasses(%eax),%eax # eax<- pDvmDex->pResClasses
8283 movl (%eax,%ecx,4),%eax # eax<- resolved class
8285 testl %eax,%eax # already resolved?
8286 jne .LOP_FILLED_NEW_ARRAY_JUMBO_continue # yes, continue
8287 # less frequent path, so we'll redo some work
8289 movl $0,OUT_ARG2(%esp) # arg2<- false
8290 movl %ecx,OUT_ARG1(%esp) # arg1<- AAAAAAAA
8291 movl offThread_method(%eax),%eax # eax<- self->method
8292 movl offMethod_clazz(%eax),%eax # eax<- method->clazz
8293 movl %eax,OUT_ARG0(%esp) # arg0<- clazz
8295 call dvmResolveClass # eax<- call(clazz,ref,flag)
8297 testl %eax,%eax # null?
8298 je common_exceptionThrown # yes, handle it
8300 # note: fall through to .LOP_FILLED_NEW_ARRAY_JUMBO_continue
8304 * eax holds array class [r0]
8307 .LOP_FILLED_NEW_ARRAY_JUMBO_continue:
8308 movl offClassObject_descriptor(%eax),%ecx # ecx<- arrayClass->descriptor
8309 movl $ALLOC_DONT_TRACK,OUT_ARG2(%esp) # arg2<- flags
8310 movzbl 1(%ecx),%ecx # ecx<- descriptor[1]
8311 movl %eax,OUT_ARG0(%esp) # arg0<- arrayClass
8313 cmpb $'I',%cl # supported?
8318 jne .LOP_FILLED_NEW_ARRAY_JUMBO_notimpl # no, not handled yet
8320 movl %ecx,offThread_retval+4(%eax) # save type
8321 movl rINST,OUT_ARG1(%esp) # arg1<- BBBB (length)
8323 call dvmAllocArrayByClass # eax<- call(arrayClass, length, flags)
8326 testl %eax,%eax # alloc successful?
8327 je common_exceptionThrown # no, handle exception
8328 movl %eax,offThread_retval(%ecx) # retval.l<- new array
8329 movzwl 8(rPC),%ecx # ecx<- CCCC
8330 leal offArrayObject_contents(%eax),%eax # eax<- newArray->contents
8333 * eax is pointer to tgt
8336 * We now need to copy values from registers into the array
8339 # set up src pointer
8342 leal (rFP,%ecx,4),%esi # set up src ptr
8343 movl %eax,%edi # set up dst ptr
8344 movl rINST,%ecx # load count register
8350 movl offThread_retval+4(%ecx),%eax # eax<- type
8352 cmpb $'I',%al # Int array?
8353 je 5f # skip card mark if so
8354 movl offThread_retval(%ecx),%eax # eax<- object head
8355 movl offThread_cardTable(%ecx),%ecx # card table base
8356 shrl $GC_CARD_SHIFT,%eax # convert to card num
8357 movb %cl,(%ecx,%eax) # mark card based on object head
8359 FETCH_INST_OPCODE 5 %ecx
8365 * Throw an exception indicating that we have not implemented this
8366 * mode of filled-new-array.
8368 .LOP_FILLED_NEW_ARRAY_JUMBO_notimpl:
8369 movl $.LstrFilledNewArrayNotImplA,%eax
8370 movl %eax,OUT_ARG0(%esp)
8371 call dvmThrowInternalError
8372 jmp common_exceptionThrown
8374 /* ------------------------------ */
8375 .L_OP_IGET_JUMBO: /* 0x106 */
8376 /* File: x86/OP_IGET_JUMBO.S */
8378 * Jumbo 32-bit instance field get.
8380 * for: iget/jumbo, iget-object/jumbo, iget-boolean/jumbo, iget-byte/jumbo,
8381 * iget-char/jumbo, iget-short/jumbo
8383 /* exop vBBBB, vCCCC, field@AAAAAAAA */
8385 SPILL(rIBASE) # preserve rIBASE
8386 movl 2(rPC),rIBASE # rIBASE<- AAAAAAAA
8387 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex
8388 movzwl 8(rPC),%ecx # ecx<- CCCC
8389 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields
8390 GET_VREG_R %ecx %ecx # ecx<- fp[CCCC], the object ptr
8391 movl (%eax,rIBASE,4),%eax # resolved entry
8392 testl %eax,%eax # is resolved entry null?
8393 jne .LOP_IGET_JUMBO_finish # no, already resolved
8394 movl rIBASE,OUT_ARG1(%esp) # needed by dvmResolveInstField
8397 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method
8398 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz
8399 SPILL_TMP1(%ecx) # save obj pointer across call
8400 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz
8401 call dvmResolveInstField # ... to dvmResolveInstField
8403 testl %eax,%eax # returns InstrField ptr
8404 jne .LOP_IGET_JUMBO_finish
8405 jmp common_exceptionThrown
8407 .LOP_IGET_JUMBO_finish:
8410 * eax holds resolved field
8414 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field
8415 testl %ecx,%ecx # object null?
8416 je common_errNullObject # object was null
8417 movl (%ecx,%eax,1),%ecx # ecx<- obj.field (8/16/32 bits)
8418 FETCH_INST_OPCODE 5 %eax
8419 UNSPILL(rIBASE) # restore rIBASE
8424 /* ------------------------------ */
8425 .L_OP_IGET_WIDE_JUMBO: /* 0x107 */
8426 /* File: x86/OP_IGET_WIDE_JUMBO.S */
8428 * Jumbo 64-bit instance field get.
8430 /* iget-wide/jumbo vBBBB, vCCCC, field@AAAA */
8432 SPILL(rIBASE) # preserve rIBASE
8433 movl 2(rPC),rIBASE # rIBASE<- AAAAAAAA
8434 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex
8435 movzwl 8(rPC),%ecx # ecx<- CCCC
8436 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields
8437 GET_VREG_R %ecx %ecx # ecx<- fp[CCCC], the object ptr
8438 movl (%eax,rIBASE,4),%eax # resolved entry
8439 testl %eax,%eax # is resolved entry null?
8440 jne .LOP_IGET_WIDE_JUMBO_finish # no, already resolved
8441 movl rIBASE,OUT_ARG1(%esp) # for dvmResolveInstField
8444 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method
8445 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz
8446 SPILL_TMP1(%ecx) # save objpointer across call
8447 movl rPC,OUT_ARG0(%esp) # pass in method->clazz
8448 call dvmResolveInstField # ... to dvmResolveInstField
8450 testl %eax,%eax # returns InstrField ptr
8451 jne .LOP_IGET_WIDE_JUMBO_finish
8452 jmp common_exceptionThrown
8454 .LOP_IGET_WIDE_JUMBO_finish:
8457 * eax holds resolved field
8461 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field
8462 testl %ecx,%ecx # object null?
8463 je common_errNullObject # object was null
8464 leal (%ecx,%eax,1),%eax # eax<- address of field
8465 movl (%eax),%ecx # ecx<- lsw
8466 movl 4(%eax),%eax # eax<- msw
8467 SET_VREG_WORD %ecx rINST 0
8468 FETCH_INST_OPCODE 5 %ecx
8469 UNSPILL(rIBASE) # restore rIBASE
8470 SET_VREG_WORD %eax rINST 1
8474 /* ------------------------------ */
8475 .L_OP_IGET_OBJECT_JUMBO: /* 0x108 */
8476 /* File: x86/OP_IGET_OBJECT_JUMBO.S */
8477 /* File: x86/OP_IGET_JUMBO.S */
8479 * Jumbo 32-bit instance field get.
8481 * for: iget/jumbo, iget-object/jumbo, iget-boolean/jumbo, iget-byte/jumbo,
8482 * iget-char/jumbo, iget-short/jumbo
8484 /* exop vBBBB, vCCCC, field@AAAAAAAA */
8486 SPILL(rIBASE) # preserve rIBASE
8487 movl 2(rPC),rIBASE # rIBASE<- AAAAAAAA
8488 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex
8489 movzwl 8(rPC),%ecx # ecx<- CCCC
8490 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields
8491 GET_VREG_R %ecx %ecx # ecx<- fp[CCCC], the object ptr
8492 movl (%eax,rIBASE,4),%eax # resolved entry
8493 testl %eax,%eax # is resolved entry null?
8494 jne .LOP_IGET_OBJECT_JUMBO_finish # no, already resolved
8495 movl rIBASE,OUT_ARG1(%esp) # needed by dvmResolveInstField
8498 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method
8499 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz
8500 SPILL_TMP1(%ecx) # save obj pointer across call
8501 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz
8502 call dvmResolveInstField # ... to dvmResolveInstField
8504 testl %eax,%eax # returns InstrField ptr
8505 jne .LOP_IGET_OBJECT_JUMBO_finish
8506 jmp common_exceptionThrown
8508 .LOP_IGET_OBJECT_JUMBO_finish:
8511 * eax holds resolved field
8515 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field
8516 testl %ecx,%ecx # object null?
8517 je common_errNullObject # object was null
8518 movl (%ecx,%eax,1),%ecx # ecx<- obj.field (8/16/32 bits)
8519 FETCH_INST_OPCODE 5 %eax
8520 UNSPILL(rIBASE) # restore rIBASE
8526 /* ------------------------------ */
8527 .L_OP_IGET_BOOLEAN_JUMBO: /* 0x109 */
8528 /* File: x86/OP_IGET_BOOLEAN_JUMBO.S */
8529 /* File: x86/OP_IGET_JUMBO.S */
8531 * Jumbo 32-bit instance field get.
8533 * for: iget/jumbo, iget-object/jumbo, iget-boolean/jumbo, iget-byte/jumbo,
8534 * iget-char/jumbo, iget-short/jumbo
8536 /* exop vBBBB, vCCCC, field@AAAAAAAA */
8538 SPILL(rIBASE) # preserve rIBASE
8539 movl 2(rPC),rIBASE # rIBASE<- AAAAAAAA
8540 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex
8541 movzwl 8(rPC),%ecx # ecx<- CCCC
8542 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields
8543 GET_VREG_R %ecx %ecx # ecx<- fp[CCCC], the object ptr
8544 movl (%eax,rIBASE,4),%eax # resolved entry
8545 testl %eax,%eax # is resolved entry null?
8546 jne .LOP_IGET_BOOLEAN_JUMBO_finish # no, already resolved
8547 movl rIBASE,OUT_ARG1(%esp) # needed by dvmResolveInstField
8550 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method
8551 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz
8552 SPILL_TMP1(%ecx) # save obj pointer across call
8553 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz
8554 call dvmResolveInstField # ... to dvmResolveInstField
8556 testl %eax,%eax # returns InstrField ptr
8557 jne .LOP_IGET_BOOLEAN_JUMBO_finish
8558 jmp common_exceptionThrown
8560 .LOP_IGET_BOOLEAN_JUMBO_finish:
8563 * eax holds resolved field
8567 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field
8568 testl %ecx,%ecx # object null?
8569 je common_errNullObject # object was null
8570 movzbl (%ecx,%eax,1),%ecx # ecx<- obj.field (8/16/32 bits)
8571 FETCH_INST_OPCODE 5 %eax
8572 UNSPILL(rIBASE) # restore rIBASE
8578 /* ------------------------------ */
8579 .L_OP_IGET_BYTE_JUMBO: /* 0x10a */
8580 /* File: x86/OP_IGET_BYTE_JUMBO.S */
8581 /* File: x86/OP_IGET_JUMBO.S */
8583 * Jumbo 32-bit instance field get.
8585 * for: iget/jumbo, iget-object/jumbo, iget-boolean/jumbo, iget-byte/jumbo,
8586 * iget-char/jumbo, iget-short/jumbo
8588 /* exop vBBBB, vCCCC, field@AAAAAAAA */
8590 SPILL(rIBASE) # preserve rIBASE
8591 movl 2(rPC),rIBASE # rIBASE<- AAAAAAAA
8592 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex
8593 movzwl 8(rPC),%ecx # ecx<- CCCC
8594 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields
8595 GET_VREG_R %ecx %ecx # ecx<- fp[CCCC], the object ptr
8596 movl (%eax,rIBASE,4),%eax # resolved entry
8597 testl %eax,%eax # is resolved entry null?
8598 jne .LOP_IGET_BYTE_JUMBO_finish # no, already resolved
8599 movl rIBASE,OUT_ARG1(%esp) # needed by dvmResolveInstField
8602 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method
8603 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz
8604 SPILL_TMP1(%ecx) # save obj pointer across call
8605 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz
8606 call dvmResolveInstField # ... to dvmResolveInstField
8608 testl %eax,%eax # returns InstrField ptr
8609 jne .LOP_IGET_BYTE_JUMBO_finish
8610 jmp common_exceptionThrown
8612 .LOP_IGET_BYTE_JUMBO_finish:
8615 * eax holds resolved field
8619 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field
8620 testl %ecx,%ecx # object null?
8621 je common_errNullObject # object was null
8622 movsbl (%ecx,%eax,1),%ecx # ecx<- obj.field (8/16/32 bits)
8623 FETCH_INST_OPCODE 5 %eax
8624 UNSPILL(rIBASE) # restore rIBASE
8630 /* ------------------------------ */
8631 .L_OP_IGET_CHAR_JUMBO: /* 0x10b */
8632 /* File: x86/OP_IGET_CHAR_JUMBO.S */
8633 /* File: x86/OP_IGET_JUMBO.S */
8635 * Jumbo 32-bit instance field get.
8637 * for: iget/jumbo, iget-object/jumbo, iget-boolean/jumbo, iget-byte/jumbo,
8638 * iget-char/jumbo, iget-short/jumbo
8640 /* exop vBBBB, vCCCC, field@AAAAAAAA */
8642 SPILL(rIBASE) # preserve rIBASE
8643 movl 2(rPC),rIBASE # rIBASE<- AAAAAAAA
8644 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex
8645 movzwl 8(rPC),%ecx # ecx<- CCCC
8646 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields
8647 GET_VREG_R %ecx %ecx # ecx<- fp[CCCC], the object ptr
8648 movl (%eax,rIBASE,4),%eax # resolved entry
8649 testl %eax,%eax # is resolved entry null?
8650 jne .LOP_IGET_CHAR_JUMBO_finish # no, already resolved
8651 movl rIBASE,OUT_ARG1(%esp) # needed by dvmResolveInstField
8654 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method
8655 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz
8656 SPILL_TMP1(%ecx) # save obj pointer across call
8657 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz
8658 call dvmResolveInstField # ... to dvmResolveInstField
8660 testl %eax,%eax # returns InstrField ptr
8661 jne .LOP_IGET_CHAR_JUMBO_finish
8662 jmp common_exceptionThrown
8664 .LOP_IGET_CHAR_JUMBO_finish:
8667 * eax holds resolved field
8671 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field
8672 testl %ecx,%ecx # object null?
8673 je common_errNullObject # object was null
8674 movzwl (%ecx,%eax,1),%ecx # ecx<- obj.field (8/16/32 bits)
8675 FETCH_INST_OPCODE 5 %eax
8676 UNSPILL(rIBASE) # restore rIBASE
8682 /* ------------------------------ */
8683 .L_OP_IGET_SHORT_JUMBO: /* 0x10c */
8684 /* File: x86/OP_IGET_SHORT_JUMBO.S */
8685 /* File: x86/OP_IGET_JUMBO.S */
8687 * Jumbo 32-bit instance field get.
8689 * for: iget/jumbo, iget-object/jumbo, iget-boolean/jumbo, iget-byte/jumbo,
8690 * iget-char/jumbo, iget-short/jumbo
8692 /* exop vBBBB, vCCCC, field@AAAAAAAA */
8694 SPILL(rIBASE) # preserve rIBASE
8695 movl 2(rPC),rIBASE # rIBASE<- AAAAAAAA
8696 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex
8697 movzwl 8(rPC),%ecx # ecx<- CCCC
8698 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields
8699 GET_VREG_R %ecx %ecx # ecx<- fp[CCCC], the object ptr
8700 movl (%eax,rIBASE,4),%eax # resolved entry
8701 testl %eax,%eax # is resolved entry null?
8702 jne .LOP_IGET_SHORT_JUMBO_finish # no, already resolved
8703 movl rIBASE,OUT_ARG1(%esp) # needed by dvmResolveInstField
8706 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method
8707 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz
8708 SPILL_TMP1(%ecx) # save obj pointer across call
8709 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz
8710 call dvmResolveInstField # ... to dvmResolveInstField
8712 testl %eax,%eax # returns InstrField ptr
8713 jne .LOP_IGET_SHORT_JUMBO_finish
8714 jmp common_exceptionThrown
8716 .LOP_IGET_SHORT_JUMBO_finish:
8719 * eax holds resolved field
8723 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field
8724 testl %ecx,%ecx # object null?
8725 je common_errNullObject # object was null
8726 movswl (%ecx,%eax,1),%ecx # ecx<- obj.field (8/16/32 bits)
8727 FETCH_INST_OPCODE 5 %eax
8728 UNSPILL(rIBASE) # restore rIBASE
8734 /* ------------------------------ */
8735 .L_OP_IPUT_JUMBO: /* 0x10d */
8736 /* File: x86/OP_IPUT_JUMBO.S */
8738 * Jumbo 32-bit instance field put.
8740 * for: iput/jumbo, iput-object/jumbo, iput-boolean/jumbo, iput-byte/jumbo,
8741 iput-char/jumbo, iput-short/jumbo
8743 /* exop vBBBB, vCCCC, field@AAAAAAAA */
8746 movl 2(rPC),rIBASE # rIBASE<- AAAAAAAA
8747 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex
8748 movzwl 8(rPC),%ecx # ecx<- CCCC
8749 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields
8750 GET_VREG_R %ecx %ecx # ecx<- fp[CCCC], the object ptr
8751 movl (%eax,rIBASE,4),%eax # resolved entry
8752 testl %eax,%eax # is resolved entry null?
8753 jne .LOP_IPUT_JUMBO_finish # no, already resolved
8754 movl rIBASE,OUT_ARG1(%esp)
8757 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method
8758 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz
8759 SPILL_TMP1(%ecx) # save obj pointer across call
8760 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz
8761 call dvmResolveInstField # ... to dvmResolveInstField
8763 testl %eax,%eax # returns InstrField ptr
8764 jne .LOP_IPUT_JUMBO_finish
8765 jmp common_exceptionThrown
8767 .LOP_IPUT_JUMBO_finish:
8770 * eax holds resolved field
8774 GET_VREG_R rINST rINST # rINST<- v[BBBB]
8775 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field
8776 testl %ecx,%ecx # object null?
8777 je common_errNullObject # object was null
8778 movl rINST,(%ecx,%eax,1) # obj.field <- v[BBBB](8/16/32 bits)
8779 FETCH_INST_OPCODE 5 %ecx
8784 /* ------------------------------ */
8785 .L_OP_IPUT_WIDE_JUMBO: /* 0x10e */
8786 /* File: x86/OP_IPUT_WIDE_JUMBO.S */
8788 * Jumbo 64-bit instance field put.
8790 /* iput-wide/jumbo vBBBB, vCCCC, field@AAAAAAAA */
8793 movl 2(rPC),rIBASE # rIBASE<- AAAAAAAA
8794 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex
8795 movzwl 8(rPC),%ecx # ecx<- CCCC
8796 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields
8797 GET_VREG_R %ecx %ecx # ecx<- fp[CCCC], the object ptr
8798 movl (%eax,rIBASE,4),%eax # resolved entry
8799 testl %eax,%eax # is resolved entry null?
8800 jne .LOP_IPUT_WIDE_JUMBO_finish # no, already resolved
8801 movl rIBASE,OUT_ARG1(%esp)
8804 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method
8805 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz
8806 SPILL_TMP1(%ecx) # save obj pointer across call
8807 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz
8808 call dvmResolveInstField # ... to dvmResolveInstField
8810 testl %eax,%eax # ... which returns InstrField ptr
8811 jne .LOP_IPUT_WIDE_JUMBO_finish
8812 jmp common_exceptionThrown
8814 .LOP_IPUT_WIDE_JUMBO_finish:
8817 * eax holds resolved field
8819 * rIBASE is scratch, but needs to be unspilled
8822 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field
8823 testl %ecx,%ecx # object null?
8824 je common_errNullObject # object was null
8825 leal (%ecx,%eax,1),%eax # eax<- address of field
8826 GET_VREG_WORD %ecx rINST 0 # ecx<- lsw
8827 GET_VREG_WORD rINST rINST 1 # rINST<- msw
8830 FETCH_INST_OPCODE 5 %ecx
8835 /* ------------------------------ */
8836 .L_OP_IPUT_OBJECT_JUMBO: /* 0x10f */
8837 /* File: x86/OP_IPUT_OBJECT_JUMBO.S */
8839 * Jumbo object field put.
8841 /* iput-object/jumbo vBBBB, vCCCC, field@AAAAAAAA */
8844 movl 2(rPC),rIBASE # rIBASE<- AAAAAAAA
8845 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex
8846 movzwl 8(rPC),%ecx # ecx<- CCCC
8847 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields
8848 GET_VREG_R %ecx %ecx # ecx<- fp[CCCC], the object ptr
8849 movl (%eax,rIBASE,4),%eax # resolved entry
8850 testl %eax,%eax # is resolved entry null?
8851 jne .LOP_IPUT_OBJECT_JUMBO_finish # no, already resolved
8852 movl rIBASE,OUT_ARG1(%esp)
8855 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method
8856 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz
8857 SPILL_TMP1(%ecx) # save obj pointer across call
8858 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz
8859 call dvmResolveInstField # ... to dvmResolveInstField
8861 testl %eax,%eax # returns InstrField ptr
8862 jne .LOP_IPUT_OBJECT_JUMBO_finish
8863 jmp common_exceptionThrown
8865 .LOP_IPUT_OBJECT_JUMBO_finish:
8868 * eax holds resolved field
8870 * rIBASE is scratch, but needs to be unspilled
8873 GET_VREG_R rINST rINST # rINST<- v[BBBB]
8874 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field
8875 testl %ecx,%ecx # object null?
8876 je common_errNullObject # object was null
8877 movl rINST,(%ecx,%eax) # obj.field <- v[BBBB](8/16/32 bits)
8879 testl rINST,rINST # stored a NULL?
8880 movl offThread_cardTable(%eax),%eax # get card table base
8881 je 1f # skip card mark if null store
8882 shrl $GC_CARD_SHIFT,%ecx # object head to card number
8883 movb %al,(%eax,%ecx) # mark card using object head
8885 FETCH_INST_OPCODE 5 %ecx
8890 /* ------------------------------ */
8891 .L_OP_IPUT_BOOLEAN_JUMBO: /* 0x110 */
8892 /* File: x86/OP_IPUT_BOOLEAN_JUMBO.S */
8893 /* File: x86/OP_IPUT_JUMBO.S */
8895 * Jumbo 32-bit instance field put.
8897 * for: iput/jumbo, iput-object/jumbo, iput-boolean/jumbo, iput-byte/jumbo,
8898 iput-char/jumbo, iput-short/jumbo
8900 /* exop vBBBB, vCCCC, field@AAAAAAAA */
8903 movl 2(rPC),rIBASE # rIBASE<- AAAAAAAA
8904 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex
8905 movzwl 8(rPC),%ecx # ecx<- CCCC
8906 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields
8907 GET_VREG_R %ecx %ecx # ecx<- fp[CCCC], the object ptr
8908 movl (%eax,rIBASE,4),%eax # resolved entry
8909 testl %eax,%eax # is resolved entry null?
8910 jne .LOP_IPUT_BOOLEAN_JUMBO_finish # no, already resolved
8911 movl rIBASE,OUT_ARG1(%esp)
8914 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method
8915 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz
8916 SPILL_TMP1(%ecx) # save obj pointer across call
8917 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz
8918 call dvmResolveInstField # ... to dvmResolveInstField
8920 testl %eax,%eax # returns InstrField ptr
8921 jne .LOP_IPUT_BOOLEAN_JUMBO_finish
8922 jmp common_exceptionThrown
8924 .LOP_IPUT_BOOLEAN_JUMBO_finish:
8927 * eax holds resolved field
8931 GET_VREG_R rINST rINST # rINST<- v[BBBB]
8932 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field
8933 testl %ecx,%ecx # object null?
8934 je common_errNullObject # object was null
8935 movb rINSTbl,(%ecx,%eax,1) # obj.field <- v[BBBB](8/16/32 bits)
8936 FETCH_INST_OPCODE 5 %ecx
8942 /* ------------------------------ */
8943 .L_OP_IPUT_BYTE_JUMBO: /* 0x111 */
8944 /* File: x86/OP_IPUT_BYTE_JUMBO.S */
8945 /* File: x86/OP_IPUT_JUMBO.S */
8947 * Jumbo 32-bit instance field put.
8949 * for: iput/jumbo, iput-object/jumbo, iput-boolean/jumbo, iput-byte/jumbo,
8950 iput-char/jumbo, iput-short/jumbo
8952 /* exop vBBBB, vCCCC, field@AAAAAAAA */
8955 movl 2(rPC),rIBASE # rIBASE<- AAAAAAAA
8956 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex
8957 movzwl 8(rPC),%ecx # ecx<- CCCC
8958 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields
8959 GET_VREG_R %ecx %ecx # ecx<- fp[CCCC], the object ptr
8960 movl (%eax,rIBASE,4),%eax # resolved entry
8961 testl %eax,%eax # is resolved entry null?
8962 jne .LOP_IPUT_BYTE_JUMBO_finish # no, already resolved
8963 movl rIBASE,OUT_ARG1(%esp)
8966 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method
8967 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz
8968 SPILL_TMP1(%ecx) # save obj pointer across call
8969 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz
8970 call dvmResolveInstField # ... to dvmResolveInstField
8972 testl %eax,%eax # returns InstrField ptr
8973 jne .LOP_IPUT_BYTE_JUMBO_finish
8974 jmp common_exceptionThrown
8976 .LOP_IPUT_BYTE_JUMBO_finish:
8979 * eax holds resolved field
8983 GET_VREG_R rINST rINST # rINST<- v[BBBB]
8984 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field
8985 testl %ecx,%ecx # object null?
8986 je common_errNullObject # object was null
8987 movb rINSTbl,(%ecx,%eax,1) # obj.field <- v[BBBB](8/16/32 bits)
8988 FETCH_INST_OPCODE 5 %ecx
8994 /* ------------------------------ */
8995 .L_OP_IPUT_CHAR_JUMBO: /* 0x112 */
8996 /* File: x86/OP_IPUT_CHAR_JUMBO.S */
8997 /* File: x86/OP_IPUT_JUMBO.S */
8999 * Jumbo 32-bit instance field put.
9001 * for: iput/jumbo, iput-object/jumbo, iput-boolean/jumbo, iput-byte/jumbo,
9002 iput-char/jumbo, iput-short/jumbo
9004 /* exop vBBBB, vCCCC, field@AAAAAAAA */
9007 movl 2(rPC),rIBASE # rIBASE<- AAAAAAAA
9008 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex
9009 movzwl 8(rPC),%ecx # ecx<- CCCC
9010 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields
9011 GET_VREG_R %ecx %ecx # ecx<- fp[CCCC], the object ptr
9012 movl (%eax,rIBASE,4),%eax # resolved entry
9013 testl %eax,%eax # is resolved entry null?
9014 jne .LOP_IPUT_CHAR_JUMBO_finish # no, already resolved
9015 movl rIBASE,OUT_ARG1(%esp)
9018 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method
9019 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz
9020 SPILL_TMP1(%ecx) # save obj pointer across call
9021 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz
9022 call dvmResolveInstField # ... to dvmResolveInstField
9024 testl %eax,%eax # returns InstrField ptr
9025 jne .LOP_IPUT_CHAR_JUMBO_finish
9026 jmp common_exceptionThrown
9028 .LOP_IPUT_CHAR_JUMBO_finish:
9031 * eax holds resolved field
9035 GET_VREG_R rINST rINST # rINST<- v[BBBB]
9036 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field
9037 testl %ecx,%ecx # object null?
9038 je common_errNullObject # object was null
9039 movw rINSTw,(%ecx,%eax,1) # obj.field <- v[BBBB](8/16/32 bits)
9040 FETCH_INST_OPCODE 5 %ecx
9046 /* ------------------------------ */
9047 .L_OP_IPUT_SHORT_JUMBO: /* 0x113 */
9048 /* File: x86/OP_IPUT_SHORT_JUMBO.S */
9049 /* File: x86/OP_IPUT_JUMBO.S */
9051 * Jumbo 32-bit instance field put.
9053 * for: iput/jumbo, iput-object/jumbo, iput-boolean/jumbo, iput-byte/jumbo,
9054 iput-char/jumbo, iput-short/jumbo
9056 /* exop vBBBB, vCCCC, field@AAAAAAAA */
9059 movl 2(rPC),rIBASE # rIBASE<- AAAAAAAA
9060 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex
9061 movzwl 8(rPC),%ecx # ecx<- CCCC
9062 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields
9063 GET_VREG_R %ecx %ecx # ecx<- fp[CCCC], the object ptr
9064 movl (%eax,rIBASE,4),%eax # resolved entry
9065 testl %eax,%eax # is resolved entry null?
9066 jne .LOP_IPUT_SHORT_JUMBO_finish # no, already resolved
9067 movl rIBASE,OUT_ARG1(%esp)
9070 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method
9071 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz
9072 SPILL_TMP1(%ecx) # save obj pointer across call
9073 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz
9074 call dvmResolveInstField # ... to dvmResolveInstField
9076 testl %eax,%eax # returns InstrField ptr
9077 jne .LOP_IPUT_SHORT_JUMBO_finish
9078 jmp common_exceptionThrown
9080 .LOP_IPUT_SHORT_JUMBO_finish:
9083 * eax holds resolved field
9087 GET_VREG_R rINST rINST # rINST<- v[BBBB]
9088 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field
9089 testl %ecx,%ecx # object null?
9090 je common_errNullObject # object was null
9091 movw rINSTw,(%ecx,%eax,1) # obj.field <- v[BBBB](8/16/32 bits)
9092 FETCH_INST_OPCODE 5 %ecx
9098 /* ------------------------------ */
9099 .L_OP_SGET_JUMBO: /* 0x114 */
9100 /* File: x86/OP_SGET_JUMBO.S */
9102 * Jumbo 32-bit SGET handler.
9104 * for: sget/jumbo, sget-object/jumbo, sget-boolean/jumbo, sget-byte/jumbo,
9105 * sget-char/jumbo, sget-short/jumbo
9107 /* exop vBBBB, field@AAAAAAAA */
9109 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex
9110 movl 2(rPC),%eax # eax<- field ref AAAAAAAA
9111 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields
9112 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr
9113 testl %eax,%eax # resolved entry null?
9114 je .LOP_SGET_JUMBO_resolve # if not, make it so
9115 .LOP_SGET_JUMBO_finish: # field ptr in eax
9116 movl offStaticField_value(%eax),%eax
9117 FETCH_INST_OPCODE 4 %ecx
9123 * Go resolve the field
9125 .LOP_SGET_JUMBO_resolve:
9127 movl 2(rPC),%eax # eax<- field ref AAAAAAAA
9128 movl offThread_method(%ecx),%ecx # ecx<- current method
9129 EXPORT_PC # could throw, need to export
9130 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz
9131 movl %eax,OUT_ARG1(%esp)
9132 movl %ecx,OUT_ARG0(%esp)
9134 call dvmResolveStaticField # eax<- resolved StaticField ptr
9137 jne .LOP_SGET_JUMBO_finish # success, continue
9138 jmp common_exceptionThrown # no, handle exception
9140 /* ------------------------------ */
9141 .L_OP_SGET_WIDE_JUMBO: /* 0x115 */
9142 /* File: x86/OP_SGET_WIDE_JUMBO.S */
9144 * Jumbo 64-bit SGET handler.
9147 /* sget-wide/jumbo vBBBB, field@AAAAAAAA */
9149 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex
9150 movl 2(rPC),%eax # eax<- field ref AAAAAAAA
9151 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields
9152 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr
9153 testl %eax,%eax # resolved entry null?
9154 je .LOP_SGET_WIDE_JUMBO_resolve # if not, make it so
9155 .LOP_SGET_WIDE_JUMBO_finish: # field ptr in eax
9156 movl offStaticField_value(%eax),%ecx # ecx<- lsw
9157 movl 4+offStaticField_value(%eax),%eax # eax<- msw
9158 SET_VREG_WORD %ecx rINST 0
9159 FETCH_INST_OPCODE 2 %ecx
9160 SET_VREG_WORD %eax rINST 1
9165 * Go resolve the field
9167 .LOP_SGET_WIDE_JUMBO_resolve:
9169 movl 2(rPC),%eax # eax<- field ref AAAAAAAA
9170 movl offThread_method(%ecx),%ecx # ecx<- current method
9171 EXPORT_PC # could throw, need to export
9172 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz
9173 movl %eax,OUT_ARG1(%esp)
9174 movl %ecx,OUT_ARG0(%esp)
9176 call dvmResolveStaticField # eax<- resolved StaticField ptr
9179 jne .LOP_SGET_WIDE_JUMBO_finish # success, continue
9180 jmp common_exceptionThrown # no, handle exception
9182 /* ------------------------------ */
9183 .L_OP_SGET_OBJECT_JUMBO: /* 0x116 */
9184 /* File: x86/OP_SGET_OBJECT_JUMBO.S */
9185 /* File: x86/OP_SGET_JUMBO.S */
9187 * Jumbo 32-bit SGET handler.
9189 * for: sget/jumbo, sget-object/jumbo, sget-boolean/jumbo, sget-byte/jumbo,
9190 * sget-char/jumbo, sget-short/jumbo
9192 /* exop vBBBB, field@AAAAAAAA */
9194 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex
9195 movl 2(rPC),%eax # eax<- field ref AAAAAAAA
9196 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields
9197 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr
9198 testl %eax,%eax # resolved entry null?
9199 je .LOP_SGET_OBJECT_JUMBO_resolve # if not, make it so
9200 .LOP_SGET_OBJECT_JUMBO_finish: # field ptr in eax
9201 movl offStaticField_value(%eax),%eax
9202 FETCH_INST_OPCODE 4 %ecx
9208 * Go resolve the field
9210 .LOP_SGET_OBJECT_JUMBO_resolve:
9212 movl 2(rPC),%eax # eax<- field ref AAAAAAAA
9213 movl offThread_method(%ecx),%ecx # ecx<- current method
9214 EXPORT_PC # could throw, need to export
9215 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz
9216 movl %eax,OUT_ARG1(%esp)
9217 movl %ecx,OUT_ARG0(%esp)
9219 call dvmResolveStaticField # eax<- resolved StaticField ptr
9222 jne .LOP_SGET_OBJECT_JUMBO_finish # success, continue
9223 jmp common_exceptionThrown # no, handle exception
9226 /* ------------------------------ */
9227 .L_OP_SGET_BOOLEAN_JUMBO: /* 0x117 */
9228 /* File: x86/OP_SGET_BOOLEAN_JUMBO.S */
9229 /* File: x86/OP_SGET_JUMBO.S */
9231 * Jumbo 32-bit SGET handler.
9233 * for: sget/jumbo, sget-object/jumbo, sget-boolean/jumbo, sget-byte/jumbo,
9234 * sget-char/jumbo, sget-short/jumbo
9236 /* exop vBBBB, field@AAAAAAAA */
9238 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex
9239 movl 2(rPC),%eax # eax<- field ref AAAAAAAA
9240 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields
9241 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr
9242 testl %eax,%eax # resolved entry null?
9243 je .LOP_SGET_BOOLEAN_JUMBO_resolve # if not, make it so
9244 .LOP_SGET_BOOLEAN_JUMBO_finish: # field ptr in eax
9245 movl offStaticField_value(%eax),%eax
9246 FETCH_INST_OPCODE 4 %ecx
9252 * Go resolve the field
9254 .LOP_SGET_BOOLEAN_JUMBO_resolve:
9256 movl 2(rPC),%eax # eax<- field ref AAAAAAAA
9257 movl offThread_method(%ecx),%ecx # ecx<- current method
9258 EXPORT_PC # could throw, need to export
9259 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz
9260 movl %eax,OUT_ARG1(%esp)
9261 movl %ecx,OUT_ARG0(%esp)
9263 call dvmResolveStaticField # eax<- resolved StaticField ptr
9266 jne .LOP_SGET_BOOLEAN_JUMBO_finish # success, continue
9267 jmp common_exceptionThrown # no, handle exception
9270 /* ------------------------------ */
9271 .L_OP_SGET_BYTE_JUMBO: /* 0x118 */
9272 /* File: x86/OP_SGET_BYTE_JUMBO.S */
9273 /* File: x86/OP_SGET_JUMBO.S */
9275 * Jumbo 32-bit SGET handler.
9277 * for: sget/jumbo, sget-object/jumbo, sget-boolean/jumbo, sget-byte/jumbo,
9278 * sget-char/jumbo, sget-short/jumbo
9280 /* exop vBBBB, field@AAAAAAAA */
9282 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex
9283 movl 2(rPC),%eax # eax<- field ref AAAAAAAA
9284 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields
9285 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr
9286 testl %eax,%eax # resolved entry null?
9287 je .LOP_SGET_BYTE_JUMBO_resolve # if not, make it so
9288 .LOP_SGET_BYTE_JUMBO_finish: # field ptr in eax
9289 movl offStaticField_value(%eax),%eax
9290 FETCH_INST_OPCODE 4 %ecx
9296 * Go resolve the field
9298 .LOP_SGET_BYTE_JUMBO_resolve:
9300 movl 2(rPC),%eax # eax<- field ref AAAAAAAA
9301 movl offThread_method(%ecx),%ecx # ecx<- current method
9302 EXPORT_PC # could throw, need to export
9303 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz
9304 movl %eax,OUT_ARG1(%esp)
9305 movl %ecx,OUT_ARG0(%esp)
9307 call dvmResolveStaticField # eax<- resolved StaticField ptr
9310 jne .LOP_SGET_BYTE_JUMBO_finish # success, continue
9311 jmp common_exceptionThrown # no, handle exception
9314 /* ------------------------------ */
9315 .L_OP_SGET_CHAR_JUMBO: /* 0x119 */
9316 /* File: x86/OP_SGET_CHAR_JUMBO.S */
9317 /* File: x86/OP_SGET_JUMBO.S */
9319 * Jumbo 32-bit SGET handler.
9321 * for: sget/jumbo, sget-object/jumbo, sget-boolean/jumbo, sget-byte/jumbo,
9322 * sget-char/jumbo, sget-short/jumbo
9324 /* exop vBBBB, field@AAAAAAAA */
9326 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex
9327 movl 2(rPC),%eax # eax<- field ref AAAAAAAA
9328 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields
9329 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr
9330 testl %eax,%eax # resolved entry null?
9331 je .LOP_SGET_CHAR_JUMBO_resolve # if not, make it so
9332 .LOP_SGET_CHAR_JUMBO_finish: # field ptr in eax
9333 movl offStaticField_value(%eax),%eax
9334 FETCH_INST_OPCODE 4 %ecx
9340 * Go resolve the field
9342 .LOP_SGET_CHAR_JUMBO_resolve:
9344 movl 2(rPC),%eax # eax<- field ref AAAAAAAA
9345 movl offThread_method(%ecx),%ecx # ecx<- current method
9346 EXPORT_PC # could throw, need to export
9347 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz
9348 movl %eax,OUT_ARG1(%esp)
9349 movl %ecx,OUT_ARG0(%esp)
9351 call dvmResolveStaticField # eax<- resolved StaticField ptr
9354 jne .LOP_SGET_CHAR_JUMBO_finish # success, continue
9355 jmp common_exceptionThrown # no, handle exception
9358 /* ------------------------------ */
9359 .L_OP_SGET_SHORT_JUMBO: /* 0x11a */
9360 /* File: x86/OP_SGET_SHORT_JUMBO.S */
9361 /* File: x86/OP_SGET_JUMBO.S */
9363 * Jumbo 32-bit SGET handler.
9365 * for: sget/jumbo, sget-object/jumbo, sget-boolean/jumbo, sget-byte/jumbo,
9366 * sget-char/jumbo, sget-short/jumbo
9368 /* exop vBBBB, field@AAAAAAAA */
9370 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex
9371 movl 2(rPC),%eax # eax<- field ref AAAAAAAA
9372 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields
9373 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr
9374 testl %eax,%eax # resolved entry null?
9375 je .LOP_SGET_SHORT_JUMBO_resolve # if not, make it so
9376 .LOP_SGET_SHORT_JUMBO_finish: # field ptr in eax
9377 movl offStaticField_value(%eax),%eax
9378 FETCH_INST_OPCODE 4 %ecx
9384 * Go resolve the field
9386 .LOP_SGET_SHORT_JUMBO_resolve:
9388 movl 2(rPC),%eax # eax<- field ref AAAAAAAA
9389 movl offThread_method(%ecx),%ecx # ecx<- current method
9390 EXPORT_PC # could throw, need to export
9391 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz
9392 movl %eax,OUT_ARG1(%esp)
9393 movl %ecx,OUT_ARG0(%esp)
9395 call dvmResolveStaticField # eax<- resolved StaticField ptr
9398 jne .LOP_SGET_SHORT_JUMBO_finish # success, continue
9399 jmp common_exceptionThrown # no, handle exception
9402 /* ------------------------------ */
9403 .L_OP_SPUT_JUMBO: /* 0x11b */
9404 /* File: x86/OP_SPUT_JUMBO.S */
9406 * Jumbo 32-bit SPUT handler.
9408 * for: sput/jumbo, sput-boolean/jumbo, sput-byte/jumbo, sput-char/jumbo,
9411 /* exop vBBBB, field@AAAAAAAA */
9413 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex
9414 movl 2(rPC),%eax # eax<- field ref AAAAAAAA
9415 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields
9416 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr
9417 testl %eax,%eax # resolved entry null?
9418 je .LOP_SPUT_JUMBO_resolve # if not, make it so
9419 .LOP_SPUT_JUMBO_finish: # field ptr in eax
9420 GET_VREG_R rINST rINST
9421 FETCH_INST_OPCODE 4 %ecx
9423 movl rINST,offStaticField_value(%eax)
9427 * Go resolve the field
9429 .LOP_SPUT_JUMBO_resolve:
9431 movl 2(rPC),%eax # eax<- field ref AAAAAAAA
9432 movl offThread_method(%ecx),%ecx # ecx<- current method
9433 EXPORT_PC # could throw, need to export
9434 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz
9435 movl %eax,OUT_ARG1(%esp)
9436 movl %ecx,OUT_ARG0(%esp)
9438 call dvmResolveStaticField # eax<- resolved StaticField ptr
9441 jne .LOP_SPUT_JUMBO_finish # success, continue
9442 jmp common_exceptionThrown # no, handle exception
9444 /* ------------------------------ */
9445 .L_OP_SPUT_WIDE_JUMBO: /* 0x11c */
9446 /* File: x86/OP_SPUT_WIDE_JUMBO.S */
9448 * Jumbo 64-bit SPUT handler.
9450 /* sput-wide/jumbo vBBBB, field@AAAAAAAA */
9452 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex
9453 movl 2(rPC),%eax # eax<- field ref AAAAAAAA
9454 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields
9455 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr
9456 testl %eax,%eax # resolved entry null?
9457 je .LOP_SPUT_WIDE_JUMBO_resolve # if not, make it so
9458 .LOP_SPUT_WIDE_JUMBO_finish: # field ptr in eax
9459 GET_VREG_WORD %ecx rINST 0 # ecx<- lsw
9460 GET_VREG_WORD rINST rINST 1 # rINST<- msw
9461 movl %ecx,offStaticField_value(%eax)
9462 FETCH_INST_OPCODE 4 %ecx
9463 movl rINST,4+offStaticField_value(%eax)
9468 * Go resolve the field
9470 .LOP_SPUT_WIDE_JUMBO_resolve:
9472 movl 2(rPC),%eax # eax<- field ref AAAAAAAA
9473 movl offThread_method(%ecx),%ecx # ecx<- current method
9474 EXPORT_PC # could throw, need to export
9475 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz
9476 movl %eax,OUT_ARG1(%esp)
9477 movl %ecx,OUT_ARG0(%esp)
9479 call dvmResolveStaticField # eax<- resolved StaticField ptr
9482 jne .LOP_SPUT_WIDE_JUMBO_finish # success, continue
9483 jmp common_exceptionThrown # no, handle exception
9485 /* ------------------------------ */
9486 .L_OP_SPUT_OBJECT_JUMBO: /* 0x11d */
9487 /* File: x86/OP_SPUT_OBJECT_JUMBO.S */
9489 * Jumbo SPUT object handler.
9491 /* sput-object/jumbo vBBBB, field@AAAAAAAA */
9493 movl 2(rPC),%eax # eax<- field ref AAAAAAAA
9494 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex
9495 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields
9496 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField
9497 testl %eax,%eax # resolved entry null?
9498 je .LOP_SPUT_OBJECT_JUMBO_resolve # if not, make it so
9499 .LOP_SPUT_OBJECT_JUMBO_finish: # field ptr in eax
9500 GET_VREG_R %ecx rINST
9501 movl %ecx,offStaticField_value(%eax) # do the store
9502 testl %ecx,%ecx # stored null object ptr?
9503 je 1f # skip card mark if null
9505 movl offField_clazz(%eax),%eax # eax<- method->clazz
9506 movl offThread_cardTable(%ecx),%ecx # get card table base
9507 shrl $GC_CARD_SHIFT,%eax # head to card number
9508 movb %cl,(%ecx,%eax) # mark card
9510 FETCH_INST_OPCODE 4 %ecx
9514 .LOP_SPUT_OBJECT_JUMBO_resolve:
9516 movl 2(rPC),%eax # eax<- field ref AAAAAAAA
9517 movl offThread_method(%ecx),%ecx # ecx<- current method
9518 EXPORT_PC # could throw, need to export
9519 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz
9520 movl %eax,OUT_ARG1(%esp)
9521 movl %ecx,OUT_ARG0(%esp)
9523 call dvmResolveStaticField # eax<- resolved StaticField ptr
9526 jne .LOP_SPUT_OBJECT_JUMBO_finish # success, continue
9527 jmp common_exceptionThrown # no, handle exception
9529 /* ------------------------------ */
9530 .L_OP_SPUT_BOOLEAN_JUMBO: /* 0x11e */
9531 /* File: x86/OP_SPUT_BOOLEAN_JUMBO.S */
9532 /* File: x86/OP_SPUT_JUMBO.S */
9534 * Jumbo 32-bit SPUT handler.
9536 * for: sput/jumbo, sput-boolean/jumbo, sput-byte/jumbo, sput-char/jumbo,
9539 /* exop vBBBB, field@AAAAAAAA */
9541 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex
9542 movl 2(rPC),%eax # eax<- field ref AAAAAAAA
9543 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields
9544 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr
9545 testl %eax,%eax # resolved entry null?
9546 je .LOP_SPUT_BOOLEAN_JUMBO_resolve # if not, make it so
9547 .LOP_SPUT_BOOLEAN_JUMBO_finish: # field ptr in eax
9548 GET_VREG_R rINST rINST
9549 FETCH_INST_OPCODE 4 %ecx
9551 movl rINST,offStaticField_value(%eax)
9555 * Go resolve the field
9557 .LOP_SPUT_BOOLEAN_JUMBO_resolve:
9559 movl 2(rPC),%eax # eax<- field ref AAAAAAAA
9560 movl offThread_method(%ecx),%ecx # ecx<- current method
9561 EXPORT_PC # could throw, need to export
9562 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz
9563 movl %eax,OUT_ARG1(%esp)
9564 movl %ecx,OUT_ARG0(%esp)
9566 call dvmResolveStaticField # eax<- resolved StaticField ptr
9569 jne .LOP_SPUT_BOOLEAN_JUMBO_finish # success, continue
9570 jmp common_exceptionThrown # no, handle exception
9573 /* ------------------------------ */
9574 .L_OP_SPUT_BYTE_JUMBO: /* 0x11f */
9575 /* File: x86/OP_SPUT_BYTE_JUMBO.S */
9576 /* File: x86/OP_SPUT_JUMBO.S */
9578 * Jumbo 32-bit SPUT handler.
9580 * for: sput/jumbo, sput-boolean/jumbo, sput-byte/jumbo, sput-char/jumbo,
9583 /* exop vBBBB, field@AAAAAAAA */
9585 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex
9586 movl 2(rPC),%eax # eax<- field ref AAAAAAAA
9587 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields
9588 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr
9589 testl %eax,%eax # resolved entry null?
9590 je .LOP_SPUT_BYTE_JUMBO_resolve # if not, make it so
9591 .LOP_SPUT_BYTE_JUMBO_finish: # field ptr in eax
9592 GET_VREG_R rINST rINST
9593 FETCH_INST_OPCODE 4 %ecx
9595 movl rINST,offStaticField_value(%eax)
9599 * Go resolve the field
9601 .LOP_SPUT_BYTE_JUMBO_resolve:
9603 movl 2(rPC),%eax # eax<- field ref AAAAAAAA
9604 movl offThread_method(%ecx),%ecx # ecx<- current method
9605 EXPORT_PC # could throw, need to export
9606 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz
9607 movl %eax,OUT_ARG1(%esp)
9608 movl %ecx,OUT_ARG0(%esp)
9610 call dvmResolveStaticField # eax<- resolved StaticField ptr
9613 jne .LOP_SPUT_BYTE_JUMBO_finish # success, continue
9614 jmp common_exceptionThrown # no, handle exception
9617 /* ------------------------------ */
9618 .L_OP_SPUT_CHAR_JUMBO: /* 0x120 */
9619 /* File: x86/OP_SPUT_CHAR_JUMBO.S */
9620 /* File: x86/OP_SPUT_JUMBO.S */
9622 * Jumbo 32-bit SPUT handler.
9624 * for: sput/jumbo, sput-boolean/jumbo, sput-byte/jumbo, sput-char/jumbo,
9627 /* exop vBBBB, field@AAAAAAAA */
9629 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex
9630 movl 2(rPC),%eax # eax<- field ref AAAAAAAA
9631 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields
9632 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr
9633 testl %eax,%eax # resolved entry null?
9634 je .LOP_SPUT_CHAR_JUMBO_resolve # if not, make it so
9635 .LOP_SPUT_CHAR_JUMBO_finish: # field ptr in eax
9636 GET_VREG_R rINST rINST
9637 FETCH_INST_OPCODE 4 %ecx
9639 movl rINST,offStaticField_value(%eax)
9643 * Go resolve the field
9645 .LOP_SPUT_CHAR_JUMBO_resolve:
9647 movl 2(rPC),%eax # eax<- field ref AAAAAAAA
9648 movl offThread_method(%ecx),%ecx # ecx<- current method
9649 EXPORT_PC # could throw, need to export
9650 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz
9651 movl %eax,OUT_ARG1(%esp)
9652 movl %ecx,OUT_ARG0(%esp)
9654 call dvmResolveStaticField # eax<- resolved StaticField ptr
9657 jne .LOP_SPUT_CHAR_JUMBO_finish # success, continue
9658 jmp common_exceptionThrown # no, handle exception
9661 /* ------------------------------ */
9662 .L_OP_SPUT_SHORT_JUMBO: /* 0x121 */
9663 /* File: x86/OP_SPUT_SHORT_JUMBO.S */
9664 /* File: x86/OP_SPUT_JUMBO.S */
9666 * Jumbo 32-bit SPUT handler.
9668 * for: sput/jumbo, sput-boolean/jumbo, sput-byte/jumbo, sput-char/jumbo,
9671 /* exop vBBBB, field@AAAAAAAA */
9673 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex
9674 movl 2(rPC),%eax # eax<- field ref AAAAAAAA
9675 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields
9676 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr
9677 testl %eax,%eax # resolved entry null?
9678 je .LOP_SPUT_SHORT_JUMBO_resolve # if not, make it so
9679 .LOP_SPUT_SHORT_JUMBO_finish: # field ptr in eax
9680 GET_VREG_R rINST rINST
9681 FETCH_INST_OPCODE 4 %ecx
9683 movl rINST,offStaticField_value(%eax)
9687 * Go resolve the field
9689 .LOP_SPUT_SHORT_JUMBO_resolve:
9691 movl 2(rPC),%eax # eax<- field ref AAAAAAAA
9692 movl offThread_method(%ecx),%ecx # ecx<- current method
9693 EXPORT_PC # could throw, need to export
9694 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz
9695 movl %eax,OUT_ARG1(%esp)
9696 movl %ecx,OUT_ARG0(%esp)
9698 call dvmResolveStaticField # eax<- resolved StaticField ptr
9701 jne .LOP_SPUT_SHORT_JUMBO_finish # success, continue
9702 jmp common_exceptionThrown # no, handle exception
9705 /* ------------------------------ */
9706 .L_OP_INVOKE_VIRTUAL_JUMBO: /* 0x122 */
9707 /* File: x86/OP_INVOKE_VIRTUAL_JUMBO.S */
9709 * Handle a jumbo virtual method call.
9711 /* invoke-virtual/jumbo vBBBB, {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */
9713 movl 2(rPC),%ecx # ecx<- AAAAAAAA
9714 movl offThread_methodClassDex(%eax),%eax # eax<- pDvmDex
9716 movl offDvmDex_pResMethods(%eax),%eax # eax<- pDvmDex->pResMethods
9717 movl (%eax,%ecx,4),%eax # eax<- resolved baseMethod
9718 testl %eax,%eax # already resolved?
9719 jne .LOP_INVOKE_VIRTUAL_JUMBO_continue # yes, continue
9721 movl %ecx,OUT_ARG1(%esp) # arg1<- ref
9722 movl offThread_method(%eax),%eax # eax<- self->method
9723 movl offMethod_clazz(%eax),%eax # ecx<- method->clazz
9724 movl %eax,OUT_ARG0(%esp) # arg0<- clazz
9725 movl $METHOD_VIRTUAL,OUT_ARG2(%esp) # arg2<- flags
9726 call dvmResolveMethod # eax<- call(clazz, ref, flags)
9727 testl %eax,%eax # got null?
9728 jne .LOP_INVOKE_VIRTUAL_JUMBO_continue # no, continue
9729 jmp common_exceptionThrown # yes, handle exception
9732 * eax = resolved base method
9735 .LOP_INVOKE_VIRTUAL_JUMBO_continue:
9736 movzwl 8(rPC),%ecx # ecx<- CCCC
9737 GET_VREG_R %ecx %ecx # ecx<- "this"
9738 movzwl offMethod_methodIndex(%eax),%eax # eax<- baseMethod->methodIndex
9739 testl %ecx,%ecx # null this?
9740 je common_errNullObject # go if so
9741 movl offObject_clazz(%ecx),%ecx # ecx<- thisPtr->clazz
9742 movl offClassObject_vtable(%ecx),%ecx # ecx<- thisPtr->clazz->vtable
9743 movl (%ecx,%eax,4),%eax # eax<- vtable[methodIndex]
9744 jmp common_invokeMethodJumbo
9746 /* ------------------------------ */
9747 .L_OP_INVOKE_SUPER_JUMBO: /* 0x123 */
9748 /* File: x86/OP_INVOKE_SUPER_JUMBO.S */
9750 * Handle a jumbo "super" method call.
9752 /* invoke-super/jumbo {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */
9754 movl 2(rPC),%eax # eax<- AAAAAAAA
9755 movl offThread_methodClassDex(rINST),%ecx # ecx<- pDvmDex
9757 movl offDvmDex_pResMethods(%ecx),%ecx # ecx<- pDvmDex->pResMethods
9758 movl (%ecx,%eax,4),%ecx # ecx<- resolved baseMethod
9759 movl offThread_method(rINST),%eax # eax<- method
9760 movzwl 8(rPC),rINST # rINST<- CCCC
9761 GET_VREG_R rINST rINST # rINST<- "this" ptr
9762 testl rINST,rINST # null "this"?
9763 je common_errNullObject # yes, throw
9764 movl offMethod_clazz(%eax),%eax # eax<- method->clazz
9765 testl %ecx,%ecx # already resolved?
9766 je .LOP_INVOKE_SUPER_JUMBO_resolve
9769 * ecx = resolved base method [r0]
9770 * eax = method->clazz [r9]
9772 .LOP_INVOKE_SUPER_JUMBO_continue:
9773 movl offClassObject_super(%eax),%eax # eax<- method->clazz->super
9774 movzwl offMethod_methodIndex(%ecx),%ecx # ecx<- baseMthod->methodIndex
9775 cmpl offClassObject_vtableCount(%eax),%ecx # compare(methodIndex,vtableCount)
9776 jae .LOP_INVOKE_SUPER_JUMBO_nsm # method not present in superclass
9777 movl offClassObject_vtable(%eax),%eax # eax<- ...clazz->super->vtable
9778 movl (%eax,%ecx,4),%eax # eax<- vtable[methodIndex]
9779 jmp common_invokeMethodJumbo
9783 * ecx = null (needs to be resolved base method)
9784 * eax = method->clazz
9786 .LOP_INVOKE_SUPER_JUMBO_resolve:
9787 SPILL_TMP1(%eax) # method->clazz
9788 movl %eax,OUT_ARG0(%esp) # arg0<- method->clazz
9789 movl 2(rPC),%ecx # ecx<- AAAAAAAA
9790 movl $METHOD_VIRTUAL,OUT_ARG2(%esp) # arg2<- resolver method type
9791 movl %ecx,OUT_ARG1(%esp) # arg1<- ref
9792 call dvmResolveMethod # eax<- call(clazz, ref, flags)
9793 testl %eax,%eax # got null?
9794 movl %eax,%ecx # ecx<- resolved base method
9795 UNSPILL_TMP1(%eax) # restore method->clazz
9796 jne .LOP_INVOKE_SUPER_JUMBO_continue # good to go - continue
9797 jmp common_exceptionThrown # handle exception
9800 * Throw a NoSuchMethodError with the method name as the message.
9801 * ecx = resolved base method
9803 .LOP_INVOKE_SUPER_JUMBO_nsm:
9804 movl offMethod_name(%ecx),%eax
9805 jmp common_errNoSuchMethod
9807 /* ------------------------------ */
9808 .L_OP_INVOKE_DIRECT_JUMBO: /* 0x124 */
9809 /* File: x86/OP_INVOKE_DIRECT_JUMBO.S */
9811 * Handle a jumbo direct method call.
9813 * (We could defer the "is 'this' pointer null" test to the common
9814 * method invocation code, and use a flag to indicate that static
9815 * calls don't count. If we do this as part of copying the arguments
9816 * out we could avoiding loading the first arg twice.)
9818 /* invoke-direct/jumbo {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */
9820 movl 2(rPC),%eax # eax<- AAAAAAAA
9821 movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex
9823 movl offDvmDex_pResMethods(%ecx),%ecx # ecx<- pDvmDex->pResMethods
9824 movzwl 8(rPC),rIBASE # rIBASE<- CCCC
9825 movl (%ecx,%eax,4),%eax # eax<- resolved methodToCall
9826 testl %eax,%eax # already resolved?
9827 GET_VREG_R %ecx rIBASE # ecx<- "this" ptr
9828 je .LOP_INVOKE_DIRECT_JUMBO_resolve # not resolved, do it now
9829 .LOP_INVOKE_DIRECT_JUMBO_finish:
9830 testl %ecx,%ecx # null "this"?
9831 jne common_invokeMethodJumbo # no, continue on
9832 jmp common_errNullObject
9836 * TMP_SPILL <- "this" register
9837 * Things a bit ugly on this path, but it's the less
9838 * frequent one. We'll have to do some reloading.
9840 .LOP_INVOKE_DIRECT_JUMBO_resolve:
9843 movl offThread_method(%ecx),%ecx # ecx<- self->method
9844 movl 2(rPC),%eax # reference AAAAAAAA
9845 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz
9846 movl $METHOD_DIRECT,OUT_ARG2(%esp)
9847 movl %eax,OUT_ARG1(%esp)
9848 movl %ecx,OUT_ARG0(%esp)
9849 call dvmResolveMethod # eax<- call(clazz, ref, flags)
9852 jne .LOP_INVOKE_DIRECT_JUMBO_finish
9853 jmp common_exceptionThrown
9855 /* ------------------------------ */
9856 .L_OP_INVOKE_STATIC_JUMBO: /* 0x125 */
9857 /* File: x86/OP_INVOKE_STATIC_JUMBO.S */
9859 * Handle a jumbo static method call.
9861 /* invoke-static/jumbo {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */
9863 movl 2(rPC),%eax # eax<- AAAAAAAA
9864 movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex
9866 movl offDvmDex_pResMethods(%ecx),%ecx # ecx<- pDvmDex->pResMethods
9867 movl (%ecx,%eax,4),%eax # eax<- resolved methodToCall
9869 jne common_invokeMethodJumbo
9871 movl offThread_method(%ecx),%ecx # ecx<- self->method
9872 movl 2(rPC),%eax # eax<- AAAAAAAA
9873 movl offMethod_clazz(%ecx),%ecx# ecx<- method->clazz
9874 movl %eax,OUT_ARG1(%esp) # arg1<- AAAAAAAA
9875 movl %ecx,OUT_ARG0(%esp) # arg0<- clazz
9876 movl $METHOD_STATIC,%eax
9877 movl %eax,OUT_ARG2(%esp) # arg2<- flags
9878 call dvmResolveMethod # call(clazz,ref,flags)
9879 testl %eax,%eax # got null?
9880 jne common_invokeMethodJumbo
9881 jmp common_exceptionThrown
9883 /* ------------------------------ */
9884 .L_OP_INVOKE_INTERFACE_JUMBO: /* 0x126 */
9885 /* File: x86/OP_INVOKE_INTERFACE_JUMBO.S */
9887 * Handle a jumbo interface method call.
9889 /* invoke-interface/jumbo {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */
9890 movzwl 8(rPC),%eax # eax<- CCCC
9892 GET_VREG_R %eax %eax # eax<- "this"
9894 testl %eax,%eax # null this?
9895 je common_errNullObject # yes, fail
9896 movl offObject_clazz(%eax),%eax# eax<- thisPtr->clazz
9897 movl %eax,OUT_ARG0(%esp) # arg0<- class
9898 movl offThread_methodClassDex(%ecx),%eax # eax<- methodClassDex
9899 movl offThread_method(%ecx),%ecx # ecx<- method
9900 movl %eax,OUT_ARG3(%esp) # arg3<- dex
9901 movl 2(rPC),%eax # eax<- AAAAAAAA
9902 movl %ecx,OUT_ARG2(%esp) # arg2<- method
9903 movl %eax,OUT_ARG1(%esp) # arg1<- AAAAAAAA
9904 call dvmFindInterfaceMethodInCache # eax<- call(class, ref, method, dex)
9906 je common_exceptionThrown
9907 jmp common_invokeMethodJumbo
9909 /* ------------------------------ */
9910 .L_OP_UNUSED_27FF: /* 0x127 */
9911 /* File: x86/OP_UNUSED_27FF.S */
9912 /* File: x86/unused.S */
9916 /* ------------------------------ */
9917 .L_OP_UNUSED_28FF: /* 0x128 */
9918 /* File: x86/OP_UNUSED_28FF.S */
9919 /* File: x86/unused.S */
9923 /* ------------------------------ */
9924 .L_OP_UNUSED_29FF: /* 0x129 */
9925 /* File: x86/OP_UNUSED_29FF.S */
9926 /* File: x86/unused.S */
9930 /* ------------------------------ */
9931 .L_OP_UNUSED_2AFF: /* 0x12a */
9932 /* File: x86/OP_UNUSED_2AFF.S */
9933 /* File: x86/unused.S */
9937 /* ------------------------------ */
9938 .L_OP_UNUSED_2BFF: /* 0x12b */
9939 /* File: x86/OP_UNUSED_2BFF.S */
9940 /* File: x86/unused.S */
9944 /* ------------------------------ */
9945 .L_OP_UNUSED_2CFF: /* 0x12c */
9946 /* File: x86/OP_UNUSED_2CFF.S */
9947 /* File: x86/unused.S */
9951 /* ------------------------------ */
9952 .L_OP_UNUSED_2DFF: /* 0x12d */
9953 /* File: x86/OP_UNUSED_2DFF.S */
9954 /* File: x86/unused.S */
9958 /* ------------------------------ */
9959 .L_OP_UNUSED_2EFF: /* 0x12e */
9960 /* File: x86/OP_UNUSED_2EFF.S */
9961 /* File: x86/unused.S */
9965 /* ------------------------------ */
9966 .L_OP_UNUSED_2FFF: /* 0x12f */
9967 /* File: x86/OP_UNUSED_2FFF.S */
9968 /* File: x86/unused.S */
9972 /* ------------------------------ */
9973 .L_OP_UNUSED_30FF: /* 0x130 */
9974 /* File: x86/OP_UNUSED_30FF.S */
9975 /* File: x86/unused.S */
9979 /* ------------------------------ */
9980 .L_OP_UNUSED_31FF: /* 0x131 */
9981 /* File: x86/OP_UNUSED_31FF.S */
9982 /* File: x86/unused.S */
9986 /* ------------------------------ */
9987 .L_OP_UNUSED_32FF: /* 0x132 */
9988 /* File: x86/OP_UNUSED_32FF.S */
9989 /* File: x86/unused.S */
9993 /* ------------------------------ */
9994 .L_OP_UNUSED_33FF: /* 0x133 */
9995 /* File: x86/OP_UNUSED_33FF.S */
9996 /* File: x86/unused.S */
10000 /* ------------------------------ */
10001 .L_OP_UNUSED_34FF: /* 0x134 */
10002 /* File: x86/OP_UNUSED_34FF.S */
10003 /* File: x86/unused.S */
10007 /* ------------------------------ */
10008 .L_OP_UNUSED_35FF: /* 0x135 */
10009 /* File: x86/OP_UNUSED_35FF.S */
10010 /* File: x86/unused.S */
10014 /* ------------------------------ */
10015 .L_OP_UNUSED_36FF: /* 0x136 */
10016 /* File: x86/OP_UNUSED_36FF.S */
10017 /* File: x86/unused.S */
10021 /* ------------------------------ */
10022 .L_OP_UNUSED_37FF: /* 0x137 */
10023 /* File: x86/OP_UNUSED_37FF.S */
10024 /* File: x86/unused.S */
10028 /* ------------------------------ */
10029 .L_OP_UNUSED_38FF: /* 0x138 */
10030 /* File: x86/OP_UNUSED_38FF.S */
10031 /* File: x86/unused.S */
10035 /* ------------------------------ */
10036 .L_OP_UNUSED_39FF: /* 0x139 */
10037 /* File: x86/OP_UNUSED_39FF.S */
10038 /* File: x86/unused.S */
10042 /* ------------------------------ */
10043 .L_OP_UNUSED_3AFF: /* 0x13a */
10044 /* File: x86/OP_UNUSED_3AFF.S */
10045 /* File: x86/unused.S */
10049 /* ------------------------------ */
10050 .L_OP_UNUSED_3BFF: /* 0x13b */
10051 /* File: x86/OP_UNUSED_3BFF.S */
10052 /* File: x86/unused.S */
10056 /* ------------------------------ */
10057 .L_OP_UNUSED_3CFF: /* 0x13c */
10058 /* File: x86/OP_UNUSED_3CFF.S */
10059 /* File: x86/unused.S */
10063 /* ------------------------------ */
10064 .L_OP_UNUSED_3DFF: /* 0x13d */
10065 /* File: x86/OP_UNUSED_3DFF.S */
10066 /* File: x86/unused.S */
10070 /* ------------------------------ */
10071 .L_OP_UNUSED_3EFF: /* 0x13e */
10072 /* File: x86/OP_UNUSED_3EFF.S */
10073 /* File: x86/unused.S */
10077 /* ------------------------------ */
10078 .L_OP_UNUSED_3FFF: /* 0x13f */
10079 /* File: x86/OP_UNUSED_3FFF.S */
10080 /* File: x86/unused.S */
10084 /* ------------------------------ */
10085 .L_OP_UNUSED_40FF: /* 0x140 */
10086 /* File: x86/OP_UNUSED_40FF.S */
10087 /* File: x86/unused.S */
10091 /* ------------------------------ */
10092 .L_OP_UNUSED_41FF: /* 0x141 */
10093 /* File: x86/OP_UNUSED_41FF.S */
10094 /* File: x86/unused.S */
10098 /* ------------------------------ */
10099 .L_OP_UNUSED_42FF: /* 0x142 */
10100 /* File: x86/OP_UNUSED_42FF.S */
10101 /* File: x86/unused.S */
10105 /* ------------------------------ */
10106 .L_OP_UNUSED_43FF: /* 0x143 */
10107 /* File: x86/OP_UNUSED_43FF.S */
10108 /* File: x86/unused.S */
10112 /* ------------------------------ */
10113 .L_OP_UNUSED_44FF: /* 0x144 */
10114 /* File: x86/OP_UNUSED_44FF.S */
10115 /* File: x86/unused.S */
10119 /* ------------------------------ */
10120 .L_OP_UNUSED_45FF: /* 0x145 */
10121 /* File: x86/OP_UNUSED_45FF.S */
10122 /* File: x86/unused.S */
10126 /* ------------------------------ */
10127 .L_OP_UNUSED_46FF: /* 0x146 */
10128 /* File: x86/OP_UNUSED_46FF.S */
10129 /* File: x86/unused.S */
10133 /* ------------------------------ */
10134 .L_OP_UNUSED_47FF: /* 0x147 */
10135 /* File: x86/OP_UNUSED_47FF.S */
10136 /* File: x86/unused.S */
10140 /* ------------------------------ */
10141 .L_OP_UNUSED_48FF: /* 0x148 */
10142 /* File: x86/OP_UNUSED_48FF.S */
10143 /* File: x86/unused.S */
10147 /* ------------------------------ */
10148 .L_OP_UNUSED_49FF: /* 0x149 */
10149 /* File: x86/OP_UNUSED_49FF.S */
10150 /* File: x86/unused.S */
10154 /* ------------------------------ */
10155 .L_OP_UNUSED_4AFF: /* 0x14a */
10156 /* File: x86/OP_UNUSED_4AFF.S */
10157 /* File: x86/unused.S */
10161 /* ------------------------------ */
10162 .L_OP_UNUSED_4BFF: /* 0x14b */
10163 /* File: x86/OP_UNUSED_4BFF.S */
10164 /* File: x86/unused.S */
10168 /* ------------------------------ */
10169 .L_OP_UNUSED_4CFF: /* 0x14c */
10170 /* File: x86/OP_UNUSED_4CFF.S */
10171 /* File: x86/unused.S */
10175 /* ------------------------------ */
10176 .L_OP_UNUSED_4DFF: /* 0x14d */
10177 /* File: x86/OP_UNUSED_4DFF.S */
10178 /* File: x86/unused.S */
10182 /* ------------------------------ */
10183 .L_OP_UNUSED_4EFF: /* 0x14e */
10184 /* File: x86/OP_UNUSED_4EFF.S */
10185 /* File: x86/unused.S */
10189 /* ------------------------------ */
10190 .L_OP_UNUSED_4FFF: /* 0x14f */
10191 /* File: x86/OP_UNUSED_4FFF.S */
10192 /* File: x86/unused.S */
10196 /* ------------------------------ */
10197 .L_OP_UNUSED_50FF: /* 0x150 */
10198 /* File: x86/OP_UNUSED_50FF.S */
10199 /* File: x86/unused.S */
10203 /* ------------------------------ */
10204 .L_OP_UNUSED_51FF: /* 0x151 */
10205 /* File: x86/OP_UNUSED_51FF.S */
10206 /* File: x86/unused.S */
10210 /* ------------------------------ */
10211 .L_OP_UNUSED_52FF: /* 0x152 */
10212 /* File: x86/OP_UNUSED_52FF.S */
10213 /* File: x86/unused.S */
10217 /* ------------------------------ */
10218 .L_OP_UNUSED_53FF: /* 0x153 */
10219 /* File: x86/OP_UNUSED_53FF.S */
10220 /* File: x86/unused.S */
10224 /* ------------------------------ */
10225 .L_OP_UNUSED_54FF: /* 0x154 */
10226 /* File: x86/OP_UNUSED_54FF.S */
10227 /* File: x86/unused.S */
10231 /* ------------------------------ */
10232 .L_OP_UNUSED_55FF: /* 0x155 */
10233 /* File: x86/OP_UNUSED_55FF.S */
10234 /* File: x86/unused.S */
10238 /* ------------------------------ */
10239 .L_OP_UNUSED_56FF: /* 0x156 */
10240 /* File: x86/OP_UNUSED_56FF.S */
10241 /* File: x86/unused.S */
10245 /* ------------------------------ */
10246 .L_OP_UNUSED_57FF: /* 0x157 */
10247 /* File: x86/OP_UNUSED_57FF.S */
10248 /* File: x86/unused.S */
10252 /* ------------------------------ */
10253 .L_OP_UNUSED_58FF: /* 0x158 */
10254 /* File: x86/OP_UNUSED_58FF.S */
10255 /* File: x86/unused.S */
10259 /* ------------------------------ */
10260 .L_OP_UNUSED_59FF: /* 0x159 */
10261 /* File: x86/OP_UNUSED_59FF.S */
10262 /* File: x86/unused.S */
10266 /* ------------------------------ */
10267 .L_OP_UNUSED_5AFF: /* 0x15a */
10268 /* File: x86/OP_UNUSED_5AFF.S */
10269 /* File: x86/unused.S */
10273 /* ------------------------------ */
10274 .L_OP_UNUSED_5BFF: /* 0x15b */
10275 /* File: x86/OP_UNUSED_5BFF.S */
10276 /* File: x86/unused.S */
10280 /* ------------------------------ */
10281 .L_OP_UNUSED_5CFF: /* 0x15c */
10282 /* File: x86/OP_UNUSED_5CFF.S */
10283 /* File: x86/unused.S */
10287 /* ------------------------------ */
10288 .L_OP_UNUSED_5DFF: /* 0x15d */
10289 /* File: x86/OP_UNUSED_5DFF.S */
10290 /* File: x86/unused.S */
10294 /* ------------------------------ */
10295 .L_OP_UNUSED_5EFF: /* 0x15e */
10296 /* File: x86/OP_UNUSED_5EFF.S */
10297 /* File: x86/unused.S */
10301 /* ------------------------------ */
10302 .L_OP_UNUSED_5FFF: /* 0x15f */
10303 /* File: x86/OP_UNUSED_5FFF.S */
10304 /* File: x86/unused.S */
10308 /* ------------------------------ */
10309 .L_OP_UNUSED_60FF: /* 0x160 */
10310 /* File: x86/OP_UNUSED_60FF.S */
10311 /* File: x86/unused.S */
10315 /* ------------------------------ */
10316 .L_OP_UNUSED_61FF: /* 0x161 */
10317 /* File: x86/OP_UNUSED_61FF.S */
10318 /* File: x86/unused.S */
10322 /* ------------------------------ */
10323 .L_OP_UNUSED_62FF: /* 0x162 */
10324 /* File: x86/OP_UNUSED_62FF.S */
10325 /* File: x86/unused.S */
10329 /* ------------------------------ */
10330 .L_OP_UNUSED_63FF: /* 0x163 */
10331 /* File: x86/OP_UNUSED_63FF.S */
10332 /* File: x86/unused.S */
10336 /* ------------------------------ */
10337 .L_OP_UNUSED_64FF: /* 0x164 */
10338 /* File: x86/OP_UNUSED_64FF.S */
10339 /* File: x86/unused.S */
10343 /* ------------------------------ */
10344 .L_OP_UNUSED_65FF: /* 0x165 */
10345 /* File: x86/OP_UNUSED_65FF.S */
10346 /* File: x86/unused.S */
10350 /* ------------------------------ */
10351 .L_OP_UNUSED_66FF: /* 0x166 */
10352 /* File: x86/OP_UNUSED_66FF.S */
10353 /* File: x86/unused.S */
10357 /* ------------------------------ */
10358 .L_OP_UNUSED_67FF: /* 0x167 */
10359 /* File: x86/OP_UNUSED_67FF.S */
10360 /* File: x86/unused.S */
10364 /* ------------------------------ */
10365 .L_OP_UNUSED_68FF: /* 0x168 */
10366 /* File: x86/OP_UNUSED_68FF.S */
10367 /* File: x86/unused.S */
10371 /* ------------------------------ */
10372 .L_OP_UNUSED_69FF: /* 0x169 */
10373 /* File: x86/OP_UNUSED_69FF.S */
10374 /* File: x86/unused.S */
10378 /* ------------------------------ */
10379 .L_OP_UNUSED_6AFF: /* 0x16a */
10380 /* File: x86/OP_UNUSED_6AFF.S */
10381 /* File: x86/unused.S */
10385 /* ------------------------------ */
10386 .L_OP_UNUSED_6BFF: /* 0x16b */
10387 /* File: x86/OP_UNUSED_6BFF.S */
10388 /* File: x86/unused.S */
10392 /* ------------------------------ */
10393 .L_OP_UNUSED_6CFF: /* 0x16c */
10394 /* File: x86/OP_UNUSED_6CFF.S */
10395 /* File: x86/unused.S */
10399 /* ------------------------------ */
10400 .L_OP_UNUSED_6DFF: /* 0x16d */
10401 /* File: x86/OP_UNUSED_6DFF.S */
10402 /* File: x86/unused.S */
10406 /* ------------------------------ */
10407 .L_OP_UNUSED_6EFF: /* 0x16e */
10408 /* File: x86/OP_UNUSED_6EFF.S */
10409 /* File: x86/unused.S */
10413 /* ------------------------------ */
10414 .L_OP_UNUSED_6FFF: /* 0x16f */
10415 /* File: x86/OP_UNUSED_6FFF.S */
10416 /* File: x86/unused.S */
10420 /* ------------------------------ */
10421 .L_OP_UNUSED_70FF: /* 0x170 */
10422 /* File: x86/OP_UNUSED_70FF.S */
10423 /* File: x86/unused.S */
10427 /* ------------------------------ */
10428 .L_OP_UNUSED_71FF: /* 0x171 */
10429 /* File: x86/OP_UNUSED_71FF.S */
10430 /* File: x86/unused.S */
10434 /* ------------------------------ */
10435 .L_OP_UNUSED_72FF: /* 0x172 */
10436 /* File: x86/OP_UNUSED_72FF.S */
10437 /* File: x86/unused.S */
10441 /* ------------------------------ */
10442 .L_OP_UNUSED_73FF: /* 0x173 */
10443 /* File: x86/OP_UNUSED_73FF.S */
10444 /* File: x86/unused.S */
10448 /* ------------------------------ */
10449 .L_OP_UNUSED_74FF: /* 0x174 */
10450 /* File: x86/OP_UNUSED_74FF.S */
10451 /* File: x86/unused.S */
10455 /* ------------------------------ */
10456 .L_OP_UNUSED_75FF: /* 0x175 */
10457 /* File: x86/OP_UNUSED_75FF.S */
10458 /* File: x86/unused.S */
10462 /* ------------------------------ */
10463 .L_OP_UNUSED_76FF: /* 0x176 */
10464 /* File: x86/OP_UNUSED_76FF.S */
10465 /* File: x86/unused.S */
10469 /* ------------------------------ */
10470 .L_OP_UNUSED_77FF: /* 0x177 */
10471 /* File: x86/OP_UNUSED_77FF.S */
10472 /* File: x86/unused.S */
10476 /* ------------------------------ */
10477 .L_OP_UNUSED_78FF: /* 0x178 */
10478 /* File: x86/OP_UNUSED_78FF.S */
10479 /* File: x86/unused.S */
10483 /* ------------------------------ */
10484 .L_OP_UNUSED_79FF: /* 0x179 */
10485 /* File: x86/OP_UNUSED_79FF.S */
10486 /* File: x86/unused.S */
10490 /* ------------------------------ */
10491 .L_OP_UNUSED_7AFF: /* 0x17a */
10492 /* File: x86/OP_UNUSED_7AFF.S */
10493 /* File: x86/unused.S */
10497 /* ------------------------------ */
10498 .L_OP_UNUSED_7BFF: /* 0x17b */
10499 /* File: x86/OP_UNUSED_7BFF.S */
10500 /* File: x86/unused.S */
10504 /* ------------------------------ */
10505 .L_OP_UNUSED_7CFF: /* 0x17c */
10506 /* File: x86/OP_UNUSED_7CFF.S */
10507 /* File: x86/unused.S */
10511 /* ------------------------------ */
10512 .L_OP_UNUSED_7DFF: /* 0x17d */
10513 /* File: x86/OP_UNUSED_7DFF.S */
10514 /* File: x86/unused.S */
10518 /* ------------------------------ */
10519 .L_OP_UNUSED_7EFF: /* 0x17e */
10520 /* File: x86/OP_UNUSED_7EFF.S */
10521 /* File: x86/unused.S */
10525 /* ------------------------------ */
10526 .L_OP_UNUSED_7FFF: /* 0x17f */
10527 /* File: x86/OP_UNUSED_7FFF.S */
10528 /* File: x86/unused.S */
10532 /* ------------------------------ */
10533 .L_OP_UNUSED_80FF: /* 0x180 */
10534 /* File: x86/OP_UNUSED_80FF.S */
10535 /* File: x86/unused.S */
10539 /* ------------------------------ */
10540 .L_OP_UNUSED_81FF: /* 0x181 */
10541 /* File: x86/OP_UNUSED_81FF.S */
10542 /* File: x86/unused.S */
10546 /* ------------------------------ */
10547 .L_OP_UNUSED_82FF: /* 0x182 */
10548 /* File: x86/OP_UNUSED_82FF.S */
10549 /* File: x86/unused.S */
10553 /* ------------------------------ */
10554 .L_OP_UNUSED_83FF: /* 0x183 */
10555 /* File: x86/OP_UNUSED_83FF.S */
10556 /* File: x86/unused.S */
10560 /* ------------------------------ */
10561 .L_OP_UNUSED_84FF: /* 0x184 */
10562 /* File: x86/OP_UNUSED_84FF.S */
10563 /* File: x86/unused.S */
10567 /* ------------------------------ */
10568 .L_OP_UNUSED_85FF: /* 0x185 */
10569 /* File: x86/OP_UNUSED_85FF.S */
10570 /* File: x86/unused.S */
10574 /* ------------------------------ */
10575 .L_OP_UNUSED_86FF: /* 0x186 */
10576 /* File: x86/OP_UNUSED_86FF.S */
10577 /* File: x86/unused.S */
10581 /* ------------------------------ */
10582 .L_OP_UNUSED_87FF: /* 0x187 */
10583 /* File: x86/OP_UNUSED_87FF.S */
10584 /* File: x86/unused.S */
10588 /* ------------------------------ */
10589 .L_OP_UNUSED_88FF: /* 0x188 */
10590 /* File: x86/OP_UNUSED_88FF.S */
10591 /* File: x86/unused.S */
10595 /* ------------------------------ */
10596 .L_OP_UNUSED_89FF: /* 0x189 */
10597 /* File: x86/OP_UNUSED_89FF.S */
10598 /* File: x86/unused.S */
10602 /* ------------------------------ */
10603 .L_OP_UNUSED_8AFF: /* 0x18a */
10604 /* File: x86/OP_UNUSED_8AFF.S */
10605 /* File: x86/unused.S */
10609 /* ------------------------------ */
10610 .L_OP_UNUSED_8BFF: /* 0x18b */
10611 /* File: x86/OP_UNUSED_8BFF.S */
10612 /* File: x86/unused.S */
10616 /* ------------------------------ */
10617 .L_OP_UNUSED_8CFF: /* 0x18c */
10618 /* File: x86/OP_UNUSED_8CFF.S */
10619 /* File: x86/unused.S */
10623 /* ------------------------------ */
10624 .L_OP_UNUSED_8DFF: /* 0x18d */
10625 /* File: x86/OP_UNUSED_8DFF.S */
10626 /* File: x86/unused.S */
10630 /* ------------------------------ */
10631 .L_OP_UNUSED_8EFF: /* 0x18e */
10632 /* File: x86/OP_UNUSED_8EFF.S */
10633 /* File: x86/unused.S */
10637 /* ------------------------------ */
10638 .L_OP_UNUSED_8FFF: /* 0x18f */
10639 /* File: x86/OP_UNUSED_8FFF.S */
10640 /* File: x86/unused.S */
10644 /* ------------------------------ */
10645 .L_OP_UNUSED_90FF: /* 0x190 */
10646 /* File: x86/OP_UNUSED_90FF.S */
10647 /* File: x86/unused.S */
10651 /* ------------------------------ */
10652 .L_OP_UNUSED_91FF: /* 0x191 */
10653 /* File: x86/OP_UNUSED_91FF.S */
10654 /* File: x86/unused.S */
10658 /* ------------------------------ */
10659 .L_OP_UNUSED_92FF: /* 0x192 */
10660 /* File: x86/OP_UNUSED_92FF.S */
10661 /* File: x86/unused.S */
10665 /* ------------------------------ */
10666 .L_OP_UNUSED_93FF: /* 0x193 */
10667 /* File: x86/OP_UNUSED_93FF.S */
10668 /* File: x86/unused.S */
10672 /* ------------------------------ */
10673 .L_OP_UNUSED_94FF: /* 0x194 */
10674 /* File: x86/OP_UNUSED_94FF.S */
10675 /* File: x86/unused.S */
10679 /* ------------------------------ */
10680 .L_OP_UNUSED_95FF: /* 0x195 */
10681 /* File: x86/OP_UNUSED_95FF.S */
10682 /* File: x86/unused.S */
10686 /* ------------------------------ */
10687 .L_OP_UNUSED_96FF: /* 0x196 */
10688 /* File: x86/OP_UNUSED_96FF.S */
10689 /* File: x86/unused.S */
10693 /* ------------------------------ */
10694 .L_OP_UNUSED_97FF: /* 0x197 */
10695 /* File: x86/OP_UNUSED_97FF.S */
10696 /* File: x86/unused.S */
10700 /* ------------------------------ */
10701 .L_OP_UNUSED_98FF: /* 0x198 */
10702 /* File: x86/OP_UNUSED_98FF.S */
10703 /* File: x86/unused.S */
10707 /* ------------------------------ */
10708 .L_OP_UNUSED_99FF: /* 0x199 */
10709 /* File: x86/OP_UNUSED_99FF.S */
10710 /* File: x86/unused.S */
10714 /* ------------------------------ */
10715 .L_OP_UNUSED_9AFF: /* 0x19a */
10716 /* File: x86/OP_UNUSED_9AFF.S */
10717 /* File: x86/unused.S */
10721 /* ------------------------------ */
10722 .L_OP_UNUSED_9BFF: /* 0x19b */
10723 /* File: x86/OP_UNUSED_9BFF.S */
10724 /* File: x86/unused.S */
10728 /* ------------------------------ */
10729 .L_OP_UNUSED_9CFF: /* 0x19c */
10730 /* File: x86/OP_UNUSED_9CFF.S */
10731 /* File: x86/unused.S */
10735 /* ------------------------------ */
10736 .L_OP_UNUSED_9DFF: /* 0x19d */
10737 /* File: x86/OP_UNUSED_9DFF.S */
10738 /* File: x86/unused.S */
10742 /* ------------------------------ */
10743 .L_OP_UNUSED_9EFF: /* 0x19e */
10744 /* File: x86/OP_UNUSED_9EFF.S */
10745 /* File: x86/unused.S */
10749 /* ------------------------------ */
10750 .L_OP_UNUSED_9FFF: /* 0x19f */
10751 /* File: x86/OP_UNUSED_9FFF.S */
10752 /* File: x86/unused.S */
10756 /* ------------------------------ */
10757 .L_OP_UNUSED_A0FF: /* 0x1a0 */
10758 /* File: x86/OP_UNUSED_A0FF.S */
10759 /* File: x86/unused.S */
10763 /* ------------------------------ */
10764 .L_OP_UNUSED_A1FF: /* 0x1a1 */
10765 /* File: x86/OP_UNUSED_A1FF.S */
10766 /* File: x86/unused.S */
10770 /* ------------------------------ */
10771 .L_OP_UNUSED_A2FF: /* 0x1a2 */
10772 /* File: x86/OP_UNUSED_A2FF.S */
10773 /* File: x86/unused.S */
10777 /* ------------------------------ */
10778 .L_OP_UNUSED_A3FF: /* 0x1a3 */
10779 /* File: x86/OP_UNUSED_A3FF.S */
10780 /* File: x86/unused.S */
10784 /* ------------------------------ */
10785 .L_OP_UNUSED_A4FF: /* 0x1a4 */
10786 /* File: x86/OP_UNUSED_A4FF.S */
10787 /* File: x86/unused.S */
10791 /* ------------------------------ */
10792 .L_OP_UNUSED_A5FF: /* 0x1a5 */
10793 /* File: x86/OP_UNUSED_A5FF.S */
10794 /* File: x86/unused.S */
10798 /* ------------------------------ */
10799 .L_OP_UNUSED_A6FF: /* 0x1a6 */
10800 /* File: x86/OP_UNUSED_A6FF.S */
10801 /* File: x86/unused.S */
10805 /* ------------------------------ */
10806 .L_OP_UNUSED_A7FF: /* 0x1a7 */
10807 /* File: x86/OP_UNUSED_A7FF.S */
10808 /* File: x86/unused.S */
10812 /* ------------------------------ */
10813 .L_OP_UNUSED_A8FF: /* 0x1a8 */
10814 /* File: x86/OP_UNUSED_A8FF.S */
10815 /* File: x86/unused.S */
10819 /* ------------------------------ */
10820 .L_OP_UNUSED_A9FF: /* 0x1a9 */
10821 /* File: x86/OP_UNUSED_A9FF.S */
10822 /* File: x86/unused.S */
10826 /* ------------------------------ */
10827 .L_OP_UNUSED_AAFF: /* 0x1aa */
10828 /* File: x86/OP_UNUSED_AAFF.S */
10829 /* File: x86/unused.S */
10833 /* ------------------------------ */
10834 .L_OP_UNUSED_ABFF: /* 0x1ab */
10835 /* File: x86/OP_UNUSED_ABFF.S */
10836 /* File: x86/unused.S */
10840 /* ------------------------------ */
10841 .L_OP_UNUSED_ACFF: /* 0x1ac */
10842 /* File: x86/OP_UNUSED_ACFF.S */
10843 /* File: x86/unused.S */
10847 /* ------------------------------ */
10848 .L_OP_UNUSED_ADFF: /* 0x1ad */
10849 /* File: x86/OP_UNUSED_ADFF.S */
10850 /* File: x86/unused.S */
10854 /* ------------------------------ */
10855 .L_OP_UNUSED_AEFF: /* 0x1ae */
10856 /* File: x86/OP_UNUSED_AEFF.S */
10857 /* File: x86/unused.S */
10861 /* ------------------------------ */
10862 .L_OP_UNUSED_AFFF: /* 0x1af */
10863 /* File: x86/OP_UNUSED_AFFF.S */
10864 /* File: x86/unused.S */
10868 /* ------------------------------ */
10869 .L_OP_UNUSED_B0FF: /* 0x1b0 */
10870 /* File: x86/OP_UNUSED_B0FF.S */
10871 /* File: x86/unused.S */
10875 /* ------------------------------ */
10876 .L_OP_UNUSED_B1FF: /* 0x1b1 */
10877 /* File: x86/OP_UNUSED_B1FF.S */
10878 /* File: x86/unused.S */
10882 /* ------------------------------ */
10883 .L_OP_UNUSED_B2FF: /* 0x1b2 */
10884 /* File: x86/OP_UNUSED_B2FF.S */
10885 /* File: x86/unused.S */
10889 /* ------------------------------ */
10890 .L_OP_UNUSED_B3FF: /* 0x1b3 */
10891 /* File: x86/OP_UNUSED_B3FF.S */
10892 /* File: x86/unused.S */
10896 /* ------------------------------ */
10897 .L_OP_UNUSED_B4FF: /* 0x1b4 */
10898 /* File: x86/OP_UNUSED_B4FF.S */
10899 /* File: x86/unused.S */
10903 /* ------------------------------ */
10904 .L_OP_UNUSED_B5FF: /* 0x1b5 */
10905 /* File: x86/OP_UNUSED_B5FF.S */
10906 /* File: x86/unused.S */
10910 /* ------------------------------ */
10911 .L_OP_UNUSED_B6FF: /* 0x1b6 */
10912 /* File: x86/OP_UNUSED_B6FF.S */
10913 /* File: x86/unused.S */
10917 /* ------------------------------ */
10918 .L_OP_UNUSED_B7FF: /* 0x1b7 */
10919 /* File: x86/OP_UNUSED_B7FF.S */
10920 /* File: x86/unused.S */
10924 /* ------------------------------ */
10925 .L_OP_UNUSED_B8FF: /* 0x1b8 */
10926 /* File: x86/OP_UNUSED_B8FF.S */
10927 /* File: x86/unused.S */
10931 /* ------------------------------ */
10932 .L_OP_UNUSED_B9FF: /* 0x1b9 */
10933 /* File: x86/OP_UNUSED_B9FF.S */
10934 /* File: x86/unused.S */
10938 /* ------------------------------ */
10939 .L_OP_UNUSED_BAFF: /* 0x1ba */
10940 /* File: x86/OP_UNUSED_BAFF.S */
10941 /* File: x86/unused.S */
10945 /* ------------------------------ */
10946 .L_OP_UNUSED_BBFF: /* 0x1bb */
10947 /* File: x86/OP_UNUSED_BBFF.S */
10948 /* File: x86/unused.S */
10952 /* ------------------------------ */
10953 .L_OP_UNUSED_BCFF: /* 0x1bc */
10954 /* File: x86/OP_UNUSED_BCFF.S */
10955 /* File: x86/unused.S */
10959 /* ------------------------------ */
10960 .L_OP_UNUSED_BDFF: /* 0x1bd */
10961 /* File: x86/OP_UNUSED_BDFF.S */
10962 /* File: x86/unused.S */
10966 /* ------------------------------ */
10967 .L_OP_UNUSED_BEFF: /* 0x1be */
10968 /* File: x86/OP_UNUSED_BEFF.S */
10969 /* File: x86/unused.S */
10973 /* ------------------------------ */
10974 .L_OP_UNUSED_BFFF: /* 0x1bf */
10975 /* File: x86/OP_UNUSED_BFFF.S */
10976 /* File: x86/unused.S */
10980 /* ------------------------------ */
10981 .L_OP_UNUSED_C0FF: /* 0x1c0 */
10982 /* File: x86/OP_UNUSED_C0FF.S */
10983 /* File: x86/unused.S */
10987 /* ------------------------------ */
10988 .L_OP_UNUSED_C1FF: /* 0x1c1 */
10989 /* File: x86/OP_UNUSED_C1FF.S */
10990 /* File: x86/unused.S */
10994 /* ------------------------------ */
10995 .L_OP_UNUSED_C2FF: /* 0x1c2 */
10996 /* File: x86/OP_UNUSED_C2FF.S */
10997 /* File: x86/unused.S */
11001 /* ------------------------------ */
11002 .L_OP_UNUSED_C3FF: /* 0x1c3 */
11003 /* File: x86/OP_UNUSED_C3FF.S */
11004 /* File: x86/unused.S */
11008 /* ------------------------------ */
11009 .L_OP_UNUSED_C4FF: /* 0x1c4 */
11010 /* File: x86/OP_UNUSED_C4FF.S */
11011 /* File: x86/unused.S */
11015 /* ------------------------------ */
11016 .L_OP_UNUSED_C5FF: /* 0x1c5 */
11017 /* File: x86/OP_UNUSED_C5FF.S */
11018 /* File: x86/unused.S */
11022 /* ------------------------------ */
11023 .L_OP_UNUSED_C6FF: /* 0x1c6 */
11024 /* File: x86/OP_UNUSED_C6FF.S */
11025 /* File: x86/unused.S */
11029 /* ------------------------------ */
11030 .L_OP_UNUSED_C7FF: /* 0x1c7 */
11031 /* File: x86/OP_UNUSED_C7FF.S */
11032 /* File: x86/unused.S */
11036 /* ------------------------------ */
11037 .L_OP_UNUSED_C8FF: /* 0x1c8 */
11038 /* File: x86/OP_UNUSED_C8FF.S */
11039 /* File: x86/unused.S */
11043 /* ------------------------------ */
11044 .L_OP_UNUSED_C9FF: /* 0x1c9 */
11045 /* File: x86/OP_UNUSED_C9FF.S */
11046 /* File: x86/unused.S */
11050 /* ------------------------------ */
11051 .L_OP_UNUSED_CAFF: /* 0x1ca */
11052 /* File: x86/OP_UNUSED_CAFF.S */
11053 /* File: x86/unused.S */
11057 /* ------------------------------ */
11058 .L_OP_UNUSED_CBFF: /* 0x1cb */
11059 /* File: x86/OP_UNUSED_CBFF.S */
11060 /* File: x86/unused.S */
11064 /* ------------------------------ */
11065 .L_OP_UNUSED_CCFF: /* 0x1cc */
11066 /* File: x86/OP_UNUSED_CCFF.S */
11067 /* File: x86/unused.S */
11071 /* ------------------------------ */
11072 .L_OP_UNUSED_CDFF: /* 0x1cd */
11073 /* File: x86/OP_UNUSED_CDFF.S */
11074 /* File: x86/unused.S */
11078 /* ------------------------------ */
11079 .L_OP_UNUSED_CEFF: /* 0x1ce */
11080 /* File: x86/OP_UNUSED_CEFF.S */
11081 /* File: x86/unused.S */
11085 /* ------------------------------ */
11086 .L_OP_UNUSED_CFFF: /* 0x1cf */
11087 /* File: x86/OP_UNUSED_CFFF.S */
11088 /* File: x86/unused.S */
11092 /* ------------------------------ */
11093 .L_OP_UNUSED_D0FF: /* 0x1d0 */
11094 /* File: x86/OP_UNUSED_D0FF.S */
11095 /* File: x86/unused.S */
11099 /* ------------------------------ */
11100 .L_OP_UNUSED_D1FF: /* 0x1d1 */
11101 /* File: x86/OP_UNUSED_D1FF.S */
11102 /* File: x86/unused.S */
11106 /* ------------------------------ */
11107 .L_OP_UNUSED_D2FF: /* 0x1d2 */
11108 /* File: x86/OP_UNUSED_D2FF.S */
11109 /* File: x86/unused.S */
11113 /* ------------------------------ */
11114 .L_OP_UNUSED_D3FF: /* 0x1d3 */
11115 /* File: x86/OP_UNUSED_D3FF.S */
11116 /* File: x86/unused.S */
11120 /* ------------------------------ */
11121 .L_OP_UNUSED_D4FF: /* 0x1d4 */
11122 /* File: x86/OP_UNUSED_D4FF.S */
11123 /* File: x86/unused.S */
11127 /* ------------------------------ */
11128 .L_OP_UNUSED_D5FF: /* 0x1d5 */
11129 /* File: x86/OP_UNUSED_D5FF.S */
11130 /* File: x86/unused.S */
11134 /* ------------------------------ */
11135 .L_OP_UNUSED_D6FF: /* 0x1d6 */
11136 /* File: x86/OP_UNUSED_D6FF.S */
11137 /* File: x86/unused.S */
11141 /* ------------------------------ */
11142 .L_OP_UNUSED_D7FF: /* 0x1d7 */
11143 /* File: x86/OP_UNUSED_D7FF.S */
11144 /* File: x86/unused.S */
11148 /* ------------------------------ */
11149 .L_OP_UNUSED_D8FF: /* 0x1d8 */
11150 /* File: x86/OP_UNUSED_D8FF.S */
11151 /* File: x86/unused.S */
11155 /* ------------------------------ */
11156 .L_OP_UNUSED_D9FF: /* 0x1d9 */
11157 /* File: x86/OP_UNUSED_D9FF.S */
11158 /* File: x86/unused.S */
11162 /* ------------------------------ */
11163 .L_OP_UNUSED_DAFF: /* 0x1da */
11164 /* File: x86/OP_UNUSED_DAFF.S */
11165 /* File: x86/unused.S */
11169 /* ------------------------------ */
11170 .L_OP_UNUSED_DBFF: /* 0x1db */
11171 /* File: x86/OP_UNUSED_DBFF.S */
11172 /* File: x86/unused.S */
11176 /* ------------------------------ */
11177 .L_OP_UNUSED_DCFF: /* 0x1dc */
11178 /* File: x86/OP_UNUSED_DCFF.S */
11179 /* File: x86/unused.S */
11183 /* ------------------------------ */
11184 .L_OP_UNUSED_DDFF: /* 0x1dd */
11185 /* File: x86/OP_UNUSED_DDFF.S */
11186 /* File: x86/unused.S */
11190 /* ------------------------------ */
11191 .L_OP_UNUSED_DEFF: /* 0x1de */
11192 /* File: x86/OP_UNUSED_DEFF.S */
11193 /* File: x86/unused.S */
11197 /* ------------------------------ */
11198 .L_OP_UNUSED_DFFF: /* 0x1df */
11199 /* File: x86/OP_UNUSED_DFFF.S */
11200 /* File: x86/unused.S */
11204 /* ------------------------------ */
11205 .L_OP_UNUSED_E0FF: /* 0x1e0 */
11206 /* File: x86/OP_UNUSED_E0FF.S */
11207 /* File: x86/unused.S */
11211 /* ------------------------------ */
11212 .L_OP_UNUSED_E1FF: /* 0x1e1 */
11213 /* File: x86/OP_UNUSED_E1FF.S */
11214 /* File: x86/unused.S */
11218 /* ------------------------------ */
11219 .L_OP_UNUSED_E2FF: /* 0x1e2 */
11220 /* File: x86/OP_UNUSED_E2FF.S */
11221 /* File: x86/unused.S */
11225 /* ------------------------------ */
11226 .L_OP_UNUSED_E3FF: /* 0x1e3 */
11227 /* File: x86/OP_UNUSED_E3FF.S */
11228 /* File: x86/unused.S */
11232 /* ------------------------------ */
11233 .L_OP_UNUSED_E4FF: /* 0x1e4 */
11234 /* File: x86/OP_UNUSED_E4FF.S */
11235 /* File: x86/unused.S */
11239 /* ------------------------------ */
11240 .L_OP_UNUSED_E5FF: /* 0x1e5 */
11241 /* File: x86/OP_UNUSED_E5FF.S */
11242 /* File: x86/unused.S */
11246 /* ------------------------------ */
11247 .L_OP_UNUSED_E6FF: /* 0x1e6 */
11248 /* File: x86/OP_UNUSED_E6FF.S */
11249 /* File: x86/unused.S */
11253 /* ------------------------------ */
11254 .L_OP_UNUSED_E7FF: /* 0x1e7 */
11255 /* File: x86/OP_UNUSED_E7FF.S */
11256 /* File: x86/unused.S */
11260 /* ------------------------------ */
11261 .L_OP_UNUSED_E8FF: /* 0x1e8 */
11262 /* File: x86/OP_UNUSED_E8FF.S */
11263 /* File: x86/unused.S */
11267 /* ------------------------------ */
11268 .L_OP_UNUSED_E9FF: /* 0x1e9 */
11269 /* File: x86/OP_UNUSED_E9FF.S */
11270 /* File: x86/unused.S */
11274 /* ------------------------------ */
11275 .L_OP_UNUSED_EAFF: /* 0x1ea */
11276 /* File: x86/OP_UNUSED_EAFF.S */
11277 /* File: x86/unused.S */
11281 /* ------------------------------ */
11282 .L_OP_UNUSED_EBFF: /* 0x1eb */
11283 /* File: x86/OP_UNUSED_EBFF.S */
11284 /* File: x86/unused.S */
11288 /* ------------------------------ */
11289 .L_OP_UNUSED_ECFF: /* 0x1ec */
11290 /* File: x86/OP_UNUSED_ECFF.S */
11291 /* File: x86/unused.S */
11295 /* ------------------------------ */
11296 .L_OP_UNUSED_EDFF: /* 0x1ed */
11297 /* File: x86/OP_UNUSED_EDFF.S */
11298 /* File: x86/unused.S */
11302 /* ------------------------------ */
11303 .L_OP_UNUSED_EEFF: /* 0x1ee */
11304 /* File: x86/OP_UNUSED_EEFF.S */
11305 /* File: x86/unused.S */
11309 /* ------------------------------ */
11310 .L_OP_UNUSED_EFFF: /* 0x1ef */
11311 /* File: x86/OP_UNUSED_EFFF.S */
11312 /* File: x86/unused.S */
11316 /* ------------------------------ */
11317 .L_OP_UNUSED_F0FF: /* 0x1f0 */
11318 /* File: x86/OP_UNUSED_F0FF.S */
11319 /* File: x86/unused.S */
11323 /* ------------------------------ */
11324 .L_OP_UNUSED_F1FF: /* 0x1f1 */
11325 /* File: x86/OP_UNUSED_F1FF.S */
11326 /* File: x86/unused.S */
11330 /* ------------------------------ */
11331 .L_OP_UNUSED_F2FF: /* 0x1f2 */
11332 /* File: x86/OP_UNUSED_F2FF.S */
11333 /* File: x86/unused.S */
11337 /* ------------------------------ */
11338 .L_OP_UNUSED_F3FF: /* 0x1f3 */
11339 /* File: x86/OP_UNUSED_F3FF.S */
11340 /* File: x86/unused.S */
11344 /* ------------------------------ */
11345 .L_OP_UNUSED_F4FF: /* 0x1f4 */
11346 /* File: x86/OP_UNUSED_F4FF.S */
11347 /* File: x86/unused.S */
11351 /* ------------------------------ */
11352 .L_OP_UNUSED_F5FF: /* 0x1f5 */
11353 /* File: x86/OP_UNUSED_F5FF.S */
11354 /* File: x86/unused.S */
11358 /* ------------------------------ */
11359 .L_OP_UNUSED_F6FF: /* 0x1f6 */
11360 /* File: x86/OP_UNUSED_F6FF.S */
11361 /* File: x86/unused.S */
11365 /* ------------------------------ */
11366 .L_OP_UNUSED_F7FF: /* 0x1f7 */
11367 /* File: x86/OP_UNUSED_F7FF.S */
11368 /* File: x86/unused.S */
11372 /* ------------------------------ */
11373 .L_OP_UNUSED_F8FF: /* 0x1f8 */
11374 /* File: x86/OP_UNUSED_F8FF.S */
11375 /* File: x86/unused.S */
11379 /* ------------------------------ */
11380 .L_OP_UNUSED_F9FF: /* 0x1f9 */
11381 /* File: x86/OP_UNUSED_F9FF.S */
11382 /* File: x86/unused.S */
11386 /* ------------------------------ */
11387 .L_OP_UNUSED_FAFF: /* 0x1fa */
11388 /* File: x86/OP_UNUSED_FAFF.S */
11389 /* File: x86/unused.S */
11393 /* ------------------------------ */
11394 .L_OP_UNUSED_FBFF: /* 0x1fb */
11395 /* File: x86/OP_UNUSED_FBFF.S */
11396 /* File: x86/unused.S */
11400 /* ------------------------------ */
11401 .L_OP_UNUSED_FCFF: /* 0x1fc */
11402 /* File: x86/OP_UNUSED_FCFF.S */
11403 /* File: x86/unused.S */
11407 /* ------------------------------ */
11408 .L_OP_UNUSED_FDFF: /* 0x1fd */
11409 /* File: x86/OP_UNUSED_FDFF.S */
11410 /* File: x86/unused.S */
11414 /* ------------------------------ */
11415 .L_OP_UNUSED_FEFF: /* 0x1fe */
11416 /* File: x86/OP_UNUSED_FEFF.S */
11417 /* File: x86/unused.S */
11421 /* ------------------------------ */
11422 .L_OP_THROW_VERIFICATION_ERROR_JUMBO: /* 0x1ff */
11423 /* File: x86/OP_THROW_VERIFICATION_ERROR_JUMBO.S */
11425 * Handle a jumbo throw-verification-error instruction. This throws an
11426 * exception for an error discovered during verification. The
11427 * exception is indicated by BBBB, with some detail provided by AAAAAAAA.
11429 /* exop BBBB, ref@AAAAAAAA */
11431 movl 2(rPC),%eax # eax<- AAAAAAAA
11432 movl offThread_method(%ecx),%ecx # ecx<- self->method
11434 movl %eax,OUT_ARG2(%esp) # arg2<- AAAAAAAA
11435 movl rINST,OUT_ARG1(%esp) # arg1<- BBBB
11436 movl %ecx,OUT_ARG0(%esp) # arg0<- method
11437 call dvmThrowVerificationError # call(method, kind, ref)
11438 jmp common_exceptionThrown # handle exception
11440 .size dvmAsmInstructionStartCode, .-dvmAsmInstructionStartCode
11441 .global dvmAsmInstructionEndCode
11442 dvmAsmInstructionEndCode:
11444 .global dvmAsmAltInstructionStartCode
11445 .type dvmAsmAltInstructionStartCode, %function
11446 dvmAsmAltInstructionStartCode:
11449 /* ------------------------------ */
11450 .L_ALT_OP_NOP: /* 0x00 */
11451 /* File: x86/alt_stub.S */
11453 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
11454 * any interesting requests and then jump to the real instruction
11455 * handler. Unlike the Arm handler, we can't do this as a tail call
11456 * because rIBASE is caller save and we need to reload it.
11459 movl rPC, OUT_ARG0(%esp)
11460 movl %eax, OUT_ARG1(%esp)
11461 call dvmCheckInst # (dPC, self)
11463 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
11464 jmp *dvmAsmInstructionStart+(0*4)
11466 /* ------------------------------ */
11467 .L_ALT_OP_MOVE: /* 0x01 */
11468 /* File: x86/alt_stub.S */
11470 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
11471 * any interesting requests and then jump to the real instruction
11472 * handler. Unlike the Arm handler, we can't do this as a tail call
11473 * because rIBASE is caller save and we need to reload it.
11476 movl rPC, OUT_ARG0(%esp)
11477 movl %eax, OUT_ARG1(%esp)
11478 call dvmCheckInst # (dPC, self)
11480 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
11481 jmp *dvmAsmInstructionStart+(1*4)
11483 /* ------------------------------ */
11484 .L_ALT_OP_MOVE_FROM16: /* 0x02 */
11485 /* File: x86/alt_stub.S */
11487 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
11488 * any interesting requests and then jump to the real instruction
11489 * handler. Unlike the Arm handler, we can't do this as a tail call
11490 * because rIBASE is caller save and we need to reload it.
11493 movl rPC, OUT_ARG0(%esp)
11494 movl %eax, OUT_ARG1(%esp)
11495 call dvmCheckInst # (dPC, self)
11497 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
11498 jmp *dvmAsmInstructionStart+(2*4)
11500 /* ------------------------------ */
11501 .L_ALT_OP_MOVE_16: /* 0x03 */
11502 /* File: x86/alt_stub.S */
11504 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
11505 * any interesting requests and then jump to the real instruction
11506 * handler. Unlike the Arm handler, we can't do this as a tail call
11507 * because rIBASE is caller save and we need to reload it.
11510 movl rPC, OUT_ARG0(%esp)
11511 movl %eax, OUT_ARG1(%esp)
11512 call dvmCheckInst # (dPC, self)
11514 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
11515 jmp *dvmAsmInstructionStart+(3*4)
11517 /* ------------------------------ */
11518 .L_ALT_OP_MOVE_WIDE: /* 0x04 */
11519 /* File: x86/alt_stub.S */
11521 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
11522 * any interesting requests and then jump to the real instruction
11523 * handler. Unlike the Arm handler, we can't do this as a tail call
11524 * because rIBASE is caller save and we need to reload it.
11527 movl rPC, OUT_ARG0(%esp)
11528 movl %eax, OUT_ARG1(%esp)
11529 call dvmCheckInst # (dPC, self)
11531 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
11532 jmp *dvmAsmInstructionStart+(4*4)
11534 /* ------------------------------ */
11535 .L_ALT_OP_MOVE_WIDE_FROM16: /* 0x05 */
11536 /* File: x86/alt_stub.S */
11538 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
11539 * any interesting requests and then jump to the real instruction
11540 * handler. Unlike the Arm handler, we can't do this as a tail call
11541 * because rIBASE is caller save and we need to reload it.
11544 movl rPC, OUT_ARG0(%esp)
11545 movl %eax, OUT_ARG1(%esp)
11546 call dvmCheckInst # (dPC, self)
11548 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
11549 jmp *dvmAsmInstructionStart+(5*4)
11551 /* ------------------------------ */
11552 .L_ALT_OP_MOVE_WIDE_16: /* 0x06 */
11553 /* File: x86/alt_stub.S */
11555 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
11556 * any interesting requests and then jump to the real instruction
11557 * handler. Unlike the Arm handler, we can't do this as a tail call
11558 * because rIBASE is caller save and we need to reload it.
11561 movl rPC, OUT_ARG0(%esp)
11562 movl %eax, OUT_ARG1(%esp)
11563 call dvmCheckInst # (dPC, self)
11565 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
11566 jmp *dvmAsmInstructionStart+(6*4)
11568 /* ------------------------------ */
11569 .L_ALT_OP_MOVE_OBJECT: /* 0x07 */
11570 /* File: x86/alt_stub.S */
11572 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
11573 * any interesting requests and then jump to the real instruction
11574 * handler. Unlike the Arm handler, we can't do this as a tail call
11575 * because rIBASE is caller save and we need to reload it.
11578 movl rPC, OUT_ARG0(%esp)
11579 movl %eax, OUT_ARG1(%esp)
11580 call dvmCheckInst # (dPC, self)
11582 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
11583 jmp *dvmAsmInstructionStart+(7*4)
11585 /* ------------------------------ */
11586 .L_ALT_OP_MOVE_OBJECT_FROM16: /* 0x08 */
11587 /* File: x86/alt_stub.S */
11589 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
11590 * any interesting requests and then jump to the real instruction
11591 * handler. Unlike the Arm handler, we can't do this as a tail call
11592 * because rIBASE is caller save and we need to reload it.
11595 movl rPC, OUT_ARG0(%esp)
11596 movl %eax, OUT_ARG1(%esp)
11597 call dvmCheckInst # (dPC, self)
11599 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
11600 jmp *dvmAsmInstructionStart+(8*4)
11602 /* ------------------------------ */
11603 .L_ALT_OP_MOVE_OBJECT_16: /* 0x09 */
11604 /* File: x86/alt_stub.S */
11606 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
11607 * any interesting requests and then jump to the real instruction
11608 * handler. Unlike the Arm handler, we can't do this as a tail call
11609 * because rIBASE is caller save and we need to reload it.
11612 movl rPC, OUT_ARG0(%esp)
11613 movl %eax, OUT_ARG1(%esp)
11614 call dvmCheckInst # (dPC, self)
11616 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
11617 jmp *dvmAsmInstructionStart+(9*4)
11619 /* ------------------------------ */
11620 .L_ALT_OP_MOVE_RESULT: /* 0x0a */
11621 /* File: x86/alt_stub.S */
11623 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
11624 * any interesting requests and then jump to the real instruction
11625 * handler. Unlike the Arm handler, we can't do this as a tail call
11626 * because rIBASE is caller save and we need to reload it.
11629 movl rPC, OUT_ARG0(%esp)
11630 movl %eax, OUT_ARG1(%esp)
11631 call dvmCheckInst # (dPC, self)
11633 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
11634 jmp *dvmAsmInstructionStart+(10*4)
11636 /* ------------------------------ */
11637 .L_ALT_OP_MOVE_RESULT_WIDE: /* 0x0b */
11638 /* File: x86/alt_stub.S */
11640 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
11641 * any interesting requests and then jump to the real instruction
11642 * handler. Unlike the Arm handler, we can't do this as a tail call
11643 * because rIBASE is caller save and we need to reload it.
11646 movl rPC, OUT_ARG0(%esp)
11647 movl %eax, OUT_ARG1(%esp)
11648 call dvmCheckInst # (dPC, self)
11650 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
11651 jmp *dvmAsmInstructionStart+(11*4)
11653 /* ------------------------------ */
11654 .L_ALT_OP_MOVE_RESULT_OBJECT: /* 0x0c */
11655 /* File: x86/alt_stub.S */
11657 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
11658 * any interesting requests and then jump to the real instruction
11659 * handler. Unlike the Arm handler, we can't do this as a tail call
11660 * because rIBASE is caller save and we need to reload it.
11663 movl rPC, OUT_ARG0(%esp)
11664 movl %eax, OUT_ARG1(%esp)
11665 call dvmCheckInst # (dPC, self)
11667 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
11668 jmp *dvmAsmInstructionStart+(12*4)
11670 /* ------------------------------ */
11671 .L_ALT_OP_MOVE_EXCEPTION: /* 0x0d */
11672 /* File: x86/alt_stub.S */
11674 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
11675 * any interesting requests and then jump to the real instruction
11676 * handler. Unlike the Arm handler, we can't do this as a tail call
11677 * because rIBASE is caller save and we need to reload it.
11680 movl rPC, OUT_ARG0(%esp)
11681 movl %eax, OUT_ARG1(%esp)
11682 call dvmCheckInst # (dPC, self)
11684 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
11685 jmp *dvmAsmInstructionStart+(13*4)
11687 /* ------------------------------ */
11688 .L_ALT_OP_RETURN_VOID: /* 0x0e */
11689 /* File: x86/alt_stub.S */
11691 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
11692 * any interesting requests and then jump to the real instruction
11693 * handler. Unlike the Arm handler, we can't do this as a tail call
11694 * because rIBASE is caller save and we need to reload it.
11697 movl rPC, OUT_ARG0(%esp)
11698 movl %eax, OUT_ARG1(%esp)
11699 call dvmCheckInst # (dPC, self)
11701 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
11702 jmp *dvmAsmInstructionStart+(14*4)
11704 /* ------------------------------ */
11705 .L_ALT_OP_RETURN: /* 0x0f */
11706 /* File: x86/alt_stub.S */
11708 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
11709 * any interesting requests and then jump to the real instruction
11710 * handler. Unlike the Arm handler, we can't do this as a tail call
11711 * because rIBASE is caller save and we need to reload it.
11714 movl rPC, OUT_ARG0(%esp)
11715 movl %eax, OUT_ARG1(%esp)
11716 call dvmCheckInst # (dPC, self)
11718 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
11719 jmp *dvmAsmInstructionStart+(15*4)
11721 /* ------------------------------ */
11722 .L_ALT_OP_RETURN_WIDE: /* 0x10 */
11723 /* File: x86/alt_stub.S */
11725 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
11726 * any interesting requests and then jump to the real instruction
11727 * handler. Unlike the Arm handler, we can't do this as a tail call
11728 * because rIBASE is caller save and we need to reload it.
11731 movl rPC, OUT_ARG0(%esp)
11732 movl %eax, OUT_ARG1(%esp)
11733 call dvmCheckInst # (dPC, self)
11735 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
11736 jmp *dvmAsmInstructionStart+(16*4)
11738 /* ------------------------------ */
11739 .L_ALT_OP_RETURN_OBJECT: /* 0x11 */
11740 /* File: x86/alt_stub.S */
11742 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
11743 * any interesting requests and then jump to the real instruction
11744 * handler. Unlike the Arm handler, we can't do this as a tail call
11745 * because rIBASE is caller save and we need to reload it.
11748 movl rPC, OUT_ARG0(%esp)
11749 movl %eax, OUT_ARG1(%esp)
11750 call dvmCheckInst # (dPC, self)
11752 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
11753 jmp *dvmAsmInstructionStart+(17*4)
11755 /* ------------------------------ */
11756 .L_ALT_OP_CONST_4: /* 0x12 */
11757 /* File: x86/alt_stub.S */
11759 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
11760 * any interesting requests and then jump to the real instruction
11761 * handler. Unlike the Arm handler, we can't do this as a tail call
11762 * because rIBASE is caller save and we need to reload it.
11765 movl rPC, OUT_ARG0(%esp)
11766 movl %eax, OUT_ARG1(%esp)
11767 call dvmCheckInst # (dPC, self)
11769 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
11770 jmp *dvmAsmInstructionStart+(18*4)
11772 /* ------------------------------ */
11773 .L_ALT_OP_CONST_16: /* 0x13 */
11774 /* File: x86/alt_stub.S */
11776 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
11777 * any interesting requests and then jump to the real instruction
11778 * handler. Unlike the Arm handler, we can't do this as a tail call
11779 * because rIBASE is caller save and we need to reload it.
11782 movl rPC, OUT_ARG0(%esp)
11783 movl %eax, OUT_ARG1(%esp)
11784 call dvmCheckInst # (dPC, self)
11786 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
11787 jmp *dvmAsmInstructionStart+(19*4)
11789 /* ------------------------------ */
11790 .L_ALT_OP_CONST: /* 0x14 */
11791 /* File: x86/alt_stub.S */
11793 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
11794 * any interesting requests and then jump to the real instruction
11795 * handler. Unlike the Arm handler, we can't do this as a tail call
11796 * because rIBASE is caller save and we need to reload it.
11799 movl rPC, OUT_ARG0(%esp)
11800 movl %eax, OUT_ARG1(%esp)
11801 call dvmCheckInst # (dPC, self)
11803 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
11804 jmp *dvmAsmInstructionStart+(20*4)
11806 /* ------------------------------ */
11807 .L_ALT_OP_CONST_HIGH16: /* 0x15 */
11808 /* File: x86/alt_stub.S */
11810 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
11811 * any interesting requests and then jump to the real instruction
11812 * handler. Unlike the Arm handler, we can't do this as a tail call
11813 * because rIBASE is caller save and we need to reload it.
11816 movl rPC, OUT_ARG0(%esp)
11817 movl %eax, OUT_ARG1(%esp)
11818 call dvmCheckInst # (dPC, self)
11820 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
11821 jmp *dvmAsmInstructionStart+(21*4)
11823 /* ------------------------------ */
11824 .L_ALT_OP_CONST_WIDE_16: /* 0x16 */
11825 /* File: x86/alt_stub.S */
11827 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
11828 * any interesting requests and then jump to the real instruction
11829 * handler. Unlike the Arm handler, we can't do this as a tail call
11830 * because rIBASE is caller save and we need to reload it.
11833 movl rPC, OUT_ARG0(%esp)
11834 movl %eax, OUT_ARG1(%esp)
11835 call dvmCheckInst # (dPC, self)
11837 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
11838 jmp *dvmAsmInstructionStart+(22*4)
11840 /* ------------------------------ */
11841 .L_ALT_OP_CONST_WIDE_32: /* 0x17 */
11842 /* File: x86/alt_stub.S */
11844 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
11845 * any interesting requests and then jump to the real instruction
11846 * handler. Unlike the Arm handler, we can't do this as a tail call
11847 * because rIBASE is caller save and we need to reload it.
11850 movl rPC, OUT_ARG0(%esp)
11851 movl %eax, OUT_ARG1(%esp)
11852 call dvmCheckInst # (dPC, self)
11854 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
11855 jmp *dvmAsmInstructionStart+(23*4)
11857 /* ------------------------------ */
11858 .L_ALT_OP_CONST_WIDE: /* 0x18 */
11859 /* File: x86/alt_stub.S */
11861 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
11862 * any interesting requests and then jump to the real instruction
11863 * handler. Unlike the Arm handler, we can't do this as a tail call
11864 * because rIBASE is caller save and we need to reload it.
11867 movl rPC, OUT_ARG0(%esp)
11868 movl %eax, OUT_ARG1(%esp)
11869 call dvmCheckInst # (dPC, self)
11871 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
11872 jmp *dvmAsmInstructionStart+(24*4)
11874 /* ------------------------------ */
11875 .L_ALT_OP_CONST_WIDE_HIGH16: /* 0x19 */
11876 /* File: x86/alt_stub.S */
11878 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
11879 * any interesting requests and then jump to the real instruction
11880 * handler. Unlike the Arm handler, we can't do this as a tail call
11881 * because rIBASE is caller save and we need to reload it.
11884 movl rPC, OUT_ARG0(%esp)
11885 movl %eax, OUT_ARG1(%esp)
11886 call dvmCheckInst # (dPC, self)
11888 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
11889 jmp *dvmAsmInstructionStart+(25*4)
11891 /* ------------------------------ */
11892 .L_ALT_OP_CONST_STRING: /* 0x1a */
11893 /* File: x86/alt_stub.S */
11895 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
11896 * any interesting requests and then jump to the real instruction
11897 * handler. Unlike the Arm handler, we can't do this as a tail call
11898 * because rIBASE is caller save and we need to reload it.
11901 movl rPC, OUT_ARG0(%esp)
11902 movl %eax, OUT_ARG1(%esp)
11903 call dvmCheckInst # (dPC, self)
11905 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
11906 jmp *dvmAsmInstructionStart+(26*4)
11908 /* ------------------------------ */
11909 .L_ALT_OP_CONST_STRING_JUMBO: /* 0x1b */
11910 /* File: x86/alt_stub.S */
11912 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
11913 * any interesting requests and then jump to the real instruction
11914 * handler. Unlike the Arm handler, we can't do this as a tail call
11915 * because rIBASE is caller save and we need to reload it.
11918 movl rPC, OUT_ARG0(%esp)
11919 movl %eax, OUT_ARG1(%esp)
11920 call dvmCheckInst # (dPC, self)
11922 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
11923 jmp *dvmAsmInstructionStart+(27*4)
11925 /* ------------------------------ */
11926 .L_ALT_OP_CONST_CLASS: /* 0x1c */
11927 /* File: x86/alt_stub.S */
11929 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
11930 * any interesting requests and then jump to the real instruction
11931 * handler. Unlike the Arm handler, we can't do this as a tail call
11932 * because rIBASE is caller save and we need to reload it.
11935 movl rPC, OUT_ARG0(%esp)
11936 movl %eax, OUT_ARG1(%esp)
11937 call dvmCheckInst # (dPC, self)
11939 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
11940 jmp *dvmAsmInstructionStart+(28*4)
11942 /* ------------------------------ */
11943 .L_ALT_OP_MONITOR_ENTER: /* 0x1d */
11944 /* File: x86/alt_stub.S */
11946 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
11947 * any interesting requests and then jump to the real instruction
11948 * handler. Unlike the Arm handler, we can't do this as a tail call
11949 * because rIBASE is caller save and we need to reload it.
11952 movl rPC, OUT_ARG0(%esp)
11953 movl %eax, OUT_ARG1(%esp)
11954 call dvmCheckInst # (dPC, self)
11956 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
11957 jmp *dvmAsmInstructionStart+(29*4)
11959 /* ------------------------------ */
11960 .L_ALT_OP_MONITOR_EXIT: /* 0x1e */
11961 /* File: x86/alt_stub.S */
11963 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
11964 * any interesting requests and then jump to the real instruction
11965 * handler. Unlike the Arm handler, we can't do this as a tail call
11966 * because rIBASE is caller save and we need to reload it.
11969 movl rPC, OUT_ARG0(%esp)
11970 movl %eax, OUT_ARG1(%esp)
11971 call dvmCheckInst # (dPC, self)
11973 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
11974 jmp *dvmAsmInstructionStart+(30*4)
11976 /* ------------------------------ */
11977 .L_ALT_OP_CHECK_CAST: /* 0x1f */
11978 /* File: x86/alt_stub.S */
11980 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
11981 * any interesting requests and then jump to the real instruction
11982 * handler. Unlike the Arm handler, we can't do this as a tail call
11983 * because rIBASE is caller save and we need to reload it.
11986 movl rPC, OUT_ARG0(%esp)
11987 movl %eax, OUT_ARG1(%esp)
11988 call dvmCheckInst # (dPC, self)
11990 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
11991 jmp *dvmAsmInstructionStart+(31*4)
11993 /* ------------------------------ */
11994 .L_ALT_OP_INSTANCE_OF: /* 0x20 */
11995 /* File: x86/alt_stub.S */
11997 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
11998 * any interesting requests and then jump to the real instruction
11999 * handler. Unlike the Arm handler, we can't do this as a tail call
12000 * because rIBASE is caller save and we need to reload it.
12003 movl rPC, OUT_ARG0(%esp)
12004 movl %eax, OUT_ARG1(%esp)
12005 call dvmCheckInst # (dPC, self)
12007 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
12008 jmp *dvmAsmInstructionStart+(32*4)
12010 /* ------------------------------ */
12011 .L_ALT_OP_ARRAY_LENGTH: /* 0x21 */
12012 /* File: x86/alt_stub.S */
12014 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
12015 * any interesting requests and then jump to the real instruction
12016 * handler. Unlike the Arm handler, we can't do this as a tail call
12017 * because rIBASE is caller save and we need to reload it.
12020 movl rPC, OUT_ARG0(%esp)
12021 movl %eax, OUT_ARG1(%esp)
12022 call dvmCheckInst # (dPC, self)
12024 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
12025 jmp *dvmAsmInstructionStart+(33*4)
12027 /* ------------------------------ */
12028 .L_ALT_OP_NEW_INSTANCE: /* 0x22 */
12029 /* File: x86/alt_stub.S */
12031 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
12032 * any interesting requests and then jump to the real instruction
12033 * handler. Unlike the Arm handler, we can't do this as a tail call
12034 * because rIBASE is caller save and we need to reload it.
12037 movl rPC, OUT_ARG0(%esp)
12038 movl %eax, OUT_ARG1(%esp)
12039 call dvmCheckInst # (dPC, self)
12041 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
12042 jmp *dvmAsmInstructionStart+(34*4)
12044 /* ------------------------------ */
12045 .L_ALT_OP_NEW_ARRAY: /* 0x23 */
12046 /* File: x86/alt_stub.S */
12048 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
12049 * any interesting requests and then jump to the real instruction
12050 * handler. Unlike the Arm handler, we can't do this as a tail call
12051 * because rIBASE is caller save and we need to reload it.
12054 movl rPC, OUT_ARG0(%esp)
12055 movl %eax, OUT_ARG1(%esp)
12056 call dvmCheckInst # (dPC, self)
12058 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
12059 jmp *dvmAsmInstructionStart+(35*4)
12061 /* ------------------------------ */
12062 .L_ALT_OP_FILLED_NEW_ARRAY: /* 0x24 */
12063 /* File: x86/alt_stub.S */
12065 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
12066 * any interesting requests and then jump to the real instruction
12067 * handler. Unlike the Arm handler, we can't do this as a tail call
12068 * because rIBASE is caller save and we need to reload it.
12071 movl rPC, OUT_ARG0(%esp)
12072 movl %eax, OUT_ARG1(%esp)
12073 call dvmCheckInst # (dPC, self)
12075 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
12076 jmp *dvmAsmInstructionStart+(36*4)
12078 /* ------------------------------ */
12079 .L_ALT_OP_FILLED_NEW_ARRAY_RANGE: /* 0x25 */
12080 /* File: x86/alt_stub.S */
12082 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
12083 * any interesting requests and then jump to the real instruction
12084 * handler. Unlike the Arm handler, we can't do this as a tail call
12085 * because rIBASE is caller save and we need to reload it.
12088 movl rPC, OUT_ARG0(%esp)
12089 movl %eax, OUT_ARG1(%esp)
12090 call dvmCheckInst # (dPC, self)
12092 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
12093 jmp *dvmAsmInstructionStart+(37*4)
12095 /* ------------------------------ */
12096 .L_ALT_OP_FILL_ARRAY_DATA: /* 0x26 */
12097 /* File: x86/alt_stub.S */
12099 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
12100 * any interesting requests and then jump to the real instruction
12101 * handler. Unlike the Arm handler, we can't do this as a tail call
12102 * because rIBASE is caller save and we need to reload it.
12105 movl rPC, OUT_ARG0(%esp)
12106 movl %eax, OUT_ARG1(%esp)
12107 call dvmCheckInst # (dPC, self)
12109 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
12110 jmp *dvmAsmInstructionStart+(38*4)
12112 /* ------------------------------ */
12113 .L_ALT_OP_THROW: /* 0x27 */
12114 /* File: x86/alt_stub.S */
12116 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
12117 * any interesting requests and then jump to the real instruction
12118 * handler. Unlike the Arm handler, we can't do this as a tail call
12119 * because rIBASE is caller save and we need to reload it.
12122 movl rPC, OUT_ARG0(%esp)
12123 movl %eax, OUT_ARG1(%esp)
12124 call dvmCheckInst # (dPC, self)
12126 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
12127 jmp *dvmAsmInstructionStart+(39*4)
12129 /* ------------------------------ */
12130 .L_ALT_OP_GOTO: /* 0x28 */
12131 /* File: x86/alt_stub.S */
12133 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
12134 * any interesting requests and then jump to the real instruction
12135 * handler. Unlike the Arm handler, we can't do this as a tail call
12136 * because rIBASE is caller save and we need to reload it.
12139 movl rPC, OUT_ARG0(%esp)
12140 movl %eax, OUT_ARG1(%esp)
12141 call dvmCheckInst # (dPC, self)
12143 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
12144 jmp *dvmAsmInstructionStart+(40*4)
12146 /* ------------------------------ */
12147 .L_ALT_OP_GOTO_16: /* 0x29 */
12148 /* File: x86/alt_stub.S */
12150 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
12151 * any interesting requests and then jump to the real instruction
12152 * handler. Unlike the Arm handler, we can't do this as a tail call
12153 * because rIBASE is caller save and we need to reload it.
12156 movl rPC, OUT_ARG0(%esp)
12157 movl %eax, OUT_ARG1(%esp)
12158 call dvmCheckInst # (dPC, self)
12160 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
12161 jmp *dvmAsmInstructionStart+(41*4)
12163 /* ------------------------------ */
12164 .L_ALT_OP_GOTO_32: /* 0x2a */
12165 /* File: x86/alt_stub.S */
12167 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
12168 * any interesting requests and then jump to the real instruction
12169 * handler. Unlike the Arm handler, we can't do this as a tail call
12170 * because rIBASE is caller save and we need to reload it.
12173 movl rPC, OUT_ARG0(%esp)
12174 movl %eax, OUT_ARG1(%esp)
12175 call dvmCheckInst # (dPC, self)
12177 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
12178 jmp *dvmAsmInstructionStart+(42*4)
12180 /* ------------------------------ */
12181 .L_ALT_OP_PACKED_SWITCH: /* 0x2b */
12182 /* File: x86/alt_stub.S */
12184 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
12185 * any interesting requests and then jump to the real instruction
12186 * handler. Unlike the Arm handler, we can't do this as a tail call
12187 * because rIBASE is caller save and we need to reload it.
12190 movl rPC, OUT_ARG0(%esp)
12191 movl %eax, OUT_ARG1(%esp)
12192 call dvmCheckInst # (dPC, self)
12194 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
12195 jmp *dvmAsmInstructionStart+(43*4)
12197 /* ------------------------------ */
12198 .L_ALT_OP_SPARSE_SWITCH: /* 0x2c */
12199 /* File: x86/alt_stub.S */
12201 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
12202 * any interesting requests and then jump to the real instruction
12203 * handler. Unlike the Arm handler, we can't do this as a tail call
12204 * because rIBASE is caller save and we need to reload it.
12207 movl rPC, OUT_ARG0(%esp)
12208 movl %eax, OUT_ARG1(%esp)
12209 call dvmCheckInst # (dPC, self)
12211 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
12212 jmp *dvmAsmInstructionStart+(44*4)
12214 /* ------------------------------ */
12215 .L_ALT_OP_CMPL_FLOAT: /* 0x2d */
12216 /* File: x86/alt_stub.S */
12218 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
12219 * any interesting requests and then jump to the real instruction
12220 * handler. Unlike the Arm handler, we can't do this as a tail call
12221 * because rIBASE is caller save and we need to reload it.
12224 movl rPC, OUT_ARG0(%esp)
12225 movl %eax, OUT_ARG1(%esp)
12226 call dvmCheckInst # (dPC, self)
12228 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
12229 jmp *dvmAsmInstructionStart+(45*4)
12231 /* ------------------------------ */
12232 .L_ALT_OP_CMPG_FLOAT: /* 0x2e */
12233 /* File: x86/alt_stub.S */
12235 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
12236 * any interesting requests and then jump to the real instruction
12237 * handler. Unlike the Arm handler, we can't do this as a tail call
12238 * because rIBASE is caller save and we need to reload it.
12241 movl rPC, OUT_ARG0(%esp)
12242 movl %eax, OUT_ARG1(%esp)
12243 call dvmCheckInst # (dPC, self)
12245 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
12246 jmp *dvmAsmInstructionStart+(46*4)
12248 /* ------------------------------ */
12249 .L_ALT_OP_CMPL_DOUBLE: /* 0x2f */
12250 /* File: x86/alt_stub.S */
12252 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
12253 * any interesting requests and then jump to the real instruction
12254 * handler. Unlike the Arm handler, we can't do this as a tail call
12255 * because rIBASE is caller save and we need to reload it.
12258 movl rPC, OUT_ARG0(%esp)
12259 movl %eax, OUT_ARG1(%esp)
12260 call dvmCheckInst # (dPC, self)
12262 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
12263 jmp *dvmAsmInstructionStart+(47*4)
12265 /* ------------------------------ */
12266 .L_ALT_OP_CMPG_DOUBLE: /* 0x30 */
12267 /* File: x86/alt_stub.S */
12269 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
12270 * any interesting requests and then jump to the real instruction
12271 * handler. Unlike the Arm handler, we can't do this as a tail call
12272 * because rIBASE is caller save and we need to reload it.
12275 movl rPC, OUT_ARG0(%esp)
12276 movl %eax, OUT_ARG1(%esp)
12277 call dvmCheckInst # (dPC, self)
12279 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
12280 jmp *dvmAsmInstructionStart+(48*4)
12282 /* ------------------------------ */
12283 .L_ALT_OP_CMP_LONG: /* 0x31 */
12284 /* File: x86/alt_stub.S */
12286 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
12287 * any interesting requests and then jump to the real instruction
12288 * handler. Unlike the Arm handler, we can't do this as a tail call
12289 * because rIBASE is caller save and we need to reload it.
12292 movl rPC, OUT_ARG0(%esp)
12293 movl %eax, OUT_ARG1(%esp)
12294 call dvmCheckInst # (dPC, self)
12296 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
12297 jmp *dvmAsmInstructionStart+(49*4)
12299 /* ------------------------------ */
12300 .L_ALT_OP_IF_EQ: /* 0x32 */
12301 /* File: x86/alt_stub.S */
12303 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
12304 * any interesting requests and then jump to the real instruction
12305 * handler. Unlike the Arm handler, we can't do this as a tail call
12306 * because rIBASE is caller save and we need to reload it.
12309 movl rPC, OUT_ARG0(%esp)
12310 movl %eax, OUT_ARG1(%esp)
12311 call dvmCheckInst # (dPC, self)
12313 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
12314 jmp *dvmAsmInstructionStart+(50*4)
12316 /* ------------------------------ */
12317 .L_ALT_OP_IF_NE: /* 0x33 */
12318 /* File: x86/alt_stub.S */
12320 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
12321 * any interesting requests and then jump to the real instruction
12322 * handler. Unlike the Arm handler, we can't do this as a tail call
12323 * because rIBASE is caller save and we need to reload it.
12326 movl rPC, OUT_ARG0(%esp)
12327 movl %eax, OUT_ARG1(%esp)
12328 call dvmCheckInst # (dPC, self)
12330 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
12331 jmp *dvmAsmInstructionStart+(51*4)
12333 /* ------------------------------ */
12334 .L_ALT_OP_IF_LT: /* 0x34 */
12335 /* File: x86/alt_stub.S */
12337 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
12338 * any interesting requests and then jump to the real instruction
12339 * handler. Unlike the Arm handler, we can't do this as a tail call
12340 * because rIBASE is caller save and we need to reload it.
12343 movl rPC, OUT_ARG0(%esp)
12344 movl %eax, OUT_ARG1(%esp)
12345 call dvmCheckInst # (dPC, self)
12347 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
12348 jmp *dvmAsmInstructionStart+(52*4)
12350 /* ------------------------------ */
12351 .L_ALT_OP_IF_GE: /* 0x35 */
12352 /* File: x86/alt_stub.S */
12354 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
12355 * any interesting requests and then jump to the real instruction
12356 * handler. Unlike the Arm handler, we can't do this as a tail call
12357 * because rIBASE is caller save and we need to reload it.
12360 movl rPC, OUT_ARG0(%esp)
12361 movl %eax, OUT_ARG1(%esp)
12362 call dvmCheckInst # (dPC, self)
12364 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
12365 jmp *dvmAsmInstructionStart+(53*4)
12367 /* ------------------------------ */
12368 .L_ALT_OP_IF_GT: /* 0x36 */
12369 /* File: x86/alt_stub.S */
12371 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
12372 * any interesting requests and then jump to the real instruction
12373 * handler. Unlike the Arm handler, we can't do this as a tail call
12374 * because rIBASE is caller save and we need to reload it.
12377 movl rPC, OUT_ARG0(%esp)
12378 movl %eax, OUT_ARG1(%esp)
12379 call dvmCheckInst # (dPC, self)
12381 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
12382 jmp *dvmAsmInstructionStart+(54*4)
12384 /* ------------------------------ */
12385 .L_ALT_OP_IF_LE: /* 0x37 */
12386 /* File: x86/alt_stub.S */
12388 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
12389 * any interesting requests and then jump to the real instruction
12390 * handler. Unlike the Arm handler, we can't do this as a tail call
12391 * because rIBASE is caller save and we need to reload it.
12394 movl rPC, OUT_ARG0(%esp)
12395 movl %eax, OUT_ARG1(%esp)
12396 call dvmCheckInst # (dPC, self)
12398 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
12399 jmp *dvmAsmInstructionStart+(55*4)
12401 /* ------------------------------ */
12402 .L_ALT_OP_IF_EQZ: /* 0x38 */
12403 /* File: x86/alt_stub.S */
12405 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
12406 * any interesting requests and then jump to the real instruction
12407 * handler. Unlike the Arm handler, we can't do this as a tail call
12408 * because rIBASE is caller save and we need to reload it.
12411 movl rPC, OUT_ARG0(%esp)
12412 movl %eax, OUT_ARG1(%esp)
12413 call dvmCheckInst # (dPC, self)
12415 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
12416 jmp *dvmAsmInstructionStart+(56*4)
12418 /* ------------------------------ */
12419 .L_ALT_OP_IF_NEZ: /* 0x39 */
12420 /* File: x86/alt_stub.S */
12422 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
12423 * any interesting requests and then jump to the real instruction
12424 * handler. Unlike the Arm handler, we can't do this as a tail call
12425 * because rIBASE is caller save and we need to reload it.
12428 movl rPC, OUT_ARG0(%esp)
12429 movl %eax, OUT_ARG1(%esp)
12430 call dvmCheckInst # (dPC, self)
12432 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
12433 jmp *dvmAsmInstructionStart+(57*4)
12435 /* ------------------------------ */
12436 .L_ALT_OP_IF_LTZ: /* 0x3a */
12437 /* File: x86/alt_stub.S */
12439 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
12440 * any interesting requests and then jump to the real instruction
12441 * handler. Unlike the Arm handler, we can't do this as a tail call
12442 * because rIBASE is caller save and we need to reload it.
12445 movl rPC, OUT_ARG0(%esp)
12446 movl %eax, OUT_ARG1(%esp)
12447 call dvmCheckInst # (dPC, self)
12449 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
12450 jmp *dvmAsmInstructionStart+(58*4)
12452 /* ------------------------------ */
12453 .L_ALT_OP_IF_GEZ: /* 0x3b */
12454 /* File: x86/alt_stub.S */
12456 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
12457 * any interesting requests and then jump to the real instruction
12458 * handler. Unlike the Arm handler, we can't do this as a tail call
12459 * because rIBASE is caller save and we need to reload it.
12462 movl rPC, OUT_ARG0(%esp)
12463 movl %eax, OUT_ARG1(%esp)
12464 call dvmCheckInst # (dPC, self)
12466 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
12467 jmp *dvmAsmInstructionStart+(59*4)
12469 /* ------------------------------ */
12470 .L_ALT_OP_IF_GTZ: /* 0x3c */
12471 /* File: x86/alt_stub.S */
12473 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
12474 * any interesting requests and then jump to the real instruction
12475 * handler. Unlike the Arm handler, we can't do this as a tail call
12476 * because rIBASE is caller save and we need to reload it.
12479 movl rPC, OUT_ARG0(%esp)
12480 movl %eax, OUT_ARG1(%esp)
12481 call dvmCheckInst # (dPC, self)
12483 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
12484 jmp *dvmAsmInstructionStart+(60*4)
12486 /* ------------------------------ */
12487 .L_ALT_OP_IF_LEZ: /* 0x3d */
12488 /* File: x86/alt_stub.S */
12490 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
12491 * any interesting requests and then jump to the real instruction
12492 * handler. Unlike the Arm handler, we can't do this as a tail call
12493 * because rIBASE is caller save and we need to reload it.
12496 movl rPC, OUT_ARG0(%esp)
12497 movl %eax, OUT_ARG1(%esp)
12498 call dvmCheckInst # (dPC, self)
12500 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
12501 jmp *dvmAsmInstructionStart+(61*4)
12503 /* ------------------------------ */
12504 .L_ALT_OP_UNUSED_3E: /* 0x3e */
12505 /* File: x86/alt_stub.S */
12507 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
12508 * any interesting requests and then jump to the real instruction
12509 * handler. Unlike the Arm handler, we can't do this as a tail call
12510 * because rIBASE is caller save and we need to reload it.
12513 movl rPC, OUT_ARG0(%esp)
12514 movl %eax, OUT_ARG1(%esp)
12515 call dvmCheckInst # (dPC, self)
12517 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
12518 jmp *dvmAsmInstructionStart+(62*4)
12520 /* ------------------------------ */
12521 .L_ALT_OP_UNUSED_3F: /* 0x3f */
12522 /* File: x86/alt_stub.S */
12524 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
12525 * any interesting requests and then jump to the real instruction
12526 * handler. Unlike the Arm handler, we can't do this as a tail call
12527 * because rIBASE is caller save and we need to reload it.
12530 movl rPC, OUT_ARG0(%esp)
12531 movl %eax, OUT_ARG1(%esp)
12532 call dvmCheckInst # (dPC, self)
12534 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
12535 jmp *dvmAsmInstructionStart+(63*4)
12537 /* ------------------------------ */
12538 .L_ALT_OP_UNUSED_40: /* 0x40 */
12539 /* File: x86/alt_stub.S */
12541 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
12542 * any interesting requests and then jump to the real instruction
12543 * handler. Unlike the Arm handler, we can't do this as a tail call
12544 * because rIBASE is caller save and we need to reload it.
12547 movl rPC, OUT_ARG0(%esp)
12548 movl %eax, OUT_ARG1(%esp)
12549 call dvmCheckInst # (dPC, self)
12551 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
12552 jmp *dvmAsmInstructionStart+(64*4)
12554 /* ------------------------------ */
12555 .L_ALT_OP_UNUSED_41: /* 0x41 */
12556 /* File: x86/alt_stub.S */
12558 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
12559 * any interesting requests and then jump to the real instruction
12560 * handler. Unlike the Arm handler, we can't do this as a tail call
12561 * because rIBASE is caller save and we need to reload it.
12564 movl rPC, OUT_ARG0(%esp)
12565 movl %eax, OUT_ARG1(%esp)
12566 call dvmCheckInst # (dPC, self)
12568 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
12569 jmp *dvmAsmInstructionStart+(65*4)
12571 /* ------------------------------ */
12572 .L_ALT_OP_UNUSED_42: /* 0x42 */
12573 /* File: x86/alt_stub.S */
12575 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
12576 * any interesting requests and then jump to the real instruction
12577 * handler. Unlike the Arm handler, we can't do this as a tail call
12578 * because rIBASE is caller save and we need to reload it.
12581 movl rPC, OUT_ARG0(%esp)
12582 movl %eax, OUT_ARG1(%esp)
12583 call dvmCheckInst # (dPC, self)
12585 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
12586 jmp *dvmAsmInstructionStart+(66*4)
12588 /* ------------------------------ */
12589 .L_ALT_OP_UNUSED_43: /* 0x43 */
12590 /* File: x86/alt_stub.S */
12592 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
12593 * any interesting requests and then jump to the real instruction
12594 * handler. Unlike the Arm handler, we can't do this as a tail call
12595 * because rIBASE is caller save and we need to reload it.
12598 movl rPC, OUT_ARG0(%esp)
12599 movl %eax, OUT_ARG1(%esp)
12600 call dvmCheckInst # (dPC, self)
12602 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
12603 jmp *dvmAsmInstructionStart+(67*4)
12605 /* ------------------------------ */
12606 .L_ALT_OP_AGET: /* 0x44 */
12607 /* File: x86/alt_stub.S */
12609 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
12610 * any interesting requests and then jump to the real instruction
12611 * handler. Unlike the Arm handler, we can't do this as a tail call
12612 * because rIBASE is caller save and we need to reload it.
12615 movl rPC, OUT_ARG0(%esp)
12616 movl %eax, OUT_ARG1(%esp)
12617 call dvmCheckInst # (dPC, self)
12619 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
12620 jmp *dvmAsmInstructionStart+(68*4)
12622 /* ------------------------------ */
12623 .L_ALT_OP_AGET_WIDE: /* 0x45 */
12624 /* File: x86/alt_stub.S */
12626 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
12627 * any interesting requests and then jump to the real instruction
12628 * handler. Unlike the Arm handler, we can't do this as a tail call
12629 * because rIBASE is caller save and we need to reload it.
12632 movl rPC, OUT_ARG0(%esp)
12633 movl %eax, OUT_ARG1(%esp)
12634 call dvmCheckInst # (dPC, self)
12636 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
12637 jmp *dvmAsmInstructionStart+(69*4)
12639 /* ------------------------------ */
12640 .L_ALT_OP_AGET_OBJECT: /* 0x46 */
12641 /* File: x86/alt_stub.S */
12643 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
12644 * any interesting requests and then jump to the real instruction
12645 * handler. Unlike the Arm handler, we can't do this as a tail call
12646 * because rIBASE is caller save and we need to reload it.
12649 movl rPC, OUT_ARG0(%esp)
12650 movl %eax, OUT_ARG1(%esp)
12651 call dvmCheckInst # (dPC, self)
12653 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
12654 jmp *dvmAsmInstructionStart+(70*4)
12656 /* ------------------------------ */
12657 .L_ALT_OP_AGET_BOOLEAN: /* 0x47 */
12658 /* File: x86/alt_stub.S */
12660 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
12661 * any interesting requests and then jump to the real instruction
12662 * handler. Unlike the Arm handler, we can't do this as a tail call
12663 * because rIBASE is caller save and we need to reload it.
12666 movl rPC, OUT_ARG0(%esp)
12667 movl %eax, OUT_ARG1(%esp)
12668 call dvmCheckInst # (dPC, self)
12670 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
12671 jmp *dvmAsmInstructionStart+(71*4)
12673 /* ------------------------------ */
12674 .L_ALT_OP_AGET_BYTE: /* 0x48 */
12675 /* File: x86/alt_stub.S */
12677 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
12678 * any interesting requests and then jump to the real instruction
12679 * handler. Unlike the Arm handler, we can't do this as a tail call
12680 * because rIBASE is caller save and we need to reload it.
12683 movl rPC, OUT_ARG0(%esp)
12684 movl %eax, OUT_ARG1(%esp)
12685 call dvmCheckInst # (dPC, self)
12687 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
12688 jmp *dvmAsmInstructionStart+(72*4)
12690 /* ------------------------------ */
12691 .L_ALT_OP_AGET_CHAR: /* 0x49 */
12692 /* File: x86/alt_stub.S */
12694 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
12695 * any interesting requests and then jump to the real instruction
12696 * handler. Unlike the Arm handler, we can't do this as a tail call
12697 * because rIBASE is caller save and we need to reload it.
12700 movl rPC, OUT_ARG0(%esp)
12701 movl %eax, OUT_ARG1(%esp)
12702 call dvmCheckInst # (dPC, self)
12704 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
12705 jmp *dvmAsmInstructionStart+(73*4)
12707 /* ------------------------------ */
12708 .L_ALT_OP_AGET_SHORT: /* 0x4a */
12709 /* File: x86/alt_stub.S */
12711 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
12712 * any interesting requests and then jump to the real instruction
12713 * handler. Unlike the Arm handler, we can't do this as a tail call
12714 * because rIBASE is caller save and we need to reload it.
12717 movl rPC, OUT_ARG0(%esp)
12718 movl %eax, OUT_ARG1(%esp)
12719 call dvmCheckInst # (dPC, self)
12721 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
12722 jmp *dvmAsmInstructionStart+(74*4)
12724 /* ------------------------------ */
12725 .L_ALT_OP_APUT: /* 0x4b */
12726 /* File: x86/alt_stub.S */
12728 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
12729 * any interesting requests and then jump to the real instruction
12730 * handler. Unlike the Arm handler, we can't do this as a tail call
12731 * because rIBASE is caller save and we need to reload it.
12734 movl rPC, OUT_ARG0(%esp)
12735 movl %eax, OUT_ARG1(%esp)
12736 call dvmCheckInst # (dPC, self)
12738 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
12739 jmp *dvmAsmInstructionStart+(75*4)
12741 /* ------------------------------ */
12742 .L_ALT_OP_APUT_WIDE: /* 0x4c */
12743 /* File: x86/alt_stub.S */
12745 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
12746 * any interesting requests and then jump to the real instruction
12747 * handler. Unlike the Arm handler, we can't do this as a tail call
12748 * because rIBASE is caller save and we need to reload it.
12751 movl rPC, OUT_ARG0(%esp)
12752 movl %eax, OUT_ARG1(%esp)
12753 call dvmCheckInst # (dPC, self)
12755 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
12756 jmp *dvmAsmInstructionStart+(76*4)
12758 /* ------------------------------ */
12759 .L_ALT_OP_APUT_OBJECT: /* 0x4d */
12760 /* File: x86/alt_stub.S */
12762 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
12763 * any interesting requests and then jump to the real instruction
12764 * handler. Unlike the Arm handler, we can't do this as a tail call
12765 * because rIBASE is caller save and we need to reload it.
12768 movl rPC, OUT_ARG0(%esp)
12769 movl %eax, OUT_ARG1(%esp)
12770 call dvmCheckInst # (dPC, self)
12772 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
12773 jmp *dvmAsmInstructionStart+(77*4)
12775 /* ------------------------------ */
12776 .L_ALT_OP_APUT_BOOLEAN: /* 0x4e */
12777 /* File: x86/alt_stub.S */
12779 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
12780 * any interesting requests and then jump to the real instruction
12781 * handler. Unlike the Arm handler, we can't do this as a tail call
12782 * because rIBASE is caller save and we need to reload it.
12785 movl rPC, OUT_ARG0(%esp)
12786 movl %eax, OUT_ARG1(%esp)
12787 call dvmCheckInst # (dPC, self)
12789 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
12790 jmp *dvmAsmInstructionStart+(78*4)
12792 /* ------------------------------ */
12793 .L_ALT_OP_APUT_BYTE: /* 0x4f */
12794 /* File: x86/alt_stub.S */
12796 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
12797 * any interesting requests and then jump to the real instruction
12798 * handler. Unlike the Arm handler, we can't do this as a tail call
12799 * because rIBASE is caller save and we need to reload it.
12802 movl rPC, OUT_ARG0(%esp)
12803 movl %eax, OUT_ARG1(%esp)
12804 call dvmCheckInst # (dPC, self)
12806 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
12807 jmp *dvmAsmInstructionStart+(79*4)
12809 /* ------------------------------ */
12810 .L_ALT_OP_APUT_CHAR: /* 0x50 */
12811 /* File: x86/alt_stub.S */
12813 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
12814 * any interesting requests and then jump to the real instruction
12815 * handler. Unlike the Arm handler, we can't do this as a tail call
12816 * because rIBASE is caller save and we need to reload it.
12819 movl rPC, OUT_ARG0(%esp)
12820 movl %eax, OUT_ARG1(%esp)
12821 call dvmCheckInst # (dPC, self)
12823 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
12824 jmp *dvmAsmInstructionStart+(80*4)
12826 /* ------------------------------ */
12827 .L_ALT_OP_APUT_SHORT: /* 0x51 */
12828 /* File: x86/alt_stub.S */
12830 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
12831 * any interesting requests and then jump to the real instruction
12832 * handler. Unlike the Arm handler, we can't do this as a tail call
12833 * because rIBASE is caller save and we need to reload it.
12836 movl rPC, OUT_ARG0(%esp)
12837 movl %eax, OUT_ARG1(%esp)
12838 call dvmCheckInst # (dPC, self)
12840 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
12841 jmp *dvmAsmInstructionStart+(81*4)
12843 /* ------------------------------ */
12844 .L_ALT_OP_IGET: /* 0x52 */
12845 /* File: x86/alt_stub.S */
12847 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
12848 * any interesting requests and then jump to the real instruction
12849 * handler. Unlike the Arm handler, we can't do this as a tail call
12850 * because rIBASE is caller save and we need to reload it.
12853 movl rPC, OUT_ARG0(%esp)
12854 movl %eax, OUT_ARG1(%esp)
12855 call dvmCheckInst # (dPC, self)
12857 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
12858 jmp *dvmAsmInstructionStart+(82*4)
12860 /* ------------------------------ */
12861 .L_ALT_OP_IGET_WIDE: /* 0x53 */
12862 /* File: x86/alt_stub.S */
12864 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
12865 * any interesting requests and then jump to the real instruction
12866 * handler. Unlike the Arm handler, we can't do this as a tail call
12867 * because rIBASE is caller save and we need to reload it.
12870 movl rPC, OUT_ARG0(%esp)
12871 movl %eax, OUT_ARG1(%esp)
12872 call dvmCheckInst # (dPC, self)
12874 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
12875 jmp *dvmAsmInstructionStart+(83*4)
12877 /* ------------------------------ */
12878 .L_ALT_OP_IGET_OBJECT: /* 0x54 */
12879 /* File: x86/alt_stub.S */
12881 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
12882 * any interesting requests and then jump to the real instruction
12883 * handler. Unlike the Arm handler, we can't do this as a tail call
12884 * because rIBASE is caller save and we need to reload it.
12887 movl rPC, OUT_ARG0(%esp)
12888 movl %eax, OUT_ARG1(%esp)
12889 call dvmCheckInst # (dPC, self)
12891 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
12892 jmp *dvmAsmInstructionStart+(84*4)
12894 /* ------------------------------ */
12895 .L_ALT_OP_IGET_BOOLEAN: /* 0x55 */
12896 /* File: x86/alt_stub.S */
12898 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
12899 * any interesting requests and then jump to the real instruction
12900 * handler. Unlike the Arm handler, we can't do this as a tail call
12901 * because rIBASE is caller save and we need to reload it.
12904 movl rPC, OUT_ARG0(%esp)
12905 movl %eax, OUT_ARG1(%esp)
12906 call dvmCheckInst # (dPC, self)
12908 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
12909 jmp *dvmAsmInstructionStart+(85*4)
12911 /* ------------------------------ */
12912 .L_ALT_OP_IGET_BYTE: /* 0x56 */
12913 /* File: x86/alt_stub.S */
12915 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
12916 * any interesting requests and then jump to the real instruction
12917 * handler. Unlike the Arm handler, we can't do this as a tail call
12918 * because rIBASE is caller save and we need to reload it.
12921 movl rPC, OUT_ARG0(%esp)
12922 movl %eax, OUT_ARG1(%esp)
12923 call dvmCheckInst # (dPC, self)
12925 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
12926 jmp *dvmAsmInstructionStart+(86*4)
12928 /* ------------------------------ */
12929 .L_ALT_OP_IGET_CHAR: /* 0x57 */
12930 /* File: x86/alt_stub.S */
12932 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
12933 * any interesting requests and then jump to the real instruction
12934 * handler. Unlike the Arm handler, we can't do this as a tail call
12935 * because rIBASE is caller save and we need to reload it.
12938 movl rPC, OUT_ARG0(%esp)
12939 movl %eax, OUT_ARG1(%esp)
12940 call dvmCheckInst # (dPC, self)
12942 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
12943 jmp *dvmAsmInstructionStart+(87*4)
12945 /* ------------------------------ */
12946 .L_ALT_OP_IGET_SHORT: /* 0x58 */
12947 /* File: x86/alt_stub.S */
12949 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
12950 * any interesting requests and then jump to the real instruction
12951 * handler. Unlike the Arm handler, we can't do this as a tail call
12952 * because rIBASE is caller save and we need to reload it.
12955 movl rPC, OUT_ARG0(%esp)
12956 movl %eax, OUT_ARG1(%esp)
12957 call dvmCheckInst # (dPC, self)
12959 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
12960 jmp *dvmAsmInstructionStart+(88*4)
12962 /* ------------------------------ */
12963 .L_ALT_OP_IPUT: /* 0x59 */
12964 /* File: x86/alt_stub.S */
12966 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
12967 * any interesting requests and then jump to the real instruction
12968 * handler. Unlike the Arm handler, we can't do this as a tail call
12969 * because rIBASE is caller save and we need to reload it.
12972 movl rPC, OUT_ARG0(%esp)
12973 movl %eax, OUT_ARG1(%esp)
12974 call dvmCheckInst # (dPC, self)
12976 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
12977 jmp *dvmAsmInstructionStart+(89*4)
12979 /* ------------------------------ */
12980 .L_ALT_OP_IPUT_WIDE: /* 0x5a */
12981 /* File: x86/alt_stub.S */
12983 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
12984 * any interesting requests and then jump to the real instruction
12985 * handler. Unlike the Arm handler, we can't do this as a tail call
12986 * because rIBASE is caller save and we need to reload it.
12989 movl rPC, OUT_ARG0(%esp)
12990 movl %eax, OUT_ARG1(%esp)
12991 call dvmCheckInst # (dPC, self)
12993 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
12994 jmp *dvmAsmInstructionStart+(90*4)
12996 /* ------------------------------ */
12997 .L_ALT_OP_IPUT_OBJECT: /* 0x5b */
12998 /* File: x86/alt_stub.S */
13000 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
13001 * any interesting requests and then jump to the real instruction
13002 * handler. Unlike the Arm handler, we can't do this as a tail call
13003 * because rIBASE is caller save and we need to reload it.
13006 movl rPC, OUT_ARG0(%esp)
13007 movl %eax, OUT_ARG1(%esp)
13008 call dvmCheckInst # (dPC, self)
13010 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
13011 jmp *dvmAsmInstructionStart+(91*4)
13013 /* ------------------------------ */
13014 .L_ALT_OP_IPUT_BOOLEAN: /* 0x5c */
13015 /* File: x86/alt_stub.S */
13017 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
13018 * any interesting requests and then jump to the real instruction
13019 * handler. Unlike the Arm handler, we can't do this as a tail call
13020 * because rIBASE is caller save and we need to reload it.
13023 movl rPC, OUT_ARG0(%esp)
13024 movl %eax, OUT_ARG1(%esp)
13025 call dvmCheckInst # (dPC, self)
13027 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
13028 jmp *dvmAsmInstructionStart+(92*4)
13030 /* ------------------------------ */
13031 .L_ALT_OP_IPUT_BYTE: /* 0x5d */
13032 /* File: x86/alt_stub.S */
13034 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
13035 * any interesting requests and then jump to the real instruction
13036 * handler. Unlike the Arm handler, we can't do this as a tail call
13037 * because rIBASE is caller save and we need to reload it.
13040 movl rPC, OUT_ARG0(%esp)
13041 movl %eax, OUT_ARG1(%esp)
13042 call dvmCheckInst # (dPC, self)
13044 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
13045 jmp *dvmAsmInstructionStart+(93*4)
13047 /* ------------------------------ */
13048 .L_ALT_OP_IPUT_CHAR: /* 0x5e */
13049 /* File: x86/alt_stub.S */
13051 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
13052 * any interesting requests and then jump to the real instruction
13053 * handler. Unlike the Arm handler, we can't do this as a tail call
13054 * because rIBASE is caller save and we need to reload it.
13057 movl rPC, OUT_ARG0(%esp)
13058 movl %eax, OUT_ARG1(%esp)
13059 call dvmCheckInst # (dPC, self)
13061 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
13062 jmp *dvmAsmInstructionStart+(94*4)
13064 /* ------------------------------ */
13065 .L_ALT_OP_IPUT_SHORT: /* 0x5f */
13066 /* File: x86/alt_stub.S */
13068 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
13069 * any interesting requests and then jump to the real instruction
13070 * handler. Unlike the Arm handler, we can't do this as a tail call
13071 * because rIBASE is caller save and we need to reload it.
13074 movl rPC, OUT_ARG0(%esp)
13075 movl %eax, OUT_ARG1(%esp)
13076 call dvmCheckInst # (dPC, self)
13078 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
13079 jmp *dvmAsmInstructionStart+(95*4)
13081 /* ------------------------------ */
13082 .L_ALT_OP_SGET: /* 0x60 */
13083 /* File: x86/alt_stub.S */
13085 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
13086 * any interesting requests and then jump to the real instruction
13087 * handler. Unlike the Arm handler, we can't do this as a tail call
13088 * because rIBASE is caller save and we need to reload it.
13091 movl rPC, OUT_ARG0(%esp)
13092 movl %eax, OUT_ARG1(%esp)
13093 call dvmCheckInst # (dPC, self)
13095 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
13096 jmp *dvmAsmInstructionStart+(96*4)
13098 /* ------------------------------ */
13099 .L_ALT_OP_SGET_WIDE: /* 0x61 */
13100 /* File: x86/alt_stub.S */
13102 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
13103 * any interesting requests and then jump to the real instruction
13104 * handler. Unlike the Arm handler, we can't do this as a tail call
13105 * because rIBASE is caller save and we need to reload it.
13108 movl rPC, OUT_ARG0(%esp)
13109 movl %eax, OUT_ARG1(%esp)
13110 call dvmCheckInst # (dPC, self)
13112 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
13113 jmp *dvmAsmInstructionStart+(97*4)
13115 /* ------------------------------ */
13116 .L_ALT_OP_SGET_OBJECT: /* 0x62 */
13117 /* File: x86/alt_stub.S */
13119 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
13120 * any interesting requests and then jump to the real instruction
13121 * handler. Unlike the Arm handler, we can't do this as a tail call
13122 * because rIBASE is caller save and we need to reload it.
13125 movl rPC, OUT_ARG0(%esp)
13126 movl %eax, OUT_ARG1(%esp)
13127 call dvmCheckInst # (dPC, self)
13129 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
13130 jmp *dvmAsmInstructionStart+(98*4)
13132 /* ------------------------------ */
13133 .L_ALT_OP_SGET_BOOLEAN: /* 0x63 */
13134 /* File: x86/alt_stub.S */
13136 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
13137 * any interesting requests and then jump to the real instruction
13138 * handler. Unlike the Arm handler, we can't do this as a tail call
13139 * because rIBASE is caller save and we need to reload it.
13142 movl rPC, OUT_ARG0(%esp)
13143 movl %eax, OUT_ARG1(%esp)
13144 call dvmCheckInst # (dPC, self)
13146 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
13147 jmp *dvmAsmInstructionStart+(99*4)
13149 /* ------------------------------ */
13150 .L_ALT_OP_SGET_BYTE: /* 0x64 */
13151 /* File: x86/alt_stub.S */
13153 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
13154 * any interesting requests and then jump to the real instruction
13155 * handler. Unlike the Arm handler, we can't do this as a tail call
13156 * because rIBASE is caller save and we need to reload it.
13159 movl rPC, OUT_ARG0(%esp)
13160 movl %eax, OUT_ARG1(%esp)
13161 call dvmCheckInst # (dPC, self)
13163 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
13164 jmp *dvmAsmInstructionStart+(100*4)
13166 /* ------------------------------ */
13167 .L_ALT_OP_SGET_CHAR: /* 0x65 */
13168 /* File: x86/alt_stub.S */
13170 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
13171 * any interesting requests and then jump to the real instruction
13172 * handler. Unlike the Arm handler, we can't do this as a tail call
13173 * because rIBASE is caller save and we need to reload it.
13176 movl rPC, OUT_ARG0(%esp)
13177 movl %eax, OUT_ARG1(%esp)
13178 call dvmCheckInst # (dPC, self)
13180 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
13181 jmp *dvmAsmInstructionStart+(101*4)
13183 /* ------------------------------ */
13184 .L_ALT_OP_SGET_SHORT: /* 0x66 */
13185 /* File: x86/alt_stub.S */
13187 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
13188 * any interesting requests and then jump to the real instruction
13189 * handler. Unlike the Arm handler, we can't do this as a tail call
13190 * because rIBASE is caller save and we need to reload it.
13193 movl rPC, OUT_ARG0(%esp)
13194 movl %eax, OUT_ARG1(%esp)
13195 call dvmCheckInst # (dPC, self)
13197 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
13198 jmp *dvmAsmInstructionStart+(102*4)
13200 /* ------------------------------ */
13201 .L_ALT_OP_SPUT: /* 0x67 */
13202 /* File: x86/alt_stub.S */
13204 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
13205 * any interesting requests and then jump to the real instruction
13206 * handler. Unlike the Arm handler, we can't do this as a tail call
13207 * because rIBASE is caller save and we need to reload it.
13210 movl rPC, OUT_ARG0(%esp)
13211 movl %eax, OUT_ARG1(%esp)
13212 call dvmCheckInst # (dPC, self)
13214 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
13215 jmp *dvmAsmInstructionStart+(103*4)
13217 /* ------------------------------ */
13218 .L_ALT_OP_SPUT_WIDE: /* 0x68 */
13219 /* File: x86/alt_stub.S */
13221 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
13222 * any interesting requests and then jump to the real instruction
13223 * handler. Unlike the Arm handler, we can't do this as a tail call
13224 * because rIBASE is caller save and we need to reload it.
13227 movl rPC, OUT_ARG0(%esp)
13228 movl %eax, OUT_ARG1(%esp)
13229 call dvmCheckInst # (dPC, self)
13231 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
13232 jmp *dvmAsmInstructionStart+(104*4)
13234 /* ------------------------------ */
13235 .L_ALT_OP_SPUT_OBJECT: /* 0x69 */
13236 /* File: x86/alt_stub.S */
13238 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
13239 * any interesting requests and then jump to the real instruction
13240 * handler. Unlike the Arm handler, we can't do this as a tail call
13241 * because rIBASE is caller save and we need to reload it.
13244 movl rPC, OUT_ARG0(%esp)
13245 movl %eax, OUT_ARG1(%esp)
13246 call dvmCheckInst # (dPC, self)
13248 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
13249 jmp *dvmAsmInstructionStart+(105*4)
13251 /* ------------------------------ */
13252 .L_ALT_OP_SPUT_BOOLEAN: /* 0x6a */
13253 /* File: x86/alt_stub.S */
13255 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
13256 * any interesting requests and then jump to the real instruction
13257 * handler. Unlike the Arm handler, we can't do this as a tail call
13258 * because rIBASE is caller save and we need to reload it.
13261 movl rPC, OUT_ARG0(%esp)
13262 movl %eax, OUT_ARG1(%esp)
13263 call dvmCheckInst # (dPC, self)
13265 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
13266 jmp *dvmAsmInstructionStart+(106*4)
13268 /* ------------------------------ */
13269 .L_ALT_OP_SPUT_BYTE: /* 0x6b */
13270 /* File: x86/alt_stub.S */
13272 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
13273 * any interesting requests and then jump to the real instruction
13274 * handler. Unlike the Arm handler, we can't do this as a tail call
13275 * because rIBASE is caller save and we need to reload it.
13278 movl rPC, OUT_ARG0(%esp)
13279 movl %eax, OUT_ARG1(%esp)
13280 call dvmCheckInst # (dPC, self)
13282 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
13283 jmp *dvmAsmInstructionStart+(107*4)
13285 /* ------------------------------ */
13286 .L_ALT_OP_SPUT_CHAR: /* 0x6c */
13287 /* File: x86/alt_stub.S */
13289 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
13290 * any interesting requests and then jump to the real instruction
13291 * handler. Unlike the Arm handler, we can't do this as a tail call
13292 * because rIBASE is caller save and we need to reload it.
13295 movl rPC, OUT_ARG0(%esp)
13296 movl %eax, OUT_ARG1(%esp)
13297 call dvmCheckInst # (dPC, self)
13299 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
13300 jmp *dvmAsmInstructionStart+(108*4)
13302 /* ------------------------------ */
13303 .L_ALT_OP_SPUT_SHORT: /* 0x6d */
13304 /* File: x86/alt_stub.S */
13306 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
13307 * any interesting requests and then jump to the real instruction
13308 * handler. Unlike the Arm handler, we can't do this as a tail call
13309 * because rIBASE is caller save and we need to reload it.
13312 movl rPC, OUT_ARG0(%esp)
13313 movl %eax, OUT_ARG1(%esp)
13314 call dvmCheckInst # (dPC, self)
13316 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
13317 jmp *dvmAsmInstructionStart+(109*4)
13319 /* ------------------------------ */
13320 .L_ALT_OP_INVOKE_VIRTUAL: /* 0x6e */
13321 /* File: x86/alt_stub.S */
13323 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
13324 * any interesting requests and then jump to the real instruction
13325 * handler. Unlike the Arm handler, we can't do this as a tail call
13326 * because rIBASE is caller save and we need to reload it.
13329 movl rPC, OUT_ARG0(%esp)
13330 movl %eax, OUT_ARG1(%esp)
13331 call dvmCheckInst # (dPC, self)
13333 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
13334 jmp *dvmAsmInstructionStart+(110*4)
13336 /* ------------------------------ */
13337 .L_ALT_OP_INVOKE_SUPER: /* 0x6f */
13338 /* File: x86/alt_stub.S */
13340 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
13341 * any interesting requests and then jump to the real instruction
13342 * handler. Unlike the Arm handler, we can't do this as a tail call
13343 * because rIBASE is caller save and we need to reload it.
13346 movl rPC, OUT_ARG0(%esp)
13347 movl %eax, OUT_ARG1(%esp)
13348 call dvmCheckInst # (dPC, self)
13350 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
13351 jmp *dvmAsmInstructionStart+(111*4)
13353 /* ------------------------------ */
13354 .L_ALT_OP_INVOKE_DIRECT: /* 0x70 */
13355 /* File: x86/alt_stub.S */
13357 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
13358 * any interesting requests and then jump to the real instruction
13359 * handler. Unlike the Arm handler, we can't do this as a tail call
13360 * because rIBASE is caller save and we need to reload it.
13363 movl rPC, OUT_ARG0(%esp)
13364 movl %eax, OUT_ARG1(%esp)
13365 call dvmCheckInst # (dPC, self)
13367 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
13368 jmp *dvmAsmInstructionStart+(112*4)
13370 /* ------------------------------ */
13371 .L_ALT_OP_INVOKE_STATIC: /* 0x71 */
13372 /* File: x86/alt_stub.S */
13374 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
13375 * any interesting requests and then jump to the real instruction
13376 * handler. Unlike the Arm handler, we can't do this as a tail call
13377 * because rIBASE is caller save and we need to reload it.
13380 movl rPC, OUT_ARG0(%esp)
13381 movl %eax, OUT_ARG1(%esp)
13382 call dvmCheckInst # (dPC, self)
13384 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
13385 jmp *dvmAsmInstructionStart+(113*4)
13387 /* ------------------------------ */
13388 .L_ALT_OP_INVOKE_INTERFACE: /* 0x72 */
13389 /* File: x86/alt_stub.S */
13391 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
13392 * any interesting requests and then jump to the real instruction
13393 * handler. Unlike the Arm handler, we can't do this as a tail call
13394 * because rIBASE is caller save and we need to reload it.
13397 movl rPC, OUT_ARG0(%esp)
13398 movl %eax, OUT_ARG1(%esp)
13399 call dvmCheckInst # (dPC, self)
13401 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
13402 jmp *dvmAsmInstructionStart+(114*4)
13404 /* ------------------------------ */
13405 .L_ALT_OP_UNUSED_73: /* 0x73 */
13406 /* File: x86/alt_stub.S */
13408 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
13409 * any interesting requests and then jump to the real instruction
13410 * handler. Unlike the Arm handler, we can't do this as a tail call
13411 * because rIBASE is caller save and we need to reload it.
13414 movl rPC, OUT_ARG0(%esp)
13415 movl %eax, OUT_ARG1(%esp)
13416 call dvmCheckInst # (dPC, self)
13418 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
13419 jmp *dvmAsmInstructionStart+(115*4)
13421 /* ------------------------------ */
13422 .L_ALT_OP_INVOKE_VIRTUAL_RANGE: /* 0x74 */
13423 /* File: x86/alt_stub.S */
13425 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
13426 * any interesting requests and then jump to the real instruction
13427 * handler. Unlike the Arm handler, we can't do this as a tail call
13428 * because rIBASE is caller save and we need to reload it.
13431 movl rPC, OUT_ARG0(%esp)
13432 movl %eax, OUT_ARG1(%esp)
13433 call dvmCheckInst # (dPC, self)
13435 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
13436 jmp *dvmAsmInstructionStart+(116*4)
13438 /* ------------------------------ */
13439 .L_ALT_OP_INVOKE_SUPER_RANGE: /* 0x75 */
13440 /* File: x86/alt_stub.S */
13442 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
13443 * any interesting requests and then jump to the real instruction
13444 * handler. Unlike the Arm handler, we can't do this as a tail call
13445 * because rIBASE is caller save and we need to reload it.
13448 movl rPC, OUT_ARG0(%esp)
13449 movl %eax, OUT_ARG1(%esp)
13450 call dvmCheckInst # (dPC, self)
13452 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
13453 jmp *dvmAsmInstructionStart+(117*4)
13455 /* ------------------------------ */
13456 .L_ALT_OP_INVOKE_DIRECT_RANGE: /* 0x76 */
13457 /* File: x86/alt_stub.S */
13459 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
13460 * any interesting requests and then jump to the real instruction
13461 * handler. Unlike the Arm handler, we can't do this as a tail call
13462 * because rIBASE is caller save and we need to reload it.
13465 movl rPC, OUT_ARG0(%esp)
13466 movl %eax, OUT_ARG1(%esp)
13467 call dvmCheckInst # (dPC, self)
13469 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
13470 jmp *dvmAsmInstructionStart+(118*4)
13472 /* ------------------------------ */
13473 .L_ALT_OP_INVOKE_STATIC_RANGE: /* 0x77 */
13474 /* File: x86/alt_stub.S */
13476 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
13477 * any interesting requests and then jump to the real instruction
13478 * handler. Unlike the Arm handler, we can't do this as a tail call
13479 * because rIBASE is caller save and we need to reload it.
13482 movl rPC, OUT_ARG0(%esp)
13483 movl %eax, OUT_ARG1(%esp)
13484 call dvmCheckInst # (dPC, self)
13486 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
13487 jmp *dvmAsmInstructionStart+(119*4)
13489 /* ------------------------------ */
13490 .L_ALT_OP_INVOKE_INTERFACE_RANGE: /* 0x78 */
13491 /* File: x86/alt_stub.S */
13493 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
13494 * any interesting requests and then jump to the real instruction
13495 * handler. Unlike the Arm handler, we can't do this as a tail call
13496 * because rIBASE is caller save and we need to reload it.
13499 movl rPC, OUT_ARG0(%esp)
13500 movl %eax, OUT_ARG1(%esp)
13501 call dvmCheckInst # (dPC, self)
13503 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
13504 jmp *dvmAsmInstructionStart+(120*4)
13506 /* ------------------------------ */
13507 .L_ALT_OP_UNUSED_79: /* 0x79 */
13508 /* File: x86/alt_stub.S */
13510 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
13511 * any interesting requests and then jump to the real instruction
13512 * handler. Unlike the Arm handler, we can't do this as a tail call
13513 * because rIBASE is caller save and we need to reload it.
13516 movl rPC, OUT_ARG0(%esp)
13517 movl %eax, OUT_ARG1(%esp)
13518 call dvmCheckInst # (dPC, self)
13520 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
13521 jmp *dvmAsmInstructionStart+(121*4)
13523 /* ------------------------------ */
13524 .L_ALT_OP_UNUSED_7A: /* 0x7a */
13525 /* File: x86/alt_stub.S */
13527 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
13528 * any interesting requests and then jump to the real instruction
13529 * handler. Unlike the Arm handler, we can't do this as a tail call
13530 * because rIBASE is caller save and we need to reload it.
13533 movl rPC, OUT_ARG0(%esp)
13534 movl %eax, OUT_ARG1(%esp)
13535 call dvmCheckInst # (dPC, self)
13537 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
13538 jmp *dvmAsmInstructionStart+(122*4)
13540 /* ------------------------------ */
13541 .L_ALT_OP_NEG_INT: /* 0x7b */
13542 /* File: x86/alt_stub.S */
13544 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
13545 * any interesting requests and then jump to the real instruction
13546 * handler. Unlike the Arm handler, we can't do this as a tail call
13547 * because rIBASE is caller save and we need to reload it.
13550 movl rPC, OUT_ARG0(%esp)
13551 movl %eax, OUT_ARG1(%esp)
13552 call dvmCheckInst # (dPC, self)
13554 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
13555 jmp *dvmAsmInstructionStart+(123*4)
13557 /* ------------------------------ */
13558 .L_ALT_OP_NOT_INT: /* 0x7c */
13559 /* File: x86/alt_stub.S */
13561 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
13562 * any interesting requests and then jump to the real instruction
13563 * handler. Unlike the Arm handler, we can't do this as a tail call
13564 * because rIBASE is caller save and we need to reload it.
13567 movl rPC, OUT_ARG0(%esp)
13568 movl %eax, OUT_ARG1(%esp)
13569 call dvmCheckInst # (dPC, self)
13571 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
13572 jmp *dvmAsmInstructionStart+(124*4)
13574 /* ------------------------------ */
13575 .L_ALT_OP_NEG_LONG: /* 0x7d */
13576 /* File: x86/alt_stub.S */
13578 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
13579 * any interesting requests and then jump to the real instruction
13580 * handler. Unlike the Arm handler, we can't do this as a tail call
13581 * because rIBASE is caller save and we need to reload it.
13584 movl rPC, OUT_ARG0(%esp)
13585 movl %eax, OUT_ARG1(%esp)
13586 call dvmCheckInst # (dPC, self)
13588 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
13589 jmp *dvmAsmInstructionStart+(125*4)
13591 /* ------------------------------ */
13592 .L_ALT_OP_NOT_LONG: /* 0x7e */
13593 /* File: x86/alt_stub.S */
13595 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
13596 * any interesting requests and then jump to the real instruction
13597 * handler. Unlike the Arm handler, we can't do this as a tail call
13598 * because rIBASE is caller save and we need to reload it.
13601 movl rPC, OUT_ARG0(%esp)
13602 movl %eax, OUT_ARG1(%esp)
13603 call dvmCheckInst # (dPC, self)
13605 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
13606 jmp *dvmAsmInstructionStart+(126*4)
13608 /* ------------------------------ */
13609 .L_ALT_OP_NEG_FLOAT: /* 0x7f */
13610 /* File: x86/alt_stub.S */
13612 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
13613 * any interesting requests and then jump to the real instruction
13614 * handler. Unlike the Arm handler, we can't do this as a tail call
13615 * because rIBASE is caller save and we need to reload it.
13618 movl rPC, OUT_ARG0(%esp)
13619 movl %eax, OUT_ARG1(%esp)
13620 call dvmCheckInst # (dPC, self)
13622 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
13623 jmp *dvmAsmInstructionStart+(127*4)
13625 /* ------------------------------ */
13626 .L_ALT_OP_NEG_DOUBLE: /* 0x80 */
13627 /* File: x86/alt_stub.S */
13629 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
13630 * any interesting requests and then jump to the real instruction
13631 * handler. Unlike the Arm handler, we can't do this as a tail call
13632 * because rIBASE is caller save and we need to reload it.
13635 movl rPC, OUT_ARG0(%esp)
13636 movl %eax, OUT_ARG1(%esp)
13637 call dvmCheckInst # (dPC, self)
13639 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
13640 jmp *dvmAsmInstructionStart+(128*4)
13642 /* ------------------------------ */
13643 .L_ALT_OP_INT_TO_LONG: /* 0x81 */
13644 /* File: x86/alt_stub.S */
13646 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
13647 * any interesting requests and then jump to the real instruction
13648 * handler. Unlike the Arm handler, we can't do this as a tail call
13649 * because rIBASE is caller save and we need to reload it.
13652 movl rPC, OUT_ARG0(%esp)
13653 movl %eax, OUT_ARG1(%esp)
13654 call dvmCheckInst # (dPC, self)
13656 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
13657 jmp *dvmAsmInstructionStart+(129*4)
13659 /* ------------------------------ */
13660 .L_ALT_OP_INT_TO_FLOAT: /* 0x82 */
13661 /* File: x86/alt_stub.S */
13663 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
13664 * any interesting requests and then jump to the real instruction
13665 * handler. Unlike the Arm handler, we can't do this as a tail call
13666 * because rIBASE is caller save and we need to reload it.
13669 movl rPC, OUT_ARG0(%esp)
13670 movl %eax, OUT_ARG1(%esp)
13671 call dvmCheckInst # (dPC, self)
13673 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
13674 jmp *dvmAsmInstructionStart+(130*4)
13676 /* ------------------------------ */
13677 .L_ALT_OP_INT_TO_DOUBLE: /* 0x83 */
13678 /* File: x86/alt_stub.S */
13680 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
13681 * any interesting requests and then jump to the real instruction
13682 * handler. Unlike the Arm handler, we can't do this as a tail call
13683 * because rIBASE is caller save and we need to reload it.
13686 movl rPC, OUT_ARG0(%esp)
13687 movl %eax, OUT_ARG1(%esp)
13688 call dvmCheckInst # (dPC, self)
13690 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
13691 jmp *dvmAsmInstructionStart+(131*4)
13693 /* ------------------------------ */
13694 .L_ALT_OP_LONG_TO_INT: /* 0x84 */
13695 /* File: x86/alt_stub.S */
13697 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
13698 * any interesting requests and then jump to the real instruction
13699 * handler. Unlike the Arm handler, we can't do this as a tail call
13700 * because rIBASE is caller save and we need to reload it.
13703 movl rPC, OUT_ARG0(%esp)
13704 movl %eax, OUT_ARG1(%esp)
13705 call dvmCheckInst # (dPC, self)
13707 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
13708 jmp *dvmAsmInstructionStart+(132*4)
13710 /* ------------------------------ */
13711 .L_ALT_OP_LONG_TO_FLOAT: /* 0x85 */
13712 /* File: x86/alt_stub.S */
13714 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
13715 * any interesting requests and then jump to the real instruction
13716 * handler. Unlike the Arm handler, we can't do this as a tail call
13717 * because rIBASE is caller save and we need to reload it.
13720 movl rPC, OUT_ARG0(%esp)
13721 movl %eax, OUT_ARG1(%esp)
13722 call dvmCheckInst # (dPC, self)
13724 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
13725 jmp *dvmAsmInstructionStart+(133*4)
13727 /* ------------------------------ */
13728 .L_ALT_OP_LONG_TO_DOUBLE: /* 0x86 */
13729 /* File: x86/alt_stub.S */
13731 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
13732 * any interesting requests and then jump to the real instruction
13733 * handler. Unlike the Arm handler, we can't do this as a tail call
13734 * because rIBASE is caller save and we need to reload it.
13737 movl rPC, OUT_ARG0(%esp)
13738 movl %eax, OUT_ARG1(%esp)
13739 call dvmCheckInst # (dPC, self)
13741 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
13742 jmp *dvmAsmInstructionStart+(134*4)
13744 /* ------------------------------ */
13745 .L_ALT_OP_FLOAT_TO_INT: /* 0x87 */
13746 /* File: x86/alt_stub.S */
13748 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
13749 * any interesting requests and then jump to the real instruction
13750 * handler. Unlike the Arm handler, we can't do this as a tail call
13751 * because rIBASE is caller save and we need to reload it.
13754 movl rPC, OUT_ARG0(%esp)
13755 movl %eax, OUT_ARG1(%esp)
13756 call dvmCheckInst # (dPC, self)
13758 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
13759 jmp *dvmAsmInstructionStart+(135*4)
13761 /* ------------------------------ */
13762 .L_ALT_OP_FLOAT_TO_LONG: /* 0x88 */
13763 /* File: x86/alt_stub.S */
13765 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
13766 * any interesting requests and then jump to the real instruction
13767 * handler. Unlike the Arm handler, we can't do this as a tail call
13768 * because rIBASE is caller save and we need to reload it.
13771 movl rPC, OUT_ARG0(%esp)
13772 movl %eax, OUT_ARG1(%esp)
13773 call dvmCheckInst # (dPC, self)
13775 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
13776 jmp *dvmAsmInstructionStart+(136*4)
13778 /* ------------------------------ */
13779 .L_ALT_OP_FLOAT_TO_DOUBLE: /* 0x89 */
13780 /* File: x86/alt_stub.S */
13782 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
13783 * any interesting requests and then jump to the real instruction
13784 * handler. Unlike the Arm handler, we can't do this as a tail call
13785 * because rIBASE is caller save and we need to reload it.
13788 movl rPC, OUT_ARG0(%esp)
13789 movl %eax, OUT_ARG1(%esp)
13790 call dvmCheckInst # (dPC, self)
13792 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
13793 jmp *dvmAsmInstructionStart+(137*4)
13795 /* ------------------------------ */
13796 .L_ALT_OP_DOUBLE_TO_INT: /* 0x8a */
13797 /* File: x86/alt_stub.S */
13799 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
13800 * any interesting requests and then jump to the real instruction
13801 * handler. Unlike the Arm handler, we can't do this as a tail call
13802 * because rIBASE is caller save and we need to reload it.
13805 movl rPC, OUT_ARG0(%esp)
13806 movl %eax, OUT_ARG1(%esp)
13807 call dvmCheckInst # (dPC, self)
13809 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
13810 jmp *dvmAsmInstructionStart+(138*4)
13812 /* ------------------------------ */
13813 .L_ALT_OP_DOUBLE_TO_LONG: /* 0x8b */
13814 /* File: x86/alt_stub.S */
13816 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
13817 * any interesting requests and then jump to the real instruction
13818 * handler. Unlike the Arm handler, we can't do this as a tail call
13819 * because rIBASE is caller save and we need to reload it.
13822 movl rPC, OUT_ARG0(%esp)
13823 movl %eax, OUT_ARG1(%esp)
13824 call dvmCheckInst # (dPC, self)
13826 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
13827 jmp *dvmAsmInstructionStart+(139*4)
13829 /* ------------------------------ */
13830 .L_ALT_OP_DOUBLE_TO_FLOAT: /* 0x8c */
13831 /* File: x86/alt_stub.S */
13833 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
13834 * any interesting requests and then jump to the real instruction
13835 * handler. Unlike the Arm handler, we can't do this as a tail call
13836 * because rIBASE is caller save and we need to reload it.
13839 movl rPC, OUT_ARG0(%esp)
13840 movl %eax, OUT_ARG1(%esp)
13841 call dvmCheckInst # (dPC, self)
13843 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
13844 jmp *dvmAsmInstructionStart+(140*4)
13846 /* ------------------------------ */
13847 .L_ALT_OP_INT_TO_BYTE: /* 0x8d */
13848 /* File: x86/alt_stub.S */
13850 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
13851 * any interesting requests and then jump to the real instruction
13852 * handler. Unlike the Arm handler, we can't do this as a tail call
13853 * because rIBASE is caller save and we need to reload it.
13856 movl rPC, OUT_ARG0(%esp)
13857 movl %eax, OUT_ARG1(%esp)
13858 call dvmCheckInst # (dPC, self)
13860 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
13861 jmp *dvmAsmInstructionStart+(141*4)
13863 /* ------------------------------ */
13864 .L_ALT_OP_INT_TO_CHAR: /* 0x8e */
13865 /* File: x86/alt_stub.S */
13867 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
13868 * any interesting requests and then jump to the real instruction
13869 * handler. Unlike the Arm handler, we can't do this as a tail call
13870 * because rIBASE is caller save and we need to reload it.
13873 movl rPC, OUT_ARG0(%esp)
13874 movl %eax, OUT_ARG1(%esp)
13875 call dvmCheckInst # (dPC, self)
13877 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
13878 jmp *dvmAsmInstructionStart+(142*4)
13880 /* ------------------------------ */
13881 .L_ALT_OP_INT_TO_SHORT: /* 0x8f */
13882 /* File: x86/alt_stub.S */
13884 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
13885 * any interesting requests and then jump to the real instruction
13886 * handler. Unlike the Arm handler, we can't do this as a tail call
13887 * because rIBASE is caller save and we need to reload it.
13890 movl rPC, OUT_ARG0(%esp)
13891 movl %eax, OUT_ARG1(%esp)
13892 call dvmCheckInst # (dPC, self)
13894 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
13895 jmp *dvmAsmInstructionStart+(143*4)
13897 /* ------------------------------ */
13898 .L_ALT_OP_ADD_INT: /* 0x90 */
13899 /* File: x86/alt_stub.S */
13901 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
13902 * any interesting requests and then jump to the real instruction
13903 * handler. Unlike the Arm handler, we can't do this as a tail call
13904 * because rIBASE is caller save and we need to reload it.
13907 movl rPC, OUT_ARG0(%esp)
13908 movl %eax, OUT_ARG1(%esp)
13909 call dvmCheckInst # (dPC, self)
13911 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
13912 jmp *dvmAsmInstructionStart+(144*4)
13914 /* ------------------------------ */
13915 .L_ALT_OP_SUB_INT: /* 0x91 */
13916 /* File: x86/alt_stub.S */
13918 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
13919 * any interesting requests and then jump to the real instruction
13920 * handler. Unlike the Arm handler, we can't do this as a tail call
13921 * because rIBASE is caller save and we need to reload it.
13924 movl rPC, OUT_ARG0(%esp)
13925 movl %eax, OUT_ARG1(%esp)
13926 call dvmCheckInst # (dPC, self)
13928 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
13929 jmp *dvmAsmInstructionStart+(145*4)
13931 /* ------------------------------ */
13932 .L_ALT_OP_MUL_INT: /* 0x92 */
13933 /* File: x86/alt_stub.S */
13935 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
13936 * any interesting requests and then jump to the real instruction
13937 * handler. Unlike the Arm handler, we can't do this as a tail call
13938 * because rIBASE is caller save and we need to reload it.
13941 movl rPC, OUT_ARG0(%esp)
13942 movl %eax, OUT_ARG1(%esp)
13943 call dvmCheckInst # (dPC, self)
13945 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
13946 jmp *dvmAsmInstructionStart+(146*4)
13948 /* ------------------------------ */
13949 .L_ALT_OP_DIV_INT: /* 0x93 */
13950 /* File: x86/alt_stub.S */
13952 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
13953 * any interesting requests and then jump to the real instruction
13954 * handler. Unlike the Arm handler, we can't do this as a tail call
13955 * because rIBASE is caller save and we need to reload it.
13958 movl rPC, OUT_ARG0(%esp)
13959 movl %eax, OUT_ARG1(%esp)
13960 call dvmCheckInst # (dPC, self)
13962 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
13963 jmp *dvmAsmInstructionStart+(147*4)
13965 /* ------------------------------ */
13966 .L_ALT_OP_REM_INT: /* 0x94 */
13967 /* File: x86/alt_stub.S */
13969 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
13970 * any interesting requests and then jump to the real instruction
13971 * handler. Unlike the Arm handler, we can't do this as a tail call
13972 * because rIBASE is caller save and we need to reload it.
13975 movl rPC, OUT_ARG0(%esp)
13976 movl %eax, OUT_ARG1(%esp)
13977 call dvmCheckInst # (dPC, self)
13979 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
13980 jmp *dvmAsmInstructionStart+(148*4)
13982 /* ------------------------------ */
13983 .L_ALT_OP_AND_INT: /* 0x95 */
13984 /* File: x86/alt_stub.S */
13986 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
13987 * any interesting requests and then jump to the real instruction
13988 * handler. Unlike the Arm handler, we can't do this as a tail call
13989 * because rIBASE is caller save and we need to reload it.
13992 movl rPC, OUT_ARG0(%esp)
13993 movl %eax, OUT_ARG1(%esp)
13994 call dvmCheckInst # (dPC, self)
13996 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
13997 jmp *dvmAsmInstructionStart+(149*4)
13999 /* ------------------------------ */
14000 .L_ALT_OP_OR_INT: /* 0x96 */
14001 /* File: x86/alt_stub.S */
14003 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
14004 * any interesting requests and then jump to the real instruction
14005 * handler. Unlike the Arm handler, we can't do this as a tail call
14006 * because rIBASE is caller save and we need to reload it.
14009 movl rPC, OUT_ARG0(%esp)
14010 movl %eax, OUT_ARG1(%esp)
14011 call dvmCheckInst # (dPC, self)
14013 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
14014 jmp *dvmAsmInstructionStart+(150*4)
14016 /* ------------------------------ */
14017 .L_ALT_OP_XOR_INT: /* 0x97 */
14018 /* File: x86/alt_stub.S */
14020 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
14021 * any interesting requests and then jump to the real instruction
14022 * handler. Unlike the Arm handler, we can't do this as a tail call
14023 * because rIBASE is caller save and we need to reload it.
14026 movl rPC, OUT_ARG0(%esp)
14027 movl %eax, OUT_ARG1(%esp)
14028 call dvmCheckInst # (dPC, self)
14030 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
14031 jmp *dvmAsmInstructionStart+(151*4)
14033 /* ------------------------------ */
14034 .L_ALT_OP_SHL_INT: /* 0x98 */
14035 /* File: x86/alt_stub.S */
14037 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
14038 * any interesting requests and then jump to the real instruction
14039 * handler. Unlike the Arm handler, we can't do this as a tail call
14040 * because rIBASE is caller save and we need to reload it.
14043 movl rPC, OUT_ARG0(%esp)
14044 movl %eax, OUT_ARG1(%esp)
14045 call dvmCheckInst # (dPC, self)
14047 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
14048 jmp *dvmAsmInstructionStart+(152*4)
14050 /* ------------------------------ */
14051 .L_ALT_OP_SHR_INT: /* 0x99 */
14052 /* File: x86/alt_stub.S */
14054 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
14055 * any interesting requests and then jump to the real instruction
14056 * handler. Unlike the Arm handler, we can't do this as a tail call
14057 * because rIBASE is caller save and we need to reload it.
14060 movl rPC, OUT_ARG0(%esp)
14061 movl %eax, OUT_ARG1(%esp)
14062 call dvmCheckInst # (dPC, self)
14064 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
14065 jmp *dvmAsmInstructionStart+(153*4)
14067 /* ------------------------------ */
14068 .L_ALT_OP_USHR_INT: /* 0x9a */
14069 /* File: x86/alt_stub.S */
14071 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
14072 * any interesting requests and then jump to the real instruction
14073 * handler. Unlike the Arm handler, we can't do this as a tail call
14074 * because rIBASE is caller save and we need to reload it.
14077 movl rPC, OUT_ARG0(%esp)
14078 movl %eax, OUT_ARG1(%esp)
14079 call dvmCheckInst # (dPC, self)
14081 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
14082 jmp *dvmAsmInstructionStart+(154*4)
14084 /* ------------------------------ */
14085 .L_ALT_OP_ADD_LONG: /* 0x9b */
14086 /* File: x86/alt_stub.S */
14088 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
14089 * any interesting requests and then jump to the real instruction
14090 * handler. Unlike the Arm handler, we can't do this as a tail call
14091 * because rIBASE is caller save and we need to reload it.
14094 movl rPC, OUT_ARG0(%esp)
14095 movl %eax, OUT_ARG1(%esp)
14096 call dvmCheckInst # (dPC, self)
14098 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
14099 jmp *dvmAsmInstructionStart+(155*4)
14101 /* ------------------------------ */
14102 .L_ALT_OP_SUB_LONG: /* 0x9c */
14103 /* File: x86/alt_stub.S */
14105 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
14106 * any interesting requests and then jump to the real instruction
14107 * handler. Unlike the Arm handler, we can't do this as a tail call
14108 * because rIBASE is caller save and we need to reload it.
14111 movl rPC, OUT_ARG0(%esp)
14112 movl %eax, OUT_ARG1(%esp)
14113 call dvmCheckInst # (dPC, self)
14115 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
14116 jmp *dvmAsmInstructionStart+(156*4)
14118 /* ------------------------------ */
14119 .L_ALT_OP_MUL_LONG: /* 0x9d */
14120 /* File: x86/alt_stub.S */
14122 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
14123 * any interesting requests and then jump to the real instruction
14124 * handler. Unlike the Arm handler, we can't do this as a tail call
14125 * because rIBASE is caller save and we need to reload it.
14128 movl rPC, OUT_ARG0(%esp)
14129 movl %eax, OUT_ARG1(%esp)
14130 call dvmCheckInst # (dPC, self)
14132 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
14133 jmp *dvmAsmInstructionStart+(157*4)
14135 /* ------------------------------ */
14136 .L_ALT_OP_DIV_LONG: /* 0x9e */
14137 /* File: x86/alt_stub.S */
14139 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
14140 * any interesting requests and then jump to the real instruction
14141 * handler. Unlike the Arm handler, we can't do this as a tail call
14142 * because rIBASE is caller save and we need to reload it.
14145 movl rPC, OUT_ARG0(%esp)
14146 movl %eax, OUT_ARG1(%esp)
14147 call dvmCheckInst # (dPC, self)
14149 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
14150 jmp *dvmAsmInstructionStart+(158*4)
14152 /* ------------------------------ */
14153 .L_ALT_OP_REM_LONG: /* 0x9f */
14154 /* File: x86/alt_stub.S */
14156 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
14157 * any interesting requests and then jump to the real instruction
14158 * handler. Unlike the Arm handler, we can't do this as a tail call
14159 * because rIBASE is caller save and we need to reload it.
14162 movl rPC, OUT_ARG0(%esp)
14163 movl %eax, OUT_ARG1(%esp)
14164 call dvmCheckInst # (dPC, self)
14166 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
14167 jmp *dvmAsmInstructionStart+(159*4)
14169 /* ------------------------------ */
14170 .L_ALT_OP_AND_LONG: /* 0xa0 */
14171 /* File: x86/alt_stub.S */
14173 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
14174 * any interesting requests and then jump to the real instruction
14175 * handler. Unlike the Arm handler, we can't do this as a tail call
14176 * because rIBASE is caller save and we need to reload it.
14179 movl rPC, OUT_ARG0(%esp)
14180 movl %eax, OUT_ARG1(%esp)
14181 call dvmCheckInst # (dPC, self)
14183 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
14184 jmp *dvmAsmInstructionStart+(160*4)
14186 /* ------------------------------ */
14187 .L_ALT_OP_OR_LONG: /* 0xa1 */
14188 /* File: x86/alt_stub.S */
14190 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
14191 * any interesting requests and then jump to the real instruction
14192 * handler. Unlike the Arm handler, we can't do this as a tail call
14193 * because rIBASE is caller save and we need to reload it.
14196 movl rPC, OUT_ARG0(%esp)
14197 movl %eax, OUT_ARG1(%esp)
14198 call dvmCheckInst # (dPC, self)
14200 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
14201 jmp *dvmAsmInstructionStart+(161*4)
14203 /* ------------------------------ */
14204 .L_ALT_OP_XOR_LONG: /* 0xa2 */
14205 /* File: x86/alt_stub.S */
14207 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
14208 * any interesting requests and then jump to the real instruction
14209 * handler. Unlike the Arm handler, we can't do this as a tail call
14210 * because rIBASE is caller save and we need to reload it.
14213 movl rPC, OUT_ARG0(%esp)
14214 movl %eax, OUT_ARG1(%esp)
14215 call dvmCheckInst # (dPC, self)
14217 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
14218 jmp *dvmAsmInstructionStart+(162*4)
14220 /* ------------------------------ */
14221 .L_ALT_OP_SHL_LONG: /* 0xa3 */
14222 /* File: x86/alt_stub.S */
14224 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
14225 * any interesting requests and then jump to the real instruction
14226 * handler. Unlike the Arm handler, we can't do this as a tail call
14227 * because rIBASE is caller save and we need to reload it.
14230 movl rPC, OUT_ARG0(%esp)
14231 movl %eax, OUT_ARG1(%esp)
14232 call dvmCheckInst # (dPC, self)
14234 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
14235 jmp *dvmAsmInstructionStart+(163*4)
14237 /* ------------------------------ */
14238 .L_ALT_OP_SHR_LONG: /* 0xa4 */
14239 /* File: x86/alt_stub.S */
14241 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
14242 * any interesting requests and then jump to the real instruction
14243 * handler. Unlike the Arm handler, we can't do this as a tail call
14244 * because rIBASE is caller save and we need to reload it.
14247 movl rPC, OUT_ARG0(%esp)
14248 movl %eax, OUT_ARG1(%esp)
14249 call dvmCheckInst # (dPC, self)
14251 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
14252 jmp *dvmAsmInstructionStart+(164*4)
14254 /* ------------------------------ */
14255 .L_ALT_OP_USHR_LONG: /* 0xa5 */
14256 /* File: x86/alt_stub.S */
14258 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
14259 * any interesting requests and then jump to the real instruction
14260 * handler. Unlike the Arm handler, we can't do this as a tail call
14261 * because rIBASE is caller save and we need to reload it.
14264 movl rPC, OUT_ARG0(%esp)
14265 movl %eax, OUT_ARG1(%esp)
14266 call dvmCheckInst # (dPC, self)
14268 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
14269 jmp *dvmAsmInstructionStart+(165*4)
14271 /* ------------------------------ */
14272 .L_ALT_OP_ADD_FLOAT: /* 0xa6 */
14273 /* File: x86/alt_stub.S */
14275 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
14276 * any interesting requests and then jump to the real instruction
14277 * handler. Unlike the Arm handler, we can't do this as a tail call
14278 * because rIBASE is caller save and we need to reload it.
14281 movl rPC, OUT_ARG0(%esp)
14282 movl %eax, OUT_ARG1(%esp)
14283 call dvmCheckInst # (dPC, self)
14285 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
14286 jmp *dvmAsmInstructionStart+(166*4)
14288 /* ------------------------------ */
14289 .L_ALT_OP_SUB_FLOAT: /* 0xa7 */
14290 /* File: x86/alt_stub.S */
14292 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
14293 * any interesting requests and then jump to the real instruction
14294 * handler. Unlike the Arm handler, we can't do this as a tail call
14295 * because rIBASE is caller save and we need to reload it.
14298 movl rPC, OUT_ARG0(%esp)
14299 movl %eax, OUT_ARG1(%esp)
14300 call dvmCheckInst # (dPC, self)
14302 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
14303 jmp *dvmAsmInstructionStart+(167*4)
14305 /* ------------------------------ */
14306 .L_ALT_OP_MUL_FLOAT: /* 0xa8 */
14307 /* File: x86/alt_stub.S */
14309 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
14310 * any interesting requests and then jump to the real instruction
14311 * handler. Unlike the Arm handler, we can't do this as a tail call
14312 * because rIBASE is caller save and we need to reload it.
14315 movl rPC, OUT_ARG0(%esp)
14316 movl %eax, OUT_ARG1(%esp)
14317 call dvmCheckInst # (dPC, self)
14319 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
14320 jmp *dvmAsmInstructionStart+(168*4)
14322 /* ------------------------------ */
14323 .L_ALT_OP_DIV_FLOAT: /* 0xa9 */
14324 /* File: x86/alt_stub.S */
14326 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
14327 * any interesting requests and then jump to the real instruction
14328 * handler. Unlike the Arm handler, we can't do this as a tail call
14329 * because rIBASE is caller save and we need to reload it.
14332 movl rPC, OUT_ARG0(%esp)
14333 movl %eax, OUT_ARG1(%esp)
14334 call dvmCheckInst # (dPC, self)
14336 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
14337 jmp *dvmAsmInstructionStart+(169*4)
14339 /* ------------------------------ */
14340 .L_ALT_OP_REM_FLOAT: /* 0xaa */
14341 /* File: x86/alt_stub.S */
14343 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
14344 * any interesting requests and then jump to the real instruction
14345 * handler. Unlike the Arm handler, we can't do this as a tail call
14346 * because rIBASE is caller save and we need to reload it.
14349 movl rPC, OUT_ARG0(%esp)
14350 movl %eax, OUT_ARG1(%esp)
14351 call dvmCheckInst # (dPC, self)
14353 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
14354 jmp *dvmAsmInstructionStart+(170*4)
14356 /* ------------------------------ */
14357 .L_ALT_OP_ADD_DOUBLE: /* 0xab */
14358 /* File: x86/alt_stub.S */
14360 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
14361 * any interesting requests and then jump to the real instruction
14362 * handler. Unlike the Arm handler, we can't do this as a tail call
14363 * because rIBASE is caller save and we need to reload it.
14366 movl rPC, OUT_ARG0(%esp)
14367 movl %eax, OUT_ARG1(%esp)
14368 call dvmCheckInst # (dPC, self)
14370 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
14371 jmp *dvmAsmInstructionStart+(171*4)
14373 /* ------------------------------ */
14374 .L_ALT_OP_SUB_DOUBLE: /* 0xac */
14375 /* File: x86/alt_stub.S */
14377 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
14378 * any interesting requests and then jump to the real instruction
14379 * handler. Unlike the Arm handler, we can't do this as a tail call
14380 * because rIBASE is caller save and we need to reload it.
14383 movl rPC, OUT_ARG0(%esp)
14384 movl %eax, OUT_ARG1(%esp)
14385 call dvmCheckInst # (dPC, self)
14387 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
14388 jmp *dvmAsmInstructionStart+(172*4)
14390 /* ------------------------------ */
14391 .L_ALT_OP_MUL_DOUBLE: /* 0xad */
14392 /* File: x86/alt_stub.S */
14394 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
14395 * any interesting requests and then jump to the real instruction
14396 * handler. Unlike the Arm handler, we can't do this as a tail call
14397 * because rIBASE is caller save and we need to reload it.
14400 movl rPC, OUT_ARG0(%esp)
14401 movl %eax, OUT_ARG1(%esp)
14402 call dvmCheckInst # (dPC, self)
14404 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
14405 jmp *dvmAsmInstructionStart+(173*4)
14407 /* ------------------------------ */
14408 .L_ALT_OP_DIV_DOUBLE: /* 0xae */
14409 /* File: x86/alt_stub.S */
14411 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
14412 * any interesting requests and then jump to the real instruction
14413 * handler. Unlike the Arm handler, we can't do this as a tail call
14414 * because rIBASE is caller save and we need to reload it.
14417 movl rPC, OUT_ARG0(%esp)
14418 movl %eax, OUT_ARG1(%esp)
14419 call dvmCheckInst # (dPC, self)
14421 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
14422 jmp *dvmAsmInstructionStart+(174*4)
14424 /* ------------------------------ */
14425 .L_ALT_OP_REM_DOUBLE: /* 0xaf */
14426 /* File: x86/alt_stub.S */
14428 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
14429 * any interesting requests and then jump to the real instruction
14430 * handler. Unlike the Arm handler, we can't do this as a tail call
14431 * because rIBASE is caller save and we need to reload it.
14434 movl rPC, OUT_ARG0(%esp)
14435 movl %eax, OUT_ARG1(%esp)
14436 call dvmCheckInst # (dPC, self)
14438 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
14439 jmp *dvmAsmInstructionStart+(175*4)
14441 /* ------------------------------ */
14442 .L_ALT_OP_ADD_INT_2ADDR: /* 0xb0 */
14443 /* File: x86/alt_stub.S */
14445 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
14446 * any interesting requests and then jump to the real instruction
14447 * handler. Unlike the Arm handler, we can't do this as a tail call
14448 * because rIBASE is caller save and we need to reload it.
14451 movl rPC, OUT_ARG0(%esp)
14452 movl %eax, OUT_ARG1(%esp)
14453 call dvmCheckInst # (dPC, self)
14455 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
14456 jmp *dvmAsmInstructionStart+(176*4)
14458 /* ------------------------------ */
14459 .L_ALT_OP_SUB_INT_2ADDR: /* 0xb1 */
14460 /* File: x86/alt_stub.S */
14462 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
14463 * any interesting requests and then jump to the real instruction
14464 * handler. Unlike the Arm handler, we can't do this as a tail call
14465 * because rIBASE is caller save and we need to reload it.
14468 movl rPC, OUT_ARG0(%esp)
14469 movl %eax, OUT_ARG1(%esp)
14470 call dvmCheckInst # (dPC, self)
14472 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
14473 jmp *dvmAsmInstructionStart+(177*4)
14475 /* ------------------------------ */
14476 .L_ALT_OP_MUL_INT_2ADDR: /* 0xb2 */
14477 /* File: x86/alt_stub.S */
14479 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
14480 * any interesting requests and then jump to the real instruction
14481 * handler. Unlike the Arm handler, we can't do this as a tail call
14482 * because rIBASE is caller save and we need to reload it.
14485 movl rPC, OUT_ARG0(%esp)
14486 movl %eax, OUT_ARG1(%esp)
14487 call dvmCheckInst # (dPC, self)
14489 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
14490 jmp *dvmAsmInstructionStart+(178*4)
14492 /* ------------------------------ */
14493 .L_ALT_OP_DIV_INT_2ADDR: /* 0xb3 */
14494 /* File: x86/alt_stub.S */
14496 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
14497 * any interesting requests and then jump to the real instruction
14498 * handler. Unlike the Arm handler, we can't do this as a tail call
14499 * because rIBASE is caller save and we need to reload it.
14502 movl rPC, OUT_ARG0(%esp)
14503 movl %eax, OUT_ARG1(%esp)
14504 call dvmCheckInst # (dPC, self)
14506 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
14507 jmp *dvmAsmInstructionStart+(179*4)
14509 /* ------------------------------ */
14510 .L_ALT_OP_REM_INT_2ADDR: /* 0xb4 */
14511 /* File: x86/alt_stub.S */
14513 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
14514 * any interesting requests and then jump to the real instruction
14515 * handler. Unlike the Arm handler, we can't do this as a tail call
14516 * because rIBASE is caller save and we need to reload it.
14519 movl rPC, OUT_ARG0(%esp)
14520 movl %eax, OUT_ARG1(%esp)
14521 call dvmCheckInst # (dPC, self)
14523 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
14524 jmp *dvmAsmInstructionStart+(180*4)
14526 /* ------------------------------ */
14527 .L_ALT_OP_AND_INT_2ADDR: /* 0xb5 */
14528 /* File: x86/alt_stub.S */
14530 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
14531 * any interesting requests and then jump to the real instruction
14532 * handler. Unlike the Arm handler, we can't do this as a tail call
14533 * because rIBASE is caller save and we need to reload it.
14536 movl rPC, OUT_ARG0(%esp)
14537 movl %eax, OUT_ARG1(%esp)
14538 call dvmCheckInst # (dPC, self)
14540 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
14541 jmp *dvmAsmInstructionStart+(181*4)
14543 /* ------------------------------ */
14544 .L_ALT_OP_OR_INT_2ADDR: /* 0xb6 */
14545 /* File: x86/alt_stub.S */
14547 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
14548 * any interesting requests and then jump to the real instruction
14549 * handler. Unlike the Arm handler, we can't do this as a tail call
14550 * because rIBASE is caller save and we need to reload it.
14553 movl rPC, OUT_ARG0(%esp)
14554 movl %eax, OUT_ARG1(%esp)
14555 call dvmCheckInst # (dPC, self)
14557 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
14558 jmp *dvmAsmInstructionStart+(182*4)
14560 /* ------------------------------ */
14561 .L_ALT_OP_XOR_INT_2ADDR: /* 0xb7 */
14562 /* File: x86/alt_stub.S */
14564 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
14565 * any interesting requests and then jump to the real instruction
14566 * handler. Unlike the Arm handler, we can't do this as a tail call
14567 * because rIBASE is caller save and we need to reload it.
14570 movl rPC, OUT_ARG0(%esp)
14571 movl %eax, OUT_ARG1(%esp)
14572 call dvmCheckInst # (dPC, self)
14574 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
14575 jmp *dvmAsmInstructionStart+(183*4)
14577 /* ------------------------------ */
14578 .L_ALT_OP_SHL_INT_2ADDR: /* 0xb8 */
14579 /* File: x86/alt_stub.S */
14581 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
14582 * any interesting requests and then jump to the real instruction
14583 * handler. Unlike the Arm handler, we can't do this as a tail call
14584 * because rIBASE is caller save and we need to reload it.
14587 movl rPC, OUT_ARG0(%esp)
14588 movl %eax, OUT_ARG1(%esp)
14589 call dvmCheckInst # (dPC, self)
14591 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
14592 jmp *dvmAsmInstructionStart+(184*4)
14594 /* ------------------------------ */
14595 .L_ALT_OP_SHR_INT_2ADDR: /* 0xb9 */
14596 /* File: x86/alt_stub.S */
14598 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
14599 * any interesting requests and then jump to the real instruction
14600 * handler. Unlike the Arm handler, we can't do this as a tail call
14601 * because rIBASE is caller save and we need to reload it.
14604 movl rPC, OUT_ARG0(%esp)
14605 movl %eax, OUT_ARG1(%esp)
14606 call dvmCheckInst # (dPC, self)
14608 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
14609 jmp *dvmAsmInstructionStart+(185*4)
14611 /* ------------------------------ */
14612 .L_ALT_OP_USHR_INT_2ADDR: /* 0xba */
14613 /* File: x86/alt_stub.S */
14615 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
14616 * any interesting requests and then jump to the real instruction
14617 * handler. Unlike the Arm handler, we can't do this as a tail call
14618 * because rIBASE is caller save and we need to reload it.
14621 movl rPC, OUT_ARG0(%esp)
14622 movl %eax, OUT_ARG1(%esp)
14623 call dvmCheckInst # (dPC, self)
14625 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
14626 jmp *dvmAsmInstructionStart+(186*4)
14628 /* ------------------------------ */
14629 .L_ALT_OP_ADD_LONG_2ADDR: /* 0xbb */
14630 /* File: x86/alt_stub.S */
14632 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
14633 * any interesting requests and then jump to the real instruction
14634 * handler. Unlike the Arm handler, we can't do this as a tail call
14635 * because rIBASE is caller save and we need to reload it.
14638 movl rPC, OUT_ARG0(%esp)
14639 movl %eax, OUT_ARG1(%esp)
14640 call dvmCheckInst # (dPC, self)
14642 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
14643 jmp *dvmAsmInstructionStart+(187*4)
14645 /* ------------------------------ */
14646 .L_ALT_OP_SUB_LONG_2ADDR: /* 0xbc */
14647 /* File: x86/alt_stub.S */
14649 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
14650 * any interesting requests and then jump to the real instruction
14651 * handler. Unlike the Arm handler, we can't do this as a tail call
14652 * because rIBASE is caller save and we need to reload it.
14655 movl rPC, OUT_ARG0(%esp)
14656 movl %eax, OUT_ARG1(%esp)
14657 call dvmCheckInst # (dPC, self)
14659 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
14660 jmp *dvmAsmInstructionStart+(188*4)
14662 /* ------------------------------ */
14663 .L_ALT_OP_MUL_LONG_2ADDR: /* 0xbd */
14664 /* File: x86/alt_stub.S */
14666 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
14667 * any interesting requests and then jump to the real instruction
14668 * handler. Unlike the Arm handler, we can't do this as a tail call
14669 * because rIBASE is caller save and we need to reload it.
14672 movl rPC, OUT_ARG0(%esp)
14673 movl %eax, OUT_ARG1(%esp)
14674 call dvmCheckInst # (dPC, self)
14676 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
14677 jmp *dvmAsmInstructionStart+(189*4)
14679 /* ------------------------------ */
14680 .L_ALT_OP_DIV_LONG_2ADDR: /* 0xbe */
14681 /* File: x86/alt_stub.S */
14683 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
14684 * any interesting requests and then jump to the real instruction
14685 * handler. Unlike the Arm handler, we can't do this as a tail call
14686 * because rIBASE is caller save and we need to reload it.
14689 movl rPC, OUT_ARG0(%esp)
14690 movl %eax, OUT_ARG1(%esp)
14691 call dvmCheckInst # (dPC, self)
14693 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
14694 jmp *dvmAsmInstructionStart+(190*4)
14696 /* ------------------------------ */
14697 .L_ALT_OP_REM_LONG_2ADDR: /* 0xbf */
14698 /* File: x86/alt_stub.S */
14700 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
14701 * any interesting requests and then jump to the real instruction
14702 * handler. Unlike the Arm handler, we can't do this as a tail call
14703 * because rIBASE is caller save and we need to reload it.
14706 movl rPC, OUT_ARG0(%esp)
14707 movl %eax, OUT_ARG1(%esp)
14708 call dvmCheckInst # (dPC, self)
14710 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
14711 jmp *dvmAsmInstructionStart+(191*4)
14713 /* ------------------------------ */
14714 .L_ALT_OP_AND_LONG_2ADDR: /* 0xc0 */
14715 /* File: x86/alt_stub.S */
14717 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
14718 * any interesting requests and then jump to the real instruction
14719 * handler. Unlike the Arm handler, we can't do this as a tail call
14720 * because rIBASE is caller save and we need to reload it.
14723 movl rPC, OUT_ARG0(%esp)
14724 movl %eax, OUT_ARG1(%esp)
14725 call dvmCheckInst # (dPC, self)
14727 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
14728 jmp *dvmAsmInstructionStart+(192*4)
14730 /* ------------------------------ */
14731 .L_ALT_OP_OR_LONG_2ADDR: /* 0xc1 */
14732 /* File: x86/alt_stub.S */
14734 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
14735 * any interesting requests and then jump to the real instruction
14736 * handler. Unlike the Arm handler, we can't do this as a tail call
14737 * because rIBASE is caller save and we need to reload it.
14740 movl rPC, OUT_ARG0(%esp)
14741 movl %eax, OUT_ARG1(%esp)
14742 call dvmCheckInst # (dPC, self)
14744 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
14745 jmp *dvmAsmInstructionStart+(193*4)
14747 /* ------------------------------ */
14748 .L_ALT_OP_XOR_LONG_2ADDR: /* 0xc2 */
14749 /* File: x86/alt_stub.S */
14751 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
14752 * any interesting requests and then jump to the real instruction
14753 * handler. Unlike the Arm handler, we can't do this as a tail call
14754 * because rIBASE is caller save and we need to reload it.
14757 movl rPC, OUT_ARG0(%esp)
14758 movl %eax, OUT_ARG1(%esp)
14759 call dvmCheckInst # (dPC, self)
14761 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
14762 jmp *dvmAsmInstructionStart+(194*4)
14764 /* ------------------------------ */
14765 .L_ALT_OP_SHL_LONG_2ADDR: /* 0xc3 */
14766 /* File: x86/alt_stub.S */
14768 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
14769 * any interesting requests and then jump to the real instruction
14770 * handler. Unlike the Arm handler, we can't do this as a tail call
14771 * because rIBASE is caller save and we need to reload it.
14774 movl rPC, OUT_ARG0(%esp)
14775 movl %eax, OUT_ARG1(%esp)
14776 call dvmCheckInst # (dPC, self)
14778 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
14779 jmp *dvmAsmInstructionStart+(195*4)
14781 /* ------------------------------ */
14782 .L_ALT_OP_SHR_LONG_2ADDR: /* 0xc4 */
14783 /* File: x86/alt_stub.S */
14785 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
14786 * any interesting requests and then jump to the real instruction
14787 * handler. Unlike the Arm handler, we can't do this as a tail call
14788 * because rIBASE is caller save and we need to reload it.
14791 movl rPC, OUT_ARG0(%esp)
14792 movl %eax, OUT_ARG1(%esp)
14793 call dvmCheckInst # (dPC, self)
14795 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
14796 jmp *dvmAsmInstructionStart+(196*4)
14798 /* ------------------------------ */
14799 .L_ALT_OP_USHR_LONG_2ADDR: /* 0xc5 */
14800 /* File: x86/alt_stub.S */
14802 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
14803 * any interesting requests and then jump to the real instruction
14804 * handler. Unlike the Arm handler, we can't do this as a tail call
14805 * because rIBASE is caller save and we need to reload it.
14808 movl rPC, OUT_ARG0(%esp)
14809 movl %eax, OUT_ARG1(%esp)
14810 call dvmCheckInst # (dPC, self)
14812 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
14813 jmp *dvmAsmInstructionStart+(197*4)
14815 /* ------------------------------ */
14816 .L_ALT_OP_ADD_FLOAT_2ADDR: /* 0xc6 */
14817 /* File: x86/alt_stub.S */
14819 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
14820 * any interesting requests and then jump to the real instruction
14821 * handler. Unlike the Arm handler, we can't do this as a tail call
14822 * because rIBASE is caller save and we need to reload it.
14825 movl rPC, OUT_ARG0(%esp)
14826 movl %eax, OUT_ARG1(%esp)
14827 call dvmCheckInst # (dPC, self)
14829 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
14830 jmp *dvmAsmInstructionStart+(198*4)
14832 /* ------------------------------ */
14833 .L_ALT_OP_SUB_FLOAT_2ADDR: /* 0xc7 */
14834 /* File: x86/alt_stub.S */
14836 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
14837 * any interesting requests and then jump to the real instruction
14838 * handler. Unlike the Arm handler, we can't do this as a tail call
14839 * because rIBASE is caller save and we need to reload it.
14842 movl rPC, OUT_ARG0(%esp)
14843 movl %eax, OUT_ARG1(%esp)
14844 call dvmCheckInst # (dPC, self)
14846 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
14847 jmp *dvmAsmInstructionStart+(199*4)
14849 /* ------------------------------ */
14850 .L_ALT_OP_MUL_FLOAT_2ADDR: /* 0xc8 */
14851 /* File: x86/alt_stub.S */
14853 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
14854 * any interesting requests and then jump to the real instruction
14855 * handler. Unlike the Arm handler, we can't do this as a tail call
14856 * because rIBASE is caller save and we need to reload it.
14859 movl rPC, OUT_ARG0(%esp)
14860 movl %eax, OUT_ARG1(%esp)
14861 call dvmCheckInst # (dPC, self)
14863 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
14864 jmp *dvmAsmInstructionStart+(200*4)
14866 /* ------------------------------ */
14867 .L_ALT_OP_DIV_FLOAT_2ADDR: /* 0xc9 */
14868 /* File: x86/alt_stub.S */
14870 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
14871 * any interesting requests and then jump to the real instruction
14872 * handler. Unlike the Arm handler, we can't do this as a tail call
14873 * because rIBASE is caller save and we need to reload it.
14876 movl rPC, OUT_ARG0(%esp)
14877 movl %eax, OUT_ARG1(%esp)
14878 call dvmCheckInst # (dPC, self)
14880 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
14881 jmp *dvmAsmInstructionStart+(201*4)
14883 /* ------------------------------ */
14884 .L_ALT_OP_REM_FLOAT_2ADDR: /* 0xca */
14885 /* File: x86/alt_stub.S */
14887 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
14888 * any interesting requests and then jump to the real instruction
14889 * handler. Unlike the Arm handler, we can't do this as a tail call
14890 * because rIBASE is caller save and we need to reload it.
14893 movl rPC, OUT_ARG0(%esp)
14894 movl %eax, OUT_ARG1(%esp)
14895 call dvmCheckInst # (dPC, self)
14897 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
14898 jmp *dvmAsmInstructionStart+(202*4)
14900 /* ------------------------------ */
14901 .L_ALT_OP_ADD_DOUBLE_2ADDR: /* 0xcb */
14902 /* File: x86/alt_stub.S */
14904 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
14905 * any interesting requests and then jump to the real instruction
14906 * handler. Unlike the Arm handler, we can't do this as a tail call
14907 * because rIBASE is caller save and we need to reload it.
14910 movl rPC, OUT_ARG0(%esp)
14911 movl %eax, OUT_ARG1(%esp)
14912 call dvmCheckInst # (dPC, self)
14914 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
14915 jmp *dvmAsmInstructionStart+(203*4)
14917 /* ------------------------------ */
14918 .L_ALT_OP_SUB_DOUBLE_2ADDR: /* 0xcc */
14919 /* File: x86/alt_stub.S */
14921 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
14922 * any interesting requests and then jump to the real instruction
14923 * handler. Unlike the Arm handler, we can't do this as a tail call
14924 * because rIBASE is caller save and we need to reload it.
14927 movl rPC, OUT_ARG0(%esp)
14928 movl %eax, OUT_ARG1(%esp)
14929 call dvmCheckInst # (dPC, self)
14931 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
14932 jmp *dvmAsmInstructionStart+(204*4)
14934 /* ------------------------------ */
14935 .L_ALT_OP_MUL_DOUBLE_2ADDR: /* 0xcd */
14936 /* File: x86/alt_stub.S */
14938 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
14939 * any interesting requests and then jump to the real instruction
14940 * handler. Unlike the Arm handler, we can't do this as a tail call
14941 * because rIBASE is caller save and we need to reload it.
14944 movl rPC, OUT_ARG0(%esp)
14945 movl %eax, OUT_ARG1(%esp)
14946 call dvmCheckInst # (dPC, self)
14948 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
14949 jmp *dvmAsmInstructionStart+(205*4)
14951 /* ------------------------------ */
14952 .L_ALT_OP_DIV_DOUBLE_2ADDR: /* 0xce */
14953 /* File: x86/alt_stub.S */
14955 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
14956 * any interesting requests and then jump to the real instruction
14957 * handler. Unlike the Arm handler, we can't do this as a tail call
14958 * because rIBASE is caller save and we need to reload it.
14961 movl rPC, OUT_ARG0(%esp)
14962 movl %eax, OUT_ARG1(%esp)
14963 call dvmCheckInst # (dPC, self)
14965 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
14966 jmp *dvmAsmInstructionStart+(206*4)
14968 /* ------------------------------ */
14969 .L_ALT_OP_REM_DOUBLE_2ADDR: /* 0xcf */
14970 /* File: x86/alt_stub.S */
14972 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
14973 * any interesting requests and then jump to the real instruction
14974 * handler. Unlike the Arm handler, we can't do this as a tail call
14975 * because rIBASE is caller save and we need to reload it.
14978 movl rPC, OUT_ARG0(%esp)
14979 movl %eax, OUT_ARG1(%esp)
14980 call dvmCheckInst # (dPC, self)
14982 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
14983 jmp *dvmAsmInstructionStart+(207*4)
14985 /* ------------------------------ */
14986 .L_ALT_OP_ADD_INT_LIT16: /* 0xd0 */
14987 /* File: x86/alt_stub.S */
14989 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
14990 * any interesting requests and then jump to the real instruction
14991 * handler. Unlike the Arm handler, we can't do this as a tail call
14992 * because rIBASE is caller save and we need to reload it.
14995 movl rPC, OUT_ARG0(%esp)
14996 movl %eax, OUT_ARG1(%esp)
14997 call dvmCheckInst # (dPC, self)
14999 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
15000 jmp *dvmAsmInstructionStart+(208*4)
15002 /* ------------------------------ */
15003 .L_ALT_OP_RSUB_INT: /* 0xd1 */
15004 /* File: x86/alt_stub.S */
15006 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
15007 * any interesting requests and then jump to the real instruction
15008 * handler. Unlike the Arm handler, we can't do this as a tail call
15009 * because rIBASE is caller save and we need to reload it.
15012 movl rPC, OUT_ARG0(%esp)
15013 movl %eax, OUT_ARG1(%esp)
15014 call dvmCheckInst # (dPC, self)
15016 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
15017 jmp *dvmAsmInstructionStart+(209*4)
15019 /* ------------------------------ */
15020 .L_ALT_OP_MUL_INT_LIT16: /* 0xd2 */
15021 /* File: x86/alt_stub.S */
15023 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
15024 * any interesting requests and then jump to the real instruction
15025 * handler. Unlike the Arm handler, we can't do this as a tail call
15026 * because rIBASE is caller save and we need to reload it.
15029 movl rPC, OUT_ARG0(%esp)
15030 movl %eax, OUT_ARG1(%esp)
15031 call dvmCheckInst # (dPC, self)
15033 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
15034 jmp *dvmAsmInstructionStart+(210*4)
15036 /* ------------------------------ */
15037 .L_ALT_OP_DIV_INT_LIT16: /* 0xd3 */
15038 /* File: x86/alt_stub.S */
15040 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
15041 * any interesting requests and then jump to the real instruction
15042 * handler. Unlike the Arm handler, we can't do this as a tail call
15043 * because rIBASE is caller save and we need to reload it.
15046 movl rPC, OUT_ARG0(%esp)
15047 movl %eax, OUT_ARG1(%esp)
15048 call dvmCheckInst # (dPC, self)
15050 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
15051 jmp *dvmAsmInstructionStart+(211*4)
15053 /* ------------------------------ */
15054 .L_ALT_OP_REM_INT_LIT16: /* 0xd4 */
15055 /* File: x86/alt_stub.S */
15057 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
15058 * any interesting requests and then jump to the real instruction
15059 * handler. Unlike the Arm handler, we can't do this as a tail call
15060 * because rIBASE is caller save and we need to reload it.
15063 movl rPC, OUT_ARG0(%esp)
15064 movl %eax, OUT_ARG1(%esp)
15065 call dvmCheckInst # (dPC, self)
15067 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
15068 jmp *dvmAsmInstructionStart+(212*4)
15070 /* ------------------------------ */
15071 .L_ALT_OP_AND_INT_LIT16: /* 0xd5 */
15072 /* File: x86/alt_stub.S */
15074 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
15075 * any interesting requests and then jump to the real instruction
15076 * handler. Unlike the Arm handler, we can't do this as a tail call
15077 * because rIBASE is caller save and we need to reload it.
15080 movl rPC, OUT_ARG0(%esp)
15081 movl %eax, OUT_ARG1(%esp)
15082 call dvmCheckInst # (dPC, self)
15084 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
15085 jmp *dvmAsmInstructionStart+(213*4)
15087 /* ------------------------------ */
15088 .L_ALT_OP_OR_INT_LIT16: /* 0xd6 */
15089 /* File: x86/alt_stub.S */
15091 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
15092 * any interesting requests and then jump to the real instruction
15093 * handler. Unlike the Arm handler, we can't do this as a tail call
15094 * because rIBASE is caller save and we need to reload it.
15097 movl rPC, OUT_ARG0(%esp)
15098 movl %eax, OUT_ARG1(%esp)
15099 call dvmCheckInst # (dPC, self)
15101 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
15102 jmp *dvmAsmInstructionStart+(214*4)
15104 /* ------------------------------ */
15105 .L_ALT_OP_XOR_INT_LIT16: /* 0xd7 */
15106 /* File: x86/alt_stub.S */
15108 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
15109 * any interesting requests and then jump to the real instruction
15110 * handler. Unlike the Arm handler, we can't do this as a tail call
15111 * because rIBASE is caller save and we need to reload it.
15114 movl rPC, OUT_ARG0(%esp)
15115 movl %eax, OUT_ARG1(%esp)
15116 call dvmCheckInst # (dPC, self)
15118 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
15119 jmp *dvmAsmInstructionStart+(215*4)
15121 /* ------------------------------ */
15122 .L_ALT_OP_ADD_INT_LIT8: /* 0xd8 */
15123 /* File: x86/alt_stub.S */
15125 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
15126 * any interesting requests and then jump to the real instruction
15127 * handler. Unlike the Arm handler, we can't do this as a tail call
15128 * because rIBASE is caller save and we need to reload it.
15131 movl rPC, OUT_ARG0(%esp)
15132 movl %eax, OUT_ARG1(%esp)
15133 call dvmCheckInst # (dPC, self)
15135 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
15136 jmp *dvmAsmInstructionStart+(216*4)
15138 /* ------------------------------ */
15139 .L_ALT_OP_RSUB_INT_LIT8: /* 0xd9 */
15140 /* File: x86/alt_stub.S */
15142 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
15143 * any interesting requests and then jump to the real instruction
15144 * handler. Unlike the Arm handler, we can't do this as a tail call
15145 * because rIBASE is caller save and we need to reload it.
15148 movl rPC, OUT_ARG0(%esp)
15149 movl %eax, OUT_ARG1(%esp)
15150 call dvmCheckInst # (dPC, self)
15152 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
15153 jmp *dvmAsmInstructionStart+(217*4)
15155 /* ------------------------------ */
15156 .L_ALT_OP_MUL_INT_LIT8: /* 0xda */
15157 /* File: x86/alt_stub.S */
15159 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
15160 * any interesting requests and then jump to the real instruction
15161 * handler. Unlike the Arm handler, we can't do this as a tail call
15162 * because rIBASE is caller save and we need to reload it.
15165 movl rPC, OUT_ARG0(%esp)
15166 movl %eax, OUT_ARG1(%esp)
15167 call dvmCheckInst # (dPC, self)
15169 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
15170 jmp *dvmAsmInstructionStart+(218*4)
15172 /* ------------------------------ */
15173 .L_ALT_OP_DIV_INT_LIT8: /* 0xdb */
15174 /* File: x86/alt_stub.S */
15176 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
15177 * any interesting requests and then jump to the real instruction
15178 * handler. Unlike the Arm handler, we can't do this as a tail call
15179 * because rIBASE is caller save and we need to reload it.
15182 movl rPC, OUT_ARG0(%esp)
15183 movl %eax, OUT_ARG1(%esp)
15184 call dvmCheckInst # (dPC, self)
15186 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
15187 jmp *dvmAsmInstructionStart+(219*4)
15189 /* ------------------------------ */
15190 .L_ALT_OP_REM_INT_LIT8: /* 0xdc */
15191 /* File: x86/alt_stub.S */
15193 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
15194 * any interesting requests and then jump to the real instruction
15195 * handler. Unlike the Arm handler, we can't do this as a tail call
15196 * because rIBASE is caller save and we need to reload it.
15199 movl rPC, OUT_ARG0(%esp)
15200 movl %eax, OUT_ARG1(%esp)
15201 call dvmCheckInst # (dPC, self)
15203 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
15204 jmp *dvmAsmInstructionStart+(220*4)
15206 /* ------------------------------ */
15207 .L_ALT_OP_AND_INT_LIT8: /* 0xdd */
15208 /* File: x86/alt_stub.S */
15210 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
15211 * any interesting requests and then jump to the real instruction
15212 * handler. Unlike the Arm handler, we can't do this as a tail call
15213 * because rIBASE is caller save and we need to reload it.
15216 movl rPC, OUT_ARG0(%esp)
15217 movl %eax, OUT_ARG1(%esp)
15218 call dvmCheckInst # (dPC, self)
15220 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
15221 jmp *dvmAsmInstructionStart+(221*4)
15223 /* ------------------------------ */
15224 .L_ALT_OP_OR_INT_LIT8: /* 0xde */
15225 /* File: x86/alt_stub.S */
15227 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
15228 * any interesting requests and then jump to the real instruction
15229 * handler. Unlike the Arm handler, we can't do this as a tail call
15230 * because rIBASE is caller save and we need to reload it.
15233 movl rPC, OUT_ARG0(%esp)
15234 movl %eax, OUT_ARG1(%esp)
15235 call dvmCheckInst # (dPC, self)
15237 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
15238 jmp *dvmAsmInstructionStart+(222*4)
15240 /* ------------------------------ */
15241 .L_ALT_OP_XOR_INT_LIT8: /* 0xdf */
15242 /* File: x86/alt_stub.S */
15244 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
15245 * any interesting requests and then jump to the real instruction
15246 * handler. Unlike the Arm handler, we can't do this as a tail call
15247 * because rIBASE is caller save and we need to reload it.
15250 movl rPC, OUT_ARG0(%esp)
15251 movl %eax, OUT_ARG1(%esp)
15252 call dvmCheckInst # (dPC, self)
15254 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
15255 jmp *dvmAsmInstructionStart+(223*4)
15257 /* ------------------------------ */
15258 .L_ALT_OP_SHL_INT_LIT8: /* 0xe0 */
15259 /* File: x86/alt_stub.S */
15261 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
15262 * any interesting requests and then jump to the real instruction
15263 * handler. Unlike the Arm handler, we can't do this as a tail call
15264 * because rIBASE is caller save and we need to reload it.
15267 movl rPC, OUT_ARG0(%esp)
15268 movl %eax, OUT_ARG1(%esp)
15269 call dvmCheckInst # (dPC, self)
15271 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
15272 jmp *dvmAsmInstructionStart+(224*4)
15274 /* ------------------------------ */
15275 .L_ALT_OP_SHR_INT_LIT8: /* 0xe1 */
15276 /* File: x86/alt_stub.S */
15278 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
15279 * any interesting requests and then jump to the real instruction
15280 * handler. Unlike the Arm handler, we can't do this as a tail call
15281 * because rIBASE is caller save and we need to reload it.
15284 movl rPC, OUT_ARG0(%esp)
15285 movl %eax, OUT_ARG1(%esp)
15286 call dvmCheckInst # (dPC, self)
15288 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
15289 jmp *dvmAsmInstructionStart+(225*4)
15291 /* ------------------------------ */
15292 .L_ALT_OP_USHR_INT_LIT8: /* 0xe2 */
15293 /* File: x86/alt_stub.S */
15295 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
15296 * any interesting requests and then jump to the real instruction
15297 * handler. Unlike the Arm handler, we can't do this as a tail call
15298 * because rIBASE is caller save and we need to reload it.
15301 movl rPC, OUT_ARG0(%esp)
15302 movl %eax, OUT_ARG1(%esp)
15303 call dvmCheckInst # (dPC, self)
15305 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
15306 jmp *dvmAsmInstructionStart+(226*4)
15308 /* ------------------------------ */
15309 .L_ALT_OP_IGET_VOLATILE: /* 0xe3 */
15310 /* File: x86/alt_stub.S */
15312 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
15313 * any interesting requests and then jump to the real instruction
15314 * handler. Unlike the Arm handler, we can't do this as a tail call
15315 * because rIBASE is caller save and we need to reload it.
15318 movl rPC, OUT_ARG0(%esp)
15319 movl %eax, OUT_ARG1(%esp)
15320 call dvmCheckInst # (dPC, self)
15322 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
15323 jmp *dvmAsmInstructionStart+(227*4)
15325 /* ------------------------------ */
15326 .L_ALT_OP_IPUT_VOLATILE: /* 0xe4 */
15327 /* File: x86/alt_stub.S */
15329 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
15330 * any interesting requests and then jump to the real instruction
15331 * handler. Unlike the Arm handler, we can't do this as a tail call
15332 * because rIBASE is caller save and we need to reload it.
15335 movl rPC, OUT_ARG0(%esp)
15336 movl %eax, OUT_ARG1(%esp)
15337 call dvmCheckInst # (dPC, self)
15339 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
15340 jmp *dvmAsmInstructionStart+(228*4)
15342 /* ------------------------------ */
15343 .L_ALT_OP_SGET_VOLATILE: /* 0xe5 */
15344 /* File: x86/alt_stub.S */
15346 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
15347 * any interesting requests and then jump to the real instruction
15348 * handler. Unlike the Arm handler, we can't do this as a tail call
15349 * because rIBASE is caller save and we need to reload it.
15352 movl rPC, OUT_ARG0(%esp)
15353 movl %eax, OUT_ARG1(%esp)
15354 call dvmCheckInst # (dPC, self)
15356 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
15357 jmp *dvmAsmInstructionStart+(229*4)
15359 /* ------------------------------ */
15360 .L_ALT_OP_SPUT_VOLATILE: /* 0xe6 */
15361 /* File: x86/alt_stub.S */
15363 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
15364 * any interesting requests and then jump to the real instruction
15365 * handler. Unlike the Arm handler, we can't do this as a tail call
15366 * because rIBASE is caller save and we need to reload it.
15369 movl rPC, OUT_ARG0(%esp)
15370 movl %eax, OUT_ARG1(%esp)
15371 call dvmCheckInst # (dPC, self)
15373 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
15374 jmp *dvmAsmInstructionStart+(230*4)
15376 /* ------------------------------ */
15377 .L_ALT_OP_IGET_OBJECT_VOLATILE: /* 0xe7 */
15378 /* File: x86/alt_stub.S */
15380 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
15381 * any interesting requests and then jump to the real instruction
15382 * handler. Unlike the Arm handler, we can't do this as a tail call
15383 * because rIBASE is caller save and we need to reload it.
15386 movl rPC, OUT_ARG0(%esp)
15387 movl %eax, OUT_ARG1(%esp)
15388 call dvmCheckInst # (dPC, self)
15390 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
15391 jmp *dvmAsmInstructionStart+(231*4)
15393 /* ------------------------------ */
15394 .L_ALT_OP_IGET_WIDE_VOLATILE: /* 0xe8 */
15395 /* File: x86/alt_stub.S */
15397 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
15398 * any interesting requests and then jump to the real instruction
15399 * handler. Unlike the Arm handler, we can't do this as a tail call
15400 * because rIBASE is caller save and we need to reload it.
15403 movl rPC, OUT_ARG0(%esp)
15404 movl %eax, OUT_ARG1(%esp)
15405 call dvmCheckInst # (dPC, self)
15407 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
15408 jmp *dvmAsmInstructionStart+(232*4)
15410 /* ------------------------------ */
15411 .L_ALT_OP_IPUT_WIDE_VOLATILE: /* 0xe9 */
15412 /* File: x86/alt_stub.S */
15414 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
15415 * any interesting requests and then jump to the real instruction
15416 * handler. Unlike the Arm handler, we can't do this as a tail call
15417 * because rIBASE is caller save and we need to reload it.
15420 movl rPC, OUT_ARG0(%esp)
15421 movl %eax, OUT_ARG1(%esp)
15422 call dvmCheckInst # (dPC, self)
15424 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
15425 jmp *dvmAsmInstructionStart+(233*4)
15427 /* ------------------------------ */
15428 .L_ALT_OP_SGET_WIDE_VOLATILE: /* 0xea */
15429 /* File: x86/alt_stub.S */
15431 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
15432 * any interesting requests and then jump to the real instruction
15433 * handler. Unlike the Arm handler, we can't do this as a tail call
15434 * because rIBASE is caller save and we need to reload it.
15437 movl rPC, OUT_ARG0(%esp)
15438 movl %eax, OUT_ARG1(%esp)
15439 call dvmCheckInst # (dPC, self)
15441 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
15442 jmp *dvmAsmInstructionStart+(234*4)
15444 /* ------------------------------ */
15445 .L_ALT_OP_SPUT_WIDE_VOLATILE: /* 0xeb */
15446 /* File: x86/alt_stub.S */
15448 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
15449 * any interesting requests and then jump to the real instruction
15450 * handler. Unlike the Arm handler, we can't do this as a tail call
15451 * because rIBASE is caller save and we need to reload it.
15454 movl rPC, OUT_ARG0(%esp)
15455 movl %eax, OUT_ARG1(%esp)
15456 call dvmCheckInst # (dPC, self)
15458 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
15459 jmp *dvmAsmInstructionStart+(235*4)
15461 /* ------------------------------ */
15462 .L_ALT_OP_BREAKPOINT: /* 0xec */
15463 /* File: x86/alt_stub.S */
15465 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
15466 * any interesting requests and then jump to the real instruction
15467 * handler. Unlike the Arm handler, we can't do this as a tail call
15468 * because rIBASE is caller save and we need to reload it.
15471 movl rPC, OUT_ARG0(%esp)
15472 movl %eax, OUT_ARG1(%esp)
15473 call dvmCheckInst # (dPC, self)
15475 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
15476 jmp *dvmAsmInstructionStart+(236*4)
15478 /* ------------------------------ */
15479 .L_ALT_OP_THROW_VERIFICATION_ERROR: /* 0xed */
15480 /* File: x86/alt_stub.S */
15482 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
15483 * any interesting requests and then jump to the real instruction
15484 * handler. Unlike the Arm handler, we can't do this as a tail call
15485 * because rIBASE is caller save and we need to reload it.
15488 movl rPC, OUT_ARG0(%esp)
15489 movl %eax, OUT_ARG1(%esp)
15490 call dvmCheckInst # (dPC, self)
15492 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
15493 jmp *dvmAsmInstructionStart+(237*4)
15495 /* ------------------------------ */
15496 .L_ALT_OP_EXECUTE_INLINE: /* 0xee */
15497 /* File: x86/alt_stub.S */
15499 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
15500 * any interesting requests and then jump to the real instruction
15501 * handler. Unlike the Arm handler, we can't do this as a tail call
15502 * because rIBASE is caller save and we need to reload it.
15505 movl rPC, OUT_ARG0(%esp)
15506 movl %eax, OUT_ARG1(%esp)
15507 call dvmCheckInst # (dPC, self)
15509 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
15510 jmp *dvmAsmInstructionStart+(238*4)
15512 /* ------------------------------ */
15513 .L_ALT_OP_EXECUTE_INLINE_RANGE: /* 0xef */
15514 /* File: x86/alt_stub.S */
15516 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
15517 * any interesting requests and then jump to the real instruction
15518 * handler. Unlike the Arm handler, we can't do this as a tail call
15519 * because rIBASE is caller save and we need to reload it.
15522 movl rPC, OUT_ARG0(%esp)
15523 movl %eax, OUT_ARG1(%esp)
15524 call dvmCheckInst # (dPC, self)
15526 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
15527 jmp *dvmAsmInstructionStart+(239*4)
15529 /* ------------------------------ */
15530 .L_ALT_OP_INVOKE_OBJECT_INIT_RANGE: /* 0xf0 */
15531 /* File: x86/alt_stub.S */
15533 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
15534 * any interesting requests and then jump to the real instruction
15535 * handler. Unlike the Arm handler, we can't do this as a tail call
15536 * because rIBASE is caller save and we need to reload it.
15539 movl rPC, OUT_ARG0(%esp)
15540 movl %eax, OUT_ARG1(%esp)
15541 call dvmCheckInst # (dPC, self)
15543 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
15544 jmp *dvmAsmInstructionStart+(240*4)
15546 /* ------------------------------ */
15547 .L_ALT_OP_RETURN_VOID_BARRIER: /* 0xf1 */
15548 /* File: x86/alt_stub.S */
15550 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
15551 * any interesting requests and then jump to the real instruction
15552 * handler. Unlike the Arm handler, we can't do this as a tail call
15553 * because rIBASE is caller save and we need to reload it.
15556 movl rPC, OUT_ARG0(%esp)
15557 movl %eax, OUT_ARG1(%esp)
15558 call dvmCheckInst # (dPC, self)
15560 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
15561 jmp *dvmAsmInstructionStart+(241*4)
15563 /* ------------------------------ */
15564 .L_ALT_OP_IGET_QUICK: /* 0xf2 */
15565 /* File: x86/alt_stub.S */
15567 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
15568 * any interesting requests and then jump to the real instruction
15569 * handler. Unlike the Arm handler, we can't do this as a tail call
15570 * because rIBASE is caller save and we need to reload it.
15573 movl rPC, OUT_ARG0(%esp)
15574 movl %eax, OUT_ARG1(%esp)
15575 call dvmCheckInst # (dPC, self)
15577 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
15578 jmp *dvmAsmInstructionStart+(242*4)
15580 /* ------------------------------ */
15581 .L_ALT_OP_IGET_WIDE_QUICK: /* 0xf3 */
15582 /* File: x86/alt_stub.S */
15584 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
15585 * any interesting requests and then jump to the real instruction
15586 * handler. Unlike the Arm handler, we can't do this as a tail call
15587 * because rIBASE is caller save and we need to reload it.
15590 movl rPC, OUT_ARG0(%esp)
15591 movl %eax, OUT_ARG1(%esp)
15592 call dvmCheckInst # (dPC, self)
15594 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
15595 jmp *dvmAsmInstructionStart+(243*4)
15597 /* ------------------------------ */
15598 .L_ALT_OP_IGET_OBJECT_QUICK: /* 0xf4 */
15599 /* File: x86/alt_stub.S */
15601 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
15602 * any interesting requests and then jump to the real instruction
15603 * handler. Unlike the Arm handler, we can't do this as a tail call
15604 * because rIBASE is caller save and we need to reload it.
15607 movl rPC, OUT_ARG0(%esp)
15608 movl %eax, OUT_ARG1(%esp)
15609 call dvmCheckInst # (dPC, self)
15611 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
15612 jmp *dvmAsmInstructionStart+(244*4)
15614 /* ------------------------------ */
15615 .L_ALT_OP_IPUT_QUICK: /* 0xf5 */
15616 /* File: x86/alt_stub.S */
15618 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
15619 * any interesting requests and then jump to the real instruction
15620 * handler. Unlike the Arm handler, we can't do this as a tail call
15621 * because rIBASE is caller save and we need to reload it.
15624 movl rPC, OUT_ARG0(%esp)
15625 movl %eax, OUT_ARG1(%esp)
15626 call dvmCheckInst # (dPC, self)
15628 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
15629 jmp *dvmAsmInstructionStart+(245*4)
15631 /* ------------------------------ */
15632 .L_ALT_OP_IPUT_WIDE_QUICK: /* 0xf6 */
15633 /* File: x86/alt_stub.S */
15635 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
15636 * any interesting requests and then jump to the real instruction
15637 * handler. Unlike the Arm handler, we can't do this as a tail call
15638 * because rIBASE is caller save and we need to reload it.
15641 movl rPC, OUT_ARG0(%esp)
15642 movl %eax, OUT_ARG1(%esp)
15643 call dvmCheckInst # (dPC, self)
15645 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
15646 jmp *dvmAsmInstructionStart+(246*4)
15648 /* ------------------------------ */
15649 .L_ALT_OP_IPUT_OBJECT_QUICK: /* 0xf7 */
15650 /* File: x86/alt_stub.S */
15652 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
15653 * any interesting requests and then jump to the real instruction
15654 * handler. Unlike the Arm handler, we can't do this as a tail call
15655 * because rIBASE is caller save and we need to reload it.
15658 movl rPC, OUT_ARG0(%esp)
15659 movl %eax, OUT_ARG1(%esp)
15660 call dvmCheckInst # (dPC, self)
15662 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
15663 jmp *dvmAsmInstructionStart+(247*4)
15665 /* ------------------------------ */
15666 .L_ALT_OP_INVOKE_VIRTUAL_QUICK: /* 0xf8 */
15667 /* File: x86/alt_stub.S */
15669 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
15670 * any interesting requests and then jump to the real instruction
15671 * handler. Unlike the Arm handler, we can't do this as a tail call
15672 * because rIBASE is caller save and we need to reload it.
15675 movl rPC, OUT_ARG0(%esp)
15676 movl %eax, OUT_ARG1(%esp)
15677 call dvmCheckInst # (dPC, self)
15679 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
15680 jmp *dvmAsmInstructionStart+(248*4)
15682 /* ------------------------------ */
15683 .L_ALT_OP_INVOKE_VIRTUAL_QUICK_RANGE: /* 0xf9 */
15684 /* File: x86/alt_stub.S */
15686 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
15687 * any interesting requests and then jump to the real instruction
15688 * handler. Unlike the Arm handler, we can't do this as a tail call
15689 * because rIBASE is caller save and we need to reload it.
15692 movl rPC, OUT_ARG0(%esp)
15693 movl %eax, OUT_ARG1(%esp)
15694 call dvmCheckInst # (dPC, self)
15696 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
15697 jmp *dvmAsmInstructionStart+(249*4)
15699 /* ------------------------------ */
15700 .L_ALT_OP_INVOKE_SUPER_QUICK: /* 0xfa */
15701 /* File: x86/alt_stub.S */
15703 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
15704 * any interesting requests and then jump to the real instruction
15705 * handler. Unlike the Arm handler, we can't do this as a tail call
15706 * because rIBASE is caller save and we need to reload it.
15709 movl rPC, OUT_ARG0(%esp)
15710 movl %eax, OUT_ARG1(%esp)
15711 call dvmCheckInst # (dPC, self)
15713 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
15714 jmp *dvmAsmInstructionStart+(250*4)
15716 /* ------------------------------ */
15717 .L_ALT_OP_INVOKE_SUPER_QUICK_RANGE: /* 0xfb */
15718 /* File: x86/alt_stub.S */
15720 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
15721 * any interesting requests and then jump to the real instruction
15722 * handler. Unlike the Arm handler, we can't do this as a tail call
15723 * because rIBASE is caller save and we need to reload it.
15726 movl rPC, OUT_ARG0(%esp)
15727 movl %eax, OUT_ARG1(%esp)
15728 call dvmCheckInst # (dPC, self)
15730 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
15731 jmp *dvmAsmInstructionStart+(251*4)
15733 /* ------------------------------ */
15734 .L_ALT_OP_IPUT_OBJECT_VOLATILE: /* 0xfc */
15735 /* File: x86/alt_stub.S */
15737 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
15738 * any interesting requests and then jump to the real instruction
15739 * handler. Unlike the Arm handler, we can't do this as a tail call
15740 * because rIBASE is caller save and we need to reload it.
15743 movl rPC, OUT_ARG0(%esp)
15744 movl %eax, OUT_ARG1(%esp)
15745 call dvmCheckInst # (dPC, self)
15747 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
15748 jmp *dvmAsmInstructionStart+(252*4)
15750 /* ------------------------------ */
15751 .L_ALT_OP_SGET_OBJECT_VOLATILE: /* 0xfd */
15752 /* File: x86/alt_stub.S */
15754 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
15755 * any interesting requests and then jump to the real instruction
15756 * handler. Unlike the Arm handler, we can't do this as a tail call
15757 * because rIBASE is caller save and we need to reload it.
15760 movl rPC, OUT_ARG0(%esp)
15761 movl %eax, OUT_ARG1(%esp)
15762 call dvmCheckInst # (dPC, self)
15764 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
15765 jmp *dvmAsmInstructionStart+(253*4)
15767 /* ------------------------------ */
15768 .L_ALT_OP_SPUT_OBJECT_VOLATILE: /* 0xfe */
15769 /* File: x86/alt_stub.S */
15771 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
15772 * any interesting requests and then jump to the real instruction
15773 * handler. Unlike the Arm handler, we can't do this as a tail call
15774 * because rIBASE is caller save and we need to reload it.
15777 movl rPC, OUT_ARG0(%esp)
15778 movl %eax, OUT_ARG1(%esp)
15779 call dvmCheckInst # (dPC, self)
15781 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
15782 jmp *dvmAsmInstructionStart+(254*4)
15784 /* ------------------------------ */
15785 .L_ALT_OP_DISPATCH_FF: /* 0xff */
15786 /* File: x86/alt_stub.S */
15788 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
15789 * any interesting requests and then jump to the real instruction
15790 * handler. Unlike the Arm handler, we can't do this as a tail call
15791 * because rIBASE is caller save and we need to reload it.
15794 movl rPC, OUT_ARG0(%esp)
15795 movl %eax, OUT_ARG1(%esp)
15796 call dvmCheckInst # (dPC, self)
15798 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
15799 jmp *dvmAsmInstructionStart+(255*4)
15801 /* ------------------------------ */
15802 .L_ALT_OP_CONST_CLASS_JUMBO: /* 0x100 */
15803 /* File: x86/alt_stub.S */
15805 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
15806 * any interesting requests and then jump to the real instruction
15807 * handler. Unlike the Arm handler, we can't do this as a tail call
15808 * because rIBASE is caller save and we need to reload it.
15811 movl rPC, OUT_ARG0(%esp)
15812 movl %eax, OUT_ARG1(%esp)
15813 call dvmCheckInst # (dPC, self)
15815 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
15816 jmp *dvmAsmInstructionStart+(256*4)
15818 /* ------------------------------ */
15819 .L_ALT_OP_CHECK_CAST_JUMBO: /* 0x101 */
15820 /* File: x86/alt_stub.S */
15822 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
15823 * any interesting requests and then jump to the real instruction
15824 * handler. Unlike the Arm handler, we can't do this as a tail call
15825 * because rIBASE is caller save and we need to reload it.
15828 movl rPC, OUT_ARG0(%esp)
15829 movl %eax, OUT_ARG1(%esp)
15830 call dvmCheckInst # (dPC, self)
15832 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
15833 jmp *dvmAsmInstructionStart+(257*4)
15835 /* ------------------------------ */
15836 .L_ALT_OP_INSTANCE_OF_JUMBO: /* 0x102 */
15837 /* File: x86/alt_stub.S */
15839 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
15840 * any interesting requests and then jump to the real instruction
15841 * handler. Unlike the Arm handler, we can't do this as a tail call
15842 * because rIBASE is caller save and we need to reload it.
15845 movl rPC, OUT_ARG0(%esp)
15846 movl %eax, OUT_ARG1(%esp)
15847 call dvmCheckInst # (dPC, self)
15849 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
15850 jmp *dvmAsmInstructionStart+(258*4)
15852 /* ------------------------------ */
15853 .L_ALT_OP_NEW_INSTANCE_JUMBO: /* 0x103 */
15854 /* File: x86/alt_stub.S */
15856 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
15857 * any interesting requests and then jump to the real instruction
15858 * handler. Unlike the Arm handler, we can't do this as a tail call
15859 * because rIBASE is caller save and we need to reload it.
15862 movl rPC, OUT_ARG0(%esp)
15863 movl %eax, OUT_ARG1(%esp)
15864 call dvmCheckInst # (dPC, self)
15866 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
15867 jmp *dvmAsmInstructionStart+(259*4)
15869 /* ------------------------------ */
15870 .L_ALT_OP_NEW_ARRAY_JUMBO: /* 0x104 */
15871 /* File: x86/alt_stub.S */
15873 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
15874 * any interesting requests and then jump to the real instruction
15875 * handler. Unlike the Arm handler, we can't do this as a tail call
15876 * because rIBASE is caller save and we need to reload it.
15879 movl rPC, OUT_ARG0(%esp)
15880 movl %eax, OUT_ARG1(%esp)
15881 call dvmCheckInst # (dPC, self)
15883 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
15884 jmp *dvmAsmInstructionStart+(260*4)
15886 /* ------------------------------ */
15887 .L_ALT_OP_FILLED_NEW_ARRAY_JUMBO: /* 0x105 */
15888 /* File: x86/alt_stub.S */
15890 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
15891 * any interesting requests and then jump to the real instruction
15892 * handler. Unlike the Arm handler, we can't do this as a tail call
15893 * because rIBASE is caller save and we need to reload it.
15896 movl rPC, OUT_ARG0(%esp)
15897 movl %eax, OUT_ARG1(%esp)
15898 call dvmCheckInst # (dPC, self)
15900 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
15901 jmp *dvmAsmInstructionStart+(261*4)
15903 /* ------------------------------ */
15904 .L_ALT_OP_IGET_JUMBO: /* 0x106 */
15905 /* File: x86/alt_stub.S */
15907 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
15908 * any interesting requests and then jump to the real instruction
15909 * handler. Unlike the Arm handler, we can't do this as a tail call
15910 * because rIBASE is caller save and we need to reload it.
15913 movl rPC, OUT_ARG0(%esp)
15914 movl %eax, OUT_ARG1(%esp)
15915 call dvmCheckInst # (dPC, self)
15917 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
15918 jmp *dvmAsmInstructionStart+(262*4)
15920 /* ------------------------------ */
15921 .L_ALT_OP_IGET_WIDE_JUMBO: /* 0x107 */
15922 /* File: x86/alt_stub.S */
15924 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
15925 * any interesting requests and then jump to the real instruction
15926 * handler. Unlike the Arm handler, we can't do this as a tail call
15927 * because rIBASE is caller save and we need to reload it.
15930 movl rPC, OUT_ARG0(%esp)
15931 movl %eax, OUT_ARG1(%esp)
15932 call dvmCheckInst # (dPC, self)
15934 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
15935 jmp *dvmAsmInstructionStart+(263*4)
15937 /* ------------------------------ */
15938 .L_ALT_OP_IGET_OBJECT_JUMBO: /* 0x108 */
15939 /* File: x86/alt_stub.S */
15941 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
15942 * any interesting requests and then jump to the real instruction
15943 * handler. Unlike the Arm handler, we can't do this as a tail call
15944 * because rIBASE is caller save and we need to reload it.
15947 movl rPC, OUT_ARG0(%esp)
15948 movl %eax, OUT_ARG1(%esp)
15949 call dvmCheckInst # (dPC, self)
15951 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
15952 jmp *dvmAsmInstructionStart+(264*4)
15954 /* ------------------------------ */
15955 .L_ALT_OP_IGET_BOOLEAN_JUMBO: /* 0x109 */
15956 /* File: x86/alt_stub.S */
15958 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
15959 * any interesting requests and then jump to the real instruction
15960 * handler. Unlike the Arm handler, we can't do this as a tail call
15961 * because rIBASE is caller save and we need to reload it.
15964 movl rPC, OUT_ARG0(%esp)
15965 movl %eax, OUT_ARG1(%esp)
15966 call dvmCheckInst # (dPC, self)
15968 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
15969 jmp *dvmAsmInstructionStart+(265*4)
15971 /* ------------------------------ */
15972 .L_ALT_OP_IGET_BYTE_JUMBO: /* 0x10a */
15973 /* File: x86/alt_stub.S */
15975 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
15976 * any interesting requests and then jump to the real instruction
15977 * handler. Unlike the Arm handler, we can't do this as a tail call
15978 * because rIBASE is caller save and we need to reload it.
15981 movl rPC, OUT_ARG0(%esp)
15982 movl %eax, OUT_ARG1(%esp)
15983 call dvmCheckInst # (dPC, self)
15985 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
15986 jmp *dvmAsmInstructionStart+(266*4)
15988 /* ------------------------------ */
15989 .L_ALT_OP_IGET_CHAR_JUMBO: /* 0x10b */
15990 /* File: x86/alt_stub.S */
15992 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
15993 * any interesting requests and then jump to the real instruction
15994 * handler. Unlike the Arm handler, we can't do this as a tail call
15995 * because rIBASE is caller save and we need to reload it.
15998 movl rPC, OUT_ARG0(%esp)
15999 movl %eax, OUT_ARG1(%esp)
16000 call dvmCheckInst # (dPC, self)
16002 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
16003 jmp *dvmAsmInstructionStart+(267*4)
16005 /* ------------------------------ */
16006 .L_ALT_OP_IGET_SHORT_JUMBO: /* 0x10c */
16007 /* File: x86/alt_stub.S */
16009 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
16010 * any interesting requests and then jump to the real instruction
16011 * handler. Unlike the Arm handler, we can't do this as a tail call
16012 * because rIBASE is caller save and we need to reload it.
16015 movl rPC, OUT_ARG0(%esp)
16016 movl %eax, OUT_ARG1(%esp)
16017 call dvmCheckInst # (dPC, self)
16019 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
16020 jmp *dvmAsmInstructionStart+(268*4)
16022 /* ------------------------------ */
16023 .L_ALT_OP_IPUT_JUMBO: /* 0x10d */
16024 /* File: x86/alt_stub.S */
16026 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
16027 * any interesting requests and then jump to the real instruction
16028 * handler. Unlike the Arm handler, we can't do this as a tail call
16029 * because rIBASE is caller save and we need to reload it.
16032 movl rPC, OUT_ARG0(%esp)
16033 movl %eax, OUT_ARG1(%esp)
16034 call dvmCheckInst # (dPC, self)
16036 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
16037 jmp *dvmAsmInstructionStart+(269*4)
16039 /* ------------------------------ */
16040 .L_ALT_OP_IPUT_WIDE_JUMBO: /* 0x10e */
16041 /* File: x86/alt_stub.S */
16043 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
16044 * any interesting requests and then jump to the real instruction
16045 * handler. Unlike the Arm handler, we can't do this as a tail call
16046 * because rIBASE is caller save and we need to reload it.
16049 movl rPC, OUT_ARG0(%esp)
16050 movl %eax, OUT_ARG1(%esp)
16051 call dvmCheckInst # (dPC, self)
16053 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
16054 jmp *dvmAsmInstructionStart+(270*4)
16056 /* ------------------------------ */
16057 .L_ALT_OP_IPUT_OBJECT_JUMBO: /* 0x10f */
16058 /* File: x86/alt_stub.S */
16060 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
16061 * any interesting requests and then jump to the real instruction
16062 * handler. Unlike the Arm handler, we can't do this as a tail call
16063 * because rIBASE is caller save and we need to reload it.
16066 movl rPC, OUT_ARG0(%esp)
16067 movl %eax, OUT_ARG1(%esp)
16068 call dvmCheckInst # (dPC, self)
16070 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
16071 jmp *dvmAsmInstructionStart+(271*4)
16073 /* ------------------------------ */
16074 .L_ALT_OP_IPUT_BOOLEAN_JUMBO: /* 0x110 */
16075 /* File: x86/alt_stub.S */
16077 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
16078 * any interesting requests and then jump to the real instruction
16079 * handler. Unlike the Arm handler, we can't do this as a tail call
16080 * because rIBASE is caller save and we need to reload it.
16083 movl rPC, OUT_ARG0(%esp)
16084 movl %eax, OUT_ARG1(%esp)
16085 call dvmCheckInst # (dPC, self)
16087 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
16088 jmp *dvmAsmInstructionStart+(272*4)
16090 /* ------------------------------ */
16091 .L_ALT_OP_IPUT_BYTE_JUMBO: /* 0x111 */
16092 /* File: x86/alt_stub.S */
16094 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
16095 * any interesting requests and then jump to the real instruction
16096 * handler. Unlike the Arm handler, we can't do this as a tail call
16097 * because rIBASE is caller save and we need to reload it.
16100 movl rPC, OUT_ARG0(%esp)
16101 movl %eax, OUT_ARG1(%esp)
16102 call dvmCheckInst # (dPC, self)
16104 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
16105 jmp *dvmAsmInstructionStart+(273*4)
16107 /* ------------------------------ */
16108 .L_ALT_OP_IPUT_CHAR_JUMBO: /* 0x112 */
16109 /* File: x86/alt_stub.S */
16111 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
16112 * any interesting requests and then jump to the real instruction
16113 * handler. Unlike the Arm handler, we can't do this as a tail call
16114 * because rIBASE is caller save and we need to reload it.
16117 movl rPC, OUT_ARG0(%esp)
16118 movl %eax, OUT_ARG1(%esp)
16119 call dvmCheckInst # (dPC, self)
16121 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
16122 jmp *dvmAsmInstructionStart+(274*4)
16124 /* ------------------------------ */
16125 .L_ALT_OP_IPUT_SHORT_JUMBO: /* 0x113 */
16126 /* File: x86/alt_stub.S */
16128 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
16129 * any interesting requests and then jump to the real instruction
16130 * handler. Unlike the Arm handler, we can't do this as a tail call
16131 * because rIBASE is caller save and we need to reload it.
16134 movl rPC, OUT_ARG0(%esp)
16135 movl %eax, OUT_ARG1(%esp)
16136 call dvmCheckInst # (dPC, self)
16138 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
16139 jmp *dvmAsmInstructionStart+(275*4)
16141 /* ------------------------------ */
16142 .L_ALT_OP_SGET_JUMBO: /* 0x114 */
16143 /* File: x86/alt_stub.S */
16145 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
16146 * any interesting requests and then jump to the real instruction
16147 * handler. Unlike the Arm handler, we can't do this as a tail call
16148 * because rIBASE is caller save and we need to reload it.
16151 movl rPC, OUT_ARG0(%esp)
16152 movl %eax, OUT_ARG1(%esp)
16153 call dvmCheckInst # (dPC, self)
16155 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
16156 jmp *dvmAsmInstructionStart+(276*4)
16158 /* ------------------------------ */
16159 .L_ALT_OP_SGET_WIDE_JUMBO: /* 0x115 */
16160 /* File: x86/alt_stub.S */
16162 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
16163 * any interesting requests and then jump to the real instruction
16164 * handler. Unlike the Arm handler, we can't do this as a tail call
16165 * because rIBASE is caller save and we need to reload it.
16168 movl rPC, OUT_ARG0(%esp)
16169 movl %eax, OUT_ARG1(%esp)
16170 call dvmCheckInst # (dPC, self)
16172 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
16173 jmp *dvmAsmInstructionStart+(277*4)
16175 /* ------------------------------ */
16176 .L_ALT_OP_SGET_OBJECT_JUMBO: /* 0x116 */
16177 /* File: x86/alt_stub.S */
16179 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
16180 * any interesting requests and then jump to the real instruction
16181 * handler. Unlike the Arm handler, we can't do this as a tail call
16182 * because rIBASE is caller save and we need to reload it.
16185 movl rPC, OUT_ARG0(%esp)
16186 movl %eax, OUT_ARG1(%esp)
16187 call dvmCheckInst # (dPC, self)
16189 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
16190 jmp *dvmAsmInstructionStart+(278*4)
16192 /* ------------------------------ */
16193 .L_ALT_OP_SGET_BOOLEAN_JUMBO: /* 0x117 */
16194 /* File: x86/alt_stub.S */
16196 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
16197 * any interesting requests and then jump to the real instruction
16198 * handler. Unlike the Arm handler, we can't do this as a tail call
16199 * because rIBASE is caller save and we need to reload it.
16202 movl rPC, OUT_ARG0(%esp)
16203 movl %eax, OUT_ARG1(%esp)
16204 call dvmCheckInst # (dPC, self)
16206 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
16207 jmp *dvmAsmInstructionStart+(279*4)
16209 /* ------------------------------ */
16210 .L_ALT_OP_SGET_BYTE_JUMBO: /* 0x118 */
16211 /* File: x86/alt_stub.S */
16213 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
16214 * any interesting requests and then jump to the real instruction
16215 * handler. Unlike the Arm handler, we can't do this as a tail call
16216 * because rIBASE is caller save and we need to reload it.
16219 movl rPC, OUT_ARG0(%esp)
16220 movl %eax, OUT_ARG1(%esp)
16221 call dvmCheckInst # (dPC, self)
16223 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
16224 jmp *dvmAsmInstructionStart+(280*4)
16226 /* ------------------------------ */
16227 .L_ALT_OP_SGET_CHAR_JUMBO: /* 0x119 */
16228 /* File: x86/alt_stub.S */
16230 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
16231 * any interesting requests and then jump to the real instruction
16232 * handler. Unlike the Arm handler, we can't do this as a tail call
16233 * because rIBASE is caller save and we need to reload it.
16236 movl rPC, OUT_ARG0(%esp)
16237 movl %eax, OUT_ARG1(%esp)
16238 call dvmCheckInst # (dPC, self)
16240 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
16241 jmp *dvmAsmInstructionStart+(281*4)
16243 /* ------------------------------ */
16244 .L_ALT_OP_SGET_SHORT_JUMBO: /* 0x11a */
16245 /* File: x86/alt_stub.S */
16247 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
16248 * any interesting requests and then jump to the real instruction
16249 * handler. Unlike the Arm handler, we can't do this as a tail call
16250 * because rIBASE is caller save and we need to reload it.
16253 movl rPC, OUT_ARG0(%esp)
16254 movl %eax, OUT_ARG1(%esp)
16255 call dvmCheckInst # (dPC, self)
16257 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
16258 jmp *dvmAsmInstructionStart+(282*4)
16260 /* ------------------------------ */
16261 .L_ALT_OP_SPUT_JUMBO: /* 0x11b */
16262 /* File: x86/alt_stub.S */
16264 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
16265 * any interesting requests and then jump to the real instruction
16266 * handler. Unlike the Arm handler, we can't do this as a tail call
16267 * because rIBASE is caller save and we need to reload it.
16270 movl rPC, OUT_ARG0(%esp)
16271 movl %eax, OUT_ARG1(%esp)
16272 call dvmCheckInst # (dPC, self)
16274 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
16275 jmp *dvmAsmInstructionStart+(283*4)
16277 /* ------------------------------ */
16278 .L_ALT_OP_SPUT_WIDE_JUMBO: /* 0x11c */
16279 /* File: x86/alt_stub.S */
16281 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
16282 * any interesting requests and then jump to the real instruction
16283 * handler. Unlike the Arm handler, we can't do this as a tail call
16284 * because rIBASE is caller save and we need to reload it.
16287 movl rPC, OUT_ARG0(%esp)
16288 movl %eax, OUT_ARG1(%esp)
16289 call dvmCheckInst # (dPC, self)
16291 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
16292 jmp *dvmAsmInstructionStart+(284*4)
16294 /* ------------------------------ */
16295 .L_ALT_OP_SPUT_OBJECT_JUMBO: /* 0x11d */
16296 /* File: x86/alt_stub.S */
16298 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
16299 * any interesting requests and then jump to the real instruction
16300 * handler. Unlike the Arm handler, we can't do this as a tail call
16301 * because rIBASE is caller save and we need to reload it.
16304 movl rPC, OUT_ARG0(%esp)
16305 movl %eax, OUT_ARG1(%esp)
16306 call dvmCheckInst # (dPC, self)
16308 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
16309 jmp *dvmAsmInstructionStart+(285*4)
16311 /* ------------------------------ */
16312 .L_ALT_OP_SPUT_BOOLEAN_JUMBO: /* 0x11e */
16313 /* File: x86/alt_stub.S */
16315 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
16316 * any interesting requests and then jump to the real instruction
16317 * handler. Unlike the Arm handler, we can't do this as a tail call
16318 * because rIBASE is caller save and we need to reload it.
16321 movl rPC, OUT_ARG0(%esp)
16322 movl %eax, OUT_ARG1(%esp)
16323 call dvmCheckInst # (dPC, self)
16325 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
16326 jmp *dvmAsmInstructionStart+(286*4)
16328 /* ------------------------------ */
16329 .L_ALT_OP_SPUT_BYTE_JUMBO: /* 0x11f */
16330 /* File: x86/alt_stub.S */
16332 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
16333 * any interesting requests and then jump to the real instruction
16334 * handler. Unlike the Arm handler, we can't do this as a tail call
16335 * because rIBASE is caller save and we need to reload it.
16338 movl rPC, OUT_ARG0(%esp)
16339 movl %eax, OUT_ARG1(%esp)
16340 call dvmCheckInst # (dPC, self)
16342 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
16343 jmp *dvmAsmInstructionStart+(287*4)
16345 /* ------------------------------ */
16346 .L_ALT_OP_SPUT_CHAR_JUMBO: /* 0x120 */
16347 /* File: x86/alt_stub.S */
16349 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
16350 * any interesting requests and then jump to the real instruction
16351 * handler. Unlike the Arm handler, we can't do this as a tail call
16352 * because rIBASE is caller save and we need to reload it.
16355 movl rPC, OUT_ARG0(%esp)
16356 movl %eax, OUT_ARG1(%esp)
16357 call dvmCheckInst # (dPC, self)
16359 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
16360 jmp *dvmAsmInstructionStart+(288*4)
16362 /* ------------------------------ */
16363 .L_ALT_OP_SPUT_SHORT_JUMBO: /* 0x121 */
16364 /* File: x86/alt_stub.S */
16366 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
16367 * any interesting requests and then jump to the real instruction
16368 * handler. Unlike the Arm handler, we can't do this as a tail call
16369 * because rIBASE is caller save and we need to reload it.
16372 movl rPC, OUT_ARG0(%esp)
16373 movl %eax, OUT_ARG1(%esp)
16374 call dvmCheckInst # (dPC, self)
16376 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
16377 jmp *dvmAsmInstructionStart+(289*4)
16379 /* ------------------------------ */
16380 .L_ALT_OP_INVOKE_VIRTUAL_JUMBO: /* 0x122 */
16381 /* File: x86/alt_stub.S */
16383 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
16384 * any interesting requests and then jump to the real instruction
16385 * handler. Unlike the Arm handler, we can't do this as a tail call
16386 * because rIBASE is caller save and we need to reload it.
16389 movl rPC, OUT_ARG0(%esp)
16390 movl %eax, OUT_ARG1(%esp)
16391 call dvmCheckInst # (dPC, self)
16393 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
16394 jmp *dvmAsmInstructionStart+(290*4)
16396 /* ------------------------------ */
16397 .L_ALT_OP_INVOKE_SUPER_JUMBO: /* 0x123 */
16398 /* File: x86/alt_stub.S */
16400 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
16401 * any interesting requests and then jump to the real instruction
16402 * handler. Unlike the Arm handler, we can't do this as a tail call
16403 * because rIBASE is caller save and we need to reload it.
16406 movl rPC, OUT_ARG0(%esp)
16407 movl %eax, OUT_ARG1(%esp)
16408 call dvmCheckInst # (dPC, self)
16410 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
16411 jmp *dvmAsmInstructionStart+(291*4)
16413 /* ------------------------------ */
16414 .L_ALT_OP_INVOKE_DIRECT_JUMBO: /* 0x124 */
16415 /* File: x86/alt_stub.S */
16417 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
16418 * any interesting requests and then jump to the real instruction
16419 * handler. Unlike the Arm handler, we can't do this as a tail call
16420 * because rIBASE is caller save and we need to reload it.
16423 movl rPC, OUT_ARG0(%esp)
16424 movl %eax, OUT_ARG1(%esp)
16425 call dvmCheckInst # (dPC, self)
16427 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
16428 jmp *dvmAsmInstructionStart+(292*4)
16430 /* ------------------------------ */
16431 .L_ALT_OP_INVOKE_STATIC_JUMBO: /* 0x125 */
16432 /* File: x86/alt_stub.S */
16434 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
16435 * any interesting requests and then jump to the real instruction
16436 * handler. Unlike the Arm handler, we can't do this as a tail call
16437 * because rIBASE is caller save and we need to reload it.
16440 movl rPC, OUT_ARG0(%esp)
16441 movl %eax, OUT_ARG1(%esp)
16442 call dvmCheckInst # (dPC, self)
16444 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
16445 jmp *dvmAsmInstructionStart+(293*4)
16447 /* ------------------------------ */
16448 .L_ALT_OP_INVOKE_INTERFACE_JUMBO: /* 0x126 */
16449 /* File: x86/alt_stub.S */
16451 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
16452 * any interesting requests and then jump to the real instruction
16453 * handler. Unlike the Arm handler, we can't do this as a tail call
16454 * because rIBASE is caller save and we need to reload it.
16457 movl rPC, OUT_ARG0(%esp)
16458 movl %eax, OUT_ARG1(%esp)
16459 call dvmCheckInst # (dPC, self)
16461 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
16462 jmp *dvmAsmInstructionStart+(294*4)
16464 /* ------------------------------ */
16465 .L_ALT_OP_UNUSED_27FF: /* 0x127 */
16466 /* File: x86/alt_stub.S */
16468 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
16469 * any interesting requests and then jump to the real instruction
16470 * handler. Unlike the Arm handler, we can't do this as a tail call
16471 * because rIBASE is caller save and we need to reload it.
16474 movl rPC, OUT_ARG0(%esp)
16475 movl %eax, OUT_ARG1(%esp)
16476 call dvmCheckInst # (dPC, self)
16478 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
16479 jmp *dvmAsmInstructionStart+(295*4)
16481 /* ------------------------------ */
16482 .L_ALT_OP_UNUSED_28FF: /* 0x128 */
16483 /* File: x86/alt_stub.S */
16485 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
16486 * any interesting requests and then jump to the real instruction
16487 * handler. Unlike the Arm handler, we can't do this as a tail call
16488 * because rIBASE is caller save and we need to reload it.
16491 movl rPC, OUT_ARG0(%esp)
16492 movl %eax, OUT_ARG1(%esp)
16493 call dvmCheckInst # (dPC, self)
16495 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
16496 jmp *dvmAsmInstructionStart+(296*4)
16498 /* ------------------------------ */
16499 .L_ALT_OP_UNUSED_29FF: /* 0x129 */
16500 /* File: x86/alt_stub.S */
16502 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
16503 * any interesting requests and then jump to the real instruction
16504 * handler. Unlike the Arm handler, we can't do this as a tail call
16505 * because rIBASE is caller save and we need to reload it.
16508 movl rPC, OUT_ARG0(%esp)
16509 movl %eax, OUT_ARG1(%esp)
16510 call dvmCheckInst # (dPC, self)
16512 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
16513 jmp *dvmAsmInstructionStart+(297*4)
16515 /* ------------------------------ */
16516 .L_ALT_OP_UNUSED_2AFF: /* 0x12a */
16517 /* File: x86/alt_stub.S */
16519 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
16520 * any interesting requests and then jump to the real instruction
16521 * handler. Unlike the Arm handler, we can't do this as a tail call
16522 * because rIBASE is caller save and we need to reload it.
16525 movl rPC, OUT_ARG0(%esp)
16526 movl %eax, OUT_ARG1(%esp)
16527 call dvmCheckInst # (dPC, self)
16529 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
16530 jmp *dvmAsmInstructionStart+(298*4)
16532 /* ------------------------------ */
16533 .L_ALT_OP_UNUSED_2BFF: /* 0x12b */
16534 /* File: x86/alt_stub.S */
16536 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
16537 * any interesting requests and then jump to the real instruction
16538 * handler. Unlike the Arm handler, we can't do this as a tail call
16539 * because rIBASE is caller save and we need to reload it.
16542 movl rPC, OUT_ARG0(%esp)
16543 movl %eax, OUT_ARG1(%esp)
16544 call dvmCheckInst # (dPC, self)
16546 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
16547 jmp *dvmAsmInstructionStart+(299*4)
16549 /* ------------------------------ */
16550 .L_ALT_OP_UNUSED_2CFF: /* 0x12c */
16551 /* File: x86/alt_stub.S */
16553 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
16554 * any interesting requests and then jump to the real instruction
16555 * handler. Unlike the Arm handler, we can't do this as a tail call
16556 * because rIBASE is caller save and we need to reload it.
16559 movl rPC, OUT_ARG0(%esp)
16560 movl %eax, OUT_ARG1(%esp)
16561 call dvmCheckInst # (dPC, self)
16563 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
16564 jmp *dvmAsmInstructionStart+(300*4)
16566 /* ------------------------------ */
16567 .L_ALT_OP_UNUSED_2DFF: /* 0x12d */
16568 /* File: x86/alt_stub.S */
16570 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
16571 * any interesting requests and then jump to the real instruction
16572 * handler. Unlike the Arm handler, we can't do this as a tail call
16573 * because rIBASE is caller save and we need to reload it.
16576 movl rPC, OUT_ARG0(%esp)
16577 movl %eax, OUT_ARG1(%esp)
16578 call dvmCheckInst # (dPC, self)
16580 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
16581 jmp *dvmAsmInstructionStart+(301*4)
16583 /* ------------------------------ */
16584 .L_ALT_OP_UNUSED_2EFF: /* 0x12e */
16585 /* File: x86/alt_stub.S */
16587 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
16588 * any interesting requests and then jump to the real instruction
16589 * handler. Unlike the Arm handler, we can't do this as a tail call
16590 * because rIBASE is caller save and we need to reload it.
16593 movl rPC, OUT_ARG0(%esp)
16594 movl %eax, OUT_ARG1(%esp)
16595 call dvmCheckInst # (dPC, self)
16597 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
16598 jmp *dvmAsmInstructionStart+(302*4)
16600 /* ------------------------------ */
16601 .L_ALT_OP_UNUSED_2FFF: /* 0x12f */
16602 /* File: x86/alt_stub.S */
16604 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
16605 * any interesting requests and then jump to the real instruction
16606 * handler. Unlike the Arm handler, we can't do this as a tail call
16607 * because rIBASE is caller save and we need to reload it.
16610 movl rPC, OUT_ARG0(%esp)
16611 movl %eax, OUT_ARG1(%esp)
16612 call dvmCheckInst # (dPC, self)
16614 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
16615 jmp *dvmAsmInstructionStart+(303*4)
16617 /* ------------------------------ */
16618 .L_ALT_OP_UNUSED_30FF: /* 0x130 */
16619 /* File: x86/alt_stub.S */
16621 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
16622 * any interesting requests and then jump to the real instruction
16623 * handler. Unlike the Arm handler, we can't do this as a tail call
16624 * because rIBASE is caller save and we need to reload it.
16627 movl rPC, OUT_ARG0(%esp)
16628 movl %eax, OUT_ARG1(%esp)
16629 call dvmCheckInst # (dPC, self)
16631 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
16632 jmp *dvmAsmInstructionStart+(304*4)
16634 /* ------------------------------ */
16635 .L_ALT_OP_UNUSED_31FF: /* 0x131 */
16636 /* File: x86/alt_stub.S */
16638 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
16639 * any interesting requests and then jump to the real instruction
16640 * handler. Unlike the Arm handler, we can't do this as a tail call
16641 * because rIBASE is caller save and we need to reload it.
16644 movl rPC, OUT_ARG0(%esp)
16645 movl %eax, OUT_ARG1(%esp)
16646 call dvmCheckInst # (dPC, self)
16648 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
16649 jmp *dvmAsmInstructionStart+(305*4)
16651 /* ------------------------------ */
16652 .L_ALT_OP_UNUSED_32FF: /* 0x132 */
16653 /* File: x86/alt_stub.S */
16655 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
16656 * any interesting requests and then jump to the real instruction
16657 * handler. Unlike the Arm handler, we can't do this as a tail call
16658 * because rIBASE is caller save and we need to reload it.
16661 movl rPC, OUT_ARG0(%esp)
16662 movl %eax, OUT_ARG1(%esp)
16663 call dvmCheckInst # (dPC, self)
16665 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
16666 jmp *dvmAsmInstructionStart+(306*4)
16668 /* ------------------------------ */
16669 .L_ALT_OP_UNUSED_33FF: /* 0x133 */
16670 /* File: x86/alt_stub.S */
16672 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
16673 * any interesting requests and then jump to the real instruction
16674 * handler. Unlike the Arm handler, we can't do this as a tail call
16675 * because rIBASE is caller save and we need to reload it.
16678 movl rPC, OUT_ARG0(%esp)
16679 movl %eax, OUT_ARG1(%esp)
16680 call dvmCheckInst # (dPC, self)
16682 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
16683 jmp *dvmAsmInstructionStart+(307*4)
16685 /* ------------------------------ */
16686 .L_ALT_OP_UNUSED_34FF: /* 0x134 */
16687 /* File: x86/alt_stub.S */
16689 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
16690 * any interesting requests and then jump to the real instruction
16691 * handler. Unlike the Arm handler, we can't do this as a tail call
16692 * because rIBASE is caller save and we need to reload it.
16695 movl rPC, OUT_ARG0(%esp)
16696 movl %eax, OUT_ARG1(%esp)
16697 call dvmCheckInst # (dPC, self)
16699 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
16700 jmp *dvmAsmInstructionStart+(308*4)
16702 /* ------------------------------ */
16703 .L_ALT_OP_UNUSED_35FF: /* 0x135 */
16704 /* File: x86/alt_stub.S */
16706 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
16707 * any interesting requests and then jump to the real instruction
16708 * handler. Unlike the Arm handler, we can't do this as a tail call
16709 * because rIBASE is caller save and we need to reload it.
16712 movl rPC, OUT_ARG0(%esp)
16713 movl %eax, OUT_ARG1(%esp)
16714 call dvmCheckInst # (dPC, self)
16716 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
16717 jmp *dvmAsmInstructionStart+(309*4)
16719 /* ------------------------------ */
16720 .L_ALT_OP_UNUSED_36FF: /* 0x136 */
16721 /* File: x86/alt_stub.S */
16723 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
16724 * any interesting requests and then jump to the real instruction
16725 * handler. Unlike the Arm handler, we can't do this as a tail call
16726 * because rIBASE is caller save and we need to reload it.
16729 movl rPC, OUT_ARG0(%esp)
16730 movl %eax, OUT_ARG1(%esp)
16731 call dvmCheckInst # (dPC, self)
16733 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
16734 jmp *dvmAsmInstructionStart+(310*4)
16736 /* ------------------------------ */
16737 .L_ALT_OP_UNUSED_37FF: /* 0x137 */
16738 /* File: x86/alt_stub.S */
16740 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
16741 * any interesting requests and then jump to the real instruction
16742 * handler. Unlike the Arm handler, we can't do this as a tail call
16743 * because rIBASE is caller save and we need to reload it.
16746 movl rPC, OUT_ARG0(%esp)
16747 movl %eax, OUT_ARG1(%esp)
16748 call dvmCheckInst # (dPC, self)
16750 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
16751 jmp *dvmAsmInstructionStart+(311*4)
16753 /* ------------------------------ */
16754 .L_ALT_OP_UNUSED_38FF: /* 0x138 */
16755 /* File: x86/alt_stub.S */
16757 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
16758 * any interesting requests and then jump to the real instruction
16759 * handler. Unlike the Arm handler, we can't do this as a tail call
16760 * because rIBASE is caller save and we need to reload it.
16763 movl rPC, OUT_ARG0(%esp)
16764 movl %eax, OUT_ARG1(%esp)
16765 call dvmCheckInst # (dPC, self)
16767 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
16768 jmp *dvmAsmInstructionStart+(312*4)
16770 /* ------------------------------ */
16771 .L_ALT_OP_UNUSED_39FF: /* 0x139 */
16772 /* File: x86/alt_stub.S */
16774 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
16775 * any interesting requests and then jump to the real instruction
16776 * handler. Unlike the Arm handler, we can't do this as a tail call
16777 * because rIBASE is caller save and we need to reload it.
16780 movl rPC, OUT_ARG0(%esp)
16781 movl %eax, OUT_ARG1(%esp)
16782 call dvmCheckInst # (dPC, self)
16784 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
16785 jmp *dvmAsmInstructionStart+(313*4)
16787 /* ------------------------------ */
16788 .L_ALT_OP_UNUSED_3AFF: /* 0x13a */
16789 /* File: x86/alt_stub.S */
16791 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
16792 * any interesting requests and then jump to the real instruction
16793 * handler. Unlike the Arm handler, we can't do this as a tail call
16794 * because rIBASE is caller save and we need to reload it.
16797 movl rPC, OUT_ARG0(%esp)
16798 movl %eax, OUT_ARG1(%esp)
16799 call dvmCheckInst # (dPC, self)
16801 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
16802 jmp *dvmAsmInstructionStart+(314*4)
16804 /* ------------------------------ */
16805 .L_ALT_OP_UNUSED_3BFF: /* 0x13b */
16806 /* File: x86/alt_stub.S */
16808 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
16809 * any interesting requests and then jump to the real instruction
16810 * handler. Unlike the Arm handler, we can't do this as a tail call
16811 * because rIBASE is caller save and we need to reload it.
16814 movl rPC, OUT_ARG0(%esp)
16815 movl %eax, OUT_ARG1(%esp)
16816 call dvmCheckInst # (dPC, self)
16818 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
16819 jmp *dvmAsmInstructionStart+(315*4)
16821 /* ------------------------------ */
16822 .L_ALT_OP_UNUSED_3CFF: /* 0x13c */
16823 /* File: x86/alt_stub.S */
16825 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
16826 * any interesting requests and then jump to the real instruction
16827 * handler. Unlike the Arm handler, we can't do this as a tail call
16828 * because rIBASE is caller save and we need to reload it.
16831 movl rPC, OUT_ARG0(%esp)
16832 movl %eax, OUT_ARG1(%esp)
16833 call dvmCheckInst # (dPC, self)
16835 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
16836 jmp *dvmAsmInstructionStart+(316*4)
16838 /* ------------------------------ */
16839 .L_ALT_OP_UNUSED_3DFF: /* 0x13d */
16840 /* File: x86/alt_stub.S */
16842 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
16843 * any interesting requests and then jump to the real instruction
16844 * handler. Unlike the Arm handler, we can't do this as a tail call
16845 * because rIBASE is caller save and we need to reload it.
16848 movl rPC, OUT_ARG0(%esp)
16849 movl %eax, OUT_ARG1(%esp)
16850 call dvmCheckInst # (dPC, self)
16852 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
16853 jmp *dvmAsmInstructionStart+(317*4)
16855 /* ------------------------------ */
16856 .L_ALT_OP_UNUSED_3EFF: /* 0x13e */
16857 /* File: x86/alt_stub.S */
16859 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
16860 * any interesting requests and then jump to the real instruction
16861 * handler. Unlike the Arm handler, we can't do this as a tail call
16862 * because rIBASE is caller save and we need to reload it.
16865 movl rPC, OUT_ARG0(%esp)
16866 movl %eax, OUT_ARG1(%esp)
16867 call dvmCheckInst # (dPC, self)
16869 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
16870 jmp *dvmAsmInstructionStart+(318*4)
16872 /* ------------------------------ */
16873 .L_ALT_OP_UNUSED_3FFF: /* 0x13f */
16874 /* File: x86/alt_stub.S */
16876 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
16877 * any interesting requests and then jump to the real instruction
16878 * handler. Unlike the Arm handler, we can't do this as a tail call
16879 * because rIBASE is caller save and we need to reload it.
16882 movl rPC, OUT_ARG0(%esp)
16883 movl %eax, OUT_ARG1(%esp)
16884 call dvmCheckInst # (dPC, self)
16886 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
16887 jmp *dvmAsmInstructionStart+(319*4)
16889 /* ------------------------------ */
16890 .L_ALT_OP_UNUSED_40FF: /* 0x140 */
16891 /* File: x86/alt_stub.S */
16893 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
16894 * any interesting requests and then jump to the real instruction
16895 * handler. Unlike the Arm handler, we can't do this as a tail call
16896 * because rIBASE is caller save and we need to reload it.
16899 movl rPC, OUT_ARG0(%esp)
16900 movl %eax, OUT_ARG1(%esp)
16901 call dvmCheckInst # (dPC, self)
16903 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
16904 jmp *dvmAsmInstructionStart+(320*4)
16906 /* ------------------------------ */
16907 .L_ALT_OP_UNUSED_41FF: /* 0x141 */
16908 /* File: x86/alt_stub.S */
16910 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
16911 * any interesting requests and then jump to the real instruction
16912 * handler. Unlike the Arm handler, we can't do this as a tail call
16913 * because rIBASE is caller save and we need to reload it.
16916 movl rPC, OUT_ARG0(%esp)
16917 movl %eax, OUT_ARG1(%esp)
16918 call dvmCheckInst # (dPC, self)
16920 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
16921 jmp *dvmAsmInstructionStart+(321*4)
16923 /* ------------------------------ */
16924 .L_ALT_OP_UNUSED_42FF: /* 0x142 */
16925 /* File: x86/alt_stub.S */
16927 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
16928 * any interesting requests and then jump to the real instruction
16929 * handler. Unlike the Arm handler, we can't do this as a tail call
16930 * because rIBASE is caller save and we need to reload it.
16933 movl rPC, OUT_ARG0(%esp)
16934 movl %eax, OUT_ARG1(%esp)
16935 call dvmCheckInst # (dPC, self)
16937 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
16938 jmp *dvmAsmInstructionStart+(322*4)
16940 /* ------------------------------ */
16941 .L_ALT_OP_UNUSED_43FF: /* 0x143 */
16942 /* File: x86/alt_stub.S */
16944 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
16945 * any interesting requests and then jump to the real instruction
16946 * handler. Unlike the Arm handler, we can't do this as a tail call
16947 * because rIBASE is caller save and we need to reload it.
16950 movl rPC, OUT_ARG0(%esp)
16951 movl %eax, OUT_ARG1(%esp)
16952 call dvmCheckInst # (dPC, self)
16954 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
16955 jmp *dvmAsmInstructionStart+(323*4)
16957 /* ------------------------------ */
16958 .L_ALT_OP_UNUSED_44FF: /* 0x144 */
16959 /* File: x86/alt_stub.S */
16961 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
16962 * any interesting requests and then jump to the real instruction
16963 * handler. Unlike the Arm handler, we can't do this as a tail call
16964 * because rIBASE is caller save and we need to reload it.
16967 movl rPC, OUT_ARG0(%esp)
16968 movl %eax, OUT_ARG1(%esp)
16969 call dvmCheckInst # (dPC, self)
16971 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
16972 jmp *dvmAsmInstructionStart+(324*4)
16974 /* ------------------------------ */
16975 .L_ALT_OP_UNUSED_45FF: /* 0x145 */
16976 /* File: x86/alt_stub.S */
16978 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
16979 * any interesting requests and then jump to the real instruction
16980 * handler. Unlike the Arm handler, we can't do this as a tail call
16981 * because rIBASE is caller save and we need to reload it.
16984 movl rPC, OUT_ARG0(%esp)
16985 movl %eax, OUT_ARG1(%esp)
16986 call dvmCheckInst # (dPC, self)
16988 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
16989 jmp *dvmAsmInstructionStart+(325*4)
16991 /* ------------------------------ */
16992 .L_ALT_OP_UNUSED_46FF: /* 0x146 */
16993 /* File: x86/alt_stub.S */
16995 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
16996 * any interesting requests and then jump to the real instruction
16997 * handler. Unlike the Arm handler, we can't do this as a tail call
16998 * because rIBASE is caller save and we need to reload it.
17001 movl rPC, OUT_ARG0(%esp)
17002 movl %eax, OUT_ARG1(%esp)
17003 call dvmCheckInst # (dPC, self)
17005 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
17006 jmp *dvmAsmInstructionStart+(326*4)
17008 /* ------------------------------ */
17009 .L_ALT_OP_UNUSED_47FF: /* 0x147 */
17010 /* File: x86/alt_stub.S */
17012 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
17013 * any interesting requests and then jump to the real instruction
17014 * handler. Unlike the Arm handler, we can't do this as a tail call
17015 * because rIBASE is caller save and we need to reload it.
17018 movl rPC, OUT_ARG0(%esp)
17019 movl %eax, OUT_ARG1(%esp)
17020 call dvmCheckInst # (dPC, self)
17022 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
17023 jmp *dvmAsmInstructionStart+(327*4)
17025 /* ------------------------------ */
17026 .L_ALT_OP_UNUSED_48FF: /* 0x148 */
17027 /* File: x86/alt_stub.S */
17029 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
17030 * any interesting requests and then jump to the real instruction
17031 * handler. Unlike the Arm handler, we can't do this as a tail call
17032 * because rIBASE is caller save and we need to reload it.
17035 movl rPC, OUT_ARG0(%esp)
17036 movl %eax, OUT_ARG1(%esp)
17037 call dvmCheckInst # (dPC, self)
17039 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
17040 jmp *dvmAsmInstructionStart+(328*4)
17042 /* ------------------------------ */
17043 .L_ALT_OP_UNUSED_49FF: /* 0x149 */
17044 /* File: x86/alt_stub.S */
17046 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
17047 * any interesting requests and then jump to the real instruction
17048 * handler. Unlike the Arm handler, we can't do this as a tail call
17049 * because rIBASE is caller save and we need to reload it.
17052 movl rPC, OUT_ARG0(%esp)
17053 movl %eax, OUT_ARG1(%esp)
17054 call dvmCheckInst # (dPC, self)
17056 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
17057 jmp *dvmAsmInstructionStart+(329*4)
17059 /* ------------------------------ */
17060 .L_ALT_OP_UNUSED_4AFF: /* 0x14a */
17061 /* File: x86/alt_stub.S */
17063 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
17064 * any interesting requests and then jump to the real instruction
17065 * handler. Unlike the Arm handler, we can't do this as a tail call
17066 * because rIBASE is caller save and we need to reload it.
17069 movl rPC, OUT_ARG0(%esp)
17070 movl %eax, OUT_ARG1(%esp)
17071 call dvmCheckInst # (dPC, self)
17073 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
17074 jmp *dvmAsmInstructionStart+(330*4)
17076 /* ------------------------------ */
17077 .L_ALT_OP_UNUSED_4BFF: /* 0x14b */
17078 /* File: x86/alt_stub.S */
17080 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
17081 * any interesting requests and then jump to the real instruction
17082 * handler. Unlike the Arm handler, we can't do this as a tail call
17083 * because rIBASE is caller save and we need to reload it.
17086 movl rPC, OUT_ARG0(%esp)
17087 movl %eax, OUT_ARG1(%esp)
17088 call dvmCheckInst # (dPC, self)
17090 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
17091 jmp *dvmAsmInstructionStart+(331*4)
17093 /* ------------------------------ */
17094 .L_ALT_OP_UNUSED_4CFF: /* 0x14c */
17095 /* File: x86/alt_stub.S */
17097 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
17098 * any interesting requests and then jump to the real instruction
17099 * handler. Unlike the Arm handler, we can't do this as a tail call
17100 * because rIBASE is caller save and we need to reload it.
17103 movl rPC, OUT_ARG0(%esp)
17104 movl %eax, OUT_ARG1(%esp)
17105 call dvmCheckInst # (dPC, self)
17107 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
17108 jmp *dvmAsmInstructionStart+(332*4)
17110 /* ------------------------------ */
17111 .L_ALT_OP_UNUSED_4DFF: /* 0x14d */
17112 /* File: x86/alt_stub.S */
17114 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
17115 * any interesting requests and then jump to the real instruction
17116 * handler. Unlike the Arm handler, we can't do this as a tail call
17117 * because rIBASE is caller save and we need to reload it.
17120 movl rPC, OUT_ARG0(%esp)
17121 movl %eax, OUT_ARG1(%esp)
17122 call dvmCheckInst # (dPC, self)
17124 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
17125 jmp *dvmAsmInstructionStart+(333*4)
17127 /* ------------------------------ */
17128 .L_ALT_OP_UNUSED_4EFF: /* 0x14e */
17129 /* File: x86/alt_stub.S */
17131 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
17132 * any interesting requests and then jump to the real instruction
17133 * handler. Unlike the Arm handler, we can't do this as a tail call
17134 * because rIBASE is caller save and we need to reload it.
17137 movl rPC, OUT_ARG0(%esp)
17138 movl %eax, OUT_ARG1(%esp)
17139 call dvmCheckInst # (dPC, self)
17141 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
17142 jmp *dvmAsmInstructionStart+(334*4)
17144 /* ------------------------------ */
17145 .L_ALT_OP_UNUSED_4FFF: /* 0x14f */
17146 /* File: x86/alt_stub.S */
17148 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
17149 * any interesting requests and then jump to the real instruction
17150 * handler. Unlike the Arm handler, we can't do this as a tail call
17151 * because rIBASE is caller save and we need to reload it.
17154 movl rPC, OUT_ARG0(%esp)
17155 movl %eax, OUT_ARG1(%esp)
17156 call dvmCheckInst # (dPC, self)
17158 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
17159 jmp *dvmAsmInstructionStart+(335*4)
17161 /* ------------------------------ */
17162 .L_ALT_OP_UNUSED_50FF: /* 0x150 */
17163 /* File: x86/alt_stub.S */
17165 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
17166 * any interesting requests and then jump to the real instruction
17167 * handler. Unlike the Arm handler, we can't do this as a tail call
17168 * because rIBASE is caller save and we need to reload it.
17171 movl rPC, OUT_ARG0(%esp)
17172 movl %eax, OUT_ARG1(%esp)
17173 call dvmCheckInst # (dPC, self)
17175 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
17176 jmp *dvmAsmInstructionStart+(336*4)
17178 /* ------------------------------ */
17179 .L_ALT_OP_UNUSED_51FF: /* 0x151 */
17180 /* File: x86/alt_stub.S */
17182 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
17183 * any interesting requests and then jump to the real instruction
17184 * handler. Unlike the Arm handler, we can't do this as a tail call
17185 * because rIBASE is caller save and we need to reload it.
17188 movl rPC, OUT_ARG0(%esp)
17189 movl %eax, OUT_ARG1(%esp)
17190 call dvmCheckInst # (dPC, self)
17192 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
17193 jmp *dvmAsmInstructionStart+(337*4)
17195 /* ------------------------------ */
17196 .L_ALT_OP_UNUSED_52FF: /* 0x152 */
17197 /* File: x86/alt_stub.S */
17199 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
17200 * any interesting requests and then jump to the real instruction
17201 * handler. Unlike the Arm handler, we can't do this as a tail call
17202 * because rIBASE is caller save and we need to reload it.
17205 movl rPC, OUT_ARG0(%esp)
17206 movl %eax, OUT_ARG1(%esp)
17207 call dvmCheckInst # (dPC, self)
17209 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
17210 jmp *dvmAsmInstructionStart+(338*4)
17212 /* ------------------------------ */
17213 .L_ALT_OP_UNUSED_53FF: /* 0x153 */
17214 /* File: x86/alt_stub.S */
17216 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
17217 * any interesting requests and then jump to the real instruction
17218 * handler. Unlike the Arm handler, we can't do this as a tail call
17219 * because rIBASE is caller save and we need to reload it.
17222 movl rPC, OUT_ARG0(%esp)
17223 movl %eax, OUT_ARG1(%esp)
17224 call dvmCheckInst # (dPC, self)
17226 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
17227 jmp *dvmAsmInstructionStart+(339*4)
17229 /* ------------------------------ */
17230 .L_ALT_OP_UNUSED_54FF: /* 0x154 */
17231 /* File: x86/alt_stub.S */
17233 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
17234 * any interesting requests and then jump to the real instruction
17235 * handler. Unlike the Arm handler, we can't do this as a tail call
17236 * because rIBASE is caller save and we need to reload it.
17239 movl rPC, OUT_ARG0(%esp)
17240 movl %eax, OUT_ARG1(%esp)
17241 call dvmCheckInst # (dPC, self)
17243 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
17244 jmp *dvmAsmInstructionStart+(340*4)
17246 /* ------------------------------ */
17247 .L_ALT_OP_UNUSED_55FF: /* 0x155 */
17248 /* File: x86/alt_stub.S */
17250 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
17251 * any interesting requests and then jump to the real instruction
17252 * handler. Unlike the Arm handler, we can't do this as a tail call
17253 * because rIBASE is caller save and we need to reload it.
17256 movl rPC, OUT_ARG0(%esp)
17257 movl %eax, OUT_ARG1(%esp)
17258 call dvmCheckInst # (dPC, self)
17260 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
17261 jmp *dvmAsmInstructionStart+(341*4)
17263 /* ------------------------------ */
17264 .L_ALT_OP_UNUSED_56FF: /* 0x156 */
17265 /* File: x86/alt_stub.S */
17267 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
17268 * any interesting requests and then jump to the real instruction
17269 * handler. Unlike the Arm handler, we can't do this as a tail call
17270 * because rIBASE is caller save and we need to reload it.
17273 movl rPC, OUT_ARG0(%esp)
17274 movl %eax, OUT_ARG1(%esp)
17275 call dvmCheckInst # (dPC, self)
17277 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
17278 jmp *dvmAsmInstructionStart+(342*4)
17280 /* ------------------------------ */
17281 .L_ALT_OP_UNUSED_57FF: /* 0x157 */
17282 /* File: x86/alt_stub.S */
17284 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
17285 * any interesting requests and then jump to the real instruction
17286 * handler. Unlike the Arm handler, we can't do this as a tail call
17287 * because rIBASE is caller save and we need to reload it.
17290 movl rPC, OUT_ARG0(%esp)
17291 movl %eax, OUT_ARG1(%esp)
17292 call dvmCheckInst # (dPC, self)
17294 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
17295 jmp *dvmAsmInstructionStart+(343*4)
17297 /* ------------------------------ */
17298 .L_ALT_OP_UNUSED_58FF: /* 0x158 */
17299 /* File: x86/alt_stub.S */
17301 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
17302 * any interesting requests and then jump to the real instruction
17303 * handler. Unlike the Arm handler, we can't do this as a tail call
17304 * because rIBASE is caller save and we need to reload it.
17307 movl rPC, OUT_ARG0(%esp)
17308 movl %eax, OUT_ARG1(%esp)
17309 call dvmCheckInst # (dPC, self)
17311 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
17312 jmp *dvmAsmInstructionStart+(344*4)
17314 /* ------------------------------ */
17315 .L_ALT_OP_UNUSED_59FF: /* 0x159 */
17316 /* File: x86/alt_stub.S */
17318 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
17319 * any interesting requests and then jump to the real instruction
17320 * handler. Unlike the Arm handler, we can't do this as a tail call
17321 * because rIBASE is caller save and we need to reload it.
17324 movl rPC, OUT_ARG0(%esp)
17325 movl %eax, OUT_ARG1(%esp)
17326 call dvmCheckInst # (dPC, self)
17328 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
17329 jmp *dvmAsmInstructionStart+(345*4)
17331 /* ------------------------------ */
17332 .L_ALT_OP_UNUSED_5AFF: /* 0x15a */
17333 /* File: x86/alt_stub.S */
17335 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
17336 * any interesting requests and then jump to the real instruction
17337 * handler. Unlike the Arm handler, we can't do this as a tail call
17338 * because rIBASE is caller save and we need to reload it.
17341 movl rPC, OUT_ARG0(%esp)
17342 movl %eax, OUT_ARG1(%esp)
17343 call dvmCheckInst # (dPC, self)
17345 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
17346 jmp *dvmAsmInstructionStart+(346*4)
17348 /* ------------------------------ */
17349 .L_ALT_OP_UNUSED_5BFF: /* 0x15b */
17350 /* File: x86/alt_stub.S */
17352 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
17353 * any interesting requests and then jump to the real instruction
17354 * handler. Unlike the Arm handler, we can't do this as a tail call
17355 * because rIBASE is caller save and we need to reload it.
17358 movl rPC, OUT_ARG0(%esp)
17359 movl %eax, OUT_ARG1(%esp)
17360 call dvmCheckInst # (dPC, self)
17362 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
17363 jmp *dvmAsmInstructionStart+(347*4)
17365 /* ------------------------------ */
17366 .L_ALT_OP_UNUSED_5CFF: /* 0x15c */
17367 /* File: x86/alt_stub.S */
17369 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
17370 * any interesting requests and then jump to the real instruction
17371 * handler. Unlike the Arm handler, we can't do this as a tail call
17372 * because rIBASE is caller save and we need to reload it.
17375 movl rPC, OUT_ARG0(%esp)
17376 movl %eax, OUT_ARG1(%esp)
17377 call dvmCheckInst # (dPC, self)
17379 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
17380 jmp *dvmAsmInstructionStart+(348*4)
17382 /* ------------------------------ */
17383 .L_ALT_OP_UNUSED_5DFF: /* 0x15d */
17384 /* File: x86/alt_stub.S */
17386 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
17387 * any interesting requests and then jump to the real instruction
17388 * handler. Unlike the Arm handler, we can't do this as a tail call
17389 * because rIBASE is caller save and we need to reload it.
17392 movl rPC, OUT_ARG0(%esp)
17393 movl %eax, OUT_ARG1(%esp)
17394 call dvmCheckInst # (dPC, self)
17396 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
17397 jmp *dvmAsmInstructionStart+(349*4)
17399 /* ------------------------------ */
17400 .L_ALT_OP_UNUSED_5EFF: /* 0x15e */
17401 /* File: x86/alt_stub.S */
17403 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
17404 * any interesting requests and then jump to the real instruction
17405 * handler. Unlike the Arm handler, we can't do this as a tail call
17406 * because rIBASE is caller save and we need to reload it.
17409 movl rPC, OUT_ARG0(%esp)
17410 movl %eax, OUT_ARG1(%esp)
17411 call dvmCheckInst # (dPC, self)
17413 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
17414 jmp *dvmAsmInstructionStart+(350*4)
17416 /* ------------------------------ */
17417 .L_ALT_OP_UNUSED_5FFF: /* 0x15f */
17418 /* File: x86/alt_stub.S */
17420 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
17421 * any interesting requests and then jump to the real instruction
17422 * handler. Unlike the Arm handler, we can't do this as a tail call
17423 * because rIBASE is caller save and we need to reload it.
17426 movl rPC, OUT_ARG0(%esp)
17427 movl %eax, OUT_ARG1(%esp)
17428 call dvmCheckInst # (dPC, self)
17430 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
17431 jmp *dvmAsmInstructionStart+(351*4)
17433 /* ------------------------------ */
17434 .L_ALT_OP_UNUSED_60FF: /* 0x160 */
17435 /* File: x86/alt_stub.S */
17437 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
17438 * any interesting requests and then jump to the real instruction
17439 * handler. Unlike the Arm handler, we can't do this as a tail call
17440 * because rIBASE is caller save and we need to reload it.
17443 movl rPC, OUT_ARG0(%esp)
17444 movl %eax, OUT_ARG1(%esp)
17445 call dvmCheckInst # (dPC, self)
17447 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
17448 jmp *dvmAsmInstructionStart+(352*4)
17450 /* ------------------------------ */
17451 .L_ALT_OP_UNUSED_61FF: /* 0x161 */
17452 /* File: x86/alt_stub.S */
17454 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
17455 * any interesting requests and then jump to the real instruction
17456 * handler. Unlike the Arm handler, we can't do this as a tail call
17457 * because rIBASE is caller save and we need to reload it.
17460 movl rPC, OUT_ARG0(%esp)
17461 movl %eax, OUT_ARG1(%esp)
17462 call dvmCheckInst # (dPC, self)
17464 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
17465 jmp *dvmAsmInstructionStart+(353*4)
17467 /* ------------------------------ */
17468 .L_ALT_OP_UNUSED_62FF: /* 0x162 */
17469 /* File: x86/alt_stub.S */
17471 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
17472 * any interesting requests and then jump to the real instruction
17473 * handler. Unlike the Arm handler, we can't do this as a tail call
17474 * because rIBASE is caller save and we need to reload it.
17477 movl rPC, OUT_ARG0(%esp)
17478 movl %eax, OUT_ARG1(%esp)
17479 call dvmCheckInst # (dPC, self)
17481 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
17482 jmp *dvmAsmInstructionStart+(354*4)
17484 /* ------------------------------ */
17485 .L_ALT_OP_UNUSED_63FF: /* 0x163 */
17486 /* File: x86/alt_stub.S */
17488 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
17489 * any interesting requests and then jump to the real instruction
17490 * handler. Unlike the Arm handler, we can't do this as a tail call
17491 * because rIBASE is caller save and we need to reload it.
17494 movl rPC, OUT_ARG0(%esp)
17495 movl %eax, OUT_ARG1(%esp)
17496 call dvmCheckInst # (dPC, self)
17498 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
17499 jmp *dvmAsmInstructionStart+(355*4)
17501 /* ------------------------------ */
17502 .L_ALT_OP_UNUSED_64FF: /* 0x164 */
17503 /* File: x86/alt_stub.S */
17505 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
17506 * any interesting requests and then jump to the real instruction
17507 * handler. Unlike the Arm handler, we can't do this as a tail call
17508 * because rIBASE is caller save and we need to reload it.
17511 movl rPC, OUT_ARG0(%esp)
17512 movl %eax, OUT_ARG1(%esp)
17513 call dvmCheckInst # (dPC, self)
17515 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
17516 jmp *dvmAsmInstructionStart+(356*4)
17518 /* ------------------------------ */
17519 .L_ALT_OP_UNUSED_65FF: /* 0x165 */
17520 /* File: x86/alt_stub.S */
17522 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
17523 * any interesting requests and then jump to the real instruction
17524 * handler. Unlike the Arm handler, we can't do this as a tail call
17525 * because rIBASE is caller save and we need to reload it.
17528 movl rPC, OUT_ARG0(%esp)
17529 movl %eax, OUT_ARG1(%esp)
17530 call dvmCheckInst # (dPC, self)
17532 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
17533 jmp *dvmAsmInstructionStart+(357*4)
17535 /* ------------------------------ */
17536 .L_ALT_OP_UNUSED_66FF: /* 0x166 */
17537 /* File: x86/alt_stub.S */
17539 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
17540 * any interesting requests and then jump to the real instruction
17541 * handler. Unlike the Arm handler, we can't do this as a tail call
17542 * because rIBASE is caller save and we need to reload it.
17545 movl rPC, OUT_ARG0(%esp)
17546 movl %eax, OUT_ARG1(%esp)
17547 call dvmCheckInst # (dPC, self)
17549 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
17550 jmp *dvmAsmInstructionStart+(358*4)
17552 /* ------------------------------ */
17553 .L_ALT_OP_UNUSED_67FF: /* 0x167 */
17554 /* File: x86/alt_stub.S */
17556 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
17557 * any interesting requests and then jump to the real instruction
17558 * handler. Unlike the Arm handler, we can't do this as a tail call
17559 * because rIBASE is caller save and we need to reload it.
17562 movl rPC, OUT_ARG0(%esp)
17563 movl %eax, OUT_ARG1(%esp)
17564 call dvmCheckInst # (dPC, self)
17566 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
17567 jmp *dvmAsmInstructionStart+(359*4)
17569 /* ------------------------------ */
17570 .L_ALT_OP_UNUSED_68FF: /* 0x168 */
17571 /* File: x86/alt_stub.S */
17573 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
17574 * any interesting requests and then jump to the real instruction
17575 * handler. Unlike the Arm handler, we can't do this as a tail call
17576 * because rIBASE is caller save and we need to reload it.
17579 movl rPC, OUT_ARG0(%esp)
17580 movl %eax, OUT_ARG1(%esp)
17581 call dvmCheckInst # (dPC, self)
17583 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
17584 jmp *dvmAsmInstructionStart+(360*4)
17586 /* ------------------------------ */
17587 .L_ALT_OP_UNUSED_69FF: /* 0x169 */
17588 /* File: x86/alt_stub.S */
17590 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
17591 * any interesting requests and then jump to the real instruction
17592 * handler. Unlike the Arm handler, we can't do this as a tail call
17593 * because rIBASE is caller save and we need to reload it.
17596 movl rPC, OUT_ARG0(%esp)
17597 movl %eax, OUT_ARG1(%esp)
17598 call dvmCheckInst # (dPC, self)
17600 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
17601 jmp *dvmAsmInstructionStart+(361*4)
17603 /* ------------------------------ */
17604 .L_ALT_OP_UNUSED_6AFF: /* 0x16a */
17605 /* File: x86/alt_stub.S */
17607 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
17608 * any interesting requests and then jump to the real instruction
17609 * handler. Unlike the Arm handler, we can't do this as a tail call
17610 * because rIBASE is caller save and we need to reload it.
17613 movl rPC, OUT_ARG0(%esp)
17614 movl %eax, OUT_ARG1(%esp)
17615 call dvmCheckInst # (dPC, self)
17617 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
17618 jmp *dvmAsmInstructionStart+(362*4)
17620 /* ------------------------------ */
17621 .L_ALT_OP_UNUSED_6BFF: /* 0x16b */
17622 /* File: x86/alt_stub.S */
17624 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
17625 * any interesting requests and then jump to the real instruction
17626 * handler. Unlike the Arm handler, we can't do this as a tail call
17627 * because rIBASE is caller save and we need to reload it.
17630 movl rPC, OUT_ARG0(%esp)
17631 movl %eax, OUT_ARG1(%esp)
17632 call dvmCheckInst # (dPC, self)
17634 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
17635 jmp *dvmAsmInstructionStart+(363*4)
17637 /* ------------------------------ */
17638 .L_ALT_OP_UNUSED_6CFF: /* 0x16c */
17639 /* File: x86/alt_stub.S */
17641 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
17642 * any interesting requests and then jump to the real instruction
17643 * handler. Unlike the Arm handler, we can't do this as a tail call
17644 * because rIBASE is caller save and we need to reload it.
17647 movl rPC, OUT_ARG0(%esp)
17648 movl %eax, OUT_ARG1(%esp)
17649 call dvmCheckInst # (dPC, self)
17651 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
17652 jmp *dvmAsmInstructionStart+(364*4)
17654 /* ------------------------------ */
17655 .L_ALT_OP_UNUSED_6DFF: /* 0x16d */
17656 /* File: x86/alt_stub.S */
17658 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
17659 * any interesting requests and then jump to the real instruction
17660 * handler. Unlike the Arm handler, we can't do this as a tail call
17661 * because rIBASE is caller save and we need to reload it.
17664 movl rPC, OUT_ARG0(%esp)
17665 movl %eax, OUT_ARG1(%esp)
17666 call dvmCheckInst # (dPC, self)
17668 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
17669 jmp *dvmAsmInstructionStart+(365*4)
17671 /* ------------------------------ */
17672 .L_ALT_OP_UNUSED_6EFF: /* 0x16e */
17673 /* File: x86/alt_stub.S */
17675 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
17676 * any interesting requests and then jump to the real instruction
17677 * handler. Unlike the Arm handler, we can't do this as a tail call
17678 * because rIBASE is caller save and we need to reload it.
17681 movl rPC, OUT_ARG0(%esp)
17682 movl %eax, OUT_ARG1(%esp)
17683 call dvmCheckInst # (dPC, self)
17685 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
17686 jmp *dvmAsmInstructionStart+(366*4)
17688 /* ------------------------------ */
17689 .L_ALT_OP_UNUSED_6FFF: /* 0x16f */
17690 /* File: x86/alt_stub.S */
17692 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
17693 * any interesting requests and then jump to the real instruction
17694 * handler. Unlike the Arm handler, we can't do this as a tail call
17695 * because rIBASE is caller save and we need to reload it.
17698 movl rPC, OUT_ARG0(%esp)
17699 movl %eax, OUT_ARG1(%esp)
17700 call dvmCheckInst # (dPC, self)
17702 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
17703 jmp *dvmAsmInstructionStart+(367*4)
17705 /* ------------------------------ */
17706 .L_ALT_OP_UNUSED_70FF: /* 0x170 */
17707 /* File: x86/alt_stub.S */
17709 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
17710 * any interesting requests and then jump to the real instruction
17711 * handler. Unlike the Arm handler, we can't do this as a tail call
17712 * because rIBASE is caller save and we need to reload it.
17715 movl rPC, OUT_ARG0(%esp)
17716 movl %eax, OUT_ARG1(%esp)
17717 call dvmCheckInst # (dPC, self)
17719 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
17720 jmp *dvmAsmInstructionStart+(368*4)
17722 /* ------------------------------ */
17723 .L_ALT_OP_UNUSED_71FF: /* 0x171 */
17724 /* File: x86/alt_stub.S */
17726 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
17727 * any interesting requests and then jump to the real instruction
17728 * handler. Unlike the Arm handler, we can't do this as a tail call
17729 * because rIBASE is caller save and we need to reload it.
17732 movl rPC, OUT_ARG0(%esp)
17733 movl %eax, OUT_ARG1(%esp)
17734 call dvmCheckInst # (dPC, self)
17736 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
17737 jmp *dvmAsmInstructionStart+(369*4)
17739 /* ------------------------------ */
17740 .L_ALT_OP_UNUSED_72FF: /* 0x172 */
17741 /* File: x86/alt_stub.S */
17743 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
17744 * any interesting requests and then jump to the real instruction
17745 * handler. Unlike the Arm handler, we can't do this as a tail call
17746 * because rIBASE is caller save and we need to reload it.
17749 movl rPC, OUT_ARG0(%esp)
17750 movl %eax, OUT_ARG1(%esp)
17751 call dvmCheckInst # (dPC, self)
17753 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
17754 jmp *dvmAsmInstructionStart+(370*4)
17756 /* ------------------------------ */
17757 .L_ALT_OP_UNUSED_73FF: /* 0x173 */
17758 /* File: x86/alt_stub.S */
17760 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
17761 * any interesting requests and then jump to the real instruction
17762 * handler. Unlike the Arm handler, we can't do this as a tail call
17763 * because rIBASE is caller save and we need to reload it.
17766 movl rPC, OUT_ARG0(%esp)
17767 movl %eax, OUT_ARG1(%esp)
17768 call dvmCheckInst # (dPC, self)
17770 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
17771 jmp *dvmAsmInstructionStart+(371*4)
17773 /* ------------------------------ */
17774 .L_ALT_OP_UNUSED_74FF: /* 0x174 */
17775 /* File: x86/alt_stub.S */
17777 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
17778 * any interesting requests and then jump to the real instruction
17779 * handler. Unlike the Arm handler, we can't do this as a tail call
17780 * because rIBASE is caller save and we need to reload it.
17783 movl rPC, OUT_ARG0(%esp)
17784 movl %eax, OUT_ARG1(%esp)
17785 call dvmCheckInst # (dPC, self)
17787 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
17788 jmp *dvmAsmInstructionStart+(372*4)
17790 /* ------------------------------ */
17791 .L_ALT_OP_UNUSED_75FF: /* 0x175 */
17792 /* File: x86/alt_stub.S */
17794 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
17795 * any interesting requests and then jump to the real instruction
17796 * handler. Unlike the Arm handler, we can't do this as a tail call
17797 * because rIBASE is caller save and we need to reload it.
17800 movl rPC, OUT_ARG0(%esp)
17801 movl %eax, OUT_ARG1(%esp)
17802 call dvmCheckInst # (dPC, self)
17804 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
17805 jmp *dvmAsmInstructionStart+(373*4)
17807 /* ------------------------------ */
17808 .L_ALT_OP_UNUSED_76FF: /* 0x176 */
17809 /* File: x86/alt_stub.S */
17811 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
17812 * any interesting requests and then jump to the real instruction
17813 * handler. Unlike the Arm handler, we can't do this as a tail call
17814 * because rIBASE is caller save and we need to reload it.
17817 movl rPC, OUT_ARG0(%esp)
17818 movl %eax, OUT_ARG1(%esp)
17819 call dvmCheckInst # (dPC, self)
17821 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
17822 jmp *dvmAsmInstructionStart+(374*4)
17824 /* ------------------------------ */
17825 .L_ALT_OP_UNUSED_77FF: /* 0x177 */
17826 /* File: x86/alt_stub.S */
17828 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
17829 * any interesting requests and then jump to the real instruction
17830 * handler. Unlike the Arm handler, we can't do this as a tail call
17831 * because rIBASE is caller save and we need to reload it.
17834 movl rPC, OUT_ARG0(%esp)
17835 movl %eax, OUT_ARG1(%esp)
17836 call dvmCheckInst # (dPC, self)
17838 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
17839 jmp *dvmAsmInstructionStart+(375*4)
17841 /* ------------------------------ */
17842 .L_ALT_OP_UNUSED_78FF: /* 0x178 */
17843 /* File: x86/alt_stub.S */
17845 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
17846 * any interesting requests and then jump to the real instruction
17847 * handler. Unlike the Arm handler, we can't do this as a tail call
17848 * because rIBASE is caller save and we need to reload it.
17851 movl rPC, OUT_ARG0(%esp)
17852 movl %eax, OUT_ARG1(%esp)
17853 call dvmCheckInst # (dPC, self)
17855 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
17856 jmp *dvmAsmInstructionStart+(376*4)
17858 /* ------------------------------ */
17859 .L_ALT_OP_UNUSED_79FF: /* 0x179 */
17860 /* File: x86/alt_stub.S */
17862 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
17863 * any interesting requests and then jump to the real instruction
17864 * handler. Unlike the Arm handler, we can't do this as a tail call
17865 * because rIBASE is caller save and we need to reload it.
17868 movl rPC, OUT_ARG0(%esp)
17869 movl %eax, OUT_ARG1(%esp)
17870 call dvmCheckInst # (dPC, self)
17872 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
17873 jmp *dvmAsmInstructionStart+(377*4)
17875 /* ------------------------------ */
17876 .L_ALT_OP_UNUSED_7AFF: /* 0x17a */
17877 /* File: x86/alt_stub.S */
17879 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
17880 * any interesting requests and then jump to the real instruction
17881 * handler. Unlike the Arm handler, we can't do this as a tail call
17882 * because rIBASE is caller save and we need to reload it.
17885 movl rPC, OUT_ARG0(%esp)
17886 movl %eax, OUT_ARG1(%esp)
17887 call dvmCheckInst # (dPC, self)
17889 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
17890 jmp *dvmAsmInstructionStart+(378*4)
17892 /* ------------------------------ */
17893 .L_ALT_OP_UNUSED_7BFF: /* 0x17b */
17894 /* File: x86/alt_stub.S */
17896 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
17897 * any interesting requests and then jump to the real instruction
17898 * handler. Unlike the Arm handler, we can't do this as a tail call
17899 * because rIBASE is caller save and we need to reload it.
17902 movl rPC, OUT_ARG0(%esp)
17903 movl %eax, OUT_ARG1(%esp)
17904 call dvmCheckInst # (dPC, self)
17906 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
17907 jmp *dvmAsmInstructionStart+(379*4)
17909 /* ------------------------------ */
17910 .L_ALT_OP_UNUSED_7CFF: /* 0x17c */
17911 /* File: x86/alt_stub.S */
17913 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
17914 * any interesting requests and then jump to the real instruction
17915 * handler. Unlike the Arm handler, we can't do this as a tail call
17916 * because rIBASE is caller save and we need to reload it.
17919 movl rPC, OUT_ARG0(%esp)
17920 movl %eax, OUT_ARG1(%esp)
17921 call dvmCheckInst # (dPC, self)
17923 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
17924 jmp *dvmAsmInstructionStart+(380*4)
17926 /* ------------------------------ */
17927 .L_ALT_OP_UNUSED_7DFF: /* 0x17d */
17928 /* File: x86/alt_stub.S */
17930 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
17931 * any interesting requests and then jump to the real instruction
17932 * handler. Unlike the Arm handler, we can't do this as a tail call
17933 * because rIBASE is caller save and we need to reload it.
17936 movl rPC, OUT_ARG0(%esp)
17937 movl %eax, OUT_ARG1(%esp)
17938 call dvmCheckInst # (dPC, self)
17940 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
17941 jmp *dvmAsmInstructionStart+(381*4)
17943 /* ------------------------------ */
17944 .L_ALT_OP_UNUSED_7EFF: /* 0x17e */
17945 /* File: x86/alt_stub.S */
17947 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
17948 * any interesting requests and then jump to the real instruction
17949 * handler. Unlike the Arm handler, we can't do this as a tail call
17950 * because rIBASE is caller save and we need to reload it.
17953 movl rPC, OUT_ARG0(%esp)
17954 movl %eax, OUT_ARG1(%esp)
17955 call dvmCheckInst # (dPC, self)
17957 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
17958 jmp *dvmAsmInstructionStart+(382*4)
17960 /* ------------------------------ */
17961 .L_ALT_OP_UNUSED_7FFF: /* 0x17f */
17962 /* File: x86/alt_stub.S */
17964 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
17965 * any interesting requests and then jump to the real instruction
17966 * handler. Unlike the Arm handler, we can't do this as a tail call
17967 * because rIBASE is caller save and we need to reload it.
17970 movl rPC, OUT_ARG0(%esp)
17971 movl %eax, OUT_ARG1(%esp)
17972 call dvmCheckInst # (dPC, self)
17974 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
17975 jmp *dvmAsmInstructionStart+(383*4)
17977 /* ------------------------------ */
17978 .L_ALT_OP_UNUSED_80FF: /* 0x180 */
17979 /* File: x86/alt_stub.S */
17981 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
17982 * any interesting requests and then jump to the real instruction
17983 * handler. Unlike the Arm handler, we can't do this as a tail call
17984 * because rIBASE is caller save and we need to reload it.
17987 movl rPC, OUT_ARG0(%esp)
17988 movl %eax, OUT_ARG1(%esp)
17989 call dvmCheckInst # (dPC, self)
17991 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
17992 jmp *dvmAsmInstructionStart+(384*4)
17994 /* ------------------------------ */
17995 .L_ALT_OP_UNUSED_81FF: /* 0x181 */
17996 /* File: x86/alt_stub.S */
17998 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
17999 * any interesting requests and then jump to the real instruction
18000 * handler. Unlike the Arm handler, we can't do this as a tail call
18001 * because rIBASE is caller save and we need to reload it.
18004 movl rPC, OUT_ARG0(%esp)
18005 movl %eax, OUT_ARG1(%esp)
18006 call dvmCheckInst # (dPC, self)
18008 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
18009 jmp *dvmAsmInstructionStart+(385*4)
18011 /* ------------------------------ */
18012 .L_ALT_OP_UNUSED_82FF: /* 0x182 */
18013 /* File: x86/alt_stub.S */
18015 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
18016 * any interesting requests and then jump to the real instruction
18017 * handler. Unlike the Arm handler, we can't do this as a tail call
18018 * because rIBASE is caller save and we need to reload it.
18021 movl rPC, OUT_ARG0(%esp)
18022 movl %eax, OUT_ARG1(%esp)
18023 call dvmCheckInst # (dPC, self)
18025 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
18026 jmp *dvmAsmInstructionStart+(386*4)
18028 /* ------------------------------ */
18029 .L_ALT_OP_UNUSED_83FF: /* 0x183 */
18030 /* File: x86/alt_stub.S */
18032 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
18033 * any interesting requests and then jump to the real instruction
18034 * handler. Unlike the Arm handler, we can't do this as a tail call
18035 * because rIBASE is caller save and we need to reload it.
18038 movl rPC, OUT_ARG0(%esp)
18039 movl %eax, OUT_ARG1(%esp)
18040 call dvmCheckInst # (dPC, self)
18042 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
18043 jmp *dvmAsmInstructionStart+(387*4)
18045 /* ------------------------------ */
18046 .L_ALT_OP_UNUSED_84FF: /* 0x184 */
18047 /* File: x86/alt_stub.S */
18049 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
18050 * any interesting requests and then jump to the real instruction
18051 * handler. Unlike the Arm handler, we can't do this as a tail call
18052 * because rIBASE is caller save and we need to reload it.
18055 movl rPC, OUT_ARG0(%esp)
18056 movl %eax, OUT_ARG1(%esp)
18057 call dvmCheckInst # (dPC, self)
18059 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
18060 jmp *dvmAsmInstructionStart+(388*4)
18062 /* ------------------------------ */
18063 .L_ALT_OP_UNUSED_85FF: /* 0x185 */
18064 /* File: x86/alt_stub.S */
18066 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
18067 * any interesting requests and then jump to the real instruction
18068 * handler. Unlike the Arm handler, we can't do this as a tail call
18069 * because rIBASE is caller save and we need to reload it.
18072 movl rPC, OUT_ARG0(%esp)
18073 movl %eax, OUT_ARG1(%esp)
18074 call dvmCheckInst # (dPC, self)
18076 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
18077 jmp *dvmAsmInstructionStart+(389*4)
18079 /* ------------------------------ */
18080 .L_ALT_OP_UNUSED_86FF: /* 0x186 */
18081 /* File: x86/alt_stub.S */
18083 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
18084 * any interesting requests and then jump to the real instruction
18085 * handler. Unlike the Arm handler, we can't do this as a tail call
18086 * because rIBASE is caller save and we need to reload it.
18089 movl rPC, OUT_ARG0(%esp)
18090 movl %eax, OUT_ARG1(%esp)
18091 call dvmCheckInst # (dPC, self)
18093 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
18094 jmp *dvmAsmInstructionStart+(390*4)
18096 /* ------------------------------ */
18097 .L_ALT_OP_UNUSED_87FF: /* 0x187 */
18098 /* File: x86/alt_stub.S */
18100 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
18101 * any interesting requests and then jump to the real instruction
18102 * handler. Unlike the Arm handler, we can't do this as a tail call
18103 * because rIBASE is caller save and we need to reload it.
18106 movl rPC, OUT_ARG0(%esp)
18107 movl %eax, OUT_ARG1(%esp)
18108 call dvmCheckInst # (dPC, self)
18110 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
18111 jmp *dvmAsmInstructionStart+(391*4)
18113 /* ------------------------------ */
18114 .L_ALT_OP_UNUSED_88FF: /* 0x188 */
18115 /* File: x86/alt_stub.S */
18117 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
18118 * any interesting requests and then jump to the real instruction
18119 * handler. Unlike the Arm handler, we can't do this as a tail call
18120 * because rIBASE is caller save and we need to reload it.
18123 movl rPC, OUT_ARG0(%esp)
18124 movl %eax, OUT_ARG1(%esp)
18125 call dvmCheckInst # (dPC, self)
18127 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
18128 jmp *dvmAsmInstructionStart+(392*4)
18130 /* ------------------------------ */
18131 .L_ALT_OP_UNUSED_89FF: /* 0x189 */
18132 /* File: x86/alt_stub.S */
18134 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
18135 * any interesting requests and then jump to the real instruction
18136 * handler. Unlike the Arm handler, we can't do this as a tail call
18137 * because rIBASE is caller save and we need to reload it.
18140 movl rPC, OUT_ARG0(%esp)
18141 movl %eax, OUT_ARG1(%esp)
18142 call dvmCheckInst # (dPC, self)
18144 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
18145 jmp *dvmAsmInstructionStart+(393*4)
18147 /* ------------------------------ */
18148 .L_ALT_OP_UNUSED_8AFF: /* 0x18a */
18149 /* File: x86/alt_stub.S */
18151 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
18152 * any interesting requests and then jump to the real instruction
18153 * handler. Unlike the Arm handler, we can't do this as a tail call
18154 * because rIBASE is caller save and we need to reload it.
18157 movl rPC, OUT_ARG0(%esp)
18158 movl %eax, OUT_ARG1(%esp)
18159 call dvmCheckInst # (dPC, self)
18161 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
18162 jmp *dvmAsmInstructionStart+(394*4)
18164 /* ------------------------------ */
18165 .L_ALT_OP_UNUSED_8BFF: /* 0x18b */
18166 /* File: x86/alt_stub.S */
18168 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
18169 * any interesting requests and then jump to the real instruction
18170 * handler. Unlike the Arm handler, we can't do this as a tail call
18171 * because rIBASE is caller save and we need to reload it.
18174 movl rPC, OUT_ARG0(%esp)
18175 movl %eax, OUT_ARG1(%esp)
18176 call dvmCheckInst # (dPC, self)
18178 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
18179 jmp *dvmAsmInstructionStart+(395*4)
18181 /* ------------------------------ */
18182 .L_ALT_OP_UNUSED_8CFF: /* 0x18c */
18183 /* File: x86/alt_stub.S */
18185 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
18186 * any interesting requests and then jump to the real instruction
18187 * handler. Unlike the Arm handler, we can't do this as a tail call
18188 * because rIBASE is caller save and we need to reload it.
18191 movl rPC, OUT_ARG0(%esp)
18192 movl %eax, OUT_ARG1(%esp)
18193 call dvmCheckInst # (dPC, self)
18195 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
18196 jmp *dvmAsmInstructionStart+(396*4)
18198 /* ------------------------------ */
18199 .L_ALT_OP_UNUSED_8DFF: /* 0x18d */
18200 /* File: x86/alt_stub.S */
18202 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
18203 * any interesting requests and then jump to the real instruction
18204 * handler. Unlike the Arm handler, we can't do this as a tail call
18205 * because rIBASE is caller save and we need to reload it.
18208 movl rPC, OUT_ARG0(%esp)
18209 movl %eax, OUT_ARG1(%esp)
18210 call dvmCheckInst # (dPC, self)
18212 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
18213 jmp *dvmAsmInstructionStart+(397*4)
18215 /* ------------------------------ */
18216 .L_ALT_OP_UNUSED_8EFF: /* 0x18e */
18217 /* File: x86/alt_stub.S */
18219 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
18220 * any interesting requests and then jump to the real instruction
18221 * handler. Unlike the Arm handler, we can't do this as a tail call
18222 * because rIBASE is caller save and we need to reload it.
18225 movl rPC, OUT_ARG0(%esp)
18226 movl %eax, OUT_ARG1(%esp)
18227 call dvmCheckInst # (dPC, self)
18229 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
18230 jmp *dvmAsmInstructionStart+(398*4)
18232 /* ------------------------------ */
18233 .L_ALT_OP_UNUSED_8FFF: /* 0x18f */
18234 /* File: x86/alt_stub.S */
18236 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
18237 * any interesting requests and then jump to the real instruction
18238 * handler. Unlike the Arm handler, we can't do this as a tail call
18239 * because rIBASE is caller save and we need to reload it.
18242 movl rPC, OUT_ARG0(%esp)
18243 movl %eax, OUT_ARG1(%esp)
18244 call dvmCheckInst # (dPC, self)
18246 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
18247 jmp *dvmAsmInstructionStart+(399*4)
18249 /* ------------------------------ */
18250 .L_ALT_OP_UNUSED_90FF: /* 0x190 */
18251 /* File: x86/alt_stub.S */
18253 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
18254 * any interesting requests and then jump to the real instruction
18255 * handler. Unlike the Arm handler, we can't do this as a tail call
18256 * because rIBASE is caller save and we need to reload it.
18259 movl rPC, OUT_ARG0(%esp)
18260 movl %eax, OUT_ARG1(%esp)
18261 call dvmCheckInst # (dPC, self)
18263 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
18264 jmp *dvmAsmInstructionStart+(400*4)
18266 /* ------------------------------ */
18267 .L_ALT_OP_UNUSED_91FF: /* 0x191 */
18268 /* File: x86/alt_stub.S */
18270 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
18271 * any interesting requests and then jump to the real instruction
18272 * handler. Unlike the Arm handler, we can't do this as a tail call
18273 * because rIBASE is caller save and we need to reload it.
18276 movl rPC, OUT_ARG0(%esp)
18277 movl %eax, OUT_ARG1(%esp)
18278 call dvmCheckInst # (dPC, self)
18280 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
18281 jmp *dvmAsmInstructionStart+(401*4)
18283 /* ------------------------------ */
18284 .L_ALT_OP_UNUSED_92FF: /* 0x192 */
18285 /* File: x86/alt_stub.S */
18287 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
18288 * any interesting requests and then jump to the real instruction
18289 * handler. Unlike the Arm handler, we can't do this as a tail call
18290 * because rIBASE is caller save and we need to reload it.
18293 movl rPC, OUT_ARG0(%esp)
18294 movl %eax, OUT_ARG1(%esp)
18295 call dvmCheckInst # (dPC, self)
18297 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
18298 jmp *dvmAsmInstructionStart+(402*4)
18300 /* ------------------------------ */
18301 .L_ALT_OP_UNUSED_93FF: /* 0x193 */
18302 /* File: x86/alt_stub.S */
18304 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
18305 * any interesting requests and then jump to the real instruction
18306 * handler. Unlike the Arm handler, we can't do this as a tail call
18307 * because rIBASE is caller save and we need to reload it.
18310 movl rPC, OUT_ARG0(%esp)
18311 movl %eax, OUT_ARG1(%esp)
18312 call dvmCheckInst # (dPC, self)
18314 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
18315 jmp *dvmAsmInstructionStart+(403*4)
18317 /* ------------------------------ */
18318 .L_ALT_OP_UNUSED_94FF: /* 0x194 */
18319 /* File: x86/alt_stub.S */
18321 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
18322 * any interesting requests and then jump to the real instruction
18323 * handler. Unlike the Arm handler, we can't do this as a tail call
18324 * because rIBASE is caller save and we need to reload it.
18327 movl rPC, OUT_ARG0(%esp)
18328 movl %eax, OUT_ARG1(%esp)
18329 call dvmCheckInst # (dPC, self)
18331 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
18332 jmp *dvmAsmInstructionStart+(404*4)
18334 /* ------------------------------ */
18335 .L_ALT_OP_UNUSED_95FF: /* 0x195 */
18336 /* File: x86/alt_stub.S */
18338 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
18339 * any interesting requests and then jump to the real instruction
18340 * handler. Unlike the Arm handler, we can't do this as a tail call
18341 * because rIBASE is caller save and we need to reload it.
18344 movl rPC, OUT_ARG0(%esp)
18345 movl %eax, OUT_ARG1(%esp)
18346 call dvmCheckInst # (dPC, self)
18348 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
18349 jmp *dvmAsmInstructionStart+(405*4)
18351 /* ------------------------------ */
18352 .L_ALT_OP_UNUSED_96FF: /* 0x196 */
18353 /* File: x86/alt_stub.S */
18355 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
18356 * any interesting requests and then jump to the real instruction
18357 * handler. Unlike the Arm handler, we can't do this as a tail call
18358 * because rIBASE is caller save and we need to reload it.
18361 movl rPC, OUT_ARG0(%esp)
18362 movl %eax, OUT_ARG1(%esp)
18363 call dvmCheckInst # (dPC, self)
18365 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
18366 jmp *dvmAsmInstructionStart+(406*4)
18368 /* ------------------------------ */
18369 .L_ALT_OP_UNUSED_97FF: /* 0x197 */
18370 /* File: x86/alt_stub.S */
18372 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
18373 * any interesting requests and then jump to the real instruction
18374 * handler. Unlike the Arm handler, we can't do this as a tail call
18375 * because rIBASE is caller save and we need to reload it.
18378 movl rPC, OUT_ARG0(%esp)
18379 movl %eax, OUT_ARG1(%esp)
18380 call dvmCheckInst # (dPC, self)
18382 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
18383 jmp *dvmAsmInstructionStart+(407*4)
18385 /* ------------------------------ */
18386 .L_ALT_OP_UNUSED_98FF: /* 0x198 */
18387 /* File: x86/alt_stub.S */
18389 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
18390 * any interesting requests and then jump to the real instruction
18391 * handler. Unlike the Arm handler, we can't do this as a tail call
18392 * because rIBASE is caller save and we need to reload it.
18395 movl rPC, OUT_ARG0(%esp)
18396 movl %eax, OUT_ARG1(%esp)
18397 call dvmCheckInst # (dPC, self)
18399 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
18400 jmp *dvmAsmInstructionStart+(408*4)
18402 /* ------------------------------ */
18403 .L_ALT_OP_UNUSED_99FF: /* 0x199 */
18404 /* File: x86/alt_stub.S */
18406 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
18407 * any interesting requests and then jump to the real instruction
18408 * handler. Unlike the Arm handler, we can't do this as a tail call
18409 * because rIBASE is caller save and we need to reload it.
18412 movl rPC, OUT_ARG0(%esp)
18413 movl %eax, OUT_ARG1(%esp)
18414 call dvmCheckInst # (dPC, self)
18416 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
18417 jmp *dvmAsmInstructionStart+(409*4)
18419 /* ------------------------------ */
18420 .L_ALT_OP_UNUSED_9AFF: /* 0x19a */
18421 /* File: x86/alt_stub.S */
18423 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
18424 * any interesting requests and then jump to the real instruction
18425 * handler. Unlike the Arm handler, we can't do this as a tail call
18426 * because rIBASE is caller save and we need to reload it.
18429 movl rPC, OUT_ARG0(%esp)
18430 movl %eax, OUT_ARG1(%esp)
18431 call dvmCheckInst # (dPC, self)
18433 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
18434 jmp *dvmAsmInstructionStart+(410*4)
18436 /* ------------------------------ */
18437 .L_ALT_OP_UNUSED_9BFF: /* 0x19b */
18438 /* File: x86/alt_stub.S */
18440 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
18441 * any interesting requests and then jump to the real instruction
18442 * handler. Unlike the Arm handler, we can't do this as a tail call
18443 * because rIBASE is caller save and we need to reload it.
18446 movl rPC, OUT_ARG0(%esp)
18447 movl %eax, OUT_ARG1(%esp)
18448 call dvmCheckInst # (dPC, self)
18450 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
18451 jmp *dvmAsmInstructionStart+(411*4)
18453 /* ------------------------------ */
18454 .L_ALT_OP_UNUSED_9CFF: /* 0x19c */
18455 /* File: x86/alt_stub.S */
18457 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
18458 * any interesting requests and then jump to the real instruction
18459 * handler. Unlike the Arm handler, we can't do this as a tail call
18460 * because rIBASE is caller save and we need to reload it.
18463 movl rPC, OUT_ARG0(%esp)
18464 movl %eax, OUT_ARG1(%esp)
18465 call dvmCheckInst # (dPC, self)
18467 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
18468 jmp *dvmAsmInstructionStart+(412*4)
18470 /* ------------------------------ */
18471 .L_ALT_OP_UNUSED_9DFF: /* 0x19d */
18472 /* File: x86/alt_stub.S */
18474 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
18475 * any interesting requests and then jump to the real instruction
18476 * handler. Unlike the Arm handler, we can't do this as a tail call
18477 * because rIBASE is caller save and we need to reload it.
18480 movl rPC, OUT_ARG0(%esp)
18481 movl %eax, OUT_ARG1(%esp)
18482 call dvmCheckInst # (dPC, self)
18484 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
18485 jmp *dvmAsmInstructionStart+(413*4)
18487 /* ------------------------------ */
18488 .L_ALT_OP_UNUSED_9EFF: /* 0x19e */
18489 /* File: x86/alt_stub.S */
18491 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
18492 * any interesting requests and then jump to the real instruction
18493 * handler. Unlike the Arm handler, we can't do this as a tail call
18494 * because rIBASE is caller save and we need to reload it.
18497 movl rPC, OUT_ARG0(%esp)
18498 movl %eax, OUT_ARG1(%esp)
18499 call dvmCheckInst # (dPC, self)
18501 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
18502 jmp *dvmAsmInstructionStart+(414*4)
18504 /* ------------------------------ */
18505 .L_ALT_OP_UNUSED_9FFF: /* 0x19f */
18506 /* File: x86/alt_stub.S */
18508 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
18509 * any interesting requests and then jump to the real instruction
18510 * handler. Unlike the Arm handler, we can't do this as a tail call
18511 * because rIBASE is caller save and we need to reload it.
18514 movl rPC, OUT_ARG0(%esp)
18515 movl %eax, OUT_ARG1(%esp)
18516 call dvmCheckInst # (dPC, self)
18518 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
18519 jmp *dvmAsmInstructionStart+(415*4)
18521 /* ------------------------------ */
18522 .L_ALT_OP_UNUSED_A0FF: /* 0x1a0 */
18523 /* File: x86/alt_stub.S */
18525 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
18526 * any interesting requests and then jump to the real instruction
18527 * handler. Unlike the Arm handler, we can't do this as a tail call
18528 * because rIBASE is caller save and we need to reload it.
18531 movl rPC, OUT_ARG0(%esp)
18532 movl %eax, OUT_ARG1(%esp)
18533 call dvmCheckInst # (dPC, self)
18535 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
18536 jmp *dvmAsmInstructionStart+(416*4)
18538 /* ------------------------------ */
18539 .L_ALT_OP_UNUSED_A1FF: /* 0x1a1 */
18540 /* File: x86/alt_stub.S */
18542 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
18543 * any interesting requests and then jump to the real instruction
18544 * handler. Unlike the Arm handler, we can't do this as a tail call
18545 * because rIBASE is caller save and we need to reload it.
18548 movl rPC, OUT_ARG0(%esp)
18549 movl %eax, OUT_ARG1(%esp)
18550 call dvmCheckInst # (dPC, self)
18552 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
18553 jmp *dvmAsmInstructionStart+(417*4)
18555 /* ------------------------------ */
18556 .L_ALT_OP_UNUSED_A2FF: /* 0x1a2 */
18557 /* File: x86/alt_stub.S */
18559 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
18560 * any interesting requests and then jump to the real instruction
18561 * handler. Unlike the Arm handler, we can't do this as a tail call
18562 * because rIBASE is caller save and we need to reload it.
18565 movl rPC, OUT_ARG0(%esp)
18566 movl %eax, OUT_ARG1(%esp)
18567 call dvmCheckInst # (dPC, self)
18569 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
18570 jmp *dvmAsmInstructionStart+(418*4)
18572 /* ------------------------------ */
18573 .L_ALT_OP_UNUSED_A3FF: /* 0x1a3 */
18574 /* File: x86/alt_stub.S */
18576 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
18577 * any interesting requests and then jump to the real instruction
18578 * handler. Unlike the Arm handler, we can't do this as a tail call
18579 * because rIBASE is caller save and we need to reload it.
18582 movl rPC, OUT_ARG0(%esp)
18583 movl %eax, OUT_ARG1(%esp)
18584 call dvmCheckInst # (dPC, self)
18586 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
18587 jmp *dvmAsmInstructionStart+(419*4)
18589 /* ------------------------------ */
18590 .L_ALT_OP_UNUSED_A4FF: /* 0x1a4 */
18591 /* File: x86/alt_stub.S */
18593 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
18594 * any interesting requests and then jump to the real instruction
18595 * handler. Unlike the Arm handler, we can't do this as a tail call
18596 * because rIBASE is caller save and we need to reload it.
18599 movl rPC, OUT_ARG0(%esp)
18600 movl %eax, OUT_ARG1(%esp)
18601 call dvmCheckInst # (dPC, self)
18603 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
18604 jmp *dvmAsmInstructionStart+(420*4)
18606 /* ------------------------------ */
18607 .L_ALT_OP_UNUSED_A5FF: /* 0x1a5 */
18608 /* File: x86/alt_stub.S */
18610 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
18611 * any interesting requests and then jump to the real instruction
18612 * handler. Unlike the Arm handler, we can't do this as a tail call
18613 * because rIBASE is caller save and we need to reload it.
18616 movl rPC, OUT_ARG0(%esp)
18617 movl %eax, OUT_ARG1(%esp)
18618 call dvmCheckInst # (dPC, self)
18620 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
18621 jmp *dvmAsmInstructionStart+(421*4)
18623 /* ------------------------------ */
18624 .L_ALT_OP_UNUSED_A6FF: /* 0x1a6 */
18625 /* File: x86/alt_stub.S */
18627 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
18628 * any interesting requests and then jump to the real instruction
18629 * handler. Unlike the Arm handler, we can't do this as a tail call
18630 * because rIBASE is caller save and we need to reload it.
18633 movl rPC, OUT_ARG0(%esp)
18634 movl %eax, OUT_ARG1(%esp)
18635 call dvmCheckInst # (dPC, self)
18637 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
18638 jmp *dvmAsmInstructionStart+(422*4)
18640 /* ------------------------------ */
18641 .L_ALT_OP_UNUSED_A7FF: /* 0x1a7 */
18642 /* File: x86/alt_stub.S */
18644 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
18645 * any interesting requests and then jump to the real instruction
18646 * handler. Unlike the Arm handler, we can't do this as a tail call
18647 * because rIBASE is caller save and we need to reload it.
18650 movl rPC, OUT_ARG0(%esp)
18651 movl %eax, OUT_ARG1(%esp)
18652 call dvmCheckInst # (dPC, self)
18654 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
18655 jmp *dvmAsmInstructionStart+(423*4)
18657 /* ------------------------------ */
18658 .L_ALT_OP_UNUSED_A8FF: /* 0x1a8 */
18659 /* File: x86/alt_stub.S */
18661 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
18662 * any interesting requests and then jump to the real instruction
18663 * handler. Unlike the Arm handler, we can't do this as a tail call
18664 * because rIBASE is caller save and we need to reload it.
18667 movl rPC, OUT_ARG0(%esp)
18668 movl %eax, OUT_ARG1(%esp)
18669 call dvmCheckInst # (dPC, self)
18671 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
18672 jmp *dvmAsmInstructionStart+(424*4)
18674 /* ------------------------------ */
18675 .L_ALT_OP_UNUSED_A9FF: /* 0x1a9 */
18676 /* File: x86/alt_stub.S */
18678 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
18679 * any interesting requests and then jump to the real instruction
18680 * handler. Unlike the Arm handler, we can't do this as a tail call
18681 * because rIBASE is caller save and we need to reload it.
18684 movl rPC, OUT_ARG0(%esp)
18685 movl %eax, OUT_ARG1(%esp)
18686 call dvmCheckInst # (dPC, self)
18688 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
18689 jmp *dvmAsmInstructionStart+(425*4)
18691 /* ------------------------------ */
18692 .L_ALT_OP_UNUSED_AAFF: /* 0x1aa */
18693 /* File: x86/alt_stub.S */
18695 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
18696 * any interesting requests and then jump to the real instruction
18697 * handler. Unlike the Arm handler, we can't do this as a tail call
18698 * because rIBASE is caller save and we need to reload it.
18701 movl rPC, OUT_ARG0(%esp)
18702 movl %eax, OUT_ARG1(%esp)
18703 call dvmCheckInst # (dPC, self)
18705 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
18706 jmp *dvmAsmInstructionStart+(426*4)
18708 /* ------------------------------ */
18709 .L_ALT_OP_UNUSED_ABFF: /* 0x1ab */
18710 /* File: x86/alt_stub.S */
18712 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
18713 * any interesting requests and then jump to the real instruction
18714 * handler. Unlike the Arm handler, we can't do this as a tail call
18715 * because rIBASE is caller save and we need to reload it.
18718 movl rPC, OUT_ARG0(%esp)
18719 movl %eax, OUT_ARG1(%esp)
18720 call dvmCheckInst # (dPC, self)
18722 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
18723 jmp *dvmAsmInstructionStart+(427*4)
18725 /* ------------------------------ */
18726 .L_ALT_OP_UNUSED_ACFF: /* 0x1ac */
18727 /* File: x86/alt_stub.S */
18729 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
18730 * any interesting requests and then jump to the real instruction
18731 * handler. Unlike the Arm handler, we can't do this as a tail call
18732 * because rIBASE is caller save and we need to reload it.
18735 movl rPC, OUT_ARG0(%esp)
18736 movl %eax, OUT_ARG1(%esp)
18737 call dvmCheckInst # (dPC, self)
18739 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
18740 jmp *dvmAsmInstructionStart+(428*4)
18742 /* ------------------------------ */
18743 .L_ALT_OP_UNUSED_ADFF: /* 0x1ad */
18744 /* File: x86/alt_stub.S */
18746 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
18747 * any interesting requests and then jump to the real instruction
18748 * handler. Unlike the Arm handler, we can't do this as a tail call
18749 * because rIBASE is caller save and we need to reload it.
18752 movl rPC, OUT_ARG0(%esp)
18753 movl %eax, OUT_ARG1(%esp)
18754 call dvmCheckInst # (dPC, self)
18756 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
18757 jmp *dvmAsmInstructionStart+(429*4)
18759 /* ------------------------------ */
18760 .L_ALT_OP_UNUSED_AEFF: /* 0x1ae */
18761 /* File: x86/alt_stub.S */
18763 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
18764 * any interesting requests and then jump to the real instruction
18765 * handler. Unlike the Arm handler, we can't do this as a tail call
18766 * because rIBASE is caller save and we need to reload it.
18769 movl rPC, OUT_ARG0(%esp)
18770 movl %eax, OUT_ARG1(%esp)
18771 call dvmCheckInst # (dPC, self)
18773 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
18774 jmp *dvmAsmInstructionStart+(430*4)
18776 /* ------------------------------ */
18777 .L_ALT_OP_UNUSED_AFFF: /* 0x1af */
18778 /* File: x86/alt_stub.S */
18780 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
18781 * any interesting requests and then jump to the real instruction
18782 * handler. Unlike the Arm handler, we can't do this as a tail call
18783 * because rIBASE is caller save and we need to reload it.
18786 movl rPC, OUT_ARG0(%esp)
18787 movl %eax, OUT_ARG1(%esp)
18788 call dvmCheckInst # (dPC, self)
18790 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
18791 jmp *dvmAsmInstructionStart+(431*4)
18793 /* ------------------------------ */
18794 .L_ALT_OP_UNUSED_B0FF: /* 0x1b0 */
18795 /* File: x86/alt_stub.S */
18797 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
18798 * any interesting requests and then jump to the real instruction
18799 * handler. Unlike the Arm handler, we can't do this as a tail call
18800 * because rIBASE is caller save and we need to reload it.
18803 movl rPC, OUT_ARG0(%esp)
18804 movl %eax, OUT_ARG1(%esp)
18805 call dvmCheckInst # (dPC, self)
18807 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
18808 jmp *dvmAsmInstructionStart+(432*4)
18810 /* ------------------------------ */
18811 .L_ALT_OP_UNUSED_B1FF: /* 0x1b1 */
18812 /* File: x86/alt_stub.S */
18814 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
18815 * any interesting requests and then jump to the real instruction
18816 * handler. Unlike the Arm handler, we can't do this as a tail call
18817 * because rIBASE is caller save and we need to reload it.
18820 movl rPC, OUT_ARG0(%esp)
18821 movl %eax, OUT_ARG1(%esp)
18822 call dvmCheckInst # (dPC, self)
18824 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
18825 jmp *dvmAsmInstructionStart+(433*4)
18827 /* ------------------------------ */
18828 .L_ALT_OP_UNUSED_B2FF: /* 0x1b2 */
18829 /* File: x86/alt_stub.S */
18831 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
18832 * any interesting requests and then jump to the real instruction
18833 * handler. Unlike the Arm handler, we can't do this as a tail call
18834 * because rIBASE is caller save and we need to reload it.
18837 movl rPC, OUT_ARG0(%esp)
18838 movl %eax, OUT_ARG1(%esp)
18839 call dvmCheckInst # (dPC, self)
18841 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
18842 jmp *dvmAsmInstructionStart+(434*4)
18844 /* ------------------------------ */
18845 .L_ALT_OP_UNUSED_B3FF: /* 0x1b3 */
18846 /* File: x86/alt_stub.S */
18848 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
18849 * any interesting requests and then jump to the real instruction
18850 * handler. Unlike the Arm handler, we can't do this as a tail call
18851 * because rIBASE is caller save and we need to reload it.
18854 movl rPC, OUT_ARG0(%esp)
18855 movl %eax, OUT_ARG1(%esp)
18856 call dvmCheckInst # (dPC, self)
18858 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
18859 jmp *dvmAsmInstructionStart+(435*4)
18861 /* ------------------------------ */
18862 .L_ALT_OP_UNUSED_B4FF: /* 0x1b4 */
18863 /* File: x86/alt_stub.S */
18865 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
18866 * any interesting requests and then jump to the real instruction
18867 * handler. Unlike the Arm handler, we can't do this as a tail call
18868 * because rIBASE is caller save and we need to reload it.
18871 movl rPC, OUT_ARG0(%esp)
18872 movl %eax, OUT_ARG1(%esp)
18873 call dvmCheckInst # (dPC, self)
18875 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
18876 jmp *dvmAsmInstructionStart+(436*4)
18878 /* ------------------------------ */
18879 .L_ALT_OP_UNUSED_B5FF: /* 0x1b5 */
18880 /* File: x86/alt_stub.S */
18882 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
18883 * any interesting requests and then jump to the real instruction
18884 * handler. Unlike the Arm handler, we can't do this as a tail call
18885 * because rIBASE is caller save and we need to reload it.
18888 movl rPC, OUT_ARG0(%esp)
18889 movl %eax, OUT_ARG1(%esp)
18890 call dvmCheckInst # (dPC, self)
18892 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
18893 jmp *dvmAsmInstructionStart+(437*4)
18895 /* ------------------------------ */
18896 .L_ALT_OP_UNUSED_B6FF: /* 0x1b6 */
18897 /* File: x86/alt_stub.S */
18899 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
18900 * any interesting requests and then jump to the real instruction
18901 * handler. Unlike the Arm handler, we can't do this as a tail call
18902 * because rIBASE is caller save and we need to reload it.
18905 movl rPC, OUT_ARG0(%esp)
18906 movl %eax, OUT_ARG1(%esp)
18907 call dvmCheckInst # (dPC, self)
18909 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
18910 jmp *dvmAsmInstructionStart+(438*4)
18912 /* ------------------------------ */
18913 .L_ALT_OP_UNUSED_B7FF: /* 0x1b7 */
18914 /* File: x86/alt_stub.S */
18916 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
18917 * any interesting requests and then jump to the real instruction
18918 * handler. Unlike the Arm handler, we can't do this as a tail call
18919 * because rIBASE is caller save and we need to reload it.
18922 movl rPC, OUT_ARG0(%esp)
18923 movl %eax, OUT_ARG1(%esp)
18924 call dvmCheckInst # (dPC, self)
18926 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
18927 jmp *dvmAsmInstructionStart+(439*4)
18929 /* ------------------------------ */
18930 .L_ALT_OP_UNUSED_B8FF: /* 0x1b8 */
18931 /* File: x86/alt_stub.S */
18933 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
18934 * any interesting requests and then jump to the real instruction
18935 * handler. Unlike the Arm handler, we can't do this as a tail call
18936 * because rIBASE is caller save and we need to reload it.
18939 movl rPC, OUT_ARG0(%esp)
18940 movl %eax, OUT_ARG1(%esp)
18941 call dvmCheckInst # (dPC, self)
18943 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
18944 jmp *dvmAsmInstructionStart+(440*4)
18946 /* ------------------------------ */
18947 .L_ALT_OP_UNUSED_B9FF: /* 0x1b9 */
18948 /* File: x86/alt_stub.S */
18950 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
18951 * any interesting requests and then jump to the real instruction
18952 * handler. Unlike the Arm handler, we can't do this as a tail call
18953 * because rIBASE is caller save and we need to reload it.
18956 movl rPC, OUT_ARG0(%esp)
18957 movl %eax, OUT_ARG1(%esp)
18958 call dvmCheckInst # (dPC, self)
18960 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
18961 jmp *dvmAsmInstructionStart+(441*4)
18963 /* ------------------------------ */
18964 .L_ALT_OP_UNUSED_BAFF: /* 0x1ba */
18965 /* File: x86/alt_stub.S */
18967 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
18968 * any interesting requests and then jump to the real instruction
18969 * handler. Unlike the Arm handler, we can't do this as a tail call
18970 * because rIBASE is caller save and we need to reload it.
18973 movl rPC, OUT_ARG0(%esp)
18974 movl %eax, OUT_ARG1(%esp)
18975 call dvmCheckInst # (dPC, self)
18977 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
18978 jmp *dvmAsmInstructionStart+(442*4)
18980 /* ------------------------------ */
18981 .L_ALT_OP_UNUSED_BBFF: /* 0x1bb */
18982 /* File: x86/alt_stub.S */
18984 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
18985 * any interesting requests and then jump to the real instruction
18986 * handler. Unlike the Arm handler, we can't do this as a tail call
18987 * because rIBASE is caller save and we need to reload it.
18990 movl rPC, OUT_ARG0(%esp)
18991 movl %eax, OUT_ARG1(%esp)
18992 call dvmCheckInst # (dPC, self)
18994 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
18995 jmp *dvmAsmInstructionStart+(443*4)
18997 /* ------------------------------ */
18998 .L_ALT_OP_UNUSED_BCFF: /* 0x1bc */
18999 /* File: x86/alt_stub.S */
19001 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
19002 * any interesting requests and then jump to the real instruction
19003 * handler. Unlike the Arm handler, we can't do this as a tail call
19004 * because rIBASE is caller save and we need to reload it.
19007 movl rPC, OUT_ARG0(%esp)
19008 movl %eax, OUT_ARG1(%esp)
19009 call dvmCheckInst # (dPC, self)
19011 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
19012 jmp *dvmAsmInstructionStart+(444*4)
19014 /* ------------------------------ */
19015 .L_ALT_OP_UNUSED_BDFF: /* 0x1bd */
19016 /* File: x86/alt_stub.S */
19018 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
19019 * any interesting requests and then jump to the real instruction
19020 * handler. Unlike the Arm handler, we can't do this as a tail call
19021 * because rIBASE is caller save and we need to reload it.
19024 movl rPC, OUT_ARG0(%esp)
19025 movl %eax, OUT_ARG1(%esp)
19026 call dvmCheckInst # (dPC, self)
19028 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
19029 jmp *dvmAsmInstructionStart+(445*4)
19031 /* ------------------------------ */
19032 .L_ALT_OP_UNUSED_BEFF: /* 0x1be */
19033 /* File: x86/alt_stub.S */
19035 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
19036 * any interesting requests and then jump to the real instruction
19037 * handler. Unlike the Arm handler, we can't do this as a tail call
19038 * because rIBASE is caller save and we need to reload it.
19041 movl rPC, OUT_ARG0(%esp)
19042 movl %eax, OUT_ARG1(%esp)
19043 call dvmCheckInst # (dPC, self)
19045 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
19046 jmp *dvmAsmInstructionStart+(446*4)
19048 /* ------------------------------ */
19049 .L_ALT_OP_UNUSED_BFFF: /* 0x1bf */
19050 /* File: x86/alt_stub.S */
19052 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
19053 * any interesting requests and then jump to the real instruction
19054 * handler. Unlike the Arm handler, we can't do this as a tail call
19055 * because rIBASE is caller save and we need to reload it.
19058 movl rPC, OUT_ARG0(%esp)
19059 movl %eax, OUT_ARG1(%esp)
19060 call dvmCheckInst # (dPC, self)
19062 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
19063 jmp *dvmAsmInstructionStart+(447*4)
19065 /* ------------------------------ */
19066 .L_ALT_OP_UNUSED_C0FF: /* 0x1c0 */
19067 /* File: x86/alt_stub.S */
19069 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
19070 * any interesting requests and then jump to the real instruction
19071 * handler. Unlike the Arm handler, we can't do this as a tail call
19072 * because rIBASE is caller save and we need to reload it.
19075 movl rPC, OUT_ARG0(%esp)
19076 movl %eax, OUT_ARG1(%esp)
19077 call dvmCheckInst # (dPC, self)
19079 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
19080 jmp *dvmAsmInstructionStart+(448*4)
19082 /* ------------------------------ */
19083 .L_ALT_OP_UNUSED_C1FF: /* 0x1c1 */
19084 /* File: x86/alt_stub.S */
19086 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
19087 * any interesting requests and then jump to the real instruction
19088 * handler. Unlike the Arm handler, we can't do this as a tail call
19089 * because rIBASE is caller save and we need to reload it.
19092 movl rPC, OUT_ARG0(%esp)
19093 movl %eax, OUT_ARG1(%esp)
19094 call dvmCheckInst # (dPC, self)
19096 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
19097 jmp *dvmAsmInstructionStart+(449*4)
19099 /* ------------------------------ */
19100 .L_ALT_OP_UNUSED_C2FF: /* 0x1c2 */
19101 /* File: x86/alt_stub.S */
19103 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
19104 * any interesting requests and then jump to the real instruction
19105 * handler. Unlike the Arm handler, we can't do this as a tail call
19106 * because rIBASE is caller save and we need to reload it.
19109 movl rPC, OUT_ARG0(%esp)
19110 movl %eax, OUT_ARG1(%esp)
19111 call dvmCheckInst # (dPC, self)
19113 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
19114 jmp *dvmAsmInstructionStart+(450*4)
19116 /* ------------------------------ */
19117 .L_ALT_OP_UNUSED_C3FF: /* 0x1c3 */
19118 /* File: x86/alt_stub.S */
19120 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
19121 * any interesting requests and then jump to the real instruction
19122 * handler. Unlike the Arm handler, we can't do this as a tail call
19123 * because rIBASE is caller save and we need to reload it.
19126 movl rPC, OUT_ARG0(%esp)
19127 movl %eax, OUT_ARG1(%esp)
19128 call dvmCheckInst # (dPC, self)
19130 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
19131 jmp *dvmAsmInstructionStart+(451*4)
19133 /* ------------------------------ */
19134 .L_ALT_OP_UNUSED_C4FF: /* 0x1c4 */
19135 /* File: x86/alt_stub.S */
19137 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
19138 * any interesting requests and then jump to the real instruction
19139 * handler. Unlike the Arm handler, we can't do this as a tail call
19140 * because rIBASE is caller save and we need to reload it.
19143 movl rPC, OUT_ARG0(%esp)
19144 movl %eax, OUT_ARG1(%esp)
19145 call dvmCheckInst # (dPC, self)
19147 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
19148 jmp *dvmAsmInstructionStart+(452*4)
19150 /* ------------------------------ */
19151 .L_ALT_OP_UNUSED_C5FF: /* 0x1c5 */
19152 /* File: x86/alt_stub.S */
19154 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
19155 * any interesting requests and then jump to the real instruction
19156 * handler. Unlike the Arm handler, we can't do this as a tail call
19157 * because rIBASE is caller save and we need to reload it.
19160 movl rPC, OUT_ARG0(%esp)
19161 movl %eax, OUT_ARG1(%esp)
19162 call dvmCheckInst # (dPC, self)
19164 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
19165 jmp *dvmAsmInstructionStart+(453*4)
19167 /* ------------------------------ */
19168 .L_ALT_OP_UNUSED_C6FF: /* 0x1c6 */
19169 /* File: x86/alt_stub.S */
19171 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
19172 * any interesting requests and then jump to the real instruction
19173 * handler. Unlike the Arm handler, we can't do this as a tail call
19174 * because rIBASE is caller save and we need to reload it.
19177 movl rPC, OUT_ARG0(%esp)
19178 movl %eax, OUT_ARG1(%esp)
19179 call dvmCheckInst # (dPC, self)
19181 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
19182 jmp *dvmAsmInstructionStart+(454*4)
19184 /* ------------------------------ */
19185 .L_ALT_OP_UNUSED_C7FF: /* 0x1c7 */
19186 /* File: x86/alt_stub.S */
19188 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
19189 * any interesting requests and then jump to the real instruction
19190 * handler. Unlike the Arm handler, we can't do this as a tail call
19191 * because rIBASE is caller save and we need to reload it.
19194 movl rPC, OUT_ARG0(%esp)
19195 movl %eax, OUT_ARG1(%esp)
19196 call dvmCheckInst # (dPC, self)
19198 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
19199 jmp *dvmAsmInstructionStart+(455*4)
19201 /* ------------------------------ */
19202 .L_ALT_OP_UNUSED_C8FF: /* 0x1c8 */
19203 /* File: x86/alt_stub.S */
19205 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
19206 * any interesting requests and then jump to the real instruction
19207 * handler. Unlike the Arm handler, we can't do this as a tail call
19208 * because rIBASE is caller save and we need to reload it.
19211 movl rPC, OUT_ARG0(%esp)
19212 movl %eax, OUT_ARG1(%esp)
19213 call dvmCheckInst # (dPC, self)
19215 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
19216 jmp *dvmAsmInstructionStart+(456*4)
19218 /* ------------------------------ */
19219 .L_ALT_OP_UNUSED_C9FF: /* 0x1c9 */
19220 /* File: x86/alt_stub.S */
19222 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
19223 * any interesting requests and then jump to the real instruction
19224 * handler. Unlike the Arm handler, we can't do this as a tail call
19225 * because rIBASE is caller save and we need to reload it.
19228 movl rPC, OUT_ARG0(%esp)
19229 movl %eax, OUT_ARG1(%esp)
19230 call dvmCheckInst # (dPC, self)
19232 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
19233 jmp *dvmAsmInstructionStart+(457*4)
19235 /* ------------------------------ */
19236 .L_ALT_OP_UNUSED_CAFF: /* 0x1ca */
19237 /* File: x86/alt_stub.S */
19239 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
19240 * any interesting requests and then jump to the real instruction
19241 * handler. Unlike the Arm handler, we can't do this as a tail call
19242 * because rIBASE is caller save and we need to reload it.
19245 movl rPC, OUT_ARG0(%esp)
19246 movl %eax, OUT_ARG1(%esp)
19247 call dvmCheckInst # (dPC, self)
19249 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
19250 jmp *dvmAsmInstructionStart+(458*4)
19252 /* ------------------------------ */
19253 .L_ALT_OP_UNUSED_CBFF: /* 0x1cb */
19254 /* File: x86/alt_stub.S */
19256 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
19257 * any interesting requests and then jump to the real instruction
19258 * handler. Unlike the Arm handler, we can't do this as a tail call
19259 * because rIBASE is caller save and we need to reload it.
19262 movl rPC, OUT_ARG0(%esp)
19263 movl %eax, OUT_ARG1(%esp)
19264 call dvmCheckInst # (dPC, self)
19266 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
19267 jmp *dvmAsmInstructionStart+(459*4)
19269 /* ------------------------------ */
19270 .L_ALT_OP_UNUSED_CCFF: /* 0x1cc */
19271 /* File: x86/alt_stub.S */
19273 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
19274 * any interesting requests and then jump to the real instruction
19275 * handler. Unlike the Arm handler, we can't do this as a tail call
19276 * because rIBASE is caller save and we need to reload it.
19279 movl rPC, OUT_ARG0(%esp)
19280 movl %eax, OUT_ARG1(%esp)
19281 call dvmCheckInst # (dPC, self)
19283 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
19284 jmp *dvmAsmInstructionStart+(460*4)
19286 /* ------------------------------ */
19287 .L_ALT_OP_UNUSED_CDFF: /* 0x1cd */
19288 /* File: x86/alt_stub.S */
19290 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
19291 * any interesting requests and then jump to the real instruction
19292 * handler. Unlike the Arm handler, we can't do this as a tail call
19293 * because rIBASE is caller save and we need to reload it.
19296 movl rPC, OUT_ARG0(%esp)
19297 movl %eax, OUT_ARG1(%esp)
19298 call dvmCheckInst # (dPC, self)
19300 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
19301 jmp *dvmAsmInstructionStart+(461*4)
19303 /* ------------------------------ */
19304 .L_ALT_OP_UNUSED_CEFF: /* 0x1ce */
19305 /* File: x86/alt_stub.S */
19307 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
19308 * any interesting requests and then jump to the real instruction
19309 * handler. Unlike the Arm handler, we can't do this as a tail call
19310 * because rIBASE is caller save and we need to reload it.
19313 movl rPC, OUT_ARG0(%esp)
19314 movl %eax, OUT_ARG1(%esp)
19315 call dvmCheckInst # (dPC, self)
19317 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
19318 jmp *dvmAsmInstructionStart+(462*4)
19320 /* ------------------------------ */
19321 .L_ALT_OP_UNUSED_CFFF: /* 0x1cf */
19322 /* File: x86/alt_stub.S */
19324 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
19325 * any interesting requests and then jump to the real instruction
19326 * handler. Unlike the Arm handler, we can't do this as a tail call
19327 * because rIBASE is caller save and we need to reload it.
19330 movl rPC, OUT_ARG0(%esp)
19331 movl %eax, OUT_ARG1(%esp)
19332 call dvmCheckInst # (dPC, self)
19334 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
19335 jmp *dvmAsmInstructionStart+(463*4)
19337 /* ------------------------------ */
19338 .L_ALT_OP_UNUSED_D0FF: /* 0x1d0 */
19339 /* File: x86/alt_stub.S */
19341 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
19342 * any interesting requests and then jump to the real instruction
19343 * handler. Unlike the Arm handler, we can't do this as a tail call
19344 * because rIBASE is caller save and we need to reload it.
19347 movl rPC, OUT_ARG0(%esp)
19348 movl %eax, OUT_ARG1(%esp)
19349 call dvmCheckInst # (dPC, self)
19351 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
19352 jmp *dvmAsmInstructionStart+(464*4)
19354 /* ------------------------------ */
19355 .L_ALT_OP_UNUSED_D1FF: /* 0x1d1 */
19356 /* File: x86/alt_stub.S */
19358 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
19359 * any interesting requests and then jump to the real instruction
19360 * handler. Unlike the Arm handler, we can't do this as a tail call
19361 * because rIBASE is caller save and we need to reload it.
19364 movl rPC, OUT_ARG0(%esp)
19365 movl %eax, OUT_ARG1(%esp)
19366 call dvmCheckInst # (dPC, self)
19368 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
19369 jmp *dvmAsmInstructionStart+(465*4)
19371 /* ------------------------------ */
19372 .L_ALT_OP_UNUSED_D2FF: /* 0x1d2 */
19373 /* File: x86/alt_stub.S */
19375 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
19376 * any interesting requests and then jump to the real instruction
19377 * handler. Unlike the Arm handler, we can't do this as a tail call
19378 * because rIBASE is caller save and we need to reload it.
19381 movl rPC, OUT_ARG0(%esp)
19382 movl %eax, OUT_ARG1(%esp)
19383 call dvmCheckInst # (dPC, self)
19385 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
19386 jmp *dvmAsmInstructionStart+(466*4)
19388 /* ------------------------------ */
19389 .L_ALT_OP_UNUSED_D3FF: /* 0x1d3 */
19390 /* File: x86/alt_stub.S */
19392 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
19393 * any interesting requests and then jump to the real instruction
19394 * handler. Unlike the Arm handler, we can't do this as a tail call
19395 * because rIBASE is caller save and we need to reload it.
19398 movl rPC, OUT_ARG0(%esp)
19399 movl %eax, OUT_ARG1(%esp)
19400 call dvmCheckInst # (dPC, self)
19402 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
19403 jmp *dvmAsmInstructionStart+(467*4)
19405 /* ------------------------------ */
19406 .L_ALT_OP_UNUSED_D4FF: /* 0x1d4 */
19407 /* File: x86/alt_stub.S */
19409 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
19410 * any interesting requests and then jump to the real instruction
19411 * handler. Unlike the Arm handler, we can't do this as a tail call
19412 * because rIBASE is caller save and we need to reload it.
19415 movl rPC, OUT_ARG0(%esp)
19416 movl %eax, OUT_ARG1(%esp)
19417 call dvmCheckInst # (dPC, self)
19419 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
19420 jmp *dvmAsmInstructionStart+(468*4)
19422 /* ------------------------------ */
19423 .L_ALT_OP_UNUSED_D5FF: /* 0x1d5 */
19424 /* File: x86/alt_stub.S */
19426 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
19427 * any interesting requests and then jump to the real instruction
19428 * handler. Unlike the Arm handler, we can't do this as a tail call
19429 * because rIBASE is caller save and we need to reload it.
19432 movl rPC, OUT_ARG0(%esp)
19433 movl %eax, OUT_ARG1(%esp)
19434 call dvmCheckInst # (dPC, self)
19436 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
19437 jmp *dvmAsmInstructionStart+(469*4)
19439 /* ------------------------------ */
19440 .L_ALT_OP_UNUSED_D6FF: /* 0x1d6 */
19441 /* File: x86/alt_stub.S */
19443 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
19444 * any interesting requests and then jump to the real instruction
19445 * handler. Unlike the Arm handler, we can't do this as a tail call
19446 * because rIBASE is caller save and we need to reload it.
19449 movl rPC, OUT_ARG0(%esp)
19450 movl %eax, OUT_ARG1(%esp)
19451 call dvmCheckInst # (dPC, self)
19453 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
19454 jmp *dvmAsmInstructionStart+(470*4)
19456 /* ------------------------------ */
19457 .L_ALT_OP_UNUSED_D7FF: /* 0x1d7 */
19458 /* File: x86/alt_stub.S */
19460 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
19461 * any interesting requests and then jump to the real instruction
19462 * handler. Unlike the Arm handler, we can't do this as a tail call
19463 * because rIBASE is caller save and we need to reload it.
19466 movl rPC, OUT_ARG0(%esp)
19467 movl %eax, OUT_ARG1(%esp)
19468 call dvmCheckInst # (dPC, self)
19470 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
19471 jmp *dvmAsmInstructionStart+(471*4)
19473 /* ------------------------------ */
19474 .L_ALT_OP_UNUSED_D8FF: /* 0x1d8 */
19475 /* File: x86/alt_stub.S */
19477 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
19478 * any interesting requests and then jump to the real instruction
19479 * handler. Unlike the Arm handler, we can't do this as a tail call
19480 * because rIBASE is caller save and we need to reload it.
19483 movl rPC, OUT_ARG0(%esp)
19484 movl %eax, OUT_ARG1(%esp)
19485 call dvmCheckInst # (dPC, self)
19487 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
19488 jmp *dvmAsmInstructionStart+(472*4)
19490 /* ------------------------------ */
19491 .L_ALT_OP_UNUSED_D9FF: /* 0x1d9 */
19492 /* File: x86/alt_stub.S */
19494 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
19495 * any interesting requests and then jump to the real instruction
19496 * handler. Unlike the Arm handler, we can't do this as a tail call
19497 * because rIBASE is caller save and we need to reload it.
19500 movl rPC, OUT_ARG0(%esp)
19501 movl %eax, OUT_ARG1(%esp)
19502 call dvmCheckInst # (dPC, self)
19504 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
19505 jmp *dvmAsmInstructionStart+(473*4)
19507 /* ------------------------------ */
19508 .L_ALT_OP_UNUSED_DAFF: /* 0x1da */
19509 /* File: x86/alt_stub.S */
19511 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
19512 * any interesting requests and then jump to the real instruction
19513 * handler. Unlike the Arm handler, we can't do this as a tail call
19514 * because rIBASE is caller save and we need to reload it.
19517 movl rPC, OUT_ARG0(%esp)
19518 movl %eax, OUT_ARG1(%esp)
19519 call dvmCheckInst # (dPC, self)
19521 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
19522 jmp *dvmAsmInstructionStart+(474*4)
19524 /* ------------------------------ */
19525 .L_ALT_OP_UNUSED_DBFF: /* 0x1db */
19526 /* File: x86/alt_stub.S */
19528 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
19529 * any interesting requests and then jump to the real instruction
19530 * handler. Unlike the Arm handler, we can't do this as a tail call
19531 * because rIBASE is caller save and we need to reload it.
19534 movl rPC, OUT_ARG0(%esp)
19535 movl %eax, OUT_ARG1(%esp)
19536 call dvmCheckInst # (dPC, self)
19538 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
19539 jmp *dvmAsmInstructionStart+(475*4)
19541 /* ------------------------------ */
19542 .L_ALT_OP_UNUSED_DCFF: /* 0x1dc */
19543 /* File: x86/alt_stub.S */
19545 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
19546 * any interesting requests and then jump to the real instruction
19547 * handler. Unlike the Arm handler, we can't do this as a tail call
19548 * because rIBASE is caller save and we need to reload it.
19551 movl rPC, OUT_ARG0(%esp)
19552 movl %eax, OUT_ARG1(%esp)
19553 call dvmCheckInst # (dPC, self)
19555 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
19556 jmp *dvmAsmInstructionStart+(476*4)
19558 /* ------------------------------ */
19559 .L_ALT_OP_UNUSED_DDFF: /* 0x1dd */
19560 /* File: x86/alt_stub.S */
19562 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
19563 * any interesting requests and then jump to the real instruction
19564 * handler. Unlike the Arm handler, we can't do this as a tail call
19565 * because rIBASE is caller save and we need to reload it.
19568 movl rPC, OUT_ARG0(%esp)
19569 movl %eax, OUT_ARG1(%esp)
19570 call dvmCheckInst # (dPC, self)
19572 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
19573 jmp *dvmAsmInstructionStart+(477*4)
19575 /* ------------------------------ */
19576 .L_ALT_OP_UNUSED_DEFF: /* 0x1de */
19577 /* File: x86/alt_stub.S */
19579 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
19580 * any interesting requests and then jump to the real instruction
19581 * handler. Unlike the Arm handler, we can't do this as a tail call
19582 * because rIBASE is caller save and we need to reload it.
19585 movl rPC, OUT_ARG0(%esp)
19586 movl %eax, OUT_ARG1(%esp)
19587 call dvmCheckInst # (dPC, self)
19589 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
19590 jmp *dvmAsmInstructionStart+(478*4)
19592 /* ------------------------------ */
19593 .L_ALT_OP_UNUSED_DFFF: /* 0x1df */
19594 /* File: x86/alt_stub.S */
19596 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
19597 * any interesting requests and then jump to the real instruction
19598 * handler. Unlike the Arm handler, we can't do this as a tail call
19599 * because rIBASE is caller save and we need to reload it.
19602 movl rPC, OUT_ARG0(%esp)
19603 movl %eax, OUT_ARG1(%esp)
19604 call dvmCheckInst # (dPC, self)
19606 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
19607 jmp *dvmAsmInstructionStart+(479*4)
19609 /* ------------------------------ */
19610 .L_ALT_OP_UNUSED_E0FF: /* 0x1e0 */
19611 /* File: x86/alt_stub.S */
19613 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
19614 * any interesting requests and then jump to the real instruction
19615 * handler. Unlike the Arm handler, we can't do this as a tail call
19616 * because rIBASE is caller save and we need to reload it.
19619 movl rPC, OUT_ARG0(%esp)
19620 movl %eax, OUT_ARG1(%esp)
19621 call dvmCheckInst # (dPC, self)
19623 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
19624 jmp *dvmAsmInstructionStart+(480*4)
19626 /* ------------------------------ */
19627 .L_ALT_OP_UNUSED_E1FF: /* 0x1e1 */
19628 /* File: x86/alt_stub.S */
19630 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
19631 * any interesting requests and then jump to the real instruction
19632 * handler. Unlike the Arm handler, we can't do this as a tail call
19633 * because rIBASE is caller save and we need to reload it.
19636 movl rPC, OUT_ARG0(%esp)
19637 movl %eax, OUT_ARG1(%esp)
19638 call dvmCheckInst # (dPC, self)
19640 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
19641 jmp *dvmAsmInstructionStart+(481*4)
19643 /* ------------------------------ */
19644 .L_ALT_OP_UNUSED_E2FF: /* 0x1e2 */
19645 /* File: x86/alt_stub.S */
19647 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
19648 * any interesting requests and then jump to the real instruction
19649 * handler. Unlike the Arm handler, we can't do this as a tail call
19650 * because rIBASE is caller save and we need to reload it.
19653 movl rPC, OUT_ARG0(%esp)
19654 movl %eax, OUT_ARG1(%esp)
19655 call dvmCheckInst # (dPC, self)
19657 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
19658 jmp *dvmAsmInstructionStart+(482*4)
19660 /* ------------------------------ */
19661 .L_ALT_OP_UNUSED_E3FF: /* 0x1e3 */
19662 /* File: x86/alt_stub.S */
19664 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
19665 * any interesting requests and then jump to the real instruction
19666 * handler. Unlike the Arm handler, we can't do this as a tail call
19667 * because rIBASE is caller save and we need to reload it.
19670 movl rPC, OUT_ARG0(%esp)
19671 movl %eax, OUT_ARG1(%esp)
19672 call dvmCheckInst # (dPC, self)
19674 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
19675 jmp *dvmAsmInstructionStart+(483*4)
19677 /* ------------------------------ */
19678 .L_ALT_OP_UNUSED_E4FF: /* 0x1e4 */
19679 /* File: x86/alt_stub.S */
19681 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
19682 * any interesting requests and then jump to the real instruction
19683 * handler. Unlike the Arm handler, we can't do this as a tail call
19684 * because rIBASE is caller save and we need to reload it.
19687 movl rPC, OUT_ARG0(%esp)
19688 movl %eax, OUT_ARG1(%esp)
19689 call dvmCheckInst # (dPC, self)
19691 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
19692 jmp *dvmAsmInstructionStart+(484*4)
19694 /* ------------------------------ */
19695 .L_ALT_OP_UNUSED_E5FF: /* 0x1e5 */
19696 /* File: x86/alt_stub.S */
19698 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
19699 * any interesting requests and then jump to the real instruction
19700 * handler. Unlike the Arm handler, we can't do this as a tail call
19701 * because rIBASE is caller save and we need to reload it.
19704 movl rPC, OUT_ARG0(%esp)
19705 movl %eax, OUT_ARG1(%esp)
19706 call dvmCheckInst # (dPC, self)
19708 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
19709 jmp *dvmAsmInstructionStart+(485*4)
19711 /* ------------------------------ */
19712 .L_ALT_OP_UNUSED_E6FF: /* 0x1e6 */
19713 /* File: x86/alt_stub.S */
19715 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
19716 * any interesting requests and then jump to the real instruction
19717 * handler. Unlike the Arm handler, we can't do this as a tail call
19718 * because rIBASE is caller save and we need to reload it.
19721 movl rPC, OUT_ARG0(%esp)
19722 movl %eax, OUT_ARG1(%esp)
19723 call dvmCheckInst # (dPC, self)
19725 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
19726 jmp *dvmAsmInstructionStart+(486*4)
19728 /* ------------------------------ */
19729 .L_ALT_OP_UNUSED_E7FF: /* 0x1e7 */
19730 /* File: x86/alt_stub.S */
19732 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
19733 * any interesting requests and then jump to the real instruction
19734 * handler. Unlike the Arm handler, we can't do this as a tail call
19735 * because rIBASE is caller save and we need to reload it.
19738 movl rPC, OUT_ARG0(%esp)
19739 movl %eax, OUT_ARG1(%esp)
19740 call dvmCheckInst # (dPC, self)
19742 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
19743 jmp *dvmAsmInstructionStart+(487*4)
19745 /* ------------------------------ */
19746 .L_ALT_OP_UNUSED_E8FF: /* 0x1e8 */
19747 /* File: x86/alt_stub.S */
19749 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
19750 * any interesting requests and then jump to the real instruction
19751 * handler. Unlike the Arm handler, we can't do this as a tail call
19752 * because rIBASE is caller save and we need to reload it.
19755 movl rPC, OUT_ARG0(%esp)
19756 movl %eax, OUT_ARG1(%esp)
19757 call dvmCheckInst # (dPC, self)
19759 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
19760 jmp *dvmAsmInstructionStart+(488*4)
19762 /* ------------------------------ */
19763 .L_ALT_OP_UNUSED_E9FF: /* 0x1e9 */
19764 /* File: x86/alt_stub.S */
19766 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
19767 * any interesting requests and then jump to the real instruction
19768 * handler. Unlike the Arm handler, we can't do this as a tail call
19769 * because rIBASE is caller save and we need to reload it.
19772 movl rPC, OUT_ARG0(%esp)
19773 movl %eax, OUT_ARG1(%esp)
19774 call dvmCheckInst # (dPC, self)
19776 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
19777 jmp *dvmAsmInstructionStart+(489*4)
19779 /* ------------------------------ */
19780 .L_ALT_OP_UNUSED_EAFF: /* 0x1ea */
19781 /* File: x86/alt_stub.S */
19783 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
19784 * any interesting requests and then jump to the real instruction
19785 * handler. Unlike the Arm handler, we can't do this as a tail call
19786 * because rIBASE is caller save and we need to reload it.
19789 movl rPC, OUT_ARG0(%esp)
19790 movl %eax, OUT_ARG1(%esp)
19791 call dvmCheckInst # (dPC, self)
19793 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
19794 jmp *dvmAsmInstructionStart+(490*4)
19796 /* ------------------------------ */
19797 .L_ALT_OP_UNUSED_EBFF: /* 0x1eb */
19798 /* File: x86/alt_stub.S */
19800 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
19801 * any interesting requests and then jump to the real instruction
19802 * handler. Unlike the Arm handler, we can't do this as a tail call
19803 * because rIBASE is caller save and we need to reload it.
19806 movl rPC, OUT_ARG0(%esp)
19807 movl %eax, OUT_ARG1(%esp)
19808 call dvmCheckInst # (dPC, self)
19810 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
19811 jmp *dvmAsmInstructionStart+(491*4)
19813 /* ------------------------------ */
19814 .L_ALT_OP_UNUSED_ECFF: /* 0x1ec */
19815 /* File: x86/alt_stub.S */
19817 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
19818 * any interesting requests and then jump to the real instruction
19819 * handler. Unlike the Arm handler, we can't do this as a tail call
19820 * because rIBASE is caller save and we need to reload it.
19823 movl rPC, OUT_ARG0(%esp)
19824 movl %eax, OUT_ARG1(%esp)
19825 call dvmCheckInst # (dPC, self)
19827 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
19828 jmp *dvmAsmInstructionStart+(492*4)
19830 /* ------------------------------ */
19831 .L_ALT_OP_UNUSED_EDFF: /* 0x1ed */
19832 /* File: x86/alt_stub.S */
19834 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
19835 * any interesting requests and then jump to the real instruction
19836 * handler. Unlike the Arm handler, we can't do this as a tail call
19837 * because rIBASE is caller save and we need to reload it.
19840 movl rPC, OUT_ARG0(%esp)
19841 movl %eax, OUT_ARG1(%esp)
19842 call dvmCheckInst # (dPC, self)
19844 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
19845 jmp *dvmAsmInstructionStart+(493*4)
19847 /* ------------------------------ */
19848 .L_ALT_OP_UNUSED_EEFF: /* 0x1ee */
19849 /* File: x86/alt_stub.S */
19851 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
19852 * any interesting requests and then jump to the real instruction
19853 * handler. Unlike the Arm handler, we can't do this as a tail call
19854 * because rIBASE is caller save and we need to reload it.
19857 movl rPC, OUT_ARG0(%esp)
19858 movl %eax, OUT_ARG1(%esp)
19859 call dvmCheckInst # (dPC, self)
19861 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
19862 jmp *dvmAsmInstructionStart+(494*4)
19864 /* ------------------------------ */
19865 .L_ALT_OP_UNUSED_EFFF: /* 0x1ef */
19866 /* File: x86/alt_stub.S */
19868 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
19869 * any interesting requests and then jump to the real instruction
19870 * handler. Unlike the Arm handler, we can't do this as a tail call
19871 * because rIBASE is caller save and we need to reload it.
19874 movl rPC, OUT_ARG0(%esp)
19875 movl %eax, OUT_ARG1(%esp)
19876 call dvmCheckInst # (dPC, self)
19878 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
19879 jmp *dvmAsmInstructionStart+(495*4)
19881 /* ------------------------------ */
19882 .L_ALT_OP_UNUSED_F0FF: /* 0x1f0 */
19883 /* File: x86/alt_stub.S */
19885 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
19886 * any interesting requests and then jump to the real instruction
19887 * handler. Unlike the Arm handler, we can't do this as a tail call
19888 * because rIBASE is caller save and we need to reload it.
19891 movl rPC, OUT_ARG0(%esp)
19892 movl %eax, OUT_ARG1(%esp)
19893 call dvmCheckInst # (dPC, self)
19895 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
19896 jmp *dvmAsmInstructionStart+(496*4)
19898 /* ------------------------------ */
19899 .L_ALT_OP_UNUSED_F1FF: /* 0x1f1 */
19900 /* File: x86/alt_stub.S */
19902 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
19903 * any interesting requests and then jump to the real instruction
19904 * handler. Unlike the Arm handler, we can't do this as a tail call
19905 * because rIBASE is caller save and we need to reload it.
19908 movl rPC, OUT_ARG0(%esp)
19909 movl %eax, OUT_ARG1(%esp)
19910 call dvmCheckInst # (dPC, self)
19912 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
19913 jmp *dvmAsmInstructionStart+(497*4)
19915 /* ------------------------------ */
19916 .L_ALT_OP_UNUSED_F2FF: /* 0x1f2 */
19917 /* File: x86/alt_stub.S */
19919 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
19920 * any interesting requests and then jump to the real instruction
19921 * handler. Unlike the Arm handler, we can't do this as a tail call
19922 * because rIBASE is caller save and we need to reload it.
19925 movl rPC, OUT_ARG0(%esp)
19926 movl %eax, OUT_ARG1(%esp)
19927 call dvmCheckInst # (dPC, self)
19929 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
19930 jmp *dvmAsmInstructionStart+(498*4)
19932 /* ------------------------------ */
19933 .L_ALT_OP_UNUSED_F3FF: /* 0x1f3 */
19934 /* File: x86/alt_stub.S */
19936 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
19937 * any interesting requests and then jump to the real instruction
19938 * handler. Unlike the Arm handler, we can't do this as a tail call
19939 * because rIBASE is caller save and we need to reload it.
19942 movl rPC, OUT_ARG0(%esp)
19943 movl %eax, OUT_ARG1(%esp)
19944 call dvmCheckInst # (dPC, self)
19946 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
19947 jmp *dvmAsmInstructionStart+(499*4)
19949 /* ------------------------------ */
19950 .L_ALT_OP_UNUSED_F4FF: /* 0x1f4 */
19951 /* File: x86/alt_stub.S */
19953 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
19954 * any interesting requests and then jump to the real instruction
19955 * handler. Unlike the Arm handler, we can't do this as a tail call
19956 * because rIBASE is caller save and we need to reload it.
19959 movl rPC, OUT_ARG0(%esp)
19960 movl %eax, OUT_ARG1(%esp)
19961 call dvmCheckInst # (dPC, self)
19963 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
19964 jmp *dvmAsmInstructionStart+(500*4)
19966 /* ------------------------------ */
19967 .L_ALT_OP_UNUSED_F5FF: /* 0x1f5 */
19968 /* File: x86/alt_stub.S */
19970 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
19971 * any interesting requests and then jump to the real instruction
19972 * handler. Unlike the Arm handler, we can't do this as a tail call
19973 * because rIBASE is caller save and we need to reload it.
19976 movl rPC, OUT_ARG0(%esp)
19977 movl %eax, OUT_ARG1(%esp)
19978 call dvmCheckInst # (dPC, self)
19980 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
19981 jmp *dvmAsmInstructionStart+(501*4)
19983 /* ------------------------------ */
19984 .L_ALT_OP_UNUSED_F6FF: /* 0x1f6 */
19985 /* File: x86/alt_stub.S */
19987 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
19988 * any interesting requests and then jump to the real instruction
19989 * handler. Unlike the Arm handler, we can't do this as a tail call
19990 * because rIBASE is caller save and we need to reload it.
19993 movl rPC, OUT_ARG0(%esp)
19994 movl %eax, OUT_ARG1(%esp)
19995 call dvmCheckInst # (dPC, self)
19997 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
19998 jmp *dvmAsmInstructionStart+(502*4)
20000 /* ------------------------------ */
20001 .L_ALT_OP_UNUSED_F7FF: /* 0x1f7 */
20002 /* File: x86/alt_stub.S */
20004 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
20005 * any interesting requests and then jump to the real instruction
20006 * handler. Unlike the Arm handler, we can't do this as a tail call
20007 * because rIBASE is caller save and we need to reload it.
20010 movl rPC, OUT_ARG0(%esp)
20011 movl %eax, OUT_ARG1(%esp)
20012 call dvmCheckInst # (dPC, self)
20014 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
20015 jmp *dvmAsmInstructionStart+(503*4)
20017 /* ------------------------------ */
20018 .L_ALT_OP_UNUSED_F8FF: /* 0x1f8 */
20019 /* File: x86/alt_stub.S */
20021 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
20022 * any interesting requests and then jump to the real instruction
20023 * handler. Unlike the Arm handler, we can't do this as a tail call
20024 * because rIBASE is caller save and we need to reload it.
20027 movl rPC, OUT_ARG0(%esp)
20028 movl %eax, OUT_ARG1(%esp)
20029 call dvmCheckInst # (dPC, self)
20031 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
20032 jmp *dvmAsmInstructionStart+(504*4)
20034 /* ------------------------------ */
20035 .L_ALT_OP_UNUSED_F9FF: /* 0x1f9 */
20036 /* File: x86/alt_stub.S */
20038 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
20039 * any interesting requests and then jump to the real instruction
20040 * handler. Unlike the Arm handler, we can't do this as a tail call
20041 * because rIBASE is caller save and we need to reload it.
20044 movl rPC, OUT_ARG0(%esp)
20045 movl %eax, OUT_ARG1(%esp)
20046 call dvmCheckInst # (dPC, self)
20048 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
20049 jmp *dvmAsmInstructionStart+(505*4)
20051 /* ------------------------------ */
20052 .L_ALT_OP_UNUSED_FAFF: /* 0x1fa */
20053 /* File: x86/alt_stub.S */
20055 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
20056 * any interesting requests and then jump to the real instruction
20057 * handler. Unlike the Arm handler, we can't do this as a tail call
20058 * because rIBASE is caller save and we need to reload it.
20061 movl rPC, OUT_ARG0(%esp)
20062 movl %eax, OUT_ARG1(%esp)
20063 call dvmCheckInst # (dPC, self)
20065 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
20066 jmp *dvmAsmInstructionStart+(506*4)
20068 /* ------------------------------ */
20069 .L_ALT_OP_UNUSED_FBFF: /* 0x1fb */
20070 /* File: x86/alt_stub.S */
20072 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
20073 * any interesting requests and then jump to the real instruction
20074 * handler. Unlike the Arm handler, we can't do this as a tail call
20075 * because rIBASE is caller save and we need to reload it.
20078 movl rPC, OUT_ARG0(%esp)
20079 movl %eax, OUT_ARG1(%esp)
20080 call dvmCheckInst # (dPC, self)
20082 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
20083 jmp *dvmAsmInstructionStart+(507*4)
20085 /* ------------------------------ */
20086 .L_ALT_OP_UNUSED_FCFF: /* 0x1fc */
20087 /* File: x86/alt_stub.S */
20089 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
20090 * any interesting requests and then jump to the real instruction
20091 * handler. Unlike the Arm handler, we can't do this as a tail call
20092 * because rIBASE is caller save and we need to reload it.
20095 movl rPC, OUT_ARG0(%esp)
20096 movl %eax, OUT_ARG1(%esp)
20097 call dvmCheckInst # (dPC, self)
20099 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
20100 jmp *dvmAsmInstructionStart+(508*4)
20102 /* ------------------------------ */
20103 .L_ALT_OP_UNUSED_FDFF: /* 0x1fd */
20104 /* File: x86/alt_stub.S */
20106 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
20107 * any interesting requests and then jump to the real instruction
20108 * handler. Unlike the Arm handler, we can't do this as a tail call
20109 * because rIBASE is caller save and we need to reload it.
20112 movl rPC, OUT_ARG0(%esp)
20113 movl %eax, OUT_ARG1(%esp)
20114 call dvmCheckInst # (dPC, self)
20116 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
20117 jmp *dvmAsmInstructionStart+(509*4)
20119 /* ------------------------------ */
20120 .L_ALT_OP_UNUSED_FEFF: /* 0x1fe */
20121 /* File: x86/alt_stub.S */
20123 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
20124 * any interesting requests and then jump to the real instruction
20125 * handler. Unlike the Arm handler, we can't do this as a tail call
20126 * because rIBASE is caller save and we need to reload it.
20129 movl rPC, OUT_ARG0(%esp)
20130 movl %eax, OUT_ARG1(%esp)
20131 call dvmCheckInst # (dPC, self)
20133 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
20134 jmp *dvmAsmInstructionStart+(510*4)
20136 /* ------------------------------ */
20137 .L_ALT_OP_THROW_VERIFICATION_ERROR_JUMBO: /* 0x1ff */
20138 /* File: x86/alt_stub.S */
20140 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle
20141 * any interesting requests and then jump to the real instruction
20142 * handler. Unlike the Arm handler, we can't do this as a tail call
20143 * because rIBASE is caller save and we need to reload it.
20146 movl rPC, OUT_ARG0(%esp)
20147 movl %eax, OUT_ARG1(%esp)
20148 call dvmCheckInst # (dPC, self)
20150 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE
20151 jmp *dvmAsmInstructionStart+(511*4)
20153 .size dvmAsmAltInstructionStartCode, .-dvmAsmAltInstructionStartCode
20154 .global dvmAsmAltInstructionEndCode
20155 dvmAsmAltInstructionEndCode:
20157 .global dvmAsmInstructionStart
20159 dvmAsmInstructionStart:
20160 .long .L_OP_NOP /* 0x00 */
20161 .long .L_OP_MOVE /* 0x01 */
20162 .long .L_OP_MOVE_FROM16 /* 0x02 */
20163 .long .L_OP_MOVE_16 /* 0x03 */
20164 .long .L_OP_MOVE_WIDE /* 0x04 */
20165 .long .L_OP_MOVE_WIDE_FROM16 /* 0x05 */
20166 .long .L_OP_MOVE_WIDE_16 /* 0x06 */
20167 .long .L_OP_MOVE_OBJECT /* 0x07 */
20168 .long .L_OP_MOVE_OBJECT_FROM16 /* 0x08 */
20169 .long .L_OP_MOVE_OBJECT_16 /* 0x09 */
20170 .long .L_OP_MOVE_RESULT /* 0x0a */
20171 .long .L_OP_MOVE_RESULT_WIDE /* 0x0b */
20172 .long .L_OP_MOVE_RESULT_OBJECT /* 0x0c */
20173 .long .L_OP_MOVE_EXCEPTION /* 0x0d */
20174 .long .L_OP_RETURN_VOID /* 0x0e */
20175 .long .L_OP_RETURN /* 0x0f */
20176 .long .L_OP_RETURN_WIDE /* 0x10 */
20177 .long .L_OP_RETURN_OBJECT /* 0x11 */
20178 .long .L_OP_CONST_4 /* 0x12 */
20179 .long .L_OP_CONST_16 /* 0x13 */
20180 .long .L_OP_CONST /* 0x14 */
20181 .long .L_OP_CONST_HIGH16 /* 0x15 */
20182 .long .L_OP_CONST_WIDE_16 /* 0x16 */
20183 .long .L_OP_CONST_WIDE_32 /* 0x17 */
20184 .long .L_OP_CONST_WIDE /* 0x18 */
20185 .long .L_OP_CONST_WIDE_HIGH16 /* 0x19 */
20186 .long .L_OP_CONST_STRING /* 0x1a */
20187 .long .L_OP_CONST_STRING_JUMBO /* 0x1b */
20188 .long .L_OP_CONST_CLASS /* 0x1c */
20189 .long .L_OP_MONITOR_ENTER /* 0x1d */
20190 .long .L_OP_MONITOR_EXIT /* 0x1e */
20191 .long .L_OP_CHECK_CAST /* 0x1f */
20192 .long .L_OP_INSTANCE_OF /* 0x20 */
20193 .long .L_OP_ARRAY_LENGTH /* 0x21 */
20194 .long .L_OP_NEW_INSTANCE /* 0x22 */
20195 .long .L_OP_NEW_ARRAY /* 0x23 */
20196 .long .L_OP_FILLED_NEW_ARRAY /* 0x24 */
20197 .long .L_OP_FILLED_NEW_ARRAY_RANGE /* 0x25 */
20198 .long .L_OP_FILL_ARRAY_DATA /* 0x26 */
20199 .long .L_OP_THROW /* 0x27 */
20200 .long .L_OP_GOTO /* 0x28 */
20201 .long .L_OP_GOTO_16 /* 0x29 */
20202 .long .L_OP_GOTO_32 /* 0x2a */
20203 .long .L_OP_PACKED_SWITCH /* 0x2b */
20204 .long .L_OP_SPARSE_SWITCH /* 0x2c */
20205 .long .L_OP_CMPL_FLOAT /* 0x2d */
20206 .long .L_OP_CMPG_FLOAT /* 0x2e */
20207 .long .L_OP_CMPL_DOUBLE /* 0x2f */
20208 .long .L_OP_CMPG_DOUBLE /* 0x30 */
20209 .long .L_OP_CMP_LONG /* 0x31 */
20210 .long .L_OP_IF_EQ /* 0x32 */
20211 .long .L_OP_IF_NE /* 0x33 */
20212 .long .L_OP_IF_LT /* 0x34 */
20213 .long .L_OP_IF_GE /* 0x35 */
20214 .long .L_OP_IF_GT /* 0x36 */
20215 .long .L_OP_IF_LE /* 0x37 */
20216 .long .L_OP_IF_EQZ /* 0x38 */
20217 .long .L_OP_IF_NEZ /* 0x39 */
20218 .long .L_OP_IF_LTZ /* 0x3a */
20219 .long .L_OP_IF_GEZ /* 0x3b */
20220 .long .L_OP_IF_GTZ /* 0x3c */
20221 .long .L_OP_IF_LEZ /* 0x3d */
20222 .long .L_OP_UNUSED_3E /* 0x3e */
20223 .long .L_OP_UNUSED_3F /* 0x3f */
20224 .long .L_OP_UNUSED_40 /* 0x40 */
20225 .long .L_OP_UNUSED_41 /* 0x41 */
20226 .long .L_OP_UNUSED_42 /* 0x42 */
20227 .long .L_OP_UNUSED_43 /* 0x43 */
20228 .long .L_OP_AGET /* 0x44 */
20229 .long .L_OP_AGET_WIDE /* 0x45 */
20230 .long .L_OP_AGET_OBJECT /* 0x46 */
20231 .long .L_OP_AGET_BOOLEAN /* 0x47 */
20232 .long .L_OP_AGET_BYTE /* 0x48 */
20233 .long .L_OP_AGET_CHAR /* 0x49 */
20234 .long .L_OP_AGET_SHORT /* 0x4a */
20235 .long .L_OP_APUT /* 0x4b */
20236 .long .L_OP_APUT_WIDE /* 0x4c */
20237 .long .L_OP_APUT_OBJECT /* 0x4d */
20238 .long .L_OP_APUT_BOOLEAN /* 0x4e */
20239 .long .L_OP_APUT_BYTE /* 0x4f */
20240 .long .L_OP_APUT_CHAR /* 0x50 */
20241 .long .L_OP_APUT_SHORT /* 0x51 */
20242 .long .L_OP_IGET /* 0x52 */
20243 .long .L_OP_IGET_WIDE /* 0x53 */
20244 .long .L_OP_IGET_OBJECT /* 0x54 */
20245 .long .L_OP_IGET_BOOLEAN /* 0x55 */
20246 .long .L_OP_IGET_BYTE /* 0x56 */
20247 .long .L_OP_IGET_CHAR /* 0x57 */
20248 .long .L_OP_IGET_SHORT /* 0x58 */
20249 .long .L_OP_IPUT /* 0x59 */
20250 .long .L_OP_IPUT_WIDE /* 0x5a */
20251 .long .L_OP_IPUT_OBJECT /* 0x5b */
20252 .long .L_OP_IPUT_BOOLEAN /* 0x5c */
20253 .long .L_OP_IPUT_BYTE /* 0x5d */
20254 .long .L_OP_IPUT_CHAR /* 0x5e */
20255 .long .L_OP_IPUT_SHORT /* 0x5f */
20256 .long .L_OP_SGET /* 0x60 */
20257 .long .L_OP_SGET_WIDE /* 0x61 */
20258 .long .L_OP_SGET_OBJECT /* 0x62 */
20259 .long .L_OP_SGET_BOOLEAN /* 0x63 */
20260 .long .L_OP_SGET_BYTE /* 0x64 */
20261 .long .L_OP_SGET_CHAR /* 0x65 */
20262 .long .L_OP_SGET_SHORT /* 0x66 */
20263 .long .L_OP_SPUT /* 0x67 */
20264 .long .L_OP_SPUT_WIDE /* 0x68 */
20265 .long .L_OP_SPUT_OBJECT /* 0x69 */
20266 .long .L_OP_SPUT_BOOLEAN /* 0x6a */
20267 .long .L_OP_SPUT_BYTE /* 0x6b */
20268 .long .L_OP_SPUT_CHAR /* 0x6c */
20269 .long .L_OP_SPUT_SHORT /* 0x6d */
20270 .long .L_OP_INVOKE_VIRTUAL /* 0x6e */
20271 .long .L_OP_INVOKE_SUPER /* 0x6f */
20272 .long .L_OP_INVOKE_DIRECT /* 0x70 */
20273 .long .L_OP_INVOKE_STATIC /* 0x71 */
20274 .long .L_OP_INVOKE_INTERFACE /* 0x72 */
20275 .long .L_OP_UNUSED_73 /* 0x73 */
20276 .long .L_OP_INVOKE_VIRTUAL_RANGE /* 0x74 */
20277 .long .L_OP_INVOKE_SUPER_RANGE /* 0x75 */
20278 .long .L_OP_INVOKE_DIRECT_RANGE /* 0x76 */
20279 .long .L_OP_INVOKE_STATIC_RANGE /* 0x77 */
20280 .long .L_OP_INVOKE_INTERFACE_RANGE /* 0x78 */
20281 .long .L_OP_UNUSED_79 /* 0x79 */
20282 .long .L_OP_UNUSED_7A /* 0x7a */
20283 .long .L_OP_NEG_INT /* 0x7b */
20284 .long .L_OP_NOT_INT /* 0x7c */
20285 .long .L_OP_NEG_LONG /* 0x7d */
20286 .long .L_OP_NOT_LONG /* 0x7e */
20287 .long .L_OP_NEG_FLOAT /* 0x7f */
20288 .long .L_OP_NEG_DOUBLE /* 0x80 */
20289 .long .L_OP_INT_TO_LONG /* 0x81 */
20290 .long .L_OP_INT_TO_FLOAT /* 0x82 */
20291 .long .L_OP_INT_TO_DOUBLE /* 0x83 */
20292 .long .L_OP_LONG_TO_INT /* 0x84 */
20293 .long .L_OP_LONG_TO_FLOAT /* 0x85 */
20294 .long .L_OP_LONG_TO_DOUBLE /* 0x86 */
20295 .long .L_OP_FLOAT_TO_INT /* 0x87 */
20296 .long .L_OP_FLOAT_TO_LONG /* 0x88 */
20297 .long .L_OP_FLOAT_TO_DOUBLE /* 0x89 */
20298 .long .L_OP_DOUBLE_TO_INT /* 0x8a */
20299 .long .L_OP_DOUBLE_TO_LONG /* 0x8b */
20300 .long .L_OP_DOUBLE_TO_FLOAT /* 0x8c */
20301 .long .L_OP_INT_TO_BYTE /* 0x8d */
20302 .long .L_OP_INT_TO_CHAR /* 0x8e */
20303 .long .L_OP_INT_TO_SHORT /* 0x8f */
20304 .long .L_OP_ADD_INT /* 0x90 */
20305 .long .L_OP_SUB_INT /* 0x91 */
20306 .long .L_OP_MUL_INT /* 0x92 */
20307 .long .L_OP_DIV_INT /* 0x93 */
20308 .long .L_OP_REM_INT /* 0x94 */
20309 .long .L_OP_AND_INT /* 0x95 */
20310 .long .L_OP_OR_INT /* 0x96 */
20311 .long .L_OP_XOR_INT /* 0x97 */
20312 .long .L_OP_SHL_INT /* 0x98 */
20313 .long .L_OP_SHR_INT /* 0x99 */
20314 .long .L_OP_USHR_INT /* 0x9a */
20315 .long .L_OP_ADD_LONG /* 0x9b */
20316 .long .L_OP_SUB_LONG /* 0x9c */
20317 .long .L_OP_MUL_LONG /* 0x9d */
20318 .long .L_OP_DIV_LONG /* 0x9e */
20319 .long .L_OP_REM_LONG /* 0x9f */
20320 .long .L_OP_AND_LONG /* 0xa0 */
20321 .long .L_OP_OR_LONG /* 0xa1 */
20322 .long .L_OP_XOR_LONG /* 0xa2 */
20323 .long .L_OP_SHL_LONG /* 0xa3 */
20324 .long .L_OP_SHR_LONG /* 0xa4 */
20325 .long .L_OP_USHR_LONG /* 0xa5 */
20326 .long .L_OP_ADD_FLOAT /* 0xa6 */
20327 .long .L_OP_SUB_FLOAT /* 0xa7 */
20328 .long .L_OP_MUL_FLOAT /* 0xa8 */
20329 .long .L_OP_DIV_FLOAT /* 0xa9 */
20330 .long .L_OP_REM_FLOAT /* 0xaa */
20331 .long .L_OP_ADD_DOUBLE /* 0xab */
20332 .long .L_OP_SUB_DOUBLE /* 0xac */
20333 .long .L_OP_MUL_DOUBLE /* 0xad */
20334 .long .L_OP_DIV_DOUBLE /* 0xae */
20335 .long .L_OP_REM_DOUBLE /* 0xaf */
20336 .long .L_OP_ADD_INT_2ADDR /* 0xb0 */
20337 .long .L_OP_SUB_INT_2ADDR /* 0xb1 */
20338 .long .L_OP_MUL_INT_2ADDR /* 0xb2 */
20339 .long .L_OP_DIV_INT_2ADDR /* 0xb3 */
20340 .long .L_OP_REM_INT_2ADDR /* 0xb4 */
20341 .long .L_OP_AND_INT_2ADDR /* 0xb5 */
20342 .long .L_OP_OR_INT_2ADDR /* 0xb6 */
20343 .long .L_OP_XOR_INT_2ADDR /* 0xb7 */
20344 .long .L_OP_SHL_INT_2ADDR /* 0xb8 */
20345 .long .L_OP_SHR_INT_2ADDR /* 0xb9 */
20346 .long .L_OP_USHR_INT_2ADDR /* 0xba */
20347 .long .L_OP_ADD_LONG_2ADDR /* 0xbb */
20348 .long .L_OP_SUB_LONG_2ADDR /* 0xbc */
20349 .long .L_OP_MUL_LONG_2ADDR /* 0xbd */
20350 .long .L_OP_DIV_LONG_2ADDR /* 0xbe */
20351 .long .L_OP_REM_LONG_2ADDR /* 0xbf */
20352 .long .L_OP_AND_LONG_2ADDR /* 0xc0 */
20353 .long .L_OP_OR_LONG_2ADDR /* 0xc1 */
20354 .long .L_OP_XOR_LONG_2ADDR /* 0xc2 */
20355 .long .L_OP_SHL_LONG_2ADDR /* 0xc3 */
20356 .long .L_OP_SHR_LONG_2ADDR /* 0xc4 */
20357 .long .L_OP_USHR_LONG_2ADDR /* 0xc5 */
20358 .long .L_OP_ADD_FLOAT_2ADDR /* 0xc6 */
20359 .long .L_OP_SUB_FLOAT_2ADDR /* 0xc7 */
20360 .long .L_OP_MUL_FLOAT_2ADDR /* 0xc8 */
20361 .long .L_OP_DIV_FLOAT_2ADDR /* 0xc9 */
20362 .long .L_OP_REM_FLOAT_2ADDR /* 0xca */
20363 .long .L_OP_ADD_DOUBLE_2ADDR /* 0xcb */
20364 .long .L_OP_SUB_DOUBLE_2ADDR /* 0xcc */
20365 .long .L_OP_MUL_DOUBLE_2ADDR /* 0xcd */
20366 .long .L_OP_DIV_DOUBLE_2ADDR /* 0xce */
20367 .long .L_OP_REM_DOUBLE_2ADDR /* 0xcf */
20368 .long .L_OP_ADD_INT_LIT16 /* 0xd0 */
20369 .long .L_OP_RSUB_INT /* 0xd1 */
20370 .long .L_OP_MUL_INT_LIT16 /* 0xd2 */
20371 .long .L_OP_DIV_INT_LIT16 /* 0xd3 */
20372 .long .L_OP_REM_INT_LIT16 /* 0xd4 */
20373 .long .L_OP_AND_INT_LIT16 /* 0xd5 */
20374 .long .L_OP_OR_INT_LIT16 /* 0xd6 */
20375 .long .L_OP_XOR_INT_LIT16 /* 0xd7 */
20376 .long .L_OP_ADD_INT_LIT8 /* 0xd8 */
20377 .long .L_OP_RSUB_INT_LIT8 /* 0xd9 */
20378 .long .L_OP_MUL_INT_LIT8 /* 0xda */
20379 .long .L_OP_DIV_INT_LIT8 /* 0xdb */
20380 .long .L_OP_REM_INT_LIT8 /* 0xdc */
20381 .long .L_OP_AND_INT_LIT8 /* 0xdd */
20382 .long .L_OP_OR_INT_LIT8 /* 0xde */
20383 .long .L_OP_XOR_INT_LIT8 /* 0xdf */
20384 .long .L_OP_SHL_INT_LIT8 /* 0xe0 */
20385 .long .L_OP_SHR_INT_LIT8 /* 0xe1 */
20386 .long .L_OP_USHR_INT_LIT8 /* 0xe2 */
20387 .long .L_OP_IGET_VOLATILE /* 0xe3 */
20388 .long .L_OP_IPUT_VOLATILE /* 0xe4 */
20389 .long .L_OP_SGET_VOLATILE /* 0xe5 */
20390 .long .L_OP_SPUT_VOLATILE /* 0xe6 */
20391 .long .L_OP_IGET_OBJECT_VOLATILE /* 0xe7 */
20392 .long .L_OP_IGET_WIDE_VOLATILE /* 0xe8 */
20393 .long .L_OP_IPUT_WIDE_VOLATILE /* 0xe9 */
20394 .long .L_OP_SGET_WIDE_VOLATILE /* 0xea */
20395 .long .L_OP_SPUT_WIDE_VOLATILE /* 0xeb */
20396 .long .L_OP_BREAKPOINT /* 0xec */
20397 .long .L_OP_THROW_VERIFICATION_ERROR /* 0xed */
20398 .long .L_OP_EXECUTE_INLINE /* 0xee */
20399 .long .L_OP_EXECUTE_INLINE_RANGE /* 0xef */
20400 .long .L_OP_INVOKE_OBJECT_INIT_RANGE /* 0xf0 */
20401 .long .L_OP_RETURN_VOID_BARRIER /* 0xf1 */
20402 .long .L_OP_IGET_QUICK /* 0xf2 */
20403 .long .L_OP_IGET_WIDE_QUICK /* 0xf3 */
20404 .long .L_OP_IGET_OBJECT_QUICK /* 0xf4 */
20405 .long .L_OP_IPUT_QUICK /* 0xf5 */
20406 .long .L_OP_IPUT_WIDE_QUICK /* 0xf6 */
20407 .long .L_OP_IPUT_OBJECT_QUICK /* 0xf7 */
20408 .long .L_OP_INVOKE_VIRTUAL_QUICK /* 0xf8 */
20409 .long .L_OP_INVOKE_VIRTUAL_QUICK_RANGE /* 0xf9 */
20410 .long .L_OP_INVOKE_SUPER_QUICK /* 0xfa */
20411 .long .L_OP_INVOKE_SUPER_QUICK_RANGE /* 0xfb */
20412 .long .L_OP_IPUT_OBJECT_VOLATILE /* 0xfc */
20413 .long .L_OP_SGET_OBJECT_VOLATILE /* 0xfd */
20414 .long .L_OP_SPUT_OBJECT_VOLATILE /* 0xfe */
20415 .long .L_OP_DISPATCH_FF /* 0xff */
20416 .long .L_OP_CONST_CLASS_JUMBO /* 0x100 */
20417 .long .L_OP_CHECK_CAST_JUMBO /* 0x101 */
20418 .long .L_OP_INSTANCE_OF_JUMBO /* 0x102 */
20419 .long .L_OP_NEW_INSTANCE_JUMBO /* 0x103 */
20420 .long .L_OP_NEW_ARRAY_JUMBO /* 0x104 */
20421 .long .L_OP_FILLED_NEW_ARRAY_JUMBO /* 0x105 */
20422 .long .L_OP_IGET_JUMBO /* 0x106 */
20423 .long .L_OP_IGET_WIDE_JUMBO /* 0x107 */
20424 .long .L_OP_IGET_OBJECT_JUMBO /* 0x108 */
20425 .long .L_OP_IGET_BOOLEAN_JUMBO /* 0x109 */
20426 .long .L_OP_IGET_BYTE_JUMBO /* 0x10a */
20427 .long .L_OP_IGET_CHAR_JUMBO /* 0x10b */
20428 .long .L_OP_IGET_SHORT_JUMBO /* 0x10c */
20429 .long .L_OP_IPUT_JUMBO /* 0x10d */
20430 .long .L_OP_IPUT_WIDE_JUMBO /* 0x10e */
20431 .long .L_OP_IPUT_OBJECT_JUMBO /* 0x10f */
20432 .long .L_OP_IPUT_BOOLEAN_JUMBO /* 0x110 */
20433 .long .L_OP_IPUT_BYTE_JUMBO /* 0x111 */
20434 .long .L_OP_IPUT_CHAR_JUMBO /* 0x112 */
20435 .long .L_OP_IPUT_SHORT_JUMBO /* 0x113 */
20436 .long .L_OP_SGET_JUMBO /* 0x114 */
20437 .long .L_OP_SGET_WIDE_JUMBO /* 0x115 */
20438 .long .L_OP_SGET_OBJECT_JUMBO /* 0x116 */
20439 .long .L_OP_SGET_BOOLEAN_JUMBO /* 0x117 */
20440 .long .L_OP_SGET_BYTE_JUMBO /* 0x118 */
20441 .long .L_OP_SGET_CHAR_JUMBO /* 0x119 */
20442 .long .L_OP_SGET_SHORT_JUMBO /* 0x11a */
20443 .long .L_OP_SPUT_JUMBO /* 0x11b */
20444 .long .L_OP_SPUT_WIDE_JUMBO /* 0x11c */
20445 .long .L_OP_SPUT_OBJECT_JUMBO /* 0x11d */
20446 .long .L_OP_SPUT_BOOLEAN_JUMBO /* 0x11e */
20447 .long .L_OP_SPUT_BYTE_JUMBO /* 0x11f */
20448 .long .L_OP_SPUT_CHAR_JUMBO /* 0x120 */
20449 .long .L_OP_SPUT_SHORT_JUMBO /* 0x121 */
20450 .long .L_OP_INVOKE_VIRTUAL_JUMBO /* 0x122 */
20451 .long .L_OP_INVOKE_SUPER_JUMBO /* 0x123 */
20452 .long .L_OP_INVOKE_DIRECT_JUMBO /* 0x124 */
20453 .long .L_OP_INVOKE_STATIC_JUMBO /* 0x125 */
20454 .long .L_OP_INVOKE_INTERFACE_JUMBO /* 0x126 */
20455 .long .L_OP_UNUSED_27FF /* 0x127 */
20456 .long .L_OP_UNUSED_28FF /* 0x128 */
20457 .long .L_OP_UNUSED_29FF /* 0x129 */
20458 .long .L_OP_UNUSED_2AFF /* 0x12a */
20459 .long .L_OP_UNUSED_2BFF /* 0x12b */
20460 .long .L_OP_UNUSED_2CFF /* 0x12c */
20461 .long .L_OP_UNUSED_2DFF /* 0x12d */
20462 .long .L_OP_UNUSED_2EFF /* 0x12e */
20463 .long .L_OP_UNUSED_2FFF /* 0x12f */
20464 .long .L_OP_UNUSED_30FF /* 0x130 */
20465 .long .L_OP_UNUSED_31FF /* 0x131 */
20466 .long .L_OP_UNUSED_32FF /* 0x132 */
20467 .long .L_OP_UNUSED_33FF /* 0x133 */
20468 .long .L_OP_UNUSED_34FF /* 0x134 */
20469 .long .L_OP_UNUSED_35FF /* 0x135 */
20470 .long .L_OP_UNUSED_36FF /* 0x136 */
20471 .long .L_OP_UNUSED_37FF /* 0x137 */
20472 .long .L_OP_UNUSED_38FF /* 0x138 */
20473 .long .L_OP_UNUSED_39FF /* 0x139 */
20474 .long .L_OP_UNUSED_3AFF /* 0x13a */
20475 .long .L_OP_UNUSED_3BFF /* 0x13b */
20476 .long .L_OP_UNUSED_3CFF /* 0x13c */
20477 .long .L_OP_UNUSED_3DFF /* 0x13d */
20478 .long .L_OP_UNUSED_3EFF /* 0x13e */
20479 .long .L_OP_UNUSED_3FFF /* 0x13f */
20480 .long .L_OP_UNUSED_40FF /* 0x140 */
20481 .long .L_OP_UNUSED_41FF /* 0x141 */
20482 .long .L_OP_UNUSED_42FF /* 0x142 */
20483 .long .L_OP_UNUSED_43FF /* 0x143 */
20484 .long .L_OP_UNUSED_44FF /* 0x144 */
20485 .long .L_OP_UNUSED_45FF /* 0x145 */
20486 .long .L_OP_UNUSED_46FF /* 0x146 */
20487 .long .L_OP_UNUSED_47FF /* 0x147 */
20488 .long .L_OP_UNUSED_48FF /* 0x148 */
20489 .long .L_OP_UNUSED_49FF /* 0x149 */
20490 .long .L_OP_UNUSED_4AFF /* 0x14a */
20491 .long .L_OP_UNUSED_4BFF /* 0x14b */
20492 .long .L_OP_UNUSED_4CFF /* 0x14c */
20493 .long .L_OP_UNUSED_4DFF /* 0x14d */
20494 .long .L_OP_UNUSED_4EFF /* 0x14e */
20495 .long .L_OP_UNUSED_4FFF /* 0x14f */
20496 .long .L_OP_UNUSED_50FF /* 0x150 */
20497 .long .L_OP_UNUSED_51FF /* 0x151 */
20498 .long .L_OP_UNUSED_52FF /* 0x152 */
20499 .long .L_OP_UNUSED_53FF /* 0x153 */
20500 .long .L_OP_UNUSED_54FF /* 0x154 */
20501 .long .L_OP_UNUSED_55FF /* 0x155 */
20502 .long .L_OP_UNUSED_56FF /* 0x156 */
20503 .long .L_OP_UNUSED_57FF /* 0x157 */
20504 .long .L_OP_UNUSED_58FF /* 0x158 */
20505 .long .L_OP_UNUSED_59FF /* 0x159 */
20506 .long .L_OP_UNUSED_5AFF /* 0x15a */
20507 .long .L_OP_UNUSED_5BFF /* 0x15b */
20508 .long .L_OP_UNUSED_5CFF /* 0x15c */
20509 .long .L_OP_UNUSED_5DFF /* 0x15d */
20510 .long .L_OP_UNUSED_5EFF /* 0x15e */
20511 .long .L_OP_UNUSED_5FFF /* 0x15f */
20512 .long .L_OP_UNUSED_60FF /* 0x160 */
20513 .long .L_OP_UNUSED_61FF /* 0x161 */
20514 .long .L_OP_UNUSED_62FF /* 0x162 */
20515 .long .L_OP_UNUSED_63FF /* 0x163 */
20516 .long .L_OP_UNUSED_64FF /* 0x164 */
20517 .long .L_OP_UNUSED_65FF /* 0x165 */
20518 .long .L_OP_UNUSED_66FF /* 0x166 */
20519 .long .L_OP_UNUSED_67FF /* 0x167 */
20520 .long .L_OP_UNUSED_68FF /* 0x168 */
20521 .long .L_OP_UNUSED_69FF /* 0x169 */
20522 .long .L_OP_UNUSED_6AFF /* 0x16a */
20523 .long .L_OP_UNUSED_6BFF /* 0x16b */
20524 .long .L_OP_UNUSED_6CFF /* 0x16c */
20525 .long .L_OP_UNUSED_6DFF /* 0x16d */
20526 .long .L_OP_UNUSED_6EFF /* 0x16e */
20527 .long .L_OP_UNUSED_6FFF /* 0x16f */
20528 .long .L_OP_UNUSED_70FF /* 0x170 */
20529 .long .L_OP_UNUSED_71FF /* 0x171 */
20530 .long .L_OP_UNUSED_72FF /* 0x172 */
20531 .long .L_OP_UNUSED_73FF /* 0x173 */
20532 .long .L_OP_UNUSED_74FF /* 0x174 */
20533 .long .L_OP_UNUSED_75FF /* 0x175 */
20534 .long .L_OP_UNUSED_76FF /* 0x176 */
20535 .long .L_OP_UNUSED_77FF /* 0x177 */
20536 .long .L_OP_UNUSED_78FF /* 0x178 */
20537 .long .L_OP_UNUSED_79FF /* 0x179 */
20538 .long .L_OP_UNUSED_7AFF /* 0x17a */
20539 .long .L_OP_UNUSED_7BFF /* 0x17b */
20540 .long .L_OP_UNUSED_7CFF /* 0x17c */
20541 .long .L_OP_UNUSED_7DFF /* 0x17d */
20542 .long .L_OP_UNUSED_7EFF /* 0x17e */
20543 .long .L_OP_UNUSED_7FFF /* 0x17f */
20544 .long .L_OP_UNUSED_80FF /* 0x180 */
20545 .long .L_OP_UNUSED_81FF /* 0x181 */
20546 .long .L_OP_UNUSED_82FF /* 0x182 */
20547 .long .L_OP_UNUSED_83FF /* 0x183 */
20548 .long .L_OP_UNUSED_84FF /* 0x184 */
20549 .long .L_OP_UNUSED_85FF /* 0x185 */
20550 .long .L_OP_UNUSED_86FF /* 0x186 */
20551 .long .L_OP_UNUSED_87FF /* 0x187 */
20552 .long .L_OP_UNUSED_88FF /* 0x188 */
20553 .long .L_OP_UNUSED_89FF /* 0x189 */
20554 .long .L_OP_UNUSED_8AFF /* 0x18a */
20555 .long .L_OP_UNUSED_8BFF /* 0x18b */
20556 .long .L_OP_UNUSED_8CFF /* 0x18c */
20557 .long .L_OP_UNUSED_8DFF /* 0x18d */
20558 .long .L_OP_UNUSED_8EFF /* 0x18e */
20559 .long .L_OP_UNUSED_8FFF /* 0x18f */
20560 .long .L_OP_UNUSED_90FF /* 0x190 */
20561 .long .L_OP_UNUSED_91FF /* 0x191 */
20562 .long .L_OP_UNUSED_92FF /* 0x192 */
20563 .long .L_OP_UNUSED_93FF /* 0x193 */
20564 .long .L_OP_UNUSED_94FF /* 0x194 */
20565 .long .L_OP_UNUSED_95FF /* 0x195 */
20566 .long .L_OP_UNUSED_96FF /* 0x196 */
20567 .long .L_OP_UNUSED_97FF /* 0x197 */
20568 .long .L_OP_UNUSED_98FF /* 0x198 */
20569 .long .L_OP_UNUSED_99FF /* 0x199 */
20570 .long .L_OP_UNUSED_9AFF /* 0x19a */
20571 .long .L_OP_UNUSED_9BFF /* 0x19b */
20572 .long .L_OP_UNUSED_9CFF /* 0x19c */
20573 .long .L_OP_UNUSED_9DFF /* 0x19d */
20574 .long .L_OP_UNUSED_9EFF /* 0x19e */
20575 .long .L_OP_UNUSED_9FFF /* 0x19f */
20576 .long .L_OP_UNUSED_A0FF /* 0x1a0 */
20577 .long .L_OP_UNUSED_A1FF /* 0x1a1 */
20578 .long .L_OP_UNUSED_A2FF /* 0x1a2 */
20579 .long .L_OP_UNUSED_A3FF /* 0x1a3 */
20580 .long .L_OP_UNUSED_A4FF /* 0x1a4 */
20581 .long .L_OP_UNUSED_A5FF /* 0x1a5 */
20582 .long .L_OP_UNUSED_A6FF /* 0x1a6 */
20583 .long .L_OP_UNUSED_A7FF /* 0x1a7 */
20584 .long .L_OP_UNUSED_A8FF /* 0x1a8 */
20585 .long .L_OP_UNUSED_A9FF /* 0x1a9 */
20586 .long .L_OP_UNUSED_AAFF /* 0x1aa */
20587 .long .L_OP_UNUSED_ABFF /* 0x1ab */
20588 .long .L_OP_UNUSED_ACFF /* 0x1ac */
20589 .long .L_OP_UNUSED_ADFF /* 0x1ad */
20590 .long .L_OP_UNUSED_AEFF /* 0x1ae */
20591 .long .L_OP_UNUSED_AFFF /* 0x1af */
20592 .long .L_OP_UNUSED_B0FF /* 0x1b0 */
20593 .long .L_OP_UNUSED_B1FF /* 0x1b1 */
20594 .long .L_OP_UNUSED_B2FF /* 0x1b2 */
20595 .long .L_OP_UNUSED_B3FF /* 0x1b3 */
20596 .long .L_OP_UNUSED_B4FF /* 0x1b4 */
20597 .long .L_OP_UNUSED_B5FF /* 0x1b5 */
20598 .long .L_OP_UNUSED_B6FF /* 0x1b6 */
20599 .long .L_OP_UNUSED_B7FF /* 0x1b7 */
20600 .long .L_OP_UNUSED_B8FF /* 0x1b8 */
20601 .long .L_OP_UNUSED_B9FF /* 0x1b9 */
20602 .long .L_OP_UNUSED_BAFF /* 0x1ba */
20603 .long .L_OP_UNUSED_BBFF /* 0x1bb */
20604 .long .L_OP_UNUSED_BCFF /* 0x1bc */
20605 .long .L_OP_UNUSED_BDFF /* 0x1bd */
20606 .long .L_OP_UNUSED_BEFF /* 0x1be */
20607 .long .L_OP_UNUSED_BFFF /* 0x1bf */
20608 .long .L_OP_UNUSED_C0FF /* 0x1c0 */
20609 .long .L_OP_UNUSED_C1FF /* 0x1c1 */
20610 .long .L_OP_UNUSED_C2FF /* 0x1c2 */
20611 .long .L_OP_UNUSED_C3FF /* 0x1c3 */
20612 .long .L_OP_UNUSED_C4FF /* 0x1c4 */
20613 .long .L_OP_UNUSED_C5FF /* 0x1c5 */
20614 .long .L_OP_UNUSED_C6FF /* 0x1c6 */
20615 .long .L_OP_UNUSED_C7FF /* 0x1c7 */
20616 .long .L_OP_UNUSED_C8FF /* 0x1c8 */
20617 .long .L_OP_UNUSED_C9FF /* 0x1c9 */
20618 .long .L_OP_UNUSED_CAFF /* 0x1ca */
20619 .long .L_OP_UNUSED_CBFF /* 0x1cb */
20620 .long .L_OP_UNUSED_CCFF /* 0x1cc */
20621 .long .L_OP_UNUSED_CDFF /* 0x1cd */
20622 .long .L_OP_UNUSED_CEFF /* 0x1ce */
20623 .long .L_OP_UNUSED_CFFF /* 0x1cf */
20624 .long .L_OP_UNUSED_D0FF /* 0x1d0 */
20625 .long .L_OP_UNUSED_D1FF /* 0x1d1 */
20626 .long .L_OP_UNUSED_D2FF /* 0x1d2 */
20627 .long .L_OP_UNUSED_D3FF /* 0x1d3 */
20628 .long .L_OP_UNUSED_D4FF /* 0x1d4 */
20629 .long .L_OP_UNUSED_D5FF /* 0x1d5 */
20630 .long .L_OP_UNUSED_D6FF /* 0x1d6 */
20631 .long .L_OP_UNUSED_D7FF /* 0x1d7 */
20632 .long .L_OP_UNUSED_D8FF /* 0x1d8 */
20633 .long .L_OP_UNUSED_D9FF /* 0x1d9 */
20634 .long .L_OP_UNUSED_DAFF /* 0x1da */
20635 .long .L_OP_UNUSED_DBFF /* 0x1db */
20636 .long .L_OP_UNUSED_DCFF /* 0x1dc */
20637 .long .L_OP_UNUSED_DDFF /* 0x1dd */
20638 .long .L_OP_UNUSED_DEFF /* 0x1de */
20639 .long .L_OP_UNUSED_DFFF /* 0x1df */
20640 .long .L_OP_UNUSED_E0FF /* 0x1e0 */
20641 .long .L_OP_UNUSED_E1FF /* 0x1e1 */
20642 .long .L_OP_UNUSED_E2FF /* 0x1e2 */
20643 .long .L_OP_UNUSED_E3FF /* 0x1e3 */
20644 .long .L_OP_UNUSED_E4FF /* 0x1e4 */
20645 .long .L_OP_UNUSED_E5FF /* 0x1e5 */
20646 .long .L_OP_UNUSED_E6FF /* 0x1e6 */
20647 .long .L_OP_UNUSED_E7FF /* 0x1e7 */
20648 .long .L_OP_UNUSED_E8FF /* 0x1e8 */
20649 .long .L_OP_UNUSED_E9FF /* 0x1e9 */
20650 .long .L_OP_UNUSED_EAFF /* 0x1ea */
20651 .long .L_OP_UNUSED_EBFF /* 0x1eb */
20652 .long .L_OP_UNUSED_ECFF /* 0x1ec */
20653 .long .L_OP_UNUSED_EDFF /* 0x1ed */
20654 .long .L_OP_UNUSED_EEFF /* 0x1ee */
20655 .long .L_OP_UNUSED_EFFF /* 0x1ef */
20656 .long .L_OP_UNUSED_F0FF /* 0x1f0 */
20657 .long .L_OP_UNUSED_F1FF /* 0x1f1 */
20658 .long .L_OP_UNUSED_F2FF /* 0x1f2 */
20659 .long .L_OP_UNUSED_F3FF /* 0x1f3 */
20660 .long .L_OP_UNUSED_F4FF /* 0x1f4 */
20661 .long .L_OP_UNUSED_F5FF /* 0x1f5 */
20662 .long .L_OP_UNUSED_F6FF /* 0x1f6 */
20663 .long .L_OP_UNUSED_F7FF /* 0x1f7 */
20664 .long .L_OP_UNUSED_F8FF /* 0x1f8 */
20665 .long .L_OP_UNUSED_F9FF /* 0x1f9 */
20666 .long .L_OP_UNUSED_FAFF /* 0x1fa */
20667 .long .L_OP_UNUSED_FBFF /* 0x1fb */
20668 .long .L_OP_UNUSED_FCFF /* 0x1fc */
20669 .long .L_OP_UNUSED_FDFF /* 0x1fd */
20670 .long .L_OP_UNUSED_FEFF /* 0x1fe */
20671 .long .L_OP_THROW_VERIFICATION_ERROR_JUMBO /* 0x1ff */
20673 .global dvmAsmAltInstructionStart
20675 dvmAsmAltInstructionStart:
20676 .long .L_ALT_OP_NOP /* 0x00 */
20677 .long .L_ALT_OP_MOVE /* 0x01 */
20678 .long .L_ALT_OP_MOVE_FROM16 /* 0x02 */
20679 .long .L_ALT_OP_MOVE_16 /* 0x03 */
20680 .long .L_ALT_OP_MOVE_WIDE /* 0x04 */
20681 .long .L_ALT_OP_MOVE_WIDE_FROM16 /* 0x05 */
20682 .long .L_ALT_OP_MOVE_WIDE_16 /* 0x06 */
20683 .long .L_ALT_OP_MOVE_OBJECT /* 0x07 */
20684 .long .L_ALT_OP_MOVE_OBJECT_FROM16 /* 0x08 */
20685 .long .L_ALT_OP_MOVE_OBJECT_16 /* 0x09 */
20686 .long .L_ALT_OP_MOVE_RESULT /* 0x0a */
20687 .long .L_ALT_OP_MOVE_RESULT_WIDE /* 0x0b */
20688 .long .L_ALT_OP_MOVE_RESULT_OBJECT /* 0x0c */
20689 .long .L_ALT_OP_MOVE_EXCEPTION /* 0x0d */
20690 .long .L_ALT_OP_RETURN_VOID /* 0x0e */
20691 .long .L_ALT_OP_RETURN /* 0x0f */
20692 .long .L_ALT_OP_RETURN_WIDE /* 0x10 */
20693 .long .L_ALT_OP_RETURN_OBJECT /* 0x11 */
20694 .long .L_ALT_OP_CONST_4 /* 0x12 */
20695 .long .L_ALT_OP_CONST_16 /* 0x13 */
20696 .long .L_ALT_OP_CONST /* 0x14 */
20697 .long .L_ALT_OP_CONST_HIGH16 /* 0x15 */
20698 .long .L_ALT_OP_CONST_WIDE_16 /* 0x16 */
20699 .long .L_ALT_OP_CONST_WIDE_32 /* 0x17 */
20700 .long .L_ALT_OP_CONST_WIDE /* 0x18 */
20701 .long .L_ALT_OP_CONST_WIDE_HIGH16 /* 0x19 */
20702 .long .L_ALT_OP_CONST_STRING /* 0x1a */
20703 .long .L_ALT_OP_CONST_STRING_JUMBO /* 0x1b */
20704 .long .L_ALT_OP_CONST_CLASS /* 0x1c */
20705 .long .L_ALT_OP_MONITOR_ENTER /* 0x1d */
20706 .long .L_ALT_OP_MONITOR_EXIT /* 0x1e */
20707 .long .L_ALT_OP_CHECK_CAST /* 0x1f */
20708 .long .L_ALT_OP_INSTANCE_OF /* 0x20 */
20709 .long .L_ALT_OP_ARRAY_LENGTH /* 0x21 */
20710 .long .L_ALT_OP_NEW_INSTANCE /* 0x22 */
20711 .long .L_ALT_OP_NEW_ARRAY /* 0x23 */
20712 .long .L_ALT_OP_FILLED_NEW_ARRAY /* 0x24 */
20713 .long .L_ALT_OP_FILLED_NEW_ARRAY_RANGE /* 0x25 */
20714 .long .L_ALT_OP_FILL_ARRAY_DATA /* 0x26 */
20715 .long .L_ALT_OP_THROW /* 0x27 */
20716 .long .L_ALT_OP_GOTO /* 0x28 */
20717 .long .L_ALT_OP_GOTO_16 /* 0x29 */
20718 .long .L_ALT_OP_GOTO_32 /* 0x2a */
20719 .long .L_ALT_OP_PACKED_SWITCH /* 0x2b */
20720 .long .L_ALT_OP_SPARSE_SWITCH /* 0x2c */
20721 .long .L_ALT_OP_CMPL_FLOAT /* 0x2d */
20722 .long .L_ALT_OP_CMPG_FLOAT /* 0x2e */
20723 .long .L_ALT_OP_CMPL_DOUBLE /* 0x2f */
20724 .long .L_ALT_OP_CMPG_DOUBLE /* 0x30 */
20725 .long .L_ALT_OP_CMP_LONG /* 0x31 */
20726 .long .L_ALT_OP_IF_EQ /* 0x32 */
20727 .long .L_ALT_OP_IF_NE /* 0x33 */
20728 .long .L_ALT_OP_IF_LT /* 0x34 */
20729 .long .L_ALT_OP_IF_GE /* 0x35 */
20730 .long .L_ALT_OP_IF_GT /* 0x36 */
20731 .long .L_ALT_OP_IF_LE /* 0x37 */
20732 .long .L_ALT_OP_IF_EQZ /* 0x38 */
20733 .long .L_ALT_OP_IF_NEZ /* 0x39 */
20734 .long .L_ALT_OP_IF_LTZ /* 0x3a */
20735 .long .L_ALT_OP_IF_GEZ /* 0x3b */
20736 .long .L_ALT_OP_IF_GTZ /* 0x3c */
20737 .long .L_ALT_OP_IF_LEZ /* 0x3d */
20738 .long .L_ALT_OP_UNUSED_3E /* 0x3e */
20739 .long .L_ALT_OP_UNUSED_3F /* 0x3f */
20740 .long .L_ALT_OP_UNUSED_40 /* 0x40 */
20741 .long .L_ALT_OP_UNUSED_41 /* 0x41 */
20742 .long .L_ALT_OP_UNUSED_42 /* 0x42 */
20743 .long .L_ALT_OP_UNUSED_43 /* 0x43 */
20744 .long .L_ALT_OP_AGET /* 0x44 */
20745 .long .L_ALT_OP_AGET_WIDE /* 0x45 */
20746 .long .L_ALT_OP_AGET_OBJECT /* 0x46 */
20747 .long .L_ALT_OP_AGET_BOOLEAN /* 0x47 */
20748 .long .L_ALT_OP_AGET_BYTE /* 0x48 */
20749 .long .L_ALT_OP_AGET_CHAR /* 0x49 */
20750 .long .L_ALT_OP_AGET_SHORT /* 0x4a */
20751 .long .L_ALT_OP_APUT /* 0x4b */
20752 .long .L_ALT_OP_APUT_WIDE /* 0x4c */
20753 .long .L_ALT_OP_APUT_OBJECT /* 0x4d */
20754 .long .L_ALT_OP_APUT_BOOLEAN /* 0x4e */
20755 .long .L_ALT_OP_APUT_BYTE /* 0x4f */
20756 .long .L_ALT_OP_APUT_CHAR /* 0x50 */
20757 .long .L_ALT_OP_APUT_SHORT /* 0x51 */
20758 .long .L_ALT_OP_IGET /* 0x52 */
20759 .long .L_ALT_OP_IGET_WIDE /* 0x53 */
20760 .long .L_ALT_OP_IGET_OBJECT /* 0x54 */
20761 .long .L_ALT_OP_IGET_BOOLEAN /* 0x55 */
20762 .long .L_ALT_OP_IGET_BYTE /* 0x56 */
20763 .long .L_ALT_OP_IGET_CHAR /* 0x57 */
20764 .long .L_ALT_OP_IGET_SHORT /* 0x58 */
20765 .long .L_ALT_OP_IPUT /* 0x59 */
20766 .long .L_ALT_OP_IPUT_WIDE /* 0x5a */
20767 .long .L_ALT_OP_IPUT_OBJECT /* 0x5b */
20768 .long .L_ALT_OP_IPUT_BOOLEAN /* 0x5c */
20769 .long .L_ALT_OP_IPUT_BYTE /* 0x5d */
20770 .long .L_ALT_OP_IPUT_CHAR /* 0x5e */
20771 .long .L_ALT_OP_IPUT_SHORT /* 0x5f */
20772 .long .L_ALT_OP_SGET /* 0x60 */
20773 .long .L_ALT_OP_SGET_WIDE /* 0x61 */
20774 .long .L_ALT_OP_SGET_OBJECT /* 0x62 */
20775 .long .L_ALT_OP_SGET_BOOLEAN /* 0x63 */
20776 .long .L_ALT_OP_SGET_BYTE /* 0x64 */
20777 .long .L_ALT_OP_SGET_CHAR /* 0x65 */
20778 .long .L_ALT_OP_SGET_SHORT /* 0x66 */
20779 .long .L_ALT_OP_SPUT /* 0x67 */
20780 .long .L_ALT_OP_SPUT_WIDE /* 0x68 */
20781 .long .L_ALT_OP_SPUT_OBJECT /* 0x69 */
20782 .long .L_ALT_OP_SPUT_BOOLEAN /* 0x6a */
20783 .long .L_ALT_OP_SPUT_BYTE /* 0x6b */
20784 .long .L_ALT_OP_SPUT_CHAR /* 0x6c */
20785 .long .L_ALT_OP_SPUT_SHORT /* 0x6d */
20786 .long .L_ALT_OP_INVOKE_VIRTUAL /* 0x6e */
20787 .long .L_ALT_OP_INVOKE_SUPER /* 0x6f */
20788 .long .L_ALT_OP_INVOKE_DIRECT /* 0x70 */
20789 .long .L_ALT_OP_INVOKE_STATIC /* 0x71 */
20790 .long .L_ALT_OP_INVOKE_INTERFACE /* 0x72 */
20791 .long .L_ALT_OP_UNUSED_73 /* 0x73 */
20792 .long .L_ALT_OP_INVOKE_VIRTUAL_RANGE /* 0x74 */
20793 .long .L_ALT_OP_INVOKE_SUPER_RANGE /* 0x75 */
20794 .long .L_ALT_OP_INVOKE_DIRECT_RANGE /* 0x76 */
20795 .long .L_ALT_OP_INVOKE_STATIC_RANGE /* 0x77 */
20796 .long .L_ALT_OP_INVOKE_INTERFACE_RANGE /* 0x78 */
20797 .long .L_ALT_OP_UNUSED_79 /* 0x79 */
20798 .long .L_ALT_OP_UNUSED_7A /* 0x7a */
20799 .long .L_ALT_OP_NEG_INT /* 0x7b */
20800 .long .L_ALT_OP_NOT_INT /* 0x7c */
20801 .long .L_ALT_OP_NEG_LONG /* 0x7d */
20802 .long .L_ALT_OP_NOT_LONG /* 0x7e */
20803 .long .L_ALT_OP_NEG_FLOAT /* 0x7f */
20804 .long .L_ALT_OP_NEG_DOUBLE /* 0x80 */
20805 .long .L_ALT_OP_INT_TO_LONG /* 0x81 */
20806 .long .L_ALT_OP_INT_TO_FLOAT /* 0x82 */
20807 .long .L_ALT_OP_INT_TO_DOUBLE /* 0x83 */
20808 .long .L_ALT_OP_LONG_TO_INT /* 0x84 */
20809 .long .L_ALT_OP_LONG_TO_FLOAT /* 0x85 */
20810 .long .L_ALT_OP_LONG_TO_DOUBLE /* 0x86 */
20811 .long .L_ALT_OP_FLOAT_TO_INT /* 0x87 */
20812 .long .L_ALT_OP_FLOAT_TO_LONG /* 0x88 */
20813 .long .L_ALT_OP_FLOAT_TO_DOUBLE /* 0x89 */
20814 .long .L_ALT_OP_DOUBLE_TO_INT /* 0x8a */
20815 .long .L_ALT_OP_DOUBLE_TO_LONG /* 0x8b */
20816 .long .L_ALT_OP_DOUBLE_TO_FLOAT /* 0x8c */
20817 .long .L_ALT_OP_INT_TO_BYTE /* 0x8d */
20818 .long .L_ALT_OP_INT_TO_CHAR /* 0x8e */
20819 .long .L_ALT_OP_INT_TO_SHORT /* 0x8f */
20820 .long .L_ALT_OP_ADD_INT /* 0x90 */
20821 .long .L_ALT_OP_SUB_INT /* 0x91 */
20822 .long .L_ALT_OP_MUL_INT /* 0x92 */
20823 .long .L_ALT_OP_DIV_INT /* 0x93 */
20824 .long .L_ALT_OP_REM_INT /* 0x94 */
20825 .long .L_ALT_OP_AND_INT /* 0x95 */
20826 .long .L_ALT_OP_OR_INT /* 0x96 */
20827 .long .L_ALT_OP_XOR_INT /* 0x97 */
20828 .long .L_ALT_OP_SHL_INT /* 0x98 */
20829 .long .L_ALT_OP_SHR_INT /* 0x99 */
20830 .long .L_ALT_OP_USHR_INT /* 0x9a */
20831 .long .L_ALT_OP_ADD_LONG /* 0x9b */
20832 .long .L_ALT_OP_SUB_LONG /* 0x9c */
20833 .long .L_ALT_OP_MUL_LONG /* 0x9d */
20834 .long .L_ALT_OP_DIV_LONG /* 0x9e */
20835 .long .L_ALT_OP_REM_LONG /* 0x9f */
20836 .long .L_ALT_OP_AND_LONG /* 0xa0 */
20837 .long .L_ALT_OP_OR_LONG /* 0xa1 */
20838 .long .L_ALT_OP_XOR_LONG /* 0xa2 */
20839 .long .L_ALT_OP_SHL_LONG /* 0xa3 */
20840 .long .L_ALT_OP_SHR_LONG /* 0xa4 */
20841 .long .L_ALT_OP_USHR_LONG /* 0xa5 */
20842 .long .L_ALT_OP_ADD_FLOAT /* 0xa6 */
20843 .long .L_ALT_OP_SUB_FLOAT /* 0xa7 */
20844 .long .L_ALT_OP_MUL_FLOAT /* 0xa8 */
20845 .long .L_ALT_OP_DIV_FLOAT /* 0xa9 */
20846 .long .L_ALT_OP_REM_FLOAT /* 0xaa */
20847 .long .L_ALT_OP_ADD_DOUBLE /* 0xab */
20848 .long .L_ALT_OP_SUB_DOUBLE /* 0xac */
20849 .long .L_ALT_OP_MUL_DOUBLE /* 0xad */
20850 .long .L_ALT_OP_DIV_DOUBLE /* 0xae */
20851 .long .L_ALT_OP_REM_DOUBLE /* 0xaf */
20852 .long .L_ALT_OP_ADD_INT_2ADDR /* 0xb0 */
20853 .long .L_ALT_OP_SUB_INT_2ADDR /* 0xb1 */
20854 .long .L_ALT_OP_MUL_INT_2ADDR /* 0xb2 */
20855 .long .L_ALT_OP_DIV_INT_2ADDR /* 0xb3 */
20856 .long .L_ALT_OP_REM_INT_2ADDR /* 0xb4 */
20857 .long .L_ALT_OP_AND_INT_2ADDR /* 0xb5 */
20858 .long .L_ALT_OP_OR_INT_2ADDR /* 0xb6 */
20859 .long .L_ALT_OP_XOR_INT_2ADDR /* 0xb7 */
20860 .long .L_ALT_OP_SHL_INT_2ADDR /* 0xb8 */
20861 .long .L_ALT_OP_SHR_INT_2ADDR /* 0xb9 */
20862 .long .L_ALT_OP_USHR_INT_2ADDR /* 0xba */
20863 .long .L_ALT_OP_ADD_LONG_2ADDR /* 0xbb */
20864 .long .L_ALT_OP_SUB_LONG_2ADDR /* 0xbc */
20865 .long .L_ALT_OP_MUL_LONG_2ADDR /* 0xbd */
20866 .long .L_ALT_OP_DIV_LONG_2ADDR /* 0xbe */
20867 .long .L_ALT_OP_REM_LONG_2ADDR /* 0xbf */
20868 .long .L_ALT_OP_AND_LONG_2ADDR /* 0xc0 */
20869 .long .L_ALT_OP_OR_LONG_2ADDR /* 0xc1 */
20870 .long .L_ALT_OP_XOR_LONG_2ADDR /* 0xc2 */
20871 .long .L_ALT_OP_SHL_LONG_2ADDR /* 0xc3 */
20872 .long .L_ALT_OP_SHR_LONG_2ADDR /* 0xc4 */
20873 .long .L_ALT_OP_USHR_LONG_2ADDR /* 0xc5 */
20874 .long .L_ALT_OP_ADD_FLOAT_2ADDR /* 0xc6 */
20875 .long .L_ALT_OP_SUB_FLOAT_2ADDR /* 0xc7 */
20876 .long .L_ALT_OP_MUL_FLOAT_2ADDR /* 0xc8 */
20877 .long .L_ALT_OP_DIV_FLOAT_2ADDR /* 0xc9 */
20878 .long .L_ALT_OP_REM_FLOAT_2ADDR /* 0xca */
20879 .long .L_ALT_OP_ADD_DOUBLE_2ADDR /* 0xcb */
20880 .long .L_ALT_OP_SUB_DOUBLE_2ADDR /* 0xcc */
20881 .long .L_ALT_OP_MUL_DOUBLE_2ADDR /* 0xcd */
20882 .long .L_ALT_OP_DIV_DOUBLE_2ADDR /* 0xce */
20883 .long .L_ALT_OP_REM_DOUBLE_2ADDR /* 0xcf */
20884 .long .L_ALT_OP_ADD_INT_LIT16 /* 0xd0 */
20885 .long .L_ALT_OP_RSUB_INT /* 0xd1 */
20886 .long .L_ALT_OP_MUL_INT_LIT16 /* 0xd2 */
20887 .long .L_ALT_OP_DIV_INT_LIT16 /* 0xd3 */
20888 .long .L_ALT_OP_REM_INT_LIT16 /* 0xd4 */
20889 .long .L_ALT_OP_AND_INT_LIT16 /* 0xd5 */
20890 .long .L_ALT_OP_OR_INT_LIT16 /* 0xd6 */
20891 .long .L_ALT_OP_XOR_INT_LIT16 /* 0xd7 */
20892 .long .L_ALT_OP_ADD_INT_LIT8 /* 0xd8 */
20893 .long .L_ALT_OP_RSUB_INT_LIT8 /* 0xd9 */
20894 .long .L_ALT_OP_MUL_INT_LIT8 /* 0xda */
20895 .long .L_ALT_OP_DIV_INT_LIT8 /* 0xdb */
20896 .long .L_ALT_OP_REM_INT_LIT8 /* 0xdc */
20897 .long .L_ALT_OP_AND_INT_LIT8 /* 0xdd */
20898 .long .L_ALT_OP_OR_INT_LIT8 /* 0xde */
20899 .long .L_ALT_OP_XOR_INT_LIT8 /* 0xdf */
20900 .long .L_ALT_OP_SHL_INT_LIT8 /* 0xe0 */
20901 .long .L_ALT_OP_SHR_INT_LIT8 /* 0xe1 */
20902 .long .L_ALT_OP_USHR_INT_LIT8 /* 0xe2 */
20903 .long .L_ALT_OP_IGET_VOLATILE /* 0xe3 */
20904 .long .L_ALT_OP_IPUT_VOLATILE /* 0xe4 */
20905 .long .L_ALT_OP_SGET_VOLATILE /* 0xe5 */
20906 .long .L_ALT_OP_SPUT_VOLATILE /* 0xe6 */
20907 .long .L_ALT_OP_IGET_OBJECT_VOLATILE /* 0xe7 */
20908 .long .L_ALT_OP_IGET_WIDE_VOLATILE /* 0xe8 */
20909 .long .L_ALT_OP_IPUT_WIDE_VOLATILE /* 0xe9 */
20910 .long .L_ALT_OP_SGET_WIDE_VOLATILE /* 0xea */
20911 .long .L_ALT_OP_SPUT_WIDE_VOLATILE /* 0xeb */
20912 .long .L_ALT_OP_BREAKPOINT /* 0xec */
20913 .long .L_ALT_OP_THROW_VERIFICATION_ERROR /* 0xed */
20914 .long .L_ALT_OP_EXECUTE_INLINE /* 0xee */
20915 .long .L_ALT_OP_EXECUTE_INLINE_RANGE /* 0xef */
20916 .long .L_ALT_OP_INVOKE_OBJECT_INIT_RANGE /* 0xf0 */
20917 .long .L_ALT_OP_RETURN_VOID_BARRIER /* 0xf1 */
20918 .long .L_ALT_OP_IGET_QUICK /* 0xf2 */
20919 .long .L_ALT_OP_IGET_WIDE_QUICK /* 0xf3 */
20920 .long .L_ALT_OP_IGET_OBJECT_QUICK /* 0xf4 */
20921 .long .L_ALT_OP_IPUT_QUICK /* 0xf5 */
20922 .long .L_ALT_OP_IPUT_WIDE_QUICK /* 0xf6 */
20923 .long .L_ALT_OP_IPUT_OBJECT_QUICK /* 0xf7 */
20924 .long .L_ALT_OP_INVOKE_VIRTUAL_QUICK /* 0xf8 */
20925 .long .L_ALT_OP_INVOKE_VIRTUAL_QUICK_RANGE /* 0xf9 */
20926 .long .L_ALT_OP_INVOKE_SUPER_QUICK /* 0xfa */
20927 .long .L_ALT_OP_INVOKE_SUPER_QUICK_RANGE /* 0xfb */
20928 .long .L_ALT_OP_IPUT_OBJECT_VOLATILE /* 0xfc */
20929 .long .L_ALT_OP_SGET_OBJECT_VOLATILE /* 0xfd */
20930 .long .L_ALT_OP_SPUT_OBJECT_VOLATILE /* 0xfe */
20931 .long .L_ALT_OP_DISPATCH_FF /* 0xff */
20932 .long .L_ALT_OP_CONST_CLASS_JUMBO /* 0x100 */
20933 .long .L_ALT_OP_CHECK_CAST_JUMBO /* 0x101 */
20934 .long .L_ALT_OP_INSTANCE_OF_JUMBO /* 0x102 */
20935 .long .L_ALT_OP_NEW_INSTANCE_JUMBO /* 0x103 */
20936 .long .L_ALT_OP_NEW_ARRAY_JUMBO /* 0x104 */
20937 .long .L_ALT_OP_FILLED_NEW_ARRAY_JUMBO /* 0x105 */
20938 .long .L_ALT_OP_IGET_JUMBO /* 0x106 */
20939 .long .L_ALT_OP_IGET_WIDE_JUMBO /* 0x107 */
20940 .long .L_ALT_OP_IGET_OBJECT_JUMBO /* 0x108 */
20941 .long .L_ALT_OP_IGET_BOOLEAN_JUMBO /* 0x109 */
20942 .long .L_ALT_OP_IGET_BYTE_JUMBO /* 0x10a */
20943 .long .L_ALT_OP_IGET_CHAR_JUMBO /* 0x10b */
20944 .long .L_ALT_OP_IGET_SHORT_JUMBO /* 0x10c */
20945 .long .L_ALT_OP_IPUT_JUMBO /* 0x10d */
20946 .long .L_ALT_OP_IPUT_WIDE_JUMBO /* 0x10e */
20947 .long .L_ALT_OP_IPUT_OBJECT_JUMBO /* 0x10f */
20948 .long .L_ALT_OP_IPUT_BOOLEAN_JUMBO /* 0x110 */
20949 .long .L_ALT_OP_IPUT_BYTE_JUMBO /* 0x111 */
20950 .long .L_ALT_OP_IPUT_CHAR_JUMBO /* 0x112 */
20951 .long .L_ALT_OP_IPUT_SHORT_JUMBO /* 0x113 */
20952 .long .L_ALT_OP_SGET_JUMBO /* 0x114 */
20953 .long .L_ALT_OP_SGET_WIDE_JUMBO /* 0x115 */
20954 .long .L_ALT_OP_SGET_OBJECT_JUMBO /* 0x116 */
20955 .long .L_ALT_OP_SGET_BOOLEAN_JUMBO /* 0x117 */
20956 .long .L_ALT_OP_SGET_BYTE_JUMBO /* 0x118 */
20957 .long .L_ALT_OP_SGET_CHAR_JUMBO /* 0x119 */
20958 .long .L_ALT_OP_SGET_SHORT_JUMBO /* 0x11a */
20959 .long .L_ALT_OP_SPUT_JUMBO /* 0x11b */
20960 .long .L_ALT_OP_SPUT_WIDE_JUMBO /* 0x11c */
20961 .long .L_ALT_OP_SPUT_OBJECT_JUMBO /* 0x11d */
20962 .long .L_ALT_OP_SPUT_BOOLEAN_JUMBO /* 0x11e */
20963 .long .L_ALT_OP_SPUT_BYTE_JUMBO /* 0x11f */
20964 .long .L_ALT_OP_SPUT_CHAR_JUMBO /* 0x120 */
20965 .long .L_ALT_OP_SPUT_SHORT_JUMBO /* 0x121 */
20966 .long .L_ALT_OP_INVOKE_VIRTUAL_JUMBO /* 0x122 */
20967 .long .L_ALT_OP_INVOKE_SUPER_JUMBO /* 0x123 */
20968 .long .L_ALT_OP_INVOKE_DIRECT_JUMBO /* 0x124 */
20969 .long .L_ALT_OP_INVOKE_STATIC_JUMBO /* 0x125 */
20970 .long .L_ALT_OP_INVOKE_INTERFACE_JUMBO /* 0x126 */
20971 .long .L_ALT_OP_UNUSED_27FF /* 0x127 */
20972 .long .L_ALT_OP_UNUSED_28FF /* 0x128 */
20973 .long .L_ALT_OP_UNUSED_29FF /* 0x129 */
20974 .long .L_ALT_OP_UNUSED_2AFF /* 0x12a */
20975 .long .L_ALT_OP_UNUSED_2BFF /* 0x12b */
20976 .long .L_ALT_OP_UNUSED_2CFF /* 0x12c */
20977 .long .L_ALT_OP_UNUSED_2DFF /* 0x12d */
20978 .long .L_ALT_OP_UNUSED_2EFF /* 0x12e */
20979 .long .L_ALT_OP_UNUSED_2FFF /* 0x12f */
20980 .long .L_ALT_OP_UNUSED_30FF /* 0x130 */
20981 .long .L_ALT_OP_UNUSED_31FF /* 0x131 */
20982 .long .L_ALT_OP_UNUSED_32FF /* 0x132 */
20983 .long .L_ALT_OP_UNUSED_33FF /* 0x133 */
20984 .long .L_ALT_OP_UNUSED_34FF /* 0x134 */
20985 .long .L_ALT_OP_UNUSED_35FF /* 0x135 */
20986 .long .L_ALT_OP_UNUSED_36FF /* 0x136 */
20987 .long .L_ALT_OP_UNUSED_37FF /* 0x137 */
20988 .long .L_ALT_OP_UNUSED_38FF /* 0x138 */
20989 .long .L_ALT_OP_UNUSED_39FF /* 0x139 */
20990 .long .L_ALT_OP_UNUSED_3AFF /* 0x13a */
20991 .long .L_ALT_OP_UNUSED_3BFF /* 0x13b */
20992 .long .L_ALT_OP_UNUSED_3CFF /* 0x13c */
20993 .long .L_ALT_OP_UNUSED_3DFF /* 0x13d */
20994 .long .L_ALT_OP_UNUSED_3EFF /* 0x13e */
20995 .long .L_ALT_OP_UNUSED_3FFF /* 0x13f */
20996 .long .L_ALT_OP_UNUSED_40FF /* 0x140 */
20997 .long .L_ALT_OP_UNUSED_41FF /* 0x141 */
20998 .long .L_ALT_OP_UNUSED_42FF /* 0x142 */
20999 .long .L_ALT_OP_UNUSED_43FF /* 0x143 */
21000 .long .L_ALT_OP_UNUSED_44FF /* 0x144 */
21001 .long .L_ALT_OP_UNUSED_45FF /* 0x145 */
21002 .long .L_ALT_OP_UNUSED_46FF /* 0x146 */
21003 .long .L_ALT_OP_UNUSED_47FF /* 0x147 */
21004 .long .L_ALT_OP_UNUSED_48FF /* 0x148 */
21005 .long .L_ALT_OP_UNUSED_49FF /* 0x149 */
21006 .long .L_ALT_OP_UNUSED_4AFF /* 0x14a */
21007 .long .L_ALT_OP_UNUSED_4BFF /* 0x14b */
21008 .long .L_ALT_OP_UNUSED_4CFF /* 0x14c */
21009 .long .L_ALT_OP_UNUSED_4DFF /* 0x14d */
21010 .long .L_ALT_OP_UNUSED_4EFF /* 0x14e */
21011 .long .L_ALT_OP_UNUSED_4FFF /* 0x14f */
21012 .long .L_ALT_OP_UNUSED_50FF /* 0x150 */
21013 .long .L_ALT_OP_UNUSED_51FF /* 0x151 */
21014 .long .L_ALT_OP_UNUSED_52FF /* 0x152 */
21015 .long .L_ALT_OP_UNUSED_53FF /* 0x153 */
21016 .long .L_ALT_OP_UNUSED_54FF /* 0x154 */
21017 .long .L_ALT_OP_UNUSED_55FF /* 0x155 */
21018 .long .L_ALT_OP_UNUSED_56FF /* 0x156 */
21019 .long .L_ALT_OP_UNUSED_57FF /* 0x157 */
21020 .long .L_ALT_OP_UNUSED_58FF /* 0x158 */
21021 .long .L_ALT_OP_UNUSED_59FF /* 0x159 */
21022 .long .L_ALT_OP_UNUSED_5AFF /* 0x15a */
21023 .long .L_ALT_OP_UNUSED_5BFF /* 0x15b */
21024 .long .L_ALT_OP_UNUSED_5CFF /* 0x15c */
21025 .long .L_ALT_OP_UNUSED_5DFF /* 0x15d */
21026 .long .L_ALT_OP_UNUSED_5EFF /* 0x15e */
21027 .long .L_ALT_OP_UNUSED_5FFF /* 0x15f */
21028 .long .L_ALT_OP_UNUSED_60FF /* 0x160 */
21029 .long .L_ALT_OP_UNUSED_61FF /* 0x161 */
21030 .long .L_ALT_OP_UNUSED_62FF /* 0x162 */
21031 .long .L_ALT_OP_UNUSED_63FF /* 0x163 */
21032 .long .L_ALT_OP_UNUSED_64FF /* 0x164 */
21033 .long .L_ALT_OP_UNUSED_65FF /* 0x165 */
21034 .long .L_ALT_OP_UNUSED_66FF /* 0x166 */
21035 .long .L_ALT_OP_UNUSED_67FF /* 0x167 */
21036 .long .L_ALT_OP_UNUSED_68FF /* 0x168 */
21037 .long .L_ALT_OP_UNUSED_69FF /* 0x169 */
21038 .long .L_ALT_OP_UNUSED_6AFF /* 0x16a */
21039 .long .L_ALT_OP_UNUSED_6BFF /* 0x16b */
21040 .long .L_ALT_OP_UNUSED_6CFF /* 0x16c */
21041 .long .L_ALT_OP_UNUSED_6DFF /* 0x16d */
21042 .long .L_ALT_OP_UNUSED_6EFF /* 0x16e */
21043 .long .L_ALT_OP_UNUSED_6FFF /* 0x16f */
21044 .long .L_ALT_OP_UNUSED_70FF /* 0x170 */
21045 .long .L_ALT_OP_UNUSED_71FF /* 0x171 */
21046 .long .L_ALT_OP_UNUSED_72FF /* 0x172 */
21047 .long .L_ALT_OP_UNUSED_73FF /* 0x173 */
21048 .long .L_ALT_OP_UNUSED_74FF /* 0x174 */
21049 .long .L_ALT_OP_UNUSED_75FF /* 0x175 */
21050 .long .L_ALT_OP_UNUSED_76FF /* 0x176 */
21051 .long .L_ALT_OP_UNUSED_77FF /* 0x177 */
21052 .long .L_ALT_OP_UNUSED_78FF /* 0x178 */
21053 .long .L_ALT_OP_UNUSED_79FF /* 0x179 */
21054 .long .L_ALT_OP_UNUSED_7AFF /* 0x17a */
21055 .long .L_ALT_OP_UNUSED_7BFF /* 0x17b */
21056 .long .L_ALT_OP_UNUSED_7CFF /* 0x17c */
21057 .long .L_ALT_OP_UNUSED_7DFF /* 0x17d */
21058 .long .L_ALT_OP_UNUSED_7EFF /* 0x17e */
21059 .long .L_ALT_OP_UNUSED_7FFF /* 0x17f */
21060 .long .L_ALT_OP_UNUSED_80FF /* 0x180 */
21061 .long .L_ALT_OP_UNUSED_81FF /* 0x181 */
21062 .long .L_ALT_OP_UNUSED_82FF /* 0x182 */
21063 .long .L_ALT_OP_UNUSED_83FF /* 0x183 */
21064 .long .L_ALT_OP_UNUSED_84FF /* 0x184 */
21065 .long .L_ALT_OP_UNUSED_85FF /* 0x185 */
21066 .long .L_ALT_OP_UNUSED_86FF /* 0x186 */
21067 .long .L_ALT_OP_UNUSED_87FF /* 0x187 */
21068 .long .L_ALT_OP_UNUSED_88FF /* 0x188 */
21069 .long .L_ALT_OP_UNUSED_89FF /* 0x189 */
21070 .long .L_ALT_OP_UNUSED_8AFF /* 0x18a */
21071 .long .L_ALT_OP_UNUSED_8BFF /* 0x18b */
21072 .long .L_ALT_OP_UNUSED_8CFF /* 0x18c */
21073 .long .L_ALT_OP_UNUSED_8DFF /* 0x18d */
21074 .long .L_ALT_OP_UNUSED_8EFF /* 0x18e */
21075 .long .L_ALT_OP_UNUSED_8FFF /* 0x18f */
21076 .long .L_ALT_OP_UNUSED_90FF /* 0x190 */
21077 .long .L_ALT_OP_UNUSED_91FF /* 0x191 */
21078 .long .L_ALT_OP_UNUSED_92FF /* 0x192 */
21079 .long .L_ALT_OP_UNUSED_93FF /* 0x193 */
21080 .long .L_ALT_OP_UNUSED_94FF /* 0x194 */
21081 .long .L_ALT_OP_UNUSED_95FF /* 0x195 */
21082 .long .L_ALT_OP_UNUSED_96FF /* 0x196 */
21083 .long .L_ALT_OP_UNUSED_97FF /* 0x197 */
21084 .long .L_ALT_OP_UNUSED_98FF /* 0x198 */
21085 .long .L_ALT_OP_UNUSED_99FF /* 0x199 */
21086 .long .L_ALT_OP_UNUSED_9AFF /* 0x19a */
21087 .long .L_ALT_OP_UNUSED_9BFF /* 0x19b */
21088 .long .L_ALT_OP_UNUSED_9CFF /* 0x19c */
21089 .long .L_ALT_OP_UNUSED_9DFF /* 0x19d */
21090 .long .L_ALT_OP_UNUSED_9EFF /* 0x19e */
21091 .long .L_ALT_OP_UNUSED_9FFF /* 0x19f */
21092 .long .L_ALT_OP_UNUSED_A0FF /* 0x1a0 */
21093 .long .L_ALT_OP_UNUSED_A1FF /* 0x1a1 */
21094 .long .L_ALT_OP_UNUSED_A2FF /* 0x1a2 */
21095 .long .L_ALT_OP_UNUSED_A3FF /* 0x1a3 */
21096 .long .L_ALT_OP_UNUSED_A4FF /* 0x1a4 */
21097 .long .L_ALT_OP_UNUSED_A5FF /* 0x1a5 */
21098 .long .L_ALT_OP_UNUSED_A6FF /* 0x1a6 */
21099 .long .L_ALT_OP_UNUSED_A7FF /* 0x1a7 */
21100 .long .L_ALT_OP_UNUSED_A8FF /* 0x1a8 */
21101 .long .L_ALT_OP_UNUSED_A9FF /* 0x1a9 */
21102 .long .L_ALT_OP_UNUSED_AAFF /* 0x1aa */
21103 .long .L_ALT_OP_UNUSED_ABFF /* 0x1ab */
21104 .long .L_ALT_OP_UNUSED_ACFF /* 0x1ac */
21105 .long .L_ALT_OP_UNUSED_ADFF /* 0x1ad */
21106 .long .L_ALT_OP_UNUSED_AEFF /* 0x1ae */
21107 .long .L_ALT_OP_UNUSED_AFFF /* 0x1af */
21108 .long .L_ALT_OP_UNUSED_B0FF /* 0x1b0 */
21109 .long .L_ALT_OP_UNUSED_B1FF /* 0x1b1 */
21110 .long .L_ALT_OP_UNUSED_B2FF /* 0x1b2 */
21111 .long .L_ALT_OP_UNUSED_B3FF /* 0x1b3 */
21112 .long .L_ALT_OP_UNUSED_B4FF /* 0x1b4 */
21113 .long .L_ALT_OP_UNUSED_B5FF /* 0x1b5 */
21114 .long .L_ALT_OP_UNUSED_B6FF /* 0x1b6 */
21115 .long .L_ALT_OP_UNUSED_B7FF /* 0x1b7 */
21116 .long .L_ALT_OP_UNUSED_B8FF /* 0x1b8 */
21117 .long .L_ALT_OP_UNUSED_B9FF /* 0x1b9 */
21118 .long .L_ALT_OP_UNUSED_BAFF /* 0x1ba */
21119 .long .L_ALT_OP_UNUSED_BBFF /* 0x1bb */
21120 .long .L_ALT_OP_UNUSED_BCFF /* 0x1bc */
21121 .long .L_ALT_OP_UNUSED_BDFF /* 0x1bd */
21122 .long .L_ALT_OP_UNUSED_BEFF /* 0x1be */
21123 .long .L_ALT_OP_UNUSED_BFFF /* 0x1bf */
21124 .long .L_ALT_OP_UNUSED_C0FF /* 0x1c0 */
21125 .long .L_ALT_OP_UNUSED_C1FF /* 0x1c1 */
21126 .long .L_ALT_OP_UNUSED_C2FF /* 0x1c2 */
21127 .long .L_ALT_OP_UNUSED_C3FF /* 0x1c3 */
21128 .long .L_ALT_OP_UNUSED_C4FF /* 0x1c4 */
21129 .long .L_ALT_OP_UNUSED_C5FF /* 0x1c5 */
21130 .long .L_ALT_OP_UNUSED_C6FF /* 0x1c6 */
21131 .long .L_ALT_OP_UNUSED_C7FF /* 0x1c7 */
21132 .long .L_ALT_OP_UNUSED_C8FF /* 0x1c8 */
21133 .long .L_ALT_OP_UNUSED_C9FF /* 0x1c9 */
21134 .long .L_ALT_OP_UNUSED_CAFF /* 0x1ca */
21135 .long .L_ALT_OP_UNUSED_CBFF /* 0x1cb */
21136 .long .L_ALT_OP_UNUSED_CCFF /* 0x1cc */
21137 .long .L_ALT_OP_UNUSED_CDFF /* 0x1cd */
21138 .long .L_ALT_OP_UNUSED_CEFF /* 0x1ce */
21139 .long .L_ALT_OP_UNUSED_CFFF /* 0x1cf */
21140 .long .L_ALT_OP_UNUSED_D0FF /* 0x1d0 */
21141 .long .L_ALT_OP_UNUSED_D1FF /* 0x1d1 */
21142 .long .L_ALT_OP_UNUSED_D2FF /* 0x1d2 */
21143 .long .L_ALT_OP_UNUSED_D3FF /* 0x1d3 */
21144 .long .L_ALT_OP_UNUSED_D4FF /* 0x1d4 */
21145 .long .L_ALT_OP_UNUSED_D5FF /* 0x1d5 */
21146 .long .L_ALT_OP_UNUSED_D6FF /* 0x1d6 */
21147 .long .L_ALT_OP_UNUSED_D7FF /* 0x1d7 */
21148 .long .L_ALT_OP_UNUSED_D8FF /* 0x1d8 */
21149 .long .L_ALT_OP_UNUSED_D9FF /* 0x1d9 */
21150 .long .L_ALT_OP_UNUSED_DAFF /* 0x1da */
21151 .long .L_ALT_OP_UNUSED_DBFF /* 0x1db */
21152 .long .L_ALT_OP_UNUSED_DCFF /* 0x1dc */
21153 .long .L_ALT_OP_UNUSED_DDFF /* 0x1dd */
21154 .long .L_ALT_OP_UNUSED_DEFF /* 0x1de */
21155 .long .L_ALT_OP_UNUSED_DFFF /* 0x1df */
21156 .long .L_ALT_OP_UNUSED_E0FF /* 0x1e0 */
21157 .long .L_ALT_OP_UNUSED_E1FF /* 0x1e1 */
21158 .long .L_ALT_OP_UNUSED_E2FF /* 0x1e2 */
21159 .long .L_ALT_OP_UNUSED_E3FF /* 0x1e3 */
21160 .long .L_ALT_OP_UNUSED_E4FF /* 0x1e4 */
21161 .long .L_ALT_OP_UNUSED_E5FF /* 0x1e5 */
21162 .long .L_ALT_OP_UNUSED_E6FF /* 0x1e6 */
21163 .long .L_ALT_OP_UNUSED_E7FF /* 0x1e7 */
21164 .long .L_ALT_OP_UNUSED_E8FF /* 0x1e8 */
21165 .long .L_ALT_OP_UNUSED_E9FF /* 0x1e9 */
21166 .long .L_ALT_OP_UNUSED_EAFF /* 0x1ea */
21167 .long .L_ALT_OP_UNUSED_EBFF /* 0x1eb */
21168 .long .L_ALT_OP_UNUSED_ECFF /* 0x1ec */
21169 .long .L_ALT_OP_UNUSED_EDFF /* 0x1ed */
21170 .long .L_ALT_OP_UNUSED_EEFF /* 0x1ee */
21171 .long .L_ALT_OP_UNUSED_EFFF /* 0x1ef */
21172 .long .L_ALT_OP_UNUSED_F0FF /* 0x1f0 */
21173 .long .L_ALT_OP_UNUSED_F1FF /* 0x1f1 */
21174 .long .L_ALT_OP_UNUSED_F2FF /* 0x1f2 */
21175 .long .L_ALT_OP_UNUSED_F3FF /* 0x1f3 */
21176 .long .L_ALT_OP_UNUSED_F4FF /* 0x1f4 */
21177 .long .L_ALT_OP_UNUSED_F5FF /* 0x1f5 */
21178 .long .L_ALT_OP_UNUSED_F6FF /* 0x1f6 */
21179 .long .L_ALT_OP_UNUSED_F7FF /* 0x1f7 */
21180 .long .L_ALT_OP_UNUSED_F8FF /* 0x1f8 */
21181 .long .L_ALT_OP_UNUSED_F9FF /* 0x1f9 */
21182 .long .L_ALT_OP_UNUSED_FAFF /* 0x1fa */
21183 .long .L_ALT_OP_UNUSED_FBFF /* 0x1fb */
21184 .long .L_ALT_OP_UNUSED_FCFF /* 0x1fc */
21185 .long .L_ALT_OP_UNUSED_FDFF /* 0x1fd */
21186 .long .L_ALT_OP_UNUSED_FEFF /* 0x1fe */
21187 .long .L_ALT_OP_THROW_VERIFICATION_ERROR_JUMBO /* 0x1ff */
21188 /* File: x86/entry.S */
21190 * Copyright (C) 2008 The Android Open Source Project
21192 * Licensed under the Apache License, Version 2.0 (the "License");
21193 * you may not use this file except in compliance with the License.
21194 * You may obtain a copy of the License at
21196 * http://www.apache.org/licenses/LICENSE-2.0
21198 * Unless required by applicable law or agreed to in writing, software
21199 * distributed under the License is distributed on an "AS IS" BASIS,
21200 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
21201 * See the License for the specific language governing permissions and
21202 * limitations under the License.
21207 .global dvmMterpStdRun
21208 .type dvmMterpStdRun, %function
21210 * bool dvmMterpStdRun(Thread* self)
21212 * Interpreter entry point. Returns changeInterp.
21216 movl 4(%esp), %ecx # get incoming rSELF
21217 push %ebp # save caller base pointer
21218 push %ecx # save rSELF at (%ebp)
21219 movl %esp, %ebp # set our %ebp
21221 * At this point we've allocated two slots on the stack
21222 * via push and stack is 8-byte aligned. Allocate space
21223 * for 8 spill slots, 3 local slots, 5 arg slots + 2 slots for
21224 * padding to bring us to 16-byte alignment
21226 subl $(FRAME_SIZE-8), %esp
21228 /* Spill callee save regs */
21229 movl %edi,EDI_SPILL(%ebp)
21230 movl %esi,ESI_SPILL(%ebp)
21231 movl %ebx,EBX_SPILL(%ebp)
21233 /* Set up "named" registers */
21234 movl offThread_pc(%ecx),rPC
21235 movl offThread_fp(%ecx),rFP
21236 movl offThread_curHandlerTable(%ecx),rIBASE
21238 /* Remember %esp for future "longjmp" */
21239 movl %esp,offThread_bailPtr(%ecx)
21241 /* How to start? */
21242 movb offThread_entryPoint(%ecx),%al
21244 /* Normal start? */
21245 cmpb $kInterpEntryInstr,%al
21248 /* Normal case: start executing the instruction at rPC */
21253 /* Reset to normal case */
21254 movb $kInterpEntryInstr,offThread_entryPoint(%ecx)
21255 cmpb $kInterpEntryReturn,%al
21256 je common_returnFromMethod
21257 cmpb $kInterpEntryThrow,%al
21258 je common_exceptionThrown
21260 movl %eax,OUT_ARG1(%esp)
21261 movl $.LstrBadEntryPoint,OUT_ARG0(%esp)
21267 .global dvmMterpStdBail
21268 .type dvmMterpStdBail, %function
21270 * void dvmMterpStdBail(Thread* self, bool changeInterp)
21272 * Restore the stack pointer and PC from the save point established on entry.
21273 * This is essentially the same as a longjmp, but should be cheaper. The
21274 * last instruction causes us to return to whoever called dvmMterpStdRun.
21276 * We're not going to build a standard frame here, so the arg accesses will
21277 * look a little strange.
21280 * esp+4 (arg0) Thread* self
21281 * esp+8 (arg1) bool changeInterp
21284 movl 4(%esp),%ecx # grab self
21285 movl 8(%esp),%eax # changeInterp to return reg
21286 movl offThread_bailPtr(%ecx),%esp # Restore "setjmp" esp
21288 addl $(FRAME_SIZE-8), %ebp # Restore %ebp at point of setjmp
21289 movl EDI_SPILL(%ebp),%edi
21290 movl ESI_SPILL(%ebp),%esi
21291 movl EBX_SPILL(%ebp),%ebx
21292 movl PREV_FP(%ebp),%ebp # restore caller's ebp
21293 addl $FRAME_SIZE,%esp # strip frame
21294 ret # return to dvmMterpStdRun's caller
21301 .LstrBadEntryPoint:
21302 .asciz "Bad entry point %d\n"
21305 /* File: x86/footer.S */
21307 * Copyright (C) 2008 The Android Open Source Project
21309 * Licensed under the Apache License, Version 2.0 (the "License");
21310 * you may not use this file except in compliance with the License.
21311 * You may obtain a copy of the License at
21313 * http://www.apache.org/licenses/LICENSE-2.0
21315 * Unless required by applicable law or agreed to in writing, software
21316 * distributed under the License is distributed on an "AS IS" BASIS,
21317 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
21318 * See the License for the specific language governing permissions and
21319 * limitations under the License.
21322 * Common subroutines and data.
21325 #if defined(WITH_JIT)
21327 * JIT-related re-entries into the interpreter. In general, if the
21328 * exit from a translation can at some point be chained, the entry
21329 * here requires that control arrived via a call, and that the "rp"
21330 * on TOS is actually a pointer to a 32-bit cell containing the Dalvik PC
21331 * of the next insn to handle. If no chaining will happen, the entry
21332 * should be reached via a direct jump and rPC set beforehand.
21335 .global dvmJitToInterpPunt
21337 * The compiler will generate a jump to this entry point when it is
21338 * having difficulty translating a Dalvik instruction. We must skip
21339 * the code cache lookup & prevent chaining to avoid bouncing between
21340 * the interpreter and code cache. rPC must be set on entry.
21342 dvmJitToInterpPunt:
21343 #if defined(WITH_JIT_TUNING)
21344 movl rPC, OUT_ARG0(%esp)
21348 movl offThread_curHandlerTable(%ecx),rIBASE
21352 .global dvmJitToInterpSingleStep
21354 * Return to the interpreter to handle a single instruction.
21355 * Should be reached via a call.
21357 * 0(%esp) <= native return address within trace
21358 * rPC <= Dalvik PC of this instruction
21359 * OUT_ARG0+4(%esp) <= Dalvik PC of next instruction
21361 dvmJitToInterpSingleStep:
21364 movl OUT_ARG0(%esp), %edx
21365 movl %eax,offThread_jitResumeNPC(%ecx)
21366 movl %edx,offThread_jitResumeDPC(%ecx)
21367 movl $kInterpEntryInstr,offThread_entryPoint(%ecx)
21368 movl $1,rINST # changeInterp <= true
21369 jmp common_gotoBail
21371 .global dvmJitToInterpNoChainNoProfile
21373 * Return from the translation cache to the interpreter to do method
21374 * invocation. Check if the translation exists for the callee, but don't
21375 * chain to it. rPC must be set on entry.
21377 dvmJitToInterpNoChainNoProfile:
21378 #if defined(WITH_JIT_TUNING)
21379 call dvmBumpNoChain
21381 movl rPC,OUT_ARG0(%esp)
21382 call dvmJitGetTraceAddr # is there a translation?
21383 movl rSELF,%ecx # ecx <- self
21384 movl %eax,offThread_inJitCodeCache(%ecx) # set inJitCodeCache flag
21387 call *%eax # exec translation if we've got one
21391 movl offThread_curHandlerTable(%ecx),rIBASE
21396 * Return from the translation cache and immediately request a
21397 * translation fro the exit target, but don't attempt to chain.
21398 * rPC set on entry.
21400 .global dvmJitToInterpTraceSelectNoChain
21401 dvmJitToInterpTraceSelectNoChain:
21402 #if defined(WITH_JIT_TUNING)
21403 call dvmBumpNoChain
21405 movl rPC,OUT_ARG0(%esp)
21406 call dvmJitGetTraceAddr # is there a translation?
21409 movl %eax,offThread_inJitCodeCache(%ecx) # set inJitCodeCache flag
21411 call *%eax # jump to tranlation
21414 /* No Translation - request one */
21416 GET_JIT_PROF_TABLE %ecx %eax
21417 cmpl $0, %eax # JIT enabled?
21418 jnz 2f # Request one if so
21420 movl offThread_curHandlerTable(%ecx),rIBASE
21421 FETCH_INST_R %ecx # Continue interpreting if not
21424 movl $kJitTSelectRequestHot,rINST # ask for trace select
21425 jmp common_selectTrace
21428 * Return from the translation cache and immediately request a
21429 * translation for the exit target. Reached via a call, and
21432 .global dvmJitToInterpTraceSelect
21433 dvmJitToInterpTraceSelect:
21434 pop rINST # save chain cell address in callee save reg
21436 movl rPC,OUT_ARG0(%esp)
21437 call dvmJitGetTraceAddr # is there a translation?
21439 jz 1b # no - ask for one
21440 movl %eax,OUT_ARG0(%esp)
21441 # FIXME - need to adjust rINST to beginning of sequence
21442 movl rINST,OUT_ARG1(%esp)
21443 call dvmJitChain # Attempt dvmJitChain(codeAddr,chainAddr)
21444 cmpl $0,%eax # Success?
21445 jz toInterpreter # didn't chain - interpret
21450 * Placeholder entries for x86 JIT
21452 .global dvmJitToInterpBackwardBranch
21453 dvmJitToInterpBackwardBranch:
21454 .global dvmJitToInterpNormal
21455 dvmJitToInterpNormal:
21456 .global dvmJitToInterpNoChain
21457 dvmJitToInterpNoChain:
21463 * Common code when a backwards branch is taken
21466 * ebx (a.k.a. rINST) -> PC adjustment in 16-bit words
21468 common_backwardBranch:
21470 call common_periodicChecks # rPC and ecx/rSELF preserved
21471 #if defined(WITH_JIT)
21472 GET_JIT_PROF_TABLE %ecx rIBASE
21473 ADVANCE_PC_INDEXED rINST
21475 movl offThread_curHandlerTable(%ecx),rIBASE
21477 jz 1f # Profiling off - continue
21478 .global updateProfile
21480 common_updateProfile:
21481 # quick & dirty hash
21485 andl $((1<<JIT_PROF_SIZE_LOG_2)-1),%eax
21492 * Here, we switch to the debug interpreter to request
21493 * trace selection. First, though, check to see if there
21494 * is already a native translation in place (and, if so,
21497 GET_JIT_THRESHOLD %ecx rINST # leaves rSELF in %ecx
21499 movb rINSTbl,(%edx,%eax) # reset counter
21500 movl %ecx,rINST # preserve rSELF
21501 movl rPC,OUT_ARG0(%esp)
21502 call dvmJitGetTraceAddr # already have one?
21503 movl %eax,offThread_inJitCodeCache(rINST) # set the inJitCodeCache flag
21506 call *%eax # FIXME: decide call vs/ jmp!. No return either way
21508 movl $kJitTSelectRequest,%eax
21509 # On entry, eax<- jitState, rPC valid
21510 common_selectTrace:
21513 movl %eax,offThread_jitState(%ecx)
21514 movl $kInterpEntryInstr,offThread_entryPoint(%ecx)
21516 jmp common_gotoBail
21518 movl offThread_curHandlerTable(%ecx),rIBASE
21519 ADVANCE_PC_INDEXED rINST
21527 * Common code for jumbo method invocation.
21530 * eax = Method* methodToCall
21531 * rINSTw trashed, must reload
21532 * rIBASE trashed, must reload before resuming interpreter
21535 common_invokeMethodJumbo:
21539 * prepare to copy args to "outs" area of current frame
21541 movzwl 6(rPC),rINST # rINST<- BBBB
21542 movzwl 8(rPC), %ecx # %ecx<- CCCC
21543 ADVANCE_PC 2 # adjust pc to make return similar
21544 SAVEAREA_FROM_FP %edx # %edx<- &StackSaveArea
21546 movl rINST, LOCAL0_OFFSET(%ebp) # LOCAL0_OFFSET(%ebp)<- BBBB
21547 jz .LinvokeArgsDone # no args; jump to args done
21548 jmp .LinvokeRangeArgs # handle args like invoke range
21551 * Common code for method invocation with range.
21554 * eax = Method* methodToCall
21555 * rINSTw trashed, must reload
21556 * rIBASE trashed, must reload before resuming interpreter
21559 common_invokeMethodRange:
21563 * prepare to copy args to "outs" area of current frame
21566 movzbl 1(rPC),rINST # rINST<- AA
21567 movzwl 4(rPC), %ecx # %ecx<- CCCC
21568 SAVEAREA_FROM_FP %edx # %edx<- &StackSaveArea
21570 movl rINST, LOCAL0_OFFSET(%ebp) # LOCAL0_OFFSET(%ebp)<- AA
21571 jz .LinvokeArgsDone # no args; jump to args done
21575 * %eax=methodToCall, %ecx=CCCC, LOCAL0_OFFSET(%ebp)=count, %edx=&outs (&stackSaveArea)
21576 * (very few methods have > 10 args; could unroll for common cases)
21580 movl %ebx, LOCAL1_OFFSET(%ebp) # LOCAL1_OFFSET(%ebp)<- save %ebx
21581 lea (rFP, %ecx, 4), %ecx # %ecx<- &vCCCC
21582 shll $2, LOCAL0_OFFSET(%ebp) # LOCAL0_OFFSET(%ebp)<- offset
21583 subl LOCAL0_OFFSET(%ebp), %edx # %edx<- update &outs
21584 shrl $2, LOCAL0_OFFSET(%ebp) # LOCAL0_OFFSET(%ebp)<- offset
21586 movl (%ecx), %ebx # %ebx<- vCCCC
21587 lea 4(%ecx), %ecx # %ecx<- &vCCCC++
21588 subl $1, LOCAL0_OFFSET(%ebp) # LOCAL0_OFFSET<- LOCAL0_OFFSET--
21589 movl %ebx, (%edx) # *outs<- vCCCC
21590 lea 4(%edx), %edx # outs++
21591 jne 1b # loop if count (LOCAL0_OFFSET(%ebp)) not zero
21592 movl LOCAL1_OFFSET(%ebp), %ebx # %ebx<- restore %ebx
21593 jmp .LinvokeArgsDone # continue
21596 * %eax is "Method* methodToCall", the method we're trying to call
21597 * prepare to copy args to "outs" area of current frame
21598 * rIBASE trashed, must reload before resuming interpreter
21601 common_invokeMethodNoRange:
21602 .LinvokeNewNoRange:
21603 movzbl 1(rPC),rINST # rINST<- BA
21604 movl rINST, LOCAL0_OFFSET(%ebp) # LOCAL0_OFFSET(%ebp)<- BA
21605 shrl $4, LOCAL0_OFFSET(%ebp) # LOCAL0_OFFSET(%ebp)<- B
21606 je .LinvokeArgsDone # no args; jump to args done
21607 movzwl 4(rPC), %ecx # %ecx<- GFED
21608 SAVEAREA_FROM_FP %edx # %edx<- &StackSaveArea
21611 * %eax=methodToCall, %ecx=GFED, LOCAL0_OFFSET(%ebp)=count, %edx=outs
21615 cmp $2, LOCAL0_OFFSET(%ebp) # compare LOCAL0_OFFSET(%ebp) to 2
21616 movl %ecx, LOCAL1_OFFSET(%ebp) # LOCAL1_OFFSET(%ebp)<- GFED
21617 jl 1f # handle 1 arg
21618 je 2f # handle 2 args
21619 cmp $4, LOCAL0_OFFSET(%ebp) # compare LOCAL0_OFFSET(%ebp) to 4
21620 jl 3f # handle 3 args
21621 je 4f # handle 4 args
21623 andl $15, rINST # rINSTw<- A
21624 lea -4(%edx), %edx # %edx<- update &outs; &outs--
21625 movl (rFP, rINST, 4), %ecx # %ecx<- vA
21626 movl %ecx, (%edx) # *outs<- vA
21627 movl LOCAL1_OFFSET(%ebp), %ecx # %ecx<- GFED
21629 shr $12, %ecx # %ecx<- G
21630 lea -4(%edx), %edx # %edx<- update &outs; &outs--
21631 movl (rFP, %ecx, 4), %ecx # %ecx<- vG
21632 movl %ecx, (%edx) # *outs<- vG
21633 movl LOCAL1_OFFSET(%ebp), %ecx # %ecx<- GFED
21635 and $0x0f00, %ecx # %ecx<- 0F00
21636 shr $8, %ecx # %ecx<- F
21637 lea -4(%edx), %edx # %edx<- update &outs; &outs--
21638 movl (rFP, %ecx, 4), %ecx # %ecx<- vF
21639 movl %ecx, (%edx) # *outs<- vF
21640 movl LOCAL1_OFFSET(%ebp), %ecx # %ecx<- GFED
21642 and $0x00f0, %ecx # %ecx<- 00E0
21643 shr $4, %ecx # %ecx<- E
21644 lea -4(%edx), %edx # %edx<- update &outs; &outs--
21645 movl (rFP, %ecx, 4), %ecx # %ecx<- vE
21646 movl %ecx, (%edx) # *outs<- vE
21647 movl LOCAL1_OFFSET(%ebp), %ecx # %ecx<- GFED
21649 and $0x000f, %ecx # %ecx<- 000D
21650 movl (rFP, %ecx, 4), %ecx # %ecx<- vD
21651 movl %ecx, -4(%edx) # *--outs<- vD
21655 * %eax is "Method* methodToCall", the method we're trying to call
21656 * find space for the new stack frame, check for overflow
21660 movzwl offMethod_registersSize(%eax), %edx # %edx<- methodToCall->regsSize
21661 movzwl offMethod_outsSize(%eax), %ecx # %ecx<- methodToCall->outsSize
21662 movl %eax, LOCAL0_OFFSET(%ebp) # LOCAL0_OFFSET<- methodToCall
21663 shl $2, %edx # %edx<- update offset
21664 SAVEAREA_FROM_FP %eax # %eax<- &StackSaveArea
21665 subl %edx, %eax # %eax<- newFP; (old savearea - regsSize)
21666 movl rSELF,%edx # %edx<- pthread
21667 movl %eax, LOCAL1_OFFSET(%ebp) # LOCAL1_OFFSET(%ebp)<- &outs
21668 subl $sizeofStackSaveArea, %eax # %eax<- newSaveArea (stack save area using newFP)
21669 movl offThread_interpStackEnd(%edx), %edx # %edx<- self->interpStackEnd
21670 movl %edx, LOCAL2_OFFSET(%ebp) # LOCAL2_OFFSET<- self->interpStackEnd
21671 shl $2, %ecx # %ecx<- update offset for outsSize
21672 movl %eax, %edx # %edx<- newSaveArea
21673 sub %ecx, %eax # %eax<- bottom; (newSaveArea - outsSize)
21674 cmp LOCAL2_OFFSET(%ebp), %eax # compare interpStackEnd and bottom
21675 movl LOCAL0_OFFSET(%ebp), %eax # %eax<- restore methodToCall
21676 jl .LstackOverflow # handle frame overflow
21679 * set up newSaveArea
21683 SAVEAREA_FROM_FP %ecx # %ecx<- &StackSaveArea
21684 movl %ecx, offStackSaveArea_prevSave(%edx) # newSaveArea->prevSave<- &outs
21686 movl rFP, offStackSaveArea_prevFrame(%edx) # newSaveArea->prevFrame<- rFP
21687 movl rPC, offStackSaveArea_savedPc(%edx) # newSaveArea->savedPc<- rPC
21688 testl $ACC_NATIVE, offMethod_accessFlags(%eax) # check for native call
21689 movl %eax, offStackSaveArea_method(%edx) # newSaveArea->method<- method to call
21690 jne .LinvokeNative # handle native call
21693 * Update "self" values for the new method
21694 * %eax=methodToCall, LOCAL1_OFFSET(%ebp)=newFp
21697 movl offMethod_clazz(%eax), %edx # %edx<- method->clazz
21698 movl rSELF,%ecx # %ecx<- pthread
21699 movl offClassObject_pDvmDex(%edx), %edx # %edx<- method->clazz->pDvmDex
21700 movl %eax, offThread_method(%ecx) # self->method<- methodToCall
21701 movl %edx, offThread_methodClassDex(%ecx) # self->methodClassDex<- method->clazz->pDvmDex
21702 movl offMethod_insns(%eax), rPC # rPC<- methodToCall->insns
21703 movl LOCAL1_OFFSET(%ebp), rFP # rFP<- newFP
21704 movl rFP, offThread_curFrame(%ecx) # self->curFrame<- newFP
21705 movl offThread_curHandlerTable(%ecx),rIBASE
21707 GOTO_NEXT # jump to methodToCall->insns
21710 * Prep for the native call
21711 * %eax=methodToCall, LOCAL1_OFFSET(%ebp)=newFP, %edx=newSaveArea
21715 movl rSELF,%ecx # %ecx<- pthread
21716 movl %eax, OUT_ARG1(%esp) # push parameter methodToCall
21717 movl offThread_jniLocal_topCookie(%ecx), %eax # %eax<- self->localRef->...
21718 movl %eax, offStackSaveArea_localRefCookie(%edx) # newSaveArea->localRefCookie<- top
21719 movl %edx, OUT_ARG4(%esp) # save newSaveArea
21720 movl LOCAL1_OFFSET(%ebp), %edx # %edx<- newFP
21721 movl %edx, offThread_curFrame(%ecx) # self->curFrame<- newFP
21722 movl %ecx, OUT_ARG3(%esp) # save self
21723 movl %ecx, OUT_ARG2(%esp) # push parameter self
21724 movl rSELF,%ecx # %ecx<- pthread
21725 movl OUT_ARG1(%esp), %eax # %eax<- methodToCall
21726 lea offThread_retval(%ecx), %ecx # %ecx<- &retval
21727 movl %ecx, OUT_ARG0(%esp) # push parameter pthread
21728 push %edx # push parameter newFP
21730 call *offMethod_nativeFunc(%eax) # call methodToCall->nativeFunc
21732 movl OUT_ARG4(%esp), %ecx # %ecx<- newSaveArea
21733 movl OUT_ARG3(%esp), %eax # %eax<- self
21734 movl offStackSaveArea_localRefCookie(%ecx), %edx # %edx<- old top
21735 cmp $0, offThread_exception(%eax) # check for exception
21736 movl rFP, offThread_curFrame(%eax) # self->curFrame<- rFP
21737 movl %edx, offThread_jniLocal_topCookie(%eax) # new top <- old top
21738 jne common_exceptionThrown # handle exception
21739 movl offThread_curHandlerTable(%eax),rIBASE
21740 FETCH_INST_OPCODE 3 %ecx
21742 GOTO_NEXT_R %ecx # jump to next instruction
21744 .LstackOverflow: # eax=methodToCall
21745 movl %eax, OUT_ARG1(%esp) # push parameter methodToCall
21746 movl rSELF,%eax # %eax<- self
21747 movl %eax, OUT_ARG0(%esp) # push parameter self
21748 call dvmHandleStackOverflow # call: (Thread* self, Method* meth)
21749 jmp common_exceptionThrown # handle exception
21753 * Do we need the thread to be suspended or have debugger/profiling activity?
21756 * ebx -> PC adjustment in 16-bit words (must be preserved)
21757 * ecx -> SELF pointer
21758 * reentry type, e.g. kInterpEntryInstr stored in rSELF->entryPoint
21760 * Note: A call will normally kill %eax and %ecx. To
21761 * streamline the normal case, this routine will preserve
21762 * %ecx in addition to the normal caller save regs. The save/restore
21763 * is a bit ugly, but will happen in the relatively uncommon path.
21764 * TODO: Basic-block style Jit will need a hook here as well. Fold it into
21765 * the suspendCount check so we can get both in 1 shot.
21766 * TUNING: Improve scheduling here & do initial single test for all.
21768 common_periodicChecks:
21769 cmpl $0,offThread_suspendCount(%ecx) # non-zero suspendCount?
21773 movl offThread_pInterpBreak(%ecx),%eax # eax <- &interpBreak
21774 cmpl $0,(%eax) # something interesting happening?
21775 jne 3f # yes - switch interpreters
21778 /* Check for suspend */
21780 /* At this point, the return pointer to the caller of
21781 * common_periodicChecks is on the top of stack. We need to preserve
21783 * The outgoing profile is:
21784 * bool dvmCheckSuspendPending(Thread* self)
21785 * Because we reached here via a call, go ahead and build a new frame.
21787 EXPORT_PC # need for precise GC
21788 movl %ecx,%eax # eax<- self
21792 movl %eax,OUT_ARG0(%esp)
21793 call dvmCheckSuspendPending
21799 * Need to check to see if debugger or profiler flags got set
21800 * while we were suspended.
21804 /* Switch interpreters */
21805 /* Note: %ebx contains the 16-bit word offset to be applied to rPC to
21806 * "complete" the interpretation of backwards branches. In effect, we
21807 * are completing the interpretation of the branch instruction here,
21808 * and the new interpreter will resume interpretation at the branch
21809 * target. However, a switch request recognized during the handling
21810 * of a return from method instruction results in an immediate abort,
21811 * and the new interpreter will resume by re-interpreting the return
21815 leal (rPC,%ebx,2),rPC # adjust pc to show target
21816 movl rSELF,%ecx # bail expect SELF already loaded
21817 movl $1,rINST # set changeInterp to true
21818 jmp common_gotoBail
21822 * Common code for handling a return instruction
21824 common_returnFromMethod:
21826 /* Set entry mode in case we bail */
21827 movb $kInterpEntryReturn,offThread_entryPoint(%ecx)
21828 xorl rINST,rINST # zero offset in case we switch interps
21829 call common_periodicChecks # Note: expects %ecx to be preserved
21831 SAVEAREA_FROM_FP %eax # eax<- saveArea (old)
21832 movl offStackSaveArea_prevFrame(%eax),rFP # rFP<- prevFrame
21833 movl (offStackSaveArea_method-sizeofStackSaveArea)(rFP),rINST
21834 cmpl $0,rINST # break?
21835 je common_gotoBail # break frame, bail out completely
21837 movl offStackSaveArea_savedPc(%eax),rPC # pc<- saveArea->savedPC
21838 movl rINST,offThread_method(%ecx) # self->method = newSave->meethod
21839 movl rFP,offThread_curFrame(%ecx) # self->curFrame = fp
21840 movl offMethod_clazz(rINST),%eax # eax<- method->clazz
21841 movl offThread_curHandlerTable(%ecx),rIBASE
21842 movl offClassObject_pDvmDex(%eax),rINST # rINST<- method->clazz->pDvmDex
21843 FETCH_INST_OPCODE 3 %eax
21844 movl rINST,offThread_methodClassDex(%ecx)
21846 /* not bailing - restore entry mode to default */
21847 movb $kInterpEntryInstr,offThread_entryPoint(%ecx)
21851 * Prepare to strip the current frame and "longjump" back to caller of
21855 * rINST holds changeInterp
21856 * ecx holds self pointer
21858 * expected profile: dvmMterpStdBail(Thread *self, bool changeInterp)
21861 movl rPC,offThread_pc(%ecx) # export state to self
21862 movl rFP,offThread_fp(%ecx)
21863 movl %ecx,OUT_ARG0(%esp) # self in arg0
21864 movl rINST,OUT_ARG1(%esp) # changeInterp in arg1
21865 call dvmMterpStdBail # bail out....
21869 * After returning from a "selfd" function, pull out the updated values
21870 * and start executing at the next instruction.
21872 common_resumeAfterGlueCall:
21874 movl offThread_pc(%eax),rPC
21875 movl offThread_fp(%eax),rFP
21876 movl offThread_curHandlerTable(%eax),rIBASE
21881 * Integer divide or mod by zero
21883 common_errDivideByZero:
21885 movl $.LstrDivideByZero,%eax
21886 movl %eax,OUT_ARG0(%esp)
21887 call dvmThrowArithmeticException
21888 jmp common_exceptionThrown
21891 * Attempt to allocate an array with a negative size.
21892 * On entry, len in eax
21894 common_errNegativeArraySize:
21896 movl %eax,OUT_ARG0(%esp) # arg0<- len
21897 call dvmThrowNegativeArraySizeException # (len)
21898 jmp common_exceptionThrown
21901 * Attempt to allocate an array with a negative size.
21902 * On entry, method name in eax
21904 common_errNoSuchMethod:
21907 movl %eax,OUT_ARG0(%esp)
21908 call dvmThrowNoSuchMethodError
21909 jmp common_exceptionThrown
21912 * Hit a null object when we weren't expecting one. Export the PC, throw a
21913 * NullPointerException and goto the exception processing code.
21915 common_errNullObject:
21918 movl %eax,OUT_ARG0(%esp)
21919 call dvmThrowNullPointerException
21920 jmp common_exceptionThrown
21923 * Array index exceeds max.
21925 * eax <- array object
21928 common_errArrayIndex:
21930 movl offArrayObject_length(%eax), %eax
21931 movl %ecx,OUT_ARG0(%esp)
21932 movl %eax,OUT_ARG1(%esp)
21933 call dvmThrowArrayIndexOutOfBoundsException # args (index, length)
21934 jmp common_exceptionThrown
21937 * Somebody has thrown an exception. Handle it.
21939 * If the exception processing code returns to us (instead of falling
21940 * out of the interpreter), continue with whatever the next instruction
21941 * now happens to be.
21943 * This does not return.
21945 common_exceptionThrown:
21947 movl rPC,offThread_pc(%ecx)
21948 movl rFP,offThread_fp(%ecx)
21949 movl %ecx,OUT_ARG0(%esp)
21950 call dvmMterp_exceptionThrown
21951 jmp common_resumeAfterGlueCall
21954 movl $0xdeadf00d,%eax
21964 .asciz "divide by zero"
21965 .LstrFilledNewArrayNotImplA:
21966 .asciz "filled-new-array only implemented for 'int'"