InterpAsm-x86.S revision 61f4c7e40b885ccb0a55d9553f07a888469621dc
1/* 2 * This file was generated automatically by gen-mterp.py for 'x86'. 3 * 4 * --> DO NOT EDIT <-- 5 */ 6 7/* File: x86/header.S */ 8/* 9 * Copyright (C) 2008 The Android Open Source Project 10 * 11 * Licensed under the Apache License, Version 2.0 (the "License"); 12 * you may not use this file except in compliance with the License. 13 * You may obtain a copy of the License at 14 * 15 * http://www.apache.org/licenses/LICENSE-2.0 16 * 17 * Unless required by applicable law or agreed to in writing, software 18 * distributed under the License is distributed on an "AS IS" BASIS, 19 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 20 * See the License for the specific language governing permissions and 21 * limitations under the License. 22 */ 23/* 24 * 32-bit x86 definitions and declarations. 25 */ 26 27/* 28386 ABI general notes: 29 30Caller save set: 31 eax, edx, ecx, st(0)-st(7) 32Callee save set: 33 ebx, esi, edi, ebp 34Return regs: 35 32-bit in eax 36 64-bit in edx:eax (low-order 32 in eax) 37 fp on top of fp stack st(0) 38 39Parameters passed on stack, pushed right-to-left. On entry to target, first 40parm is at 4(%esp). Traditional entry code is: 41 42functEntry: 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 46 47Once past the prologue, arguments are referenced at ((argno + 2)*4)(%ebp) 48 49Alignment of stack not strictly required, but should be for performance. We'll 50align frame sizes to 16-byte multiples. 51 52If we're not doing variable stack allocation (alloca), the frame pointer can be 53eliminated and all arg references adjusted to be esp relative. 54 55Mterp notes: 56 57Some key interpreter variables will be assigned to registers. Note that each 58will also have an associated spill location (mostly useful for those assigned 59to callee save registers). 60 61 nick reg purpose 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 68 69Notes: 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 73 74*/ 75 76#define rSELF (%ebp) 77#define rPC %esi 78#define rFP %edi 79#define rINST %ebx 80#define rINSTw %bx 81#define rINSTbh %bh 82#define rINSTbl %bl 83#define rIBASE %edx 84 85 86/* Frame diagram while executing dvmMterpStdRun, high to low addresses */ 87#define IN_ARG0 ( 12) 88#define CALLER_RP ( 8) 89#define PREV_FP ( 4) 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 112 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 121 122#if defined(WITH_JIT) 123.macro GET_JIT_PROF_TABLE _self _reg 124 movl offThread_pJitProfTable(\_self),\_reg 125.endm 126.macro GET_JIT_THRESHOLD _self _reg 127 movl offThread_jitThreshold(\_self),\_reg 128.endm 129#endif 130 131/* save/restore the PC and/or FP from the self struct */ 132.macro SAVE_PC_FP_TO_SELF _reg 133 movl rSELF,\_reg 134 movl rPC,offThread_pc(\_reg) 135 movl rFP,offThread_fp(\_reg) 136.endm 137 138.macro LOAD_PC_FP_FROM_SELF 139 movl rSELF,rFP 140 movl offThread_pc(rFP),rPC 141 movl offThread_fp(rFP),rFP 142.endm 143 144/* The interpreter assumes a properly aligned stack on entry, and 145 * will preserve 16-byte alignment. 146 */ 147 148/* 149 * "export" the PC to the interpreted stack frame, f/b/o future exception 150 * objects. Must be done *before* something throws. 151 * 152 * In C this is "SAVEAREA_FROM_FP(fp)->xtra.currentPc = pc", i.e. 153 * fp - sizeof(StackSaveArea) + offsetof(SaveArea, xtra.currentPc) 154 * 155 * It's okay to do this more than once. 156 */ 157.macro EXPORT_PC 158 movl rPC, (-sizeofStackSaveArea + offStackSaveArea_currentPc)(rFP) 159.endm 160 161/* 162 * Given a frame pointer, find the stack save area. 163 * 164 * In C this is "((StackSaveArea*)(_fp) -1)". 165 */ 166.macro SAVEAREA_FROM_FP _reg 167 leal -sizeofStackSaveArea(rFP), \_reg 168.endm 169 170/* 171 * Fetch the next instruction from rPC into rINSTw. Does not advance rPC. 172 */ 173.macro FETCH_INST 174 movzwl (rPC),rINST 175.endm 176 177/* 178 * Fetch the opcode byte and zero-extend it into _reg. Must be used 179 * in conjunction with GOTO_NEXT_R 180 */ 181.macro FETCH_INST_R _reg 182 movzbl (rPC),\_reg 183.endm 184 185/* 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 188 */ 189.macro FETCH_INST_OPCODE _count _reg 190 movzbl \_count*2(rPC),\_reg 191.endm 192 193/* 194 * Fetch the nth instruction word from rPC into rINSTw. Does not advance 195 * rPC, and _count is in words 196 */ 197.macro FETCH_INST_WORD _count 198 movzwl \_count*2(rPC),rINST 199.endm 200 201/* 202 * Fetch instruction word indexed (used for branching). 203 * Index is in instruction word units. 204 */ 205.macro FETCH_INST_INDEXED _reg 206 movzwl (rPC,\_reg,2),rINST 207.endm 208 209/* 210 * Advance rPC by instruction count 211 */ 212.macro ADVANCE_PC _count 213 leal 2*\_count(rPC),rPC 214.endm 215 216/* 217 * Advance rPC by branch offset in register 218 */ 219.macro ADVANCE_PC_INDEXED _reg 220 leal (rPC,\_reg,2),rPC 221.endm 222 223.macro GOTO_NEXT 224 movzx rINSTbl,%eax 225 movzbl rINSTbh,rINST 226 jmp *(rIBASE,%eax,4) 227.endm 228 229 /* 230 * Version of GOTO_NEXT that assumes _reg preloaded with opcode. 231 * Should be paired with FETCH_INST_R 232 */ 233.macro GOTO_NEXT_R _reg 234 movzbl 1(rPC),rINST 235 jmp *(rIBASE,\_reg,4) 236.endm 237 238 /* 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 242 */ 243.macro GOTO_NEXT_JUMBO_R _reg 244 movzwl 6(rPC),rINST 245 jmp *(rIBASE,\_reg,4) 246.endm 247 248/* 249 * Get/set the 32-bit value from a Dalvik register. 250 */ 251.macro GET_VREG_R _reg _vreg 252 movl (rFP,\_vreg,4),\_reg 253.endm 254 255.macro SET_VREG _reg _vreg 256 movl \_reg,(rFP,\_vreg,4) 257.endm 258 259.macro GET_VREG_WORD _reg _vreg _offset 260 movl 4*(\_offset)(rFP,\_vreg,4),\_reg 261.endm 262 263.macro SET_VREG_WORD _reg _vreg _offset 264 movl \_reg,4*(\_offset)(rFP,\_vreg,4) 265.endm 266 267#define sReg0 LOCAL0_OFFSET(%ebp) 268#define sReg1 LOCAL1_OFFSET(%ebp) 269#define sReg2 LOCAL2_OFFSET(%ebp) 270 271 /* 272 * Hard coded helper values. 273 */ 274 275.balign 16 276 277.LdoubNeg: 278 .quad 0x8000000000000000 279 280.L64bits: 281 .quad 0xFFFFFFFFFFFFFFFF 282 283.LshiftMask2: 284 .quad 0x0000000000000000 285.LshiftMask: 286 .quad 0x000000000000003F 287 288.Lvalue64: 289 .quad 0x0000000000000040 290 291.LvaluePosInfLong: 292 .quad 0x7FFFFFFFFFFFFFFF 293 294.LvalueNegInfLong: 295 .quad 0x8000000000000000 296 297.LvalueNanLong: 298 .quad 0x0000000000000000 299 300.LintMin: 301.long 0x80000000 302 303.LintMax: 304.long 0x7FFFFFFF 305 306 307/* 308 * This is a #include, not a %include, because we want the C pre-processor 309 * to expand the macros into assembler assignment statements. 310 */ 311#include "../common/asm-constants.h" 312 313#if defined(WITH_JIT) 314#include "../common/jit-config.h" 315#endif 316 317 318 .global dvmAsmInstructionStartCode 319 .type dvmAsmInstructionStartCode, %function 320dvmAsmInstructionStartCode = .L_OP_NOP 321 .text 322 323/* ------------------------------ */ 324.L_OP_NOP: /* 0x00 */ 325/* File: x86/OP_NOP.S */ 326 FETCH_INST_OPCODE 1 %ecx 327 ADVANCE_PC 1 328 GOTO_NEXT_R %ecx 329 330/* ------------------------------ */ 331.L_OP_MOVE: /* 0x01 */ 332/* File: x86/OP_MOVE.S */ 333 /* for move, move-object, long-to-int */ 334 /* op vA, vB */ 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 340 ADVANCE_PC 1 341 SET_VREG rINST %eax # fp[A]<-fp[B] 342 GOTO_NEXT_R %ecx 343 344/* ------------------------------ */ 345.L_OP_MOVE_FROM16: /* 0x02 */ 346/* File: x86/OP_MOVE_FROM16.S */ 347 /* for: move/from16, move-object/from16 */ 348 /* op vAA, vBBBB */ 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 353 ADVANCE_PC 2 354 SET_VREG rINST %eax # fp[AA]<- ecx] 355 GOTO_NEXT_R %ecx 356 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 366 ADVANCE_PC 3 367 SET_VREG rINST %eax 368 GOTO_NEXT_R %ecx 369 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 383 ADVANCE_PC 1 384 GOTO_NEXT_R %ecx 385 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 398 ADVANCE_PC 2 399 GOTO_NEXT_R %ecx 400 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 413 ADVANCE_PC 3 414 GOTO_NEXT_R %ecx 415 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 */ 421 /* op vA, vB */ 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 427 ADVANCE_PC 1 428 SET_VREG rINST %eax # fp[A]<-fp[B] 429 GOTO_NEXT_R %ecx 430 431 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 */ 437 /* op vAA, vBBBB */ 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 442 ADVANCE_PC 2 443 SET_VREG rINST %eax # fp[AA]<- ecx] 444 GOTO_NEXT_R %ecx 445 446 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 457 ADVANCE_PC 3 458 SET_VREG rINST %eax 459 GOTO_NEXT_R %ecx 460 461 462/* ------------------------------ */ 463.L_OP_MOVE_RESULT: /* 0x0a */ 464/* File: x86/OP_MOVE_RESULT.S */ 465 /* for: move-result, move-result-object */ 466 /* op vAA */ 467 movl rSELF,%eax # eax<- rSELF 468 movl offThread_retval(%eax),%eax # eax<- self->retval.l 469 FETCH_INST_OPCODE 1 %ecx 470 ADVANCE_PC 1 471 SET_VREG %eax rINST # fp[AA]<- retval.l 472 GOTO_NEXT_R %ecx 473 474/* ------------------------------ */ 475.L_OP_MOVE_RESULT_WIDE: /* 0x0b */ 476/* File: x86/OP_MOVE_RESULT_WIDE.S */ 477 /* move-result-wide vAA */ 478 movl rSELF,%ecx 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 484 ADVANCE_PC 1 485 GOTO_NEXT_R %ecx 486 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 */ 492 /* op vAA */ 493 movl rSELF,%eax # eax<- rSELF 494 movl offThread_retval(%eax),%eax # eax<- self->retval.l 495 FETCH_INST_OPCODE 1 %ecx 496 ADVANCE_PC 1 497 SET_VREG %eax rINST # fp[AA]<- retval.l 498 GOTO_NEXT_R %ecx 499 500 501/* ------------------------------ */ 502.L_OP_MOVE_EXCEPTION: /* 0x0d */ 503/* File: x86/OP_MOVE_EXCEPTION.S */ 504 /* move-exception vAA */ 505 movl rSELF,%ecx 506 movl offThread_exception(%ecx),%eax # eax<- dvmGetException bypass 507 SET_VREG %eax rINST # fp[AA]<- exception object 508 FETCH_INST_OPCODE 1 %eax 509 ADVANCE_PC 1 510 movl $0,offThread_exception(%ecx) # dvmClearException bypass 511 GOTO_NEXT_R %eax 512 513/* ------------------------------ */ 514.L_OP_RETURN_VOID: /* 0x0e */ 515/* File: x86/OP_RETURN_VOID.S */ 516 jmp common_returnFromMethod 517 518/* ------------------------------ */ 519.L_OP_RETURN: /* 0x0f */ 520/* File: x86/OP_RETURN.S */ 521 /* 522 * Return a 32-bit value. Copies the return value into the "self" 523 * structure, then jumps to the return handler. 524 * 525 * for: return, return-object 526 */ 527 /* op vAA */ 528 movl rSELF,%ecx 529 GET_VREG_R %eax rINST # eax<- vAA 530 movl %eax,offThread_retval(%ecx) # retval.i <- AA 531 jmp common_returnFromMethod 532 533/* ------------------------------ */ 534.L_OP_RETURN_WIDE: /* 0x10 */ 535/* File: x86/OP_RETURN_WIDE.S */ 536 /* 537 * Return a 64-bit value. Copies the return value into the "self" 538 * structure, then jumps to the return handler. 539 */ 540 /* return-wide vAA */ 541 movl rSELF,%ecx 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 547 548/* ------------------------------ */ 549.L_OP_RETURN_OBJECT: /* 0x11 */ 550/* File: x86/OP_RETURN_OBJECT.S */ 551/* File: x86/OP_RETURN.S */ 552 /* 553 * Return a 32-bit value. Copies the return value into the "self" 554 * structure, then jumps to the return handler. 555 * 556 * for: return, return-object 557 */ 558 /* op vAA */ 559 movl rSELF,%ecx 560 GET_VREG_R %eax rINST # eax<- vAA 561 movl %eax,offThread_retval(%ecx) # retval.i <- AA 562 jmp common_returnFromMethod 563 564 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 570 movl $0xf,rINST 571 andl %eax,rINST # rINST<- A 572 FETCH_INST_OPCODE 1 %ecx 573 ADVANCE_PC 1 574 sarl $4,%eax 575 SET_VREG %eax rINST 576 GOTO_NEXT_R %ecx 577 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 584 ADVANCE_PC 2 585 SET_VREG %ecx rINST # vAA<- ssssBBBB 586 GOTO_NEXT_R %eax 587 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 595 ADVANCE_PC 3 596 SET_VREG %eax rINST # vAA<- eax 597 GOTO_NEXT_R %ecx 598 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 605 ADVANCE_PC 2 606 sall $16,%eax # eax<- BBBB0000 607 SET_VREG %eax rINST # vAA<- eax 608 GOTO_NEXT_R %ecx 609 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 621 ADVANCE_PC 2 622 GOTO_NEXT_R %ecx 623 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 635 ADVANCE_PC 3 636 GOTO_NEXT_R %ecx 637 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 646 movl rINST,4(%ecx) 647 movl %eax,(%ecx) 648 FETCH_INST_OPCODE 5 %ecx 649 ADVANCE_PC 5 650 GOTO_NEXT_R %ecx 651 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 658 ADVANCE_PC 2 659 sall $16,%eax # eax<- BBBB0000 660 SET_VREG_WORD %eax rINST 1 # v[AA+1]<- eax 661 xorl %eax,%eax 662 SET_VREG_WORD %eax rINST 0 # v[AA+0]<- eax 663 GOTO_NEXT_R %ecx 664 665/* ------------------------------ */ 666.L_OP_CONST_STRING: /* 0x1a */ 667/* File: x86/OP_CONST_STRING.S */ 668 669 /* const/string vAA, String@BBBB */ 670 movl rSELF,%ecx 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] 679 ADVANCE_PC 2 680 GOTO_NEXT_R %ecx 681 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: 685 movl rSELF,%eax 686 EXPORT_PC 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) 692 SPILL(rIBASE) 693 call dvmResolveString # go resolve 694 UNSPILL(rIBASE) 695 testl %eax,%eax # failed? 696 je common_exceptionThrown 697 FETCH_INST_OPCODE 2 %ecx 698 SET_VREG %eax rINST 699 ADVANCE_PC 2 700 GOTO_NEXT_R %ecx 701 702/* ------------------------------ */ 703.L_OP_CONST_STRING_JUMBO: /* 0x1b */ 704/* File: x86/OP_CONST_STRING_JUMBO.S */ 705 706 /* const/string vAA, String@BBBBBBBB */ 707 movl rSELF,%ecx 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] 716 ADVANCE_PC 3 717 GOTO_NEXT_R %ecx 718 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: 722 movl rSELF,%eax 723 EXPORT_PC 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) 729 SPILL(rIBASE) 730 call dvmResolveString # go resolve 731 UNSPILL(rIBASE) 732 testl %eax,%eax # failed? 733 je common_exceptionThrown 734 FETCH_INST_OPCODE 3 %ecx 735 SET_VREG %eax rINST 736 ADVANCE_PC 3 737 GOTO_NEXT_R %ecx 738 739/* ------------------------------ */ 740.L_OP_CONST_CLASS: /* 0x1c */ 741/* File: x86/OP_CONST_CLASS.S */ 742 743 /* const/class vAA, Class@BBBB */ 744 movl rSELF,%ecx 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] 753 ADVANCE_PC 2 754 GOTO_NEXT_R %ecx 755 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: 759 movl rSELF,%eax 760 EXPORT_PC 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) 767 SPILL(rIBASE) 768 call dvmResolveClass # go resolve 769 UNSPILL(rIBASE) 770 testl %eax,%eax # failed? 771 je common_exceptionThrown 772 FETCH_INST_OPCODE 2 %ecx 773 SET_VREG %eax rINST 774 ADVANCE_PC 2 775 GOTO_NEXT_R %ecx 776 777/* ------------------------------ */ 778.L_OP_MONITOR_ENTER: /* 0x1d */ 779/* File: x86/OP_MONITOR_ENTER.S */ 780 /* 781 * Synchronize on an object. 782 */ 783 /* monitor-enter vAA */ 784 movl rSELF,%ecx 785 GET_VREG_R %eax rINST # eax<- vAA 786 FETCH_INST_WORD 1 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) 792 SPILL(rIBASE) 793 call dvmLockObject # dvmLockObject(self,object) 794 UNSPILL(rIBASE) 795 FETCH_INST_OPCODE 1 %ecx 796 ADVANCE_PC 1 797 GOTO_NEXT_R %ecx 798 799/* ------------------------------ */ 800.L_OP_MONITOR_EXIT: /* 0x1e */ 801/* File: x86/OP_MONITOR_EXIT.S */ 802 /* 803 * Unlock an object. 804 * 805 * Exceptions that occur when unlocking a monitor need to appear as 806 * if they happened at the following instruction. See the Dalvik 807 * instruction spec. 808 */ 809 /* monitor-exit vAA */ 810 GET_VREG_R %eax rINST 811 movl rSELF,%ecx 812 EXPORT_PC 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) 817 SPILL(rIBASE) 818 call dvmUnlockObject # unlock(self,obj) 819 UNSPILL(rIBASE) 820 FETCH_INST_OPCODE 1 %ecx 821 testl %eax,%eax # success? 822 ADVANCE_PC 1 823 je common_exceptionThrown # no, exception pending 824 GOTO_NEXT_R %ecx 825.LOP_MONITOR_EXIT_errNullObject: 826 ADVANCE_PC 1 # advance before throw 827 jmp common_errNullObject 828 829/* ------------------------------ */ 830.L_OP_CHECK_CAST: /* 0x1f */ 831/* File: x86/OP_CHECK_CAST.S */ 832 /* 833 * Check to see if a cast from one class to another is allowed. 834 */ 835 /* check-cast vAA, class@BBBB */ 836 movl rSELF,%ecx 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 852 ADVANCE_PC 2 853 GOTO_NEXT_R %ecx 854 855 /* 856 * Trivial test failed, need to perform full check. This is common. 857 * ecx holds obj->clazz 858 * eax holds class resolved from BBBB 859 * rINST holds object 860 */ 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) 865 SPILL(rIBASE) 866 call dvmInstanceofNonTrivial # eax<- boolean result 867 UNSPILL(rIBASE) 868 testl %eax,%eax # failed? 869 jne .LOP_CHECK_CAST_okay # no, success 870 871 # A cast has failed. We need to throw a ClassCastException. 872 EXPORT_PC 873 movl offObject_clazz(rINST),%eax 874 movl %eax,OUT_ARG0(%esp) # arg0<- obj->clazz 875 movl sReg0,%ecx 876 movl %ecx,OUT_ARG1(%esp) # arg1<- desired class 877 call dvmThrowClassCastException 878 jmp common_exceptionThrown 879 880 /* 881 * Resolution required. This is the least-likely path, and we're 882 * going to have to recreate some data. 883 * 884 * rINST holds object 885 */ 886.LOP_CHECK_CAST_resolve: 887 movl rSELF,%ecx 888 EXPORT_PC 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 895 SPILL(rIBASE) 896 call dvmResolveClass # eax<- resolved ClassObject ptr 897 UNSPILL(rIBASE) 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 902 903/* ------------------------------ */ 904.L_OP_INSTANCE_OF: /* 0x20 */ 905/* File: x86/OP_INSTANCE_OF.S */ 906 /* 907 * Check to see if an object reference is an instance of a class. 908 * 909 * Most common situation is a non-null object, being compared against 910 * an already-resolved class. 911 */ 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) 916 movl rSELF,%ecx 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 930 /* 931 * Trivial test failed, need to perform full check. This is common. 932 * eax holds obj->clazz 933 * ecx holds class resolved from BBBB 934 * rINST has BA 935 */ 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 940 941 /* 942 * eax holds boolean result 943 * rINST holds BA 944 */ 945.LOP_INSTANCE_OF_store: 946 FETCH_INST_OPCODE 2 %ecx 947 UNSPILL(rIBASE) 948 andb $0xf,rINSTbl # <- A 949 ADVANCE_PC 2 950 SET_VREG %eax rINST # vA<- eax 951 GOTO_NEXT_R %ecx 952 953 /* 954 * Trivial test succeeded, save and bail. 955 * r9 holds A 956 */ 957.LOP_INSTANCE_OF_trivial: 958 FETCH_INST_OPCODE 2 %ecx 959 UNSPILL(rIBASE) 960 andb $0xf,rINSTbl # <- A 961 ADVANCE_PC 2 962 movl $1,%eax 963 SET_VREG %eax rINST # vA<- true 964 GOTO_NEXT_R %ecx 965 966 /* 967 * Resolution required. This is the least-likely path. 968 * 969 * rIBASE holds BBBB 970 * rINST holds BA 971 */ 972.LOP_INSTANCE_OF_resolve: 973 movl rIBASE,OUT_ARG1(%esp) # arg1<- BBBB 974 movl rSELF,%ecx 975 movl offThread_method(%ecx),%ecx 976 movl $1,OUT_ARG2(%esp) # arg2<- true 977 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 978 EXPORT_PC 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 985 */ 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 992 993/* ------------------------------ */ 994.L_OP_ARRAY_LENGTH: /* 0x21 */ 995/* File: x86/OP_ARRAY_LENGTH.S */ 996 /* 997 * Return the length of an array. 998 */ 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 1007 ADVANCE_PC 1 1008 SET_VREG rINST %eax 1009 GOTO_NEXT_R %ecx 1010 1011/* ------------------------------ */ 1012.L_OP_NEW_INSTANCE: /* 0x22 */ 1013/* File: x86/OP_NEW_INSTANCE.S */ 1014 /* 1015 * Create a new instance of a class. 1016 */ 1017 /* new-instance vAA, class@BBBB */ 1018 movl rSELF,%ecx 1019 movzwl 2(rPC),%eax # eax<- BBBB 1020 movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex 1021 SPILL(rIBASE) 1022 movl offDvmDex_pResClasses(%ecx),%ecx # ecx<- pDvmDex->pResClasses 1023 EXPORT_PC 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 1035 UNSPILL(rIBASE) 1036 testl %eax,%eax # success? 1037 je common_exceptionThrown # no, bail out 1038 SET_VREG %eax rINST 1039 ADVANCE_PC 2 1040 GOTO_NEXT_R %ecx 1041 1042 /* 1043 * Class initialization required. 1044 * 1045 * ecx holds class object 1046 */ 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 1055 1056 /* 1057 * Resolution required. This is the least-likely path. 1058 * 1059 */ 1060.LOP_NEW_INSTANCE_resolve: 1061 movl rSELF,%ecx 1062 movzwl 2(rPC),%eax 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 1073 1074/* ------------------------------ */ 1075.L_OP_NEW_ARRAY: /* 0x23 */ 1076/* File: x86/OP_NEW_ARRAY.S */ 1077 /* 1078 * Allocate an array of objects, specified with the array class 1079 * and a count. 1080 * 1081 * The verifier guarantees that this is an array class, so we don't 1082 * check for it here. 1083 */ 1084 /* new-array vA, vB, class@CCCC */ 1085 movl rSELF,%ecx 1086 EXPORT_PC 1087 movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex 1088 movzwl 2(rPC),%eax # eax<- CCCC 1089 movl offDvmDex_pResClasses(%ecx),%ecx # ecx<- pDvmDex->pResClasses 1090 SPILL(rIBASE) 1091 movl (%ecx,%eax,4),%ecx # ecx<- resolved class 1092 movzbl rINSTbl,%eax 1093 sarl $4,%eax # eax<- B 1094 GET_VREG_R %eax %eax # eax<- vB (array length) 1095 andb $0xf,rINSTbl # rINST<- A 1096 testl %eax,%eax 1097 js common_errNegativeArraySize # bail, passing len in eax 1098 testl %ecx,%ecx # already resolved? 1099 jne .LOP_NEW_ARRAY_finish # yes, fast path 1100 /* 1101 * Resolve class. (This is an uncommon case.) 1102 * ecx holds class (null here) 1103 * eax holds array length (vB) 1104 */ 1105 movl rSELF,%ecx 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) 1114 movl %eax,%ecx 1115 UNSPILL_TMP1(%eax) 1116 testl %ecx,%ecx # successful resolution? 1117 je common_exceptionThrown # no, bail. 1118# fall through to OP_NEW_ARRAY_finish 1119 1120 /* 1121 * Finish allocation 1122 * 1123 * ecx holds class 1124 * eax holds array length (vB) 1125 */ 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 1132 UNSPILL(rIBASE) 1133 testl %eax,%eax # failed? 1134 je common_exceptionThrown # yup - go handle 1135 SET_VREG %eax rINST 1136 ADVANCE_PC 2 1137 GOTO_NEXT_R %ecx 1138 1139/* ------------------------------ */ 1140.L_OP_FILLED_NEW_ARRAY: /* 0x24 */ 1141/* File: x86/OP_FILLED_NEW_ARRAY.S */ 1142 /* 1143 * Create a new array with elements filled from registers. 1144 * 1145 * for: filled-new-array, filled-new-array/range 1146 */ 1147 /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ 1148 /* op {vCCCC..v(CCCC+AA-1)}, type@BBBB */ 1149 movl rSELF,%eax 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 1155 EXPORT_PC 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 1159 movl rSELF,%eax 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 1168 1169 # note: fall through to .LOP_FILLED_NEW_ARRAY_continue 1170 1171 /* 1172 * On entry: 1173 * eax holds array class [r0] 1174 * rINST holds AA or BB [r10] 1175 * ecx is scratch 1176 */ 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 1182 movl rSELF,%eax 1183 cmpb $'I',%cl # supported? 1184 je 1f 1185 cmpb $'L',%cl 1186 je 1f 1187 cmpb $'[',%cl 1188 jne .LOP_FILLED_NEW_ARRAY_notimpl # no, not handled yet 11891: 1190 movl %ecx,offThread_retval+4(%eax) # save type 1191 .if (!0) 1192 SPILL_TMP1(rINST) # save copy, need "B" later 1193 sarl $4,rINST 1194 .endif 1195 movl rINST,OUT_ARG1(%esp) # arg1<- A or AA (length) 1196 call dvmAllocArrayByClass # eax<- call(arrayClass, length, flags) 1197 movl rSELF,%ecx 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 1203 1204/* at this point: 1205 * eax is pointer to tgt 1206 * rINST is length 1207 * ecx is FEDC or CCCC 1208 * TMP_SPILL1 is BA 1209 * We now need to copy values from registers into the array 1210 */ 1211 1212 .if 0 1213 # set up src pointer 1214 SPILL_TMP2(%esi) 1215 SPILL_TMP3(%edi) 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 1219 rep 1220 movsd 1221 UNSPILL_TMP2(%esi) 1222 UNSPILL_TMP3(%edi) 1223 movl rSELF,%ecx 1224 movl offThread_retval+4(%ecx),%eax # eax<- type 1225 .else 1226 testl rINST,rINST 1227 je 4f 1228 UNSPILL_TMP1(rIBASE) # restore "BA" 1229 andl $0x0f,rIBASE # rIBASE<- 0000000A 1230 sall $16,rIBASE # rIBASE<- 000A0000 1231 orl %ecx,rIBASE # rIBASE<- 000AFEDC 12323: 1233 movl $0xf,%ecx 1234 andl rIBASE,%ecx # ecx<- next reg to load 1235 GET_VREG_R %ecx %ecx 1236 shrl $4,rIBASE 1237 leal 4(%eax),%eax 1238 movl %ecx,-4(%eax) 1239 sub $1,rINST 1240 jne 3b 12414: 1242 movl rSELF,%ecx 1243 movl offThread_retval+4(%ecx),%eax # eax<- type 1244 .endif 1245 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 12525: 1253 UNSPILL(rIBASE) # restore rIBASE 1254 FETCH_INST_OPCODE 3 %ecx 1255 ADVANCE_PC 3 1256 GOTO_NEXT_R %ecx 1257 1258 1259 /* 1260 * Throw an exception indicating that we have not implemented this 1261 * mode of filled-new-array. 1262 */ 1263.LOP_FILLED_NEW_ARRAY_notimpl: 1264 movl $.LstrFilledNewArrayNotImplA,%eax 1265 movl %eax,OUT_ARG0(%esp) 1266 call dvmThrowInternalError 1267 jmp common_exceptionThrown 1268 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 */ 1273 /* 1274 * Create a new array with elements filled from registers. 1275 * 1276 * for: filled-new-array, filled-new-array/range 1277 */ 1278 /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ 1279 /* op {vCCCC..v(CCCC+AA-1)}, type@BBBB */ 1280 movl rSELF,%eax 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 1286 EXPORT_PC 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 1290 movl rSELF,%eax 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 1299 1300 # note: fall through to .LOP_FILLED_NEW_ARRAY_RANGE_continue 1301 1302 /* 1303 * On entry: 1304 * eax holds array class [r0] 1305 * rINST holds AA or BB [r10] 1306 * ecx is scratch 1307 */ 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 1313 movl rSELF,%eax 1314 cmpb $'I',%cl # supported? 1315 je 1f 1316 cmpb $'L',%cl 1317 je 1f 1318 cmpb $'[',%cl 1319 jne .LOP_FILLED_NEW_ARRAY_RANGE_notimpl # no, not handled yet 13201: 1321 movl %ecx,offThread_retval+4(%eax) # save type 1322 .if (!1) 1323 SPILL_TMP1(rINST) # save copy, need "B" later 1324 sarl $4,rINST 1325 .endif 1326 movl rINST,OUT_ARG1(%esp) # arg1<- A or AA (length) 1327 call dvmAllocArrayByClass # eax<- call(arrayClass, length, flags) 1328 movl rSELF,%ecx 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 1334 1335/* at this point: 1336 * eax is pointer to tgt 1337 * rINST is length 1338 * ecx is FEDC or CCCC 1339 * TMP_SPILL1 is BA 1340 * We now need to copy values from registers into the array 1341 */ 1342 1343 .if 1 1344 # set up src pointer 1345 SPILL_TMP2(%esi) 1346 SPILL_TMP3(%edi) 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 1350 rep 1351 movsd 1352 UNSPILL_TMP2(%esi) 1353 UNSPILL_TMP3(%edi) 1354 movl rSELF,%ecx 1355 movl offThread_retval+4(%ecx),%eax # eax<- type 1356 .else 1357 testl rINST,rINST 1358 je 4f 1359 UNSPILL_TMP1(rIBASE) # restore "BA" 1360 andl $0x0f,rIBASE # rIBASE<- 0000000A 1361 sall $16,rIBASE # rIBASE<- 000A0000 1362 orl %ecx,rIBASE # rIBASE<- 000AFEDC 13633: 1364 movl $0xf,%ecx 1365 andl rIBASE,%ecx # ecx<- next reg to load 1366 GET_VREG_R %ecx %ecx 1367 shrl $4,rIBASE 1368 leal 4(%eax),%eax 1369 movl %ecx,-4(%eax) 1370 sub $1,rINST 1371 jne 3b 13724: 1373 movl rSELF,%ecx 1374 movl offThread_retval+4(%ecx),%eax # eax<- type 1375 .endif 1376 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 13835: 1384 UNSPILL(rIBASE) # restore rIBASE 1385 FETCH_INST_OPCODE 3 %ecx 1386 ADVANCE_PC 3 1387 GOTO_NEXT_R %ecx 1388 1389 1390 /* 1391 * Throw an exception indicating that we have not implemented this 1392 * mode of filled-new-array. 1393 */ 1394.LOP_FILLED_NEW_ARRAY_RANGE_notimpl: 1395 movl $.LstrFilledNewArrayNotImplA,%eax 1396 movl %eax,OUT_ARG0(%esp) 1397 call dvmThrowInternalError 1398 jmp common_exceptionThrown 1399 1400 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 1408 EXPORT_PC 1409 movl %eax,OUT_ARG0(%esp) 1410 movl %ecx,OUT_ARG1(%esp) 1411 SPILL(rIBASE) 1412 call dvmInterpHandleFillArrayData 1413 UNSPILL(rIBASE) 1414 FETCH_INST_OPCODE 3 %ecx 1415 testl %eax,%eax # exception thrown? 1416 je common_exceptionThrown 1417 ADVANCE_PC 3 1418 GOTO_NEXT_R %ecx 1419 1420/* ------------------------------ */ 1421.L_OP_THROW: /* 0x27 */ 1422/* File: x86/OP_THROW.S */ 1423 /* 1424 * Throw an exception object in the current thread. 1425 */ 1426 /* throw vAA */ 1427 EXPORT_PC 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 1434 1435/* ------------------------------ */ 1436.L_OP_GOTO: /* 0x28 */ 1437/* File: x86/OP_GOTO.S */ 1438 /* 1439 * Unconditional branch, 8-bit offset. 1440 * 1441 * The branch distance is a signed code-unit offset, which we need to 1442 * double to get a byte offset. 1443 */ 1444 /* goto +AA */ 1445 movsbl rINSTbl,rINST # ebx<- ssssssAA 1446 testl rINST,rINST # test for <0 1447 js common_backwardBranch 1448 movl rINST,%eax 1449 FETCH_INST_INDEXED %eax 1450 ADVANCE_PC_INDEXED %eax 1451 GOTO_NEXT 1452 1453/* ------------------------------ */ 1454.L_OP_GOTO_16: /* 0x29 */ 1455/* File: x86/OP_GOTO_16.S */ 1456 /* 1457 * Unconditional branch, 16-bit offset. 1458 * 1459 * The branch distance is a signed code-unit offset 1460 */ 1461 /* goto/16 +AAAA */ 1462 movswl 2(rPC),rINST # rINST<- ssssAAAA 1463 testl rINST,rINST # test for <0 1464 js common_backwardBranch 1465 movl rINST,%eax 1466 FETCH_INST_INDEXED %eax 1467 ADVANCE_PC_INDEXED %eax 1468 GOTO_NEXT 1469 1470/* ------------------------------ */ 1471.L_OP_GOTO_32: /* 0x2a */ 1472/* File: x86/OP_GOTO_32.S */ 1473 /* 1474 * Unconditional branch, 32-bit offset. 1475 * 1476 * The branch distance is a signed code-unit offset. 1477 * 1478 * Unlike most opcodes, this one is allowed to branch to itself, so 1479 * our "backward branch" test must be "<=0" instead of "<0". 1480 */ 1481 /* goto/32 AAAAAAAA */ 1482 movl 2(rPC),rINST # rINST<- AAAAAAAA 1483 cmpl $0,rINST # test for <= 0 1484 jle common_backwardBranch 1485 movl rINST,%eax 1486 FETCH_INST_INDEXED %eax 1487 ADVANCE_PC_INDEXED %eax 1488 GOTO_NEXT 1489 1490/* ------------------------------ */ 1491.L_OP_PACKED_SWITCH: /* 0x2b */ 1492/* File: x86/OP_PACKED_SWITCH.S */ 1493 /* 1494 * Handle a packed-switch or sparse-switch instruction. In both cases 1495 * we decode it and hand it off to a helper function. 1496 * 1497 * We don't really expect backward branches in a switch statement, but 1498 * they're perfectly legal, so we check for them here. 1499 * 1500 * for: packed-switch, sparse-switch 1501 */ 1502 /* op vAA, +BBBB */ 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 1508 SPILL(rIBASE) 1509 call dvmInterpHandlePackedSwitch 1510 UNSPILL(rIBASE) 1511 testl %eax,%eax 1512 movl %eax,rINST # set up word offset 1513 jle common_backwardBranch # check on special actions 1514 ADVANCE_PC_INDEXED rINST 1515 FETCH_INST 1516 GOTO_NEXT 1517 1518/* ------------------------------ */ 1519.L_OP_SPARSE_SWITCH: /* 0x2c */ 1520/* File: x86/OP_SPARSE_SWITCH.S */ 1521/* File: x86/OP_PACKED_SWITCH.S */ 1522 /* 1523 * Handle a packed-switch or sparse-switch instruction. In both cases 1524 * we decode it and hand it off to a helper function. 1525 * 1526 * We don't really expect backward branches in a switch statement, but 1527 * they're perfectly legal, so we check for them here. 1528 * 1529 * for: packed-switch, sparse-switch 1530 */ 1531 /* op vAA, +BBBB */ 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 1537 SPILL(rIBASE) 1538 call dvmInterpHandleSparseSwitch 1539 UNSPILL(rIBASE) 1540 testl %eax,%eax 1541 movl %eax,rINST # set up word offset 1542 jle common_backwardBranch # check on special actions 1543 ADVANCE_PC_INDEXED rINST 1544 FETCH_INST 1545 GOTO_NEXT 1546 1547 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 1555 .if 0 1556 fldl (rFP,%eax,4) 1557 fldl (rFP,%ecx,4) 1558 .else 1559 flds (rFP,%eax,4) 1560 flds (rFP,%ecx,4) 1561 .endif 1562 xorl %ecx,%ecx 1563 fucompp # z if equal, p set if NaN, c set if st0 < st1 1564 fnstsw %ax 1565 sahf 1566 FETCH_INST_OPCODE 2 %eax 1567 jp .LOP_CMPL_FLOAT_isNaN 1568 je .LOP_CMPL_FLOAT_finish 1569 sbbl %ecx,%ecx 1570 jb .LOP_CMPL_FLOAT_finish 1571 incl %ecx 1572.LOP_CMPL_FLOAT_finish: 1573 SET_VREG %ecx rINST 1574 ADVANCE_PC 2 1575 GOTO_NEXT_R %eax 1576 1577.LOP_CMPL_FLOAT_isNaN: 1578 movl $-1,%ecx 1579 jmp .LOP_CMPL_FLOAT_finish 1580 1581 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 1589 .if 0 1590 fldl (rFP,%eax,4) 1591 fldl (rFP,%ecx,4) 1592 .else 1593 flds (rFP,%eax,4) 1594 flds (rFP,%ecx,4) 1595 .endif 1596 xorl %ecx,%ecx 1597 fucompp # z if equal, p set if NaN, c set if st0 < st1 1598 fnstsw %ax 1599 sahf 1600 FETCH_INST_OPCODE 2 %eax 1601 jp .LOP_CMPG_FLOAT_isNaN 1602 je .LOP_CMPG_FLOAT_finish 1603 sbbl %ecx,%ecx 1604 jb .LOP_CMPG_FLOAT_finish 1605 incl %ecx 1606.LOP_CMPG_FLOAT_finish: 1607 SET_VREG %ecx rINST 1608 ADVANCE_PC 2 1609 GOTO_NEXT_R %eax 1610 1611.LOP_CMPG_FLOAT_isNaN: 1612 movl $1,%ecx 1613 jmp .LOP_CMPG_FLOAT_finish 1614 1615 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 1623 .if 1 1624 fldl (rFP,%eax,4) 1625 fldl (rFP,%ecx,4) 1626 .else 1627 flds (rFP,%eax,4) 1628 flds (rFP,%ecx,4) 1629 .endif 1630 xorl %ecx,%ecx 1631 fucompp # z if equal, p set if NaN, c set if st0 < st1 1632 fnstsw %ax 1633 sahf 1634 FETCH_INST_OPCODE 2 %eax 1635 jp .LOP_CMPL_DOUBLE_isNaN 1636 je .LOP_CMPL_DOUBLE_finish 1637 sbbl %ecx,%ecx 1638 jb .LOP_CMPL_DOUBLE_finish 1639 incl %ecx 1640.LOP_CMPL_DOUBLE_finish: 1641 SET_VREG %ecx rINST 1642 ADVANCE_PC 2 1643 GOTO_NEXT_R %eax 1644 1645.LOP_CMPL_DOUBLE_isNaN: 1646 movl $-1,%ecx 1647 jmp .LOP_CMPL_DOUBLE_finish 1648 1649 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 1656 .if 1 1657 fldl (rFP,%eax,4) 1658 fldl (rFP,%ecx,4) 1659 .else 1660 flds (rFP,%eax,4) 1661 flds (rFP,%ecx,4) 1662 .endif 1663 xorl %ecx,%ecx 1664 fucompp # z if equal, p set if NaN, c set if st0 < st1 1665 fnstsw %ax 1666 sahf 1667 FETCH_INST_OPCODE 2 %eax 1668 jp .LOP_CMPG_DOUBLE_isNaN 1669 je .LOP_CMPG_DOUBLE_finish 1670 sbbl %ecx,%ecx 1671 jb .LOP_CMPG_DOUBLE_finish 1672 incl %ecx 1673.LOP_CMPG_DOUBLE_finish: 1674 SET_VREG %ecx rINST 1675 ADVANCE_PC 2 1676 GOTO_NEXT_R %eax 1677 1678.LOP_CMPG_DOUBLE_isNaN: 1679 movl $1,%ecx 1680 jmp .LOP_CMPG_DOUBLE_finish 1681 1682/* ------------------------------ */ 1683.L_OP_CMP_LONG: /* 0x31 */ 1684/* File: x86/OP_CMP_LONG.S */ 1685 /* 1686 * Compare two 64-bit values. Puts 0, 1, or -1 into the destination 1687 * register based on the results of the comparison. 1688 */ 1689 // TUNING: rework to avoid rIBASE spill 1690 /* cmp-long vAA, vBB, vCC */ 1691 movzbl 2(rPC),%ecx # ecx<- BB 1692 SPILL(rIBASE) 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 1702 SET_VREG %ecx rINST 1703 FETCH_INST_OPCODE 2 %ecx 1704 UNSPILL(rIBASE) 1705 ADVANCE_PC 2 1706 GOTO_NEXT_R %ecx 1707 1708.LOP_CMP_LONG_bigger: 1709 movl $1,%ecx 1710 SET_VREG %ecx rINST 1711 FETCH_INST_OPCODE 2 %ecx 1712 UNSPILL(rIBASE) 1713 ADVANCE_PC 2 1714 GOTO_NEXT_R %ecx 1715 1716.LOP_CMP_LONG_smaller: 1717 movl $-1,%ecx 1718 SET_VREG %ecx rINST 1719 FETCH_INST_OPCODE 2 %ecx 1720 UNSPILL(rIBASE) 1721 ADVANCE_PC 2 1722 GOTO_NEXT_R %ecx 1723 1724/* ------------------------------ */ 1725.L_OP_IF_EQ: /* 0x32 */ 1726/* File: x86/OP_IF_EQ.S */ 1727/* File: x86/bincmp.S */ 1728 /* 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". 1732 * 1733 * For: if-eq, if-ne, if-lt, if-ge, if-gt, if-le 1734 */ 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 1743 jne 1f 1744 testl rINST,rINST 1745 js common_backwardBranch 1746 movl rINST,%eax 17471: 1748 FETCH_INST_INDEXED %eax 1749 ADVANCE_PC_INDEXED %eax 1750 GOTO_NEXT 1751 1752 1753/* ------------------------------ */ 1754.L_OP_IF_NE: /* 0x33 */ 1755/* File: x86/OP_IF_NE.S */ 1756/* File: x86/bincmp.S */ 1757 /* 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". 1761 * 1762 * For: if-eq, if-ne, if-lt, if-ge, if-gt, if-le 1763 */ 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 1772 je 1f 1773 testl rINST,rINST 1774 js common_backwardBranch 1775 movl rINST,%eax 17761: 1777 FETCH_INST_INDEXED %eax 1778 ADVANCE_PC_INDEXED %eax 1779 GOTO_NEXT 1780 1781 1782/* ------------------------------ */ 1783.L_OP_IF_LT: /* 0x34 */ 1784/* File: x86/OP_IF_LT.S */ 1785/* File: x86/bincmp.S */ 1786 /* 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". 1790 * 1791 * For: if-eq, if-ne, if-lt, if-ge, if-gt, if-le 1792 */ 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 1801 jge 1f 1802 testl rINST,rINST 1803 js common_backwardBranch 1804 movl rINST,%eax 18051: 1806 FETCH_INST_INDEXED %eax 1807 ADVANCE_PC_INDEXED %eax 1808 GOTO_NEXT 1809 1810 1811/* ------------------------------ */ 1812.L_OP_IF_GE: /* 0x35 */ 1813/* File: x86/OP_IF_GE.S */ 1814/* File: x86/bincmp.S */ 1815 /* 1816 * Generic two-operand compare-and-branch operation. Provide a "revcmp" 1817 * fragment that specifies the *reverse* comparison to perform, e.g. 1818 * for "if-le" you would use "gt". 1819 * 1820 * For: if-eq, if-ne, if-lt, if-ge, if-gt, if-le 1821 */ 1822 /* if-cmp vA, vB, +CCCC */ 1823 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 1830 jl 1f 1831 testl rINST,rINST 1832 js common_backwardBranch 1833 movl rINST,%eax 18341: 1835 FETCH_INST_INDEXED %eax 1836 ADVANCE_PC_INDEXED %eax 1837 GOTO_NEXT 1838 1839 1840/* ------------------------------ */ 1841.L_OP_IF_GT: /* 0x36 */ 1842/* File: x86/OP_IF_GT.S */ 1843/* File: x86/bincmp.S */ 1844 /* 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". 1848 * 1849 * For: if-eq, if-ne, if-lt, if-ge, if-gt, if-le 1850 */ 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 1859 jle 1f 1860 testl rINST,rINST 1861 js common_backwardBranch 1862 movl rINST,%eax 18631: 1864 FETCH_INST_INDEXED %eax 1865 ADVANCE_PC_INDEXED %eax 1866 GOTO_NEXT 1867 1868 1869/* ------------------------------ */ 1870.L_OP_IF_LE: /* 0x37 */ 1871/* File: x86/OP_IF_LE.S */ 1872/* File: x86/bincmp.S */ 1873 /* 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". 1877 * 1878 * For: if-eq, if-ne, if-lt, if-ge, if-gt, if-le 1879 */ 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 1888 jg 1f 1889 testl rINST,rINST 1890 js common_backwardBranch 1891 movl rINST,%eax 18921: 1893 FETCH_INST_INDEXED %eax 1894 ADVANCE_PC_INDEXED %eax 1895 GOTO_NEXT 1896 1897 1898/* ------------------------------ */ 1899.L_OP_IF_EQZ: /* 0x38 */ 1900/* File: x86/OP_IF_EQZ.S */ 1901/* File: x86/zcmp.S */ 1902 /* 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". 1906 * 1907 * for: if-eqz, if-nez, if-ltz, if-gez, if-gtz, if-lez 1908 */ 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 1913 jne 1f 1914 testl rINST,rINST 1915 js common_backwardBranch 1916 movl rINST,%eax 19171: 1918 FETCH_INST_INDEXED %eax 1919 ADVANCE_PC_INDEXED %eax 1920 GOTO_NEXT 1921 1922 1923/* ------------------------------ */ 1924.L_OP_IF_NEZ: /* 0x39 */ 1925/* File: x86/OP_IF_NEZ.S */ 1926/* File: x86/zcmp.S */ 1927 /* 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". 1931 * 1932 * for: if-eqz, if-nez, if-ltz, if-gez, if-gtz, if-lez 1933 */ 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 1938 je 1f 1939 testl rINST,rINST 1940 js common_backwardBranch 1941 movl rINST,%eax 19421: 1943 FETCH_INST_INDEXED %eax 1944 ADVANCE_PC_INDEXED %eax 1945 GOTO_NEXT 1946 1947 1948/* ------------------------------ */ 1949.L_OP_IF_LTZ: /* 0x3a */ 1950/* File: x86/OP_IF_LTZ.S */ 1951/* File: x86/zcmp.S */ 1952 /* 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". 1956 * 1957 * for: if-eqz, if-nez, if-ltz, if-gez, if-gtz, if-lez 1958 */ 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 1963 jge 1f 1964 testl rINST,rINST 1965 js common_backwardBranch 1966 movl rINST,%eax 19671: 1968 FETCH_INST_INDEXED %eax 1969 ADVANCE_PC_INDEXED %eax 1970 GOTO_NEXT 1971 1972 1973/* ------------------------------ */ 1974.L_OP_IF_GEZ: /* 0x3b */ 1975/* File: x86/OP_IF_GEZ.S */ 1976/* File: x86/zcmp.S */ 1977 /* 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". 1981 * 1982 * for: if-eqz, if-nez, if-ltz, if-gez, if-gtz, if-lez 1983 */ 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 1988 jl 1f 1989 testl rINST,rINST 1990 js common_backwardBranch 1991 movl rINST,%eax 19921: 1993 FETCH_INST_INDEXED %eax 1994 ADVANCE_PC_INDEXED %eax 1995 GOTO_NEXT 1996 1997 1998/* ------------------------------ */ 1999.L_OP_IF_GTZ: /* 0x3c */ 2000/* File: x86/OP_IF_GTZ.S */ 2001/* File: x86/zcmp.S */ 2002 /* 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". 2006 * 2007 * for: if-eqz, if-nez, if-ltz, if-gez, if-gtz, if-lez 2008 */ 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 2013 jle 1f 2014 testl rINST,rINST 2015 js common_backwardBranch 2016 movl rINST,%eax 20171: 2018 FETCH_INST_INDEXED %eax 2019 ADVANCE_PC_INDEXED %eax 2020 GOTO_NEXT 2021 2022 2023/* ------------------------------ */ 2024.L_OP_IF_LEZ: /* 0x3d */ 2025/* File: x86/OP_IF_LEZ.S */ 2026/* File: x86/zcmp.S */ 2027 /* 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". 2031 * 2032 * for: if-eqz, if-nez, if-ltz, if-gez, if-gtz, if-lez 2033 */ 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 2038 jg 1f 2039 testl rINST,rINST 2040 js common_backwardBranch 2041 movl rINST,%eax 20421: 2043 FETCH_INST_INDEXED %eax 2044 ADVANCE_PC_INDEXED %eax 2045 GOTO_NEXT 2046 2047 2048/* ------------------------------ */ 2049.L_OP_UNUSED_3E: /* 0x3e */ 2050/* File: x86/OP_UNUSED_3E.S */ 2051/* File: x86/unused.S */ 2052 jmp common_abort 2053 2054 2055/* ------------------------------ */ 2056.L_OP_UNUSED_3F: /* 0x3f */ 2057/* File: x86/OP_UNUSED_3F.S */ 2058/* File: x86/unused.S */ 2059 jmp common_abort 2060 2061 2062/* ------------------------------ */ 2063.L_OP_UNUSED_40: /* 0x40 */ 2064/* File: x86/OP_UNUSED_40.S */ 2065/* File: x86/unused.S */ 2066 jmp common_abort 2067 2068 2069/* ------------------------------ */ 2070.L_OP_UNUSED_41: /* 0x41 */ 2071/* File: x86/OP_UNUSED_41.S */ 2072/* File: x86/unused.S */ 2073 jmp common_abort 2074 2075 2076/* ------------------------------ */ 2077.L_OP_UNUSED_42: /* 0x42 */ 2078/* File: x86/OP_UNUSED_42.S */ 2079/* File: x86/unused.S */ 2080 jmp common_abort 2081 2082 2083/* ------------------------------ */ 2084.L_OP_UNUSED_43: /* 0x43 */ 2085/* File: x86/OP_UNUSED_43.S */ 2086/* File: x86/unused.S */ 2087 jmp common_abort 2088 2089 2090/* ------------------------------ */ 2091.L_OP_AGET: /* 0x44 */ 2092/* File: x86/OP_AGET.S */ 2093 /* 2094 * Array get, 32 bits or less. vAA <- vBB[vCC]. 2095 * 2096 * for: aget, aget-object, aget-boolean, aget-byte, aget-char, aget-short 2097 */ 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 2107 # arrayObj in eax 2108 # index in ecx 2109 movl offArrayObject_contents(%eax,%ecx,4),%eax 2110.LOP_AGET_finish: 2111 FETCH_INST_OPCODE 2 %ecx 2112 SET_VREG %eax rINST 2113 ADVANCE_PC 2 2114 GOTO_NEXT_R %ecx 2115 2116/* ------------------------------ */ 2117.L_OP_AGET_WIDE: /* 0x45 */ 2118/* File: x86/OP_AGET_WIDE.S */ 2119 /* 2120 * Array get, 64 bits. vAA <- vBB[vCC]. 2121 * 2122 */ 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 2132 # arrayObj in eax 2133 # index in ecx 2134 leal offArrayObject_contents(%eax,%ecx,8),%eax 2135 movl (%eax),%ecx 2136 movl 4(%eax),%eax 2137 SET_VREG_WORD %ecx rINST 0 2138 SET_VREG_WORD %eax rINST 1 2139 FETCH_INST_OPCODE 2 %ecx 2140 ADVANCE_PC 2 2141 GOTO_NEXT_R %ecx 2142 2143/* ------------------------------ */ 2144.L_OP_AGET_OBJECT: /* 0x46 */ 2145/* File: x86/OP_AGET_OBJECT.S */ 2146/* File: x86/OP_AGET.S */ 2147 /* 2148 * Array get, 32 bits or less. vAA <- vBB[vCC]. 2149 * 2150 * for: aget, aget-object, aget-boolean, aget-byte, aget-char, aget-short 2151 */ 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 2161 # arrayObj in eax 2162 # index in ecx 2163 movl offArrayObject_contents(%eax,%ecx,4),%eax 2164.LOP_AGET_OBJECT_finish: 2165 FETCH_INST_OPCODE 2 %ecx 2166 SET_VREG %eax rINST 2167 ADVANCE_PC 2 2168 GOTO_NEXT_R %ecx 2169 2170 2171/* ------------------------------ */ 2172.L_OP_AGET_BOOLEAN: /* 0x47 */ 2173/* File: x86/OP_AGET_BOOLEAN.S */ 2174/* File: x86/OP_AGET.S */ 2175 /* 2176 * Array get, 32 bits or less. vAA <- vBB[vCC]. 2177 * 2178 * for: aget, aget-object, aget-boolean, aget-byte, aget-char, aget-short 2179 */ 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 2189 # arrayObj in eax 2190 # index in ecx 2191 movzbl offArrayObject_contents(%eax,%ecx,1),%eax 2192.LOP_AGET_BOOLEAN_finish: 2193 FETCH_INST_OPCODE 2 %ecx 2194 SET_VREG %eax rINST 2195 ADVANCE_PC 2 2196 GOTO_NEXT_R %ecx 2197 2198 2199/* ------------------------------ */ 2200.L_OP_AGET_BYTE: /* 0x48 */ 2201/* File: x86/OP_AGET_BYTE.S */ 2202/* File: x86/OP_AGET.S */ 2203 /* 2204 * Array get, 32 bits or less. vAA <- vBB[vCC]. 2205 * 2206 * for: aget, aget-object, aget-boolean, aget-byte, aget-char, aget-short 2207 */ 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 2217 # arrayObj in eax 2218 # index in ecx 2219 movsbl offArrayObject_contents(%eax,%ecx,1),%eax 2220.LOP_AGET_BYTE_finish: 2221 FETCH_INST_OPCODE 2 %ecx 2222 SET_VREG %eax rINST 2223 ADVANCE_PC 2 2224 GOTO_NEXT_R %ecx 2225 2226 2227/* ------------------------------ */ 2228.L_OP_AGET_CHAR: /* 0x49 */ 2229/* File: x86/OP_AGET_CHAR.S */ 2230/* File: x86/OP_AGET.S */ 2231 /* 2232 * Array get, 32 bits or less. vAA <- vBB[vCC]. 2233 * 2234 * for: aget, aget-object, aget-boolean, aget-byte, aget-char, aget-short 2235 */ 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 2245 # arrayObj in eax 2246 # index in ecx 2247 movzwl offArrayObject_contents(%eax,%ecx,2),%eax 2248.LOP_AGET_CHAR_finish: 2249 FETCH_INST_OPCODE 2 %ecx 2250 SET_VREG %eax rINST 2251 ADVANCE_PC 2 2252 GOTO_NEXT_R %ecx 2253 2254 2255/* ------------------------------ */ 2256.L_OP_AGET_SHORT: /* 0x4a */ 2257/* File: x86/OP_AGET_SHORT.S */ 2258/* File: x86/OP_AGET.S */ 2259 /* 2260 * Array get, 32 bits or less. vAA <- vBB[vCC]. 2261 * 2262 * for: aget, aget-object, aget-boolean, aget-byte, aget-char, aget-short 2263 */ 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 2273 # arrayObj in eax 2274 # index in ecx 2275 movswl offArrayObject_contents(%eax,%ecx,2),%eax 2276.LOP_AGET_SHORT_finish: 2277 FETCH_INST_OPCODE 2 %ecx 2278 SET_VREG %eax rINST 2279 ADVANCE_PC 2 2280 GOTO_NEXT_R %ecx 2281 2282 2283/* ------------------------------ */ 2284.L_OP_APUT: /* 0x4b */ 2285/* File: x86/OP_APUT.S */ 2286 /* 2287 * Array put, 32 bits or less. vBB[vCC] <- vAA 2288 * 2289 * for: aput, aput-object, aput-boolean, aput-byte, aput-char, aput-short 2290 */ 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: 2300 # arrayObj in eax 2301 # index in ecx 2302 leal offArrayObject_contents(%eax,%ecx,4),%eax 2303.LOP_APUT_finish: 2304 GET_VREG_R rINST rINST 2305 FETCH_INST_OPCODE 2 %ecx 2306 movl rINST,(%eax) 2307 ADVANCE_PC 2 2308 GOTO_NEXT_R %ecx 2309 2310/* ------------------------------ */ 2311.L_OP_APUT_WIDE: /* 0x4c */ 2312/* File: x86/OP_APUT_WIDE.S */ 2313 /* 2314 * Array put, 64 bits. vBB[vCC]<-vAA. 2315 * 2316 */ 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: 2326 # arrayObj in eax 2327 # index in ecx 2328 leal offArrayObject_contents(%eax,%ecx,8),%eax 2329 GET_VREG_WORD %ecx rINST 0 2330 GET_VREG_WORD rINST rINST 1 2331 movl %ecx,(%eax) 2332 FETCH_INST_OPCODE 2 %ecx 2333 movl rINST,4(%eax) 2334 ADVANCE_PC 2 2335 GOTO_NEXT_R %ecx 2336 2337/* ------------------------------ */ 2338.L_OP_APUT_OBJECT: /* 0x4d */ 2339/* File: x86/OP_APUT_OBJECT.S */ 2340 /* 2341 * Array put, 32 bits or less. vBB[vCC] <- vAA 2342 * 2343 * for: aput, aput-object, aput-boolean, aput-byte, aput-char, aput-short 2344 */ 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 2355 # arrayObj in eax 2356 # index in ecx 2357 /* On entry: 2358 * eax<- array object 2359 * ecx<- index 2360 * rINST<- vAA 2361 */ 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 2372 movl %eax,sReg1 2373 SPILL(rIBASE) 2374 call dvmCanPutArrayElement # test object type vs. array type 2375 UNSPILL(rIBASE) 2376 UNSPILL_TMP1(%ecx) # recover target address 2377 testl %eax,%eax 2378 movl rSELF,%eax 2379 jne .LOP_APUT_OBJECT_types_okay 2380 2381 # The types don't match. We need to throw an ArrayStoreException. 2382 EXPORT_PC 2383 movl sReg0,%eax # restore the two classes... 2384 movl %eax,OUT_ARG0(%esp) 2385 movl sReg1,%ecx 2386 movl %ecx,OUT_ARG1(%esp) 2387 call dvmThrowArrayStoreExceptionIncompatibleElement # ...and throw 2388 jmp common_exceptionThrown 2389 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 2397 ADVANCE_PC 2 2398 GOTO_NEXT_R %ecx 2399 2400.LOP_APUT_OBJECT_skip_check: 2401 movl rINST,(%ecx) 2402 FETCH_INST_OPCODE 2 %ecx 2403 ADVANCE_PC 2 2404 GOTO_NEXT_R %ecx 2405 2406/* ------------------------------ */ 2407.L_OP_APUT_BOOLEAN: /* 0x4e */ 2408/* File: x86/OP_APUT_BOOLEAN.S */ 2409/* File: x86/OP_APUT.S */ 2410 /* 2411 * Array put, 32 bits or less. vBB[vCC] <- vAA 2412 * 2413 * for: aput, aput-object, aput-boolean, aput-byte, aput-char, aput-short 2414 */ 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: 2424 # arrayObj in eax 2425 # index in ecx 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 2430 movb rINSTbl,(%eax) 2431 ADVANCE_PC 2 2432 GOTO_NEXT_R %ecx 2433 2434 2435/* ------------------------------ */ 2436.L_OP_APUT_BYTE: /* 0x4f */ 2437/* File: x86/OP_APUT_BYTE.S */ 2438/* File: x86/OP_APUT.S */ 2439 /* 2440 * Array put, 32 bits or less. vBB[vCC] <- vAA 2441 * 2442 * for: aput, aput-object, aput-boolean, aput-byte, aput-char, aput-short 2443 */ 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: 2453 # arrayObj in eax 2454 # index in ecx 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 2459 movb rINSTbl,(%eax) 2460 ADVANCE_PC 2 2461 GOTO_NEXT_R %ecx 2462 2463 2464/* ------------------------------ */ 2465.L_OP_APUT_CHAR: /* 0x50 */ 2466/* File: x86/OP_APUT_CHAR.S */ 2467/* File: x86/OP_APUT.S */ 2468 /* 2469 * Array put, 32 bits or less. vBB[vCC] <- vAA 2470 * 2471 * for: aput, aput-object, aput-boolean, aput-byte, aput-char, aput-short 2472 */ 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: 2482 # arrayObj in eax 2483 # index in ecx 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 2488 movw rINSTw,(%eax) 2489 ADVANCE_PC 2 2490 GOTO_NEXT_R %ecx 2491 2492 2493/* ------------------------------ */ 2494.L_OP_APUT_SHORT: /* 0x51 */ 2495/* File: x86/OP_APUT_SHORT.S */ 2496/* File: x86/OP_APUT.S */ 2497 /* 2498 * Array put, 32 bits or less. vBB[vCC] <- vAA 2499 * 2500 * for: aput, aput-object, aput-boolean, aput-byte, aput-char, aput-short 2501 */ 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: 2511 # arrayObj in eax 2512 # index in ecx 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 2517 movw rINSTw,(%eax) 2518 ADVANCE_PC 2 2519 GOTO_NEXT_R %ecx 2520 2521 2522/* ------------------------------ */ 2523.L_OP_IGET: /* 0x52 */ 2524/* File: x86/OP_IGET.S */ 2525 /* 2526 * General 32-bit instance field get. 2527 * 2528 * for: iget, iget-object, iget-boolean, iget-byte, iget-char, iget-short 2529 */ 2530 /* op vA, vB, field@CCCC */ 2531 movl rSELF,%ecx 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 2544 movl rSELF,rIBASE 2545 EXPORT_PC 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 2551 UNSPILL_TMP1(%ecx) 2552 testl %eax,%eax # returns InstrField ptr 2553 jne .LOP_IGET_finish 2554 jmp common_exceptionThrown 2555 2556.LOP_IGET_finish: 2557 /* 2558 * Currently: 2559 * eax holds resolved field 2560 * ecx holds object 2561 * rINST holds A 2562 */ 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 2568 UNSPILL(rIBASE) 2569 SET_VREG %ecx rINST 2570 ADVANCE_PC 2 2571 GOTO_NEXT_R %eax 2572 2573/* ------------------------------ */ 2574.L_OP_IGET_WIDE: /* 0x53 */ 2575/* File: x86/OP_IGET_WIDE.S */ 2576 /* 2577 * 64-bit instance field get. 2578 * 2579 */ 2580 /* op vA, vB, field@CCCC */ 2581 movl rSELF,%ecx 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 2594 movl rSELF,rIBASE 2595 EXPORT_PC 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 2601 UNSPILL_TMP1(%ecx) 2602 testl %eax,%eax # returns InstrField ptr 2603 jne .LOP_IGET_WIDE_finish 2604 jmp common_exceptionThrown 2605 2606.LOP_IGET_WIDE_finish: 2607 /* 2608 * Currently: 2609 * eax holds resolved field 2610 * ecx holds object 2611 * rINST holds A 2612 */ 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 2623 ADVANCE_PC 2 2624 GOTO_NEXT_R %ecx 2625 2626/* ------------------------------ */ 2627.L_OP_IGET_OBJECT: /* 0x54 */ 2628/* File: x86/OP_IGET_OBJECT.S */ 2629/* File: x86/OP_IGET.S */ 2630 /* 2631 * General 32-bit instance field get. 2632 * 2633 * for: iget, iget-object, iget-boolean, iget-byte, iget-char, iget-short 2634 */ 2635 /* op vA, vB, field@CCCC */ 2636 movl rSELF,%ecx 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 2649 movl rSELF,rIBASE 2650 EXPORT_PC 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 2656 UNSPILL_TMP1(%ecx) 2657 testl %eax,%eax # returns InstrField ptr 2658 jne .LOP_IGET_OBJECT_finish 2659 jmp common_exceptionThrown 2660 2661.LOP_IGET_OBJECT_finish: 2662 /* 2663 * Currently: 2664 * eax holds resolved field 2665 * ecx holds object 2666 * rINST holds A 2667 */ 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 2673 UNSPILL(rIBASE) 2674 SET_VREG %ecx rINST 2675 ADVANCE_PC 2 2676 GOTO_NEXT_R %eax 2677 2678 2679/* ------------------------------ */ 2680.L_OP_IGET_BOOLEAN: /* 0x55 */ 2681/* File: x86/OP_IGET_BOOLEAN.S */ 2682/* File: x86/OP_IGET.S */ 2683 /* 2684 * General 32-bit instance field get. 2685 * 2686 * for: iget, iget-object, iget-boolean, iget-byte, iget-char, iget-short 2687 */ 2688 /* op vA, vB, field@CCCC */ 2689 movl rSELF,%ecx 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 2702 movl rSELF,rIBASE 2703 EXPORT_PC 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 2709 UNSPILL_TMP1(%ecx) 2710 testl %eax,%eax # returns InstrField ptr 2711 jne .LOP_IGET_BOOLEAN_finish 2712 jmp common_exceptionThrown 2713 2714.LOP_IGET_BOOLEAN_finish: 2715 /* 2716 * Currently: 2717 * eax holds resolved field 2718 * ecx holds object 2719 * rINST holds A 2720 */ 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 2726 UNSPILL(rIBASE) 2727 SET_VREG %ecx rINST 2728 ADVANCE_PC 2 2729 GOTO_NEXT_R %eax 2730 2731 2732/* ------------------------------ */ 2733.L_OP_IGET_BYTE: /* 0x56 */ 2734/* File: x86/OP_IGET_BYTE.S */ 2735/* File: x86/OP_IGET.S */ 2736 /* 2737 * General 32-bit instance field get. 2738 * 2739 * for: iget, iget-object, iget-boolean, iget-byte, iget-char, iget-short 2740 */ 2741 /* op vA, vB, field@CCCC */ 2742 movl rSELF,%ecx 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 2755 movl rSELF,rIBASE 2756 EXPORT_PC 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 2762 UNSPILL_TMP1(%ecx) 2763 testl %eax,%eax # returns InstrField ptr 2764 jne .LOP_IGET_BYTE_finish 2765 jmp common_exceptionThrown 2766 2767.LOP_IGET_BYTE_finish: 2768 /* 2769 * Currently: 2770 * eax holds resolved field 2771 * ecx holds object 2772 * rINST holds A 2773 */ 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 2779 UNSPILL(rIBASE) 2780 SET_VREG %ecx rINST 2781 ADVANCE_PC 2 2782 GOTO_NEXT_R %eax 2783 2784 2785/* ------------------------------ */ 2786.L_OP_IGET_CHAR: /* 0x57 */ 2787/* File: x86/OP_IGET_CHAR.S */ 2788/* File: x86/OP_IGET.S */ 2789 /* 2790 * General 32-bit instance field get. 2791 * 2792 * for: iget, iget-object, iget-boolean, iget-byte, iget-char, iget-short 2793 */ 2794 /* op vA, vB, field@CCCC */ 2795 movl rSELF,%ecx 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 2808 movl rSELF,rIBASE 2809 EXPORT_PC 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 2815 UNSPILL_TMP1(%ecx) 2816 testl %eax,%eax # returns InstrField ptr 2817 jne .LOP_IGET_CHAR_finish 2818 jmp common_exceptionThrown 2819 2820.LOP_IGET_CHAR_finish: 2821 /* 2822 * Currently: 2823 * eax holds resolved field 2824 * ecx holds object 2825 * rINST holds A 2826 */ 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 2832 UNSPILL(rIBASE) 2833 SET_VREG %ecx rINST 2834 ADVANCE_PC 2 2835 GOTO_NEXT_R %eax 2836 2837 2838/* ------------------------------ */ 2839.L_OP_IGET_SHORT: /* 0x58 */ 2840/* File: x86/OP_IGET_SHORT.S */ 2841/* File: x86/OP_IGET.S */ 2842 /* 2843 * General 32-bit instance field get. 2844 * 2845 * for: iget, iget-object, iget-boolean, iget-byte, iget-char, iget-short 2846 */ 2847 /* op vA, vB, field@CCCC */ 2848 movl rSELF,%ecx 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 2861 movl rSELF,rIBASE 2862 EXPORT_PC 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 2868 UNSPILL_TMP1(%ecx) 2869 testl %eax,%eax # returns InstrField ptr 2870 jne .LOP_IGET_SHORT_finish 2871 jmp common_exceptionThrown 2872 2873.LOP_IGET_SHORT_finish: 2874 /* 2875 * Currently: 2876 * eax holds resolved field 2877 * ecx holds object 2878 * rINST holds A 2879 */ 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 2885 UNSPILL(rIBASE) 2886 SET_VREG %ecx rINST 2887 ADVANCE_PC 2 2888 GOTO_NEXT_R %eax 2889 2890 2891/* ------------------------------ */ 2892.L_OP_IPUT: /* 0x59 */ 2893/* File: x86/OP_IPUT.S */ 2894 2895 /* 2896 * General 32-bit instance field put. 2897 * 2898 * for: iput, iput-object, iput-boolean, iput-byte, iput-char, iput-short 2899 */ 2900 /* op vA, vB, field@CCCC */ 2901 movl rSELF,%ecx 2902 SPILL (rIBASE) 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) 2914 movl rSELF,rIBASE 2915 EXPORT_PC 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 2921 UNSPILL_TMP1(%ecx) 2922 testl %eax,%eax # returns InstrField ptr 2923 jne .LOP_IPUT_finish 2924 jmp common_exceptionThrown 2925 2926.LOP_IPUT_finish: 2927 /* 2928 * Currently: 2929 * eax holds resolved field 2930 * ecx holds object 2931 * rINST holds A 2932 */ 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 2939 UNSPILL(rIBASE) 2940 ADVANCE_PC 2 2941 GOTO_NEXT_R %ecx 2942 2943/* ------------------------------ */ 2944.L_OP_IPUT_WIDE: /* 0x5a */ 2945/* File: x86/OP_IPUT_WIDE.S */ 2946 /* 2947 * 64-bit instance field put. 2948 * 2949 */ 2950 /* op vA, vB, field@CCCC */ 2951 movl rSELF,%ecx 2952 SPILL(rIBASE) 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) 2964 movl rSELF,rIBASE 2965 EXPORT_PC 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 2971 UNSPILL_TMP1(%ecx) 2972 testl %eax,%eax # ... which returns InstrField ptr 2973 jne .LOP_IPUT_WIDE_finish 2974 jmp common_exceptionThrown 2975 2976.LOP_IPUT_WIDE_finish: 2977 /* 2978 * Currently: 2979 * eax holds resolved field 2980 * ecx holds object 2981 * rIBASE is scratch, but needs to be unspilled 2982 * rINST holds A 2983 */ 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 2990 movl rINST,4(%eax) 2991 movl %ecx,(%eax) 2992 FETCH_INST_OPCODE 2 %ecx 2993 UNSPILL(rIBASE) 2994 ADVANCE_PC 2 2995 GOTO_NEXT_R %ecx 2996 2997/* ------------------------------ */ 2998.L_OP_IPUT_OBJECT: /* 0x5b */ 2999/* File: x86/OP_IPUT_OBJECT.S */ 3000 /* 3001 * Object field put. 3002 * 3003 * for: iput-object 3004 */ 3005 /* op vA, vB, field@CCCC */ 3006 movl rSELF,%ecx 3007 SPILL(rIBASE) 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) 3019 movl rSELF,rIBASE 3020 EXPORT_PC 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 3026 UNSPILL_TMP1(%ecx) 3027 testl %eax,%eax # returns InstrField ptr 3028 jne .LOP_IPUT_OBJECT_finish 3029 jmp common_exceptionThrown 3030 3031.LOP_IPUT_OBJECT_finish: 3032 /* 3033 * Currently: 3034 * eax holds resolved field 3035 * ecx holds object 3036 * rIBASE is scratch, but needs to be unspilled 3037 * rINST holds A 3038 */ 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) 3044 movl rSELF,%eax 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 30501: 3051 UNSPILL(rIBASE) 3052 FETCH_INST_OPCODE 2 %ecx 3053 ADVANCE_PC 2 3054 GOTO_NEXT_R %ecx 3055 3056/* ------------------------------ */ 3057.L_OP_IPUT_BOOLEAN: /* 0x5c */ 3058/* File: x86/OP_IPUT_BOOLEAN.S */ 3059/* File: x86/OP_IPUT.S */ 3060 3061 /* 3062 * General 32-bit instance field put. 3063 * 3064 * for: iput, iput-object, iput-boolean, iput-byte, iput-char, iput-short 3065 */ 3066 /* op vA, vB, field@CCCC */ 3067 movl rSELF,%ecx 3068 SPILL (rIBASE) 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) 3080 movl rSELF,rIBASE 3081 EXPORT_PC 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 3087 UNSPILL_TMP1(%ecx) 3088 testl %eax,%eax # returns InstrField ptr 3089 jne .LOP_IPUT_BOOLEAN_finish 3090 jmp common_exceptionThrown 3091 3092.LOP_IPUT_BOOLEAN_finish: 3093 /* 3094 * Currently: 3095 * eax holds resolved field 3096 * ecx holds object 3097 * rINST holds A 3098 */ 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 3105 UNSPILL(rIBASE) 3106 ADVANCE_PC 2 3107 GOTO_NEXT_R %ecx 3108 3109 3110/* ------------------------------ */ 3111.L_OP_IPUT_BYTE: /* 0x5d */ 3112/* File: x86/OP_IPUT_BYTE.S */ 3113/* File: x86/OP_IPUT.S */ 3114 3115 /* 3116 * General 32-bit instance field put. 3117 * 3118 * for: iput, iput-object, iput-boolean, iput-byte, iput-char, iput-short 3119 */ 3120 /* op vA, vB, field@CCCC */ 3121 movl rSELF,%ecx 3122 SPILL (rIBASE) 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) 3134 movl rSELF,rIBASE 3135 EXPORT_PC 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 3141 UNSPILL_TMP1(%ecx) 3142 testl %eax,%eax # returns InstrField ptr 3143 jne .LOP_IPUT_BYTE_finish 3144 jmp common_exceptionThrown 3145 3146.LOP_IPUT_BYTE_finish: 3147 /* 3148 * Currently: 3149 * eax holds resolved field 3150 * ecx holds object 3151 * rINST holds A 3152 */ 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 3159 UNSPILL(rIBASE) 3160 ADVANCE_PC 2 3161 GOTO_NEXT_R %ecx 3162 3163 3164/* ------------------------------ */ 3165.L_OP_IPUT_CHAR: /* 0x5e */ 3166/* File: x86/OP_IPUT_CHAR.S */ 3167/* File: x86/OP_IPUT.S */ 3168 3169 /* 3170 * General 32-bit instance field put. 3171 * 3172 * for: iput, iput-object, iput-boolean, iput-byte, iput-char, iput-short 3173 */ 3174 /* op vA, vB, field@CCCC */ 3175 movl rSELF,%ecx 3176 SPILL (rIBASE) 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) 3188 movl rSELF,rIBASE 3189 EXPORT_PC 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 3195 UNSPILL_TMP1(%ecx) 3196 testl %eax,%eax # returns InstrField ptr 3197 jne .LOP_IPUT_CHAR_finish 3198 jmp common_exceptionThrown 3199 3200.LOP_IPUT_CHAR_finish: 3201 /* 3202 * Currently: 3203 * eax holds resolved field 3204 * ecx holds object 3205 * rINST holds A 3206 */ 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 3213 UNSPILL(rIBASE) 3214 ADVANCE_PC 2 3215 GOTO_NEXT_R %ecx 3216 3217 3218/* ------------------------------ */ 3219.L_OP_IPUT_SHORT: /* 0x5f */ 3220/* File: x86/OP_IPUT_SHORT.S */ 3221/* File: x86/OP_IPUT.S */ 3222 3223 /* 3224 * General 32-bit instance field put. 3225 * 3226 * for: iput, iput-object, iput-boolean, iput-byte, iput-char, iput-short 3227 */ 3228 /* op vA, vB, field@CCCC */ 3229 movl rSELF,%ecx 3230 SPILL (rIBASE) 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) 3242 movl rSELF,rIBASE 3243 EXPORT_PC 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 3249 UNSPILL_TMP1(%ecx) 3250 testl %eax,%eax # returns InstrField ptr 3251 jne .LOP_IPUT_SHORT_finish 3252 jmp common_exceptionThrown 3253 3254.LOP_IPUT_SHORT_finish: 3255 /* 3256 * Currently: 3257 * eax holds resolved field 3258 * ecx holds object 3259 * rINST holds A 3260 */ 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 3267 UNSPILL(rIBASE) 3268 ADVANCE_PC 2 3269 GOTO_NEXT_R %ecx 3270 3271 3272/* ------------------------------ */ 3273.L_OP_SGET: /* 0x60 */ 3274/* File: x86/OP_SGET.S */ 3275 /* 3276 * General 32-bit SGET handler. 3277 * 3278 * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short 3279 */ 3280 /* op vAA, field@BBBB */ 3281 movl rSELF,%ecx 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 3291 ADVANCE_PC 2 3292 SET_VREG %eax rINST 3293 GOTO_NEXT_R %ecx 3294 3295 /* 3296 * Go resolve the field 3297 */ 3298.LOP_SGET_resolve: 3299 movl rSELF,%ecx 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) 3306 SPILL(rIBASE) 3307 call dvmResolveStaticField # eax<- resolved StaticField ptr 3308 UNSPILL(rIBASE) 3309 testl %eax,%eax 3310 jne .LOP_SGET_finish # success, continue 3311 jmp common_exceptionThrown # no, handle exception 3312 3313/* ------------------------------ */ 3314.L_OP_SGET_WIDE: /* 0x61 */ 3315/* File: x86/OP_SGET_WIDE.S */ 3316 /* 3317 * 64-bit SGET handler. 3318 * 3319 */ 3320 /* sget-wide vAA, field@BBBB */ 3321 movl rSELF,%ecx 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 3334 ADVANCE_PC 2 3335 GOTO_NEXT_R %ecx 3336 3337 /* 3338 * Go resolve the field 3339 */ 3340.LOP_SGET_WIDE_resolve: 3341 movl rSELF,%ecx 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) 3348 SPILL(rIBASE) 3349 call dvmResolveStaticField # eax<- resolved StaticField ptr 3350 UNSPILL(rIBASE) 3351 testl %eax,%eax 3352 jne .LOP_SGET_WIDE_finish # success, continue 3353 jmp common_exceptionThrown # no, handle exception 3354 3355/* ------------------------------ */ 3356.L_OP_SGET_OBJECT: /* 0x62 */ 3357/* File: x86/OP_SGET_OBJECT.S */ 3358/* File: x86/OP_SGET.S */ 3359 /* 3360 * General 32-bit SGET handler. 3361 * 3362 * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short 3363 */ 3364 /* op vAA, field@BBBB */ 3365 movl rSELF,%ecx 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 3375 ADVANCE_PC 2 3376 SET_VREG %eax rINST 3377 GOTO_NEXT_R %ecx 3378 3379 /* 3380 * Go resolve the field 3381 */ 3382.LOP_SGET_OBJECT_resolve: 3383 movl rSELF,%ecx 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) 3390 SPILL(rIBASE) 3391 call dvmResolveStaticField # eax<- resolved StaticField ptr 3392 UNSPILL(rIBASE) 3393 testl %eax,%eax 3394 jne .LOP_SGET_OBJECT_finish # success, continue 3395 jmp common_exceptionThrown # no, handle exception 3396 3397 3398/* ------------------------------ */ 3399.L_OP_SGET_BOOLEAN: /* 0x63 */ 3400/* File: x86/OP_SGET_BOOLEAN.S */ 3401/* File: x86/OP_SGET.S */ 3402 /* 3403 * General 32-bit SGET handler. 3404 * 3405 * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short 3406 */ 3407 /* op vAA, field@BBBB */ 3408 movl rSELF,%ecx 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 3418 ADVANCE_PC 2 3419 SET_VREG %eax rINST 3420 GOTO_NEXT_R %ecx 3421 3422 /* 3423 * Go resolve the field 3424 */ 3425.LOP_SGET_BOOLEAN_resolve: 3426 movl rSELF,%ecx 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) 3433 SPILL(rIBASE) 3434 call dvmResolveStaticField # eax<- resolved StaticField ptr 3435 UNSPILL(rIBASE) 3436 testl %eax,%eax 3437 jne .LOP_SGET_BOOLEAN_finish # success, continue 3438 jmp common_exceptionThrown # no, handle exception 3439 3440 3441/* ------------------------------ */ 3442.L_OP_SGET_BYTE: /* 0x64 */ 3443/* File: x86/OP_SGET_BYTE.S */ 3444/* File: x86/OP_SGET.S */ 3445 /* 3446 * General 32-bit SGET handler. 3447 * 3448 * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short 3449 */ 3450 /* op vAA, field@BBBB */ 3451 movl rSELF,%ecx 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 3461 ADVANCE_PC 2 3462 SET_VREG %eax rINST 3463 GOTO_NEXT_R %ecx 3464 3465 /* 3466 * Go resolve the field 3467 */ 3468.LOP_SGET_BYTE_resolve: 3469 movl rSELF,%ecx 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) 3476 SPILL(rIBASE) 3477 call dvmResolveStaticField # eax<- resolved StaticField ptr 3478 UNSPILL(rIBASE) 3479 testl %eax,%eax 3480 jne .LOP_SGET_BYTE_finish # success, continue 3481 jmp common_exceptionThrown # no, handle exception 3482 3483 3484/* ------------------------------ */ 3485.L_OP_SGET_CHAR: /* 0x65 */ 3486/* File: x86/OP_SGET_CHAR.S */ 3487/* File: x86/OP_SGET.S */ 3488 /* 3489 * General 32-bit SGET handler. 3490 * 3491 * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short 3492 */ 3493 /* op vAA, field@BBBB */ 3494 movl rSELF,%ecx 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 3504 ADVANCE_PC 2 3505 SET_VREG %eax rINST 3506 GOTO_NEXT_R %ecx 3507 3508 /* 3509 * Go resolve the field 3510 */ 3511.LOP_SGET_CHAR_resolve: 3512 movl rSELF,%ecx 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) 3519 SPILL(rIBASE) 3520 call dvmResolveStaticField # eax<- resolved StaticField ptr 3521 UNSPILL(rIBASE) 3522 testl %eax,%eax 3523 jne .LOP_SGET_CHAR_finish # success, continue 3524 jmp common_exceptionThrown # no, handle exception 3525 3526 3527/* ------------------------------ */ 3528.L_OP_SGET_SHORT: /* 0x66 */ 3529/* File: x86/OP_SGET_SHORT.S */ 3530/* File: x86/OP_SGET.S */ 3531 /* 3532 * General 32-bit SGET handler. 3533 * 3534 * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short 3535 */ 3536 /* op vAA, field@BBBB */ 3537 movl rSELF,%ecx 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 3547 ADVANCE_PC 2 3548 SET_VREG %eax rINST 3549 GOTO_NEXT_R %ecx 3550 3551 /* 3552 * Go resolve the field 3553 */ 3554.LOP_SGET_SHORT_resolve: 3555 movl rSELF,%ecx 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) 3562 SPILL(rIBASE) 3563 call dvmResolveStaticField # eax<- resolved StaticField ptr 3564 UNSPILL(rIBASE) 3565 testl %eax,%eax 3566 jne .LOP_SGET_SHORT_finish # success, continue 3567 jmp common_exceptionThrown # no, handle exception 3568 3569 3570/* ------------------------------ */ 3571.L_OP_SPUT: /* 0x67 */ 3572/* File: x86/OP_SPUT.S */ 3573 /* 3574 * General 32-bit SPUT handler. 3575 * 3576 * for: sput, sput-boolean, sput-byte, sput-char, sput-short 3577 */ 3578 /* op vAA, field@BBBB */ 3579 movl rSELF,%ecx 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 3589 ADVANCE_PC 2 3590 movl rINST,offStaticField_value(%eax) 3591 GOTO_NEXT_R %ecx 3592 3593 /* 3594 * Go resolve the field 3595 */ 3596.LOP_SPUT_resolve: 3597 movl rSELF,%ecx 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) 3604 SPILL(rIBASE) 3605 call dvmResolveStaticField # eax<- resolved StaticField ptr 3606 UNSPILL(rIBASE) 3607 testl %eax,%eax 3608 jne .LOP_SPUT_finish # success, continue 3609 jmp common_exceptionThrown # no, handle exception 3610 3611/* ------------------------------ */ 3612.L_OP_SPUT_WIDE: /* 0x68 */ 3613/* File: x86/OP_SPUT_WIDE.S */ 3614 /* 3615 * General 32-bit SPUT handler. 3616 * 3617 * for: sput, sput-object, sput-boolean, sput-byte, sput-char, sput-short 3618 */ 3619 /* op vAA, field@BBBB */ 3620 movl rSELF,%ecx 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) 3633 ADVANCE_PC 2 3634 GOTO_NEXT_R %ecx 3635 3636 /* 3637 * Go resolve the field 3638 */ 3639.LOP_SPUT_WIDE_resolve: 3640 movl rSELF,%ecx 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) 3647 SPILL(rIBASE) 3648 call dvmResolveStaticField # eax<- resolved StaticField ptr 3649 UNSPILL(rIBASE) 3650 testl %eax,%eax 3651 jne .LOP_SPUT_WIDE_finish # success, continue 3652 jmp common_exceptionThrown # no, handle exception 3653 3654/* ------------------------------ */ 3655.L_OP_SPUT_OBJECT: /* 0x69 */ 3656/* File: x86/OP_SPUT_OBJECT.S */ 3657 /* 3658 * SPUT object handler. 3659 */ 3660 /* op vAA, field@BBBB */ 3661 movl rSELF,%ecx 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 3674 movl rSELF,%ecx 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 36791: 3680 FETCH_INST_OPCODE 2 %ecx 3681 ADVANCE_PC 2 3682 GOTO_NEXT_R %ecx 3683 3684.LOP_SPUT_OBJECT_resolve: 3685 movl rSELF,%ecx 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) 3692 SPILL(rIBASE) 3693 call dvmResolveStaticField # eax<- resolved StaticField ptr 3694 UNSPILL(rIBASE) 3695 testl %eax,%eax 3696 jne .LOP_SPUT_OBJECT_finish # success, continue 3697 jmp common_exceptionThrown # no, handle exception 3698 3699/* ------------------------------ */ 3700.L_OP_SPUT_BOOLEAN: /* 0x6a */ 3701/* File: x86/OP_SPUT_BOOLEAN.S */ 3702/* File: x86/OP_SPUT.S */ 3703 /* 3704 * General 32-bit SPUT handler. 3705 * 3706 * for: sput, sput-boolean, sput-byte, sput-char, sput-short 3707 */ 3708 /* op vAA, field@BBBB */ 3709 movl rSELF,%ecx 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 3719 ADVANCE_PC 2 3720 movl rINST,offStaticField_value(%eax) 3721 GOTO_NEXT_R %ecx 3722 3723 /* 3724 * Go resolve the field 3725 */ 3726.LOP_SPUT_BOOLEAN_resolve: 3727 movl rSELF,%ecx 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) 3734 SPILL(rIBASE) 3735 call dvmResolveStaticField # eax<- resolved StaticField ptr 3736 UNSPILL(rIBASE) 3737 testl %eax,%eax 3738 jne .LOP_SPUT_BOOLEAN_finish # success, continue 3739 jmp common_exceptionThrown # no, handle exception 3740 3741 3742/* ------------------------------ */ 3743.L_OP_SPUT_BYTE: /* 0x6b */ 3744/* File: x86/OP_SPUT_BYTE.S */ 3745/* File: x86/OP_SPUT.S */ 3746 /* 3747 * General 32-bit SPUT handler. 3748 * 3749 * for: sput, sput-boolean, sput-byte, sput-char, sput-short 3750 */ 3751 /* op vAA, field@BBBB */ 3752 movl rSELF,%ecx 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 3762 ADVANCE_PC 2 3763 movl rINST,offStaticField_value(%eax) 3764 GOTO_NEXT_R %ecx 3765 3766 /* 3767 * Go resolve the field 3768 */ 3769.LOP_SPUT_BYTE_resolve: 3770 movl rSELF,%ecx 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) 3777 SPILL(rIBASE) 3778 call dvmResolveStaticField # eax<- resolved StaticField ptr 3779 UNSPILL(rIBASE) 3780 testl %eax,%eax 3781 jne .LOP_SPUT_BYTE_finish # success, continue 3782 jmp common_exceptionThrown # no, handle exception 3783 3784 3785/* ------------------------------ */ 3786.L_OP_SPUT_CHAR: /* 0x6c */ 3787/* File: x86/OP_SPUT_CHAR.S */ 3788/* File: x86/OP_SPUT.S */ 3789 /* 3790 * General 32-bit SPUT handler. 3791 * 3792 * for: sput, sput-boolean, sput-byte, sput-char, sput-short 3793 */ 3794 /* op vAA, field@BBBB */ 3795 movl rSELF,%ecx 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 3805 ADVANCE_PC 2 3806 movl rINST,offStaticField_value(%eax) 3807 GOTO_NEXT_R %ecx 3808 3809 /* 3810 * Go resolve the field 3811 */ 3812.LOP_SPUT_CHAR_resolve: 3813 movl rSELF,%ecx 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) 3820 SPILL(rIBASE) 3821 call dvmResolveStaticField # eax<- resolved StaticField ptr 3822 UNSPILL(rIBASE) 3823 testl %eax,%eax 3824 jne .LOP_SPUT_CHAR_finish # success, continue 3825 jmp common_exceptionThrown # no, handle exception 3826 3827 3828/* ------------------------------ */ 3829.L_OP_SPUT_SHORT: /* 0x6d */ 3830/* File: x86/OP_SPUT_SHORT.S */ 3831/* File: x86/OP_SPUT.S */ 3832 /* 3833 * General 32-bit SPUT handler. 3834 * 3835 * for: sput, sput-boolean, sput-byte, sput-char, sput-short 3836 */ 3837 /* op vAA, field@BBBB */ 3838 movl rSELF,%ecx 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 3848 ADVANCE_PC 2 3849 movl rINST,offStaticField_value(%eax) 3850 GOTO_NEXT_R %ecx 3851 3852 /* 3853 * Go resolve the field 3854 */ 3855.LOP_SPUT_SHORT_resolve: 3856 movl rSELF,%ecx 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) 3863 SPILL(rIBASE) 3864 call dvmResolveStaticField # eax<- resolved StaticField ptr 3865 UNSPILL(rIBASE) 3866 testl %eax,%eax 3867 jne .LOP_SPUT_SHORT_finish # success, continue 3868 jmp common_exceptionThrown # no, handle exception 3869 3870 3871/* ------------------------------ */ 3872.L_OP_INVOKE_VIRTUAL: /* 0x6e */ 3873/* File: x86/OP_INVOKE_VIRTUAL.S */ 3874 3875 /* 3876 * Handle a virtual method call. 3877 * 3878 * for: invoke-virtual, invoke-virtual/range 3879 */ 3880 /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ 3881 /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ 3882 movl rSELF,%eax 3883 movzwl 2(rPC),%ecx # ecx<- BBBB 3884 movl offThread_methodClassDex(%eax),%eax # eax<- pDvmDex 3885 EXPORT_PC 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 3890 movl rSELF,%eax 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 3900 3901 /* At this point: 3902 * eax = resolved base method 3903 * ecx = scratch 3904 */ 3905.LOP_INVOKE_VIRTUAL_continue: 3906 movzwl 4(rPC),%ecx # ecx<- GFED or CCCC 3907 .if (!0) 3908 andl $0xf,%ecx # ecx<- D (or stays CCCC) 3909 .endif 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 3918 3919/* ------------------------------ */ 3920.L_OP_INVOKE_SUPER: /* 0x6f */ 3921/* File: x86/OP_INVOKE_SUPER.S */ 3922 /* 3923 * Handle a "super" method call. 3924 * 3925 * for: invoke-super, invoke-super/range 3926 */ 3927 /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ 3928 /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ 3929 movl rSELF,rINST 3930 movzwl 2(rPC),%eax # eax<- BBBB 3931 movl offThread_methodClassDex(rINST),%ecx # ecx<- pDvmDex 3932 EXPORT_PC 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 3937 .if (!0) 3938 andl $0xf,rINST # rINST<- D (or stays CCCC) 3939 .endif 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 3946 /* 3947 * At this point: 3948 * ecx = resolved base method [r0] 3949 * eax = method->clazz [r9] 3950 */ 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 3959 3960 3961 /* At this point: 3962 * ecx = null (needs to be resolved base method) 3963 * eax = method->clazz 3964 */ 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 3977 3978 /* 3979 * Throw a NoSuchMethodError with the method name as the message. 3980 * ecx = resolved base method 3981 */ 3982.LOP_INVOKE_SUPER_nsm: 3983 movl offMethod_name(%ecx),%eax 3984 jmp common_errNoSuchMethod 3985 3986/* ------------------------------ */ 3987.L_OP_INVOKE_DIRECT: /* 0x70 */ 3988/* File: x86/OP_INVOKE_DIRECT.S */ 3989 /* 3990 * Handle a direct method call. 3991 * 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.) 3996 * 3997 * for: invoke-direct, invoke-direct/range 3998 */ 3999 /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ 4000 /* op {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ 4001 movl rSELF,%ecx 4002 movzwl 2(rPC),%eax # eax<- BBBB 4003 movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex 4004 EXPORT_PC 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 4008 .if (!0) 4009 andl $0xf,rIBASE # rIBASE<- D (or stays CCCC) 4010 .endif 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 4018 4019 /* 4020 * On entry: 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. 4024 */ 4025.LOP_INVOKE_DIRECT_resolve: 4026 SPILL_TMP1(%ecx) 4027 movl rSELF,%ecx 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) 4035 UNSPILL_TMP1(%ecx) 4036 testl %eax,%eax 4037 jne .LOP_INVOKE_DIRECT_finish 4038 jmp common_exceptionThrown 4039 4040/* ------------------------------ */ 4041.L_OP_INVOKE_STATIC: /* 0x71 */ 4042/* File: x86/OP_INVOKE_STATIC.S */ 4043 /* 4044 * Handle a static method call. 4045 * 4046 * for: invoke-static, invoke-static/range 4047 */ 4048 /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ 4049 /* op {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ 4050 movl rSELF,%ecx 4051 movzwl 2(rPC),%eax # eax<- BBBB 4052 movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex 4053 EXPORT_PC 4054 movl offDvmDex_pResMethods(%ecx),%ecx # ecx<- pDvmDex->pResMethods 4055 movl (%ecx,%eax,4),%eax # eax<- resolved methodToCall 4056 testl %eax,%eax 4057 jne common_invokeMethodNoRange 4058 movl rSELF,%ecx 4059 movl offThread_method(%ecx),%ecx # ecx<- self->method 4060 movzwl 2(rPC),%eax 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 4070 4071/* ------------------------------ */ 4072.L_OP_INVOKE_INTERFACE: /* 0x72 */ 4073/* File: x86/OP_INVOKE_INTERFACE.S */ 4074 /* 4075 * Handle an interface method call. 4076 * 4077 * for: invoke-interface, invoke-interface/range 4078 */ 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 4082 movl rSELF,%ecx 4083 .if (!0) 4084 andl $0xf,%eax # eax<- C (or stays CCCC) 4085 .endif 4086 GET_VREG_R %eax %eax # eax<- "this" 4087 EXPORT_PC 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) 4099 testl %eax,%eax 4100 je common_exceptionThrown 4101 jmp common_invokeMethodNoRange 4102 4103/* ------------------------------ */ 4104.L_OP_UNUSED_73: /* 0x73 */ 4105/* File: x86/OP_UNUSED_73.S */ 4106/* File: x86/unused.S */ 4107 jmp common_abort 4108 4109 4110/* ------------------------------ */ 4111.L_OP_INVOKE_VIRTUAL_RANGE: /* 0x74 */ 4112/* File: x86/OP_INVOKE_VIRTUAL_RANGE.S */ 4113/* File: x86/OP_INVOKE_VIRTUAL.S */ 4114 4115 /* 4116 * Handle a virtual method call. 4117 * 4118 * for: invoke-virtual, invoke-virtual/range 4119 */ 4120 /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ 4121 /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ 4122 movl rSELF,%eax 4123 movzwl 2(rPC),%ecx # ecx<- BBBB 4124 movl offThread_methodClassDex(%eax),%eax # eax<- pDvmDex 4125 EXPORT_PC 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 4130 movl rSELF,%eax 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 4140 4141 /* At this point: 4142 * eax = resolved base method 4143 * ecx = scratch 4144 */ 4145.LOP_INVOKE_VIRTUAL_RANGE_continue: 4146 movzwl 4(rPC),%ecx # ecx<- GFED or CCCC 4147 .if (!1) 4148 andl $0xf,%ecx # ecx<- D (or stays CCCC) 4149 .endif 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 4158 4159 4160/* ------------------------------ */ 4161.L_OP_INVOKE_SUPER_RANGE: /* 0x75 */ 4162/* File: x86/OP_INVOKE_SUPER_RANGE.S */ 4163/* File: x86/OP_INVOKE_SUPER.S */ 4164 /* 4165 * Handle a "super" method call. 4166 * 4167 * for: invoke-super, invoke-super/range 4168 */ 4169 /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ 4170 /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ 4171 movl rSELF,rINST 4172 movzwl 2(rPC),%eax # eax<- BBBB 4173 movl offThread_methodClassDex(rINST),%ecx # ecx<- pDvmDex 4174 EXPORT_PC 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 4179 .if (!1) 4180 andl $0xf,rINST # rINST<- D (or stays CCCC) 4181 .endif 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 4188 /* 4189 * At this point: 4190 * ecx = resolved base method [r0] 4191 * eax = method->clazz [r9] 4192 */ 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 4201 4202 4203 /* At this point: 4204 * ecx = null (needs to be resolved base method) 4205 * eax = method->clazz 4206 */ 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 4219 4220 /* 4221 * Throw a NoSuchMethodError with the method name as the message. 4222 * ecx = resolved base method 4223 */ 4224.LOP_INVOKE_SUPER_RANGE_nsm: 4225 movl offMethod_name(%ecx),%eax 4226 jmp common_errNoSuchMethod 4227 4228 4229/* ------------------------------ */ 4230.L_OP_INVOKE_DIRECT_RANGE: /* 0x76 */ 4231/* File: x86/OP_INVOKE_DIRECT_RANGE.S */ 4232/* File: x86/OP_INVOKE_DIRECT.S */ 4233 /* 4234 * Handle a direct method call. 4235 * 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.) 4240 * 4241 * for: invoke-direct, invoke-direct/range 4242 */ 4243 /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ 4244 /* op {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ 4245 movl rSELF,%ecx 4246 movzwl 2(rPC),%eax # eax<- BBBB 4247 movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex 4248 EXPORT_PC 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 4252 .if (!1) 4253 andl $0xf,rIBASE # rIBASE<- D (or stays CCCC) 4254 .endif 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 4262 4263 /* 4264 * On entry: 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. 4268 */ 4269.LOP_INVOKE_DIRECT_RANGE_resolve: 4270 SPILL_TMP1(%ecx) 4271 movl rSELF,%ecx 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) 4279 UNSPILL_TMP1(%ecx) 4280 testl %eax,%eax 4281 jne .LOP_INVOKE_DIRECT_RANGE_finish 4282 jmp common_exceptionThrown 4283 4284 4285/* ------------------------------ */ 4286.L_OP_INVOKE_STATIC_RANGE: /* 0x77 */ 4287/* File: x86/OP_INVOKE_STATIC_RANGE.S */ 4288/* File: x86/OP_INVOKE_STATIC.S */ 4289 /* 4290 * Handle a static method call. 4291 * 4292 * for: invoke-static, invoke-static/range 4293 */ 4294 /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ 4295 /* op {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ 4296 movl rSELF,%ecx 4297 movzwl 2(rPC),%eax # eax<- BBBB 4298 movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex 4299 EXPORT_PC 4300 movl offDvmDex_pResMethods(%ecx),%ecx # ecx<- pDvmDex->pResMethods 4301 movl (%ecx,%eax,4),%eax # eax<- resolved methodToCall 4302 testl %eax,%eax 4303 jne common_invokeMethodRange 4304 movl rSELF,%ecx 4305 movl offThread_method(%ecx),%ecx # ecx<- self->method 4306 movzwl 2(rPC),%eax 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 4316 4317 4318/* ------------------------------ */ 4319.L_OP_INVOKE_INTERFACE_RANGE: /* 0x78 */ 4320/* File: x86/OP_INVOKE_INTERFACE_RANGE.S */ 4321/* File: x86/OP_INVOKE_INTERFACE.S */ 4322 /* 4323 * Handle an interface method call. 4324 * 4325 * for: invoke-interface, invoke-interface/range 4326 */ 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 4330 movl rSELF,%ecx 4331 .if (!1) 4332 andl $0xf,%eax # eax<- C (or stays CCCC) 4333 .endif 4334 GET_VREG_R %eax %eax # eax<- "this" 4335 EXPORT_PC 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) 4347 testl %eax,%eax 4348 je common_exceptionThrown 4349 jmp common_invokeMethodRange 4350 4351 4352/* ------------------------------ */ 4353.L_OP_UNUSED_79: /* 0x79 */ 4354/* File: x86/OP_UNUSED_79.S */ 4355/* File: x86/unused.S */ 4356 jmp common_abort 4357 4358 4359/* ------------------------------ */ 4360.L_OP_UNUSED_7A: /* 0x7a */ 4361/* File: x86/OP_UNUSED_7A.S */ 4362/* File: x86/unused.S */ 4363 jmp common_abort 4364 4365 4366/* ------------------------------ */ 4367.L_OP_NEG_INT: /* 0x7b */ 4368/* File: x86/OP_NEG_INT.S */ 4369/* File: x86/unop.S */ 4370 /* 4371 * Generic 32-bit unary operation. Provide an "instr" line that 4372 * specifies an instruction that performs "result = op eax". 4373 */ 4374 /* unop vA, vB */ 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 4379 4380 4381 negl %eax 4382 SET_VREG %eax %ecx 4383 FETCH_INST_OPCODE 1 %ecx 4384 ADVANCE_PC 1 4385 GOTO_NEXT_R %ecx 4386 4387 4388/* ------------------------------ */ 4389.L_OP_NOT_INT: /* 0x7c */ 4390/* File: x86/OP_NOT_INT.S */ 4391/* File: x86/unop.S */ 4392 /* 4393 * Generic 32-bit unary operation. Provide an "instr" line that 4394 * specifies an instruction that performs "result = op eax". 4395 */ 4396 /* unop vA, vB */ 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 4401 4402 4403 notl %eax 4404 SET_VREG %eax %ecx 4405 FETCH_INST_OPCODE 1 %ecx 4406 ADVANCE_PC 1 4407 GOTO_NEXT_R %ecx 4408 4409 4410/* ------------------------------ */ 4411.L_OP_NEG_LONG: /* 0x7d */ 4412/* File: x86/OP_NEG_LONG.S */ 4413 /* unop vA, vB */ 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] 4419 negl %eax 4420 adcl $0,%ecx 4421 negl %ecx 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 4425 ADVANCE_PC 1 4426 GOTO_NEXT_R %eax 4427 4428/* ------------------------------ */ 4429.L_OP_NOT_LONG: /* 0x7e */ 4430/* File: x86/OP_NOT_LONG.S */ 4431 /* unop vA, vB */ 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] 4437 notl %eax 4438 notl %ecx 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 4442 ADVANCE_PC 1 4443 GOTO_NEXT_R %eax 4444 4445/* ------------------------------ */ 4446.L_OP_NEG_FLOAT: /* 0x7f */ 4447/* File: x86/OP_NEG_FLOAT.S */ 4448/* File: x86/fpcvt.S */ 4449 /* 4450 * Generic 32-bit FP conversion operation. 4451 */ 4452 /* unop vA, vB */ 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 4457 fchs 4458 fstps (rFP,%ecx,4) # vA<- %st0 4459 FETCH_INST_OPCODE 1 %ecx 4460 ADVANCE_PC 1 4461 GOTO_NEXT_R %ecx 4462 4463 4464/* ------------------------------ */ 4465.L_OP_NEG_DOUBLE: /* 0x80 */ 4466/* File: x86/OP_NEG_DOUBLE.S */ 4467/* File: x86/fpcvt.S */ 4468 /* 4469 * Generic 32-bit FP conversion operation. 4470 */ 4471 /* unop vA, vB */ 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 4476 fchs 4477 fstpl (rFP,%ecx,4) # vA<- %st0 4478 FETCH_INST_OPCODE 1 %ecx 4479 ADVANCE_PC 1 4480 GOTO_NEXT_R %ecx 4481 4482 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 4495 UNSPILL(rIBASE) 4496 SET_VREG_WORD %eax rINST 0 # v[A+0]<- %eax 4497 ADVANCE_PC 1 4498 GOTO_NEXT_R %ecx 4499 4500/* ------------------------------ */ 4501.L_OP_INT_TO_FLOAT: /* 0x82 */ 4502/* File: x86/OP_INT_TO_FLOAT.S */ 4503/* File: x86/fpcvt.S */ 4504 /* 4505 * Generic 32-bit FP conversion operation. 4506 */ 4507 /* unop vA, vB */ 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 4512 4513 fstps (rFP,%ecx,4) # vA<- %st0 4514 FETCH_INST_OPCODE 1 %ecx 4515 ADVANCE_PC 1 4516 GOTO_NEXT_R %ecx 4517 4518 4519/* ------------------------------ */ 4520.L_OP_INT_TO_DOUBLE: /* 0x83 */ 4521/* File: x86/OP_INT_TO_DOUBLE.S */ 4522/* File: x86/fpcvt.S */ 4523 /* 4524 * Generic 32-bit FP conversion operation. 4525 */ 4526 /* unop vA, vB */ 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 4531 4532 fstpl (rFP,%ecx,4) # vA<- %st0 4533 FETCH_INST_OPCODE 1 %ecx 4534 ADVANCE_PC 1 4535 GOTO_NEXT_R %ecx 4536 4537 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 */ 4544 /* op vA, vB */ 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 4550 ADVANCE_PC 1 4551 SET_VREG rINST %eax # fp[A]<-fp[B] 4552 GOTO_NEXT_R %ecx 4553 4554 4555/* ------------------------------ */ 4556.L_OP_LONG_TO_FLOAT: /* 0x85 */ 4557/* File: x86/OP_LONG_TO_FLOAT.S */ 4558/* File: x86/fpcvt.S */ 4559 /* 4560 * Generic 32-bit FP conversion operation. 4561 */ 4562 /* unop vA, vB */ 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 4567 4568 fstps (rFP,%ecx,4) # vA<- %st0 4569 FETCH_INST_OPCODE 1 %ecx 4570 ADVANCE_PC 1 4571 GOTO_NEXT_R %ecx 4572 4573 4574/* ------------------------------ */ 4575.L_OP_LONG_TO_DOUBLE: /* 0x86 */ 4576/* File: x86/OP_LONG_TO_DOUBLE.S */ 4577/* File: x86/fpcvt.S */ 4578 /* 4579 * Generic 32-bit FP conversion operation. 4580 */ 4581 /* unop vA, vB */ 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 4586 4587 fstpl (rFP,%ecx,4) # vA<- %st0 4588 FETCH_INST_OPCODE 1 %ecx 4589 ADVANCE_PC 1 4590 GOTO_NEXT_R %ecx 4591 4592 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. 4603 */ 4604 /* float/double to int/long vA, vB */ 4605 movzbl rINSTbl,%ecx # ecx<- A+ 4606 sarl $4,rINST # rINST<- B 4607 .if 0 4608 fldl (rFP,rINST,4) # %st0<- vB 4609 .else 4610 flds (rFP,rINST,4) # %st0<- vB 4611 .endif 4612 ftst 4613 fnstcw LOCAL0_OFFSET(%ebp) # remember original rounding mode 4614 movzwl LOCAL0_OFFSET(%ebp),%eax 4615 movb $0xc,%ah 4616 movw %ax,LOCAL0_OFFSET+2(%ebp) 4617 fldcw LOCAL0_OFFSET+2(%ebp) # set "to zero" rounding mode 4618 andb $0xf,%cl # ecx<- A 4619 .if 0 4620 fistpll (rFP,%ecx,4) # convert and store 4621 .else 4622 fistpl (rFP,%ecx,4) # convert and store 4623 .endif 4624 fldcw LOCAL0_OFFSET(%ebp) # restore previous rounding mode 4625 .if 0 4626 movl $0x80000000,%eax 4627 xorl 4(rFP,%ecx,4),%eax 4628 orl (rFP,%ecx,4),%eax 4629 .else 4630 cmpl $0x80000000,(rFP,%ecx,4) 4631 .endif 4632 je .LOP_FLOAT_TO_INT_special_case # fix up result 4633 4634.LOP_FLOAT_TO_INT_finish: 4635 FETCH_INST_OPCODE 1 %ecx 4636 ADVANCE_PC 1 4637 GOTO_NEXT_R %ecx 4638 4639.LOP_FLOAT_TO_INT_special_case: 4640 fnstsw %ax 4641 sahf 4642 jp .LOP_FLOAT_TO_INT_isNaN 4643 adcl $-1,(rFP,%ecx,4) 4644 .if 0 4645 adcl $-1,4(rFP,%ecx,4) 4646 .endif 4647 jmp .LOP_FLOAT_TO_INT_finish 4648.LOP_FLOAT_TO_INT_isNaN: 4649 movl $0,(rFP,%ecx,4) 4650 .if 0 4651 movl $0,4(rFP,%ecx,4) 4652 .endif 4653 jmp .LOP_FLOAT_TO_INT_finish 4654 4655 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. 4666 */ 4667 /* float/double to int/long vA, vB */ 4668 movzbl rINSTbl,%ecx # ecx<- A+ 4669 sarl $4,rINST # rINST<- B 4670 .if 0 4671 fldl (rFP,rINST,4) # %st0<- vB 4672 .else 4673 flds (rFP,rINST,4) # %st0<- vB 4674 .endif 4675 ftst 4676 fnstcw LOCAL0_OFFSET(%ebp) # remember original rounding mode 4677 movzwl LOCAL0_OFFSET(%ebp),%eax 4678 movb $0xc,%ah 4679 movw %ax,LOCAL0_OFFSET+2(%ebp) 4680 fldcw LOCAL0_OFFSET+2(%ebp) # set "to zero" rounding mode 4681 andb $0xf,%cl # ecx<- A 4682 .if 1 4683 fistpll (rFP,%ecx,4) # convert and store 4684 .else 4685 fistpl (rFP,%ecx,4) # convert and store 4686 .endif 4687 fldcw LOCAL0_OFFSET(%ebp) # restore previous rounding mode 4688 .if 1 4689 movl $0x80000000,%eax 4690 xorl 4(rFP,%ecx,4),%eax 4691 orl (rFP,%ecx,4),%eax 4692 .else 4693 cmpl $0x80000000,(rFP,%ecx,4) 4694 .endif 4695 je .LOP_FLOAT_TO_LONG_special_case # fix up result 4696 4697.LOP_FLOAT_TO_LONG_finish: 4698 FETCH_INST_OPCODE 1 %ecx 4699 ADVANCE_PC 1 4700 GOTO_NEXT_R %ecx 4701 4702.LOP_FLOAT_TO_LONG_special_case: 4703 fnstsw %ax 4704 sahf 4705 jp .LOP_FLOAT_TO_LONG_isNaN 4706 adcl $-1,(rFP,%ecx,4) 4707 .if 1 4708 adcl $-1,4(rFP,%ecx,4) 4709 .endif 4710 jmp .LOP_FLOAT_TO_LONG_finish 4711.LOP_FLOAT_TO_LONG_isNaN: 4712 movl $0,(rFP,%ecx,4) 4713 .if 1 4714 movl $0,4(rFP,%ecx,4) 4715 .endif 4716 jmp .LOP_FLOAT_TO_LONG_finish 4717 4718 4719/* ------------------------------ */ 4720.L_OP_FLOAT_TO_DOUBLE: /* 0x89 */ 4721/* File: x86/OP_FLOAT_TO_DOUBLE.S */ 4722/* File: x86/fpcvt.S */ 4723 /* 4724 * Generic 32-bit FP conversion operation. 4725 */ 4726 /* unop vA, vB */ 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 4731 4732 fstpl (rFP,%ecx,4) # vA<- %st0 4733 FETCH_INST_OPCODE 1 %ecx 4734 ADVANCE_PC 1 4735 GOTO_NEXT_R %ecx 4736 4737 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. 4748 */ 4749 /* float/double to int/long vA, vB */ 4750 movzbl rINSTbl,%ecx # ecx<- A+ 4751 sarl $4,rINST # rINST<- B 4752 .if 1 4753 fldl (rFP,rINST,4) # %st0<- vB 4754 .else 4755 flds (rFP,rINST,4) # %st0<- vB 4756 .endif 4757 ftst 4758 fnstcw LOCAL0_OFFSET(%ebp) # remember original rounding mode 4759 movzwl LOCAL0_OFFSET(%ebp),%eax 4760 movb $0xc,%ah 4761 movw %ax,LOCAL0_OFFSET+2(%ebp) 4762 fldcw LOCAL0_OFFSET+2(%ebp) # set "to zero" rounding mode 4763 andb $0xf,%cl # ecx<- A 4764 .if 0 4765 fistpll (rFP,%ecx,4) # convert and store 4766 .else 4767 fistpl (rFP,%ecx,4) # convert and store 4768 .endif 4769 fldcw LOCAL0_OFFSET(%ebp) # restore previous rounding mode 4770 .if 0 4771 movl $0x80000000,%eax 4772 xorl 4(rFP,%ecx,4),%eax 4773 orl (rFP,%ecx,4),%eax 4774 .else 4775 cmpl $0x80000000,(rFP,%ecx,4) 4776 .endif 4777 je .LOP_DOUBLE_TO_INT_special_case # fix up result 4778 4779.LOP_DOUBLE_TO_INT_finish: 4780 FETCH_INST_OPCODE 1 %ecx 4781 ADVANCE_PC 1 4782 GOTO_NEXT_R %ecx 4783 4784.LOP_DOUBLE_TO_INT_special_case: 4785 fnstsw %ax 4786 sahf 4787 jp .LOP_DOUBLE_TO_INT_isNaN 4788 adcl $-1,(rFP,%ecx,4) 4789 .if 0 4790 adcl $-1,4(rFP,%ecx,4) 4791 .endif 4792 jmp .LOP_DOUBLE_TO_INT_finish 4793.LOP_DOUBLE_TO_INT_isNaN: 4794 movl $0,(rFP,%ecx,4) 4795 .if 0 4796 movl $0,4(rFP,%ecx,4) 4797 .endif 4798 jmp .LOP_DOUBLE_TO_INT_finish 4799 4800 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. 4811 */ 4812 /* float/double to int/long vA, vB */ 4813 movzbl rINSTbl,%ecx # ecx<- A+ 4814 sarl $4,rINST # rINST<- B 4815 .if 1 4816 fldl (rFP,rINST,4) # %st0<- vB 4817 .else 4818 flds (rFP,rINST,4) # %st0<- vB 4819 .endif 4820 ftst 4821 fnstcw LOCAL0_OFFSET(%ebp) # remember original rounding mode 4822 movzwl LOCAL0_OFFSET(%ebp),%eax 4823 movb $0xc,%ah 4824 movw %ax,LOCAL0_OFFSET+2(%ebp) 4825 fldcw LOCAL0_OFFSET+2(%ebp) # set "to zero" rounding mode 4826 andb $0xf,%cl # ecx<- A 4827 .if 1 4828 fistpll (rFP,%ecx,4) # convert and store 4829 .else 4830 fistpl (rFP,%ecx,4) # convert and store 4831 .endif 4832 fldcw LOCAL0_OFFSET(%ebp) # restore previous rounding mode 4833 .if 1 4834 movl $0x80000000,%eax 4835 xorl 4(rFP,%ecx,4),%eax 4836 orl (rFP,%ecx,4),%eax 4837 .else 4838 cmpl $0x80000000,(rFP,%ecx,4) 4839 .endif 4840 je .LOP_DOUBLE_TO_LONG_special_case # fix up result 4841 4842.LOP_DOUBLE_TO_LONG_finish: 4843 FETCH_INST_OPCODE 1 %ecx 4844 ADVANCE_PC 1 4845 GOTO_NEXT_R %ecx 4846 4847.LOP_DOUBLE_TO_LONG_special_case: 4848 fnstsw %ax 4849 sahf 4850 jp .LOP_DOUBLE_TO_LONG_isNaN 4851 adcl $-1,(rFP,%ecx,4) 4852 .if 1 4853 adcl $-1,4(rFP,%ecx,4) 4854 .endif 4855 jmp .LOP_DOUBLE_TO_LONG_finish 4856.LOP_DOUBLE_TO_LONG_isNaN: 4857 movl $0,(rFP,%ecx,4) 4858 .if 1 4859 movl $0,4(rFP,%ecx,4) 4860 .endif 4861 jmp .LOP_DOUBLE_TO_LONG_finish 4862 4863 4864/* ------------------------------ */ 4865.L_OP_DOUBLE_TO_FLOAT: /* 0x8c */ 4866/* File: x86/OP_DOUBLE_TO_FLOAT.S */ 4867/* File: x86/fpcvt.S */ 4868 /* 4869 * Generic 32-bit FP conversion operation. 4870 */ 4871 /* unop vA, vB */ 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 4876 4877 fstps (rFP,%ecx,4) # vA<- %st0 4878 FETCH_INST_OPCODE 1 %ecx 4879 ADVANCE_PC 1 4880 GOTO_NEXT_R %ecx 4881 4882 4883/* ------------------------------ */ 4884.L_OP_INT_TO_BYTE: /* 0x8d */ 4885/* File: x86/OP_INT_TO_BYTE.S */ 4886/* File: x86/unop.S */ 4887 /* 4888 * Generic 32-bit unary operation. Provide an "instr" line that 4889 * specifies an instruction that performs "result = op eax". 4890 */ 4891 /* unop vA, vB */ 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 4896 4897 4898 movsbl %al,%eax 4899 SET_VREG %eax %ecx 4900 FETCH_INST_OPCODE 1 %ecx 4901 ADVANCE_PC 1 4902 GOTO_NEXT_R %ecx 4903 4904 4905/* ------------------------------ */ 4906.L_OP_INT_TO_CHAR: /* 0x8e */ 4907/* File: x86/OP_INT_TO_CHAR.S */ 4908/* File: x86/unop.S */ 4909 /* 4910 * Generic 32-bit unary operation. Provide an "instr" line that 4911 * specifies an instruction that performs "result = op eax". 4912 */ 4913 /* unop vA, vB */ 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 4918 4919 4920 movzwl %ax,%eax 4921 SET_VREG %eax %ecx 4922 FETCH_INST_OPCODE 1 %ecx 4923 ADVANCE_PC 1 4924 GOTO_NEXT_R %ecx 4925 4926 4927/* ------------------------------ */ 4928.L_OP_INT_TO_SHORT: /* 0x8f */ 4929/* File: x86/OP_INT_TO_SHORT.S */ 4930/* File: x86/unop.S */ 4931 /* 4932 * Generic 32-bit unary operation. Provide an "instr" line that 4933 * specifies an instruction that performs "result = op eax". 4934 */ 4935 /* unop vA, vB */ 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 4940 4941 4942 movswl %ax,%eax 4943 SET_VREG %eax %ecx 4944 FETCH_INST_OPCODE 1 %ecx 4945 ADVANCE_PC 1 4946 GOTO_NEXT_R %ecx 4947 4948 4949/* ------------------------------ */ 4950.L_OP_ADD_INT: /* 0x90 */ 4951/* File: x86/OP_ADD_INT.S */ 4952/* File: x86/binop.S */ 4953 /* 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".) 4958 * 4959 * For: add-int, sub-int, and-int, or-int, 4960 * xor-int, shl-int, shr-int, ushr-int 4961 */ 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 4967 SET_VREG %eax rINST 4968 FETCH_INST_OPCODE 2 %ecx 4969 ADVANCE_PC 2 4970 GOTO_NEXT_R %ecx 4971 4972 4973/* ------------------------------ */ 4974.L_OP_SUB_INT: /* 0x91 */ 4975/* File: x86/OP_SUB_INT.S */ 4976/* File: x86/binop.S */ 4977 /* 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".) 4982 * 4983 * For: add-int, sub-int, and-int, or-int, 4984 * xor-int, shl-int, shr-int, ushr-int 4985 */ 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 4991 SET_VREG %eax rINST 4992 FETCH_INST_OPCODE 2 %ecx 4993 ADVANCE_PC 2 4994 GOTO_NEXT_R %ecx 4995 4996 4997/* ------------------------------ */ 4998.L_OP_MUL_INT: /* 0x92 */ 4999/* File: x86/OP_MUL_INT.S */ 5000 /* 5001 * 32-bit binary multiplication. 5002 */ 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 5007 SPILL(rIBASE) 5008 imull (rFP,%ecx,4),%eax # trashes rIBASE/edx 5009 UNSPILL(rIBASE) 5010 FETCH_INST_OPCODE 2 %ecx 5011 ADVANCE_PC 2 5012 SET_VREG %eax rINST 5013 GOTO_NEXT_R %ecx 5014 5015/* ------------------------------ */ 5016.L_OP_DIV_INT: /* 0x93 */ 5017/* File: x86/OP_DIV_INT.S */ 5018/* File: x86/bindiv.S */ 5019 5020 /* 5021 * 32-bit binary div/rem operation. Handles special case of op0=minint and 5022 * op1=-1. 5023 */ 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 5029 SPILL(rIBASE) 5030 cmpl $0,%ecx 5031 je common_errDivideByZero 5032 cmpl $-1,%ecx 5033 jne .LOP_DIV_INT_continue_div 5034 cmpl $0x80000000,%eax 5035 jne .LOP_DIV_INT_continue_div 5036 movl $0x80000000,%eax 5037 SET_VREG %eax rINST 5038 UNSPILL(rIBASE) 5039 FETCH_INST_OPCODE 2 %ecx 5040 ADVANCE_PC 2 5041 GOTO_NEXT_R %ecx 5042 5043.LOP_DIV_INT_continue_div: 5044 cltd 5045 idivl %ecx 5046 SET_VREG %eax rINST 5047 UNSPILL(rIBASE) 5048 FETCH_INST_OPCODE 2 %ecx 5049 ADVANCE_PC 2 5050 GOTO_NEXT_R %ecx 5051 5052 5053/* ------------------------------ */ 5054.L_OP_REM_INT: /* 0x94 */ 5055/* File: x86/OP_REM_INT.S */ 5056/* File: x86/bindiv.S */ 5057 5058 /* 5059 * 32-bit binary div/rem operation. Handles special case of op0=minint and 5060 * op1=-1. 5061 */ 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 5067 SPILL(rIBASE) 5068 cmpl $0,%ecx 5069 je common_errDivideByZero 5070 cmpl $-1,%ecx 5071 jne .LOP_REM_INT_continue_div 5072 cmpl $0x80000000,%eax 5073 jne .LOP_REM_INT_continue_div 5074 movl $0,rIBASE 5075 SET_VREG rIBASE rINST 5076 UNSPILL(rIBASE) 5077 FETCH_INST_OPCODE 2 %ecx 5078 ADVANCE_PC 2 5079 GOTO_NEXT_R %ecx 5080 5081.LOP_REM_INT_continue_div: 5082 cltd 5083 idivl %ecx 5084 SET_VREG rIBASE rINST 5085 UNSPILL(rIBASE) 5086 FETCH_INST_OPCODE 2 %ecx 5087 ADVANCE_PC 2 5088 GOTO_NEXT_R %ecx 5089 5090 5091/* ------------------------------ */ 5092.L_OP_AND_INT: /* 0x95 */ 5093/* File: x86/OP_AND_INT.S */ 5094/* File: x86/binop.S */ 5095 /* 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".) 5100 * 5101 * For: add-int, sub-int, and-int, or-int, 5102 * xor-int, shl-int, shr-int, ushr-int 5103 */ 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 5109 SET_VREG %eax rINST 5110 FETCH_INST_OPCODE 2 %ecx 5111 ADVANCE_PC 2 5112 GOTO_NEXT_R %ecx 5113 5114 5115/* ------------------------------ */ 5116.L_OP_OR_INT: /* 0x96 */ 5117/* File: x86/OP_OR_INT.S */ 5118/* File: x86/binop.S */ 5119 /* 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".) 5124 * 5125 * For: add-int, sub-int, and-int, or-int, 5126 * xor-int, shl-int, shr-int, ushr-int 5127 */ 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 5133 SET_VREG %eax rINST 5134 FETCH_INST_OPCODE 2 %ecx 5135 ADVANCE_PC 2 5136 GOTO_NEXT_R %ecx 5137 5138 5139/* ------------------------------ */ 5140.L_OP_XOR_INT: /* 0x97 */ 5141/* File: x86/OP_XOR_INT.S */ 5142/* File: x86/binop.S */ 5143 /* 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".) 5148 * 5149 * For: add-int, sub-int, and-int, or-int, 5150 * xor-int, shl-int, shr-int, ushr-int 5151 */ 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 5157 SET_VREG %eax rINST 5158 FETCH_INST_OPCODE 2 %ecx 5159 ADVANCE_PC 2 5160 GOTO_NEXT_R %ecx 5161 5162 5163/* ------------------------------ */ 5164.L_OP_SHL_INT: /* 0x98 */ 5165/* File: x86/OP_SHL_INT.S */ 5166/* File: x86/binop1.S */ 5167 /* 5168 * Generic 32-bit binary operation in which both operands loaded to 5169 * registers (op0 in eax, op1 in ecx). 5170 */ 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 5177 SET_VREG %eax rINST 5178 FETCH_INST_OPCODE 2 %ecx 5179 ADVANCE_PC 2 5180 GOTO_NEXT_R %ecx 5181 5182 5183/* ------------------------------ */ 5184.L_OP_SHR_INT: /* 0x99 */ 5185/* File: x86/OP_SHR_INT.S */ 5186/* File: x86/binop1.S */ 5187 /* 5188 * Generic 32-bit binary operation in which both operands loaded to 5189 * registers (op0 in eax, op1 in ecx). 5190 */ 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 5197 SET_VREG %eax rINST 5198 FETCH_INST_OPCODE 2 %ecx 5199 ADVANCE_PC 2 5200 GOTO_NEXT_R %ecx 5201 5202 5203/* ------------------------------ */ 5204.L_OP_USHR_INT: /* 0x9a */ 5205/* File: x86/OP_USHR_INT.S */ 5206/* File: x86/binop1.S */ 5207 /* 5208 * Generic 32-bit binary operation in which both operands loaded to 5209 * registers (op0 in eax, op1 in ecx). 5210 */ 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 5217 SET_VREG %eax rINST 5218 FETCH_INST_OPCODE 2 %ecx 5219 ADVANCE_PC 2 5220 GOTO_NEXT_R %ecx 5221 5222 5223/* ------------------------------ */ 5224.L_OP_ADD_LONG: /* 0x9b */ 5225/* File: x86/OP_ADD_LONG.S */ 5226/* File: x86/binopWide.S */ 5227 /* 5228 * Generic 64-bit binary operation. 5229 */ 5230 /* binop vAA, vBB, vCC */ 5231 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 5243 ADVANCE_PC 2 5244 GOTO_NEXT_R %ecx 5245 5246 5247/* ------------------------------ */ 5248.L_OP_SUB_LONG: /* 0x9c */ 5249/* File: x86/OP_SUB_LONG.S */ 5250/* File: x86/binopWide.S */ 5251 /* 5252 * Generic 64-bit binary operation. 5253 */ 5254 /* binop vAA, vBB, vCC */ 5255 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 5267 ADVANCE_PC 2 5268 GOTO_NEXT_R %ecx 5269 5270 5271/* ------------------------------ */ 5272.L_OP_MUL_LONG: /* 0x9d */ 5273/* File: x86/OP_MUL_LONG.S */ 5274 /* 5275 * Signed 64-bit integer multiply. 5276 * 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. 5283 */ 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 5288 SPILL(rFP) 5289 SPILL(rINST) 5290 SPILL(rIBASE) 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) 5300 UNSPILL(rINST) 5301 UNSPILL(rFP) 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 5306 UNSPILL(rIBASE) 5307 movl %eax,(rFP,rINST,4) # v[B]<- %eax 5308 ADVANCE_PC 2 5309 GOTO_NEXT_R %ecx 5310 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) 5321 testl %eax,%eax 5322 je .LOP_DIV_LONG_check_zero 5323 cmpl $-1,%eax 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) 5332 call __divdi3 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 5338 ADVANCE_PC 2 5339 GOTO_NEXT_R %ecx 5340 5341.LOP_DIV_LONG_check_zero: 5342 testl rIBASE,rIBASE 5343 jne .LOP_DIV_LONG_notSpecial 5344 jmp common_errDivideByZero 5345.LOP_DIV_LONG_check_neg1: 5346 testl rIBASE,%eax 5347 jne .LOP_DIV_LONG_notSpecial 5348 GET_VREG_WORD rIBASE %ecx 0 5349 GET_VREG_WORD %ecx %ecx 1 5350 testl rIBASE,rIBASE 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 */ 5355 xorl %eax,%eax 5356 movl $0x80000000,rIBASE 5357 jmp .LOP_DIV_LONG_finish 5358 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) 5370 testl %eax,%eax 5371 je .LOP_REM_LONG_check_zero 5372 cmpl $-1,%eax 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) 5381 call __moddi3 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 5387 ADVANCE_PC 2 5388 GOTO_NEXT_R %ecx 5389 5390.LOP_REM_LONG_check_zero: 5391 testl rIBASE,rIBASE 5392 jne .LOP_REM_LONG_notSpecial 5393 jmp common_errDivideByZero 5394.LOP_REM_LONG_check_neg1: 5395 testl rIBASE,%eax 5396 jne .LOP_REM_LONG_notSpecial 5397 GET_VREG_WORD rIBASE %ecx 0 5398 GET_VREG_WORD %ecx %ecx 1 5399 testl rIBASE,rIBASE 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 */ 5404 xorl %eax,%eax 5405 movl $0,rIBASE 5406 jmp .LOP_REM_LONG_finish 5407 5408 5409/* ------------------------------ */ 5410.L_OP_AND_LONG: /* 0xa0 */ 5411/* File: x86/OP_AND_LONG.S */ 5412/* File: x86/binopWide.S */ 5413 /* 5414 * Generic 64-bit binary operation. 5415 */ 5416 /* binop vAA, vBB, vCC */ 5417 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 5429 ADVANCE_PC 2 5430 GOTO_NEXT_R %ecx 5431 5432 5433/* ------------------------------ */ 5434.L_OP_OR_LONG: /* 0xa1 */ 5435/* File: x86/OP_OR_LONG.S */ 5436/* File: x86/binopWide.S */ 5437 /* 5438 * Generic 64-bit binary operation. 5439 */ 5440 /* binop vAA, vBB, vCC */ 5441 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 5453 ADVANCE_PC 2 5454 GOTO_NEXT_R %ecx 5455 5456 5457/* ------------------------------ */ 5458.L_OP_XOR_LONG: /* 0xa2 */ 5459/* File: x86/OP_XOR_LONG.S */ 5460/* File: x86/binopWide.S */ 5461 /* 5462 * Generic 64-bit binary operation. 5463 */ 5464 /* binop vAA, vBB, vCC */ 5465 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 5477 ADVANCE_PC 2 5478 GOTO_NEXT_R %ecx 5479 5480 5481/* ------------------------------ */ 5482.L_OP_SHL_LONG: /* 0xa3 */ 5483/* File: x86/OP_SHL_LONG.S */ 5484 /* 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 5490 * case specially. 5491 */ 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 5498 SPILL(rIBASE) 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] 5502 shldl %eax,rIBASE 5503 sall %cl,%eax 5504 testb $32,%cl 5505 je 2f 5506 movl %eax,rIBASE 5507 xorl %eax,%eax 55082: 5509 SET_VREG_WORD rIBASE rINST 1 # v[AA+1]<- rIBASE 5510 FETCH_INST_OPCODE 2 %ecx 5511 UNSPILL(rIBASE) 5512 SET_VREG_WORD %eax rINST 0 # v[AA+0]<- %eax 5513 ADVANCE_PC 2 5514 GOTO_NEXT_R %ecx 5515 5516/* ------------------------------ */ 5517.L_OP_SHR_LONG: /* 0xa4 */ 5518/* File: x86/OP_SHR_LONG.S */ 5519 /* 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 5525 * case specially. 5526 */ 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 5533 SPILL(rIBASE) 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] 5537 shrdl rIBASE,%eax 5538 sarl %cl,rIBASE 5539 testb $32,%cl 5540 je 2f 5541 movl rIBASE,%eax 5542 sarl $31,rIBASE 55432: 5544 SET_VREG_WORD rIBASE rINST 1 # v[AA+1]<- rIBASE 5545 FETCH_INST_OPCODE 2 %ecx 5546 UNSPILL(rIBASE) 5547 SET_VREG_WORD %eax rINST 0 # v[AA+0]<- eax 5548 ADVANCE_PC 2 5549 GOTO_NEXT_R %ecx 5550 5551/* ------------------------------ */ 5552.L_OP_USHR_LONG: /* 0xa5 */ 5553/* File: x86/OP_USHR_LONG.S */ 5554 /* 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 5560 * case specially. 5561 */ 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 5568 SPILL(rIBASE) 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] 5572 shrdl rIBASE,%eax 5573 shrl %cl,rIBASE 5574 testb $32,%cl 5575 je 2f 5576 movl rIBASE,%eax 5577 xorl rIBASE,rIBASE 55782: 5579 SET_VREG_WORD rIBASE rINST 1 # v[AA+1]<- rIBASE 5580 FETCH_INST_OPCODE 2 %ecx 5581 UNSPILL(rIBASE) 5582 SET_VREG_WORD %eax rINST 0 # v[BB+0]<- eax 5583 ADVANCE_PC 2 5584 GOTO_NEXT_R %ecx 5585 5586/* ------------------------------ */ 5587.L_OP_ADD_FLOAT: /* 0xa6 */ 5588/* File: x86/OP_ADD_FLOAT.S */ 5589/* File: x86/binflop.S */ 5590 /* 5591 * Generic 32-bit binary float operation. 5592 * 5593 * For: add-fp, sub-fp, mul-fp, div-fp 5594 */ 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 5601 ADVANCE_PC 2 5602 fstps (rFP,rINST,4) # %st to vAA 5603 GOTO_NEXT_R %ecx 5604 5605 5606/* ------------------------------ */ 5607.L_OP_SUB_FLOAT: /* 0xa7 */ 5608/* File: x86/OP_SUB_FLOAT.S */ 5609/* File: x86/binflop.S */ 5610 /* 5611 * Generic 32-bit binary float operation. 5612 * 5613 * For: add-fp, sub-fp, mul-fp, div-fp 5614 */ 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 5621 ADVANCE_PC 2 5622 fstps (rFP,rINST,4) # %st to vAA 5623 GOTO_NEXT_R %ecx 5624 5625 5626/* ------------------------------ */ 5627.L_OP_MUL_FLOAT: /* 0xa8 */ 5628/* File: x86/OP_MUL_FLOAT.S */ 5629/* File: x86/binflop.S */ 5630 /* 5631 * Generic 32-bit binary float operation. 5632 * 5633 * For: add-fp, sub-fp, mul-fp, div-fp 5634 */ 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 5641 ADVANCE_PC 2 5642 fstps (rFP,rINST,4) # %st to vAA 5643 GOTO_NEXT_R %ecx 5644 5645 5646/* ------------------------------ */ 5647.L_OP_DIV_FLOAT: /* 0xa9 */ 5648/* File: x86/OP_DIV_FLOAT.S */ 5649/* File: x86/binflop.S */ 5650 /* 5651 * Generic 32-bit binary float operation. 5652 * 5653 * For: add-fp, sub-fp, mul-fp, div-fp 5654 */ 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 5661 ADVANCE_PC 2 5662 fstps (rFP,rINST,4) # %st to vAA 5663 GOTO_NEXT_R %ecx 5664 5665 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 56751: 5676 fprem 5677 fstsw %ax 5678 sahf 5679 jp 1b 5680 fstp %st(1) 5681 FETCH_INST_OPCODE 2 %eax 5682 ADVANCE_PC 2 5683 fstps (rFP,%ecx,4) # %st to vAA 5684 GOTO_NEXT_R %eax 5685 5686/* ------------------------------ */ 5687.L_OP_ADD_DOUBLE: /* 0xab */ 5688/* File: x86/OP_ADD_DOUBLE.S */ 5689/* File: x86/binflop.S */ 5690 /* 5691 * Generic 32-bit binary float operation. 5692 * 5693 * For: add-fp, sub-fp, mul-fp, div-fp 5694 */ 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 5701 ADVANCE_PC 2 5702 fstpl (rFP,rINST,4) # %st to vAA 5703 GOTO_NEXT_R %ecx 5704 5705 5706/* ------------------------------ */ 5707.L_OP_SUB_DOUBLE: /* 0xac */ 5708/* File: x86/OP_SUB_DOUBLE.S */ 5709/* File: x86/binflop.S */ 5710 /* 5711 * Generic 32-bit binary float operation. 5712 * 5713 * For: add-fp, sub-fp, mul-fp, div-fp 5714 */ 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 5721 ADVANCE_PC 2 5722 fstpl (rFP,rINST,4) # %st to vAA 5723 GOTO_NEXT_R %ecx 5724 5725 5726/* ------------------------------ */ 5727.L_OP_MUL_DOUBLE: /* 0xad */ 5728/* File: x86/OP_MUL_DOUBLE.S */ 5729/* File: x86/binflop.S */ 5730 /* 5731 * Generic 32-bit binary float operation. 5732 * 5733 * For: add-fp, sub-fp, mul-fp, div-fp 5734 */ 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 5741 ADVANCE_PC 2 5742 fstpl (rFP,rINST,4) # %st to vAA 5743 GOTO_NEXT_R %ecx 5744 5745 5746/* ------------------------------ */ 5747.L_OP_DIV_DOUBLE: /* 0xae */ 5748/* File: x86/OP_DIV_DOUBLE.S */ 5749/* File: x86/binflop.S */ 5750 /* 5751 * Generic 32-bit binary float operation. 5752 * 5753 * For: add-fp, sub-fp, mul-fp, div-fp 5754 */ 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 5761 ADVANCE_PC 2 5762 fstpl (rFP,rINST,4) # %st to vAA 5763 GOTO_NEXT_R %ecx 5764 5765 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 57751: 5776 fprem 5777 fstsw %ax 5778 sahf 5779 jp 1b 5780 fstp %st(1) 5781 ADVANCE_PC 2 5782 fstpl (rFP,rINST,4) # %st to vAA 5783 GOTO_NEXT_R %ecx 5784 5785/* ------------------------------ */ 5786.L_OP_ADD_INT_2ADDR: /* 0xb0 */ 5787/* File: x86/OP_ADD_INT_2ADDR.S */ 5788/* File: x86/binop2addr.S */ 5789 /* 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".) 5794 * 5795 * If "chkzero" is set to 1, we perform a divide-by-zero check on 5796 * vCC (r1). Useful for integer division and modulus. 5797 * 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 5802 */ 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 5810 ADVANCE_PC 1 5811 GOTO_NEXT_R %ecx 5812 5813 5814/* ------------------------------ */ 5815.L_OP_SUB_INT_2ADDR: /* 0xb1 */ 5816/* File: x86/OP_SUB_INT_2ADDR.S */ 5817/* File: x86/binop2addr.S */ 5818 /* 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".) 5823 * 5824 * If "chkzero" is set to 1, we perform a divide-by-zero check on 5825 * vCC (r1). Useful for integer division and modulus. 5826 * 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 5831 */ 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 5839 ADVANCE_PC 1 5840 GOTO_NEXT_R %ecx 5841 5842 5843/* ------------------------------ */ 5844.L_OP_MUL_INT_2ADDR: /* 0xb2 */ 5845/* File: x86/OP_MUL_INT_2ADDR.S */ 5846 /* mul vA, vB */ 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 5851 SPILL(rIBASE) 5852 imull (rFP,%ecx,4),%eax # trashes rIBASE/edx 5853 UNSPILL(rIBASE) 5854 SET_VREG %eax %ecx 5855 FETCH_INST_OPCODE 1 %ecx 5856 ADVANCE_PC 1 5857 GOTO_NEXT_R %ecx 5858 5859/* ------------------------------ */ 5860.L_OP_DIV_INT_2ADDR: /* 0xb3 */ 5861/* File: x86/OP_DIV_INT_2ADDR.S */ 5862/* File: x86/bindiv2addr.S */ 5863 /* 5864 * 32-bit binary div/rem operation. Handles special case of op0=minint and 5865 * op1=-1. 5866 */ 5867 /* div/rem/2addr vA, vB */ 5868 movzx rINSTbl,%ecx # eax<- BA 5869 SPILL(rIBASE) 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 5874 cmpl $0,%ecx 5875 je common_errDivideByZero 5876 cmpl $-1,%ecx 5877 jne .LOP_DIV_INT_2ADDR_continue_div2addr 5878 cmpl $0x80000000,%eax 5879 jne .LOP_DIV_INT_2ADDR_continue_div2addr 5880 movl $0x80000000,%eax 5881 SET_VREG %eax rINST 5882 UNSPILL(rIBASE) 5883 FETCH_INST_OPCODE 1 %ecx 5884 ADVANCE_PC 1 5885 GOTO_NEXT_R %ecx 5886 5887.LOP_DIV_INT_2ADDR_continue_div2addr: 5888 cltd 5889 idivl %ecx 5890 SET_VREG %eax rINST 5891 UNSPILL(rIBASE) 5892 FETCH_INST_OPCODE 1 %ecx 5893 ADVANCE_PC 1 5894 GOTO_NEXT_R %ecx 5895 5896 5897/* ------------------------------ */ 5898.L_OP_REM_INT_2ADDR: /* 0xb4 */ 5899/* File: x86/OP_REM_INT_2ADDR.S */ 5900/* File: x86/bindiv2addr.S */ 5901 /* 5902 * 32-bit binary div/rem operation. Handles special case of op0=minint and 5903 * op1=-1. 5904 */ 5905 /* div/rem/2addr vA, vB */ 5906 movzx rINSTbl,%ecx # eax<- BA 5907 SPILL(rIBASE) 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 5912 cmpl $0,%ecx 5913 je common_errDivideByZero 5914 cmpl $-1,%ecx 5915 jne .LOP_REM_INT_2ADDR_continue_div2addr 5916 cmpl $0x80000000,%eax 5917 jne .LOP_REM_INT_2ADDR_continue_div2addr 5918 movl $0,rIBASE 5919 SET_VREG rIBASE rINST 5920 UNSPILL(rIBASE) 5921 FETCH_INST_OPCODE 1 %ecx 5922 ADVANCE_PC 1 5923 GOTO_NEXT_R %ecx 5924 5925.LOP_REM_INT_2ADDR_continue_div2addr: 5926 cltd 5927 idivl %ecx 5928 SET_VREG rIBASE rINST 5929 UNSPILL(rIBASE) 5930 FETCH_INST_OPCODE 1 %ecx 5931 ADVANCE_PC 1 5932 GOTO_NEXT_R %ecx 5933 5934 5935/* ------------------------------ */ 5936.L_OP_AND_INT_2ADDR: /* 0xb5 */ 5937/* File: x86/OP_AND_INT_2ADDR.S */ 5938/* File: x86/binop2addr.S */ 5939 /* 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".) 5944 * 5945 * If "chkzero" is set to 1, we perform a divide-by-zero check on 5946 * vCC (r1). Useful for integer division and modulus. 5947 * 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 5952 */ 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 5960 ADVANCE_PC 1 5961 GOTO_NEXT_R %ecx 5962 5963 5964/* ------------------------------ */ 5965.L_OP_OR_INT_2ADDR: /* 0xb6 */ 5966/* File: x86/OP_OR_INT_2ADDR.S */ 5967/* File: x86/binop2addr.S */ 5968 /* 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".) 5973 * 5974 * If "chkzero" is set to 1, we perform a divide-by-zero check on 5975 * vCC (r1). Useful for integer division and modulus. 5976 * 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 5981 */ 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 5989 ADVANCE_PC 1 5990 GOTO_NEXT_R %ecx 5991 5992 5993/* ------------------------------ */ 5994.L_OP_XOR_INT_2ADDR: /* 0xb7 */ 5995/* File: x86/OP_XOR_INT_2ADDR.S */ 5996/* File: x86/binop2addr.S */ 5997 /* 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".) 6002 * 6003 * If "chkzero" is set to 1, we perform a divide-by-zero check on 6004 * vCC (r1). Useful for integer division and modulus. 6005 * 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 6010 */ 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 6018 ADVANCE_PC 1 6019 GOTO_NEXT_R %ecx 6020 6021 6022/* ------------------------------ */ 6023.L_OP_SHL_INT_2ADDR: /* 0xb8 */ 6024/* File: x86/OP_SHL_INT_2ADDR.S */ 6025/* File: x86/shop2addr.S */ 6026 /* 6027 * Generic 32-bit "shift/2addr" operation. 6028 */ 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 6037 SET_VREG %eax rINST 6038 ADVANCE_PC 1 6039 GOTO_NEXT_R %ecx 6040 6041 6042/* ------------------------------ */ 6043.L_OP_SHR_INT_2ADDR: /* 0xb9 */ 6044/* File: x86/OP_SHR_INT_2ADDR.S */ 6045/* File: x86/shop2addr.S */ 6046 /* 6047 * Generic 32-bit "shift/2addr" operation. 6048 */ 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 6057 SET_VREG %eax rINST 6058 ADVANCE_PC 1 6059 GOTO_NEXT_R %ecx 6060 6061 6062/* ------------------------------ */ 6063.L_OP_USHR_INT_2ADDR: /* 0xba */ 6064/* File: x86/OP_USHR_INT_2ADDR.S */ 6065/* File: x86/shop2addr.S */ 6066 /* 6067 * Generic 32-bit "shift/2addr" operation. 6068 */ 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 6077 SET_VREG %eax rINST 6078 ADVANCE_PC 1 6079 GOTO_NEXT_R %ecx 6080 6081 6082/* ------------------------------ */ 6083.L_OP_ADD_LONG_2ADDR: /* 0xbb */ 6084/* File: x86/OP_ADD_LONG_2ADDR.S */ 6085/* File: x86/binopWide2addr.S */ 6086 /* 6087 * Generic 64-bit binary operation. 6088 */ 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 6098 ADVANCE_PC 1 6099 GOTO_NEXT_R %ecx 6100 6101 6102/* ------------------------------ */ 6103.L_OP_SUB_LONG_2ADDR: /* 0xbc */ 6104/* File: x86/OP_SUB_LONG_2ADDR.S */ 6105/* File: x86/binopWide2addr.S */ 6106 /* 6107 * Generic 64-bit binary operation. 6108 */ 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 6118 ADVANCE_PC 1 6119 GOTO_NEXT_R %ecx 6120 6121 6122/* ------------------------------ */ 6123.L_OP_MUL_LONG_2ADDR: /* 0xbd */ 6124/* File: x86/OP_MUL_LONG_2ADDR.S */ 6125 /* 6126 * Signed 64-bit integer multiply, 2-addr version 6127 * 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. 6135 */ 6136 /* mul-long/2addr vA, vB */ 6137 movzbl rINSTbl,%eax # eax<- BA 6138 andb $0xf,%al # eax<- A 6139 sarl $4,rINST # rINST<- B 6140 SPILL_TMP2(%esi) 6141 SPILL(rFP) 6142 SPILL(rIBASE) 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 6155 UNSPILL_TMP2(%esi) 6156 FETCH_INST_OPCODE 1 %ecx 6157 UNSPILL(rIBASE) 6158 UNSPILL(rFP) 6159 ADVANCE_PC 1 6160 GOTO_NEXT_R %ecx 6161 6162/* ------------------------------ */ 6163.L_OP_DIV_LONG_2ADDR: /* 0xbe */ 6164/* File: x86/OP_DIV_LONG_2ADDR.S */ 6165 /* div/2addr vA, vB */ 6166 movzbl rINSTbl,%eax 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) 6173 testl %eax,%eax 6174 je .LOP_DIV_LONG_2ADDR_check_zero 6175 cmpl $-1,%eax 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) 6184 call __divdi3 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 6190 ADVANCE_PC 1 6191 GOTO_NEXT_R %ecx 6192 6193.LOP_DIV_LONG_2ADDR_check_zero: 6194 testl rIBASE,rIBASE 6195 jne .LOP_DIV_LONG_2ADDR_notSpecial 6196 jmp common_errDivideByZero 6197.LOP_DIV_LONG_2ADDR_check_neg1: 6198 testl rIBASE,%eax 6199 jne .LOP_DIV_LONG_2ADDR_notSpecial 6200 GET_VREG_WORD rIBASE rINST 0 6201 GET_VREG_WORD %ecx rINST 1 6202 testl rIBASE,rIBASE 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 */ 6207 xorl %eax,%eax 6208 movl $0x80000000,rIBASE 6209 jmp .LOP_DIV_LONG_2ADDR_finish 6210 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 */ 6216 movzbl rINSTbl,%eax 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) 6223 testl %eax,%eax 6224 je .LOP_REM_LONG_2ADDR_check_zero 6225 cmpl $-1,%eax 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) 6234 call __moddi3 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 6240 ADVANCE_PC 1 6241 GOTO_NEXT_R %ecx 6242 6243.LOP_REM_LONG_2ADDR_check_zero: 6244 testl rIBASE,rIBASE 6245 jne .LOP_REM_LONG_2ADDR_notSpecial 6246 jmp common_errDivideByZero 6247.LOP_REM_LONG_2ADDR_check_neg1: 6248 testl rIBASE,%eax 6249 jne .LOP_REM_LONG_2ADDR_notSpecial 6250 GET_VREG_WORD rIBASE rINST 0 6251 GET_VREG_WORD %ecx rINST 1 6252 testl rIBASE,rIBASE 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 */ 6257 xorl %eax,%eax 6258 movl $0,rIBASE 6259 jmp .LOP_REM_LONG_2ADDR_finish 6260 6261 6262/* ------------------------------ */ 6263.L_OP_AND_LONG_2ADDR: /* 0xc0 */ 6264/* File: x86/OP_AND_LONG_2ADDR.S */ 6265/* File: x86/binopWide2addr.S */ 6266 /* 6267 * Generic 64-bit binary operation. 6268 */ 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 6278 ADVANCE_PC 1 6279 GOTO_NEXT_R %ecx 6280 6281 6282/* ------------------------------ */ 6283.L_OP_OR_LONG_2ADDR: /* 0xc1 */ 6284/* File: x86/OP_OR_LONG_2ADDR.S */ 6285/* File: x86/binopWide2addr.S */ 6286 /* 6287 * Generic 64-bit binary operation. 6288 */ 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 6298 ADVANCE_PC 1 6299 GOTO_NEXT_R %ecx 6300 6301 6302/* ------------------------------ */ 6303.L_OP_XOR_LONG_2ADDR: /* 0xc2 */ 6304/* File: x86/OP_XOR_LONG_2ADDR.S */ 6305/* File: x86/binopWide2addr.S */ 6306 /* 6307 * Generic 64-bit binary operation. 6308 */ 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 6318 ADVANCE_PC 1 6319 GOTO_NEXT_R %ecx 6320 6321 6322/* ------------------------------ */ 6323.L_OP_SHL_LONG_2ADDR: /* 0xc3 */ 6324/* File: x86/OP_SHL_LONG_2ADDR.S */ 6325 /* 6326 * Long integer shift, 2addr version. vA is 64-bit value/result, vB is 6327 * 32-bit shift distance. 6328 */ 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 6337 SPILL(rIBASE) 6338 GET_VREG_WORD rIBASE rINST 1 # rIBASE<- v[AA+1] 6339 GET_VREG_R %ecx %ecx # ecx<- vBB 6340 shldl %eax,rIBASE 6341 sall %cl,%eax 6342 testb $32,%cl 6343 je 2f 6344 movl %eax,rIBASE 6345 xorl %eax,%eax 63462: 6347 SET_VREG_WORD rIBASE rINST 1 # v[AA+1]<- rIBASE 6348 UNSPILL(rIBASE) 6349 FETCH_INST_OPCODE 1 %ecx 6350 SET_VREG_WORD %eax rINST 0 # v[AA+0]<- eax 6351 ADVANCE_PC 1 6352 GOTO_NEXT_R %ecx 6353 6354/* ------------------------------ */ 6355.L_OP_SHR_LONG_2ADDR: /* 0xc4 */ 6356/* File: x86/OP_SHR_LONG_2ADDR.S */ 6357 /* 6358 * Long integer shift, 2addr version. vA is 64-bit value/result, vB is 6359 * 32-bit shift distance. 6360 */ 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 6369 SPILL(rIBASE) 6370 GET_VREG_WORD rIBASE rINST 1 # rIBASE<- v[AA+1] 6371 GET_VREG_R %ecx %ecx # ecx<- vBB 6372 shrdl rIBASE,%eax 6373 sarl %cl,rIBASE 6374 testb $32,%cl 6375 je 2f 6376 movl rIBASE,%eax 6377 sarl $31,rIBASE 63782: 6379 SET_VREG_WORD rIBASE rINST 1 # v[AA+1]<- rIBASE 6380 UNSPILL(rIBASE) 6381 FETCH_INST_OPCODE 1 %ecx 6382 SET_VREG_WORD %eax rINST 0 # v[AA+0]<- eax 6383 ADVANCE_PC 1 6384 GOTO_NEXT_R %ecx 6385 6386/* ------------------------------ */ 6387.L_OP_USHR_LONG_2ADDR: /* 0xc5 */ 6388/* File: x86/OP_USHR_LONG_2ADDR.S */ 6389 /* 6390 * Long integer shift, 2addr version. vA is 64-bit value/result, vB is 6391 * 32-bit shift distance. 6392 */ 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 6401 SPILL(rIBASE) 6402 GET_VREG_WORD rIBASE rINST 1 # rIBASE<- v[AA+1] 6403 GET_VREG_R %ecx %ecx # ecx<- vBB 6404 shrdl rIBASE,%eax 6405 shrl %cl,rIBASE 6406 testb $32,%cl 6407 je 2f 6408 movl rIBASE,%eax 6409 xorl rIBASE,rIBASE 64102: 6411 SET_VREG_WORD rIBASE rINST 1 # v[AA+1]<- rIBASE 6412 FETCH_INST_OPCODE 1 %ecx 6413 UNSPILL(rIBASE) 6414 SET_VREG_WORD %eax rINST 0 # v[AA+0]<- eax 6415 ADVANCE_PC 1 6416 GOTO_NEXT_R %ecx 6417 6418/* ------------------------------ */ 6419.L_OP_ADD_FLOAT_2ADDR: /* 0xc6 */ 6420/* File: x86/OP_ADD_FLOAT_2ADDR.S */ 6421/* File: x86/binflop2addr.S */ 6422 /* 6423 * Generic 32-bit binary float operation. 6424 * 6425 * For: add-fp, sub-fp, mul-fp, div-fp 6426 */ 6427 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 6435 ADVANCE_PC 1 6436 fstps (rFP,%ecx,4) # %st to vA 6437 GOTO_NEXT_R %eax 6438 6439 6440/* ------------------------------ */ 6441.L_OP_SUB_FLOAT_2ADDR: /* 0xc7 */ 6442/* File: x86/OP_SUB_FLOAT_2ADDR.S */ 6443/* File: x86/binflop2addr.S */ 6444 /* 6445 * Generic 32-bit binary float operation. 6446 * 6447 * For: add-fp, sub-fp, mul-fp, div-fp 6448 */ 6449 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 6457 ADVANCE_PC 1 6458 fstps (rFP,%ecx,4) # %st to vA 6459 GOTO_NEXT_R %eax 6460 6461 6462/* ------------------------------ */ 6463.L_OP_MUL_FLOAT_2ADDR: /* 0xc8 */ 6464/* File: x86/OP_MUL_FLOAT_2ADDR.S */ 6465/* File: x86/binflop2addr.S */ 6466 /* 6467 * Generic 32-bit binary float operation. 6468 * 6469 * For: add-fp, sub-fp, mul-fp, div-fp 6470 */ 6471 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 6479 ADVANCE_PC 1 6480 fstps (rFP,%ecx,4) # %st to vA 6481 GOTO_NEXT_R %eax 6482 6483 6484/* ------------------------------ */ 6485.L_OP_DIV_FLOAT_2ADDR: /* 0xc9 */ 6486/* File: x86/OP_DIV_FLOAT_2ADDR.S */ 6487/* File: x86/binflop2addr.S */ 6488 /* 6489 * Generic 32-bit binary float operation. 6490 * 6491 * For: add-fp, sub-fp, mul-fp, div-fp 6492 */ 6493 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 6501 ADVANCE_PC 1 6502 fstps (rFP,%ecx,4) # %st to vA 6503 GOTO_NEXT_R %eax 6504 6505 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 65151: 6516 fprem 6517 fstsw %ax 6518 sahf 6519 jp 1b 6520 fstp %st(1) 6521 FETCH_INST_OPCODE 1 %eax 6522 ADVANCE_PC 1 6523 fstps (rFP,%ecx,4) # %st to vA 6524 GOTO_NEXT_R %eax 6525 6526/* ------------------------------ */ 6527.L_OP_ADD_DOUBLE_2ADDR: /* 0xcb */ 6528/* File: x86/OP_ADD_DOUBLE_2ADDR.S */ 6529/* File: x86/binflop2addr.S */ 6530 /* 6531 * Generic 32-bit binary float operation. 6532 * 6533 * For: add-fp, sub-fp, mul-fp, div-fp 6534 */ 6535 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 6543 ADVANCE_PC 1 6544 fstpl (rFP,%ecx,4) # %st to vA 6545 GOTO_NEXT_R %eax 6546 6547 6548/* ------------------------------ */ 6549.L_OP_SUB_DOUBLE_2ADDR: /* 0xcc */ 6550/* File: x86/OP_SUB_DOUBLE_2ADDR.S */ 6551/* File: x86/binflop2addr.S */ 6552 /* 6553 * Generic 32-bit binary float operation. 6554 * 6555 * For: add-fp, sub-fp, mul-fp, div-fp 6556 */ 6557 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 6565 ADVANCE_PC 1 6566 fstpl (rFP,%ecx,4) # %st to vA 6567 GOTO_NEXT_R %eax 6568 6569 6570/* ------------------------------ */ 6571.L_OP_MUL_DOUBLE_2ADDR: /* 0xcd */ 6572/* File: x86/OP_MUL_DOUBLE_2ADDR.S */ 6573/* File: x86/binflop2addr.S */ 6574 /* 6575 * Generic 32-bit binary float operation. 6576 * 6577 * For: add-fp, sub-fp, mul-fp, div-fp 6578 */ 6579 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 6587 ADVANCE_PC 1 6588 fstpl (rFP,%ecx,4) # %st to vA 6589 GOTO_NEXT_R %eax 6590 6591 6592/* ------------------------------ */ 6593.L_OP_DIV_DOUBLE_2ADDR: /* 0xce */ 6594/* File: x86/OP_DIV_DOUBLE_2ADDR.S */ 6595/* File: x86/binflop2addr.S */ 6596 /* 6597 * Generic 32-bit binary float operation. 6598 * 6599 * For: add-fp, sub-fp, mul-fp, div-fp 6600 */ 6601 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 6609 ADVANCE_PC 1 6610 fstpl (rFP,%ecx,4) # %st to vA 6611 GOTO_NEXT_R %eax 6612 6613 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 66231: 6624 fprem 6625 fstsw %ax 6626 sahf 6627 jp 1b 6628 fstp %st(1) 6629 FETCH_INST_OPCODE 1 %eax 6630 ADVANCE_PC 1 6631 fstpl (rFP,%ecx,4) # %st to vA 6632 GOTO_NEXT_R %eax 6633 6634/* ------------------------------ */ 6635.L_OP_ADD_INT_LIT16: /* 0xd0 */ 6636/* File: x86/OP_ADD_INT_LIT16.S */ 6637/* File: x86/binopLit16.S */ 6638 /* 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".) 6643 * 6644 * For: add-int/lit16, rsub-int, 6645 * and-int/lit16, or-int/lit16, xor-int/lit16 6646 */ 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 6654 SET_VREG %eax rINST 6655 FETCH_INST_OPCODE 2 %ecx 6656 ADVANCE_PC 2 6657 GOTO_NEXT_R %ecx 6658 6659 6660/* ------------------------------ */ 6661.L_OP_RSUB_INT: /* 0xd1 */ 6662/* File: x86/OP_RSUB_INT.S */ 6663/* File: x86/binopLit16.S */ 6664 /* 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".) 6669 * 6670 * For: add-int/lit16, rsub-int, 6671 * and-int/lit16, or-int/lit16, xor-int/lit16 6672 */ 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 6680 SET_VREG %ecx rINST 6681 FETCH_INST_OPCODE 2 %ecx 6682 ADVANCE_PC 2 6683 GOTO_NEXT_R %ecx 6684 6685 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 6696 SPILL(rIBASE) 6697 imull %ecx,%eax # trashes rIBASE/edx 6698 UNSPILL(rIBASE) 6699 FETCH_INST_OPCODE 2 %ecx 6700 ADVANCE_PC 2 6701 SET_VREG %eax rINST 6702 GOTO_NEXT_R %ecx 6703 6704/* ------------------------------ */ 6705.L_OP_DIV_INT_LIT16: /* 0xd3 */ 6706/* File: x86/OP_DIV_INT_LIT16.S */ 6707/* File: x86/bindivLit16.S */ 6708 /* 6709 * 32-bit binary div/rem operation. Handles special case of op0=minint and 6710 * op1=-1. 6711 */ 6712 /* div/rem/lit16 vA, vB, #+CCCC */ 6713 /* Need A in rINST, ssssCCCC in ecx, vB in eax */ 6714 movzbl rINSTbl,%eax # eax<- 000000BA 6715 SPILL(rIBASE) 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 6720 cmpl $0,%ecx 6721 je common_errDivideByZero 6722 cmpl $-1,%ecx 6723 jne .LOP_DIV_INT_LIT16_continue_div 6724 cmpl $0x80000000,%eax 6725 jne .LOP_DIV_INT_LIT16_continue_div 6726 movl $0x80000000,%eax 6727 SET_VREG %eax rINST 6728 UNSPILL(rIBASE) 6729 FETCH_INST_OPCODE 2 %ecx 6730 ADVANCE_PC 2 6731 GOTO_NEXT_R %ecx 6732 6733.LOP_DIV_INT_LIT16_continue_div: 6734 cltd 6735 idivl %ecx 6736 SET_VREG %eax rINST 6737 UNSPILL(rIBASE) 6738 FETCH_INST_OPCODE 2 %ecx 6739 ADVANCE_PC 2 6740 GOTO_NEXT_R %ecx 6741 6742 6743/* ------------------------------ */ 6744.L_OP_REM_INT_LIT16: /* 0xd4 */ 6745/* File: x86/OP_REM_INT_LIT16.S */ 6746/* File: x86/bindivLit16.S */ 6747 /* 6748 * 32-bit binary div/rem operation. Handles special case of op0=minint and 6749 * op1=-1. 6750 */ 6751 /* div/rem/lit16 vA, vB, #+CCCC */ 6752 /* Need A in rINST, ssssCCCC in ecx, vB in eax */ 6753 movzbl rINSTbl,%eax # eax<- 000000BA 6754 SPILL(rIBASE) 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 6759 cmpl $0,%ecx 6760 je common_errDivideByZero 6761 cmpl $-1,%ecx 6762 jne .LOP_REM_INT_LIT16_continue_div 6763 cmpl $0x80000000,%eax 6764 jne .LOP_REM_INT_LIT16_continue_div 6765 movl $0,rIBASE 6766 SET_VREG rIBASE rINST 6767 UNSPILL(rIBASE) 6768 FETCH_INST_OPCODE 2 %ecx 6769 ADVANCE_PC 2 6770 GOTO_NEXT_R %ecx 6771 6772.LOP_REM_INT_LIT16_continue_div: 6773 cltd 6774 idivl %ecx 6775 SET_VREG rIBASE rINST 6776 UNSPILL(rIBASE) 6777 FETCH_INST_OPCODE 2 %ecx 6778 ADVANCE_PC 2 6779 GOTO_NEXT_R %ecx 6780 6781 6782/* ------------------------------ */ 6783.L_OP_AND_INT_LIT16: /* 0xd5 */ 6784/* File: x86/OP_AND_INT_LIT16.S */ 6785/* File: x86/binopLit16.S */ 6786 /* 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".) 6791 * 6792 * For: add-int/lit16, rsub-int, 6793 * and-int/lit16, or-int/lit16, xor-int/lit16 6794 */ 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 6802 SET_VREG %eax rINST 6803 FETCH_INST_OPCODE 2 %ecx 6804 ADVANCE_PC 2 6805 GOTO_NEXT_R %ecx 6806 6807 6808/* ------------------------------ */ 6809.L_OP_OR_INT_LIT16: /* 0xd6 */ 6810/* File: x86/OP_OR_INT_LIT16.S */ 6811/* File: x86/binopLit16.S */ 6812 /* 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".) 6817 * 6818 * For: add-int/lit16, rsub-int, 6819 * and-int/lit16, or-int/lit16, xor-int/lit16 6820 */ 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 6828 SET_VREG %eax rINST 6829 FETCH_INST_OPCODE 2 %ecx 6830 ADVANCE_PC 2 6831 GOTO_NEXT_R %ecx 6832 6833 6834/* ------------------------------ */ 6835.L_OP_XOR_INT_LIT16: /* 0xd7 */ 6836/* File: x86/OP_XOR_INT_LIT16.S */ 6837/* File: x86/binopLit16.S */ 6838 /* 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".) 6843 * 6844 * For: add-int/lit16, rsub-int, 6845 * and-int/lit16, or-int/lit16, xor-int/lit16 6846 */ 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 6854 SET_VREG %eax rINST 6855 FETCH_INST_OPCODE 2 %ecx 6856 ADVANCE_PC 2 6857 GOTO_NEXT_R %ecx 6858 6859 6860/* ------------------------------ */ 6861.L_OP_ADD_INT_LIT8: /* 0xd8 */ 6862/* File: x86/OP_ADD_INT_LIT8.S */ 6863/* File: x86/binopLit8.S */ 6864 /* 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".) 6869 * 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 6873 */ 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 6879 SET_VREG %eax rINST 6880 FETCH_INST_OPCODE 2 %ecx 6881 ADVANCE_PC 2 6882 GOTO_NEXT_R %ecx 6883 6884 6885/* ------------------------------ */ 6886.L_OP_RSUB_INT_LIT8: /* 0xd9 */ 6887/* File: x86/OP_RSUB_INT_LIT8.S */ 6888/* File: x86/binopLit8.S */ 6889 /* 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".) 6894 * 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 6898 */ 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 6904 SET_VREG %ecx rINST 6905 FETCH_INST_OPCODE 2 %ecx 6906 ADVANCE_PC 2 6907 GOTO_NEXT_R %ecx 6908 6909 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 6917 SPILL(rIBASE) 6918 imull %ecx,%eax # trashes rIBASE/edx 6919 UNSPILL(rIBASE) 6920 FETCH_INST_OPCODE 2 %ecx 6921 ADVANCE_PC 2 6922 SET_VREG %eax rINST 6923 GOTO_NEXT_R %ecx 6924 6925/* ------------------------------ */ 6926.L_OP_DIV_INT_LIT8: /* 0xdb */ 6927/* File: x86/OP_DIV_INT_LIT8.S */ 6928/* File: x86/bindivLit8.S */ 6929 /* 6930 * 32-bit div/rem "lit8" binary operation. Handles special case of 6931 * op0=minint & op1=-1 6932 */ 6933 /* div/rem/lit8 vAA, vBB, #+CC */ 6934 movzbl 2(rPC),%eax # eax<- BB 6935 movsbl 3(rPC),%ecx # ecx<- ssssssCC 6936 SPILL(rIBASE) 6937 GET_VREG_R %eax %eax # eax<- rBB 6938 cmpl $0,%ecx 6939 je common_errDivideByZero 6940 cmpl $0x80000000,%eax 6941 jne .LOP_DIV_INT_LIT8_continue_div 6942 cmpl $-1,%ecx 6943 jne .LOP_DIV_INT_LIT8_continue_div 6944 movl $0x80000000,%eax 6945 SET_VREG %eax rINST 6946 UNSPILL(rIBASE) 6947 FETCH_INST_OPCODE 2 %ecx 6948 ADVANCE_PC 2 6949 GOTO_NEXT_R %ecx 6950 6951.LOP_DIV_INT_LIT8_continue_div: 6952 cltd 6953 idivl %ecx 6954 SET_VREG %eax rINST 6955 UNSPILL(rIBASE) 6956 FETCH_INST_OPCODE 2 %ecx 6957 ADVANCE_PC 2 6958 GOTO_NEXT_R %ecx 6959 6960 6961/* ------------------------------ */ 6962.L_OP_REM_INT_LIT8: /* 0xdc */ 6963/* File: x86/OP_REM_INT_LIT8.S */ 6964/* File: x86/bindivLit8.S */ 6965 /* 6966 * 32-bit div/rem "lit8" binary operation. Handles special case of 6967 * op0=minint & op1=-1 6968 */ 6969 /* div/rem/lit8 vAA, vBB, #+CC */ 6970 movzbl 2(rPC),%eax # eax<- BB 6971 movsbl 3(rPC),%ecx # ecx<- ssssssCC 6972 SPILL(rIBASE) 6973 GET_VREG_R %eax %eax # eax<- rBB 6974 cmpl $0,%ecx 6975 je common_errDivideByZero 6976 cmpl $0x80000000,%eax 6977 jne .LOP_REM_INT_LIT8_continue_div 6978 cmpl $-1,%ecx 6979 jne .LOP_REM_INT_LIT8_continue_div 6980 movl $0,rIBASE 6981 SET_VREG rIBASE rINST 6982 UNSPILL(rIBASE) 6983 FETCH_INST_OPCODE 2 %ecx 6984 ADVANCE_PC 2 6985 GOTO_NEXT_R %ecx 6986 6987.LOP_REM_INT_LIT8_continue_div: 6988 cltd 6989 idivl %ecx 6990 SET_VREG rIBASE rINST 6991 UNSPILL(rIBASE) 6992 FETCH_INST_OPCODE 2 %ecx 6993 ADVANCE_PC 2 6994 GOTO_NEXT_R %ecx 6995 6996 6997/* ------------------------------ */ 6998.L_OP_AND_INT_LIT8: /* 0xdd */ 6999/* File: x86/OP_AND_INT_LIT8.S */ 7000/* File: x86/binopLit8.S */ 7001 /* 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".) 7006 * 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 7010 */ 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 7016 SET_VREG %eax rINST 7017 FETCH_INST_OPCODE 2 %ecx 7018 ADVANCE_PC 2 7019 GOTO_NEXT_R %ecx 7020 7021 7022/* ------------------------------ */ 7023.L_OP_OR_INT_LIT8: /* 0xde */ 7024/* File: x86/OP_OR_INT_LIT8.S */ 7025/* File: x86/binopLit8.S */ 7026 /* 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".) 7031 * 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 7035 */ 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 7041 SET_VREG %eax rINST 7042 FETCH_INST_OPCODE 2 %ecx 7043 ADVANCE_PC 2 7044 GOTO_NEXT_R %ecx 7045 7046 7047/* ------------------------------ */ 7048.L_OP_XOR_INT_LIT8: /* 0xdf */ 7049/* File: x86/OP_XOR_INT_LIT8.S */ 7050/* File: x86/binopLit8.S */ 7051 /* 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".) 7056 * 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 7060 */ 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 7066 SET_VREG %eax rINST 7067 FETCH_INST_OPCODE 2 %ecx 7068 ADVANCE_PC 2 7069 GOTO_NEXT_R %ecx 7070 7071 7072/* ------------------------------ */ 7073.L_OP_SHL_INT_LIT8: /* 0xe0 */ 7074/* File: x86/OP_SHL_INT_LIT8.S */ 7075/* File: x86/binopLit8.S */ 7076 /* 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".) 7081 * 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 7085 */ 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 7091 SET_VREG %eax rINST 7092 FETCH_INST_OPCODE 2 %ecx 7093 ADVANCE_PC 2 7094 GOTO_NEXT_R %ecx 7095 7096 7097/* ------------------------------ */ 7098.L_OP_SHR_INT_LIT8: /* 0xe1 */ 7099/* File: x86/OP_SHR_INT_LIT8.S */ 7100/* File: x86/binopLit8.S */ 7101 /* 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".) 7106 * 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 7110 */ 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 7116 SET_VREG %eax rINST 7117 FETCH_INST_OPCODE 2 %ecx 7118 ADVANCE_PC 2 7119 GOTO_NEXT_R %ecx 7120 7121 7122/* ------------------------------ */ 7123.L_OP_USHR_INT_LIT8: /* 0xe2 */ 7124/* File: x86/OP_USHR_INT_LIT8.S */ 7125/* File: x86/binopLit8.S */ 7126 /* 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".) 7131 * 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 7135 */ 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 7141 SET_VREG %eax rINST 7142 FETCH_INST_OPCODE 2 %ecx 7143 ADVANCE_PC 2 7144 GOTO_NEXT_R %ecx 7145 7146 7147/* ------------------------------ */ 7148.L_OP_IGET_VOLATILE: /* 0xe3 */ 7149/* File: x86/OP_IGET_VOLATILE.S */ 7150/* File: x86/OP_IGET.S */ 7151 /* 7152 * General 32-bit instance field get. 7153 * 7154 * for: iget, iget-object, iget-boolean, iget-byte, iget-char, iget-short 7155 */ 7156 /* op vA, vB, field@CCCC */ 7157 movl rSELF,%ecx 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 7170 movl rSELF,rIBASE 7171 EXPORT_PC 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 7177 UNSPILL_TMP1(%ecx) 7178 testl %eax,%eax # returns InstrField ptr 7179 jne .LOP_IGET_VOLATILE_finish 7180 jmp common_exceptionThrown 7181 7182.LOP_IGET_VOLATILE_finish: 7183 /* 7184 * Currently: 7185 * eax holds resolved field 7186 * ecx holds object 7187 * rINST holds A 7188 */ 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 7194 UNSPILL(rIBASE) 7195 SET_VREG %ecx rINST 7196 ADVANCE_PC 2 7197 GOTO_NEXT_R %eax 7198 7199 7200/* ------------------------------ */ 7201.L_OP_IPUT_VOLATILE: /* 0xe4 */ 7202/* File: x86/OP_IPUT_VOLATILE.S */ 7203/* File: x86/OP_IPUT.S */ 7204 7205 /* 7206 * General 32-bit instance field put. 7207 * 7208 * for: iput, iput-object, iput-boolean, iput-byte, iput-char, iput-short 7209 */ 7210 /* op vA, vB, field@CCCC */ 7211 movl rSELF,%ecx 7212 SPILL (rIBASE) 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) 7224 movl rSELF,rIBASE 7225 EXPORT_PC 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 7231 UNSPILL_TMP1(%ecx) 7232 testl %eax,%eax # returns InstrField ptr 7233 jne .LOP_IPUT_VOLATILE_finish 7234 jmp common_exceptionThrown 7235 7236.LOP_IPUT_VOLATILE_finish: 7237 /* 7238 * Currently: 7239 * eax holds resolved field 7240 * ecx holds object 7241 * rINST holds A 7242 */ 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 7249 UNSPILL(rIBASE) 7250 ADVANCE_PC 2 7251 GOTO_NEXT_R %ecx 7252 7253 7254/* ------------------------------ */ 7255.L_OP_SGET_VOLATILE: /* 0xe5 */ 7256/* File: x86/OP_SGET_VOLATILE.S */ 7257/* File: x86/OP_SGET.S */ 7258 /* 7259 * General 32-bit SGET handler. 7260 * 7261 * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short 7262 */ 7263 /* op vAA, field@BBBB */ 7264 movl rSELF,%ecx 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 7274 ADVANCE_PC 2 7275 SET_VREG %eax rINST 7276 GOTO_NEXT_R %ecx 7277 7278 /* 7279 * Go resolve the field 7280 */ 7281.LOP_SGET_VOLATILE_resolve: 7282 movl rSELF,%ecx 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) 7289 SPILL(rIBASE) 7290 call dvmResolveStaticField # eax<- resolved StaticField ptr 7291 UNSPILL(rIBASE) 7292 testl %eax,%eax 7293 jne .LOP_SGET_VOLATILE_finish # success, continue 7294 jmp common_exceptionThrown # no, handle exception 7295 7296 7297/* ------------------------------ */ 7298.L_OP_SPUT_VOLATILE: /* 0xe6 */ 7299/* File: x86/OP_SPUT_VOLATILE.S */ 7300/* File: x86/OP_SPUT.S */ 7301 /* 7302 * General 32-bit SPUT handler. 7303 * 7304 * for: sput, sput-boolean, sput-byte, sput-char, sput-short 7305 */ 7306 /* op vAA, field@BBBB */ 7307 movl rSELF,%ecx 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 7317 ADVANCE_PC 2 7318 movl rINST,offStaticField_value(%eax) 7319 GOTO_NEXT_R %ecx 7320 7321 /* 7322 * Go resolve the field 7323 */ 7324.LOP_SPUT_VOLATILE_resolve: 7325 movl rSELF,%ecx 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) 7332 SPILL(rIBASE) 7333 call dvmResolveStaticField # eax<- resolved StaticField ptr 7334 UNSPILL(rIBASE) 7335 testl %eax,%eax 7336 jne .LOP_SPUT_VOLATILE_finish # success, continue 7337 jmp common_exceptionThrown # no, handle exception 7338 7339 7340/* ------------------------------ */ 7341.L_OP_IGET_OBJECT_VOLATILE: /* 0xe7 */ 7342/* File: x86/OP_IGET_OBJECT_VOLATILE.S */ 7343/* File: x86/OP_IGET.S */ 7344 /* 7345 * General 32-bit instance field get. 7346 * 7347 * for: iget, iget-object, iget-boolean, iget-byte, iget-char, iget-short 7348 */ 7349 /* op vA, vB, field@CCCC */ 7350 movl rSELF,%ecx 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 7363 movl rSELF,rIBASE 7364 EXPORT_PC 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 7370 UNSPILL_TMP1(%ecx) 7371 testl %eax,%eax # returns InstrField ptr 7372 jne .LOP_IGET_OBJECT_VOLATILE_finish 7373 jmp common_exceptionThrown 7374 7375.LOP_IGET_OBJECT_VOLATILE_finish: 7376 /* 7377 * Currently: 7378 * eax holds resolved field 7379 * ecx holds object 7380 * rINST holds A 7381 */ 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 7387 UNSPILL(rIBASE) 7388 SET_VREG %ecx rINST 7389 ADVANCE_PC 2 7390 GOTO_NEXT_R %eax 7391 7392 7393/* ------------------------------ */ 7394.L_OP_IGET_WIDE_VOLATILE: /* 0xe8 */ 7395 /* (stub) */ 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 7399 movl rSELF,%ecx 7400 LOAD_PC_FP_FROM_SELF # retrieve updated values 7401 movl offThread_curHandlerTable(%ecx),rIBASE # set up rIBASE 7402 FETCH_INST 7403 GOTO_NEXT 7404/* ------------------------------ */ 7405.L_OP_IPUT_WIDE_VOLATILE: /* 0xe9 */ 7406 /* (stub) */ 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 7410 movl rSELF,%ecx 7411 LOAD_PC_FP_FROM_SELF # retrieve updated values 7412 movl offThread_curHandlerTable(%ecx),rIBASE # set up rIBASE 7413 FETCH_INST 7414 GOTO_NEXT 7415/* ------------------------------ */ 7416.L_OP_SGET_WIDE_VOLATILE: /* 0xea */ 7417 /* (stub) */ 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 7421 movl rSELF,%ecx 7422 LOAD_PC_FP_FROM_SELF # retrieve updated values 7423 movl offThread_curHandlerTable(%ecx),rIBASE # set up rIBASE 7424 FETCH_INST 7425 GOTO_NEXT 7426/* ------------------------------ */ 7427.L_OP_SPUT_WIDE_VOLATILE: /* 0xeb */ 7428 /* (stub) */ 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 7432 movl rSELF,%ecx 7433 LOAD_PC_FP_FROM_SELF # retrieve updated values 7434 movl offThread_curHandlerTable(%ecx),rIBASE # set up rIBASE 7435 FETCH_INST 7436 GOTO_NEXT 7437/* ------------------------------ */ 7438.L_OP_BREAKPOINT: /* 0xec */ 7439/* File: x86/OP_BREAKPOINT.S */ 7440/* File: x86/unused.S */ 7441 jmp common_abort 7442 7443 7444/* ------------------------------ */ 7445.L_OP_THROW_VERIFICATION_ERROR: /* 0xed */ 7446/* File: x86/OP_THROW_VERIFICATION_ERROR.S */ 7447 /* 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. 7451 */ 7452 /* op AA, ref@BBBB */ 7453 movl rSELF,%ecx 7454 movzwl 2(rPC),%eax # eax<- BBBB 7455 movl offThread_method(%ecx),%ecx # ecx<- self->method 7456 EXPORT_PC 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 7462 7463/* ------------------------------ */ 7464.L_OP_EXECUTE_INLINE: /* 0xee */ 7465/* File: x86/OP_EXECUTE_INLINE.S */ 7466 /* 7467 * Execute a "native inline" instruction. 7468 * 7469 * We will be calling through a function table: 7470 * 7471 * (*gDvmInlineOpsTable[opIndex].func)(arg0, arg1, arg2, arg3, pResult) 7472 * 7473 * Ignores argument count - always loads 4. 7474 * 7475 */ 7476 /* [opt] execute-inline vAA, {vC, vD, vE, vF}, inline@BBBB */ 7477 movl rSELF,%ecx 7478 EXPORT_PC 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 7488 ADVANCE_PC 3 7489 GOTO_NEXT_R %ecx 7490 7491.LOP_EXECUTE_INLINE_continue: 7492 /* 7493 * Extract args, call function. 7494 * ecx = #of args (0-4) 7495 * eax = call index 7496 * @esp = return addr 7497 * esp is -4 from normal 7498 * 7499 * Go ahead and load all 4 args, even if not used. 7500 */ 7501 movzwl 4(rPC),rIBASE 7502 7503 movl $0xf,%ecx 7504 andl rIBASE,%ecx 7505 GET_VREG_R %ecx %ecx 7506 sarl $4,rIBASE 7507 movl %ecx,4+OUT_ARG0(%esp) 7508 7509 movl $0xf,%ecx 7510 andl rIBASE,%ecx 7511 GET_VREG_R %ecx %ecx 7512 sarl $4,rIBASE 7513 movl %ecx,4+OUT_ARG1(%esp) 7514 7515 movl $0xf,%ecx 7516 andl rIBASE,%ecx 7517 GET_VREG_R %ecx %ecx 7518 sarl $4,rIBASE 7519 movl %ecx,4+OUT_ARG2(%esp) 7520 7521 movl $0xf,%ecx 7522 andl rIBASE,%ecx 7523 GET_VREG_R %ecx %ecx 7524 sarl $4,rIBASE 7525 movl %ecx,4+OUT_ARG3(%esp) 7526 7527 sall $4,%eax # index *= sizeof(table entry) 7528 jmp *gDvmInlineOpsTable(%eax) 7529 # will return to caller of .LOP_EXECUTE_INLINE_continue 7530 7531/* ------------------------------ */ 7532.L_OP_EXECUTE_INLINE_RANGE: /* 0xef */ 7533 /* (stub) */ 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 7537 movl rSELF,%ecx 7538 LOAD_PC_FP_FROM_SELF # retrieve updated values 7539 movl offThread_curHandlerTable(%ecx),rIBASE # set up rIBASE 7540 FETCH_INST 7541 GOTO_NEXT 7542/* ------------------------------ */ 7543.L_OP_INVOKE_OBJECT_INIT_RANGE: /* 0xf0 */ 7544 /* (stub) */ 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 7548 movl rSELF,%ecx 7549 LOAD_PC_FP_FROM_SELF # retrieve updated values 7550 movl offThread_curHandlerTable(%ecx),rIBASE # set up rIBASE 7551 FETCH_INST 7552 GOTO_NEXT 7553/* ------------------------------ */ 7554.L_OP_RETURN_VOID_BARRIER: /* 0xf1 */ 7555 /* (stub) */ 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 7559 movl rSELF,%ecx 7560 LOAD_PC_FP_FROM_SELF # retrieve updated values 7561 movl offThread_curHandlerTable(%ecx),rIBASE # set up rIBASE 7562 FETCH_INST 7563 GOTO_NEXT 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 7577 ADVANCE_PC 2 7578 andb $0xf,rINSTbl # rINST<- A 7579 SET_VREG %eax rINST # fp[A]<- result 7580 GOTO_NEXT_R %ecx 7581 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 7600 ADVANCE_PC 2 7601 GOTO_NEXT_R %ecx 7602 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 7617 ADVANCE_PC 2 7618 andb $0xf,rINSTbl # rINST<- A 7619 SET_VREG %eax rINST # fp[A]<- result 7620 GOTO_NEXT_R %ecx 7621 7622 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 7638 ADVANCE_PC 2 7639 GOTO_NEXT_R %ecx 7640 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 7656 movl %eax,(%ecx) 7657 movl rINST,4(%ecx) 7658 FETCH_INST_OPCODE 2 %ecx 7659 ADVANCE_PC 2 7660 GOTO_NEXT_R %ecx 7661 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) 7676 movl rSELF,%eax 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 76821: 7683 FETCH_INST_OPCODE 2 %ecx 7684 ADVANCE_PC 2 7685 GOTO_NEXT_R %ecx 7686 7687/* ------------------------------ */ 7688.L_OP_INVOKE_VIRTUAL_QUICK: /* 0xf8 */ 7689/* File: x86/OP_INVOKE_VIRTUAL_QUICK.S */ 7690 /* 7691 * Handle an optimized virtual method call. 7692 * 7693 * for: [opt] invoke-virtual-quick, invoke-virtual-quick/range 7694 */ 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 7699 .if (!0) 7700 andl $0xf,%eax # eax<- C (or stays CCCC) 7701 .endif 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 7710 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 */ 7715 /* 7716 * Handle an optimized virtual method call. 7717 * 7718 * for: [opt] invoke-virtual-quick, invoke-virtual-quick/range 7719 */ 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 7724 .if (!1) 7725 andl $0xf,%eax # eax<- C (or stays CCCC) 7726 .endif 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 7735 7736 7737/* ------------------------------ */ 7738.L_OP_INVOKE_SUPER_QUICK: /* 0xfa */ 7739/* File: x86/OP_INVOKE_SUPER_QUICK.S */ 7740 /* 7741 * Handle an optimized "super" method call. 7742 * 7743 * for: [opt] invoke-super-quick, invoke-super-quick/range 7744 */ 7745 /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ 7746 /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ 7747 movl rSELF,%ecx 7748 movzwl 4(rPC),%eax # eax<- GFED or CCCC 7749 movl offThread_method(%ecx),%ecx # ecx<- current method 7750 .if (!0) 7751 andl $0xf,%eax # eax<- D (or stays CCCC) 7752 .endif 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 7760 EXPORT_PC 7761 movl (%ecx,%eax,4),%eax # eax<- super->vtable[BBBB] 7762 jmp common_invokeMethodNoRange 7763 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 */ 7768 /* 7769 * Handle an optimized "super" method call. 7770 * 7771 * for: [opt] invoke-super-quick, invoke-super-quick/range 7772 */ 7773 /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ 7774 /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ 7775 movl rSELF,%ecx 7776 movzwl 4(rPC),%eax # eax<- GFED or CCCC 7777 movl offThread_method(%ecx),%ecx # ecx<- current method 7778 .if (!1) 7779 andl $0xf,%eax # eax<- D (or stays CCCC) 7780 .endif 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 7788 EXPORT_PC 7789 movl (%ecx,%eax,4),%eax # eax<- super->vtable[BBBB] 7790 jmp common_invokeMethodRange 7791 7792 7793/* ------------------------------ */ 7794.L_OP_IPUT_OBJECT_VOLATILE: /* 0xfc */ 7795/* File: x86/OP_IPUT_OBJECT_VOLATILE.S */ 7796/* File: x86/OP_IPUT_OBJECT.S */ 7797 /* 7798 * Object field put. 7799 * 7800 * for: iput-object 7801 */ 7802 /* op vA, vB, field@CCCC */ 7803 movl rSELF,%ecx 7804 SPILL(rIBASE) 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) 7816 movl rSELF,rIBASE 7817 EXPORT_PC 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 7823 UNSPILL_TMP1(%ecx) 7824 testl %eax,%eax # returns InstrField ptr 7825 jne .LOP_IPUT_OBJECT_VOLATILE_finish 7826 jmp common_exceptionThrown 7827 7828.LOP_IPUT_OBJECT_VOLATILE_finish: 7829 /* 7830 * Currently: 7831 * eax holds resolved field 7832 * ecx holds object 7833 * rIBASE is scratch, but needs to be unspilled 7834 * rINST holds A 7835 */ 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) 7841 movl rSELF,%eax 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 78471: 7848 UNSPILL(rIBASE) 7849 FETCH_INST_OPCODE 2 %ecx 7850 ADVANCE_PC 2 7851 GOTO_NEXT_R %ecx 7852 7853 7854/* ------------------------------ */ 7855.L_OP_SGET_OBJECT_VOLATILE: /* 0xfd */ 7856/* File: x86/OP_SGET_OBJECT_VOLATILE.S */ 7857/* File: x86/OP_SGET.S */ 7858 /* 7859 * General 32-bit SGET handler. 7860 * 7861 * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short 7862 */ 7863 /* op vAA, field@BBBB */ 7864 movl rSELF,%ecx 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 7874 ADVANCE_PC 2 7875 SET_VREG %eax rINST 7876 GOTO_NEXT_R %ecx 7877 7878 /* 7879 * Go resolve the field 7880 */ 7881.LOP_SGET_OBJECT_VOLATILE_resolve: 7882 movl rSELF,%ecx 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) 7889 SPILL(rIBASE) 7890 call dvmResolveStaticField # eax<- resolved StaticField ptr 7891 UNSPILL(rIBASE) 7892 testl %eax,%eax 7893 jne .LOP_SGET_OBJECT_VOLATILE_finish # success, continue 7894 jmp common_exceptionThrown # no, handle exception 7895 7896 7897/* ------------------------------ */ 7898.L_OP_SPUT_OBJECT_VOLATILE: /* 0xfe */ 7899/* File: x86/OP_SPUT_OBJECT_VOLATILE.S */ 7900/* File: x86/OP_SPUT_OBJECT.S */ 7901 /* 7902 * SPUT object handler. 7903 */ 7904 /* op vAA, field@BBBB */ 7905 movl rSELF,%ecx 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 7918 movl rSELF,%ecx 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 79231: 7924 FETCH_INST_OPCODE 2 %ecx 7925 ADVANCE_PC 2 7926 GOTO_NEXT_R %ecx 7927 7928.LOP_SPUT_OBJECT_VOLATILE_resolve: 7929 movl rSELF,%ecx 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) 7936 SPILL(rIBASE) 7937 call dvmResolveStaticField # eax<- resolved StaticField ptr 7938 UNSPILL(rIBASE) 7939 testl %eax,%eax 7940 jne .LOP_SPUT_OBJECT_VOLATILE_finish # success, continue 7941 jmp common_exceptionThrown # no, handle exception 7942 7943 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 7949 7950/* ------------------------------ */ 7951.L_OP_CONST_CLASS_JUMBO: /* 0x100 */ 7952/* File: x86/OP_CONST_CLASS_JUMBO.S */ 7953 /* const-class/jumbo vBBBB, Class@AAAAAAAA */ 7954 movl rSELF,%ecx 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 movl (%ecx,%eax,4),%eax # eax<- rResClasses[AAAAAAAA] 7959 FETCH_INST_OPCODE 4 %ecx 7960 testl %eax,%eax # resolved yet? 7961 je .LOP_CONST_CLASS_JUMBO_resolve 7962 SET_VREG %eax rINST # vBBBB<- rResClasses[AAAAAAAA] 7963 ADVANCE_PC 4 7964 GOTO_NEXT_R %ecx 7965 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: 7969 movl rSELF,%eax 7970 EXPORT_PC 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) 7977 SPILL(rIBASE) 7978 call dvmResolveClass # go resolve 7979 UNSPILL(rIBASE) 7980 testl %eax,%eax # failed? 7981 je common_exceptionThrown 7982 FETCH_INST_OPCODE 4 %ecx 7983 SET_VREG %eax rINST 7984 ADVANCE_PC 4 7985 GOTO_NEXT_R %ecx 7986 7987/* ------------------------------ */ 7988.L_OP_CHECK_CAST_JUMBO: /* 0x101 */ 7989/* File: x86/OP_CHECK_CAST_JUMBO.S */ 7990 /* 7991 * Check to see if a cast from one class to another is allowed. 7992 */ 7993 /* check-cast/jumbo vBBBB, class@AAAAAAAA */ 7994 movl rSELF,%ecx 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 8010 ADVANCE_PC 4 8011 GOTO_NEXT_R %ecx 8012 8013 /* 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 8018 */ 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) 8023 SPILL(rIBASE) 8024 call dvmInstanceofNonTrivial # eax<- boolean result 8025 UNSPILL(rIBASE) 8026 testl %eax,%eax # failed? 8027 jne .LOP_CHECK_CAST_JUMBO_okay # no, success 8028 8029 # A cast has failed. We need to throw a ClassCastException. 8030 EXPORT_PC 8031 movl offObject_clazz(rINST),%eax 8032 movl %eax,OUT_ARG0(%esp) # arg0<- obj->clazz 8033 movl sReg0,%ecx 8034 movl %ecx,OUT_ARG1(%esp) # arg1<- desired class 8035 call dvmThrowClassCastException 8036 jmp common_exceptionThrown 8037 8038 /* 8039 * Resolution required. This is the least-likely path, and we're 8040 * going to have to recreate some data. 8041 * 8042 * rINST holds object 8043 */ 8044.LOP_CHECK_CAST_JUMBO_resolve: 8045 movl rSELF,%ecx 8046 EXPORT_PC 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 8053 SPILL(rIBASE) 8054 call dvmResolveClass # eax<- resolved ClassObject ptr 8055 UNSPILL(rIBASE) 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 8060 8061/* ------------------------------ */ 8062.L_OP_INSTANCE_OF_JUMBO: /* 0x102 */ 8063/* File: x86/OP_INSTANCE_OF_JUMBO.S */ 8064 /* 8065 * Check to see if an object reference is an instance of a class. 8066 * 8067 * Most common situation is a non-null object, being compared against 8068 * an already-resolved class. 8069 */ 8070 /* instance-of/jumbo vBBBB, vCCCC, class@AAAAAAAA */ 8071 movzwl 8(rPC),%eax # eax<- CCCC 8072 GET_VREG_R %eax %eax # eax<- vCCCC (obj) 8073 movl rSELF,%ecx 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 8087 /* 8088 * Trivial test failed, need to perform full check. This is common. 8089 * eax holds obj->clazz 8090 * ecx holds class resolved from BBBB 8091 * rINST has BA 8092 */ 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 8097 8098 /* 8099 * eax holds boolean result 8100 * rINST holds BBBB 8101 */ 8102.LOP_INSTANCE_OF_JUMBO_store: 8103 FETCH_INST_OPCODE 5 %ecx 8104 UNSPILL(rIBASE) 8105 ADVANCE_PC 5 8106 SET_VREG %eax rINST # vBBBB<- eax 8107 GOTO_NEXT_R %ecx 8108 8109 /* 8110 * Trivial test succeeded, save and bail. 8111 * r9 holds BBBB 8112 */ 8113.LOP_INSTANCE_OF_JUMBO_trivial: 8114 FETCH_INST_OPCODE 5 %ecx 8115 UNSPILL(rIBASE) 8116 ADVANCE_PC 5 8117 movl $1,%eax 8118 SET_VREG %eax rINST # vBBBB<- true 8119 GOTO_NEXT_R %ecx 8120 8121 /* 8122 * Resolution required. This is the least-likely path. 8123 * 8124 * edx holds AAAAAAAA 8125 */ 8126.LOP_INSTANCE_OF_JUMBO_resolve: 8127 movl rIBASE,OUT_ARG1(%esp) # arg1<- AAAAAAAA 8128 movl rSELF,%ecx 8129 movl offThread_method(%ecx),%ecx 8130 movl $1,OUT_ARG2(%esp) # arg2<- true 8131 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 8132 EXPORT_PC 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 8139 */ 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 8145 8146/* ------------------------------ */ 8147.L_OP_NEW_INSTANCE_JUMBO: /* 0x103 */ 8148/* File: x86/OP_NEW_INSTANCE_JUMBO.S */ 8149 /* 8150 * Create a new instance of a class. 8151 */ 8152 /* new-instance/jumbo vBBBB, class@AAAAAAAA */ 8153 movl rSELF,%ecx 8154 movl 2(rPC),%eax # eax<- AAAAAAAA 8155 movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex 8156 movl offDvmDex_pResClasses(%ecx),%ecx # ecx<- pDvmDex->pResClasses 8157 EXPORT_PC 8158 movl (%ecx,%eax,4),%ecx # ecx<- resolved class 8159 SPILL(rIBASE) 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 8169 UNSPILL(rIBASE) 8170 FETCH_INST_OPCODE 4 %ecx 8171 testl %eax,%eax # success? 8172 je common_exceptionThrown # no, bail out 8173 SET_VREG %eax rINST 8174 ADVANCE_PC 4 8175 GOTO_NEXT_R %ecx 8176 8177 /* 8178 * Class initialization required. 8179 * 8180 * ecx holds class object 8181 */ 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 8190 8191 /* 8192 * Resolution required. This is the least-likely path. 8193 * 8194 */ 8195.LOP_NEW_INSTANCE_JUMBO_resolve: 8196 movl rSELF,%ecx 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 8208 8209/* ------------------------------ */ 8210.L_OP_NEW_ARRAY_JUMBO: /* 0x104 */ 8211/* File: x86/OP_NEW_ARRAY_JUMBO.S */ 8212 /* 8213 * Allocate an array of objects, specified with the array class 8214 * and a count. 8215 * 8216 * The verifier guarantees that this is an array class, so we don't 8217 * check for it here. 8218 */ 8219 /* new-array/jumbo vBBBB, vCCCC, class@AAAAAAAA */ 8220 movl rSELF,%ecx 8221 EXPORT_PC 8222 movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex 8223 movl 2(rPC),%eax # eax<- AAAAAAAA 8224 movl offDvmDex_pResClasses(%ecx),%ecx # ecx<- pDvmDex->pResClasses 8225 SPILL(rIBASE) 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) 8229 testl %eax,%eax 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 8233 /* 8234 * Resolve class. (This is an uncommon case.) 8235 * ecx holds class (null here) 8236 * eax holds array length (vCCCC) 8237 */ 8238 movl rSELF,%ecx 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) 8247 movl %eax,%ecx 8248 UNSPILL_TMP1(%eax) 8249 testl %ecx,%ecx # successful resolution? 8250 je common_exceptionThrown # no, bail. 8251# fall through to OP_NEW_ARRAY_JUMBO_finish 8252 8253 /* 8254 * Finish allocation 8255 * 8256 * ecx holds class 8257 * eax holds array length (vCCCC) 8258 */ 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) 8264 UNSPILL(rIBASE) 8265 FETCH_INST_OPCODE 5 %ecx 8266 testl %eax,%eax # failed? 8267 je common_exceptionThrown # yup - go handle 8268 SET_VREG %eax rINST 8269 ADVANCE_PC 5 8270 GOTO_NEXT_R %ecx 8271 8272/* ------------------------------ */ 8273.L_OP_FILLED_NEW_ARRAY_JUMBO: /* 0x105 */ 8274/* File: x86/OP_FILLED_NEW_ARRAY_JUMBO.S */ 8275 /* 8276 * Create a new array with elements filled from registers. 8277 */ 8278 /* filled-new-array/jumbo {vCCCC..v(CCCC+BBBB-1)}, type@AAAAAAAA */ 8279 movl rSELF,%eax 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 8284 EXPORT_PC 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 8288 movl rSELF,%eax 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 8294 SPILL(rIBASE) 8295 call dvmResolveClass # eax<- call(clazz,ref,flag) 8296 UNSPILL(rIBASE) 8297 testl %eax,%eax # null? 8298 je common_exceptionThrown # yes, handle it 8299 8300 # note: fall through to .LOP_FILLED_NEW_ARRAY_JUMBO_continue 8301 8302 /* 8303 * On entry: 8304 * eax holds array class [r0] 8305 * ecx is scratch 8306 */ 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 8312 movl rSELF,%eax 8313 cmpb $'I',%cl # supported? 8314 je 1f 8315 cmpb $'L',%cl 8316 je 1f 8317 cmpb $'[',%cl 8318 jne .LOP_FILLED_NEW_ARRAY_JUMBO_notimpl # no, not handled yet 83191: 8320 movl %ecx,offThread_retval+4(%eax) # save type 8321 movl rINST,OUT_ARG1(%esp) # arg1<- BBBB (length) 8322 SPILL(rIBASE) 8323 call dvmAllocArrayByClass # eax<- call(arrayClass, length, flags) 8324 UNSPILL(rIBASE) 8325 movl rSELF,%ecx 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 8331 8332/* at this point: 8333 * eax is pointer to tgt 8334 * rINST is length 8335 * ecx is CCCC 8336 * We now need to copy values from registers into the array 8337 */ 8338 8339 # set up src pointer 8340 SPILL_TMP2(%esi) 8341 SPILL_TMP3(%edi) 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 8345 rep 8346 movsd 8347 UNSPILL_TMP2(%esi) 8348 UNSPILL_TMP3(%edi) 8349 movl rSELF,%ecx 8350 movl offThread_retval+4(%ecx),%eax # eax<- type 8351 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 83585: 8359 FETCH_INST_OPCODE 5 %ecx 8360 ADVANCE_PC 5 8361 GOTO_NEXT_R %ecx 8362 8363 8364 /* 8365 * Throw an exception indicating that we have not implemented this 8366 * mode of filled-new-array. 8367 */ 8368.LOP_FILLED_NEW_ARRAY_JUMBO_notimpl: 8369 movl $.LstrFilledNewArrayNotImplA,%eax 8370 movl %eax,OUT_ARG0(%esp) 8371 call dvmThrowInternalError 8372 jmp common_exceptionThrown 8373 8374/* ------------------------------ */ 8375.L_OP_IGET_JUMBO: /* 0x106 */ 8376/* File: x86/OP_IGET_JUMBO.S */ 8377 /* 8378 * Jumbo 32-bit instance field get. 8379 * 8380 * for: iget/jumbo, iget-object/jumbo, iget-boolean/jumbo, iget-byte/jumbo, 8381 * iget-char/jumbo, iget-short/jumbo 8382 */ 8383 /* exop vBBBB, vCCCC, field@AAAAAAAA */ 8384 movl rSELF,%ecx 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 8395 movl rSELF,rIBASE 8396 EXPORT_PC 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 8402 UNSPILL_TMP1(%ecx) 8403 testl %eax,%eax # returns InstrField ptr 8404 jne .LOP_IGET_JUMBO_finish 8405 jmp common_exceptionThrown 8406 8407.LOP_IGET_JUMBO_finish: 8408 /* 8409 * Currently: 8410 * eax holds resolved field 8411 * ecx holds object 8412 * rINST holds BBBB 8413 */ 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 8420 SET_VREG %ecx rINST 8421 ADVANCE_PC 5 8422 GOTO_NEXT_R %eax 8423 8424/* ------------------------------ */ 8425.L_OP_IGET_WIDE_JUMBO: /* 0x107 */ 8426/* File: x86/OP_IGET_WIDE_JUMBO.S */ 8427 /* 8428 * Jumbo 64-bit instance field get. 8429 */ 8430 /* iget-wide/jumbo vBBBB, vCCCC, field@AAAA */ 8431 movl rSELF,%ecx 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 8442 movl rSELF,rIBASE 8443 EXPORT_PC 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 8449 UNSPILL_TMP1(%ecx) 8450 testl %eax,%eax # returns InstrField ptr 8451 jne .LOP_IGET_WIDE_JUMBO_finish 8452 jmp common_exceptionThrown 8453 8454.LOP_IGET_WIDE_JUMBO_finish: 8455 /* 8456 * Currently: 8457 * eax holds resolved field 8458 * ecx holds object 8459 * rINST holds BBBB 8460 */ 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 8471 ADVANCE_PC 5 8472 GOTO_NEXT_R %ecx 8473 8474/* ------------------------------ */ 8475.L_OP_IGET_OBJECT_JUMBO: /* 0x108 */ 8476/* File: x86/OP_IGET_OBJECT_JUMBO.S */ 8477/* File: x86/OP_IGET_JUMBO.S */ 8478 /* 8479 * Jumbo 32-bit instance field get. 8480 * 8481 * for: iget/jumbo, iget-object/jumbo, iget-boolean/jumbo, iget-byte/jumbo, 8482 * iget-char/jumbo, iget-short/jumbo 8483 */ 8484 /* exop vBBBB, vCCCC, field@AAAAAAAA */ 8485 movl rSELF,%ecx 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 8496 movl rSELF,rIBASE 8497 EXPORT_PC 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 8503 UNSPILL_TMP1(%ecx) 8504 testl %eax,%eax # returns InstrField ptr 8505 jne .LOP_IGET_OBJECT_JUMBO_finish 8506 jmp common_exceptionThrown 8507 8508.LOP_IGET_OBJECT_JUMBO_finish: 8509 /* 8510 * Currently: 8511 * eax holds resolved field 8512 * ecx holds object 8513 * rINST holds BBBB 8514 */ 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 8521 SET_VREG %ecx rINST 8522 ADVANCE_PC 5 8523 GOTO_NEXT_R %eax 8524 8525 8526/* ------------------------------ */ 8527.L_OP_IGET_BOOLEAN_JUMBO: /* 0x109 */ 8528/* File: x86/OP_IGET_BOOLEAN_JUMBO.S */ 8529/* File: x86/OP_IGET_JUMBO.S */ 8530 /* 8531 * Jumbo 32-bit instance field get. 8532 * 8533 * for: iget/jumbo, iget-object/jumbo, iget-boolean/jumbo, iget-byte/jumbo, 8534 * iget-char/jumbo, iget-short/jumbo 8535 */ 8536 /* exop vBBBB, vCCCC, field@AAAAAAAA */ 8537 movl rSELF,%ecx 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 8548 movl rSELF,rIBASE 8549 EXPORT_PC 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 8555 UNSPILL_TMP1(%ecx) 8556 testl %eax,%eax # returns InstrField ptr 8557 jne .LOP_IGET_BOOLEAN_JUMBO_finish 8558 jmp common_exceptionThrown 8559 8560.LOP_IGET_BOOLEAN_JUMBO_finish: 8561 /* 8562 * Currently: 8563 * eax holds resolved field 8564 * ecx holds object 8565 * rINST holds BBBB 8566 */ 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 8573 SET_VREG %ecx rINST 8574 ADVANCE_PC 5 8575 GOTO_NEXT_R %eax 8576 8577 8578/* ------------------------------ */ 8579.L_OP_IGET_BYTE_JUMBO: /* 0x10a */ 8580/* File: x86/OP_IGET_BYTE_JUMBO.S */ 8581/* File: x86/OP_IGET_JUMBO.S */ 8582 /* 8583 * Jumbo 32-bit instance field get. 8584 * 8585 * for: iget/jumbo, iget-object/jumbo, iget-boolean/jumbo, iget-byte/jumbo, 8586 * iget-char/jumbo, iget-short/jumbo 8587 */ 8588 /* exop vBBBB, vCCCC, field@AAAAAAAA */ 8589 movl rSELF,%ecx 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 8600 movl rSELF,rIBASE 8601 EXPORT_PC 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 8607 UNSPILL_TMP1(%ecx) 8608 testl %eax,%eax # returns InstrField ptr 8609 jne .LOP_IGET_BYTE_JUMBO_finish 8610 jmp common_exceptionThrown 8611 8612.LOP_IGET_BYTE_JUMBO_finish: 8613 /* 8614 * Currently: 8615 * eax holds resolved field 8616 * ecx holds object 8617 * rINST holds BBBB 8618 */ 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 8625 SET_VREG %ecx rINST 8626 ADVANCE_PC 5 8627 GOTO_NEXT_R %eax 8628 8629 8630/* ------------------------------ */ 8631.L_OP_IGET_CHAR_JUMBO: /* 0x10b */ 8632/* File: x86/OP_IGET_CHAR_JUMBO.S */ 8633/* File: x86/OP_IGET_JUMBO.S */ 8634 /* 8635 * Jumbo 32-bit instance field get. 8636 * 8637 * for: iget/jumbo, iget-object/jumbo, iget-boolean/jumbo, iget-byte/jumbo, 8638 * iget-char/jumbo, iget-short/jumbo 8639 */ 8640 /* exop vBBBB, vCCCC, field@AAAAAAAA */ 8641 movl rSELF,%ecx 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 8652 movl rSELF,rIBASE 8653 EXPORT_PC 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 8659 UNSPILL_TMP1(%ecx) 8660 testl %eax,%eax # returns InstrField ptr 8661 jne .LOP_IGET_CHAR_JUMBO_finish 8662 jmp common_exceptionThrown 8663 8664.LOP_IGET_CHAR_JUMBO_finish: 8665 /* 8666 * Currently: 8667 * eax holds resolved field 8668 * ecx holds object 8669 * rINST holds BBBB 8670 */ 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 8677 SET_VREG %ecx rINST 8678 ADVANCE_PC 5 8679 GOTO_NEXT_R %eax 8680 8681 8682/* ------------------------------ */ 8683.L_OP_IGET_SHORT_JUMBO: /* 0x10c */ 8684/* File: x86/OP_IGET_SHORT_JUMBO.S */ 8685/* File: x86/OP_IGET_JUMBO.S */ 8686 /* 8687 * Jumbo 32-bit instance field get. 8688 * 8689 * for: iget/jumbo, iget-object/jumbo, iget-boolean/jumbo, iget-byte/jumbo, 8690 * iget-char/jumbo, iget-short/jumbo 8691 */ 8692 /* exop vBBBB, vCCCC, field@AAAAAAAA */ 8693 movl rSELF,%ecx 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 8704 movl rSELF,rIBASE 8705 EXPORT_PC 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 8711 UNSPILL_TMP1(%ecx) 8712 testl %eax,%eax # returns InstrField ptr 8713 jne .LOP_IGET_SHORT_JUMBO_finish 8714 jmp common_exceptionThrown 8715 8716.LOP_IGET_SHORT_JUMBO_finish: 8717 /* 8718 * Currently: 8719 * eax holds resolved field 8720 * ecx holds object 8721 * rINST holds BBBB 8722 */ 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 8729 SET_VREG %ecx rINST 8730 ADVANCE_PC 5 8731 GOTO_NEXT_R %eax 8732 8733 8734/* ------------------------------ */ 8735.L_OP_IPUT_JUMBO: /* 0x10d */ 8736/* File: x86/OP_IPUT_JUMBO.S */ 8737 /* 8738 * Jumbo 32-bit instance field put. 8739 * 8740 * for: iput/jumbo, iput-object/jumbo, iput-boolean/jumbo, iput-byte/jumbo, 8741 iput-char/jumbo, iput-short/jumbo 8742 */ 8743 /* exop vBBBB, vCCCC, field@AAAAAAAA */ 8744 movl rSELF,%ecx 8745 SPILL(rIBASE) 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) 8755 movl rSELF,rIBASE 8756 EXPORT_PC 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 8762 UNSPILL_TMP1(%ecx) 8763 testl %eax,%eax # returns InstrField ptr 8764 jne .LOP_IPUT_JUMBO_finish 8765 jmp common_exceptionThrown 8766 8767.LOP_IPUT_JUMBO_finish: 8768 /* 8769 * Currently: 8770 * eax holds resolved field 8771 * ecx holds object 8772 * rINST holds BBBB 8773 */ 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 8780 UNSPILL(rIBASE) 8781 ADVANCE_PC 5 8782 GOTO_NEXT_R %ecx 8783 8784/* ------------------------------ */ 8785.L_OP_IPUT_WIDE_JUMBO: /* 0x10e */ 8786/* File: x86/OP_IPUT_WIDE_JUMBO.S */ 8787 /* 8788 * Jumbo 64-bit instance field put. 8789 */ 8790 /* iput-wide/jumbo vBBBB, vCCCC, field@AAAAAAAA */ 8791 movl rSELF,%ecx 8792 SPILL(rIBASE) 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) 8802 movl rSELF,rIBASE 8803 EXPORT_PC 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 8809 UNSPILL_TMP1(%ecx) 8810 testl %eax,%eax # ... which returns InstrField ptr 8811 jne .LOP_IPUT_WIDE_JUMBO_finish 8812 jmp common_exceptionThrown 8813 8814.LOP_IPUT_WIDE_JUMBO_finish: 8815 /* 8816 * Currently: 8817 * eax holds resolved field 8818 * ecx holds object 8819 * rIBASE is scratch, but needs to be unspilled 8820 * rINST holds BBBB 8821 */ 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 8828 movl rINST,4(%eax) 8829 movl %ecx,(%eax) 8830 FETCH_INST_OPCODE 5 %ecx 8831 UNSPILL(rIBASE) 8832 ADVANCE_PC 5 8833 GOTO_NEXT_R %ecx 8834 8835/* ------------------------------ */ 8836.L_OP_IPUT_OBJECT_JUMBO: /* 0x10f */ 8837/* File: x86/OP_IPUT_OBJECT_JUMBO.S */ 8838 /* 8839 * Jumbo object field put. 8840 */ 8841 /* iput-object/jumbo vBBBB, vCCCC, field@AAAAAAAA */ 8842 movl rSELF,%ecx 8843 SPILL(rIBASE) 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) 8853 movl rSELF,rIBASE 8854 EXPORT_PC 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 8860 UNSPILL_TMP1(%ecx) 8861 testl %eax,%eax # returns InstrField ptr 8862 jne .LOP_IPUT_OBJECT_JUMBO_finish 8863 jmp common_exceptionThrown 8864 8865.LOP_IPUT_OBJECT_JUMBO_finish: 8866 /* 8867 * Currently: 8868 * eax holds resolved field 8869 * ecx holds object 8870 * rIBASE is scratch, but needs to be unspilled 8871 * rINST holds BBBB 8872 */ 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) 8878 movl rSELF,%eax 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 88841: 8885 FETCH_INST_OPCODE 5 %ecx 8886 UNSPILL(rIBASE) 8887 ADVANCE_PC 5 8888 GOTO_NEXT_R %ecx 8889 8890/* ------------------------------ */ 8891.L_OP_IPUT_BOOLEAN_JUMBO: /* 0x110 */ 8892/* File: x86/OP_IPUT_BOOLEAN_JUMBO.S */ 8893/* File: x86/OP_IPUT_JUMBO.S */ 8894 /* 8895 * Jumbo 32-bit instance field put. 8896 * 8897 * for: iput/jumbo, iput-object/jumbo, iput-boolean/jumbo, iput-byte/jumbo, 8898 iput-char/jumbo, iput-short/jumbo 8899 */ 8900 /* exop vBBBB, vCCCC, field@AAAAAAAA */ 8901 movl rSELF,%ecx 8902 SPILL(rIBASE) 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) 8912 movl rSELF,rIBASE 8913 EXPORT_PC 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 8919 UNSPILL_TMP1(%ecx) 8920 testl %eax,%eax # returns InstrField ptr 8921 jne .LOP_IPUT_BOOLEAN_JUMBO_finish 8922 jmp common_exceptionThrown 8923 8924.LOP_IPUT_BOOLEAN_JUMBO_finish: 8925 /* 8926 * Currently: 8927 * eax holds resolved field 8928 * ecx holds object 8929 * rINST holds BBBB 8930 */ 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 8937 UNSPILL(rIBASE) 8938 ADVANCE_PC 5 8939 GOTO_NEXT_R %ecx 8940 8941 8942/* ------------------------------ */ 8943.L_OP_IPUT_BYTE_JUMBO: /* 0x111 */ 8944/* File: x86/OP_IPUT_BYTE_JUMBO.S */ 8945/* File: x86/OP_IPUT_JUMBO.S */ 8946 /* 8947 * Jumbo 32-bit instance field put. 8948 * 8949 * for: iput/jumbo, iput-object/jumbo, iput-boolean/jumbo, iput-byte/jumbo, 8950 iput-char/jumbo, iput-short/jumbo 8951 */ 8952 /* exop vBBBB, vCCCC, field@AAAAAAAA */ 8953 movl rSELF,%ecx 8954 SPILL(rIBASE) 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) 8964 movl rSELF,rIBASE 8965 EXPORT_PC 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 8971 UNSPILL_TMP1(%ecx) 8972 testl %eax,%eax # returns InstrField ptr 8973 jne .LOP_IPUT_BYTE_JUMBO_finish 8974 jmp common_exceptionThrown 8975 8976.LOP_IPUT_BYTE_JUMBO_finish: 8977 /* 8978 * Currently: 8979 * eax holds resolved field 8980 * ecx holds object 8981 * rINST holds BBBB 8982 */ 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 8989 UNSPILL(rIBASE) 8990 ADVANCE_PC 5 8991 GOTO_NEXT_R %ecx 8992 8993 8994/* ------------------------------ */ 8995.L_OP_IPUT_CHAR_JUMBO: /* 0x112 */ 8996/* File: x86/OP_IPUT_CHAR_JUMBO.S */ 8997/* File: x86/OP_IPUT_JUMBO.S */ 8998 /* 8999 * Jumbo 32-bit instance field put. 9000 * 9001 * for: iput/jumbo, iput-object/jumbo, iput-boolean/jumbo, iput-byte/jumbo, 9002 iput-char/jumbo, iput-short/jumbo 9003 */ 9004 /* exop vBBBB, vCCCC, field@AAAAAAAA */ 9005 movl rSELF,%ecx 9006 SPILL(rIBASE) 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) 9016 movl rSELF,rIBASE 9017 EXPORT_PC 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 9023 UNSPILL_TMP1(%ecx) 9024 testl %eax,%eax # returns InstrField ptr 9025 jne .LOP_IPUT_CHAR_JUMBO_finish 9026 jmp common_exceptionThrown 9027 9028.LOP_IPUT_CHAR_JUMBO_finish: 9029 /* 9030 * Currently: 9031 * eax holds resolved field 9032 * ecx holds object 9033 * rINST holds BBBB 9034 */ 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 9041 UNSPILL(rIBASE) 9042 ADVANCE_PC 5 9043 GOTO_NEXT_R %ecx 9044 9045 9046/* ------------------------------ */ 9047.L_OP_IPUT_SHORT_JUMBO: /* 0x113 */ 9048/* File: x86/OP_IPUT_SHORT_JUMBO.S */ 9049/* File: x86/OP_IPUT_JUMBO.S */ 9050 /* 9051 * Jumbo 32-bit instance field put. 9052 * 9053 * for: iput/jumbo, iput-object/jumbo, iput-boolean/jumbo, iput-byte/jumbo, 9054 iput-char/jumbo, iput-short/jumbo 9055 */ 9056 /* exop vBBBB, vCCCC, field@AAAAAAAA */ 9057 movl rSELF,%ecx 9058 SPILL(rIBASE) 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) 9068 movl rSELF,rIBASE 9069 EXPORT_PC 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 9075 UNSPILL_TMP1(%ecx) 9076 testl %eax,%eax # returns InstrField ptr 9077 jne .LOP_IPUT_SHORT_JUMBO_finish 9078 jmp common_exceptionThrown 9079 9080.LOP_IPUT_SHORT_JUMBO_finish: 9081 /* 9082 * Currently: 9083 * eax holds resolved field 9084 * ecx holds object 9085 * rINST holds BBBB 9086 */ 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 9093 UNSPILL(rIBASE) 9094 ADVANCE_PC 5 9095 GOTO_NEXT_R %ecx 9096 9097 9098/* ------------------------------ */ 9099.L_OP_SGET_JUMBO: /* 0x114 */ 9100/* File: x86/OP_SGET_JUMBO.S */ 9101 /* 9102 * Jumbo 32-bit SGET handler. 9103 * 9104 * for: sget/jumbo, sget-object/jumbo, sget-boolean/jumbo, sget-byte/jumbo, 9105 * sget-char/jumbo, sget-short/jumbo 9106 */ 9107 /* exop vBBBB, field@AAAAAAAA */ 9108 movl rSELF,%ecx 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 9118 ADVANCE_PC 4 9119 SET_VREG %eax rINST 9120 GOTO_NEXT_R %ecx 9121 9122 /* 9123 * Go resolve the field 9124 */ 9125.LOP_SGET_JUMBO_resolve: 9126 movl rSELF,%ecx 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) 9133 SPILL(rIBASE) 9134 call dvmResolveStaticField # eax<- resolved StaticField ptr 9135 UNSPILL(rIBASE) 9136 testl %eax,%eax 9137 jne .LOP_SGET_JUMBO_finish # success, continue 9138 jmp common_exceptionThrown # no, handle exception 9139 9140/* ------------------------------ */ 9141.L_OP_SGET_WIDE_JUMBO: /* 0x115 */ 9142/* File: x86/OP_SGET_WIDE_JUMBO.S */ 9143 /* 9144 * Jumbo 64-bit SGET handler. 9145 * 9146 */ 9147 /* sget-wide/jumbo vBBBB, field@AAAAAAAA */ 9148 movl rSELF,%ecx 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 9161 ADVANCE_PC 2 9162 GOTO_NEXT_R %ecx 9163 9164 /* 9165 * Go resolve the field 9166 */ 9167.LOP_SGET_WIDE_JUMBO_resolve: 9168 movl rSELF,%ecx 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) 9175 SPILL(rIBASE) 9176 call dvmResolveStaticField # eax<- resolved StaticField ptr 9177 UNSPILL(rIBASE) 9178 testl %eax,%eax 9179 jne .LOP_SGET_WIDE_JUMBO_finish # success, continue 9180 jmp common_exceptionThrown # no, handle exception 9181 9182/* ------------------------------ */ 9183.L_OP_SGET_OBJECT_JUMBO: /* 0x116 */ 9184/* File: x86/OP_SGET_OBJECT_JUMBO.S */ 9185/* File: x86/OP_SGET_JUMBO.S */ 9186 /* 9187 * Jumbo 32-bit SGET handler. 9188 * 9189 * for: sget/jumbo, sget-object/jumbo, sget-boolean/jumbo, sget-byte/jumbo, 9190 * sget-char/jumbo, sget-short/jumbo 9191 */ 9192 /* exop vBBBB, field@AAAAAAAA */ 9193 movl rSELF,%ecx 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 9203 ADVANCE_PC 4 9204 SET_VREG %eax rINST 9205 GOTO_NEXT_R %ecx 9206 9207 /* 9208 * Go resolve the field 9209 */ 9210.LOP_SGET_OBJECT_JUMBO_resolve: 9211 movl rSELF,%ecx 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) 9218 SPILL(rIBASE) 9219 call dvmResolveStaticField # eax<- resolved StaticField ptr 9220 UNSPILL(rIBASE) 9221 testl %eax,%eax 9222 jne .LOP_SGET_OBJECT_JUMBO_finish # success, continue 9223 jmp common_exceptionThrown # no, handle exception 9224 9225 9226/* ------------------------------ */ 9227.L_OP_SGET_BOOLEAN_JUMBO: /* 0x117 */ 9228/* File: x86/OP_SGET_BOOLEAN_JUMBO.S */ 9229/* File: x86/OP_SGET_JUMBO.S */ 9230 /* 9231 * Jumbo 32-bit SGET handler. 9232 * 9233 * for: sget/jumbo, sget-object/jumbo, sget-boolean/jumbo, sget-byte/jumbo, 9234 * sget-char/jumbo, sget-short/jumbo 9235 */ 9236 /* exop vBBBB, field@AAAAAAAA */ 9237 movl rSELF,%ecx 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 9247 ADVANCE_PC 4 9248 SET_VREG %eax rINST 9249 GOTO_NEXT_R %ecx 9250 9251 /* 9252 * Go resolve the field 9253 */ 9254.LOP_SGET_BOOLEAN_JUMBO_resolve: 9255 movl rSELF,%ecx 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) 9262 SPILL(rIBASE) 9263 call dvmResolveStaticField # eax<- resolved StaticField ptr 9264 UNSPILL(rIBASE) 9265 testl %eax,%eax 9266 jne .LOP_SGET_BOOLEAN_JUMBO_finish # success, continue 9267 jmp common_exceptionThrown # no, handle exception 9268 9269 9270/* ------------------------------ */ 9271.L_OP_SGET_BYTE_JUMBO: /* 0x118 */ 9272/* File: x86/OP_SGET_BYTE_JUMBO.S */ 9273/* File: x86/OP_SGET_JUMBO.S */ 9274 /* 9275 * Jumbo 32-bit SGET handler. 9276 * 9277 * for: sget/jumbo, sget-object/jumbo, sget-boolean/jumbo, sget-byte/jumbo, 9278 * sget-char/jumbo, sget-short/jumbo 9279 */ 9280 /* exop vBBBB, field@AAAAAAAA */ 9281 movl rSELF,%ecx 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 9291 ADVANCE_PC 4 9292 SET_VREG %eax rINST 9293 GOTO_NEXT_R %ecx 9294 9295 /* 9296 * Go resolve the field 9297 */ 9298.LOP_SGET_BYTE_JUMBO_resolve: 9299 movl rSELF,%ecx 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) 9306 SPILL(rIBASE) 9307 call dvmResolveStaticField # eax<- resolved StaticField ptr 9308 UNSPILL(rIBASE) 9309 testl %eax,%eax 9310 jne .LOP_SGET_BYTE_JUMBO_finish # success, continue 9311 jmp common_exceptionThrown # no, handle exception 9312 9313 9314/* ------------------------------ */ 9315.L_OP_SGET_CHAR_JUMBO: /* 0x119 */ 9316/* File: x86/OP_SGET_CHAR_JUMBO.S */ 9317/* File: x86/OP_SGET_JUMBO.S */ 9318 /* 9319 * Jumbo 32-bit SGET handler. 9320 * 9321 * for: sget/jumbo, sget-object/jumbo, sget-boolean/jumbo, sget-byte/jumbo, 9322 * sget-char/jumbo, sget-short/jumbo 9323 */ 9324 /* exop vBBBB, field@AAAAAAAA */ 9325 movl rSELF,%ecx 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 9335 ADVANCE_PC 4 9336 SET_VREG %eax rINST 9337 GOTO_NEXT_R %ecx 9338 9339 /* 9340 * Go resolve the field 9341 */ 9342.LOP_SGET_CHAR_JUMBO_resolve: 9343 movl rSELF,%ecx 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) 9350 SPILL(rIBASE) 9351 call dvmResolveStaticField # eax<- resolved StaticField ptr 9352 UNSPILL(rIBASE) 9353 testl %eax,%eax 9354 jne .LOP_SGET_CHAR_JUMBO_finish # success, continue 9355 jmp common_exceptionThrown # no, handle exception 9356 9357 9358/* ------------------------------ */ 9359.L_OP_SGET_SHORT_JUMBO: /* 0x11a */ 9360/* File: x86/OP_SGET_SHORT_JUMBO.S */ 9361/* File: x86/OP_SGET_JUMBO.S */ 9362 /* 9363 * Jumbo 32-bit SGET handler. 9364 * 9365 * for: sget/jumbo, sget-object/jumbo, sget-boolean/jumbo, sget-byte/jumbo, 9366 * sget-char/jumbo, sget-short/jumbo 9367 */ 9368 /* exop vBBBB, field@AAAAAAAA */ 9369 movl rSELF,%ecx 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 9379 ADVANCE_PC 4 9380 SET_VREG %eax rINST 9381 GOTO_NEXT_R %ecx 9382 9383 /* 9384 * Go resolve the field 9385 */ 9386.LOP_SGET_SHORT_JUMBO_resolve: 9387 movl rSELF,%ecx 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) 9394 SPILL(rIBASE) 9395 call dvmResolveStaticField # eax<- resolved StaticField ptr 9396 UNSPILL(rIBASE) 9397 testl %eax,%eax 9398 jne .LOP_SGET_SHORT_JUMBO_finish # success, continue 9399 jmp common_exceptionThrown # no, handle exception 9400 9401 9402/* ------------------------------ */ 9403.L_OP_SPUT_JUMBO: /* 0x11b */ 9404/* File: x86/OP_SPUT_JUMBO.S */ 9405 /* 9406 * Jumbo 32-bit SPUT handler. 9407 * 9408 * for: sput/jumbo, sput-boolean/jumbo, sput-byte/jumbo, sput-char/jumbo, 9409 * sput-short/jumbo 9410 */ 9411 /* exop vBBBB, field@AAAAAAAA */ 9412 movl rSELF,%ecx 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 9422 ADVANCE_PC 4 9423 movl rINST,offStaticField_value(%eax) 9424 GOTO_NEXT_R %ecx 9425 9426 /* 9427 * Go resolve the field 9428 */ 9429.LOP_SPUT_JUMBO_resolve: 9430 movl rSELF,%ecx 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) 9437 SPILL(rIBASE) 9438 call dvmResolveStaticField # eax<- resolved StaticField ptr 9439 UNSPILL(rIBASE) 9440 testl %eax,%eax 9441 jne .LOP_SPUT_JUMBO_finish # success, continue 9442 jmp common_exceptionThrown # no, handle exception 9443 9444/* ------------------------------ */ 9445.L_OP_SPUT_WIDE_JUMBO: /* 0x11c */ 9446/* File: x86/OP_SPUT_WIDE_JUMBO.S */ 9447 /* 9448 * Jumbo 64-bit SPUT handler. 9449 */ 9450 /* sput-wide/jumbo vBBBB, field@AAAAAAAA */ 9451 movl rSELF,%ecx 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) 9464 ADVANCE_PC 4 9465 GOTO_NEXT_R %ecx 9466 9467 /* 9468 * Go resolve the field 9469 */ 9470.LOP_SPUT_WIDE_JUMBO_resolve: 9471 movl rSELF,%ecx 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) 9478 SPILL(rIBASE) 9479 call dvmResolveStaticField # eax<- resolved StaticField ptr 9480 UNSPILL(rIBASE) 9481 testl %eax,%eax 9482 jne .LOP_SPUT_WIDE_JUMBO_finish # success, continue 9483 jmp common_exceptionThrown # no, handle exception 9484 9485/* ------------------------------ */ 9486.L_OP_SPUT_OBJECT_JUMBO: /* 0x11d */ 9487/* File: x86/OP_SPUT_OBJECT_JUMBO.S */ 9488 /* 9489 * Jumbo SPUT object handler. 9490 */ 9491 /* sput-object/jumbo vBBBB, field@AAAAAAAA */ 9492 movl rSELF,%ecx 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 9504 movl rSELF,%ecx 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 95091: 9510 FETCH_INST_OPCODE 4 %ecx 9511 ADVANCE_PC 4 9512 GOTO_NEXT_R %ecx 9513 9514.LOP_SPUT_OBJECT_JUMBO_resolve: 9515 movl rSELF,%ecx 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) 9522 SPILL(rIBASE) 9523 call dvmResolveStaticField # eax<- resolved StaticField ptr 9524 UNSPILL(rIBASE) 9525 testl %eax,%eax 9526 jne .LOP_SPUT_OBJECT_JUMBO_finish # success, continue 9527 jmp common_exceptionThrown # no, handle exception 9528 9529/* ------------------------------ */ 9530.L_OP_SPUT_BOOLEAN_JUMBO: /* 0x11e */ 9531/* File: x86/OP_SPUT_BOOLEAN_JUMBO.S */ 9532/* File: x86/OP_SPUT_JUMBO.S */ 9533 /* 9534 * Jumbo 32-bit SPUT handler. 9535 * 9536 * for: sput/jumbo, sput-boolean/jumbo, sput-byte/jumbo, sput-char/jumbo, 9537 * sput-short/jumbo 9538 */ 9539 /* exop vBBBB, field@AAAAAAAA */ 9540 movl rSELF,%ecx 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 9550 ADVANCE_PC 4 9551 movl rINST,offStaticField_value(%eax) 9552 GOTO_NEXT_R %ecx 9553 9554 /* 9555 * Go resolve the field 9556 */ 9557.LOP_SPUT_BOOLEAN_JUMBO_resolve: 9558 movl rSELF,%ecx 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) 9565 SPILL(rIBASE) 9566 call dvmResolveStaticField # eax<- resolved StaticField ptr 9567 UNSPILL(rIBASE) 9568 testl %eax,%eax 9569 jne .LOP_SPUT_BOOLEAN_JUMBO_finish # success, continue 9570 jmp common_exceptionThrown # no, handle exception 9571 9572 9573/* ------------------------------ */ 9574.L_OP_SPUT_BYTE_JUMBO: /* 0x11f */ 9575/* File: x86/OP_SPUT_BYTE_JUMBO.S */ 9576/* File: x86/OP_SPUT_JUMBO.S */ 9577 /* 9578 * Jumbo 32-bit SPUT handler. 9579 * 9580 * for: sput/jumbo, sput-boolean/jumbo, sput-byte/jumbo, sput-char/jumbo, 9581 * sput-short/jumbo 9582 */ 9583 /* exop vBBBB, field@AAAAAAAA */ 9584 movl rSELF,%ecx 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 9594 ADVANCE_PC 4 9595 movl rINST,offStaticField_value(%eax) 9596 GOTO_NEXT_R %ecx 9597 9598 /* 9599 * Go resolve the field 9600 */ 9601.LOP_SPUT_BYTE_JUMBO_resolve: 9602 movl rSELF,%ecx 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) 9609 SPILL(rIBASE) 9610 call dvmResolveStaticField # eax<- resolved StaticField ptr 9611 UNSPILL(rIBASE) 9612 testl %eax,%eax 9613 jne .LOP_SPUT_BYTE_JUMBO_finish # success, continue 9614 jmp common_exceptionThrown # no, handle exception 9615 9616 9617/* ------------------------------ */ 9618.L_OP_SPUT_CHAR_JUMBO: /* 0x120 */ 9619/* File: x86/OP_SPUT_CHAR_JUMBO.S */ 9620/* File: x86/OP_SPUT_JUMBO.S */ 9621 /* 9622 * Jumbo 32-bit SPUT handler. 9623 * 9624 * for: sput/jumbo, sput-boolean/jumbo, sput-byte/jumbo, sput-char/jumbo, 9625 * sput-short/jumbo 9626 */ 9627 /* exop vBBBB, field@AAAAAAAA */ 9628 movl rSELF,%ecx 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 9638 ADVANCE_PC 4 9639 movl rINST,offStaticField_value(%eax) 9640 GOTO_NEXT_R %ecx 9641 9642 /* 9643 * Go resolve the field 9644 */ 9645.LOP_SPUT_CHAR_JUMBO_resolve: 9646 movl rSELF,%ecx 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) 9653 SPILL(rIBASE) 9654 call dvmResolveStaticField # eax<- resolved StaticField ptr 9655 UNSPILL(rIBASE) 9656 testl %eax,%eax 9657 jne .LOP_SPUT_CHAR_JUMBO_finish # success, continue 9658 jmp common_exceptionThrown # no, handle exception 9659 9660 9661/* ------------------------------ */ 9662.L_OP_SPUT_SHORT_JUMBO: /* 0x121 */ 9663/* File: x86/OP_SPUT_SHORT_JUMBO.S */ 9664/* File: x86/OP_SPUT_JUMBO.S */ 9665 /* 9666 * Jumbo 32-bit SPUT handler. 9667 * 9668 * for: sput/jumbo, sput-boolean/jumbo, sput-byte/jumbo, sput-char/jumbo, 9669 * sput-short/jumbo 9670 */ 9671 /* exop vBBBB, field@AAAAAAAA */ 9672 movl rSELF,%ecx 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 9682 ADVANCE_PC 4 9683 movl rINST,offStaticField_value(%eax) 9684 GOTO_NEXT_R %ecx 9685 9686 /* 9687 * Go resolve the field 9688 */ 9689.LOP_SPUT_SHORT_JUMBO_resolve: 9690 movl rSELF,%ecx 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) 9697 SPILL(rIBASE) 9698 call dvmResolveStaticField # eax<- resolved StaticField ptr 9699 UNSPILL(rIBASE) 9700 testl %eax,%eax 9701 jne .LOP_SPUT_SHORT_JUMBO_finish # success, continue 9702 jmp common_exceptionThrown # no, handle exception 9703 9704 9705/* ------------------------------ */ 9706.L_OP_INVOKE_VIRTUAL_JUMBO: /* 0x122 */ 9707/* File: x86/OP_INVOKE_VIRTUAL_JUMBO.S */ 9708 /* 9709 * Handle a jumbo virtual method call. 9710 */ 9711 /* invoke-virtual/jumbo vBBBB, {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */ 9712 movl rSELF,%eax 9713 movl 2(rPC),%ecx # ecx<- AAAAAAAA 9714 movl offThread_methodClassDex(%eax),%eax # eax<- pDvmDex 9715 EXPORT_PC 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 9720 movl rSELF,%eax 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 9730 9731 /* At this point: 9732 * eax = resolved base method 9733 * ecx = scratch 9734 */ 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 9745 9746/* ------------------------------ */ 9747.L_OP_INVOKE_SUPER_JUMBO: /* 0x123 */ 9748/* File: x86/OP_INVOKE_SUPER_JUMBO.S */ 9749 /* 9750 * Handle a jumbo "super" method call. 9751 */ 9752 /* invoke-super/jumbo {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */ 9753 movl rSELF,rINST 9754 movl 2(rPC),%eax # eax<- AAAAAAAA 9755 movl offThread_methodClassDex(rINST),%ecx # ecx<- pDvmDex 9756 EXPORT_PC 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 9767 /* 9768 * At this point: 9769 * ecx = resolved base method [r0] 9770 * eax = method->clazz [r9] 9771 */ 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 9780 9781 9782 /* At this point: 9783 * ecx = null (needs to be resolved base method) 9784 * eax = method->clazz 9785 */ 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 9798 9799 /* 9800 * Throw a NoSuchMethodError with the method name as the message. 9801 * ecx = resolved base method 9802 */ 9803.LOP_INVOKE_SUPER_JUMBO_nsm: 9804 movl offMethod_name(%ecx),%eax 9805 jmp common_errNoSuchMethod 9806 9807/* ------------------------------ */ 9808.L_OP_INVOKE_DIRECT_JUMBO: /* 0x124 */ 9809/* File: x86/OP_INVOKE_DIRECT_JUMBO.S */ 9810 /* 9811 * Handle a jumbo direct method call. 9812 * 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.) 9817 */ 9818 /* invoke-direct/jumbo {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */ 9819 movl rSELF,%ecx 9820 movl 2(rPC),%eax # eax<- AAAAAAAA 9821 movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex 9822 EXPORT_PC 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 9833 9834 /* 9835 * On entry: 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. 9839 */ 9840.LOP_INVOKE_DIRECT_JUMBO_resolve: 9841 SPILL_TMP1(%ecx) 9842 movl rSELF,%ecx 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) 9850 UNSPILL_TMP1(%ecx) 9851 testl %eax,%eax 9852 jne .LOP_INVOKE_DIRECT_JUMBO_finish 9853 jmp common_exceptionThrown 9854 9855/* ------------------------------ */ 9856.L_OP_INVOKE_STATIC_JUMBO: /* 0x125 */ 9857/* File: x86/OP_INVOKE_STATIC_JUMBO.S */ 9858 /* 9859 * Handle a jumbo static method call. 9860 */ 9861 /* invoke-static/jumbo {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */ 9862 movl rSELF,%ecx 9863 movl 2(rPC),%eax # eax<- AAAAAAAA 9864 movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex 9865 EXPORT_PC 9866 movl offDvmDex_pResMethods(%ecx),%ecx # ecx<- pDvmDex->pResMethods 9867 movl (%ecx,%eax,4),%eax # eax<- resolved methodToCall 9868 testl %eax,%eax 9869 jne common_invokeMethodJumbo 9870 movl rSELF,%ecx 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 9882 9883/* ------------------------------ */ 9884.L_OP_INVOKE_INTERFACE_JUMBO: /* 0x126 */ 9885/* File: x86/OP_INVOKE_INTERFACE_JUMBO.S */ 9886 /* 9887 * Handle a jumbo interface method call. 9888 */ 9889 /* invoke-interface/jumbo {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */ 9890 movzwl 8(rPC),%eax # eax<- CCCC 9891 movl rSELF,%ecx 9892 GET_VREG_R %eax %eax # eax<- "this" 9893 EXPORT_PC 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) 9905 testl %eax,%eax 9906 je common_exceptionThrown 9907 jmp common_invokeMethodJumbo 9908 9909/* ------------------------------ */ 9910.L_OP_UNUSED_27FF: /* 0x127 */ 9911/* File: x86/OP_UNUSED_27FF.S */ 9912/* File: x86/unused.S */ 9913 jmp common_abort 9914 9915 9916/* ------------------------------ */ 9917.L_OP_UNUSED_28FF: /* 0x128 */ 9918/* File: x86/OP_UNUSED_28FF.S */ 9919/* File: x86/unused.S */ 9920 jmp common_abort 9921 9922 9923/* ------------------------------ */ 9924.L_OP_UNUSED_29FF: /* 0x129 */ 9925/* File: x86/OP_UNUSED_29FF.S */ 9926/* File: x86/unused.S */ 9927 jmp common_abort 9928 9929 9930/* ------------------------------ */ 9931.L_OP_UNUSED_2AFF: /* 0x12a */ 9932/* File: x86/OP_UNUSED_2AFF.S */ 9933/* File: x86/unused.S */ 9934 jmp common_abort 9935 9936 9937/* ------------------------------ */ 9938.L_OP_UNUSED_2BFF: /* 0x12b */ 9939/* File: x86/OP_UNUSED_2BFF.S */ 9940/* File: x86/unused.S */ 9941 jmp common_abort 9942 9943 9944/* ------------------------------ */ 9945.L_OP_UNUSED_2CFF: /* 0x12c */ 9946/* File: x86/OP_UNUSED_2CFF.S */ 9947/* File: x86/unused.S */ 9948 jmp common_abort 9949 9950 9951/* ------------------------------ */ 9952.L_OP_UNUSED_2DFF: /* 0x12d */ 9953/* File: x86/OP_UNUSED_2DFF.S */ 9954/* File: x86/unused.S */ 9955 jmp common_abort 9956 9957 9958/* ------------------------------ */ 9959.L_OP_UNUSED_2EFF: /* 0x12e */ 9960/* File: x86/OP_UNUSED_2EFF.S */ 9961/* File: x86/unused.S */ 9962 jmp common_abort 9963 9964 9965/* ------------------------------ */ 9966.L_OP_UNUSED_2FFF: /* 0x12f */ 9967/* File: x86/OP_UNUSED_2FFF.S */ 9968/* File: x86/unused.S */ 9969 jmp common_abort 9970 9971 9972/* ------------------------------ */ 9973.L_OP_UNUSED_30FF: /* 0x130 */ 9974/* File: x86/OP_UNUSED_30FF.S */ 9975/* File: x86/unused.S */ 9976 jmp common_abort 9977 9978 9979/* ------------------------------ */ 9980.L_OP_UNUSED_31FF: /* 0x131 */ 9981/* File: x86/OP_UNUSED_31FF.S */ 9982/* File: x86/unused.S */ 9983 jmp common_abort 9984 9985 9986/* ------------------------------ */ 9987.L_OP_UNUSED_32FF: /* 0x132 */ 9988/* File: x86/OP_UNUSED_32FF.S */ 9989/* File: x86/unused.S */ 9990 jmp common_abort 9991 9992 9993/* ------------------------------ */ 9994.L_OP_UNUSED_33FF: /* 0x133 */ 9995/* File: x86/OP_UNUSED_33FF.S */ 9996/* File: x86/unused.S */ 9997 jmp common_abort 9998 9999 10000/* ------------------------------ */ 10001.L_OP_UNUSED_34FF: /* 0x134 */ 10002/* File: x86/OP_UNUSED_34FF.S */ 10003/* File: x86/unused.S */ 10004 jmp common_abort 10005 10006 10007/* ------------------------------ */ 10008.L_OP_UNUSED_35FF: /* 0x135 */ 10009/* File: x86/OP_UNUSED_35FF.S */ 10010/* File: x86/unused.S */ 10011 jmp common_abort 10012 10013 10014/* ------------------------------ */ 10015.L_OP_UNUSED_36FF: /* 0x136 */ 10016/* File: x86/OP_UNUSED_36FF.S */ 10017/* File: x86/unused.S */ 10018 jmp common_abort 10019 10020 10021/* ------------------------------ */ 10022.L_OP_UNUSED_37FF: /* 0x137 */ 10023/* File: x86/OP_UNUSED_37FF.S */ 10024/* File: x86/unused.S */ 10025 jmp common_abort 10026 10027 10028/* ------------------------------ */ 10029.L_OP_UNUSED_38FF: /* 0x138 */ 10030/* File: x86/OP_UNUSED_38FF.S */ 10031/* File: x86/unused.S */ 10032 jmp common_abort 10033 10034 10035/* ------------------------------ */ 10036.L_OP_UNUSED_39FF: /* 0x139 */ 10037/* File: x86/OP_UNUSED_39FF.S */ 10038/* File: x86/unused.S */ 10039 jmp common_abort 10040 10041 10042/* ------------------------------ */ 10043.L_OP_UNUSED_3AFF: /* 0x13a */ 10044/* File: x86/OP_UNUSED_3AFF.S */ 10045/* File: x86/unused.S */ 10046 jmp common_abort 10047 10048 10049/* ------------------------------ */ 10050.L_OP_UNUSED_3BFF: /* 0x13b */ 10051/* File: x86/OP_UNUSED_3BFF.S */ 10052/* File: x86/unused.S */ 10053 jmp common_abort 10054 10055 10056/* ------------------------------ */ 10057.L_OP_UNUSED_3CFF: /* 0x13c */ 10058/* File: x86/OP_UNUSED_3CFF.S */ 10059/* File: x86/unused.S */ 10060 jmp common_abort 10061 10062 10063/* ------------------------------ */ 10064.L_OP_UNUSED_3DFF: /* 0x13d */ 10065/* File: x86/OP_UNUSED_3DFF.S */ 10066/* File: x86/unused.S */ 10067 jmp common_abort 10068 10069 10070/* ------------------------------ */ 10071.L_OP_UNUSED_3EFF: /* 0x13e */ 10072/* File: x86/OP_UNUSED_3EFF.S */ 10073/* File: x86/unused.S */ 10074 jmp common_abort 10075 10076 10077/* ------------------------------ */ 10078.L_OP_UNUSED_3FFF: /* 0x13f */ 10079/* File: x86/OP_UNUSED_3FFF.S */ 10080/* File: x86/unused.S */ 10081 jmp common_abort 10082 10083 10084/* ------------------------------ */ 10085.L_OP_UNUSED_40FF: /* 0x140 */ 10086/* File: x86/OP_UNUSED_40FF.S */ 10087/* File: x86/unused.S */ 10088 jmp common_abort 10089 10090 10091/* ------------------------------ */ 10092.L_OP_UNUSED_41FF: /* 0x141 */ 10093/* File: x86/OP_UNUSED_41FF.S */ 10094/* File: x86/unused.S */ 10095 jmp common_abort 10096 10097 10098/* ------------------------------ */ 10099.L_OP_UNUSED_42FF: /* 0x142 */ 10100/* File: x86/OP_UNUSED_42FF.S */ 10101/* File: x86/unused.S */ 10102 jmp common_abort 10103 10104 10105/* ------------------------------ */ 10106.L_OP_UNUSED_43FF: /* 0x143 */ 10107/* File: x86/OP_UNUSED_43FF.S */ 10108/* File: x86/unused.S */ 10109 jmp common_abort 10110 10111 10112/* ------------------------------ */ 10113.L_OP_UNUSED_44FF: /* 0x144 */ 10114/* File: x86/OP_UNUSED_44FF.S */ 10115/* File: x86/unused.S */ 10116 jmp common_abort 10117 10118 10119/* ------------------------------ */ 10120.L_OP_UNUSED_45FF: /* 0x145 */ 10121/* File: x86/OP_UNUSED_45FF.S */ 10122/* File: x86/unused.S */ 10123 jmp common_abort 10124 10125 10126/* ------------------------------ */ 10127.L_OP_UNUSED_46FF: /* 0x146 */ 10128/* File: x86/OP_UNUSED_46FF.S */ 10129/* File: x86/unused.S */ 10130 jmp common_abort 10131 10132 10133/* ------------------------------ */ 10134.L_OP_UNUSED_47FF: /* 0x147 */ 10135/* File: x86/OP_UNUSED_47FF.S */ 10136/* File: x86/unused.S */ 10137 jmp common_abort 10138 10139 10140/* ------------------------------ */ 10141.L_OP_UNUSED_48FF: /* 0x148 */ 10142/* File: x86/OP_UNUSED_48FF.S */ 10143/* File: x86/unused.S */ 10144 jmp common_abort 10145 10146 10147/* ------------------------------ */ 10148.L_OP_UNUSED_49FF: /* 0x149 */ 10149/* File: x86/OP_UNUSED_49FF.S */ 10150/* File: x86/unused.S */ 10151 jmp common_abort 10152 10153 10154/* ------------------------------ */ 10155.L_OP_UNUSED_4AFF: /* 0x14a */ 10156/* File: x86/OP_UNUSED_4AFF.S */ 10157/* File: x86/unused.S */ 10158 jmp common_abort 10159 10160 10161/* ------------------------------ */ 10162.L_OP_UNUSED_4BFF: /* 0x14b */ 10163/* File: x86/OP_UNUSED_4BFF.S */ 10164/* File: x86/unused.S */ 10165 jmp common_abort 10166 10167 10168/* ------------------------------ */ 10169.L_OP_UNUSED_4CFF: /* 0x14c */ 10170/* File: x86/OP_UNUSED_4CFF.S */ 10171/* File: x86/unused.S */ 10172 jmp common_abort 10173 10174 10175/* ------------------------------ */ 10176.L_OP_UNUSED_4DFF: /* 0x14d */ 10177/* File: x86/OP_UNUSED_4DFF.S */ 10178/* File: x86/unused.S */ 10179 jmp common_abort 10180 10181 10182/* ------------------------------ */ 10183.L_OP_UNUSED_4EFF: /* 0x14e */ 10184/* File: x86/OP_UNUSED_4EFF.S */ 10185/* File: x86/unused.S */ 10186 jmp common_abort 10187 10188 10189/* ------------------------------ */ 10190.L_OP_UNUSED_4FFF: /* 0x14f */ 10191/* File: x86/OP_UNUSED_4FFF.S */ 10192/* File: x86/unused.S */ 10193 jmp common_abort 10194 10195 10196/* ------------------------------ */ 10197.L_OP_UNUSED_50FF: /* 0x150 */ 10198/* File: x86/OP_UNUSED_50FF.S */ 10199/* File: x86/unused.S */ 10200 jmp common_abort 10201 10202 10203/* ------------------------------ */ 10204.L_OP_UNUSED_51FF: /* 0x151 */ 10205/* File: x86/OP_UNUSED_51FF.S */ 10206/* File: x86/unused.S */ 10207 jmp common_abort 10208 10209 10210/* ------------------------------ */ 10211.L_OP_UNUSED_52FF: /* 0x152 */ 10212/* File: x86/OP_UNUSED_52FF.S */ 10213/* File: x86/unused.S */ 10214 jmp common_abort 10215 10216 10217/* ------------------------------ */ 10218.L_OP_UNUSED_53FF: /* 0x153 */ 10219/* File: x86/OP_UNUSED_53FF.S */ 10220/* File: x86/unused.S */ 10221 jmp common_abort 10222 10223 10224/* ------------------------------ */ 10225.L_OP_UNUSED_54FF: /* 0x154 */ 10226/* File: x86/OP_UNUSED_54FF.S */ 10227/* File: x86/unused.S */ 10228 jmp common_abort 10229 10230 10231/* ------------------------------ */ 10232.L_OP_UNUSED_55FF: /* 0x155 */ 10233/* File: x86/OP_UNUSED_55FF.S */ 10234/* File: x86/unused.S */ 10235 jmp common_abort 10236 10237 10238/* ------------------------------ */ 10239.L_OP_UNUSED_56FF: /* 0x156 */ 10240/* File: x86/OP_UNUSED_56FF.S */ 10241/* File: x86/unused.S */ 10242 jmp common_abort 10243 10244 10245/* ------------------------------ */ 10246.L_OP_UNUSED_57FF: /* 0x157 */ 10247/* File: x86/OP_UNUSED_57FF.S */ 10248/* File: x86/unused.S */ 10249 jmp common_abort 10250 10251 10252/* ------------------------------ */ 10253.L_OP_UNUSED_58FF: /* 0x158 */ 10254/* File: x86/OP_UNUSED_58FF.S */ 10255/* File: x86/unused.S */ 10256 jmp common_abort 10257 10258 10259/* ------------------------------ */ 10260.L_OP_UNUSED_59FF: /* 0x159 */ 10261/* File: x86/OP_UNUSED_59FF.S */ 10262/* File: x86/unused.S */ 10263 jmp common_abort 10264 10265 10266/* ------------------------------ */ 10267.L_OP_UNUSED_5AFF: /* 0x15a */ 10268/* File: x86/OP_UNUSED_5AFF.S */ 10269/* File: x86/unused.S */ 10270 jmp common_abort 10271 10272 10273/* ------------------------------ */ 10274.L_OP_UNUSED_5BFF: /* 0x15b */ 10275/* File: x86/OP_UNUSED_5BFF.S */ 10276/* File: x86/unused.S */ 10277 jmp common_abort 10278 10279 10280/* ------------------------------ */ 10281.L_OP_UNUSED_5CFF: /* 0x15c */ 10282/* File: x86/OP_UNUSED_5CFF.S */ 10283/* File: x86/unused.S */ 10284 jmp common_abort 10285 10286 10287/* ------------------------------ */ 10288.L_OP_UNUSED_5DFF: /* 0x15d */ 10289/* File: x86/OP_UNUSED_5DFF.S */ 10290/* File: x86/unused.S */ 10291 jmp common_abort 10292 10293 10294/* ------------------------------ */ 10295.L_OP_UNUSED_5EFF: /* 0x15e */ 10296/* File: x86/OP_UNUSED_5EFF.S */ 10297/* File: x86/unused.S */ 10298 jmp common_abort 10299 10300 10301/* ------------------------------ */ 10302.L_OP_UNUSED_5FFF: /* 0x15f */ 10303/* File: x86/OP_UNUSED_5FFF.S */ 10304/* File: x86/unused.S */ 10305 jmp common_abort 10306 10307 10308/* ------------------------------ */ 10309.L_OP_UNUSED_60FF: /* 0x160 */ 10310/* File: x86/OP_UNUSED_60FF.S */ 10311/* File: x86/unused.S */ 10312 jmp common_abort 10313 10314 10315/* ------------------------------ */ 10316.L_OP_UNUSED_61FF: /* 0x161 */ 10317/* File: x86/OP_UNUSED_61FF.S */ 10318/* File: x86/unused.S */ 10319 jmp common_abort 10320 10321 10322/* ------------------------------ */ 10323.L_OP_UNUSED_62FF: /* 0x162 */ 10324/* File: x86/OP_UNUSED_62FF.S */ 10325/* File: x86/unused.S */ 10326 jmp common_abort 10327 10328 10329/* ------------------------------ */ 10330.L_OP_UNUSED_63FF: /* 0x163 */ 10331/* File: x86/OP_UNUSED_63FF.S */ 10332/* File: x86/unused.S */ 10333 jmp common_abort 10334 10335 10336/* ------------------------------ */ 10337.L_OP_UNUSED_64FF: /* 0x164 */ 10338/* File: x86/OP_UNUSED_64FF.S */ 10339/* File: x86/unused.S */ 10340 jmp common_abort 10341 10342 10343/* ------------------------------ */ 10344.L_OP_UNUSED_65FF: /* 0x165 */ 10345/* File: x86/OP_UNUSED_65FF.S */ 10346/* File: x86/unused.S */ 10347 jmp common_abort 10348 10349 10350/* ------------------------------ */ 10351.L_OP_UNUSED_66FF: /* 0x166 */ 10352/* File: x86/OP_UNUSED_66FF.S */ 10353/* File: x86/unused.S */ 10354 jmp common_abort 10355 10356 10357/* ------------------------------ */ 10358.L_OP_UNUSED_67FF: /* 0x167 */ 10359/* File: x86/OP_UNUSED_67FF.S */ 10360/* File: x86/unused.S */ 10361 jmp common_abort 10362 10363 10364/* ------------------------------ */ 10365.L_OP_UNUSED_68FF: /* 0x168 */ 10366/* File: x86/OP_UNUSED_68FF.S */ 10367/* File: x86/unused.S */ 10368 jmp common_abort 10369 10370 10371/* ------------------------------ */ 10372.L_OP_UNUSED_69FF: /* 0x169 */ 10373/* File: x86/OP_UNUSED_69FF.S */ 10374/* File: x86/unused.S */ 10375 jmp common_abort 10376 10377 10378/* ------------------------------ */ 10379.L_OP_UNUSED_6AFF: /* 0x16a */ 10380/* File: x86/OP_UNUSED_6AFF.S */ 10381/* File: x86/unused.S */ 10382 jmp common_abort 10383 10384 10385/* ------------------------------ */ 10386.L_OP_UNUSED_6BFF: /* 0x16b */ 10387/* File: x86/OP_UNUSED_6BFF.S */ 10388/* File: x86/unused.S */ 10389 jmp common_abort 10390 10391 10392/* ------------------------------ */ 10393.L_OP_UNUSED_6CFF: /* 0x16c */ 10394/* File: x86/OP_UNUSED_6CFF.S */ 10395/* File: x86/unused.S */ 10396 jmp common_abort 10397 10398 10399/* ------------------------------ */ 10400.L_OP_UNUSED_6DFF: /* 0x16d */ 10401/* File: x86/OP_UNUSED_6DFF.S */ 10402/* File: x86/unused.S */ 10403 jmp common_abort 10404 10405 10406/* ------------------------------ */ 10407.L_OP_UNUSED_6EFF: /* 0x16e */ 10408/* File: x86/OP_UNUSED_6EFF.S */ 10409/* File: x86/unused.S */ 10410 jmp common_abort 10411 10412 10413/* ------------------------------ */ 10414.L_OP_UNUSED_6FFF: /* 0x16f */ 10415/* File: x86/OP_UNUSED_6FFF.S */ 10416/* File: x86/unused.S */ 10417 jmp common_abort 10418 10419 10420/* ------------------------------ */ 10421.L_OP_UNUSED_70FF: /* 0x170 */ 10422/* File: x86/OP_UNUSED_70FF.S */ 10423/* File: x86/unused.S */ 10424 jmp common_abort 10425 10426 10427/* ------------------------------ */ 10428.L_OP_UNUSED_71FF: /* 0x171 */ 10429/* File: x86/OP_UNUSED_71FF.S */ 10430/* File: x86/unused.S */ 10431 jmp common_abort 10432 10433 10434/* ------------------------------ */ 10435.L_OP_UNUSED_72FF: /* 0x172 */ 10436/* File: x86/OP_UNUSED_72FF.S */ 10437/* File: x86/unused.S */ 10438 jmp common_abort 10439 10440 10441/* ------------------------------ */ 10442.L_OP_UNUSED_73FF: /* 0x173 */ 10443/* File: x86/OP_UNUSED_73FF.S */ 10444/* File: x86/unused.S */ 10445 jmp common_abort 10446 10447 10448/* ------------------------------ */ 10449.L_OP_UNUSED_74FF: /* 0x174 */ 10450/* File: x86/OP_UNUSED_74FF.S */ 10451/* File: x86/unused.S */ 10452 jmp common_abort 10453 10454 10455/* ------------------------------ */ 10456.L_OP_UNUSED_75FF: /* 0x175 */ 10457/* File: x86/OP_UNUSED_75FF.S */ 10458/* File: x86/unused.S */ 10459 jmp common_abort 10460 10461 10462/* ------------------------------ */ 10463.L_OP_UNUSED_76FF: /* 0x176 */ 10464/* File: x86/OP_UNUSED_76FF.S */ 10465/* File: x86/unused.S */ 10466 jmp common_abort 10467 10468 10469/* ------------------------------ */ 10470.L_OP_UNUSED_77FF: /* 0x177 */ 10471/* File: x86/OP_UNUSED_77FF.S */ 10472/* File: x86/unused.S */ 10473 jmp common_abort 10474 10475 10476/* ------------------------------ */ 10477.L_OP_UNUSED_78FF: /* 0x178 */ 10478/* File: x86/OP_UNUSED_78FF.S */ 10479/* File: x86/unused.S */ 10480 jmp common_abort 10481 10482 10483/* ------------------------------ */ 10484.L_OP_UNUSED_79FF: /* 0x179 */ 10485/* File: x86/OP_UNUSED_79FF.S */ 10486/* File: x86/unused.S */ 10487 jmp common_abort 10488 10489 10490/* ------------------------------ */ 10491.L_OP_UNUSED_7AFF: /* 0x17a */ 10492/* File: x86/OP_UNUSED_7AFF.S */ 10493/* File: x86/unused.S */ 10494 jmp common_abort 10495 10496 10497/* ------------------------------ */ 10498.L_OP_UNUSED_7BFF: /* 0x17b */ 10499/* File: x86/OP_UNUSED_7BFF.S */ 10500/* File: x86/unused.S */ 10501 jmp common_abort 10502 10503 10504/* ------------------------------ */ 10505.L_OP_UNUSED_7CFF: /* 0x17c */ 10506/* File: x86/OP_UNUSED_7CFF.S */ 10507/* File: x86/unused.S */ 10508 jmp common_abort 10509 10510 10511/* ------------------------------ */ 10512.L_OP_UNUSED_7DFF: /* 0x17d */ 10513/* File: x86/OP_UNUSED_7DFF.S */ 10514/* File: x86/unused.S */ 10515 jmp common_abort 10516 10517 10518/* ------------------------------ */ 10519.L_OP_UNUSED_7EFF: /* 0x17e */ 10520/* File: x86/OP_UNUSED_7EFF.S */ 10521/* File: x86/unused.S */ 10522 jmp common_abort 10523 10524 10525/* ------------------------------ */ 10526.L_OP_UNUSED_7FFF: /* 0x17f */ 10527/* File: x86/OP_UNUSED_7FFF.S */ 10528/* File: x86/unused.S */ 10529 jmp common_abort 10530 10531 10532/* ------------------------------ */ 10533.L_OP_UNUSED_80FF: /* 0x180 */ 10534/* File: x86/OP_UNUSED_80FF.S */ 10535/* File: x86/unused.S */ 10536 jmp common_abort 10537 10538 10539/* ------------------------------ */ 10540.L_OP_UNUSED_81FF: /* 0x181 */ 10541/* File: x86/OP_UNUSED_81FF.S */ 10542/* File: x86/unused.S */ 10543 jmp common_abort 10544 10545 10546/* ------------------------------ */ 10547.L_OP_UNUSED_82FF: /* 0x182 */ 10548/* File: x86/OP_UNUSED_82FF.S */ 10549/* File: x86/unused.S */ 10550 jmp common_abort 10551 10552 10553/* ------------------------------ */ 10554.L_OP_UNUSED_83FF: /* 0x183 */ 10555/* File: x86/OP_UNUSED_83FF.S */ 10556/* File: x86/unused.S */ 10557 jmp common_abort 10558 10559 10560/* ------------------------------ */ 10561.L_OP_UNUSED_84FF: /* 0x184 */ 10562/* File: x86/OP_UNUSED_84FF.S */ 10563/* File: x86/unused.S */ 10564 jmp common_abort 10565 10566 10567/* ------------------------------ */ 10568.L_OP_UNUSED_85FF: /* 0x185 */ 10569/* File: x86/OP_UNUSED_85FF.S */ 10570/* File: x86/unused.S */ 10571 jmp common_abort 10572 10573 10574/* ------------------------------ */ 10575.L_OP_UNUSED_86FF: /* 0x186 */ 10576/* File: x86/OP_UNUSED_86FF.S */ 10577/* File: x86/unused.S */ 10578 jmp common_abort 10579 10580 10581/* ------------------------------ */ 10582.L_OP_UNUSED_87FF: /* 0x187 */ 10583/* File: x86/OP_UNUSED_87FF.S */ 10584/* File: x86/unused.S */ 10585 jmp common_abort 10586 10587 10588/* ------------------------------ */ 10589.L_OP_UNUSED_88FF: /* 0x188 */ 10590/* File: x86/OP_UNUSED_88FF.S */ 10591/* File: x86/unused.S */ 10592 jmp common_abort 10593 10594 10595/* ------------------------------ */ 10596.L_OP_UNUSED_89FF: /* 0x189 */ 10597/* File: x86/OP_UNUSED_89FF.S */ 10598/* File: x86/unused.S */ 10599 jmp common_abort 10600 10601 10602/* ------------------------------ */ 10603.L_OP_UNUSED_8AFF: /* 0x18a */ 10604/* File: x86/OP_UNUSED_8AFF.S */ 10605/* File: x86/unused.S */ 10606 jmp common_abort 10607 10608 10609/* ------------------------------ */ 10610.L_OP_UNUSED_8BFF: /* 0x18b */ 10611/* File: x86/OP_UNUSED_8BFF.S */ 10612/* File: x86/unused.S */ 10613 jmp common_abort 10614 10615 10616/* ------------------------------ */ 10617.L_OP_UNUSED_8CFF: /* 0x18c */ 10618/* File: x86/OP_UNUSED_8CFF.S */ 10619/* File: x86/unused.S */ 10620 jmp common_abort 10621 10622 10623/* ------------------------------ */ 10624.L_OP_UNUSED_8DFF: /* 0x18d */ 10625/* File: x86/OP_UNUSED_8DFF.S */ 10626/* File: x86/unused.S */ 10627 jmp common_abort 10628 10629 10630/* ------------------------------ */ 10631.L_OP_UNUSED_8EFF: /* 0x18e */ 10632/* File: x86/OP_UNUSED_8EFF.S */ 10633/* File: x86/unused.S */ 10634 jmp common_abort 10635 10636 10637/* ------------------------------ */ 10638.L_OP_UNUSED_8FFF: /* 0x18f */ 10639/* File: x86/OP_UNUSED_8FFF.S */ 10640/* File: x86/unused.S */ 10641 jmp common_abort 10642 10643 10644/* ------------------------------ */ 10645.L_OP_UNUSED_90FF: /* 0x190 */ 10646/* File: x86/OP_UNUSED_90FF.S */ 10647/* File: x86/unused.S */ 10648 jmp common_abort 10649 10650 10651/* ------------------------------ */ 10652.L_OP_UNUSED_91FF: /* 0x191 */ 10653/* File: x86/OP_UNUSED_91FF.S */ 10654/* File: x86/unused.S */ 10655 jmp common_abort 10656 10657 10658/* ------------------------------ */ 10659.L_OP_UNUSED_92FF: /* 0x192 */ 10660/* File: x86/OP_UNUSED_92FF.S */ 10661/* File: x86/unused.S */ 10662 jmp common_abort 10663 10664 10665/* ------------------------------ */ 10666.L_OP_UNUSED_93FF: /* 0x193 */ 10667/* File: x86/OP_UNUSED_93FF.S */ 10668/* File: x86/unused.S */ 10669 jmp common_abort 10670 10671 10672/* ------------------------------ */ 10673.L_OP_UNUSED_94FF: /* 0x194 */ 10674/* File: x86/OP_UNUSED_94FF.S */ 10675/* File: x86/unused.S */ 10676 jmp common_abort 10677 10678 10679/* ------------------------------ */ 10680.L_OP_UNUSED_95FF: /* 0x195 */ 10681/* File: x86/OP_UNUSED_95FF.S */ 10682/* File: x86/unused.S */ 10683 jmp common_abort 10684 10685 10686/* ------------------------------ */ 10687.L_OP_UNUSED_96FF: /* 0x196 */ 10688/* File: x86/OP_UNUSED_96FF.S */ 10689/* File: x86/unused.S */ 10690 jmp common_abort 10691 10692 10693/* ------------------------------ */ 10694.L_OP_UNUSED_97FF: /* 0x197 */ 10695/* File: x86/OP_UNUSED_97FF.S */ 10696/* File: x86/unused.S */ 10697 jmp common_abort 10698 10699 10700/* ------------------------------ */ 10701.L_OP_UNUSED_98FF: /* 0x198 */ 10702/* File: x86/OP_UNUSED_98FF.S */ 10703/* File: x86/unused.S */ 10704 jmp common_abort 10705 10706 10707/* ------------------------------ */ 10708.L_OP_UNUSED_99FF: /* 0x199 */ 10709/* File: x86/OP_UNUSED_99FF.S */ 10710/* File: x86/unused.S */ 10711 jmp common_abort 10712 10713 10714/* ------------------------------ */ 10715.L_OP_UNUSED_9AFF: /* 0x19a */ 10716/* File: x86/OP_UNUSED_9AFF.S */ 10717/* File: x86/unused.S */ 10718 jmp common_abort 10719 10720 10721/* ------------------------------ */ 10722.L_OP_UNUSED_9BFF: /* 0x19b */ 10723/* File: x86/OP_UNUSED_9BFF.S */ 10724/* File: x86/unused.S */ 10725 jmp common_abort 10726 10727 10728/* ------------------------------ */ 10729.L_OP_UNUSED_9CFF: /* 0x19c */ 10730/* File: x86/OP_UNUSED_9CFF.S */ 10731/* File: x86/unused.S */ 10732 jmp common_abort 10733 10734 10735/* ------------------------------ */ 10736.L_OP_UNUSED_9DFF: /* 0x19d */ 10737/* File: x86/OP_UNUSED_9DFF.S */ 10738/* File: x86/unused.S */ 10739 jmp common_abort 10740 10741 10742/* ------------------------------ */ 10743.L_OP_UNUSED_9EFF: /* 0x19e */ 10744/* File: x86/OP_UNUSED_9EFF.S */ 10745/* File: x86/unused.S */ 10746 jmp common_abort 10747 10748 10749/* ------------------------------ */ 10750.L_OP_UNUSED_9FFF: /* 0x19f */ 10751/* File: x86/OP_UNUSED_9FFF.S */ 10752/* File: x86/unused.S */ 10753 jmp common_abort 10754 10755 10756/* ------------------------------ */ 10757.L_OP_UNUSED_A0FF: /* 0x1a0 */ 10758/* File: x86/OP_UNUSED_A0FF.S */ 10759/* File: x86/unused.S */ 10760 jmp common_abort 10761 10762 10763/* ------------------------------ */ 10764.L_OP_UNUSED_A1FF: /* 0x1a1 */ 10765/* File: x86/OP_UNUSED_A1FF.S */ 10766/* File: x86/unused.S */ 10767 jmp common_abort 10768 10769 10770/* ------------------------------ */ 10771.L_OP_UNUSED_A2FF: /* 0x1a2 */ 10772/* File: x86/OP_UNUSED_A2FF.S */ 10773/* File: x86/unused.S */ 10774 jmp common_abort 10775 10776 10777/* ------------------------------ */ 10778.L_OP_UNUSED_A3FF: /* 0x1a3 */ 10779/* File: x86/OP_UNUSED_A3FF.S */ 10780/* File: x86/unused.S */ 10781 jmp common_abort 10782 10783 10784/* ------------------------------ */ 10785.L_OP_UNUSED_A4FF: /* 0x1a4 */ 10786/* File: x86/OP_UNUSED_A4FF.S */ 10787/* File: x86/unused.S */ 10788 jmp common_abort 10789 10790 10791/* ------------------------------ */ 10792.L_OP_UNUSED_A5FF: /* 0x1a5 */ 10793/* File: x86/OP_UNUSED_A5FF.S */ 10794/* File: x86/unused.S */ 10795 jmp common_abort 10796 10797 10798/* ------------------------------ */ 10799.L_OP_UNUSED_A6FF: /* 0x1a6 */ 10800/* File: x86/OP_UNUSED_A6FF.S */ 10801/* File: x86/unused.S */ 10802 jmp common_abort 10803 10804 10805/* ------------------------------ */ 10806.L_OP_UNUSED_A7FF: /* 0x1a7 */ 10807/* File: x86/OP_UNUSED_A7FF.S */ 10808/* File: x86/unused.S */ 10809 jmp common_abort 10810 10811 10812/* ------------------------------ */ 10813.L_OP_UNUSED_A8FF: /* 0x1a8 */ 10814/* File: x86/OP_UNUSED_A8FF.S */ 10815/* File: x86/unused.S */ 10816 jmp common_abort 10817 10818 10819/* ------------------------------ */ 10820.L_OP_UNUSED_A9FF: /* 0x1a9 */ 10821/* File: x86/OP_UNUSED_A9FF.S */ 10822/* File: x86/unused.S */ 10823 jmp common_abort 10824 10825 10826/* ------------------------------ */ 10827.L_OP_UNUSED_AAFF: /* 0x1aa */ 10828/* File: x86/OP_UNUSED_AAFF.S */ 10829/* File: x86/unused.S */ 10830 jmp common_abort 10831 10832 10833/* ------------------------------ */ 10834.L_OP_UNUSED_ABFF: /* 0x1ab */ 10835/* File: x86/OP_UNUSED_ABFF.S */ 10836/* File: x86/unused.S */ 10837 jmp common_abort 10838 10839 10840/* ------------------------------ */ 10841.L_OP_UNUSED_ACFF: /* 0x1ac */ 10842/* File: x86/OP_UNUSED_ACFF.S */ 10843/* File: x86/unused.S */ 10844 jmp common_abort 10845 10846 10847/* ------------------------------ */ 10848.L_OP_UNUSED_ADFF: /* 0x1ad */ 10849/* File: x86/OP_UNUSED_ADFF.S */ 10850/* File: x86/unused.S */ 10851 jmp common_abort 10852 10853 10854/* ------------------------------ */ 10855.L_OP_UNUSED_AEFF: /* 0x1ae */ 10856/* File: x86/OP_UNUSED_AEFF.S */ 10857/* File: x86/unused.S */ 10858 jmp common_abort 10859 10860 10861/* ------------------------------ */ 10862.L_OP_UNUSED_AFFF: /* 0x1af */ 10863/* File: x86/OP_UNUSED_AFFF.S */ 10864/* File: x86/unused.S */ 10865 jmp common_abort 10866 10867 10868/* ------------------------------ */ 10869.L_OP_UNUSED_B0FF: /* 0x1b0 */ 10870/* File: x86/OP_UNUSED_B0FF.S */ 10871/* File: x86/unused.S */ 10872 jmp common_abort 10873 10874 10875/* ------------------------------ */ 10876.L_OP_UNUSED_B1FF: /* 0x1b1 */ 10877/* File: x86/OP_UNUSED_B1FF.S */ 10878/* File: x86/unused.S */ 10879 jmp common_abort 10880 10881 10882/* ------------------------------ */ 10883.L_OP_UNUSED_B2FF: /* 0x1b2 */ 10884/* File: x86/OP_UNUSED_B2FF.S */ 10885/* File: x86/unused.S */ 10886 jmp common_abort 10887 10888 10889/* ------------------------------ */ 10890.L_OP_UNUSED_B3FF: /* 0x1b3 */ 10891/* File: x86/OP_UNUSED_B3FF.S */ 10892/* File: x86/unused.S */ 10893 jmp common_abort 10894 10895 10896/* ------------------------------ */ 10897.L_OP_UNUSED_B4FF: /* 0x1b4 */ 10898/* File: x86/OP_UNUSED_B4FF.S */ 10899/* File: x86/unused.S */ 10900 jmp common_abort 10901 10902 10903/* ------------------------------ */ 10904.L_OP_UNUSED_B5FF: /* 0x1b5 */ 10905/* File: x86/OP_UNUSED_B5FF.S */ 10906/* File: x86/unused.S */ 10907 jmp common_abort 10908 10909 10910/* ------------------------------ */ 10911.L_OP_UNUSED_B6FF: /* 0x1b6 */ 10912/* File: x86/OP_UNUSED_B6FF.S */ 10913/* File: x86/unused.S */ 10914 jmp common_abort 10915 10916 10917/* ------------------------------ */ 10918.L_OP_UNUSED_B7FF: /* 0x1b7 */ 10919/* File: x86/OP_UNUSED_B7FF.S */ 10920/* File: x86/unused.S */ 10921 jmp common_abort 10922 10923 10924/* ------------------------------ */ 10925.L_OP_UNUSED_B8FF: /* 0x1b8 */ 10926/* File: x86/OP_UNUSED_B8FF.S */ 10927/* File: x86/unused.S */ 10928 jmp common_abort 10929 10930 10931/* ------------------------------ */ 10932.L_OP_UNUSED_B9FF: /* 0x1b9 */ 10933/* File: x86/OP_UNUSED_B9FF.S */ 10934/* File: x86/unused.S */ 10935 jmp common_abort 10936 10937 10938/* ------------------------------ */ 10939.L_OP_UNUSED_BAFF: /* 0x1ba */ 10940/* File: x86/OP_UNUSED_BAFF.S */ 10941/* File: x86/unused.S */ 10942 jmp common_abort 10943 10944 10945/* ------------------------------ */ 10946.L_OP_UNUSED_BBFF: /* 0x1bb */ 10947/* File: x86/OP_UNUSED_BBFF.S */ 10948/* File: x86/unused.S */ 10949 jmp common_abort 10950 10951 10952/* ------------------------------ */ 10953.L_OP_UNUSED_BCFF: /* 0x1bc */ 10954/* File: x86/OP_UNUSED_BCFF.S */ 10955/* File: x86/unused.S */ 10956 jmp common_abort 10957 10958 10959/* ------------------------------ */ 10960.L_OP_UNUSED_BDFF: /* 0x1bd */ 10961/* File: x86/OP_UNUSED_BDFF.S */ 10962/* File: x86/unused.S */ 10963 jmp common_abort 10964 10965 10966/* ------------------------------ */ 10967.L_OP_UNUSED_BEFF: /* 0x1be */ 10968/* File: x86/OP_UNUSED_BEFF.S */ 10969/* File: x86/unused.S */ 10970 jmp common_abort 10971 10972 10973/* ------------------------------ */ 10974.L_OP_UNUSED_BFFF: /* 0x1bf */ 10975/* File: x86/OP_UNUSED_BFFF.S */ 10976/* File: x86/unused.S */ 10977 jmp common_abort 10978 10979 10980/* ------------------------------ */ 10981.L_OP_UNUSED_C0FF: /* 0x1c0 */ 10982/* File: x86/OP_UNUSED_C0FF.S */ 10983/* File: x86/unused.S */ 10984 jmp common_abort 10985 10986 10987/* ------------------------------ */ 10988.L_OP_UNUSED_C1FF: /* 0x1c1 */ 10989/* File: x86/OP_UNUSED_C1FF.S */ 10990/* File: x86/unused.S */ 10991 jmp common_abort 10992 10993 10994/* ------------------------------ */ 10995.L_OP_UNUSED_C2FF: /* 0x1c2 */ 10996/* File: x86/OP_UNUSED_C2FF.S */ 10997/* File: x86/unused.S */ 10998 jmp common_abort 10999 11000 11001/* ------------------------------ */ 11002.L_OP_UNUSED_C3FF: /* 0x1c3 */ 11003/* File: x86/OP_UNUSED_C3FF.S */ 11004/* File: x86/unused.S */ 11005 jmp common_abort 11006 11007 11008/* ------------------------------ */ 11009.L_OP_UNUSED_C4FF: /* 0x1c4 */ 11010/* File: x86/OP_UNUSED_C4FF.S */ 11011/* File: x86/unused.S */ 11012 jmp common_abort 11013 11014 11015/* ------------------------------ */ 11016.L_OP_UNUSED_C5FF: /* 0x1c5 */ 11017/* File: x86/OP_UNUSED_C5FF.S */ 11018/* File: x86/unused.S */ 11019 jmp common_abort 11020 11021 11022/* ------------------------------ */ 11023.L_OP_UNUSED_C6FF: /* 0x1c6 */ 11024/* File: x86/OP_UNUSED_C6FF.S */ 11025/* File: x86/unused.S */ 11026 jmp common_abort 11027 11028 11029/* ------------------------------ */ 11030.L_OP_UNUSED_C7FF: /* 0x1c7 */ 11031/* File: x86/OP_UNUSED_C7FF.S */ 11032/* File: x86/unused.S */ 11033 jmp common_abort 11034 11035 11036/* ------------------------------ */ 11037.L_OP_UNUSED_C8FF: /* 0x1c8 */ 11038/* File: x86/OP_UNUSED_C8FF.S */ 11039/* File: x86/unused.S */ 11040 jmp common_abort 11041 11042 11043/* ------------------------------ */ 11044.L_OP_UNUSED_C9FF: /* 0x1c9 */ 11045/* File: x86/OP_UNUSED_C9FF.S */ 11046/* File: x86/unused.S */ 11047 jmp common_abort 11048 11049 11050/* ------------------------------ */ 11051.L_OP_UNUSED_CAFF: /* 0x1ca */ 11052/* File: x86/OP_UNUSED_CAFF.S */ 11053/* File: x86/unused.S */ 11054 jmp common_abort 11055 11056 11057/* ------------------------------ */ 11058.L_OP_UNUSED_CBFF: /* 0x1cb */ 11059/* File: x86/OP_UNUSED_CBFF.S */ 11060/* File: x86/unused.S */ 11061 jmp common_abort 11062 11063 11064/* ------------------------------ */ 11065.L_OP_UNUSED_CCFF: /* 0x1cc */ 11066/* File: x86/OP_UNUSED_CCFF.S */ 11067/* File: x86/unused.S */ 11068 jmp common_abort 11069 11070 11071/* ------------------------------ */ 11072.L_OP_UNUSED_CDFF: /* 0x1cd */ 11073/* File: x86/OP_UNUSED_CDFF.S */ 11074/* File: x86/unused.S */ 11075 jmp common_abort 11076 11077 11078/* ------------------------------ */ 11079.L_OP_UNUSED_CEFF: /* 0x1ce */ 11080/* File: x86/OP_UNUSED_CEFF.S */ 11081/* File: x86/unused.S */ 11082 jmp common_abort 11083 11084 11085/* ------------------------------ */ 11086.L_OP_UNUSED_CFFF: /* 0x1cf */ 11087/* File: x86/OP_UNUSED_CFFF.S */ 11088/* File: x86/unused.S */ 11089 jmp common_abort 11090 11091 11092/* ------------------------------ */ 11093.L_OP_UNUSED_D0FF: /* 0x1d0 */ 11094/* File: x86/OP_UNUSED_D0FF.S */ 11095/* File: x86/unused.S */ 11096 jmp common_abort 11097 11098 11099/* ------------------------------ */ 11100.L_OP_UNUSED_D1FF: /* 0x1d1 */ 11101/* File: x86/OP_UNUSED_D1FF.S */ 11102/* File: x86/unused.S */ 11103 jmp common_abort 11104 11105 11106/* ------------------------------ */ 11107.L_OP_UNUSED_D2FF: /* 0x1d2 */ 11108/* File: x86/OP_UNUSED_D2FF.S */ 11109/* File: x86/unused.S */ 11110 jmp common_abort 11111 11112 11113/* ------------------------------ */ 11114.L_OP_UNUSED_D3FF: /* 0x1d3 */ 11115/* File: x86/OP_UNUSED_D3FF.S */ 11116/* File: x86/unused.S */ 11117 jmp common_abort 11118 11119 11120/* ------------------------------ */ 11121.L_OP_UNUSED_D4FF: /* 0x1d4 */ 11122/* File: x86/OP_UNUSED_D4FF.S */ 11123/* File: x86/unused.S */ 11124 jmp common_abort 11125 11126 11127/* ------------------------------ */ 11128.L_OP_UNUSED_D5FF: /* 0x1d5 */ 11129/* File: x86/OP_UNUSED_D5FF.S */ 11130/* File: x86/unused.S */ 11131 jmp common_abort 11132 11133 11134/* ------------------------------ */ 11135.L_OP_UNUSED_D6FF: /* 0x1d6 */ 11136/* File: x86/OP_UNUSED_D6FF.S */ 11137/* File: x86/unused.S */ 11138 jmp common_abort 11139 11140 11141/* ------------------------------ */ 11142.L_OP_UNUSED_D7FF: /* 0x1d7 */ 11143/* File: x86/OP_UNUSED_D7FF.S */ 11144/* File: x86/unused.S */ 11145 jmp common_abort 11146 11147 11148/* ------------------------------ */ 11149.L_OP_UNUSED_D8FF: /* 0x1d8 */ 11150/* File: x86/OP_UNUSED_D8FF.S */ 11151/* File: x86/unused.S */ 11152 jmp common_abort 11153 11154 11155/* ------------------------------ */ 11156.L_OP_UNUSED_D9FF: /* 0x1d9 */ 11157/* File: x86/OP_UNUSED_D9FF.S */ 11158/* File: x86/unused.S */ 11159 jmp common_abort 11160 11161 11162/* ------------------------------ */ 11163.L_OP_UNUSED_DAFF: /* 0x1da */ 11164/* File: x86/OP_UNUSED_DAFF.S */ 11165/* File: x86/unused.S */ 11166 jmp common_abort 11167 11168 11169/* ------------------------------ */ 11170.L_OP_UNUSED_DBFF: /* 0x1db */ 11171/* File: x86/OP_UNUSED_DBFF.S */ 11172/* File: x86/unused.S */ 11173 jmp common_abort 11174 11175 11176/* ------------------------------ */ 11177.L_OP_UNUSED_DCFF: /* 0x1dc */ 11178/* File: x86/OP_UNUSED_DCFF.S */ 11179/* File: x86/unused.S */ 11180 jmp common_abort 11181 11182 11183/* ------------------------------ */ 11184.L_OP_UNUSED_DDFF: /* 0x1dd */ 11185/* File: x86/OP_UNUSED_DDFF.S */ 11186/* File: x86/unused.S */ 11187 jmp common_abort 11188 11189 11190/* ------------------------------ */ 11191.L_OP_UNUSED_DEFF: /* 0x1de */ 11192/* File: x86/OP_UNUSED_DEFF.S */ 11193/* File: x86/unused.S */ 11194 jmp common_abort 11195 11196 11197/* ------------------------------ */ 11198.L_OP_UNUSED_DFFF: /* 0x1df */ 11199/* File: x86/OP_UNUSED_DFFF.S */ 11200/* File: x86/unused.S */ 11201 jmp common_abort 11202 11203 11204/* ------------------------------ */ 11205.L_OP_UNUSED_E0FF: /* 0x1e0 */ 11206/* File: x86/OP_UNUSED_E0FF.S */ 11207/* File: x86/unused.S */ 11208 jmp common_abort 11209 11210 11211/* ------------------------------ */ 11212.L_OP_UNUSED_E1FF: /* 0x1e1 */ 11213/* File: x86/OP_UNUSED_E1FF.S */ 11214/* File: x86/unused.S */ 11215 jmp common_abort 11216 11217 11218/* ------------------------------ */ 11219.L_OP_UNUSED_E2FF: /* 0x1e2 */ 11220/* File: x86/OP_UNUSED_E2FF.S */ 11221/* File: x86/unused.S */ 11222 jmp common_abort 11223 11224 11225/* ------------------------------ */ 11226.L_OP_UNUSED_E3FF: /* 0x1e3 */ 11227/* File: x86/OP_UNUSED_E3FF.S */ 11228/* File: x86/unused.S */ 11229 jmp common_abort 11230 11231 11232/* ------------------------------ */ 11233.L_OP_UNUSED_E4FF: /* 0x1e4 */ 11234/* File: x86/OP_UNUSED_E4FF.S */ 11235/* File: x86/unused.S */ 11236 jmp common_abort 11237 11238 11239/* ------------------------------ */ 11240.L_OP_UNUSED_E5FF: /* 0x1e5 */ 11241/* File: x86/OP_UNUSED_E5FF.S */ 11242/* File: x86/unused.S */ 11243 jmp common_abort 11244 11245 11246/* ------------------------------ */ 11247.L_OP_UNUSED_E6FF: /* 0x1e6 */ 11248/* File: x86/OP_UNUSED_E6FF.S */ 11249/* File: x86/unused.S */ 11250 jmp common_abort 11251 11252 11253/* ------------------------------ */ 11254.L_OP_UNUSED_E7FF: /* 0x1e7 */ 11255/* File: x86/OP_UNUSED_E7FF.S */ 11256/* File: x86/unused.S */ 11257 jmp common_abort 11258 11259 11260/* ------------------------------ */ 11261.L_OP_UNUSED_E8FF: /* 0x1e8 */ 11262/* File: x86/OP_UNUSED_E8FF.S */ 11263/* File: x86/unused.S */ 11264 jmp common_abort 11265 11266 11267/* ------------------------------ */ 11268.L_OP_UNUSED_E9FF: /* 0x1e9 */ 11269/* File: x86/OP_UNUSED_E9FF.S */ 11270/* File: x86/unused.S */ 11271 jmp common_abort 11272 11273 11274/* ------------------------------ */ 11275.L_OP_UNUSED_EAFF: /* 0x1ea */ 11276/* File: x86/OP_UNUSED_EAFF.S */ 11277/* File: x86/unused.S */ 11278 jmp common_abort 11279 11280 11281/* ------------------------------ */ 11282.L_OP_UNUSED_EBFF: /* 0x1eb */ 11283/* File: x86/OP_UNUSED_EBFF.S */ 11284/* File: x86/unused.S */ 11285 jmp common_abort 11286 11287 11288/* ------------------------------ */ 11289.L_OP_UNUSED_ECFF: /* 0x1ec */ 11290/* File: x86/OP_UNUSED_ECFF.S */ 11291/* File: x86/unused.S */ 11292 jmp common_abort 11293 11294 11295/* ------------------------------ */ 11296.L_OP_UNUSED_EDFF: /* 0x1ed */ 11297/* File: x86/OP_UNUSED_EDFF.S */ 11298/* File: x86/unused.S */ 11299 jmp common_abort 11300 11301 11302/* ------------------------------ */ 11303.L_OP_UNUSED_EEFF: /* 0x1ee */ 11304/* File: x86/OP_UNUSED_EEFF.S */ 11305/* File: x86/unused.S */ 11306 jmp common_abort 11307 11308 11309/* ------------------------------ */ 11310.L_OP_UNUSED_EFFF: /* 0x1ef */ 11311/* File: x86/OP_UNUSED_EFFF.S */ 11312/* File: x86/unused.S */ 11313 jmp common_abort 11314 11315 11316/* ------------------------------ */ 11317.L_OP_UNUSED_F0FF: /* 0x1f0 */ 11318/* File: x86/OP_UNUSED_F0FF.S */ 11319/* File: x86/unused.S */ 11320 jmp common_abort 11321 11322 11323/* ------------------------------ */ 11324.L_OP_UNUSED_F1FF: /* 0x1f1 */ 11325/* File: x86/OP_UNUSED_F1FF.S */ 11326/* File: x86/unused.S */ 11327 jmp common_abort 11328 11329 11330/* ------------------------------ */ 11331.L_OP_INVOKE_OBJECT_INIT_JUMBO: /* 0x1f2 */ 11332 /* (stub) */ 11333 SAVE_PC_FP_TO_SELF %ecx # leaves rSELF in %ecx 11334 movl %ecx,OUT_ARG0(%esp) # self is first arg to function 11335 call dvmMterp_OP_INVOKE_OBJECT_INIT_JUMBO # do the real work 11336 movl rSELF,%ecx 11337 LOAD_PC_FP_FROM_SELF # retrieve updated values 11338 movl offThread_curHandlerTable(%ecx),rIBASE # set up rIBASE 11339 FETCH_INST 11340 GOTO_NEXT 11341/* ------------------------------ */ 11342.L_OP_IGET_VOLATILE_JUMBO: /* 0x1f3 */ 11343 /* (stub) */ 11344 SAVE_PC_FP_TO_SELF %ecx # leaves rSELF in %ecx 11345 movl %ecx,OUT_ARG0(%esp) # self is first arg to function 11346 call dvmMterp_OP_IGET_VOLATILE_JUMBO # do the real work 11347 movl rSELF,%ecx 11348 LOAD_PC_FP_FROM_SELF # retrieve updated values 11349 movl offThread_curHandlerTable(%ecx),rIBASE # set up rIBASE 11350 FETCH_INST 11351 GOTO_NEXT 11352/* ------------------------------ */ 11353.L_OP_IGET_WIDE_VOLATILE_JUMBO: /* 0x1f4 */ 11354 /* (stub) */ 11355 SAVE_PC_FP_TO_SELF %ecx # leaves rSELF in %ecx 11356 movl %ecx,OUT_ARG0(%esp) # self is first arg to function 11357 call dvmMterp_OP_IGET_WIDE_VOLATILE_JUMBO # do the real work 11358 movl rSELF,%ecx 11359 LOAD_PC_FP_FROM_SELF # retrieve updated values 11360 movl offThread_curHandlerTable(%ecx),rIBASE # set up rIBASE 11361 FETCH_INST 11362 GOTO_NEXT 11363/* ------------------------------ */ 11364.L_OP_IGET_OBJECT_VOLATILE_JUMBO: /* 0x1f5 */ 11365 /* (stub) */ 11366 SAVE_PC_FP_TO_SELF %ecx # leaves rSELF in %ecx 11367 movl %ecx,OUT_ARG0(%esp) # self is first arg to function 11368 call dvmMterp_OP_IGET_OBJECT_VOLATILE_JUMBO # do the real work 11369 movl rSELF,%ecx 11370 LOAD_PC_FP_FROM_SELF # retrieve updated values 11371 movl offThread_curHandlerTable(%ecx),rIBASE # set up rIBASE 11372 FETCH_INST 11373 GOTO_NEXT 11374/* ------------------------------ */ 11375.L_OP_IPUT_VOLATILE_JUMBO: /* 0x1f6 */ 11376 /* (stub) */ 11377 SAVE_PC_FP_TO_SELF %ecx # leaves rSELF in %ecx 11378 movl %ecx,OUT_ARG0(%esp) # self is first arg to function 11379 call dvmMterp_OP_IPUT_VOLATILE_JUMBO # do the real work 11380 movl rSELF,%ecx 11381 LOAD_PC_FP_FROM_SELF # retrieve updated values 11382 movl offThread_curHandlerTable(%ecx),rIBASE # set up rIBASE 11383 FETCH_INST 11384 GOTO_NEXT 11385/* ------------------------------ */ 11386.L_OP_IPUT_WIDE_VOLATILE_JUMBO: /* 0x1f7 */ 11387 /* (stub) */ 11388 SAVE_PC_FP_TO_SELF %ecx # leaves rSELF in %ecx 11389 movl %ecx,OUT_ARG0(%esp) # self is first arg to function 11390 call dvmMterp_OP_IPUT_WIDE_VOLATILE_JUMBO # do the real work 11391 movl rSELF,%ecx 11392 LOAD_PC_FP_FROM_SELF # retrieve updated values 11393 movl offThread_curHandlerTable(%ecx),rIBASE # set up rIBASE 11394 FETCH_INST 11395 GOTO_NEXT 11396/* ------------------------------ */ 11397.L_OP_IPUT_OBJECT_VOLATILE_JUMBO: /* 0x1f8 */ 11398 /* (stub) */ 11399 SAVE_PC_FP_TO_SELF %ecx # leaves rSELF in %ecx 11400 movl %ecx,OUT_ARG0(%esp) # self is first arg to function 11401 call dvmMterp_OP_IPUT_OBJECT_VOLATILE_JUMBO # do the real work 11402 movl rSELF,%ecx 11403 LOAD_PC_FP_FROM_SELF # retrieve updated values 11404 movl offThread_curHandlerTable(%ecx),rIBASE # set up rIBASE 11405 FETCH_INST 11406 GOTO_NEXT 11407/* ------------------------------ */ 11408.L_OP_SGET_VOLATILE_JUMBO: /* 0x1f9 */ 11409 /* (stub) */ 11410 SAVE_PC_FP_TO_SELF %ecx # leaves rSELF in %ecx 11411 movl %ecx,OUT_ARG0(%esp) # self is first arg to function 11412 call dvmMterp_OP_SGET_VOLATILE_JUMBO # do the real work 11413 movl rSELF,%ecx 11414 LOAD_PC_FP_FROM_SELF # retrieve updated values 11415 movl offThread_curHandlerTable(%ecx),rIBASE # set up rIBASE 11416 FETCH_INST 11417 GOTO_NEXT 11418/* ------------------------------ */ 11419.L_OP_SGET_WIDE_VOLATILE_JUMBO: /* 0x1fa */ 11420 /* (stub) */ 11421 SAVE_PC_FP_TO_SELF %ecx # leaves rSELF in %ecx 11422 movl %ecx,OUT_ARG0(%esp) # self is first arg to function 11423 call dvmMterp_OP_SGET_WIDE_VOLATILE_JUMBO # do the real work 11424 movl rSELF,%ecx 11425 LOAD_PC_FP_FROM_SELF # retrieve updated values 11426 movl offThread_curHandlerTable(%ecx),rIBASE # set up rIBASE 11427 FETCH_INST 11428 GOTO_NEXT 11429/* ------------------------------ */ 11430.L_OP_SGET_OBJECT_VOLATILE_JUMBO: /* 0x1fb */ 11431 /* (stub) */ 11432 SAVE_PC_FP_TO_SELF %ecx # leaves rSELF in %ecx 11433 movl %ecx,OUT_ARG0(%esp) # self is first arg to function 11434 call dvmMterp_OP_SGET_OBJECT_VOLATILE_JUMBO # do the real work 11435 movl rSELF,%ecx 11436 LOAD_PC_FP_FROM_SELF # retrieve updated values 11437 movl offThread_curHandlerTable(%ecx),rIBASE # set up rIBASE 11438 FETCH_INST 11439 GOTO_NEXT 11440/* ------------------------------ */ 11441.L_OP_SPUT_VOLATILE_JUMBO: /* 0x1fc */ 11442 /* (stub) */ 11443 SAVE_PC_FP_TO_SELF %ecx # leaves rSELF in %ecx 11444 movl %ecx,OUT_ARG0(%esp) # self is first arg to function 11445 call dvmMterp_OP_SPUT_VOLATILE_JUMBO # do the real work 11446 movl rSELF,%ecx 11447 LOAD_PC_FP_FROM_SELF # retrieve updated values 11448 movl offThread_curHandlerTable(%ecx),rIBASE # set up rIBASE 11449 FETCH_INST 11450 GOTO_NEXT 11451/* ------------------------------ */ 11452.L_OP_SPUT_WIDE_VOLATILE_JUMBO: /* 0x1fd */ 11453 /* (stub) */ 11454 SAVE_PC_FP_TO_SELF %ecx # leaves rSELF in %ecx 11455 movl %ecx,OUT_ARG0(%esp) # self is first arg to function 11456 call dvmMterp_OP_SPUT_WIDE_VOLATILE_JUMBO # do the real work 11457 movl rSELF,%ecx 11458 LOAD_PC_FP_FROM_SELF # retrieve updated values 11459 movl offThread_curHandlerTable(%ecx),rIBASE # set up rIBASE 11460 FETCH_INST 11461 GOTO_NEXT 11462/* ------------------------------ */ 11463.L_OP_SPUT_OBJECT_VOLATILE_JUMBO: /* 0x1fe */ 11464 /* (stub) */ 11465 SAVE_PC_FP_TO_SELF %ecx # leaves rSELF in %ecx 11466 movl %ecx,OUT_ARG0(%esp) # self is first arg to function 11467 call dvmMterp_OP_SPUT_OBJECT_VOLATILE_JUMBO # do the real work 11468 movl rSELF,%ecx 11469 LOAD_PC_FP_FROM_SELF # retrieve updated values 11470 movl offThread_curHandlerTable(%ecx),rIBASE # set up rIBASE 11471 FETCH_INST 11472 GOTO_NEXT 11473/* ------------------------------ */ 11474.L_OP_THROW_VERIFICATION_ERROR_JUMBO: /* 0x1ff */ 11475/* File: x86/OP_THROW_VERIFICATION_ERROR_JUMBO.S */ 11476 /* 11477 * Handle a jumbo throw-verification-error instruction. This throws an 11478 * exception for an error discovered during verification. The 11479 * exception is indicated by BBBB, with some detail provided by AAAAAAAA. 11480 */ 11481 /* exop BBBB, ref@AAAAAAAA */ 11482 movl rSELF,%ecx 11483 movl 2(rPC),%eax # eax<- AAAAAAAA 11484 movl offThread_method(%ecx),%ecx # ecx<- self->method 11485 EXPORT_PC 11486 movl %eax,OUT_ARG2(%esp) # arg2<- AAAAAAAA 11487 movl rINST,OUT_ARG1(%esp) # arg1<- BBBB 11488 movl %ecx,OUT_ARG0(%esp) # arg0<- method 11489 call dvmThrowVerificationError # call(method, kind, ref) 11490 jmp common_exceptionThrown # handle exception 11491 11492 .size dvmAsmInstructionStartCode, .-dvmAsmInstructionStartCode 11493 .global dvmAsmInstructionEndCode 11494dvmAsmInstructionEndCode: 11495 11496 .global dvmAsmAltInstructionStartCode 11497 .type dvmAsmAltInstructionStartCode, %function 11498dvmAsmAltInstructionStartCode: 11499 .text 11500 11501/* ------------------------------ */ 11502.L_ALT_OP_NOP: /* 0x00 */ 11503/* File: x86/alt_stub.S */ 11504/* 11505 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11506 * any interesting requests and then jump to the real instruction 11507 * handler. Unlike the Arm handler, we can't do this as a tail call 11508 * because rIBASE is caller save and we need to reload it. 11509 */ 11510 movl rSELF, %eax 11511 movl rPC, OUT_ARG0(%esp) 11512 movl %eax, OUT_ARG1(%esp) 11513 call dvmCheckInst # (dPC, self) 11514 movl rSELF, %ecx 11515 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11516 jmp *dvmAsmInstructionStart+(0*4) 11517 11518/* ------------------------------ */ 11519.L_ALT_OP_MOVE: /* 0x01 */ 11520/* File: x86/alt_stub.S */ 11521/* 11522 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11523 * any interesting requests and then jump to the real instruction 11524 * handler. Unlike the Arm handler, we can't do this as a tail call 11525 * because rIBASE is caller save and we need to reload it. 11526 */ 11527 movl rSELF, %eax 11528 movl rPC, OUT_ARG0(%esp) 11529 movl %eax, OUT_ARG1(%esp) 11530 call dvmCheckInst # (dPC, self) 11531 movl rSELF, %ecx 11532 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11533 jmp *dvmAsmInstructionStart+(1*4) 11534 11535/* ------------------------------ */ 11536.L_ALT_OP_MOVE_FROM16: /* 0x02 */ 11537/* File: x86/alt_stub.S */ 11538/* 11539 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11540 * any interesting requests and then jump to the real instruction 11541 * handler. Unlike the Arm handler, we can't do this as a tail call 11542 * because rIBASE is caller save and we need to reload it. 11543 */ 11544 movl rSELF, %eax 11545 movl rPC, OUT_ARG0(%esp) 11546 movl %eax, OUT_ARG1(%esp) 11547 call dvmCheckInst # (dPC, self) 11548 movl rSELF, %ecx 11549 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11550 jmp *dvmAsmInstructionStart+(2*4) 11551 11552/* ------------------------------ */ 11553.L_ALT_OP_MOVE_16: /* 0x03 */ 11554/* File: x86/alt_stub.S */ 11555/* 11556 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11557 * any interesting requests and then jump to the real instruction 11558 * handler. Unlike the Arm handler, we can't do this as a tail call 11559 * because rIBASE is caller save and we need to reload it. 11560 */ 11561 movl rSELF, %eax 11562 movl rPC, OUT_ARG0(%esp) 11563 movl %eax, OUT_ARG1(%esp) 11564 call dvmCheckInst # (dPC, self) 11565 movl rSELF, %ecx 11566 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11567 jmp *dvmAsmInstructionStart+(3*4) 11568 11569/* ------------------------------ */ 11570.L_ALT_OP_MOVE_WIDE: /* 0x04 */ 11571/* File: x86/alt_stub.S */ 11572/* 11573 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11574 * any interesting requests and then jump to the real instruction 11575 * handler. Unlike the Arm handler, we can't do this as a tail call 11576 * because rIBASE is caller save and we need to reload it. 11577 */ 11578 movl rSELF, %eax 11579 movl rPC, OUT_ARG0(%esp) 11580 movl %eax, OUT_ARG1(%esp) 11581 call dvmCheckInst # (dPC, self) 11582 movl rSELF, %ecx 11583 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11584 jmp *dvmAsmInstructionStart+(4*4) 11585 11586/* ------------------------------ */ 11587.L_ALT_OP_MOVE_WIDE_FROM16: /* 0x05 */ 11588/* File: x86/alt_stub.S */ 11589/* 11590 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11591 * any interesting requests and then jump to the real instruction 11592 * handler. Unlike the Arm handler, we can't do this as a tail call 11593 * because rIBASE is caller save and we need to reload it. 11594 */ 11595 movl rSELF, %eax 11596 movl rPC, OUT_ARG0(%esp) 11597 movl %eax, OUT_ARG1(%esp) 11598 call dvmCheckInst # (dPC, self) 11599 movl rSELF, %ecx 11600 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11601 jmp *dvmAsmInstructionStart+(5*4) 11602 11603/* ------------------------------ */ 11604.L_ALT_OP_MOVE_WIDE_16: /* 0x06 */ 11605/* File: x86/alt_stub.S */ 11606/* 11607 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11608 * any interesting requests and then jump to the real instruction 11609 * handler. Unlike the Arm handler, we can't do this as a tail call 11610 * because rIBASE is caller save and we need to reload it. 11611 */ 11612 movl rSELF, %eax 11613 movl rPC, OUT_ARG0(%esp) 11614 movl %eax, OUT_ARG1(%esp) 11615 call dvmCheckInst # (dPC, self) 11616 movl rSELF, %ecx 11617 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11618 jmp *dvmAsmInstructionStart+(6*4) 11619 11620/* ------------------------------ */ 11621.L_ALT_OP_MOVE_OBJECT: /* 0x07 */ 11622/* File: x86/alt_stub.S */ 11623/* 11624 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11625 * any interesting requests and then jump to the real instruction 11626 * handler. Unlike the Arm handler, we can't do this as a tail call 11627 * because rIBASE is caller save and we need to reload it. 11628 */ 11629 movl rSELF, %eax 11630 movl rPC, OUT_ARG0(%esp) 11631 movl %eax, OUT_ARG1(%esp) 11632 call dvmCheckInst # (dPC, self) 11633 movl rSELF, %ecx 11634 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11635 jmp *dvmAsmInstructionStart+(7*4) 11636 11637/* ------------------------------ */ 11638.L_ALT_OP_MOVE_OBJECT_FROM16: /* 0x08 */ 11639/* File: x86/alt_stub.S */ 11640/* 11641 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11642 * any interesting requests and then jump to the real instruction 11643 * handler. Unlike the Arm handler, we can't do this as a tail call 11644 * because rIBASE is caller save and we need to reload it. 11645 */ 11646 movl rSELF, %eax 11647 movl rPC, OUT_ARG0(%esp) 11648 movl %eax, OUT_ARG1(%esp) 11649 call dvmCheckInst # (dPC, self) 11650 movl rSELF, %ecx 11651 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11652 jmp *dvmAsmInstructionStart+(8*4) 11653 11654/* ------------------------------ */ 11655.L_ALT_OP_MOVE_OBJECT_16: /* 0x09 */ 11656/* File: x86/alt_stub.S */ 11657/* 11658 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11659 * any interesting requests and then jump to the real instruction 11660 * handler. Unlike the Arm handler, we can't do this as a tail call 11661 * because rIBASE is caller save and we need to reload it. 11662 */ 11663 movl rSELF, %eax 11664 movl rPC, OUT_ARG0(%esp) 11665 movl %eax, OUT_ARG1(%esp) 11666 call dvmCheckInst # (dPC, self) 11667 movl rSELF, %ecx 11668 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11669 jmp *dvmAsmInstructionStart+(9*4) 11670 11671/* ------------------------------ */ 11672.L_ALT_OP_MOVE_RESULT: /* 0x0a */ 11673/* File: x86/alt_stub.S */ 11674/* 11675 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11676 * any interesting requests and then jump to the real instruction 11677 * handler. Unlike the Arm handler, we can't do this as a tail call 11678 * because rIBASE is caller save and we need to reload it. 11679 */ 11680 movl rSELF, %eax 11681 movl rPC, OUT_ARG0(%esp) 11682 movl %eax, OUT_ARG1(%esp) 11683 call dvmCheckInst # (dPC, self) 11684 movl rSELF, %ecx 11685 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11686 jmp *dvmAsmInstructionStart+(10*4) 11687 11688/* ------------------------------ */ 11689.L_ALT_OP_MOVE_RESULT_WIDE: /* 0x0b */ 11690/* File: x86/alt_stub.S */ 11691/* 11692 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11693 * any interesting requests and then jump to the real instruction 11694 * handler. Unlike the Arm handler, we can't do this as a tail call 11695 * because rIBASE is caller save and we need to reload it. 11696 */ 11697 movl rSELF, %eax 11698 movl rPC, OUT_ARG0(%esp) 11699 movl %eax, OUT_ARG1(%esp) 11700 call dvmCheckInst # (dPC, self) 11701 movl rSELF, %ecx 11702 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11703 jmp *dvmAsmInstructionStart+(11*4) 11704 11705/* ------------------------------ */ 11706.L_ALT_OP_MOVE_RESULT_OBJECT: /* 0x0c */ 11707/* File: x86/alt_stub.S */ 11708/* 11709 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11710 * any interesting requests and then jump to the real instruction 11711 * handler. Unlike the Arm handler, we can't do this as a tail call 11712 * because rIBASE is caller save and we need to reload it. 11713 */ 11714 movl rSELF, %eax 11715 movl rPC, OUT_ARG0(%esp) 11716 movl %eax, OUT_ARG1(%esp) 11717 call dvmCheckInst # (dPC, self) 11718 movl rSELF, %ecx 11719 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11720 jmp *dvmAsmInstructionStart+(12*4) 11721 11722/* ------------------------------ */ 11723.L_ALT_OP_MOVE_EXCEPTION: /* 0x0d */ 11724/* File: x86/alt_stub.S */ 11725/* 11726 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11727 * any interesting requests and then jump to the real instruction 11728 * handler. Unlike the Arm handler, we can't do this as a tail call 11729 * because rIBASE is caller save and we need to reload it. 11730 */ 11731 movl rSELF, %eax 11732 movl rPC, OUT_ARG0(%esp) 11733 movl %eax, OUT_ARG1(%esp) 11734 call dvmCheckInst # (dPC, self) 11735 movl rSELF, %ecx 11736 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11737 jmp *dvmAsmInstructionStart+(13*4) 11738 11739/* ------------------------------ */ 11740.L_ALT_OP_RETURN_VOID: /* 0x0e */ 11741/* File: x86/alt_stub.S */ 11742/* 11743 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11744 * any interesting requests and then jump to the real instruction 11745 * handler. Unlike the Arm handler, we can't do this as a tail call 11746 * because rIBASE is caller save and we need to reload it. 11747 */ 11748 movl rSELF, %eax 11749 movl rPC, OUT_ARG0(%esp) 11750 movl %eax, OUT_ARG1(%esp) 11751 call dvmCheckInst # (dPC, self) 11752 movl rSELF, %ecx 11753 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11754 jmp *dvmAsmInstructionStart+(14*4) 11755 11756/* ------------------------------ */ 11757.L_ALT_OP_RETURN: /* 0x0f */ 11758/* File: x86/alt_stub.S */ 11759/* 11760 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11761 * any interesting requests and then jump to the real instruction 11762 * handler. Unlike the Arm handler, we can't do this as a tail call 11763 * because rIBASE is caller save and we need to reload it. 11764 */ 11765 movl rSELF, %eax 11766 movl rPC, OUT_ARG0(%esp) 11767 movl %eax, OUT_ARG1(%esp) 11768 call dvmCheckInst # (dPC, self) 11769 movl rSELF, %ecx 11770 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11771 jmp *dvmAsmInstructionStart+(15*4) 11772 11773/* ------------------------------ */ 11774.L_ALT_OP_RETURN_WIDE: /* 0x10 */ 11775/* File: x86/alt_stub.S */ 11776/* 11777 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11778 * any interesting requests and then jump to the real instruction 11779 * handler. Unlike the Arm handler, we can't do this as a tail call 11780 * because rIBASE is caller save and we need to reload it. 11781 */ 11782 movl rSELF, %eax 11783 movl rPC, OUT_ARG0(%esp) 11784 movl %eax, OUT_ARG1(%esp) 11785 call dvmCheckInst # (dPC, self) 11786 movl rSELF, %ecx 11787 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11788 jmp *dvmAsmInstructionStart+(16*4) 11789 11790/* ------------------------------ */ 11791.L_ALT_OP_RETURN_OBJECT: /* 0x11 */ 11792/* File: x86/alt_stub.S */ 11793/* 11794 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11795 * any interesting requests and then jump to the real instruction 11796 * handler. Unlike the Arm handler, we can't do this as a tail call 11797 * because rIBASE is caller save and we need to reload it. 11798 */ 11799 movl rSELF, %eax 11800 movl rPC, OUT_ARG0(%esp) 11801 movl %eax, OUT_ARG1(%esp) 11802 call dvmCheckInst # (dPC, self) 11803 movl rSELF, %ecx 11804 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11805 jmp *dvmAsmInstructionStart+(17*4) 11806 11807/* ------------------------------ */ 11808.L_ALT_OP_CONST_4: /* 0x12 */ 11809/* File: x86/alt_stub.S */ 11810/* 11811 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11812 * any interesting requests and then jump to the real instruction 11813 * handler. Unlike the Arm handler, we can't do this as a tail call 11814 * because rIBASE is caller save and we need to reload it. 11815 */ 11816 movl rSELF, %eax 11817 movl rPC, OUT_ARG0(%esp) 11818 movl %eax, OUT_ARG1(%esp) 11819 call dvmCheckInst # (dPC, self) 11820 movl rSELF, %ecx 11821 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11822 jmp *dvmAsmInstructionStart+(18*4) 11823 11824/* ------------------------------ */ 11825.L_ALT_OP_CONST_16: /* 0x13 */ 11826/* File: x86/alt_stub.S */ 11827/* 11828 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11829 * any interesting requests and then jump to the real instruction 11830 * handler. Unlike the Arm handler, we can't do this as a tail call 11831 * because rIBASE is caller save and we need to reload it. 11832 */ 11833 movl rSELF, %eax 11834 movl rPC, OUT_ARG0(%esp) 11835 movl %eax, OUT_ARG1(%esp) 11836 call dvmCheckInst # (dPC, self) 11837 movl rSELF, %ecx 11838 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11839 jmp *dvmAsmInstructionStart+(19*4) 11840 11841/* ------------------------------ */ 11842.L_ALT_OP_CONST: /* 0x14 */ 11843/* File: x86/alt_stub.S */ 11844/* 11845 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11846 * any interesting requests and then jump to the real instruction 11847 * handler. Unlike the Arm handler, we can't do this as a tail call 11848 * because rIBASE is caller save and we need to reload it. 11849 */ 11850 movl rSELF, %eax 11851 movl rPC, OUT_ARG0(%esp) 11852 movl %eax, OUT_ARG1(%esp) 11853 call dvmCheckInst # (dPC, self) 11854 movl rSELF, %ecx 11855 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11856 jmp *dvmAsmInstructionStart+(20*4) 11857 11858/* ------------------------------ */ 11859.L_ALT_OP_CONST_HIGH16: /* 0x15 */ 11860/* File: x86/alt_stub.S */ 11861/* 11862 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11863 * any interesting requests and then jump to the real instruction 11864 * handler. Unlike the Arm handler, we can't do this as a tail call 11865 * because rIBASE is caller save and we need to reload it. 11866 */ 11867 movl rSELF, %eax 11868 movl rPC, OUT_ARG0(%esp) 11869 movl %eax, OUT_ARG1(%esp) 11870 call dvmCheckInst # (dPC, self) 11871 movl rSELF, %ecx 11872 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11873 jmp *dvmAsmInstructionStart+(21*4) 11874 11875/* ------------------------------ */ 11876.L_ALT_OP_CONST_WIDE_16: /* 0x16 */ 11877/* File: x86/alt_stub.S */ 11878/* 11879 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11880 * any interesting requests and then jump to the real instruction 11881 * handler. Unlike the Arm handler, we can't do this as a tail call 11882 * because rIBASE is caller save and we need to reload it. 11883 */ 11884 movl rSELF, %eax 11885 movl rPC, OUT_ARG0(%esp) 11886 movl %eax, OUT_ARG1(%esp) 11887 call dvmCheckInst # (dPC, self) 11888 movl rSELF, %ecx 11889 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11890 jmp *dvmAsmInstructionStart+(22*4) 11891 11892/* ------------------------------ */ 11893.L_ALT_OP_CONST_WIDE_32: /* 0x17 */ 11894/* File: x86/alt_stub.S */ 11895/* 11896 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11897 * any interesting requests and then jump to the real instruction 11898 * handler. Unlike the Arm handler, we can't do this as a tail call 11899 * because rIBASE is caller save and we need to reload it. 11900 */ 11901 movl rSELF, %eax 11902 movl rPC, OUT_ARG0(%esp) 11903 movl %eax, OUT_ARG1(%esp) 11904 call dvmCheckInst # (dPC, self) 11905 movl rSELF, %ecx 11906 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11907 jmp *dvmAsmInstructionStart+(23*4) 11908 11909/* ------------------------------ */ 11910.L_ALT_OP_CONST_WIDE: /* 0x18 */ 11911/* File: x86/alt_stub.S */ 11912/* 11913 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11914 * any interesting requests and then jump to the real instruction 11915 * handler. Unlike the Arm handler, we can't do this as a tail call 11916 * because rIBASE is caller save and we need to reload it. 11917 */ 11918 movl rSELF, %eax 11919 movl rPC, OUT_ARG0(%esp) 11920 movl %eax, OUT_ARG1(%esp) 11921 call dvmCheckInst # (dPC, self) 11922 movl rSELF, %ecx 11923 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11924 jmp *dvmAsmInstructionStart+(24*4) 11925 11926/* ------------------------------ */ 11927.L_ALT_OP_CONST_WIDE_HIGH16: /* 0x19 */ 11928/* File: x86/alt_stub.S */ 11929/* 11930 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11931 * any interesting requests and then jump to the real instruction 11932 * handler. Unlike the Arm handler, we can't do this as a tail call 11933 * because rIBASE is caller save and we need to reload it. 11934 */ 11935 movl rSELF, %eax 11936 movl rPC, OUT_ARG0(%esp) 11937 movl %eax, OUT_ARG1(%esp) 11938 call dvmCheckInst # (dPC, self) 11939 movl rSELF, %ecx 11940 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11941 jmp *dvmAsmInstructionStart+(25*4) 11942 11943/* ------------------------------ */ 11944.L_ALT_OP_CONST_STRING: /* 0x1a */ 11945/* File: x86/alt_stub.S */ 11946/* 11947 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11948 * any interesting requests and then jump to the real instruction 11949 * handler. Unlike the Arm handler, we can't do this as a tail call 11950 * because rIBASE is caller save and we need to reload it. 11951 */ 11952 movl rSELF, %eax 11953 movl rPC, OUT_ARG0(%esp) 11954 movl %eax, OUT_ARG1(%esp) 11955 call dvmCheckInst # (dPC, self) 11956 movl rSELF, %ecx 11957 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11958 jmp *dvmAsmInstructionStart+(26*4) 11959 11960/* ------------------------------ */ 11961.L_ALT_OP_CONST_STRING_JUMBO: /* 0x1b */ 11962/* File: x86/alt_stub.S */ 11963/* 11964 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11965 * any interesting requests and then jump to the real instruction 11966 * handler. Unlike the Arm handler, we can't do this as a tail call 11967 * because rIBASE is caller save and we need to reload it. 11968 */ 11969 movl rSELF, %eax 11970 movl rPC, OUT_ARG0(%esp) 11971 movl %eax, OUT_ARG1(%esp) 11972 call dvmCheckInst # (dPC, self) 11973 movl rSELF, %ecx 11974 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11975 jmp *dvmAsmInstructionStart+(27*4) 11976 11977/* ------------------------------ */ 11978.L_ALT_OP_CONST_CLASS: /* 0x1c */ 11979/* File: x86/alt_stub.S */ 11980/* 11981 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11982 * any interesting requests and then jump to the real instruction 11983 * handler. Unlike the Arm handler, we can't do this as a tail call 11984 * because rIBASE is caller save and we need to reload it. 11985 */ 11986 movl rSELF, %eax 11987 movl rPC, OUT_ARG0(%esp) 11988 movl %eax, OUT_ARG1(%esp) 11989 call dvmCheckInst # (dPC, self) 11990 movl rSELF, %ecx 11991 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11992 jmp *dvmAsmInstructionStart+(28*4) 11993 11994/* ------------------------------ */ 11995.L_ALT_OP_MONITOR_ENTER: /* 0x1d */ 11996/* File: x86/alt_stub.S */ 11997/* 11998 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11999 * any interesting requests and then jump to the real instruction 12000 * handler. Unlike the Arm handler, we can't do this as a tail call 12001 * because rIBASE is caller save and we need to reload it. 12002 */ 12003 movl rSELF, %eax 12004 movl rPC, OUT_ARG0(%esp) 12005 movl %eax, OUT_ARG1(%esp) 12006 call dvmCheckInst # (dPC, self) 12007 movl rSELF, %ecx 12008 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12009 jmp *dvmAsmInstructionStart+(29*4) 12010 12011/* ------------------------------ */ 12012.L_ALT_OP_MONITOR_EXIT: /* 0x1e */ 12013/* File: x86/alt_stub.S */ 12014/* 12015 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12016 * any interesting requests and then jump to the real instruction 12017 * handler. Unlike the Arm handler, we can't do this as a tail call 12018 * because rIBASE is caller save and we need to reload it. 12019 */ 12020 movl rSELF, %eax 12021 movl rPC, OUT_ARG0(%esp) 12022 movl %eax, OUT_ARG1(%esp) 12023 call dvmCheckInst # (dPC, self) 12024 movl rSELF, %ecx 12025 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12026 jmp *dvmAsmInstructionStart+(30*4) 12027 12028/* ------------------------------ */ 12029.L_ALT_OP_CHECK_CAST: /* 0x1f */ 12030/* File: x86/alt_stub.S */ 12031/* 12032 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12033 * any interesting requests and then jump to the real instruction 12034 * handler. Unlike the Arm handler, we can't do this as a tail call 12035 * because rIBASE is caller save and we need to reload it. 12036 */ 12037 movl rSELF, %eax 12038 movl rPC, OUT_ARG0(%esp) 12039 movl %eax, OUT_ARG1(%esp) 12040 call dvmCheckInst # (dPC, self) 12041 movl rSELF, %ecx 12042 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12043 jmp *dvmAsmInstructionStart+(31*4) 12044 12045/* ------------------------------ */ 12046.L_ALT_OP_INSTANCE_OF: /* 0x20 */ 12047/* File: x86/alt_stub.S */ 12048/* 12049 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12050 * any interesting requests and then jump to the real instruction 12051 * handler. Unlike the Arm handler, we can't do this as a tail call 12052 * because rIBASE is caller save and we need to reload it. 12053 */ 12054 movl rSELF, %eax 12055 movl rPC, OUT_ARG0(%esp) 12056 movl %eax, OUT_ARG1(%esp) 12057 call dvmCheckInst # (dPC, self) 12058 movl rSELF, %ecx 12059 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12060 jmp *dvmAsmInstructionStart+(32*4) 12061 12062/* ------------------------------ */ 12063.L_ALT_OP_ARRAY_LENGTH: /* 0x21 */ 12064/* File: x86/alt_stub.S */ 12065/* 12066 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12067 * any interesting requests and then jump to the real instruction 12068 * handler. Unlike the Arm handler, we can't do this as a tail call 12069 * because rIBASE is caller save and we need to reload it. 12070 */ 12071 movl rSELF, %eax 12072 movl rPC, OUT_ARG0(%esp) 12073 movl %eax, OUT_ARG1(%esp) 12074 call dvmCheckInst # (dPC, self) 12075 movl rSELF, %ecx 12076 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12077 jmp *dvmAsmInstructionStart+(33*4) 12078 12079/* ------------------------------ */ 12080.L_ALT_OP_NEW_INSTANCE: /* 0x22 */ 12081/* File: x86/alt_stub.S */ 12082/* 12083 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12084 * any interesting requests and then jump to the real instruction 12085 * handler. Unlike the Arm handler, we can't do this as a tail call 12086 * because rIBASE is caller save and we need to reload it. 12087 */ 12088 movl rSELF, %eax 12089 movl rPC, OUT_ARG0(%esp) 12090 movl %eax, OUT_ARG1(%esp) 12091 call dvmCheckInst # (dPC, self) 12092 movl rSELF, %ecx 12093 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12094 jmp *dvmAsmInstructionStart+(34*4) 12095 12096/* ------------------------------ */ 12097.L_ALT_OP_NEW_ARRAY: /* 0x23 */ 12098/* File: x86/alt_stub.S */ 12099/* 12100 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12101 * any interesting requests and then jump to the real instruction 12102 * handler. Unlike the Arm handler, we can't do this as a tail call 12103 * because rIBASE is caller save and we need to reload it. 12104 */ 12105 movl rSELF, %eax 12106 movl rPC, OUT_ARG0(%esp) 12107 movl %eax, OUT_ARG1(%esp) 12108 call dvmCheckInst # (dPC, self) 12109 movl rSELF, %ecx 12110 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12111 jmp *dvmAsmInstructionStart+(35*4) 12112 12113/* ------------------------------ */ 12114.L_ALT_OP_FILLED_NEW_ARRAY: /* 0x24 */ 12115/* File: x86/alt_stub.S */ 12116/* 12117 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12118 * any interesting requests and then jump to the real instruction 12119 * handler. Unlike the Arm handler, we can't do this as a tail call 12120 * because rIBASE is caller save and we need to reload it. 12121 */ 12122 movl rSELF, %eax 12123 movl rPC, OUT_ARG0(%esp) 12124 movl %eax, OUT_ARG1(%esp) 12125 call dvmCheckInst # (dPC, self) 12126 movl rSELF, %ecx 12127 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12128 jmp *dvmAsmInstructionStart+(36*4) 12129 12130/* ------------------------------ */ 12131.L_ALT_OP_FILLED_NEW_ARRAY_RANGE: /* 0x25 */ 12132/* File: x86/alt_stub.S */ 12133/* 12134 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12135 * any interesting requests and then jump to the real instruction 12136 * handler. Unlike the Arm handler, we can't do this as a tail call 12137 * because rIBASE is caller save and we need to reload it. 12138 */ 12139 movl rSELF, %eax 12140 movl rPC, OUT_ARG0(%esp) 12141 movl %eax, OUT_ARG1(%esp) 12142 call dvmCheckInst # (dPC, self) 12143 movl rSELF, %ecx 12144 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12145 jmp *dvmAsmInstructionStart+(37*4) 12146 12147/* ------------------------------ */ 12148.L_ALT_OP_FILL_ARRAY_DATA: /* 0x26 */ 12149/* File: x86/alt_stub.S */ 12150/* 12151 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12152 * any interesting requests and then jump to the real instruction 12153 * handler. Unlike the Arm handler, we can't do this as a tail call 12154 * because rIBASE is caller save and we need to reload it. 12155 */ 12156 movl rSELF, %eax 12157 movl rPC, OUT_ARG0(%esp) 12158 movl %eax, OUT_ARG1(%esp) 12159 call dvmCheckInst # (dPC, self) 12160 movl rSELF, %ecx 12161 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12162 jmp *dvmAsmInstructionStart+(38*4) 12163 12164/* ------------------------------ */ 12165.L_ALT_OP_THROW: /* 0x27 */ 12166/* File: x86/alt_stub.S */ 12167/* 12168 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12169 * any interesting requests and then jump to the real instruction 12170 * handler. Unlike the Arm handler, we can't do this as a tail call 12171 * because rIBASE is caller save and we need to reload it. 12172 */ 12173 movl rSELF, %eax 12174 movl rPC, OUT_ARG0(%esp) 12175 movl %eax, OUT_ARG1(%esp) 12176 call dvmCheckInst # (dPC, self) 12177 movl rSELF, %ecx 12178 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12179 jmp *dvmAsmInstructionStart+(39*4) 12180 12181/* ------------------------------ */ 12182.L_ALT_OP_GOTO: /* 0x28 */ 12183/* File: x86/alt_stub.S */ 12184/* 12185 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12186 * any interesting requests and then jump to the real instruction 12187 * handler. Unlike the Arm handler, we can't do this as a tail call 12188 * because rIBASE is caller save and we need to reload it. 12189 */ 12190 movl rSELF, %eax 12191 movl rPC, OUT_ARG0(%esp) 12192 movl %eax, OUT_ARG1(%esp) 12193 call dvmCheckInst # (dPC, self) 12194 movl rSELF, %ecx 12195 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12196 jmp *dvmAsmInstructionStart+(40*4) 12197 12198/* ------------------------------ */ 12199.L_ALT_OP_GOTO_16: /* 0x29 */ 12200/* File: x86/alt_stub.S */ 12201/* 12202 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12203 * any interesting requests and then jump to the real instruction 12204 * handler. Unlike the Arm handler, we can't do this as a tail call 12205 * because rIBASE is caller save and we need to reload it. 12206 */ 12207 movl rSELF, %eax 12208 movl rPC, OUT_ARG0(%esp) 12209 movl %eax, OUT_ARG1(%esp) 12210 call dvmCheckInst # (dPC, self) 12211 movl rSELF, %ecx 12212 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12213 jmp *dvmAsmInstructionStart+(41*4) 12214 12215/* ------------------------------ */ 12216.L_ALT_OP_GOTO_32: /* 0x2a */ 12217/* File: x86/alt_stub.S */ 12218/* 12219 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12220 * any interesting requests and then jump to the real instruction 12221 * handler. Unlike the Arm handler, we can't do this as a tail call 12222 * because rIBASE is caller save and we need to reload it. 12223 */ 12224 movl rSELF, %eax 12225 movl rPC, OUT_ARG0(%esp) 12226 movl %eax, OUT_ARG1(%esp) 12227 call dvmCheckInst # (dPC, self) 12228 movl rSELF, %ecx 12229 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12230 jmp *dvmAsmInstructionStart+(42*4) 12231 12232/* ------------------------------ */ 12233.L_ALT_OP_PACKED_SWITCH: /* 0x2b */ 12234/* File: x86/alt_stub.S */ 12235/* 12236 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12237 * any interesting requests and then jump to the real instruction 12238 * handler. Unlike the Arm handler, we can't do this as a tail call 12239 * because rIBASE is caller save and we need to reload it. 12240 */ 12241 movl rSELF, %eax 12242 movl rPC, OUT_ARG0(%esp) 12243 movl %eax, OUT_ARG1(%esp) 12244 call dvmCheckInst # (dPC, self) 12245 movl rSELF, %ecx 12246 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12247 jmp *dvmAsmInstructionStart+(43*4) 12248 12249/* ------------------------------ */ 12250.L_ALT_OP_SPARSE_SWITCH: /* 0x2c */ 12251/* File: x86/alt_stub.S */ 12252/* 12253 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12254 * any interesting requests and then jump to the real instruction 12255 * handler. Unlike the Arm handler, we can't do this as a tail call 12256 * because rIBASE is caller save and we need to reload it. 12257 */ 12258 movl rSELF, %eax 12259 movl rPC, OUT_ARG0(%esp) 12260 movl %eax, OUT_ARG1(%esp) 12261 call dvmCheckInst # (dPC, self) 12262 movl rSELF, %ecx 12263 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12264 jmp *dvmAsmInstructionStart+(44*4) 12265 12266/* ------------------------------ */ 12267.L_ALT_OP_CMPL_FLOAT: /* 0x2d */ 12268/* File: x86/alt_stub.S */ 12269/* 12270 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12271 * any interesting requests and then jump to the real instruction 12272 * handler. Unlike the Arm handler, we can't do this as a tail call 12273 * because rIBASE is caller save and we need to reload it. 12274 */ 12275 movl rSELF, %eax 12276 movl rPC, OUT_ARG0(%esp) 12277 movl %eax, OUT_ARG1(%esp) 12278 call dvmCheckInst # (dPC, self) 12279 movl rSELF, %ecx 12280 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12281 jmp *dvmAsmInstructionStart+(45*4) 12282 12283/* ------------------------------ */ 12284.L_ALT_OP_CMPG_FLOAT: /* 0x2e */ 12285/* File: x86/alt_stub.S */ 12286/* 12287 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12288 * any interesting requests and then jump to the real instruction 12289 * handler. Unlike the Arm handler, we can't do this as a tail call 12290 * because rIBASE is caller save and we need to reload it. 12291 */ 12292 movl rSELF, %eax 12293 movl rPC, OUT_ARG0(%esp) 12294 movl %eax, OUT_ARG1(%esp) 12295 call dvmCheckInst # (dPC, self) 12296 movl rSELF, %ecx 12297 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12298 jmp *dvmAsmInstructionStart+(46*4) 12299 12300/* ------------------------------ */ 12301.L_ALT_OP_CMPL_DOUBLE: /* 0x2f */ 12302/* File: x86/alt_stub.S */ 12303/* 12304 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12305 * any interesting requests and then jump to the real instruction 12306 * handler. Unlike the Arm handler, we can't do this as a tail call 12307 * because rIBASE is caller save and we need to reload it. 12308 */ 12309 movl rSELF, %eax 12310 movl rPC, OUT_ARG0(%esp) 12311 movl %eax, OUT_ARG1(%esp) 12312 call dvmCheckInst # (dPC, self) 12313 movl rSELF, %ecx 12314 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12315 jmp *dvmAsmInstructionStart+(47*4) 12316 12317/* ------------------------------ */ 12318.L_ALT_OP_CMPG_DOUBLE: /* 0x30 */ 12319/* File: x86/alt_stub.S */ 12320/* 12321 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12322 * any interesting requests and then jump to the real instruction 12323 * handler. Unlike the Arm handler, we can't do this as a tail call 12324 * because rIBASE is caller save and we need to reload it. 12325 */ 12326 movl rSELF, %eax 12327 movl rPC, OUT_ARG0(%esp) 12328 movl %eax, OUT_ARG1(%esp) 12329 call dvmCheckInst # (dPC, self) 12330 movl rSELF, %ecx 12331 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12332 jmp *dvmAsmInstructionStart+(48*4) 12333 12334/* ------------------------------ */ 12335.L_ALT_OP_CMP_LONG: /* 0x31 */ 12336/* File: x86/alt_stub.S */ 12337/* 12338 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12339 * any interesting requests and then jump to the real instruction 12340 * handler. Unlike the Arm handler, we can't do this as a tail call 12341 * because rIBASE is caller save and we need to reload it. 12342 */ 12343 movl rSELF, %eax 12344 movl rPC, OUT_ARG0(%esp) 12345 movl %eax, OUT_ARG1(%esp) 12346 call dvmCheckInst # (dPC, self) 12347 movl rSELF, %ecx 12348 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12349 jmp *dvmAsmInstructionStart+(49*4) 12350 12351/* ------------------------------ */ 12352.L_ALT_OP_IF_EQ: /* 0x32 */ 12353/* File: x86/alt_stub.S */ 12354/* 12355 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12356 * any interesting requests and then jump to the real instruction 12357 * handler. Unlike the Arm handler, we can't do this as a tail call 12358 * because rIBASE is caller save and we need to reload it. 12359 */ 12360 movl rSELF, %eax 12361 movl rPC, OUT_ARG0(%esp) 12362 movl %eax, OUT_ARG1(%esp) 12363 call dvmCheckInst # (dPC, self) 12364 movl rSELF, %ecx 12365 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12366 jmp *dvmAsmInstructionStart+(50*4) 12367 12368/* ------------------------------ */ 12369.L_ALT_OP_IF_NE: /* 0x33 */ 12370/* File: x86/alt_stub.S */ 12371/* 12372 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12373 * any interesting requests and then jump to the real instruction 12374 * handler. Unlike the Arm handler, we can't do this as a tail call 12375 * because rIBASE is caller save and we need to reload it. 12376 */ 12377 movl rSELF, %eax 12378 movl rPC, OUT_ARG0(%esp) 12379 movl %eax, OUT_ARG1(%esp) 12380 call dvmCheckInst # (dPC, self) 12381 movl rSELF, %ecx 12382 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12383 jmp *dvmAsmInstructionStart+(51*4) 12384 12385/* ------------------------------ */ 12386.L_ALT_OP_IF_LT: /* 0x34 */ 12387/* File: x86/alt_stub.S */ 12388/* 12389 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12390 * any interesting requests and then jump to the real instruction 12391 * handler. Unlike the Arm handler, we can't do this as a tail call 12392 * because rIBASE is caller save and we need to reload it. 12393 */ 12394 movl rSELF, %eax 12395 movl rPC, OUT_ARG0(%esp) 12396 movl %eax, OUT_ARG1(%esp) 12397 call dvmCheckInst # (dPC, self) 12398 movl rSELF, %ecx 12399 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12400 jmp *dvmAsmInstructionStart+(52*4) 12401 12402/* ------------------------------ */ 12403.L_ALT_OP_IF_GE: /* 0x35 */ 12404/* File: x86/alt_stub.S */ 12405/* 12406 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12407 * any interesting requests and then jump to the real instruction 12408 * handler. Unlike the Arm handler, we can't do this as a tail call 12409 * because rIBASE is caller save and we need to reload it. 12410 */ 12411 movl rSELF, %eax 12412 movl rPC, OUT_ARG0(%esp) 12413 movl %eax, OUT_ARG1(%esp) 12414 call dvmCheckInst # (dPC, self) 12415 movl rSELF, %ecx 12416 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12417 jmp *dvmAsmInstructionStart+(53*4) 12418 12419/* ------------------------------ */ 12420.L_ALT_OP_IF_GT: /* 0x36 */ 12421/* File: x86/alt_stub.S */ 12422/* 12423 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12424 * any interesting requests and then jump to the real instruction 12425 * handler. Unlike the Arm handler, we can't do this as a tail call 12426 * because rIBASE is caller save and we need to reload it. 12427 */ 12428 movl rSELF, %eax 12429 movl rPC, OUT_ARG0(%esp) 12430 movl %eax, OUT_ARG1(%esp) 12431 call dvmCheckInst # (dPC, self) 12432 movl rSELF, %ecx 12433 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12434 jmp *dvmAsmInstructionStart+(54*4) 12435 12436/* ------------------------------ */ 12437.L_ALT_OP_IF_LE: /* 0x37 */ 12438/* File: x86/alt_stub.S */ 12439/* 12440 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12441 * any interesting requests and then jump to the real instruction 12442 * handler. Unlike the Arm handler, we can't do this as a tail call 12443 * because rIBASE is caller save and we need to reload it. 12444 */ 12445 movl rSELF, %eax 12446 movl rPC, OUT_ARG0(%esp) 12447 movl %eax, OUT_ARG1(%esp) 12448 call dvmCheckInst # (dPC, self) 12449 movl rSELF, %ecx 12450 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12451 jmp *dvmAsmInstructionStart+(55*4) 12452 12453/* ------------------------------ */ 12454.L_ALT_OP_IF_EQZ: /* 0x38 */ 12455/* File: x86/alt_stub.S */ 12456/* 12457 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12458 * any interesting requests and then jump to the real instruction 12459 * handler. Unlike the Arm handler, we can't do this as a tail call 12460 * because rIBASE is caller save and we need to reload it. 12461 */ 12462 movl rSELF, %eax 12463 movl rPC, OUT_ARG0(%esp) 12464 movl %eax, OUT_ARG1(%esp) 12465 call dvmCheckInst # (dPC, self) 12466 movl rSELF, %ecx 12467 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12468 jmp *dvmAsmInstructionStart+(56*4) 12469 12470/* ------------------------------ */ 12471.L_ALT_OP_IF_NEZ: /* 0x39 */ 12472/* File: x86/alt_stub.S */ 12473/* 12474 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12475 * any interesting requests and then jump to the real instruction 12476 * handler. Unlike the Arm handler, we can't do this as a tail call 12477 * because rIBASE is caller save and we need to reload it. 12478 */ 12479 movl rSELF, %eax 12480 movl rPC, OUT_ARG0(%esp) 12481 movl %eax, OUT_ARG1(%esp) 12482 call dvmCheckInst # (dPC, self) 12483 movl rSELF, %ecx 12484 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12485 jmp *dvmAsmInstructionStart+(57*4) 12486 12487/* ------------------------------ */ 12488.L_ALT_OP_IF_LTZ: /* 0x3a */ 12489/* File: x86/alt_stub.S */ 12490/* 12491 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12492 * any interesting requests and then jump to the real instruction 12493 * handler. Unlike the Arm handler, we can't do this as a tail call 12494 * because rIBASE is caller save and we need to reload it. 12495 */ 12496 movl rSELF, %eax 12497 movl rPC, OUT_ARG0(%esp) 12498 movl %eax, OUT_ARG1(%esp) 12499 call dvmCheckInst # (dPC, self) 12500 movl rSELF, %ecx 12501 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12502 jmp *dvmAsmInstructionStart+(58*4) 12503 12504/* ------------------------------ */ 12505.L_ALT_OP_IF_GEZ: /* 0x3b */ 12506/* File: x86/alt_stub.S */ 12507/* 12508 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12509 * any interesting requests and then jump to the real instruction 12510 * handler. Unlike the Arm handler, we can't do this as a tail call 12511 * because rIBASE is caller save and we need to reload it. 12512 */ 12513 movl rSELF, %eax 12514 movl rPC, OUT_ARG0(%esp) 12515 movl %eax, OUT_ARG1(%esp) 12516 call dvmCheckInst # (dPC, self) 12517 movl rSELF, %ecx 12518 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12519 jmp *dvmAsmInstructionStart+(59*4) 12520 12521/* ------------------------------ */ 12522.L_ALT_OP_IF_GTZ: /* 0x3c */ 12523/* File: x86/alt_stub.S */ 12524/* 12525 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12526 * any interesting requests and then jump to the real instruction 12527 * handler. Unlike the Arm handler, we can't do this as a tail call 12528 * because rIBASE is caller save and we need to reload it. 12529 */ 12530 movl rSELF, %eax 12531 movl rPC, OUT_ARG0(%esp) 12532 movl %eax, OUT_ARG1(%esp) 12533 call dvmCheckInst # (dPC, self) 12534 movl rSELF, %ecx 12535 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12536 jmp *dvmAsmInstructionStart+(60*4) 12537 12538/* ------------------------------ */ 12539.L_ALT_OP_IF_LEZ: /* 0x3d */ 12540/* File: x86/alt_stub.S */ 12541/* 12542 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12543 * any interesting requests and then jump to the real instruction 12544 * handler. Unlike the Arm handler, we can't do this as a tail call 12545 * because rIBASE is caller save and we need to reload it. 12546 */ 12547 movl rSELF, %eax 12548 movl rPC, OUT_ARG0(%esp) 12549 movl %eax, OUT_ARG1(%esp) 12550 call dvmCheckInst # (dPC, self) 12551 movl rSELF, %ecx 12552 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12553 jmp *dvmAsmInstructionStart+(61*4) 12554 12555/* ------------------------------ */ 12556.L_ALT_OP_UNUSED_3E: /* 0x3e */ 12557/* File: x86/alt_stub.S */ 12558/* 12559 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12560 * any interesting requests and then jump to the real instruction 12561 * handler. Unlike the Arm handler, we can't do this as a tail call 12562 * because rIBASE is caller save and we need to reload it. 12563 */ 12564 movl rSELF, %eax 12565 movl rPC, OUT_ARG0(%esp) 12566 movl %eax, OUT_ARG1(%esp) 12567 call dvmCheckInst # (dPC, self) 12568 movl rSELF, %ecx 12569 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12570 jmp *dvmAsmInstructionStart+(62*4) 12571 12572/* ------------------------------ */ 12573.L_ALT_OP_UNUSED_3F: /* 0x3f */ 12574/* File: x86/alt_stub.S */ 12575/* 12576 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12577 * any interesting requests and then jump to the real instruction 12578 * handler. Unlike the Arm handler, we can't do this as a tail call 12579 * because rIBASE is caller save and we need to reload it. 12580 */ 12581 movl rSELF, %eax 12582 movl rPC, OUT_ARG0(%esp) 12583 movl %eax, OUT_ARG1(%esp) 12584 call dvmCheckInst # (dPC, self) 12585 movl rSELF, %ecx 12586 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12587 jmp *dvmAsmInstructionStart+(63*4) 12588 12589/* ------------------------------ */ 12590.L_ALT_OP_UNUSED_40: /* 0x40 */ 12591/* File: x86/alt_stub.S */ 12592/* 12593 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12594 * any interesting requests and then jump to the real instruction 12595 * handler. Unlike the Arm handler, we can't do this as a tail call 12596 * because rIBASE is caller save and we need to reload it. 12597 */ 12598 movl rSELF, %eax 12599 movl rPC, OUT_ARG0(%esp) 12600 movl %eax, OUT_ARG1(%esp) 12601 call dvmCheckInst # (dPC, self) 12602 movl rSELF, %ecx 12603 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12604 jmp *dvmAsmInstructionStart+(64*4) 12605 12606/* ------------------------------ */ 12607.L_ALT_OP_UNUSED_41: /* 0x41 */ 12608/* File: x86/alt_stub.S */ 12609/* 12610 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12611 * any interesting requests and then jump to the real instruction 12612 * handler. Unlike the Arm handler, we can't do this as a tail call 12613 * because rIBASE is caller save and we need to reload it. 12614 */ 12615 movl rSELF, %eax 12616 movl rPC, OUT_ARG0(%esp) 12617 movl %eax, OUT_ARG1(%esp) 12618 call dvmCheckInst # (dPC, self) 12619 movl rSELF, %ecx 12620 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12621 jmp *dvmAsmInstructionStart+(65*4) 12622 12623/* ------------------------------ */ 12624.L_ALT_OP_UNUSED_42: /* 0x42 */ 12625/* File: x86/alt_stub.S */ 12626/* 12627 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12628 * any interesting requests and then jump to the real instruction 12629 * handler. Unlike the Arm handler, we can't do this as a tail call 12630 * because rIBASE is caller save and we need to reload it. 12631 */ 12632 movl rSELF, %eax 12633 movl rPC, OUT_ARG0(%esp) 12634 movl %eax, OUT_ARG1(%esp) 12635 call dvmCheckInst # (dPC, self) 12636 movl rSELF, %ecx 12637 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12638 jmp *dvmAsmInstructionStart+(66*4) 12639 12640/* ------------------------------ */ 12641.L_ALT_OP_UNUSED_43: /* 0x43 */ 12642/* File: x86/alt_stub.S */ 12643/* 12644 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12645 * any interesting requests and then jump to the real instruction 12646 * handler. Unlike the Arm handler, we can't do this as a tail call 12647 * because rIBASE is caller save and we need to reload it. 12648 */ 12649 movl rSELF, %eax 12650 movl rPC, OUT_ARG0(%esp) 12651 movl %eax, OUT_ARG1(%esp) 12652 call dvmCheckInst # (dPC, self) 12653 movl rSELF, %ecx 12654 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12655 jmp *dvmAsmInstructionStart+(67*4) 12656 12657/* ------------------------------ */ 12658.L_ALT_OP_AGET: /* 0x44 */ 12659/* File: x86/alt_stub.S */ 12660/* 12661 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12662 * any interesting requests and then jump to the real instruction 12663 * handler. Unlike the Arm handler, we can't do this as a tail call 12664 * because rIBASE is caller save and we need to reload it. 12665 */ 12666 movl rSELF, %eax 12667 movl rPC, OUT_ARG0(%esp) 12668 movl %eax, OUT_ARG1(%esp) 12669 call dvmCheckInst # (dPC, self) 12670 movl rSELF, %ecx 12671 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12672 jmp *dvmAsmInstructionStart+(68*4) 12673 12674/* ------------------------------ */ 12675.L_ALT_OP_AGET_WIDE: /* 0x45 */ 12676/* File: x86/alt_stub.S */ 12677/* 12678 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12679 * any interesting requests and then jump to the real instruction 12680 * handler. Unlike the Arm handler, we can't do this as a tail call 12681 * because rIBASE is caller save and we need to reload it. 12682 */ 12683 movl rSELF, %eax 12684 movl rPC, OUT_ARG0(%esp) 12685 movl %eax, OUT_ARG1(%esp) 12686 call dvmCheckInst # (dPC, self) 12687 movl rSELF, %ecx 12688 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12689 jmp *dvmAsmInstructionStart+(69*4) 12690 12691/* ------------------------------ */ 12692.L_ALT_OP_AGET_OBJECT: /* 0x46 */ 12693/* File: x86/alt_stub.S */ 12694/* 12695 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12696 * any interesting requests and then jump to the real instruction 12697 * handler. Unlike the Arm handler, we can't do this as a tail call 12698 * because rIBASE is caller save and we need to reload it. 12699 */ 12700 movl rSELF, %eax 12701 movl rPC, OUT_ARG0(%esp) 12702 movl %eax, OUT_ARG1(%esp) 12703 call dvmCheckInst # (dPC, self) 12704 movl rSELF, %ecx 12705 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12706 jmp *dvmAsmInstructionStart+(70*4) 12707 12708/* ------------------------------ */ 12709.L_ALT_OP_AGET_BOOLEAN: /* 0x47 */ 12710/* File: x86/alt_stub.S */ 12711/* 12712 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12713 * any interesting requests and then jump to the real instruction 12714 * handler. Unlike the Arm handler, we can't do this as a tail call 12715 * because rIBASE is caller save and we need to reload it. 12716 */ 12717 movl rSELF, %eax 12718 movl rPC, OUT_ARG0(%esp) 12719 movl %eax, OUT_ARG1(%esp) 12720 call dvmCheckInst # (dPC, self) 12721 movl rSELF, %ecx 12722 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12723 jmp *dvmAsmInstructionStart+(71*4) 12724 12725/* ------------------------------ */ 12726.L_ALT_OP_AGET_BYTE: /* 0x48 */ 12727/* File: x86/alt_stub.S */ 12728/* 12729 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12730 * any interesting requests and then jump to the real instruction 12731 * handler. Unlike the Arm handler, we can't do this as a tail call 12732 * because rIBASE is caller save and we need to reload it. 12733 */ 12734 movl rSELF, %eax 12735 movl rPC, OUT_ARG0(%esp) 12736 movl %eax, OUT_ARG1(%esp) 12737 call dvmCheckInst # (dPC, self) 12738 movl rSELF, %ecx 12739 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12740 jmp *dvmAsmInstructionStart+(72*4) 12741 12742/* ------------------------------ */ 12743.L_ALT_OP_AGET_CHAR: /* 0x49 */ 12744/* File: x86/alt_stub.S */ 12745/* 12746 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12747 * any interesting requests and then jump to the real instruction 12748 * handler. Unlike the Arm handler, we can't do this as a tail call 12749 * because rIBASE is caller save and we need to reload it. 12750 */ 12751 movl rSELF, %eax 12752 movl rPC, OUT_ARG0(%esp) 12753 movl %eax, OUT_ARG1(%esp) 12754 call dvmCheckInst # (dPC, self) 12755 movl rSELF, %ecx 12756 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12757 jmp *dvmAsmInstructionStart+(73*4) 12758 12759/* ------------------------------ */ 12760.L_ALT_OP_AGET_SHORT: /* 0x4a */ 12761/* File: x86/alt_stub.S */ 12762/* 12763 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12764 * any interesting requests and then jump to the real instruction 12765 * handler. Unlike the Arm handler, we can't do this as a tail call 12766 * because rIBASE is caller save and we need to reload it. 12767 */ 12768 movl rSELF, %eax 12769 movl rPC, OUT_ARG0(%esp) 12770 movl %eax, OUT_ARG1(%esp) 12771 call dvmCheckInst # (dPC, self) 12772 movl rSELF, %ecx 12773 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12774 jmp *dvmAsmInstructionStart+(74*4) 12775 12776/* ------------------------------ */ 12777.L_ALT_OP_APUT: /* 0x4b */ 12778/* File: x86/alt_stub.S */ 12779/* 12780 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12781 * any interesting requests and then jump to the real instruction 12782 * handler. Unlike the Arm handler, we can't do this as a tail call 12783 * because rIBASE is caller save and we need to reload it. 12784 */ 12785 movl rSELF, %eax 12786 movl rPC, OUT_ARG0(%esp) 12787 movl %eax, OUT_ARG1(%esp) 12788 call dvmCheckInst # (dPC, self) 12789 movl rSELF, %ecx 12790 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12791 jmp *dvmAsmInstructionStart+(75*4) 12792 12793/* ------------------------------ */ 12794.L_ALT_OP_APUT_WIDE: /* 0x4c */ 12795/* File: x86/alt_stub.S */ 12796/* 12797 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12798 * any interesting requests and then jump to the real instruction 12799 * handler. Unlike the Arm handler, we can't do this as a tail call 12800 * because rIBASE is caller save and we need to reload it. 12801 */ 12802 movl rSELF, %eax 12803 movl rPC, OUT_ARG0(%esp) 12804 movl %eax, OUT_ARG1(%esp) 12805 call dvmCheckInst # (dPC, self) 12806 movl rSELF, %ecx 12807 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12808 jmp *dvmAsmInstructionStart+(76*4) 12809 12810/* ------------------------------ */ 12811.L_ALT_OP_APUT_OBJECT: /* 0x4d */ 12812/* File: x86/alt_stub.S */ 12813/* 12814 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12815 * any interesting requests and then jump to the real instruction 12816 * handler. Unlike the Arm handler, we can't do this as a tail call 12817 * because rIBASE is caller save and we need to reload it. 12818 */ 12819 movl rSELF, %eax 12820 movl rPC, OUT_ARG0(%esp) 12821 movl %eax, OUT_ARG1(%esp) 12822 call dvmCheckInst # (dPC, self) 12823 movl rSELF, %ecx 12824 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12825 jmp *dvmAsmInstructionStart+(77*4) 12826 12827/* ------------------------------ */ 12828.L_ALT_OP_APUT_BOOLEAN: /* 0x4e */ 12829/* File: x86/alt_stub.S */ 12830/* 12831 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12832 * any interesting requests and then jump to the real instruction 12833 * handler. Unlike the Arm handler, we can't do this as a tail call 12834 * because rIBASE is caller save and we need to reload it. 12835 */ 12836 movl rSELF, %eax 12837 movl rPC, OUT_ARG0(%esp) 12838 movl %eax, OUT_ARG1(%esp) 12839 call dvmCheckInst # (dPC, self) 12840 movl rSELF, %ecx 12841 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12842 jmp *dvmAsmInstructionStart+(78*4) 12843 12844/* ------------------------------ */ 12845.L_ALT_OP_APUT_BYTE: /* 0x4f */ 12846/* File: x86/alt_stub.S */ 12847/* 12848 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12849 * any interesting requests and then jump to the real instruction 12850 * handler. Unlike the Arm handler, we can't do this as a tail call 12851 * because rIBASE is caller save and we need to reload it. 12852 */ 12853 movl rSELF, %eax 12854 movl rPC, OUT_ARG0(%esp) 12855 movl %eax, OUT_ARG1(%esp) 12856 call dvmCheckInst # (dPC, self) 12857 movl rSELF, %ecx 12858 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12859 jmp *dvmAsmInstructionStart+(79*4) 12860 12861/* ------------------------------ */ 12862.L_ALT_OP_APUT_CHAR: /* 0x50 */ 12863/* File: x86/alt_stub.S */ 12864/* 12865 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12866 * any interesting requests and then jump to the real instruction 12867 * handler. Unlike the Arm handler, we can't do this as a tail call 12868 * because rIBASE is caller save and we need to reload it. 12869 */ 12870 movl rSELF, %eax 12871 movl rPC, OUT_ARG0(%esp) 12872 movl %eax, OUT_ARG1(%esp) 12873 call dvmCheckInst # (dPC, self) 12874 movl rSELF, %ecx 12875 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12876 jmp *dvmAsmInstructionStart+(80*4) 12877 12878/* ------------------------------ */ 12879.L_ALT_OP_APUT_SHORT: /* 0x51 */ 12880/* File: x86/alt_stub.S */ 12881/* 12882 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12883 * any interesting requests and then jump to the real instruction 12884 * handler. Unlike the Arm handler, we can't do this as a tail call 12885 * because rIBASE is caller save and we need to reload it. 12886 */ 12887 movl rSELF, %eax 12888 movl rPC, OUT_ARG0(%esp) 12889 movl %eax, OUT_ARG1(%esp) 12890 call dvmCheckInst # (dPC, self) 12891 movl rSELF, %ecx 12892 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12893 jmp *dvmAsmInstructionStart+(81*4) 12894 12895/* ------------------------------ */ 12896.L_ALT_OP_IGET: /* 0x52 */ 12897/* File: x86/alt_stub.S */ 12898/* 12899 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12900 * any interesting requests and then jump to the real instruction 12901 * handler. Unlike the Arm handler, we can't do this as a tail call 12902 * because rIBASE is caller save and we need to reload it. 12903 */ 12904 movl rSELF, %eax 12905 movl rPC, OUT_ARG0(%esp) 12906 movl %eax, OUT_ARG1(%esp) 12907 call dvmCheckInst # (dPC, self) 12908 movl rSELF, %ecx 12909 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12910 jmp *dvmAsmInstructionStart+(82*4) 12911 12912/* ------------------------------ */ 12913.L_ALT_OP_IGET_WIDE: /* 0x53 */ 12914/* File: x86/alt_stub.S */ 12915/* 12916 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12917 * any interesting requests and then jump to the real instruction 12918 * handler. Unlike the Arm handler, we can't do this as a tail call 12919 * because rIBASE is caller save and we need to reload it. 12920 */ 12921 movl rSELF, %eax 12922 movl rPC, OUT_ARG0(%esp) 12923 movl %eax, OUT_ARG1(%esp) 12924 call dvmCheckInst # (dPC, self) 12925 movl rSELF, %ecx 12926 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12927 jmp *dvmAsmInstructionStart+(83*4) 12928 12929/* ------------------------------ */ 12930.L_ALT_OP_IGET_OBJECT: /* 0x54 */ 12931/* File: x86/alt_stub.S */ 12932/* 12933 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12934 * any interesting requests and then jump to the real instruction 12935 * handler. Unlike the Arm handler, we can't do this as a tail call 12936 * because rIBASE is caller save and we need to reload it. 12937 */ 12938 movl rSELF, %eax 12939 movl rPC, OUT_ARG0(%esp) 12940 movl %eax, OUT_ARG1(%esp) 12941 call dvmCheckInst # (dPC, self) 12942 movl rSELF, %ecx 12943 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12944 jmp *dvmAsmInstructionStart+(84*4) 12945 12946/* ------------------------------ */ 12947.L_ALT_OP_IGET_BOOLEAN: /* 0x55 */ 12948/* File: x86/alt_stub.S */ 12949/* 12950 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12951 * any interesting requests and then jump to the real instruction 12952 * handler. Unlike the Arm handler, we can't do this as a tail call 12953 * because rIBASE is caller save and we need to reload it. 12954 */ 12955 movl rSELF, %eax 12956 movl rPC, OUT_ARG0(%esp) 12957 movl %eax, OUT_ARG1(%esp) 12958 call dvmCheckInst # (dPC, self) 12959 movl rSELF, %ecx 12960 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12961 jmp *dvmAsmInstructionStart+(85*4) 12962 12963/* ------------------------------ */ 12964.L_ALT_OP_IGET_BYTE: /* 0x56 */ 12965/* File: x86/alt_stub.S */ 12966/* 12967 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12968 * any interesting requests and then jump to the real instruction 12969 * handler. Unlike the Arm handler, we can't do this as a tail call 12970 * because rIBASE is caller save and we need to reload it. 12971 */ 12972 movl rSELF, %eax 12973 movl rPC, OUT_ARG0(%esp) 12974 movl %eax, OUT_ARG1(%esp) 12975 call dvmCheckInst # (dPC, self) 12976 movl rSELF, %ecx 12977 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12978 jmp *dvmAsmInstructionStart+(86*4) 12979 12980/* ------------------------------ */ 12981.L_ALT_OP_IGET_CHAR: /* 0x57 */ 12982/* File: x86/alt_stub.S */ 12983/* 12984 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12985 * any interesting requests and then jump to the real instruction 12986 * handler. Unlike the Arm handler, we can't do this as a tail call 12987 * because rIBASE is caller save and we need to reload it. 12988 */ 12989 movl rSELF, %eax 12990 movl rPC, OUT_ARG0(%esp) 12991 movl %eax, OUT_ARG1(%esp) 12992 call dvmCheckInst # (dPC, self) 12993 movl rSELF, %ecx 12994 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12995 jmp *dvmAsmInstructionStart+(87*4) 12996 12997/* ------------------------------ */ 12998.L_ALT_OP_IGET_SHORT: /* 0x58 */ 12999/* File: x86/alt_stub.S */ 13000/* 13001 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13002 * any interesting requests and then jump to the real instruction 13003 * handler. Unlike the Arm handler, we can't do this as a tail call 13004 * because rIBASE is caller save and we need to reload it. 13005 */ 13006 movl rSELF, %eax 13007 movl rPC, OUT_ARG0(%esp) 13008 movl %eax, OUT_ARG1(%esp) 13009 call dvmCheckInst # (dPC, self) 13010 movl rSELF, %ecx 13011 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13012 jmp *dvmAsmInstructionStart+(88*4) 13013 13014/* ------------------------------ */ 13015.L_ALT_OP_IPUT: /* 0x59 */ 13016/* File: x86/alt_stub.S */ 13017/* 13018 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13019 * any interesting requests and then jump to the real instruction 13020 * handler. Unlike the Arm handler, we can't do this as a tail call 13021 * because rIBASE is caller save and we need to reload it. 13022 */ 13023 movl rSELF, %eax 13024 movl rPC, OUT_ARG0(%esp) 13025 movl %eax, OUT_ARG1(%esp) 13026 call dvmCheckInst # (dPC, self) 13027 movl rSELF, %ecx 13028 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13029 jmp *dvmAsmInstructionStart+(89*4) 13030 13031/* ------------------------------ */ 13032.L_ALT_OP_IPUT_WIDE: /* 0x5a */ 13033/* File: x86/alt_stub.S */ 13034/* 13035 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13036 * any interesting requests and then jump to the real instruction 13037 * handler. Unlike the Arm handler, we can't do this as a tail call 13038 * because rIBASE is caller save and we need to reload it. 13039 */ 13040 movl rSELF, %eax 13041 movl rPC, OUT_ARG0(%esp) 13042 movl %eax, OUT_ARG1(%esp) 13043 call dvmCheckInst # (dPC, self) 13044 movl rSELF, %ecx 13045 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13046 jmp *dvmAsmInstructionStart+(90*4) 13047 13048/* ------------------------------ */ 13049.L_ALT_OP_IPUT_OBJECT: /* 0x5b */ 13050/* File: x86/alt_stub.S */ 13051/* 13052 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13053 * any interesting requests and then jump to the real instruction 13054 * handler. Unlike the Arm handler, we can't do this as a tail call 13055 * because rIBASE is caller save and we need to reload it. 13056 */ 13057 movl rSELF, %eax 13058 movl rPC, OUT_ARG0(%esp) 13059 movl %eax, OUT_ARG1(%esp) 13060 call dvmCheckInst # (dPC, self) 13061 movl rSELF, %ecx 13062 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13063 jmp *dvmAsmInstructionStart+(91*4) 13064 13065/* ------------------------------ */ 13066.L_ALT_OP_IPUT_BOOLEAN: /* 0x5c */ 13067/* File: x86/alt_stub.S */ 13068/* 13069 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13070 * any interesting requests and then jump to the real instruction 13071 * handler. Unlike the Arm handler, we can't do this as a tail call 13072 * because rIBASE is caller save and we need to reload it. 13073 */ 13074 movl rSELF, %eax 13075 movl rPC, OUT_ARG0(%esp) 13076 movl %eax, OUT_ARG1(%esp) 13077 call dvmCheckInst # (dPC, self) 13078 movl rSELF, %ecx 13079 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13080 jmp *dvmAsmInstructionStart+(92*4) 13081 13082/* ------------------------------ */ 13083.L_ALT_OP_IPUT_BYTE: /* 0x5d */ 13084/* File: x86/alt_stub.S */ 13085/* 13086 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13087 * any interesting requests and then jump to the real instruction 13088 * handler. Unlike the Arm handler, we can't do this as a tail call 13089 * because rIBASE is caller save and we need to reload it. 13090 */ 13091 movl rSELF, %eax 13092 movl rPC, OUT_ARG0(%esp) 13093 movl %eax, OUT_ARG1(%esp) 13094 call dvmCheckInst # (dPC, self) 13095 movl rSELF, %ecx 13096 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13097 jmp *dvmAsmInstructionStart+(93*4) 13098 13099/* ------------------------------ */ 13100.L_ALT_OP_IPUT_CHAR: /* 0x5e */ 13101/* File: x86/alt_stub.S */ 13102/* 13103 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13104 * any interesting requests and then jump to the real instruction 13105 * handler. Unlike the Arm handler, we can't do this as a tail call 13106 * because rIBASE is caller save and we need to reload it. 13107 */ 13108 movl rSELF, %eax 13109 movl rPC, OUT_ARG0(%esp) 13110 movl %eax, OUT_ARG1(%esp) 13111 call dvmCheckInst # (dPC, self) 13112 movl rSELF, %ecx 13113 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13114 jmp *dvmAsmInstructionStart+(94*4) 13115 13116/* ------------------------------ */ 13117.L_ALT_OP_IPUT_SHORT: /* 0x5f */ 13118/* File: x86/alt_stub.S */ 13119/* 13120 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13121 * any interesting requests and then jump to the real instruction 13122 * handler. Unlike the Arm handler, we can't do this as a tail call 13123 * because rIBASE is caller save and we need to reload it. 13124 */ 13125 movl rSELF, %eax 13126 movl rPC, OUT_ARG0(%esp) 13127 movl %eax, OUT_ARG1(%esp) 13128 call dvmCheckInst # (dPC, self) 13129 movl rSELF, %ecx 13130 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13131 jmp *dvmAsmInstructionStart+(95*4) 13132 13133/* ------------------------------ */ 13134.L_ALT_OP_SGET: /* 0x60 */ 13135/* File: x86/alt_stub.S */ 13136/* 13137 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13138 * any interesting requests and then jump to the real instruction 13139 * handler. Unlike the Arm handler, we can't do this as a tail call 13140 * because rIBASE is caller save and we need to reload it. 13141 */ 13142 movl rSELF, %eax 13143 movl rPC, OUT_ARG0(%esp) 13144 movl %eax, OUT_ARG1(%esp) 13145 call dvmCheckInst # (dPC, self) 13146 movl rSELF, %ecx 13147 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13148 jmp *dvmAsmInstructionStart+(96*4) 13149 13150/* ------------------------------ */ 13151.L_ALT_OP_SGET_WIDE: /* 0x61 */ 13152/* File: x86/alt_stub.S */ 13153/* 13154 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13155 * any interesting requests and then jump to the real instruction 13156 * handler. Unlike the Arm handler, we can't do this as a tail call 13157 * because rIBASE is caller save and we need to reload it. 13158 */ 13159 movl rSELF, %eax 13160 movl rPC, OUT_ARG0(%esp) 13161 movl %eax, OUT_ARG1(%esp) 13162 call dvmCheckInst # (dPC, self) 13163 movl rSELF, %ecx 13164 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13165 jmp *dvmAsmInstructionStart+(97*4) 13166 13167/* ------------------------------ */ 13168.L_ALT_OP_SGET_OBJECT: /* 0x62 */ 13169/* File: x86/alt_stub.S */ 13170/* 13171 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13172 * any interesting requests and then jump to the real instruction 13173 * handler. Unlike the Arm handler, we can't do this as a tail call 13174 * because rIBASE is caller save and we need to reload it. 13175 */ 13176 movl rSELF, %eax 13177 movl rPC, OUT_ARG0(%esp) 13178 movl %eax, OUT_ARG1(%esp) 13179 call dvmCheckInst # (dPC, self) 13180 movl rSELF, %ecx 13181 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13182 jmp *dvmAsmInstructionStart+(98*4) 13183 13184/* ------------------------------ */ 13185.L_ALT_OP_SGET_BOOLEAN: /* 0x63 */ 13186/* File: x86/alt_stub.S */ 13187/* 13188 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13189 * any interesting requests and then jump to the real instruction 13190 * handler. Unlike the Arm handler, we can't do this as a tail call 13191 * because rIBASE is caller save and we need to reload it. 13192 */ 13193 movl rSELF, %eax 13194 movl rPC, OUT_ARG0(%esp) 13195 movl %eax, OUT_ARG1(%esp) 13196 call dvmCheckInst # (dPC, self) 13197 movl rSELF, %ecx 13198 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13199 jmp *dvmAsmInstructionStart+(99*4) 13200 13201/* ------------------------------ */ 13202.L_ALT_OP_SGET_BYTE: /* 0x64 */ 13203/* File: x86/alt_stub.S */ 13204/* 13205 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13206 * any interesting requests and then jump to the real instruction 13207 * handler. Unlike the Arm handler, we can't do this as a tail call 13208 * because rIBASE is caller save and we need to reload it. 13209 */ 13210 movl rSELF, %eax 13211 movl rPC, OUT_ARG0(%esp) 13212 movl %eax, OUT_ARG1(%esp) 13213 call dvmCheckInst # (dPC, self) 13214 movl rSELF, %ecx 13215 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13216 jmp *dvmAsmInstructionStart+(100*4) 13217 13218/* ------------------------------ */ 13219.L_ALT_OP_SGET_CHAR: /* 0x65 */ 13220/* File: x86/alt_stub.S */ 13221/* 13222 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13223 * any interesting requests and then jump to the real instruction 13224 * handler. Unlike the Arm handler, we can't do this as a tail call 13225 * because rIBASE is caller save and we need to reload it. 13226 */ 13227 movl rSELF, %eax 13228 movl rPC, OUT_ARG0(%esp) 13229 movl %eax, OUT_ARG1(%esp) 13230 call dvmCheckInst # (dPC, self) 13231 movl rSELF, %ecx 13232 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13233 jmp *dvmAsmInstructionStart+(101*4) 13234 13235/* ------------------------------ */ 13236.L_ALT_OP_SGET_SHORT: /* 0x66 */ 13237/* File: x86/alt_stub.S */ 13238/* 13239 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13240 * any interesting requests and then jump to the real instruction 13241 * handler. Unlike the Arm handler, we can't do this as a tail call 13242 * because rIBASE is caller save and we need to reload it. 13243 */ 13244 movl rSELF, %eax 13245 movl rPC, OUT_ARG0(%esp) 13246 movl %eax, OUT_ARG1(%esp) 13247 call dvmCheckInst # (dPC, self) 13248 movl rSELF, %ecx 13249 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13250 jmp *dvmAsmInstructionStart+(102*4) 13251 13252/* ------------------------------ */ 13253.L_ALT_OP_SPUT: /* 0x67 */ 13254/* File: x86/alt_stub.S */ 13255/* 13256 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13257 * any interesting requests and then jump to the real instruction 13258 * handler. Unlike the Arm handler, we can't do this as a tail call 13259 * because rIBASE is caller save and we need to reload it. 13260 */ 13261 movl rSELF, %eax 13262 movl rPC, OUT_ARG0(%esp) 13263 movl %eax, OUT_ARG1(%esp) 13264 call dvmCheckInst # (dPC, self) 13265 movl rSELF, %ecx 13266 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13267 jmp *dvmAsmInstructionStart+(103*4) 13268 13269/* ------------------------------ */ 13270.L_ALT_OP_SPUT_WIDE: /* 0x68 */ 13271/* File: x86/alt_stub.S */ 13272/* 13273 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13274 * any interesting requests and then jump to the real instruction 13275 * handler. Unlike the Arm handler, we can't do this as a tail call 13276 * because rIBASE is caller save and we need to reload it. 13277 */ 13278 movl rSELF, %eax 13279 movl rPC, OUT_ARG0(%esp) 13280 movl %eax, OUT_ARG1(%esp) 13281 call dvmCheckInst # (dPC, self) 13282 movl rSELF, %ecx 13283 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13284 jmp *dvmAsmInstructionStart+(104*4) 13285 13286/* ------------------------------ */ 13287.L_ALT_OP_SPUT_OBJECT: /* 0x69 */ 13288/* File: x86/alt_stub.S */ 13289/* 13290 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13291 * any interesting requests and then jump to the real instruction 13292 * handler. Unlike the Arm handler, we can't do this as a tail call 13293 * because rIBASE is caller save and we need to reload it. 13294 */ 13295 movl rSELF, %eax 13296 movl rPC, OUT_ARG0(%esp) 13297 movl %eax, OUT_ARG1(%esp) 13298 call dvmCheckInst # (dPC, self) 13299 movl rSELF, %ecx 13300 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13301 jmp *dvmAsmInstructionStart+(105*4) 13302 13303/* ------------------------------ */ 13304.L_ALT_OP_SPUT_BOOLEAN: /* 0x6a */ 13305/* File: x86/alt_stub.S */ 13306/* 13307 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13308 * any interesting requests and then jump to the real instruction 13309 * handler. Unlike the Arm handler, we can't do this as a tail call 13310 * because rIBASE is caller save and we need to reload it. 13311 */ 13312 movl rSELF, %eax 13313 movl rPC, OUT_ARG0(%esp) 13314 movl %eax, OUT_ARG1(%esp) 13315 call dvmCheckInst # (dPC, self) 13316 movl rSELF, %ecx 13317 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13318 jmp *dvmAsmInstructionStart+(106*4) 13319 13320/* ------------------------------ */ 13321.L_ALT_OP_SPUT_BYTE: /* 0x6b */ 13322/* File: x86/alt_stub.S */ 13323/* 13324 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13325 * any interesting requests and then jump to the real instruction 13326 * handler. Unlike the Arm handler, we can't do this as a tail call 13327 * because rIBASE is caller save and we need to reload it. 13328 */ 13329 movl rSELF, %eax 13330 movl rPC, OUT_ARG0(%esp) 13331 movl %eax, OUT_ARG1(%esp) 13332 call dvmCheckInst # (dPC, self) 13333 movl rSELF, %ecx 13334 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13335 jmp *dvmAsmInstructionStart+(107*4) 13336 13337/* ------------------------------ */ 13338.L_ALT_OP_SPUT_CHAR: /* 0x6c */ 13339/* File: x86/alt_stub.S */ 13340/* 13341 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13342 * any interesting requests and then jump to the real instruction 13343 * handler. Unlike the Arm handler, we can't do this as a tail call 13344 * because rIBASE is caller save and we need to reload it. 13345 */ 13346 movl rSELF, %eax 13347 movl rPC, OUT_ARG0(%esp) 13348 movl %eax, OUT_ARG1(%esp) 13349 call dvmCheckInst # (dPC, self) 13350 movl rSELF, %ecx 13351 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13352 jmp *dvmAsmInstructionStart+(108*4) 13353 13354/* ------------------------------ */ 13355.L_ALT_OP_SPUT_SHORT: /* 0x6d */ 13356/* File: x86/alt_stub.S */ 13357/* 13358 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13359 * any interesting requests and then jump to the real instruction 13360 * handler. Unlike the Arm handler, we can't do this as a tail call 13361 * because rIBASE is caller save and we need to reload it. 13362 */ 13363 movl rSELF, %eax 13364 movl rPC, OUT_ARG0(%esp) 13365 movl %eax, OUT_ARG1(%esp) 13366 call dvmCheckInst # (dPC, self) 13367 movl rSELF, %ecx 13368 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13369 jmp *dvmAsmInstructionStart+(109*4) 13370 13371/* ------------------------------ */ 13372.L_ALT_OP_INVOKE_VIRTUAL: /* 0x6e */ 13373/* File: x86/alt_stub.S */ 13374/* 13375 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13376 * any interesting requests and then jump to the real instruction 13377 * handler. Unlike the Arm handler, we can't do this as a tail call 13378 * because rIBASE is caller save and we need to reload it. 13379 */ 13380 movl rSELF, %eax 13381 movl rPC, OUT_ARG0(%esp) 13382 movl %eax, OUT_ARG1(%esp) 13383 call dvmCheckInst # (dPC, self) 13384 movl rSELF, %ecx 13385 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13386 jmp *dvmAsmInstructionStart+(110*4) 13387 13388/* ------------------------------ */ 13389.L_ALT_OP_INVOKE_SUPER: /* 0x6f */ 13390/* File: x86/alt_stub.S */ 13391/* 13392 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13393 * any interesting requests and then jump to the real instruction 13394 * handler. Unlike the Arm handler, we can't do this as a tail call 13395 * because rIBASE is caller save and we need to reload it. 13396 */ 13397 movl rSELF, %eax 13398 movl rPC, OUT_ARG0(%esp) 13399 movl %eax, OUT_ARG1(%esp) 13400 call dvmCheckInst # (dPC, self) 13401 movl rSELF, %ecx 13402 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13403 jmp *dvmAsmInstructionStart+(111*4) 13404 13405/* ------------------------------ */ 13406.L_ALT_OP_INVOKE_DIRECT: /* 0x70 */ 13407/* File: x86/alt_stub.S */ 13408/* 13409 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13410 * any interesting requests and then jump to the real instruction 13411 * handler. Unlike the Arm handler, we can't do this as a tail call 13412 * because rIBASE is caller save and we need to reload it. 13413 */ 13414 movl rSELF, %eax 13415 movl rPC, OUT_ARG0(%esp) 13416 movl %eax, OUT_ARG1(%esp) 13417 call dvmCheckInst # (dPC, self) 13418 movl rSELF, %ecx 13419 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13420 jmp *dvmAsmInstructionStart+(112*4) 13421 13422/* ------------------------------ */ 13423.L_ALT_OP_INVOKE_STATIC: /* 0x71 */ 13424/* File: x86/alt_stub.S */ 13425/* 13426 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13427 * any interesting requests and then jump to the real instruction 13428 * handler. Unlike the Arm handler, we can't do this as a tail call 13429 * because rIBASE is caller save and we need to reload it. 13430 */ 13431 movl rSELF, %eax 13432 movl rPC, OUT_ARG0(%esp) 13433 movl %eax, OUT_ARG1(%esp) 13434 call dvmCheckInst # (dPC, self) 13435 movl rSELF, %ecx 13436 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13437 jmp *dvmAsmInstructionStart+(113*4) 13438 13439/* ------------------------------ */ 13440.L_ALT_OP_INVOKE_INTERFACE: /* 0x72 */ 13441/* File: x86/alt_stub.S */ 13442/* 13443 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13444 * any interesting requests and then jump to the real instruction 13445 * handler. Unlike the Arm handler, we can't do this as a tail call 13446 * because rIBASE is caller save and we need to reload it. 13447 */ 13448 movl rSELF, %eax 13449 movl rPC, OUT_ARG0(%esp) 13450 movl %eax, OUT_ARG1(%esp) 13451 call dvmCheckInst # (dPC, self) 13452 movl rSELF, %ecx 13453 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13454 jmp *dvmAsmInstructionStart+(114*4) 13455 13456/* ------------------------------ */ 13457.L_ALT_OP_UNUSED_73: /* 0x73 */ 13458/* File: x86/alt_stub.S */ 13459/* 13460 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13461 * any interesting requests and then jump to the real instruction 13462 * handler. Unlike the Arm handler, we can't do this as a tail call 13463 * because rIBASE is caller save and we need to reload it. 13464 */ 13465 movl rSELF, %eax 13466 movl rPC, OUT_ARG0(%esp) 13467 movl %eax, OUT_ARG1(%esp) 13468 call dvmCheckInst # (dPC, self) 13469 movl rSELF, %ecx 13470 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13471 jmp *dvmAsmInstructionStart+(115*4) 13472 13473/* ------------------------------ */ 13474.L_ALT_OP_INVOKE_VIRTUAL_RANGE: /* 0x74 */ 13475/* File: x86/alt_stub.S */ 13476/* 13477 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13478 * any interesting requests and then jump to the real instruction 13479 * handler. Unlike the Arm handler, we can't do this as a tail call 13480 * because rIBASE is caller save and we need to reload it. 13481 */ 13482 movl rSELF, %eax 13483 movl rPC, OUT_ARG0(%esp) 13484 movl %eax, OUT_ARG1(%esp) 13485 call dvmCheckInst # (dPC, self) 13486 movl rSELF, %ecx 13487 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13488 jmp *dvmAsmInstructionStart+(116*4) 13489 13490/* ------------------------------ */ 13491.L_ALT_OP_INVOKE_SUPER_RANGE: /* 0x75 */ 13492/* File: x86/alt_stub.S */ 13493/* 13494 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13495 * any interesting requests and then jump to the real instruction 13496 * handler. Unlike the Arm handler, we can't do this as a tail call 13497 * because rIBASE is caller save and we need to reload it. 13498 */ 13499 movl rSELF, %eax 13500 movl rPC, OUT_ARG0(%esp) 13501 movl %eax, OUT_ARG1(%esp) 13502 call dvmCheckInst # (dPC, self) 13503 movl rSELF, %ecx 13504 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13505 jmp *dvmAsmInstructionStart+(117*4) 13506 13507/* ------------------------------ */ 13508.L_ALT_OP_INVOKE_DIRECT_RANGE: /* 0x76 */ 13509/* File: x86/alt_stub.S */ 13510/* 13511 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13512 * any interesting requests and then jump to the real instruction 13513 * handler. Unlike the Arm handler, we can't do this as a tail call 13514 * because rIBASE is caller save and we need to reload it. 13515 */ 13516 movl rSELF, %eax 13517 movl rPC, OUT_ARG0(%esp) 13518 movl %eax, OUT_ARG1(%esp) 13519 call dvmCheckInst # (dPC, self) 13520 movl rSELF, %ecx 13521 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13522 jmp *dvmAsmInstructionStart+(118*4) 13523 13524/* ------------------------------ */ 13525.L_ALT_OP_INVOKE_STATIC_RANGE: /* 0x77 */ 13526/* File: x86/alt_stub.S */ 13527/* 13528 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13529 * any interesting requests and then jump to the real instruction 13530 * handler. Unlike the Arm handler, we can't do this as a tail call 13531 * because rIBASE is caller save and we need to reload it. 13532 */ 13533 movl rSELF, %eax 13534 movl rPC, OUT_ARG0(%esp) 13535 movl %eax, OUT_ARG1(%esp) 13536 call dvmCheckInst # (dPC, self) 13537 movl rSELF, %ecx 13538 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13539 jmp *dvmAsmInstructionStart+(119*4) 13540 13541/* ------------------------------ */ 13542.L_ALT_OP_INVOKE_INTERFACE_RANGE: /* 0x78 */ 13543/* File: x86/alt_stub.S */ 13544/* 13545 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13546 * any interesting requests and then jump to the real instruction 13547 * handler. Unlike the Arm handler, we can't do this as a tail call 13548 * because rIBASE is caller save and we need to reload it. 13549 */ 13550 movl rSELF, %eax 13551 movl rPC, OUT_ARG0(%esp) 13552 movl %eax, OUT_ARG1(%esp) 13553 call dvmCheckInst # (dPC, self) 13554 movl rSELF, %ecx 13555 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13556 jmp *dvmAsmInstructionStart+(120*4) 13557 13558/* ------------------------------ */ 13559.L_ALT_OP_UNUSED_79: /* 0x79 */ 13560/* File: x86/alt_stub.S */ 13561/* 13562 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13563 * any interesting requests and then jump to the real instruction 13564 * handler. Unlike the Arm handler, we can't do this as a tail call 13565 * because rIBASE is caller save and we need to reload it. 13566 */ 13567 movl rSELF, %eax 13568 movl rPC, OUT_ARG0(%esp) 13569 movl %eax, OUT_ARG1(%esp) 13570 call dvmCheckInst # (dPC, self) 13571 movl rSELF, %ecx 13572 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13573 jmp *dvmAsmInstructionStart+(121*4) 13574 13575/* ------------------------------ */ 13576.L_ALT_OP_UNUSED_7A: /* 0x7a */ 13577/* File: x86/alt_stub.S */ 13578/* 13579 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13580 * any interesting requests and then jump to the real instruction 13581 * handler. Unlike the Arm handler, we can't do this as a tail call 13582 * because rIBASE is caller save and we need to reload it. 13583 */ 13584 movl rSELF, %eax 13585 movl rPC, OUT_ARG0(%esp) 13586 movl %eax, OUT_ARG1(%esp) 13587 call dvmCheckInst # (dPC, self) 13588 movl rSELF, %ecx 13589 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13590 jmp *dvmAsmInstructionStart+(122*4) 13591 13592/* ------------------------------ */ 13593.L_ALT_OP_NEG_INT: /* 0x7b */ 13594/* File: x86/alt_stub.S */ 13595/* 13596 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13597 * any interesting requests and then jump to the real instruction 13598 * handler. Unlike the Arm handler, we can't do this as a tail call 13599 * because rIBASE is caller save and we need to reload it. 13600 */ 13601 movl rSELF, %eax 13602 movl rPC, OUT_ARG0(%esp) 13603 movl %eax, OUT_ARG1(%esp) 13604 call dvmCheckInst # (dPC, self) 13605 movl rSELF, %ecx 13606 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13607 jmp *dvmAsmInstructionStart+(123*4) 13608 13609/* ------------------------------ */ 13610.L_ALT_OP_NOT_INT: /* 0x7c */ 13611/* File: x86/alt_stub.S */ 13612/* 13613 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13614 * any interesting requests and then jump to the real instruction 13615 * handler. Unlike the Arm handler, we can't do this as a tail call 13616 * because rIBASE is caller save and we need to reload it. 13617 */ 13618 movl rSELF, %eax 13619 movl rPC, OUT_ARG0(%esp) 13620 movl %eax, OUT_ARG1(%esp) 13621 call dvmCheckInst # (dPC, self) 13622 movl rSELF, %ecx 13623 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13624 jmp *dvmAsmInstructionStart+(124*4) 13625 13626/* ------------------------------ */ 13627.L_ALT_OP_NEG_LONG: /* 0x7d */ 13628/* File: x86/alt_stub.S */ 13629/* 13630 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13631 * any interesting requests and then jump to the real instruction 13632 * handler. Unlike the Arm handler, we can't do this as a tail call 13633 * because rIBASE is caller save and we need to reload it. 13634 */ 13635 movl rSELF, %eax 13636 movl rPC, OUT_ARG0(%esp) 13637 movl %eax, OUT_ARG1(%esp) 13638 call dvmCheckInst # (dPC, self) 13639 movl rSELF, %ecx 13640 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13641 jmp *dvmAsmInstructionStart+(125*4) 13642 13643/* ------------------------------ */ 13644.L_ALT_OP_NOT_LONG: /* 0x7e */ 13645/* File: x86/alt_stub.S */ 13646/* 13647 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13648 * any interesting requests and then jump to the real instruction 13649 * handler. Unlike the Arm handler, we can't do this as a tail call 13650 * because rIBASE is caller save and we need to reload it. 13651 */ 13652 movl rSELF, %eax 13653 movl rPC, OUT_ARG0(%esp) 13654 movl %eax, OUT_ARG1(%esp) 13655 call dvmCheckInst # (dPC, self) 13656 movl rSELF, %ecx 13657 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13658 jmp *dvmAsmInstructionStart+(126*4) 13659 13660/* ------------------------------ */ 13661.L_ALT_OP_NEG_FLOAT: /* 0x7f */ 13662/* File: x86/alt_stub.S */ 13663/* 13664 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13665 * any interesting requests and then jump to the real instruction 13666 * handler. Unlike the Arm handler, we can't do this as a tail call 13667 * because rIBASE is caller save and we need to reload it. 13668 */ 13669 movl rSELF, %eax 13670 movl rPC, OUT_ARG0(%esp) 13671 movl %eax, OUT_ARG1(%esp) 13672 call dvmCheckInst # (dPC, self) 13673 movl rSELF, %ecx 13674 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13675 jmp *dvmAsmInstructionStart+(127*4) 13676 13677/* ------------------------------ */ 13678.L_ALT_OP_NEG_DOUBLE: /* 0x80 */ 13679/* File: x86/alt_stub.S */ 13680/* 13681 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13682 * any interesting requests and then jump to the real instruction 13683 * handler. Unlike the Arm handler, we can't do this as a tail call 13684 * because rIBASE is caller save and we need to reload it. 13685 */ 13686 movl rSELF, %eax 13687 movl rPC, OUT_ARG0(%esp) 13688 movl %eax, OUT_ARG1(%esp) 13689 call dvmCheckInst # (dPC, self) 13690 movl rSELF, %ecx 13691 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13692 jmp *dvmAsmInstructionStart+(128*4) 13693 13694/* ------------------------------ */ 13695.L_ALT_OP_INT_TO_LONG: /* 0x81 */ 13696/* File: x86/alt_stub.S */ 13697/* 13698 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13699 * any interesting requests and then jump to the real instruction 13700 * handler. Unlike the Arm handler, we can't do this as a tail call 13701 * because rIBASE is caller save and we need to reload it. 13702 */ 13703 movl rSELF, %eax 13704 movl rPC, OUT_ARG0(%esp) 13705 movl %eax, OUT_ARG1(%esp) 13706 call dvmCheckInst # (dPC, self) 13707 movl rSELF, %ecx 13708 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13709 jmp *dvmAsmInstructionStart+(129*4) 13710 13711/* ------------------------------ */ 13712.L_ALT_OP_INT_TO_FLOAT: /* 0x82 */ 13713/* File: x86/alt_stub.S */ 13714/* 13715 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13716 * any interesting requests and then jump to the real instruction 13717 * handler. Unlike the Arm handler, we can't do this as a tail call 13718 * because rIBASE is caller save and we need to reload it. 13719 */ 13720 movl rSELF, %eax 13721 movl rPC, OUT_ARG0(%esp) 13722 movl %eax, OUT_ARG1(%esp) 13723 call dvmCheckInst # (dPC, self) 13724 movl rSELF, %ecx 13725 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13726 jmp *dvmAsmInstructionStart+(130*4) 13727 13728/* ------------------------------ */ 13729.L_ALT_OP_INT_TO_DOUBLE: /* 0x83 */ 13730/* File: x86/alt_stub.S */ 13731/* 13732 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13733 * any interesting requests and then jump to the real instruction 13734 * handler. Unlike the Arm handler, we can't do this as a tail call 13735 * because rIBASE is caller save and we need to reload it. 13736 */ 13737 movl rSELF, %eax 13738 movl rPC, OUT_ARG0(%esp) 13739 movl %eax, OUT_ARG1(%esp) 13740 call dvmCheckInst # (dPC, self) 13741 movl rSELF, %ecx 13742 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13743 jmp *dvmAsmInstructionStart+(131*4) 13744 13745/* ------------------------------ */ 13746.L_ALT_OP_LONG_TO_INT: /* 0x84 */ 13747/* File: x86/alt_stub.S */ 13748/* 13749 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13750 * any interesting requests and then jump to the real instruction 13751 * handler. Unlike the Arm handler, we can't do this as a tail call 13752 * because rIBASE is caller save and we need to reload it. 13753 */ 13754 movl rSELF, %eax 13755 movl rPC, OUT_ARG0(%esp) 13756 movl %eax, OUT_ARG1(%esp) 13757 call dvmCheckInst # (dPC, self) 13758 movl rSELF, %ecx 13759 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13760 jmp *dvmAsmInstructionStart+(132*4) 13761 13762/* ------------------------------ */ 13763.L_ALT_OP_LONG_TO_FLOAT: /* 0x85 */ 13764/* File: x86/alt_stub.S */ 13765/* 13766 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13767 * any interesting requests and then jump to the real instruction 13768 * handler. Unlike the Arm handler, we can't do this as a tail call 13769 * because rIBASE is caller save and we need to reload it. 13770 */ 13771 movl rSELF, %eax 13772 movl rPC, OUT_ARG0(%esp) 13773 movl %eax, OUT_ARG1(%esp) 13774 call dvmCheckInst # (dPC, self) 13775 movl rSELF, %ecx 13776 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13777 jmp *dvmAsmInstructionStart+(133*4) 13778 13779/* ------------------------------ */ 13780.L_ALT_OP_LONG_TO_DOUBLE: /* 0x86 */ 13781/* File: x86/alt_stub.S */ 13782/* 13783 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13784 * any interesting requests and then jump to the real instruction 13785 * handler. Unlike the Arm handler, we can't do this as a tail call 13786 * because rIBASE is caller save and we need to reload it. 13787 */ 13788 movl rSELF, %eax 13789 movl rPC, OUT_ARG0(%esp) 13790 movl %eax, OUT_ARG1(%esp) 13791 call dvmCheckInst # (dPC, self) 13792 movl rSELF, %ecx 13793 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13794 jmp *dvmAsmInstructionStart+(134*4) 13795 13796/* ------------------------------ */ 13797.L_ALT_OP_FLOAT_TO_INT: /* 0x87 */ 13798/* File: x86/alt_stub.S */ 13799/* 13800 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13801 * any interesting requests and then jump to the real instruction 13802 * handler. Unlike the Arm handler, we can't do this as a tail call 13803 * because rIBASE is caller save and we need to reload it. 13804 */ 13805 movl rSELF, %eax 13806 movl rPC, OUT_ARG0(%esp) 13807 movl %eax, OUT_ARG1(%esp) 13808 call dvmCheckInst # (dPC, self) 13809 movl rSELF, %ecx 13810 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13811 jmp *dvmAsmInstructionStart+(135*4) 13812 13813/* ------------------------------ */ 13814.L_ALT_OP_FLOAT_TO_LONG: /* 0x88 */ 13815/* File: x86/alt_stub.S */ 13816/* 13817 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13818 * any interesting requests and then jump to the real instruction 13819 * handler. Unlike the Arm handler, we can't do this as a tail call 13820 * because rIBASE is caller save and we need to reload it. 13821 */ 13822 movl rSELF, %eax 13823 movl rPC, OUT_ARG0(%esp) 13824 movl %eax, OUT_ARG1(%esp) 13825 call dvmCheckInst # (dPC, self) 13826 movl rSELF, %ecx 13827 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13828 jmp *dvmAsmInstructionStart+(136*4) 13829 13830/* ------------------------------ */ 13831.L_ALT_OP_FLOAT_TO_DOUBLE: /* 0x89 */ 13832/* File: x86/alt_stub.S */ 13833/* 13834 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13835 * any interesting requests and then jump to the real instruction 13836 * handler. Unlike the Arm handler, we can't do this as a tail call 13837 * because rIBASE is caller save and we need to reload it. 13838 */ 13839 movl rSELF, %eax 13840 movl rPC, OUT_ARG0(%esp) 13841 movl %eax, OUT_ARG1(%esp) 13842 call dvmCheckInst # (dPC, self) 13843 movl rSELF, %ecx 13844 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13845 jmp *dvmAsmInstructionStart+(137*4) 13846 13847/* ------------------------------ */ 13848.L_ALT_OP_DOUBLE_TO_INT: /* 0x8a */ 13849/* File: x86/alt_stub.S */ 13850/* 13851 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13852 * any interesting requests and then jump to the real instruction 13853 * handler. Unlike the Arm handler, we can't do this as a tail call 13854 * because rIBASE is caller save and we need to reload it. 13855 */ 13856 movl rSELF, %eax 13857 movl rPC, OUT_ARG0(%esp) 13858 movl %eax, OUT_ARG1(%esp) 13859 call dvmCheckInst # (dPC, self) 13860 movl rSELF, %ecx 13861 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13862 jmp *dvmAsmInstructionStart+(138*4) 13863 13864/* ------------------------------ */ 13865.L_ALT_OP_DOUBLE_TO_LONG: /* 0x8b */ 13866/* File: x86/alt_stub.S */ 13867/* 13868 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13869 * any interesting requests and then jump to the real instruction 13870 * handler. Unlike the Arm handler, we can't do this as a tail call 13871 * because rIBASE is caller save and we need to reload it. 13872 */ 13873 movl rSELF, %eax 13874 movl rPC, OUT_ARG0(%esp) 13875 movl %eax, OUT_ARG1(%esp) 13876 call dvmCheckInst # (dPC, self) 13877 movl rSELF, %ecx 13878 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13879 jmp *dvmAsmInstructionStart+(139*4) 13880 13881/* ------------------------------ */ 13882.L_ALT_OP_DOUBLE_TO_FLOAT: /* 0x8c */ 13883/* File: x86/alt_stub.S */ 13884/* 13885 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13886 * any interesting requests and then jump to the real instruction 13887 * handler. Unlike the Arm handler, we can't do this as a tail call 13888 * because rIBASE is caller save and we need to reload it. 13889 */ 13890 movl rSELF, %eax 13891 movl rPC, OUT_ARG0(%esp) 13892 movl %eax, OUT_ARG1(%esp) 13893 call dvmCheckInst # (dPC, self) 13894 movl rSELF, %ecx 13895 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13896 jmp *dvmAsmInstructionStart+(140*4) 13897 13898/* ------------------------------ */ 13899.L_ALT_OP_INT_TO_BYTE: /* 0x8d */ 13900/* File: x86/alt_stub.S */ 13901/* 13902 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13903 * any interesting requests and then jump to the real instruction 13904 * handler. Unlike the Arm handler, we can't do this as a tail call 13905 * because rIBASE is caller save and we need to reload it. 13906 */ 13907 movl rSELF, %eax 13908 movl rPC, OUT_ARG0(%esp) 13909 movl %eax, OUT_ARG1(%esp) 13910 call dvmCheckInst # (dPC, self) 13911 movl rSELF, %ecx 13912 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13913 jmp *dvmAsmInstructionStart+(141*4) 13914 13915/* ------------------------------ */ 13916.L_ALT_OP_INT_TO_CHAR: /* 0x8e */ 13917/* File: x86/alt_stub.S */ 13918/* 13919 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13920 * any interesting requests and then jump to the real instruction 13921 * handler. Unlike the Arm handler, we can't do this as a tail call 13922 * because rIBASE is caller save and we need to reload it. 13923 */ 13924 movl rSELF, %eax 13925 movl rPC, OUT_ARG0(%esp) 13926 movl %eax, OUT_ARG1(%esp) 13927 call dvmCheckInst # (dPC, self) 13928 movl rSELF, %ecx 13929 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13930 jmp *dvmAsmInstructionStart+(142*4) 13931 13932/* ------------------------------ */ 13933.L_ALT_OP_INT_TO_SHORT: /* 0x8f */ 13934/* File: x86/alt_stub.S */ 13935/* 13936 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13937 * any interesting requests and then jump to the real instruction 13938 * handler. Unlike the Arm handler, we can't do this as a tail call 13939 * because rIBASE is caller save and we need to reload it. 13940 */ 13941 movl rSELF, %eax 13942 movl rPC, OUT_ARG0(%esp) 13943 movl %eax, OUT_ARG1(%esp) 13944 call dvmCheckInst # (dPC, self) 13945 movl rSELF, %ecx 13946 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13947 jmp *dvmAsmInstructionStart+(143*4) 13948 13949/* ------------------------------ */ 13950.L_ALT_OP_ADD_INT: /* 0x90 */ 13951/* File: x86/alt_stub.S */ 13952/* 13953 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13954 * any interesting requests and then jump to the real instruction 13955 * handler. Unlike the Arm handler, we can't do this as a tail call 13956 * because rIBASE is caller save and we need to reload it. 13957 */ 13958 movl rSELF, %eax 13959 movl rPC, OUT_ARG0(%esp) 13960 movl %eax, OUT_ARG1(%esp) 13961 call dvmCheckInst # (dPC, self) 13962 movl rSELF, %ecx 13963 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13964 jmp *dvmAsmInstructionStart+(144*4) 13965 13966/* ------------------------------ */ 13967.L_ALT_OP_SUB_INT: /* 0x91 */ 13968/* File: x86/alt_stub.S */ 13969/* 13970 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13971 * any interesting requests and then jump to the real instruction 13972 * handler. Unlike the Arm handler, we can't do this as a tail call 13973 * because rIBASE is caller save and we need to reload it. 13974 */ 13975 movl rSELF, %eax 13976 movl rPC, OUT_ARG0(%esp) 13977 movl %eax, OUT_ARG1(%esp) 13978 call dvmCheckInst # (dPC, self) 13979 movl rSELF, %ecx 13980 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13981 jmp *dvmAsmInstructionStart+(145*4) 13982 13983/* ------------------------------ */ 13984.L_ALT_OP_MUL_INT: /* 0x92 */ 13985/* File: x86/alt_stub.S */ 13986/* 13987 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13988 * any interesting requests and then jump to the real instruction 13989 * handler. Unlike the Arm handler, we can't do this as a tail call 13990 * because rIBASE is caller save and we need to reload it. 13991 */ 13992 movl rSELF, %eax 13993 movl rPC, OUT_ARG0(%esp) 13994 movl %eax, OUT_ARG1(%esp) 13995 call dvmCheckInst # (dPC, self) 13996 movl rSELF, %ecx 13997 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13998 jmp *dvmAsmInstructionStart+(146*4) 13999 14000/* ------------------------------ */ 14001.L_ALT_OP_DIV_INT: /* 0x93 */ 14002/* File: x86/alt_stub.S */ 14003/* 14004 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14005 * any interesting requests and then jump to the real instruction 14006 * handler. Unlike the Arm handler, we can't do this as a tail call 14007 * because rIBASE is caller save and we need to reload it. 14008 */ 14009 movl rSELF, %eax 14010 movl rPC, OUT_ARG0(%esp) 14011 movl %eax, OUT_ARG1(%esp) 14012 call dvmCheckInst # (dPC, self) 14013 movl rSELF, %ecx 14014 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14015 jmp *dvmAsmInstructionStart+(147*4) 14016 14017/* ------------------------------ */ 14018.L_ALT_OP_REM_INT: /* 0x94 */ 14019/* File: x86/alt_stub.S */ 14020/* 14021 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14022 * any interesting requests and then jump to the real instruction 14023 * handler. Unlike the Arm handler, we can't do this as a tail call 14024 * because rIBASE is caller save and we need to reload it. 14025 */ 14026 movl rSELF, %eax 14027 movl rPC, OUT_ARG0(%esp) 14028 movl %eax, OUT_ARG1(%esp) 14029 call dvmCheckInst # (dPC, self) 14030 movl rSELF, %ecx 14031 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14032 jmp *dvmAsmInstructionStart+(148*4) 14033 14034/* ------------------------------ */ 14035.L_ALT_OP_AND_INT: /* 0x95 */ 14036/* File: x86/alt_stub.S */ 14037/* 14038 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14039 * any interesting requests and then jump to the real instruction 14040 * handler. Unlike the Arm handler, we can't do this as a tail call 14041 * because rIBASE is caller save and we need to reload it. 14042 */ 14043 movl rSELF, %eax 14044 movl rPC, OUT_ARG0(%esp) 14045 movl %eax, OUT_ARG1(%esp) 14046 call dvmCheckInst # (dPC, self) 14047 movl rSELF, %ecx 14048 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14049 jmp *dvmAsmInstructionStart+(149*4) 14050 14051/* ------------------------------ */ 14052.L_ALT_OP_OR_INT: /* 0x96 */ 14053/* File: x86/alt_stub.S */ 14054/* 14055 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14056 * any interesting requests and then jump to the real instruction 14057 * handler. Unlike the Arm handler, we can't do this as a tail call 14058 * because rIBASE is caller save and we need to reload it. 14059 */ 14060 movl rSELF, %eax 14061 movl rPC, OUT_ARG0(%esp) 14062 movl %eax, OUT_ARG1(%esp) 14063 call dvmCheckInst # (dPC, self) 14064 movl rSELF, %ecx 14065 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14066 jmp *dvmAsmInstructionStart+(150*4) 14067 14068/* ------------------------------ */ 14069.L_ALT_OP_XOR_INT: /* 0x97 */ 14070/* File: x86/alt_stub.S */ 14071/* 14072 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14073 * any interesting requests and then jump to the real instruction 14074 * handler. Unlike the Arm handler, we can't do this as a tail call 14075 * because rIBASE is caller save and we need to reload it. 14076 */ 14077 movl rSELF, %eax 14078 movl rPC, OUT_ARG0(%esp) 14079 movl %eax, OUT_ARG1(%esp) 14080 call dvmCheckInst # (dPC, self) 14081 movl rSELF, %ecx 14082 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14083 jmp *dvmAsmInstructionStart+(151*4) 14084 14085/* ------------------------------ */ 14086.L_ALT_OP_SHL_INT: /* 0x98 */ 14087/* File: x86/alt_stub.S */ 14088/* 14089 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14090 * any interesting requests and then jump to the real instruction 14091 * handler. Unlike the Arm handler, we can't do this as a tail call 14092 * because rIBASE is caller save and we need to reload it. 14093 */ 14094 movl rSELF, %eax 14095 movl rPC, OUT_ARG0(%esp) 14096 movl %eax, OUT_ARG1(%esp) 14097 call dvmCheckInst # (dPC, self) 14098 movl rSELF, %ecx 14099 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14100 jmp *dvmAsmInstructionStart+(152*4) 14101 14102/* ------------------------------ */ 14103.L_ALT_OP_SHR_INT: /* 0x99 */ 14104/* File: x86/alt_stub.S */ 14105/* 14106 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14107 * any interesting requests and then jump to the real instruction 14108 * handler. Unlike the Arm handler, we can't do this as a tail call 14109 * because rIBASE is caller save and we need to reload it. 14110 */ 14111 movl rSELF, %eax 14112 movl rPC, OUT_ARG0(%esp) 14113 movl %eax, OUT_ARG1(%esp) 14114 call dvmCheckInst # (dPC, self) 14115 movl rSELF, %ecx 14116 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14117 jmp *dvmAsmInstructionStart+(153*4) 14118 14119/* ------------------------------ */ 14120.L_ALT_OP_USHR_INT: /* 0x9a */ 14121/* File: x86/alt_stub.S */ 14122/* 14123 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14124 * any interesting requests and then jump to the real instruction 14125 * handler. Unlike the Arm handler, we can't do this as a tail call 14126 * because rIBASE is caller save and we need to reload it. 14127 */ 14128 movl rSELF, %eax 14129 movl rPC, OUT_ARG0(%esp) 14130 movl %eax, OUT_ARG1(%esp) 14131 call dvmCheckInst # (dPC, self) 14132 movl rSELF, %ecx 14133 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14134 jmp *dvmAsmInstructionStart+(154*4) 14135 14136/* ------------------------------ */ 14137.L_ALT_OP_ADD_LONG: /* 0x9b */ 14138/* File: x86/alt_stub.S */ 14139/* 14140 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14141 * any interesting requests and then jump to the real instruction 14142 * handler. Unlike the Arm handler, we can't do this as a tail call 14143 * because rIBASE is caller save and we need to reload it. 14144 */ 14145 movl rSELF, %eax 14146 movl rPC, OUT_ARG0(%esp) 14147 movl %eax, OUT_ARG1(%esp) 14148 call dvmCheckInst # (dPC, self) 14149 movl rSELF, %ecx 14150 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14151 jmp *dvmAsmInstructionStart+(155*4) 14152 14153/* ------------------------------ */ 14154.L_ALT_OP_SUB_LONG: /* 0x9c */ 14155/* File: x86/alt_stub.S */ 14156/* 14157 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14158 * any interesting requests and then jump to the real instruction 14159 * handler. Unlike the Arm handler, we can't do this as a tail call 14160 * because rIBASE is caller save and we need to reload it. 14161 */ 14162 movl rSELF, %eax 14163 movl rPC, OUT_ARG0(%esp) 14164 movl %eax, OUT_ARG1(%esp) 14165 call dvmCheckInst # (dPC, self) 14166 movl rSELF, %ecx 14167 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14168 jmp *dvmAsmInstructionStart+(156*4) 14169 14170/* ------------------------------ */ 14171.L_ALT_OP_MUL_LONG: /* 0x9d */ 14172/* File: x86/alt_stub.S */ 14173/* 14174 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14175 * any interesting requests and then jump to the real instruction 14176 * handler. Unlike the Arm handler, we can't do this as a tail call 14177 * because rIBASE is caller save and we need to reload it. 14178 */ 14179 movl rSELF, %eax 14180 movl rPC, OUT_ARG0(%esp) 14181 movl %eax, OUT_ARG1(%esp) 14182 call dvmCheckInst # (dPC, self) 14183 movl rSELF, %ecx 14184 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14185 jmp *dvmAsmInstructionStart+(157*4) 14186 14187/* ------------------------------ */ 14188.L_ALT_OP_DIV_LONG: /* 0x9e */ 14189/* File: x86/alt_stub.S */ 14190/* 14191 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14192 * any interesting requests and then jump to the real instruction 14193 * handler. Unlike the Arm handler, we can't do this as a tail call 14194 * because rIBASE is caller save and we need to reload it. 14195 */ 14196 movl rSELF, %eax 14197 movl rPC, OUT_ARG0(%esp) 14198 movl %eax, OUT_ARG1(%esp) 14199 call dvmCheckInst # (dPC, self) 14200 movl rSELF, %ecx 14201 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14202 jmp *dvmAsmInstructionStart+(158*4) 14203 14204/* ------------------------------ */ 14205.L_ALT_OP_REM_LONG: /* 0x9f */ 14206/* File: x86/alt_stub.S */ 14207/* 14208 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14209 * any interesting requests and then jump to the real instruction 14210 * handler. Unlike the Arm handler, we can't do this as a tail call 14211 * because rIBASE is caller save and we need to reload it. 14212 */ 14213 movl rSELF, %eax 14214 movl rPC, OUT_ARG0(%esp) 14215 movl %eax, OUT_ARG1(%esp) 14216 call dvmCheckInst # (dPC, self) 14217 movl rSELF, %ecx 14218 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14219 jmp *dvmAsmInstructionStart+(159*4) 14220 14221/* ------------------------------ */ 14222.L_ALT_OP_AND_LONG: /* 0xa0 */ 14223/* File: x86/alt_stub.S */ 14224/* 14225 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14226 * any interesting requests and then jump to the real instruction 14227 * handler. Unlike the Arm handler, we can't do this as a tail call 14228 * because rIBASE is caller save and we need to reload it. 14229 */ 14230 movl rSELF, %eax 14231 movl rPC, OUT_ARG0(%esp) 14232 movl %eax, OUT_ARG1(%esp) 14233 call dvmCheckInst # (dPC, self) 14234 movl rSELF, %ecx 14235 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14236 jmp *dvmAsmInstructionStart+(160*4) 14237 14238/* ------------------------------ */ 14239.L_ALT_OP_OR_LONG: /* 0xa1 */ 14240/* File: x86/alt_stub.S */ 14241/* 14242 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14243 * any interesting requests and then jump to the real instruction 14244 * handler. Unlike the Arm handler, we can't do this as a tail call 14245 * because rIBASE is caller save and we need to reload it. 14246 */ 14247 movl rSELF, %eax 14248 movl rPC, OUT_ARG0(%esp) 14249 movl %eax, OUT_ARG1(%esp) 14250 call dvmCheckInst # (dPC, self) 14251 movl rSELF, %ecx 14252 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14253 jmp *dvmAsmInstructionStart+(161*4) 14254 14255/* ------------------------------ */ 14256.L_ALT_OP_XOR_LONG: /* 0xa2 */ 14257/* File: x86/alt_stub.S */ 14258/* 14259 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14260 * any interesting requests and then jump to the real instruction 14261 * handler. Unlike the Arm handler, we can't do this as a tail call 14262 * because rIBASE is caller save and we need to reload it. 14263 */ 14264 movl rSELF, %eax 14265 movl rPC, OUT_ARG0(%esp) 14266 movl %eax, OUT_ARG1(%esp) 14267 call dvmCheckInst # (dPC, self) 14268 movl rSELF, %ecx 14269 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14270 jmp *dvmAsmInstructionStart+(162*4) 14271 14272/* ------------------------------ */ 14273.L_ALT_OP_SHL_LONG: /* 0xa3 */ 14274/* File: x86/alt_stub.S */ 14275/* 14276 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14277 * any interesting requests and then jump to the real instruction 14278 * handler. Unlike the Arm handler, we can't do this as a tail call 14279 * because rIBASE is caller save and we need to reload it. 14280 */ 14281 movl rSELF, %eax 14282 movl rPC, OUT_ARG0(%esp) 14283 movl %eax, OUT_ARG1(%esp) 14284 call dvmCheckInst # (dPC, self) 14285 movl rSELF, %ecx 14286 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14287 jmp *dvmAsmInstructionStart+(163*4) 14288 14289/* ------------------------------ */ 14290.L_ALT_OP_SHR_LONG: /* 0xa4 */ 14291/* File: x86/alt_stub.S */ 14292/* 14293 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14294 * any interesting requests and then jump to the real instruction 14295 * handler. Unlike the Arm handler, we can't do this as a tail call 14296 * because rIBASE is caller save and we need to reload it. 14297 */ 14298 movl rSELF, %eax 14299 movl rPC, OUT_ARG0(%esp) 14300 movl %eax, OUT_ARG1(%esp) 14301 call dvmCheckInst # (dPC, self) 14302 movl rSELF, %ecx 14303 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14304 jmp *dvmAsmInstructionStart+(164*4) 14305 14306/* ------------------------------ */ 14307.L_ALT_OP_USHR_LONG: /* 0xa5 */ 14308/* File: x86/alt_stub.S */ 14309/* 14310 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14311 * any interesting requests and then jump to the real instruction 14312 * handler. Unlike the Arm handler, we can't do this as a tail call 14313 * because rIBASE is caller save and we need to reload it. 14314 */ 14315 movl rSELF, %eax 14316 movl rPC, OUT_ARG0(%esp) 14317 movl %eax, OUT_ARG1(%esp) 14318 call dvmCheckInst # (dPC, self) 14319 movl rSELF, %ecx 14320 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14321 jmp *dvmAsmInstructionStart+(165*4) 14322 14323/* ------------------------------ */ 14324.L_ALT_OP_ADD_FLOAT: /* 0xa6 */ 14325/* File: x86/alt_stub.S */ 14326/* 14327 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14328 * any interesting requests and then jump to the real instruction 14329 * handler. Unlike the Arm handler, we can't do this as a tail call 14330 * because rIBASE is caller save and we need to reload it. 14331 */ 14332 movl rSELF, %eax 14333 movl rPC, OUT_ARG0(%esp) 14334 movl %eax, OUT_ARG1(%esp) 14335 call dvmCheckInst # (dPC, self) 14336 movl rSELF, %ecx 14337 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14338 jmp *dvmAsmInstructionStart+(166*4) 14339 14340/* ------------------------------ */ 14341.L_ALT_OP_SUB_FLOAT: /* 0xa7 */ 14342/* File: x86/alt_stub.S */ 14343/* 14344 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14345 * any interesting requests and then jump to the real instruction 14346 * handler. Unlike the Arm handler, we can't do this as a tail call 14347 * because rIBASE is caller save and we need to reload it. 14348 */ 14349 movl rSELF, %eax 14350 movl rPC, OUT_ARG0(%esp) 14351 movl %eax, OUT_ARG1(%esp) 14352 call dvmCheckInst # (dPC, self) 14353 movl rSELF, %ecx 14354 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14355 jmp *dvmAsmInstructionStart+(167*4) 14356 14357/* ------------------------------ */ 14358.L_ALT_OP_MUL_FLOAT: /* 0xa8 */ 14359/* File: x86/alt_stub.S */ 14360/* 14361 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14362 * any interesting requests and then jump to the real instruction 14363 * handler. Unlike the Arm handler, we can't do this as a tail call 14364 * because rIBASE is caller save and we need to reload it. 14365 */ 14366 movl rSELF, %eax 14367 movl rPC, OUT_ARG0(%esp) 14368 movl %eax, OUT_ARG1(%esp) 14369 call dvmCheckInst # (dPC, self) 14370 movl rSELF, %ecx 14371 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14372 jmp *dvmAsmInstructionStart+(168*4) 14373 14374/* ------------------------------ */ 14375.L_ALT_OP_DIV_FLOAT: /* 0xa9 */ 14376/* File: x86/alt_stub.S */ 14377/* 14378 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14379 * any interesting requests and then jump to the real instruction 14380 * handler. Unlike the Arm handler, we can't do this as a tail call 14381 * because rIBASE is caller save and we need to reload it. 14382 */ 14383 movl rSELF, %eax 14384 movl rPC, OUT_ARG0(%esp) 14385 movl %eax, OUT_ARG1(%esp) 14386 call dvmCheckInst # (dPC, self) 14387 movl rSELF, %ecx 14388 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14389 jmp *dvmAsmInstructionStart+(169*4) 14390 14391/* ------------------------------ */ 14392.L_ALT_OP_REM_FLOAT: /* 0xaa */ 14393/* File: x86/alt_stub.S */ 14394/* 14395 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14396 * any interesting requests and then jump to the real instruction 14397 * handler. Unlike the Arm handler, we can't do this as a tail call 14398 * because rIBASE is caller save and we need to reload it. 14399 */ 14400 movl rSELF, %eax 14401 movl rPC, OUT_ARG0(%esp) 14402 movl %eax, OUT_ARG1(%esp) 14403 call dvmCheckInst # (dPC, self) 14404 movl rSELF, %ecx 14405 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14406 jmp *dvmAsmInstructionStart+(170*4) 14407 14408/* ------------------------------ */ 14409.L_ALT_OP_ADD_DOUBLE: /* 0xab */ 14410/* File: x86/alt_stub.S */ 14411/* 14412 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14413 * any interesting requests and then jump to the real instruction 14414 * handler. Unlike the Arm handler, we can't do this as a tail call 14415 * because rIBASE is caller save and we need to reload it. 14416 */ 14417 movl rSELF, %eax 14418 movl rPC, OUT_ARG0(%esp) 14419 movl %eax, OUT_ARG1(%esp) 14420 call dvmCheckInst # (dPC, self) 14421 movl rSELF, %ecx 14422 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14423 jmp *dvmAsmInstructionStart+(171*4) 14424 14425/* ------------------------------ */ 14426.L_ALT_OP_SUB_DOUBLE: /* 0xac */ 14427/* File: x86/alt_stub.S */ 14428/* 14429 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14430 * any interesting requests and then jump to the real instruction 14431 * handler. Unlike the Arm handler, we can't do this as a tail call 14432 * because rIBASE is caller save and we need to reload it. 14433 */ 14434 movl rSELF, %eax 14435 movl rPC, OUT_ARG0(%esp) 14436 movl %eax, OUT_ARG1(%esp) 14437 call dvmCheckInst # (dPC, self) 14438 movl rSELF, %ecx 14439 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14440 jmp *dvmAsmInstructionStart+(172*4) 14441 14442/* ------------------------------ */ 14443.L_ALT_OP_MUL_DOUBLE: /* 0xad */ 14444/* File: x86/alt_stub.S */ 14445/* 14446 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14447 * any interesting requests and then jump to the real instruction 14448 * handler. Unlike the Arm handler, we can't do this as a tail call 14449 * because rIBASE is caller save and we need to reload it. 14450 */ 14451 movl rSELF, %eax 14452 movl rPC, OUT_ARG0(%esp) 14453 movl %eax, OUT_ARG1(%esp) 14454 call dvmCheckInst # (dPC, self) 14455 movl rSELF, %ecx 14456 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14457 jmp *dvmAsmInstructionStart+(173*4) 14458 14459/* ------------------------------ */ 14460.L_ALT_OP_DIV_DOUBLE: /* 0xae */ 14461/* File: x86/alt_stub.S */ 14462/* 14463 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14464 * any interesting requests and then jump to the real instruction 14465 * handler. Unlike the Arm handler, we can't do this as a tail call 14466 * because rIBASE is caller save and we need to reload it. 14467 */ 14468 movl rSELF, %eax 14469 movl rPC, OUT_ARG0(%esp) 14470 movl %eax, OUT_ARG1(%esp) 14471 call dvmCheckInst # (dPC, self) 14472 movl rSELF, %ecx 14473 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14474 jmp *dvmAsmInstructionStart+(174*4) 14475 14476/* ------------------------------ */ 14477.L_ALT_OP_REM_DOUBLE: /* 0xaf */ 14478/* File: x86/alt_stub.S */ 14479/* 14480 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14481 * any interesting requests and then jump to the real instruction 14482 * handler. Unlike the Arm handler, we can't do this as a tail call 14483 * because rIBASE is caller save and we need to reload it. 14484 */ 14485 movl rSELF, %eax 14486 movl rPC, OUT_ARG0(%esp) 14487 movl %eax, OUT_ARG1(%esp) 14488 call dvmCheckInst # (dPC, self) 14489 movl rSELF, %ecx 14490 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14491 jmp *dvmAsmInstructionStart+(175*4) 14492 14493/* ------------------------------ */ 14494.L_ALT_OP_ADD_INT_2ADDR: /* 0xb0 */ 14495/* File: x86/alt_stub.S */ 14496/* 14497 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14498 * any interesting requests and then jump to the real instruction 14499 * handler. Unlike the Arm handler, we can't do this as a tail call 14500 * because rIBASE is caller save and we need to reload it. 14501 */ 14502 movl rSELF, %eax 14503 movl rPC, OUT_ARG0(%esp) 14504 movl %eax, OUT_ARG1(%esp) 14505 call dvmCheckInst # (dPC, self) 14506 movl rSELF, %ecx 14507 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14508 jmp *dvmAsmInstructionStart+(176*4) 14509 14510/* ------------------------------ */ 14511.L_ALT_OP_SUB_INT_2ADDR: /* 0xb1 */ 14512/* File: x86/alt_stub.S */ 14513/* 14514 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14515 * any interesting requests and then jump to the real instruction 14516 * handler. Unlike the Arm handler, we can't do this as a tail call 14517 * because rIBASE is caller save and we need to reload it. 14518 */ 14519 movl rSELF, %eax 14520 movl rPC, OUT_ARG0(%esp) 14521 movl %eax, OUT_ARG1(%esp) 14522 call dvmCheckInst # (dPC, self) 14523 movl rSELF, %ecx 14524 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14525 jmp *dvmAsmInstructionStart+(177*4) 14526 14527/* ------------------------------ */ 14528.L_ALT_OP_MUL_INT_2ADDR: /* 0xb2 */ 14529/* File: x86/alt_stub.S */ 14530/* 14531 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14532 * any interesting requests and then jump to the real instruction 14533 * handler. Unlike the Arm handler, we can't do this as a tail call 14534 * because rIBASE is caller save and we need to reload it. 14535 */ 14536 movl rSELF, %eax 14537 movl rPC, OUT_ARG0(%esp) 14538 movl %eax, OUT_ARG1(%esp) 14539 call dvmCheckInst # (dPC, self) 14540 movl rSELF, %ecx 14541 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14542 jmp *dvmAsmInstructionStart+(178*4) 14543 14544/* ------------------------------ */ 14545.L_ALT_OP_DIV_INT_2ADDR: /* 0xb3 */ 14546/* File: x86/alt_stub.S */ 14547/* 14548 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14549 * any interesting requests and then jump to the real instruction 14550 * handler. Unlike the Arm handler, we can't do this as a tail call 14551 * because rIBASE is caller save and we need to reload it. 14552 */ 14553 movl rSELF, %eax 14554 movl rPC, OUT_ARG0(%esp) 14555 movl %eax, OUT_ARG1(%esp) 14556 call dvmCheckInst # (dPC, self) 14557 movl rSELF, %ecx 14558 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14559 jmp *dvmAsmInstructionStart+(179*4) 14560 14561/* ------------------------------ */ 14562.L_ALT_OP_REM_INT_2ADDR: /* 0xb4 */ 14563/* File: x86/alt_stub.S */ 14564/* 14565 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14566 * any interesting requests and then jump to the real instruction 14567 * handler. Unlike the Arm handler, we can't do this as a tail call 14568 * because rIBASE is caller save and we need to reload it. 14569 */ 14570 movl rSELF, %eax 14571 movl rPC, OUT_ARG0(%esp) 14572 movl %eax, OUT_ARG1(%esp) 14573 call dvmCheckInst # (dPC, self) 14574 movl rSELF, %ecx 14575 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14576 jmp *dvmAsmInstructionStart+(180*4) 14577 14578/* ------------------------------ */ 14579.L_ALT_OP_AND_INT_2ADDR: /* 0xb5 */ 14580/* File: x86/alt_stub.S */ 14581/* 14582 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14583 * any interesting requests and then jump to the real instruction 14584 * handler. Unlike the Arm handler, we can't do this as a tail call 14585 * because rIBASE is caller save and we need to reload it. 14586 */ 14587 movl rSELF, %eax 14588 movl rPC, OUT_ARG0(%esp) 14589 movl %eax, OUT_ARG1(%esp) 14590 call dvmCheckInst # (dPC, self) 14591 movl rSELF, %ecx 14592 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14593 jmp *dvmAsmInstructionStart+(181*4) 14594 14595/* ------------------------------ */ 14596.L_ALT_OP_OR_INT_2ADDR: /* 0xb6 */ 14597/* File: x86/alt_stub.S */ 14598/* 14599 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14600 * any interesting requests and then jump to the real instruction 14601 * handler. Unlike the Arm handler, we can't do this as a tail call 14602 * because rIBASE is caller save and we need to reload it. 14603 */ 14604 movl rSELF, %eax 14605 movl rPC, OUT_ARG0(%esp) 14606 movl %eax, OUT_ARG1(%esp) 14607 call dvmCheckInst # (dPC, self) 14608 movl rSELF, %ecx 14609 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14610 jmp *dvmAsmInstructionStart+(182*4) 14611 14612/* ------------------------------ */ 14613.L_ALT_OP_XOR_INT_2ADDR: /* 0xb7 */ 14614/* File: x86/alt_stub.S */ 14615/* 14616 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14617 * any interesting requests and then jump to the real instruction 14618 * handler. Unlike the Arm handler, we can't do this as a tail call 14619 * because rIBASE is caller save and we need to reload it. 14620 */ 14621 movl rSELF, %eax 14622 movl rPC, OUT_ARG0(%esp) 14623 movl %eax, OUT_ARG1(%esp) 14624 call dvmCheckInst # (dPC, self) 14625 movl rSELF, %ecx 14626 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14627 jmp *dvmAsmInstructionStart+(183*4) 14628 14629/* ------------------------------ */ 14630.L_ALT_OP_SHL_INT_2ADDR: /* 0xb8 */ 14631/* File: x86/alt_stub.S */ 14632/* 14633 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14634 * any interesting requests and then jump to the real instruction 14635 * handler. Unlike the Arm handler, we can't do this as a tail call 14636 * because rIBASE is caller save and we need to reload it. 14637 */ 14638 movl rSELF, %eax 14639 movl rPC, OUT_ARG0(%esp) 14640 movl %eax, OUT_ARG1(%esp) 14641 call dvmCheckInst # (dPC, self) 14642 movl rSELF, %ecx 14643 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14644 jmp *dvmAsmInstructionStart+(184*4) 14645 14646/* ------------------------------ */ 14647.L_ALT_OP_SHR_INT_2ADDR: /* 0xb9 */ 14648/* File: x86/alt_stub.S */ 14649/* 14650 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14651 * any interesting requests and then jump to the real instruction 14652 * handler. Unlike the Arm handler, we can't do this as a tail call 14653 * because rIBASE is caller save and we need to reload it. 14654 */ 14655 movl rSELF, %eax 14656 movl rPC, OUT_ARG0(%esp) 14657 movl %eax, OUT_ARG1(%esp) 14658 call dvmCheckInst # (dPC, self) 14659 movl rSELF, %ecx 14660 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14661 jmp *dvmAsmInstructionStart+(185*4) 14662 14663/* ------------------------------ */ 14664.L_ALT_OP_USHR_INT_2ADDR: /* 0xba */ 14665/* File: x86/alt_stub.S */ 14666/* 14667 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14668 * any interesting requests and then jump to the real instruction 14669 * handler. Unlike the Arm handler, we can't do this as a tail call 14670 * because rIBASE is caller save and we need to reload it. 14671 */ 14672 movl rSELF, %eax 14673 movl rPC, OUT_ARG0(%esp) 14674 movl %eax, OUT_ARG1(%esp) 14675 call dvmCheckInst # (dPC, self) 14676 movl rSELF, %ecx 14677 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14678 jmp *dvmAsmInstructionStart+(186*4) 14679 14680/* ------------------------------ */ 14681.L_ALT_OP_ADD_LONG_2ADDR: /* 0xbb */ 14682/* File: x86/alt_stub.S */ 14683/* 14684 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14685 * any interesting requests and then jump to the real instruction 14686 * handler. Unlike the Arm handler, we can't do this as a tail call 14687 * because rIBASE is caller save and we need to reload it. 14688 */ 14689 movl rSELF, %eax 14690 movl rPC, OUT_ARG0(%esp) 14691 movl %eax, OUT_ARG1(%esp) 14692 call dvmCheckInst # (dPC, self) 14693 movl rSELF, %ecx 14694 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14695 jmp *dvmAsmInstructionStart+(187*4) 14696 14697/* ------------------------------ */ 14698.L_ALT_OP_SUB_LONG_2ADDR: /* 0xbc */ 14699/* File: x86/alt_stub.S */ 14700/* 14701 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14702 * any interesting requests and then jump to the real instruction 14703 * handler. Unlike the Arm handler, we can't do this as a tail call 14704 * because rIBASE is caller save and we need to reload it. 14705 */ 14706 movl rSELF, %eax 14707 movl rPC, OUT_ARG0(%esp) 14708 movl %eax, OUT_ARG1(%esp) 14709 call dvmCheckInst # (dPC, self) 14710 movl rSELF, %ecx 14711 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14712 jmp *dvmAsmInstructionStart+(188*4) 14713 14714/* ------------------------------ */ 14715.L_ALT_OP_MUL_LONG_2ADDR: /* 0xbd */ 14716/* File: x86/alt_stub.S */ 14717/* 14718 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14719 * any interesting requests and then jump to the real instruction 14720 * handler. Unlike the Arm handler, we can't do this as a tail call 14721 * because rIBASE is caller save and we need to reload it. 14722 */ 14723 movl rSELF, %eax 14724 movl rPC, OUT_ARG0(%esp) 14725 movl %eax, OUT_ARG1(%esp) 14726 call dvmCheckInst # (dPC, self) 14727 movl rSELF, %ecx 14728 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14729 jmp *dvmAsmInstructionStart+(189*4) 14730 14731/* ------------------------------ */ 14732.L_ALT_OP_DIV_LONG_2ADDR: /* 0xbe */ 14733/* File: x86/alt_stub.S */ 14734/* 14735 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14736 * any interesting requests and then jump to the real instruction 14737 * handler. Unlike the Arm handler, we can't do this as a tail call 14738 * because rIBASE is caller save and we need to reload it. 14739 */ 14740 movl rSELF, %eax 14741 movl rPC, OUT_ARG0(%esp) 14742 movl %eax, OUT_ARG1(%esp) 14743 call dvmCheckInst # (dPC, self) 14744 movl rSELF, %ecx 14745 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14746 jmp *dvmAsmInstructionStart+(190*4) 14747 14748/* ------------------------------ */ 14749.L_ALT_OP_REM_LONG_2ADDR: /* 0xbf */ 14750/* File: x86/alt_stub.S */ 14751/* 14752 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14753 * any interesting requests and then jump to the real instruction 14754 * handler. Unlike the Arm handler, we can't do this as a tail call 14755 * because rIBASE is caller save and we need to reload it. 14756 */ 14757 movl rSELF, %eax 14758 movl rPC, OUT_ARG0(%esp) 14759 movl %eax, OUT_ARG1(%esp) 14760 call dvmCheckInst # (dPC, self) 14761 movl rSELF, %ecx 14762 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14763 jmp *dvmAsmInstructionStart+(191*4) 14764 14765/* ------------------------------ */ 14766.L_ALT_OP_AND_LONG_2ADDR: /* 0xc0 */ 14767/* File: x86/alt_stub.S */ 14768/* 14769 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14770 * any interesting requests and then jump to the real instruction 14771 * handler. Unlike the Arm handler, we can't do this as a tail call 14772 * because rIBASE is caller save and we need to reload it. 14773 */ 14774 movl rSELF, %eax 14775 movl rPC, OUT_ARG0(%esp) 14776 movl %eax, OUT_ARG1(%esp) 14777 call dvmCheckInst # (dPC, self) 14778 movl rSELF, %ecx 14779 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14780 jmp *dvmAsmInstructionStart+(192*4) 14781 14782/* ------------------------------ */ 14783.L_ALT_OP_OR_LONG_2ADDR: /* 0xc1 */ 14784/* File: x86/alt_stub.S */ 14785/* 14786 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14787 * any interesting requests and then jump to the real instruction 14788 * handler. Unlike the Arm handler, we can't do this as a tail call 14789 * because rIBASE is caller save and we need to reload it. 14790 */ 14791 movl rSELF, %eax 14792 movl rPC, OUT_ARG0(%esp) 14793 movl %eax, OUT_ARG1(%esp) 14794 call dvmCheckInst # (dPC, self) 14795 movl rSELF, %ecx 14796 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14797 jmp *dvmAsmInstructionStart+(193*4) 14798 14799/* ------------------------------ */ 14800.L_ALT_OP_XOR_LONG_2ADDR: /* 0xc2 */ 14801/* File: x86/alt_stub.S */ 14802/* 14803 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14804 * any interesting requests and then jump to the real instruction 14805 * handler. Unlike the Arm handler, we can't do this as a tail call 14806 * because rIBASE is caller save and we need to reload it. 14807 */ 14808 movl rSELF, %eax 14809 movl rPC, OUT_ARG0(%esp) 14810 movl %eax, OUT_ARG1(%esp) 14811 call dvmCheckInst # (dPC, self) 14812 movl rSELF, %ecx 14813 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14814 jmp *dvmAsmInstructionStart+(194*4) 14815 14816/* ------------------------------ */ 14817.L_ALT_OP_SHL_LONG_2ADDR: /* 0xc3 */ 14818/* File: x86/alt_stub.S */ 14819/* 14820 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14821 * any interesting requests and then jump to the real instruction 14822 * handler. Unlike the Arm handler, we can't do this as a tail call 14823 * because rIBASE is caller save and we need to reload it. 14824 */ 14825 movl rSELF, %eax 14826 movl rPC, OUT_ARG0(%esp) 14827 movl %eax, OUT_ARG1(%esp) 14828 call dvmCheckInst # (dPC, self) 14829 movl rSELF, %ecx 14830 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14831 jmp *dvmAsmInstructionStart+(195*4) 14832 14833/* ------------------------------ */ 14834.L_ALT_OP_SHR_LONG_2ADDR: /* 0xc4 */ 14835/* File: x86/alt_stub.S */ 14836/* 14837 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14838 * any interesting requests and then jump to the real instruction 14839 * handler. Unlike the Arm handler, we can't do this as a tail call 14840 * because rIBASE is caller save and we need to reload it. 14841 */ 14842 movl rSELF, %eax 14843 movl rPC, OUT_ARG0(%esp) 14844 movl %eax, OUT_ARG1(%esp) 14845 call dvmCheckInst # (dPC, self) 14846 movl rSELF, %ecx 14847 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14848 jmp *dvmAsmInstructionStart+(196*4) 14849 14850/* ------------------------------ */ 14851.L_ALT_OP_USHR_LONG_2ADDR: /* 0xc5 */ 14852/* File: x86/alt_stub.S */ 14853/* 14854 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14855 * any interesting requests and then jump to the real instruction 14856 * handler. Unlike the Arm handler, we can't do this as a tail call 14857 * because rIBASE is caller save and we need to reload it. 14858 */ 14859 movl rSELF, %eax 14860 movl rPC, OUT_ARG0(%esp) 14861 movl %eax, OUT_ARG1(%esp) 14862 call dvmCheckInst # (dPC, self) 14863 movl rSELF, %ecx 14864 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14865 jmp *dvmAsmInstructionStart+(197*4) 14866 14867/* ------------------------------ */ 14868.L_ALT_OP_ADD_FLOAT_2ADDR: /* 0xc6 */ 14869/* File: x86/alt_stub.S */ 14870/* 14871 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14872 * any interesting requests and then jump to the real instruction 14873 * handler. Unlike the Arm handler, we can't do this as a tail call 14874 * because rIBASE is caller save and we need to reload it. 14875 */ 14876 movl rSELF, %eax 14877 movl rPC, OUT_ARG0(%esp) 14878 movl %eax, OUT_ARG1(%esp) 14879 call dvmCheckInst # (dPC, self) 14880 movl rSELF, %ecx 14881 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14882 jmp *dvmAsmInstructionStart+(198*4) 14883 14884/* ------------------------------ */ 14885.L_ALT_OP_SUB_FLOAT_2ADDR: /* 0xc7 */ 14886/* File: x86/alt_stub.S */ 14887/* 14888 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14889 * any interesting requests and then jump to the real instruction 14890 * handler. Unlike the Arm handler, we can't do this as a tail call 14891 * because rIBASE is caller save and we need to reload it. 14892 */ 14893 movl rSELF, %eax 14894 movl rPC, OUT_ARG0(%esp) 14895 movl %eax, OUT_ARG1(%esp) 14896 call dvmCheckInst # (dPC, self) 14897 movl rSELF, %ecx 14898 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14899 jmp *dvmAsmInstructionStart+(199*4) 14900 14901/* ------------------------------ */ 14902.L_ALT_OP_MUL_FLOAT_2ADDR: /* 0xc8 */ 14903/* File: x86/alt_stub.S */ 14904/* 14905 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14906 * any interesting requests and then jump to the real instruction 14907 * handler. Unlike the Arm handler, we can't do this as a tail call 14908 * because rIBASE is caller save and we need to reload it. 14909 */ 14910 movl rSELF, %eax 14911 movl rPC, OUT_ARG0(%esp) 14912 movl %eax, OUT_ARG1(%esp) 14913 call dvmCheckInst # (dPC, self) 14914 movl rSELF, %ecx 14915 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14916 jmp *dvmAsmInstructionStart+(200*4) 14917 14918/* ------------------------------ */ 14919.L_ALT_OP_DIV_FLOAT_2ADDR: /* 0xc9 */ 14920/* File: x86/alt_stub.S */ 14921/* 14922 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14923 * any interesting requests and then jump to the real instruction 14924 * handler. Unlike the Arm handler, we can't do this as a tail call 14925 * because rIBASE is caller save and we need to reload it. 14926 */ 14927 movl rSELF, %eax 14928 movl rPC, OUT_ARG0(%esp) 14929 movl %eax, OUT_ARG1(%esp) 14930 call dvmCheckInst # (dPC, self) 14931 movl rSELF, %ecx 14932 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14933 jmp *dvmAsmInstructionStart+(201*4) 14934 14935/* ------------------------------ */ 14936.L_ALT_OP_REM_FLOAT_2ADDR: /* 0xca */ 14937/* File: x86/alt_stub.S */ 14938/* 14939 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14940 * any interesting requests and then jump to the real instruction 14941 * handler. Unlike the Arm handler, we can't do this as a tail call 14942 * because rIBASE is caller save and we need to reload it. 14943 */ 14944 movl rSELF, %eax 14945 movl rPC, OUT_ARG0(%esp) 14946 movl %eax, OUT_ARG1(%esp) 14947 call dvmCheckInst # (dPC, self) 14948 movl rSELF, %ecx 14949 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14950 jmp *dvmAsmInstructionStart+(202*4) 14951 14952/* ------------------------------ */ 14953.L_ALT_OP_ADD_DOUBLE_2ADDR: /* 0xcb */ 14954/* File: x86/alt_stub.S */ 14955/* 14956 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14957 * any interesting requests and then jump to the real instruction 14958 * handler. Unlike the Arm handler, we can't do this as a tail call 14959 * because rIBASE is caller save and we need to reload it. 14960 */ 14961 movl rSELF, %eax 14962 movl rPC, OUT_ARG0(%esp) 14963 movl %eax, OUT_ARG1(%esp) 14964 call dvmCheckInst # (dPC, self) 14965 movl rSELF, %ecx 14966 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14967 jmp *dvmAsmInstructionStart+(203*4) 14968 14969/* ------------------------------ */ 14970.L_ALT_OP_SUB_DOUBLE_2ADDR: /* 0xcc */ 14971/* File: x86/alt_stub.S */ 14972/* 14973 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14974 * any interesting requests and then jump to the real instruction 14975 * handler. Unlike the Arm handler, we can't do this as a tail call 14976 * because rIBASE is caller save and we need to reload it. 14977 */ 14978 movl rSELF, %eax 14979 movl rPC, OUT_ARG0(%esp) 14980 movl %eax, OUT_ARG1(%esp) 14981 call dvmCheckInst # (dPC, self) 14982 movl rSELF, %ecx 14983 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14984 jmp *dvmAsmInstructionStart+(204*4) 14985 14986/* ------------------------------ */ 14987.L_ALT_OP_MUL_DOUBLE_2ADDR: /* 0xcd */ 14988/* File: x86/alt_stub.S */ 14989/* 14990 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14991 * any interesting requests and then jump to the real instruction 14992 * handler. Unlike the Arm handler, we can't do this as a tail call 14993 * because rIBASE is caller save and we need to reload it. 14994 */ 14995 movl rSELF, %eax 14996 movl rPC, OUT_ARG0(%esp) 14997 movl %eax, OUT_ARG1(%esp) 14998 call dvmCheckInst # (dPC, self) 14999 movl rSELF, %ecx 15000 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15001 jmp *dvmAsmInstructionStart+(205*4) 15002 15003/* ------------------------------ */ 15004.L_ALT_OP_DIV_DOUBLE_2ADDR: /* 0xce */ 15005/* File: x86/alt_stub.S */ 15006/* 15007 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15008 * any interesting requests and then jump to the real instruction 15009 * handler. Unlike the Arm handler, we can't do this as a tail call 15010 * because rIBASE is caller save and we need to reload it. 15011 */ 15012 movl rSELF, %eax 15013 movl rPC, OUT_ARG0(%esp) 15014 movl %eax, OUT_ARG1(%esp) 15015 call dvmCheckInst # (dPC, self) 15016 movl rSELF, %ecx 15017 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15018 jmp *dvmAsmInstructionStart+(206*4) 15019 15020/* ------------------------------ */ 15021.L_ALT_OP_REM_DOUBLE_2ADDR: /* 0xcf */ 15022/* File: x86/alt_stub.S */ 15023/* 15024 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15025 * any interesting requests and then jump to the real instruction 15026 * handler. Unlike the Arm handler, we can't do this as a tail call 15027 * because rIBASE is caller save and we need to reload it. 15028 */ 15029 movl rSELF, %eax 15030 movl rPC, OUT_ARG0(%esp) 15031 movl %eax, OUT_ARG1(%esp) 15032 call dvmCheckInst # (dPC, self) 15033 movl rSELF, %ecx 15034 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15035 jmp *dvmAsmInstructionStart+(207*4) 15036 15037/* ------------------------------ */ 15038.L_ALT_OP_ADD_INT_LIT16: /* 0xd0 */ 15039/* File: x86/alt_stub.S */ 15040/* 15041 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15042 * any interesting requests and then jump to the real instruction 15043 * handler. Unlike the Arm handler, we can't do this as a tail call 15044 * because rIBASE is caller save and we need to reload it. 15045 */ 15046 movl rSELF, %eax 15047 movl rPC, OUT_ARG0(%esp) 15048 movl %eax, OUT_ARG1(%esp) 15049 call dvmCheckInst # (dPC, self) 15050 movl rSELF, %ecx 15051 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15052 jmp *dvmAsmInstructionStart+(208*4) 15053 15054/* ------------------------------ */ 15055.L_ALT_OP_RSUB_INT: /* 0xd1 */ 15056/* File: x86/alt_stub.S */ 15057/* 15058 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15059 * any interesting requests and then jump to the real instruction 15060 * handler. Unlike the Arm handler, we can't do this as a tail call 15061 * because rIBASE is caller save and we need to reload it. 15062 */ 15063 movl rSELF, %eax 15064 movl rPC, OUT_ARG0(%esp) 15065 movl %eax, OUT_ARG1(%esp) 15066 call dvmCheckInst # (dPC, self) 15067 movl rSELF, %ecx 15068 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15069 jmp *dvmAsmInstructionStart+(209*4) 15070 15071/* ------------------------------ */ 15072.L_ALT_OP_MUL_INT_LIT16: /* 0xd2 */ 15073/* File: x86/alt_stub.S */ 15074/* 15075 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15076 * any interesting requests and then jump to the real instruction 15077 * handler. Unlike the Arm handler, we can't do this as a tail call 15078 * because rIBASE is caller save and we need to reload it. 15079 */ 15080 movl rSELF, %eax 15081 movl rPC, OUT_ARG0(%esp) 15082 movl %eax, OUT_ARG1(%esp) 15083 call dvmCheckInst # (dPC, self) 15084 movl rSELF, %ecx 15085 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15086 jmp *dvmAsmInstructionStart+(210*4) 15087 15088/* ------------------------------ */ 15089.L_ALT_OP_DIV_INT_LIT16: /* 0xd3 */ 15090/* File: x86/alt_stub.S */ 15091/* 15092 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15093 * any interesting requests and then jump to the real instruction 15094 * handler. Unlike the Arm handler, we can't do this as a tail call 15095 * because rIBASE is caller save and we need to reload it. 15096 */ 15097 movl rSELF, %eax 15098 movl rPC, OUT_ARG0(%esp) 15099 movl %eax, OUT_ARG1(%esp) 15100 call dvmCheckInst # (dPC, self) 15101 movl rSELF, %ecx 15102 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15103 jmp *dvmAsmInstructionStart+(211*4) 15104 15105/* ------------------------------ */ 15106.L_ALT_OP_REM_INT_LIT16: /* 0xd4 */ 15107/* File: x86/alt_stub.S */ 15108/* 15109 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15110 * any interesting requests and then jump to the real instruction 15111 * handler. Unlike the Arm handler, we can't do this as a tail call 15112 * because rIBASE is caller save and we need to reload it. 15113 */ 15114 movl rSELF, %eax 15115 movl rPC, OUT_ARG0(%esp) 15116 movl %eax, OUT_ARG1(%esp) 15117 call dvmCheckInst # (dPC, self) 15118 movl rSELF, %ecx 15119 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15120 jmp *dvmAsmInstructionStart+(212*4) 15121 15122/* ------------------------------ */ 15123.L_ALT_OP_AND_INT_LIT16: /* 0xd5 */ 15124/* File: x86/alt_stub.S */ 15125/* 15126 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15127 * any interesting requests and then jump to the real instruction 15128 * handler. Unlike the Arm handler, we can't do this as a tail call 15129 * because rIBASE is caller save and we need to reload it. 15130 */ 15131 movl rSELF, %eax 15132 movl rPC, OUT_ARG0(%esp) 15133 movl %eax, OUT_ARG1(%esp) 15134 call dvmCheckInst # (dPC, self) 15135 movl rSELF, %ecx 15136 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15137 jmp *dvmAsmInstructionStart+(213*4) 15138 15139/* ------------------------------ */ 15140.L_ALT_OP_OR_INT_LIT16: /* 0xd6 */ 15141/* File: x86/alt_stub.S */ 15142/* 15143 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15144 * any interesting requests and then jump to the real instruction 15145 * handler. Unlike the Arm handler, we can't do this as a tail call 15146 * because rIBASE is caller save and we need to reload it. 15147 */ 15148 movl rSELF, %eax 15149 movl rPC, OUT_ARG0(%esp) 15150 movl %eax, OUT_ARG1(%esp) 15151 call dvmCheckInst # (dPC, self) 15152 movl rSELF, %ecx 15153 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15154 jmp *dvmAsmInstructionStart+(214*4) 15155 15156/* ------------------------------ */ 15157.L_ALT_OP_XOR_INT_LIT16: /* 0xd7 */ 15158/* File: x86/alt_stub.S */ 15159/* 15160 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15161 * any interesting requests and then jump to the real instruction 15162 * handler. Unlike the Arm handler, we can't do this as a tail call 15163 * because rIBASE is caller save and we need to reload it. 15164 */ 15165 movl rSELF, %eax 15166 movl rPC, OUT_ARG0(%esp) 15167 movl %eax, OUT_ARG1(%esp) 15168 call dvmCheckInst # (dPC, self) 15169 movl rSELF, %ecx 15170 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15171 jmp *dvmAsmInstructionStart+(215*4) 15172 15173/* ------------------------------ */ 15174.L_ALT_OP_ADD_INT_LIT8: /* 0xd8 */ 15175/* File: x86/alt_stub.S */ 15176/* 15177 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15178 * any interesting requests and then jump to the real instruction 15179 * handler. Unlike the Arm handler, we can't do this as a tail call 15180 * because rIBASE is caller save and we need to reload it. 15181 */ 15182 movl rSELF, %eax 15183 movl rPC, OUT_ARG0(%esp) 15184 movl %eax, OUT_ARG1(%esp) 15185 call dvmCheckInst # (dPC, self) 15186 movl rSELF, %ecx 15187 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15188 jmp *dvmAsmInstructionStart+(216*4) 15189 15190/* ------------------------------ */ 15191.L_ALT_OP_RSUB_INT_LIT8: /* 0xd9 */ 15192/* File: x86/alt_stub.S */ 15193/* 15194 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15195 * any interesting requests and then jump to the real instruction 15196 * handler. Unlike the Arm handler, we can't do this as a tail call 15197 * because rIBASE is caller save and we need to reload it. 15198 */ 15199 movl rSELF, %eax 15200 movl rPC, OUT_ARG0(%esp) 15201 movl %eax, OUT_ARG1(%esp) 15202 call dvmCheckInst # (dPC, self) 15203 movl rSELF, %ecx 15204 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15205 jmp *dvmAsmInstructionStart+(217*4) 15206 15207/* ------------------------------ */ 15208.L_ALT_OP_MUL_INT_LIT8: /* 0xda */ 15209/* File: x86/alt_stub.S */ 15210/* 15211 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15212 * any interesting requests and then jump to the real instruction 15213 * handler. Unlike the Arm handler, we can't do this as a tail call 15214 * because rIBASE is caller save and we need to reload it. 15215 */ 15216 movl rSELF, %eax 15217 movl rPC, OUT_ARG0(%esp) 15218 movl %eax, OUT_ARG1(%esp) 15219 call dvmCheckInst # (dPC, self) 15220 movl rSELF, %ecx 15221 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15222 jmp *dvmAsmInstructionStart+(218*4) 15223 15224/* ------------------------------ */ 15225.L_ALT_OP_DIV_INT_LIT8: /* 0xdb */ 15226/* File: x86/alt_stub.S */ 15227/* 15228 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15229 * any interesting requests and then jump to the real instruction 15230 * handler. Unlike the Arm handler, we can't do this as a tail call 15231 * because rIBASE is caller save and we need to reload it. 15232 */ 15233 movl rSELF, %eax 15234 movl rPC, OUT_ARG0(%esp) 15235 movl %eax, OUT_ARG1(%esp) 15236 call dvmCheckInst # (dPC, self) 15237 movl rSELF, %ecx 15238 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15239 jmp *dvmAsmInstructionStart+(219*4) 15240 15241/* ------------------------------ */ 15242.L_ALT_OP_REM_INT_LIT8: /* 0xdc */ 15243/* File: x86/alt_stub.S */ 15244/* 15245 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15246 * any interesting requests and then jump to the real instruction 15247 * handler. Unlike the Arm handler, we can't do this as a tail call 15248 * because rIBASE is caller save and we need to reload it. 15249 */ 15250 movl rSELF, %eax 15251 movl rPC, OUT_ARG0(%esp) 15252 movl %eax, OUT_ARG1(%esp) 15253 call dvmCheckInst # (dPC, self) 15254 movl rSELF, %ecx 15255 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15256 jmp *dvmAsmInstructionStart+(220*4) 15257 15258/* ------------------------------ */ 15259.L_ALT_OP_AND_INT_LIT8: /* 0xdd */ 15260/* File: x86/alt_stub.S */ 15261/* 15262 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15263 * any interesting requests and then jump to the real instruction 15264 * handler. Unlike the Arm handler, we can't do this as a tail call 15265 * because rIBASE is caller save and we need to reload it. 15266 */ 15267 movl rSELF, %eax 15268 movl rPC, OUT_ARG0(%esp) 15269 movl %eax, OUT_ARG1(%esp) 15270 call dvmCheckInst # (dPC, self) 15271 movl rSELF, %ecx 15272 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15273 jmp *dvmAsmInstructionStart+(221*4) 15274 15275/* ------------------------------ */ 15276.L_ALT_OP_OR_INT_LIT8: /* 0xde */ 15277/* File: x86/alt_stub.S */ 15278/* 15279 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15280 * any interesting requests and then jump to the real instruction 15281 * handler. Unlike the Arm handler, we can't do this as a tail call 15282 * because rIBASE is caller save and we need to reload it. 15283 */ 15284 movl rSELF, %eax 15285 movl rPC, OUT_ARG0(%esp) 15286 movl %eax, OUT_ARG1(%esp) 15287 call dvmCheckInst # (dPC, self) 15288 movl rSELF, %ecx 15289 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15290 jmp *dvmAsmInstructionStart+(222*4) 15291 15292/* ------------------------------ */ 15293.L_ALT_OP_XOR_INT_LIT8: /* 0xdf */ 15294/* File: x86/alt_stub.S */ 15295/* 15296 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15297 * any interesting requests and then jump to the real instruction 15298 * handler. Unlike the Arm handler, we can't do this as a tail call 15299 * because rIBASE is caller save and we need to reload it. 15300 */ 15301 movl rSELF, %eax 15302 movl rPC, OUT_ARG0(%esp) 15303 movl %eax, OUT_ARG1(%esp) 15304 call dvmCheckInst # (dPC, self) 15305 movl rSELF, %ecx 15306 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15307 jmp *dvmAsmInstructionStart+(223*4) 15308 15309/* ------------------------------ */ 15310.L_ALT_OP_SHL_INT_LIT8: /* 0xe0 */ 15311/* File: x86/alt_stub.S */ 15312/* 15313 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15314 * any interesting requests and then jump to the real instruction 15315 * handler. Unlike the Arm handler, we can't do this as a tail call 15316 * because rIBASE is caller save and we need to reload it. 15317 */ 15318 movl rSELF, %eax 15319 movl rPC, OUT_ARG0(%esp) 15320 movl %eax, OUT_ARG1(%esp) 15321 call dvmCheckInst # (dPC, self) 15322 movl rSELF, %ecx 15323 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15324 jmp *dvmAsmInstructionStart+(224*4) 15325 15326/* ------------------------------ */ 15327.L_ALT_OP_SHR_INT_LIT8: /* 0xe1 */ 15328/* File: x86/alt_stub.S */ 15329/* 15330 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15331 * any interesting requests and then jump to the real instruction 15332 * handler. Unlike the Arm handler, we can't do this as a tail call 15333 * because rIBASE is caller save and we need to reload it. 15334 */ 15335 movl rSELF, %eax 15336 movl rPC, OUT_ARG0(%esp) 15337 movl %eax, OUT_ARG1(%esp) 15338 call dvmCheckInst # (dPC, self) 15339 movl rSELF, %ecx 15340 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15341 jmp *dvmAsmInstructionStart+(225*4) 15342 15343/* ------------------------------ */ 15344.L_ALT_OP_USHR_INT_LIT8: /* 0xe2 */ 15345/* File: x86/alt_stub.S */ 15346/* 15347 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15348 * any interesting requests and then jump to the real instruction 15349 * handler. Unlike the Arm handler, we can't do this as a tail call 15350 * because rIBASE is caller save and we need to reload it. 15351 */ 15352 movl rSELF, %eax 15353 movl rPC, OUT_ARG0(%esp) 15354 movl %eax, OUT_ARG1(%esp) 15355 call dvmCheckInst # (dPC, self) 15356 movl rSELF, %ecx 15357 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15358 jmp *dvmAsmInstructionStart+(226*4) 15359 15360/* ------------------------------ */ 15361.L_ALT_OP_IGET_VOLATILE: /* 0xe3 */ 15362/* File: x86/alt_stub.S */ 15363/* 15364 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15365 * any interesting requests and then jump to the real instruction 15366 * handler. Unlike the Arm handler, we can't do this as a tail call 15367 * because rIBASE is caller save and we need to reload it. 15368 */ 15369 movl rSELF, %eax 15370 movl rPC, OUT_ARG0(%esp) 15371 movl %eax, OUT_ARG1(%esp) 15372 call dvmCheckInst # (dPC, self) 15373 movl rSELF, %ecx 15374 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15375 jmp *dvmAsmInstructionStart+(227*4) 15376 15377/* ------------------------------ */ 15378.L_ALT_OP_IPUT_VOLATILE: /* 0xe4 */ 15379/* File: x86/alt_stub.S */ 15380/* 15381 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15382 * any interesting requests and then jump to the real instruction 15383 * handler. Unlike the Arm handler, we can't do this as a tail call 15384 * because rIBASE is caller save and we need to reload it. 15385 */ 15386 movl rSELF, %eax 15387 movl rPC, OUT_ARG0(%esp) 15388 movl %eax, OUT_ARG1(%esp) 15389 call dvmCheckInst # (dPC, self) 15390 movl rSELF, %ecx 15391 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15392 jmp *dvmAsmInstructionStart+(228*4) 15393 15394/* ------------------------------ */ 15395.L_ALT_OP_SGET_VOLATILE: /* 0xe5 */ 15396/* File: x86/alt_stub.S */ 15397/* 15398 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15399 * any interesting requests and then jump to the real instruction 15400 * handler. Unlike the Arm handler, we can't do this as a tail call 15401 * because rIBASE is caller save and we need to reload it. 15402 */ 15403 movl rSELF, %eax 15404 movl rPC, OUT_ARG0(%esp) 15405 movl %eax, OUT_ARG1(%esp) 15406 call dvmCheckInst # (dPC, self) 15407 movl rSELF, %ecx 15408 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15409 jmp *dvmAsmInstructionStart+(229*4) 15410 15411/* ------------------------------ */ 15412.L_ALT_OP_SPUT_VOLATILE: /* 0xe6 */ 15413/* File: x86/alt_stub.S */ 15414/* 15415 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15416 * any interesting requests and then jump to the real instruction 15417 * handler. Unlike the Arm handler, we can't do this as a tail call 15418 * because rIBASE is caller save and we need to reload it. 15419 */ 15420 movl rSELF, %eax 15421 movl rPC, OUT_ARG0(%esp) 15422 movl %eax, OUT_ARG1(%esp) 15423 call dvmCheckInst # (dPC, self) 15424 movl rSELF, %ecx 15425 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15426 jmp *dvmAsmInstructionStart+(230*4) 15427 15428/* ------------------------------ */ 15429.L_ALT_OP_IGET_OBJECT_VOLATILE: /* 0xe7 */ 15430/* File: x86/alt_stub.S */ 15431/* 15432 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15433 * any interesting requests and then jump to the real instruction 15434 * handler. Unlike the Arm handler, we can't do this as a tail call 15435 * because rIBASE is caller save and we need to reload it. 15436 */ 15437 movl rSELF, %eax 15438 movl rPC, OUT_ARG0(%esp) 15439 movl %eax, OUT_ARG1(%esp) 15440 call dvmCheckInst # (dPC, self) 15441 movl rSELF, %ecx 15442 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15443 jmp *dvmAsmInstructionStart+(231*4) 15444 15445/* ------------------------------ */ 15446.L_ALT_OP_IGET_WIDE_VOLATILE: /* 0xe8 */ 15447/* File: x86/alt_stub.S */ 15448/* 15449 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15450 * any interesting requests and then jump to the real instruction 15451 * handler. Unlike the Arm handler, we can't do this as a tail call 15452 * because rIBASE is caller save and we need to reload it. 15453 */ 15454 movl rSELF, %eax 15455 movl rPC, OUT_ARG0(%esp) 15456 movl %eax, OUT_ARG1(%esp) 15457 call dvmCheckInst # (dPC, self) 15458 movl rSELF, %ecx 15459 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15460 jmp *dvmAsmInstructionStart+(232*4) 15461 15462/* ------------------------------ */ 15463.L_ALT_OP_IPUT_WIDE_VOLATILE: /* 0xe9 */ 15464/* File: x86/alt_stub.S */ 15465/* 15466 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15467 * any interesting requests and then jump to the real instruction 15468 * handler. Unlike the Arm handler, we can't do this as a tail call 15469 * because rIBASE is caller save and we need to reload it. 15470 */ 15471 movl rSELF, %eax 15472 movl rPC, OUT_ARG0(%esp) 15473 movl %eax, OUT_ARG1(%esp) 15474 call dvmCheckInst # (dPC, self) 15475 movl rSELF, %ecx 15476 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15477 jmp *dvmAsmInstructionStart+(233*4) 15478 15479/* ------------------------------ */ 15480.L_ALT_OP_SGET_WIDE_VOLATILE: /* 0xea */ 15481/* File: x86/alt_stub.S */ 15482/* 15483 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15484 * any interesting requests and then jump to the real instruction 15485 * handler. Unlike the Arm handler, we can't do this as a tail call 15486 * because rIBASE is caller save and we need to reload it. 15487 */ 15488 movl rSELF, %eax 15489 movl rPC, OUT_ARG0(%esp) 15490 movl %eax, OUT_ARG1(%esp) 15491 call dvmCheckInst # (dPC, self) 15492 movl rSELF, %ecx 15493 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15494 jmp *dvmAsmInstructionStart+(234*4) 15495 15496/* ------------------------------ */ 15497.L_ALT_OP_SPUT_WIDE_VOLATILE: /* 0xeb */ 15498/* File: x86/alt_stub.S */ 15499/* 15500 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15501 * any interesting requests and then jump to the real instruction 15502 * handler. Unlike the Arm handler, we can't do this as a tail call 15503 * because rIBASE is caller save and we need to reload it. 15504 */ 15505 movl rSELF, %eax 15506 movl rPC, OUT_ARG0(%esp) 15507 movl %eax, OUT_ARG1(%esp) 15508 call dvmCheckInst # (dPC, self) 15509 movl rSELF, %ecx 15510 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15511 jmp *dvmAsmInstructionStart+(235*4) 15512 15513/* ------------------------------ */ 15514.L_ALT_OP_BREAKPOINT: /* 0xec */ 15515/* File: x86/alt_stub.S */ 15516/* 15517 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15518 * any interesting requests and then jump to the real instruction 15519 * handler. Unlike the Arm handler, we can't do this as a tail call 15520 * because rIBASE is caller save and we need to reload it. 15521 */ 15522 movl rSELF, %eax 15523 movl rPC, OUT_ARG0(%esp) 15524 movl %eax, OUT_ARG1(%esp) 15525 call dvmCheckInst # (dPC, self) 15526 movl rSELF, %ecx 15527 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15528 jmp *dvmAsmInstructionStart+(236*4) 15529 15530/* ------------------------------ */ 15531.L_ALT_OP_THROW_VERIFICATION_ERROR: /* 0xed */ 15532/* File: x86/alt_stub.S */ 15533/* 15534 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15535 * any interesting requests and then jump to the real instruction 15536 * handler. Unlike the Arm handler, we can't do this as a tail call 15537 * because rIBASE is caller save and we need to reload it. 15538 */ 15539 movl rSELF, %eax 15540 movl rPC, OUT_ARG0(%esp) 15541 movl %eax, OUT_ARG1(%esp) 15542 call dvmCheckInst # (dPC, self) 15543 movl rSELF, %ecx 15544 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15545 jmp *dvmAsmInstructionStart+(237*4) 15546 15547/* ------------------------------ */ 15548.L_ALT_OP_EXECUTE_INLINE: /* 0xee */ 15549/* File: x86/alt_stub.S */ 15550/* 15551 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15552 * any interesting requests and then jump to the real instruction 15553 * handler. Unlike the Arm handler, we can't do this as a tail call 15554 * because rIBASE is caller save and we need to reload it. 15555 */ 15556 movl rSELF, %eax 15557 movl rPC, OUT_ARG0(%esp) 15558 movl %eax, OUT_ARG1(%esp) 15559 call dvmCheckInst # (dPC, self) 15560 movl rSELF, %ecx 15561 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15562 jmp *dvmAsmInstructionStart+(238*4) 15563 15564/* ------------------------------ */ 15565.L_ALT_OP_EXECUTE_INLINE_RANGE: /* 0xef */ 15566/* File: x86/alt_stub.S */ 15567/* 15568 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15569 * any interesting requests and then jump to the real instruction 15570 * handler. Unlike the Arm handler, we can't do this as a tail call 15571 * because rIBASE is caller save and we need to reload it. 15572 */ 15573 movl rSELF, %eax 15574 movl rPC, OUT_ARG0(%esp) 15575 movl %eax, OUT_ARG1(%esp) 15576 call dvmCheckInst # (dPC, self) 15577 movl rSELF, %ecx 15578 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15579 jmp *dvmAsmInstructionStart+(239*4) 15580 15581/* ------------------------------ */ 15582.L_ALT_OP_INVOKE_OBJECT_INIT_RANGE: /* 0xf0 */ 15583/* File: x86/alt_stub.S */ 15584/* 15585 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15586 * any interesting requests and then jump to the real instruction 15587 * handler. Unlike the Arm handler, we can't do this as a tail call 15588 * because rIBASE is caller save and we need to reload it. 15589 */ 15590 movl rSELF, %eax 15591 movl rPC, OUT_ARG0(%esp) 15592 movl %eax, OUT_ARG1(%esp) 15593 call dvmCheckInst # (dPC, self) 15594 movl rSELF, %ecx 15595 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15596 jmp *dvmAsmInstructionStart+(240*4) 15597 15598/* ------------------------------ */ 15599.L_ALT_OP_RETURN_VOID_BARRIER: /* 0xf1 */ 15600/* File: x86/alt_stub.S */ 15601/* 15602 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15603 * any interesting requests and then jump to the real instruction 15604 * handler. Unlike the Arm handler, we can't do this as a tail call 15605 * because rIBASE is caller save and we need to reload it. 15606 */ 15607 movl rSELF, %eax 15608 movl rPC, OUT_ARG0(%esp) 15609 movl %eax, OUT_ARG1(%esp) 15610 call dvmCheckInst # (dPC, self) 15611 movl rSELF, %ecx 15612 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15613 jmp *dvmAsmInstructionStart+(241*4) 15614 15615/* ------------------------------ */ 15616.L_ALT_OP_IGET_QUICK: /* 0xf2 */ 15617/* File: x86/alt_stub.S */ 15618/* 15619 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15620 * any interesting requests and then jump to the real instruction 15621 * handler. Unlike the Arm handler, we can't do this as a tail call 15622 * because rIBASE is caller save and we need to reload it. 15623 */ 15624 movl rSELF, %eax 15625 movl rPC, OUT_ARG0(%esp) 15626 movl %eax, OUT_ARG1(%esp) 15627 call dvmCheckInst # (dPC, self) 15628 movl rSELF, %ecx 15629 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15630 jmp *dvmAsmInstructionStart+(242*4) 15631 15632/* ------------------------------ */ 15633.L_ALT_OP_IGET_WIDE_QUICK: /* 0xf3 */ 15634/* File: x86/alt_stub.S */ 15635/* 15636 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15637 * any interesting requests and then jump to the real instruction 15638 * handler. Unlike the Arm handler, we can't do this as a tail call 15639 * because rIBASE is caller save and we need to reload it. 15640 */ 15641 movl rSELF, %eax 15642 movl rPC, OUT_ARG0(%esp) 15643 movl %eax, OUT_ARG1(%esp) 15644 call dvmCheckInst # (dPC, self) 15645 movl rSELF, %ecx 15646 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15647 jmp *dvmAsmInstructionStart+(243*4) 15648 15649/* ------------------------------ */ 15650.L_ALT_OP_IGET_OBJECT_QUICK: /* 0xf4 */ 15651/* File: x86/alt_stub.S */ 15652/* 15653 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15654 * any interesting requests and then jump to the real instruction 15655 * handler. Unlike the Arm handler, we can't do this as a tail call 15656 * because rIBASE is caller save and we need to reload it. 15657 */ 15658 movl rSELF, %eax 15659 movl rPC, OUT_ARG0(%esp) 15660 movl %eax, OUT_ARG1(%esp) 15661 call dvmCheckInst # (dPC, self) 15662 movl rSELF, %ecx 15663 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15664 jmp *dvmAsmInstructionStart+(244*4) 15665 15666/* ------------------------------ */ 15667.L_ALT_OP_IPUT_QUICK: /* 0xf5 */ 15668/* File: x86/alt_stub.S */ 15669/* 15670 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15671 * any interesting requests and then jump to the real instruction 15672 * handler. Unlike the Arm handler, we can't do this as a tail call 15673 * because rIBASE is caller save and we need to reload it. 15674 */ 15675 movl rSELF, %eax 15676 movl rPC, OUT_ARG0(%esp) 15677 movl %eax, OUT_ARG1(%esp) 15678 call dvmCheckInst # (dPC, self) 15679 movl rSELF, %ecx 15680 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15681 jmp *dvmAsmInstructionStart+(245*4) 15682 15683/* ------------------------------ */ 15684.L_ALT_OP_IPUT_WIDE_QUICK: /* 0xf6 */ 15685/* File: x86/alt_stub.S */ 15686/* 15687 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15688 * any interesting requests and then jump to the real instruction 15689 * handler. Unlike the Arm handler, we can't do this as a tail call 15690 * because rIBASE is caller save and we need to reload it. 15691 */ 15692 movl rSELF, %eax 15693 movl rPC, OUT_ARG0(%esp) 15694 movl %eax, OUT_ARG1(%esp) 15695 call dvmCheckInst # (dPC, self) 15696 movl rSELF, %ecx 15697 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15698 jmp *dvmAsmInstructionStart+(246*4) 15699 15700/* ------------------------------ */ 15701.L_ALT_OP_IPUT_OBJECT_QUICK: /* 0xf7 */ 15702/* File: x86/alt_stub.S */ 15703/* 15704 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15705 * any interesting requests and then jump to the real instruction 15706 * handler. Unlike the Arm handler, we can't do this as a tail call 15707 * because rIBASE is caller save and we need to reload it. 15708 */ 15709 movl rSELF, %eax 15710 movl rPC, OUT_ARG0(%esp) 15711 movl %eax, OUT_ARG1(%esp) 15712 call dvmCheckInst # (dPC, self) 15713 movl rSELF, %ecx 15714 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15715 jmp *dvmAsmInstructionStart+(247*4) 15716 15717/* ------------------------------ */ 15718.L_ALT_OP_INVOKE_VIRTUAL_QUICK: /* 0xf8 */ 15719/* File: x86/alt_stub.S */ 15720/* 15721 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15722 * any interesting requests and then jump to the real instruction 15723 * handler. Unlike the Arm handler, we can't do this as a tail call 15724 * because rIBASE is caller save and we need to reload it. 15725 */ 15726 movl rSELF, %eax 15727 movl rPC, OUT_ARG0(%esp) 15728 movl %eax, OUT_ARG1(%esp) 15729 call dvmCheckInst # (dPC, self) 15730 movl rSELF, %ecx 15731 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15732 jmp *dvmAsmInstructionStart+(248*4) 15733 15734/* ------------------------------ */ 15735.L_ALT_OP_INVOKE_VIRTUAL_QUICK_RANGE: /* 0xf9 */ 15736/* File: x86/alt_stub.S */ 15737/* 15738 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15739 * any interesting requests and then jump to the real instruction 15740 * handler. Unlike the Arm handler, we can't do this as a tail call 15741 * because rIBASE is caller save and we need to reload it. 15742 */ 15743 movl rSELF, %eax 15744 movl rPC, OUT_ARG0(%esp) 15745 movl %eax, OUT_ARG1(%esp) 15746 call dvmCheckInst # (dPC, self) 15747 movl rSELF, %ecx 15748 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15749 jmp *dvmAsmInstructionStart+(249*4) 15750 15751/* ------------------------------ */ 15752.L_ALT_OP_INVOKE_SUPER_QUICK: /* 0xfa */ 15753/* File: x86/alt_stub.S */ 15754/* 15755 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15756 * any interesting requests and then jump to the real instruction 15757 * handler. Unlike the Arm handler, we can't do this as a tail call 15758 * because rIBASE is caller save and we need to reload it. 15759 */ 15760 movl rSELF, %eax 15761 movl rPC, OUT_ARG0(%esp) 15762 movl %eax, OUT_ARG1(%esp) 15763 call dvmCheckInst # (dPC, self) 15764 movl rSELF, %ecx 15765 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15766 jmp *dvmAsmInstructionStart+(250*4) 15767 15768/* ------------------------------ */ 15769.L_ALT_OP_INVOKE_SUPER_QUICK_RANGE: /* 0xfb */ 15770/* File: x86/alt_stub.S */ 15771/* 15772 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15773 * any interesting requests and then jump to the real instruction 15774 * handler. Unlike the Arm handler, we can't do this as a tail call 15775 * because rIBASE is caller save and we need to reload it. 15776 */ 15777 movl rSELF, %eax 15778 movl rPC, OUT_ARG0(%esp) 15779 movl %eax, OUT_ARG1(%esp) 15780 call dvmCheckInst # (dPC, self) 15781 movl rSELF, %ecx 15782 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15783 jmp *dvmAsmInstructionStart+(251*4) 15784 15785/* ------------------------------ */ 15786.L_ALT_OP_IPUT_OBJECT_VOLATILE: /* 0xfc */ 15787/* File: x86/alt_stub.S */ 15788/* 15789 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15790 * any interesting requests and then jump to the real instruction 15791 * handler. Unlike the Arm handler, we can't do this as a tail call 15792 * because rIBASE is caller save and we need to reload it. 15793 */ 15794 movl rSELF, %eax 15795 movl rPC, OUT_ARG0(%esp) 15796 movl %eax, OUT_ARG1(%esp) 15797 call dvmCheckInst # (dPC, self) 15798 movl rSELF, %ecx 15799 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15800 jmp *dvmAsmInstructionStart+(252*4) 15801 15802/* ------------------------------ */ 15803.L_ALT_OP_SGET_OBJECT_VOLATILE: /* 0xfd */ 15804/* File: x86/alt_stub.S */ 15805/* 15806 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15807 * any interesting requests and then jump to the real instruction 15808 * handler. Unlike the Arm handler, we can't do this as a tail call 15809 * because rIBASE is caller save and we need to reload it. 15810 */ 15811 movl rSELF, %eax 15812 movl rPC, OUT_ARG0(%esp) 15813 movl %eax, OUT_ARG1(%esp) 15814 call dvmCheckInst # (dPC, self) 15815 movl rSELF, %ecx 15816 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15817 jmp *dvmAsmInstructionStart+(253*4) 15818 15819/* ------------------------------ */ 15820.L_ALT_OP_SPUT_OBJECT_VOLATILE: /* 0xfe */ 15821/* File: x86/alt_stub.S */ 15822/* 15823 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15824 * any interesting requests and then jump to the real instruction 15825 * handler. Unlike the Arm handler, we can't do this as a tail call 15826 * because rIBASE is caller save and we need to reload it. 15827 */ 15828 movl rSELF, %eax 15829 movl rPC, OUT_ARG0(%esp) 15830 movl %eax, OUT_ARG1(%esp) 15831 call dvmCheckInst # (dPC, self) 15832 movl rSELF, %ecx 15833 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15834 jmp *dvmAsmInstructionStart+(254*4) 15835 15836/* ------------------------------ */ 15837.L_ALT_OP_DISPATCH_FF: /* 0xff */ 15838/* File: x86/alt_stub.S */ 15839/* 15840 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15841 * any interesting requests and then jump to the real instruction 15842 * handler. Unlike the Arm handler, we can't do this as a tail call 15843 * because rIBASE is caller save and we need to reload it. 15844 */ 15845 movl rSELF, %eax 15846 movl rPC, OUT_ARG0(%esp) 15847 movl %eax, OUT_ARG1(%esp) 15848 call dvmCheckInst # (dPC, self) 15849 movl rSELF, %ecx 15850 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15851 jmp *dvmAsmInstructionStart+(255*4) 15852 15853/* ------------------------------ */ 15854.L_ALT_OP_CONST_CLASS_JUMBO: /* 0x100 */ 15855/* File: x86/alt_stub.S */ 15856/* 15857 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15858 * any interesting requests and then jump to the real instruction 15859 * handler. Unlike the Arm handler, we can't do this as a tail call 15860 * because rIBASE is caller save and we need to reload it. 15861 */ 15862 movl rSELF, %eax 15863 movl rPC, OUT_ARG0(%esp) 15864 movl %eax, OUT_ARG1(%esp) 15865 call dvmCheckInst # (dPC, self) 15866 movl rSELF, %ecx 15867 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15868 jmp *dvmAsmInstructionStart+(256*4) 15869 15870/* ------------------------------ */ 15871.L_ALT_OP_CHECK_CAST_JUMBO: /* 0x101 */ 15872/* File: x86/alt_stub.S */ 15873/* 15874 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15875 * any interesting requests and then jump to the real instruction 15876 * handler. Unlike the Arm handler, we can't do this as a tail call 15877 * because rIBASE is caller save and we need to reload it. 15878 */ 15879 movl rSELF, %eax 15880 movl rPC, OUT_ARG0(%esp) 15881 movl %eax, OUT_ARG1(%esp) 15882 call dvmCheckInst # (dPC, self) 15883 movl rSELF, %ecx 15884 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15885 jmp *dvmAsmInstructionStart+(257*4) 15886 15887/* ------------------------------ */ 15888.L_ALT_OP_INSTANCE_OF_JUMBO: /* 0x102 */ 15889/* File: x86/alt_stub.S */ 15890/* 15891 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15892 * any interesting requests and then jump to the real instruction 15893 * handler. Unlike the Arm handler, we can't do this as a tail call 15894 * because rIBASE is caller save and we need to reload it. 15895 */ 15896 movl rSELF, %eax 15897 movl rPC, OUT_ARG0(%esp) 15898 movl %eax, OUT_ARG1(%esp) 15899 call dvmCheckInst # (dPC, self) 15900 movl rSELF, %ecx 15901 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15902 jmp *dvmAsmInstructionStart+(258*4) 15903 15904/* ------------------------------ */ 15905.L_ALT_OP_NEW_INSTANCE_JUMBO: /* 0x103 */ 15906/* File: x86/alt_stub.S */ 15907/* 15908 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15909 * any interesting requests and then jump to the real instruction 15910 * handler. Unlike the Arm handler, we can't do this as a tail call 15911 * because rIBASE is caller save and we need to reload it. 15912 */ 15913 movl rSELF, %eax 15914 movl rPC, OUT_ARG0(%esp) 15915 movl %eax, OUT_ARG1(%esp) 15916 call dvmCheckInst # (dPC, self) 15917 movl rSELF, %ecx 15918 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15919 jmp *dvmAsmInstructionStart+(259*4) 15920 15921/* ------------------------------ */ 15922.L_ALT_OP_NEW_ARRAY_JUMBO: /* 0x104 */ 15923/* File: x86/alt_stub.S */ 15924/* 15925 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15926 * any interesting requests and then jump to the real instruction 15927 * handler. Unlike the Arm handler, we can't do this as a tail call 15928 * because rIBASE is caller save and we need to reload it. 15929 */ 15930 movl rSELF, %eax 15931 movl rPC, OUT_ARG0(%esp) 15932 movl %eax, OUT_ARG1(%esp) 15933 call dvmCheckInst # (dPC, self) 15934 movl rSELF, %ecx 15935 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15936 jmp *dvmAsmInstructionStart+(260*4) 15937 15938/* ------------------------------ */ 15939.L_ALT_OP_FILLED_NEW_ARRAY_JUMBO: /* 0x105 */ 15940/* File: x86/alt_stub.S */ 15941/* 15942 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15943 * any interesting requests and then jump to the real instruction 15944 * handler. Unlike the Arm handler, we can't do this as a tail call 15945 * because rIBASE is caller save and we need to reload it. 15946 */ 15947 movl rSELF, %eax 15948 movl rPC, OUT_ARG0(%esp) 15949 movl %eax, OUT_ARG1(%esp) 15950 call dvmCheckInst # (dPC, self) 15951 movl rSELF, %ecx 15952 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15953 jmp *dvmAsmInstructionStart+(261*4) 15954 15955/* ------------------------------ */ 15956.L_ALT_OP_IGET_JUMBO: /* 0x106 */ 15957/* File: x86/alt_stub.S */ 15958/* 15959 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15960 * any interesting requests and then jump to the real instruction 15961 * handler. Unlike the Arm handler, we can't do this as a tail call 15962 * because rIBASE is caller save and we need to reload it. 15963 */ 15964 movl rSELF, %eax 15965 movl rPC, OUT_ARG0(%esp) 15966 movl %eax, OUT_ARG1(%esp) 15967 call dvmCheckInst # (dPC, self) 15968 movl rSELF, %ecx 15969 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15970 jmp *dvmAsmInstructionStart+(262*4) 15971 15972/* ------------------------------ */ 15973.L_ALT_OP_IGET_WIDE_JUMBO: /* 0x107 */ 15974/* File: x86/alt_stub.S */ 15975/* 15976 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15977 * any interesting requests and then jump to the real instruction 15978 * handler. Unlike the Arm handler, we can't do this as a tail call 15979 * because rIBASE is caller save and we need to reload it. 15980 */ 15981 movl rSELF, %eax 15982 movl rPC, OUT_ARG0(%esp) 15983 movl %eax, OUT_ARG1(%esp) 15984 call dvmCheckInst # (dPC, self) 15985 movl rSELF, %ecx 15986 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15987 jmp *dvmAsmInstructionStart+(263*4) 15988 15989/* ------------------------------ */ 15990.L_ALT_OP_IGET_OBJECT_JUMBO: /* 0x108 */ 15991/* File: x86/alt_stub.S */ 15992/* 15993 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15994 * any interesting requests and then jump to the real instruction 15995 * handler. Unlike the Arm handler, we can't do this as a tail call 15996 * because rIBASE is caller save and we need to reload it. 15997 */ 15998 movl rSELF, %eax 15999 movl rPC, OUT_ARG0(%esp) 16000 movl %eax, OUT_ARG1(%esp) 16001 call dvmCheckInst # (dPC, self) 16002 movl rSELF, %ecx 16003 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16004 jmp *dvmAsmInstructionStart+(264*4) 16005 16006/* ------------------------------ */ 16007.L_ALT_OP_IGET_BOOLEAN_JUMBO: /* 0x109 */ 16008/* File: x86/alt_stub.S */ 16009/* 16010 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16011 * any interesting requests and then jump to the real instruction 16012 * handler. Unlike the Arm handler, we can't do this as a tail call 16013 * because rIBASE is caller save and we need to reload it. 16014 */ 16015 movl rSELF, %eax 16016 movl rPC, OUT_ARG0(%esp) 16017 movl %eax, OUT_ARG1(%esp) 16018 call dvmCheckInst # (dPC, self) 16019 movl rSELF, %ecx 16020 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16021 jmp *dvmAsmInstructionStart+(265*4) 16022 16023/* ------------------------------ */ 16024.L_ALT_OP_IGET_BYTE_JUMBO: /* 0x10a */ 16025/* File: x86/alt_stub.S */ 16026/* 16027 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16028 * any interesting requests and then jump to the real instruction 16029 * handler. Unlike the Arm handler, we can't do this as a tail call 16030 * because rIBASE is caller save and we need to reload it. 16031 */ 16032 movl rSELF, %eax 16033 movl rPC, OUT_ARG0(%esp) 16034 movl %eax, OUT_ARG1(%esp) 16035 call dvmCheckInst # (dPC, self) 16036 movl rSELF, %ecx 16037 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16038 jmp *dvmAsmInstructionStart+(266*4) 16039 16040/* ------------------------------ */ 16041.L_ALT_OP_IGET_CHAR_JUMBO: /* 0x10b */ 16042/* File: x86/alt_stub.S */ 16043/* 16044 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16045 * any interesting requests and then jump to the real instruction 16046 * handler. Unlike the Arm handler, we can't do this as a tail call 16047 * because rIBASE is caller save and we need to reload it. 16048 */ 16049 movl rSELF, %eax 16050 movl rPC, OUT_ARG0(%esp) 16051 movl %eax, OUT_ARG1(%esp) 16052 call dvmCheckInst # (dPC, self) 16053 movl rSELF, %ecx 16054 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16055 jmp *dvmAsmInstructionStart+(267*4) 16056 16057/* ------------------------------ */ 16058.L_ALT_OP_IGET_SHORT_JUMBO: /* 0x10c */ 16059/* File: x86/alt_stub.S */ 16060/* 16061 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16062 * any interesting requests and then jump to the real instruction 16063 * handler. Unlike the Arm handler, we can't do this as a tail call 16064 * because rIBASE is caller save and we need to reload it. 16065 */ 16066 movl rSELF, %eax 16067 movl rPC, OUT_ARG0(%esp) 16068 movl %eax, OUT_ARG1(%esp) 16069 call dvmCheckInst # (dPC, self) 16070 movl rSELF, %ecx 16071 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16072 jmp *dvmAsmInstructionStart+(268*4) 16073 16074/* ------------------------------ */ 16075.L_ALT_OP_IPUT_JUMBO: /* 0x10d */ 16076/* File: x86/alt_stub.S */ 16077/* 16078 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16079 * any interesting requests and then jump to the real instruction 16080 * handler. Unlike the Arm handler, we can't do this as a tail call 16081 * because rIBASE is caller save and we need to reload it. 16082 */ 16083 movl rSELF, %eax 16084 movl rPC, OUT_ARG0(%esp) 16085 movl %eax, OUT_ARG1(%esp) 16086 call dvmCheckInst # (dPC, self) 16087 movl rSELF, %ecx 16088 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16089 jmp *dvmAsmInstructionStart+(269*4) 16090 16091/* ------------------------------ */ 16092.L_ALT_OP_IPUT_WIDE_JUMBO: /* 0x10e */ 16093/* File: x86/alt_stub.S */ 16094/* 16095 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16096 * any interesting requests and then jump to the real instruction 16097 * handler. Unlike the Arm handler, we can't do this as a tail call 16098 * because rIBASE is caller save and we need to reload it. 16099 */ 16100 movl rSELF, %eax 16101 movl rPC, OUT_ARG0(%esp) 16102 movl %eax, OUT_ARG1(%esp) 16103 call dvmCheckInst # (dPC, self) 16104 movl rSELF, %ecx 16105 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16106 jmp *dvmAsmInstructionStart+(270*4) 16107 16108/* ------------------------------ */ 16109.L_ALT_OP_IPUT_OBJECT_JUMBO: /* 0x10f */ 16110/* File: x86/alt_stub.S */ 16111/* 16112 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16113 * any interesting requests and then jump to the real instruction 16114 * handler. Unlike the Arm handler, we can't do this as a tail call 16115 * because rIBASE is caller save and we need to reload it. 16116 */ 16117 movl rSELF, %eax 16118 movl rPC, OUT_ARG0(%esp) 16119 movl %eax, OUT_ARG1(%esp) 16120 call dvmCheckInst # (dPC, self) 16121 movl rSELF, %ecx 16122 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16123 jmp *dvmAsmInstructionStart+(271*4) 16124 16125/* ------------------------------ */ 16126.L_ALT_OP_IPUT_BOOLEAN_JUMBO: /* 0x110 */ 16127/* File: x86/alt_stub.S */ 16128/* 16129 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16130 * any interesting requests and then jump to the real instruction 16131 * handler. Unlike the Arm handler, we can't do this as a tail call 16132 * because rIBASE is caller save and we need to reload it. 16133 */ 16134 movl rSELF, %eax 16135 movl rPC, OUT_ARG0(%esp) 16136 movl %eax, OUT_ARG1(%esp) 16137 call dvmCheckInst # (dPC, self) 16138 movl rSELF, %ecx 16139 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16140 jmp *dvmAsmInstructionStart+(272*4) 16141 16142/* ------------------------------ */ 16143.L_ALT_OP_IPUT_BYTE_JUMBO: /* 0x111 */ 16144/* File: x86/alt_stub.S */ 16145/* 16146 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16147 * any interesting requests and then jump to the real instruction 16148 * handler. Unlike the Arm handler, we can't do this as a tail call 16149 * because rIBASE is caller save and we need to reload it. 16150 */ 16151 movl rSELF, %eax 16152 movl rPC, OUT_ARG0(%esp) 16153 movl %eax, OUT_ARG1(%esp) 16154 call dvmCheckInst # (dPC, self) 16155 movl rSELF, %ecx 16156 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16157 jmp *dvmAsmInstructionStart+(273*4) 16158 16159/* ------------------------------ */ 16160.L_ALT_OP_IPUT_CHAR_JUMBO: /* 0x112 */ 16161/* File: x86/alt_stub.S */ 16162/* 16163 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16164 * any interesting requests and then jump to the real instruction 16165 * handler. Unlike the Arm handler, we can't do this as a tail call 16166 * because rIBASE is caller save and we need to reload it. 16167 */ 16168 movl rSELF, %eax 16169 movl rPC, OUT_ARG0(%esp) 16170 movl %eax, OUT_ARG1(%esp) 16171 call dvmCheckInst # (dPC, self) 16172 movl rSELF, %ecx 16173 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16174 jmp *dvmAsmInstructionStart+(274*4) 16175 16176/* ------------------------------ */ 16177.L_ALT_OP_IPUT_SHORT_JUMBO: /* 0x113 */ 16178/* File: x86/alt_stub.S */ 16179/* 16180 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16181 * any interesting requests and then jump to the real instruction 16182 * handler. Unlike the Arm handler, we can't do this as a tail call 16183 * because rIBASE is caller save and we need to reload it. 16184 */ 16185 movl rSELF, %eax 16186 movl rPC, OUT_ARG0(%esp) 16187 movl %eax, OUT_ARG1(%esp) 16188 call dvmCheckInst # (dPC, self) 16189 movl rSELF, %ecx 16190 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16191 jmp *dvmAsmInstructionStart+(275*4) 16192 16193/* ------------------------------ */ 16194.L_ALT_OP_SGET_JUMBO: /* 0x114 */ 16195/* File: x86/alt_stub.S */ 16196/* 16197 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16198 * any interesting requests and then jump to the real instruction 16199 * handler. Unlike the Arm handler, we can't do this as a tail call 16200 * because rIBASE is caller save and we need to reload it. 16201 */ 16202 movl rSELF, %eax 16203 movl rPC, OUT_ARG0(%esp) 16204 movl %eax, OUT_ARG1(%esp) 16205 call dvmCheckInst # (dPC, self) 16206 movl rSELF, %ecx 16207 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16208 jmp *dvmAsmInstructionStart+(276*4) 16209 16210/* ------------------------------ */ 16211.L_ALT_OP_SGET_WIDE_JUMBO: /* 0x115 */ 16212/* File: x86/alt_stub.S */ 16213/* 16214 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16215 * any interesting requests and then jump to the real instruction 16216 * handler. Unlike the Arm handler, we can't do this as a tail call 16217 * because rIBASE is caller save and we need to reload it. 16218 */ 16219 movl rSELF, %eax 16220 movl rPC, OUT_ARG0(%esp) 16221 movl %eax, OUT_ARG1(%esp) 16222 call dvmCheckInst # (dPC, self) 16223 movl rSELF, %ecx 16224 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16225 jmp *dvmAsmInstructionStart+(277*4) 16226 16227/* ------------------------------ */ 16228.L_ALT_OP_SGET_OBJECT_JUMBO: /* 0x116 */ 16229/* File: x86/alt_stub.S */ 16230/* 16231 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16232 * any interesting requests and then jump to the real instruction 16233 * handler. Unlike the Arm handler, we can't do this as a tail call 16234 * because rIBASE is caller save and we need to reload it. 16235 */ 16236 movl rSELF, %eax 16237 movl rPC, OUT_ARG0(%esp) 16238 movl %eax, OUT_ARG1(%esp) 16239 call dvmCheckInst # (dPC, self) 16240 movl rSELF, %ecx 16241 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16242 jmp *dvmAsmInstructionStart+(278*4) 16243 16244/* ------------------------------ */ 16245.L_ALT_OP_SGET_BOOLEAN_JUMBO: /* 0x117 */ 16246/* File: x86/alt_stub.S */ 16247/* 16248 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16249 * any interesting requests and then jump to the real instruction 16250 * handler. Unlike the Arm handler, we can't do this as a tail call 16251 * because rIBASE is caller save and we need to reload it. 16252 */ 16253 movl rSELF, %eax 16254 movl rPC, OUT_ARG0(%esp) 16255 movl %eax, OUT_ARG1(%esp) 16256 call dvmCheckInst # (dPC, self) 16257 movl rSELF, %ecx 16258 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16259 jmp *dvmAsmInstructionStart+(279*4) 16260 16261/* ------------------------------ */ 16262.L_ALT_OP_SGET_BYTE_JUMBO: /* 0x118 */ 16263/* File: x86/alt_stub.S */ 16264/* 16265 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16266 * any interesting requests and then jump to the real instruction 16267 * handler. Unlike the Arm handler, we can't do this as a tail call 16268 * because rIBASE is caller save and we need to reload it. 16269 */ 16270 movl rSELF, %eax 16271 movl rPC, OUT_ARG0(%esp) 16272 movl %eax, OUT_ARG1(%esp) 16273 call dvmCheckInst # (dPC, self) 16274 movl rSELF, %ecx 16275 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16276 jmp *dvmAsmInstructionStart+(280*4) 16277 16278/* ------------------------------ */ 16279.L_ALT_OP_SGET_CHAR_JUMBO: /* 0x119 */ 16280/* File: x86/alt_stub.S */ 16281/* 16282 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16283 * any interesting requests and then jump to the real instruction 16284 * handler. Unlike the Arm handler, we can't do this as a tail call 16285 * because rIBASE is caller save and we need to reload it. 16286 */ 16287 movl rSELF, %eax 16288 movl rPC, OUT_ARG0(%esp) 16289 movl %eax, OUT_ARG1(%esp) 16290 call dvmCheckInst # (dPC, self) 16291 movl rSELF, %ecx 16292 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16293 jmp *dvmAsmInstructionStart+(281*4) 16294 16295/* ------------------------------ */ 16296.L_ALT_OP_SGET_SHORT_JUMBO: /* 0x11a */ 16297/* File: x86/alt_stub.S */ 16298/* 16299 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16300 * any interesting requests and then jump to the real instruction 16301 * handler. Unlike the Arm handler, we can't do this as a tail call 16302 * because rIBASE is caller save and we need to reload it. 16303 */ 16304 movl rSELF, %eax 16305 movl rPC, OUT_ARG0(%esp) 16306 movl %eax, OUT_ARG1(%esp) 16307 call dvmCheckInst # (dPC, self) 16308 movl rSELF, %ecx 16309 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16310 jmp *dvmAsmInstructionStart+(282*4) 16311 16312/* ------------------------------ */ 16313.L_ALT_OP_SPUT_JUMBO: /* 0x11b */ 16314/* File: x86/alt_stub.S */ 16315/* 16316 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16317 * any interesting requests and then jump to the real instruction 16318 * handler. Unlike the Arm handler, we can't do this as a tail call 16319 * because rIBASE is caller save and we need to reload it. 16320 */ 16321 movl rSELF, %eax 16322 movl rPC, OUT_ARG0(%esp) 16323 movl %eax, OUT_ARG1(%esp) 16324 call dvmCheckInst # (dPC, self) 16325 movl rSELF, %ecx 16326 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16327 jmp *dvmAsmInstructionStart+(283*4) 16328 16329/* ------------------------------ */ 16330.L_ALT_OP_SPUT_WIDE_JUMBO: /* 0x11c */ 16331/* File: x86/alt_stub.S */ 16332/* 16333 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16334 * any interesting requests and then jump to the real instruction 16335 * handler. Unlike the Arm handler, we can't do this as a tail call 16336 * because rIBASE is caller save and we need to reload it. 16337 */ 16338 movl rSELF, %eax 16339 movl rPC, OUT_ARG0(%esp) 16340 movl %eax, OUT_ARG1(%esp) 16341 call dvmCheckInst # (dPC, self) 16342 movl rSELF, %ecx 16343 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16344 jmp *dvmAsmInstructionStart+(284*4) 16345 16346/* ------------------------------ */ 16347.L_ALT_OP_SPUT_OBJECT_JUMBO: /* 0x11d */ 16348/* File: x86/alt_stub.S */ 16349/* 16350 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16351 * any interesting requests and then jump to the real instruction 16352 * handler. Unlike the Arm handler, we can't do this as a tail call 16353 * because rIBASE is caller save and we need to reload it. 16354 */ 16355 movl rSELF, %eax 16356 movl rPC, OUT_ARG0(%esp) 16357 movl %eax, OUT_ARG1(%esp) 16358 call dvmCheckInst # (dPC, self) 16359 movl rSELF, %ecx 16360 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16361 jmp *dvmAsmInstructionStart+(285*4) 16362 16363/* ------------------------------ */ 16364.L_ALT_OP_SPUT_BOOLEAN_JUMBO: /* 0x11e */ 16365/* File: x86/alt_stub.S */ 16366/* 16367 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16368 * any interesting requests and then jump to the real instruction 16369 * handler. Unlike the Arm handler, we can't do this as a tail call 16370 * because rIBASE is caller save and we need to reload it. 16371 */ 16372 movl rSELF, %eax 16373 movl rPC, OUT_ARG0(%esp) 16374 movl %eax, OUT_ARG1(%esp) 16375 call dvmCheckInst # (dPC, self) 16376 movl rSELF, %ecx 16377 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16378 jmp *dvmAsmInstructionStart+(286*4) 16379 16380/* ------------------------------ */ 16381.L_ALT_OP_SPUT_BYTE_JUMBO: /* 0x11f */ 16382/* File: x86/alt_stub.S */ 16383/* 16384 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16385 * any interesting requests and then jump to the real instruction 16386 * handler. Unlike the Arm handler, we can't do this as a tail call 16387 * because rIBASE is caller save and we need to reload it. 16388 */ 16389 movl rSELF, %eax 16390 movl rPC, OUT_ARG0(%esp) 16391 movl %eax, OUT_ARG1(%esp) 16392 call dvmCheckInst # (dPC, self) 16393 movl rSELF, %ecx 16394 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16395 jmp *dvmAsmInstructionStart+(287*4) 16396 16397/* ------------------------------ */ 16398.L_ALT_OP_SPUT_CHAR_JUMBO: /* 0x120 */ 16399/* File: x86/alt_stub.S */ 16400/* 16401 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16402 * any interesting requests and then jump to the real instruction 16403 * handler. Unlike the Arm handler, we can't do this as a tail call 16404 * because rIBASE is caller save and we need to reload it. 16405 */ 16406 movl rSELF, %eax 16407 movl rPC, OUT_ARG0(%esp) 16408 movl %eax, OUT_ARG1(%esp) 16409 call dvmCheckInst # (dPC, self) 16410 movl rSELF, %ecx 16411 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16412 jmp *dvmAsmInstructionStart+(288*4) 16413 16414/* ------------------------------ */ 16415.L_ALT_OP_SPUT_SHORT_JUMBO: /* 0x121 */ 16416/* File: x86/alt_stub.S */ 16417/* 16418 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16419 * any interesting requests and then jump to the real instruction 16420 * handler. Unlike the Arm handler, we can't do this as a tail call 16421 * because rIBASE is caller save and we need to reload it. 16422 */ 16423 movl rSELF, %eax 16424 movl rPC, OUT_ARG0(%esp) 16425 movl %eax, OUT_ARG1(%esp) 16426 call dvmCheckInst # (dPC, self) 16427 movl rSELF, %ecx 16428 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16429 jmp *dvmAsmInstructionStart+(289*4) 16430 16431/* ------------------------------ */ 16432.L_ALT_OP_INVOKE_VIRTUAL_JUMBO: /* 0x122 */ 16433/* File: x86/alt_stub.S */ 16434/* 16435 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16436 * any interesting requests and then jump to the real instruction 16437 * handler. Unlike the Arm handler, we can't do this as a tail call 16438 * because rIBASE is caller save and we need to reload it. 16439 */ 16440 movl rSELF, %eax 16441 movl rPC, OUT_ARG0(%esp) 16442 movl %eax, OUT_ARG1(%esp) 16443 call dvmCheckInst # (dPC, self) 16444 movl rSELF, %ecx 16445 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16446 jmp *dvmAsmInstructionStart+(290*4) 16447 16448/* ------------------------------ */ 16449.L_ALT_OP_INVOKE_SUPER_JUMBO: /* 0x123 */ 16450/* File: x86/alt_stub.S */ 16451/* 16452 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16453 * any interesting requests and then jump to the real instruction 16454 * handler. Unlike the Arm handler, we can't do this as a tail call 16455 * because rIBASE is caller save and we need to reload it. 16456 */ 16457 movl rSELF, %eax 16458 movl rPC, OUT_ARG0(%esp) 16459 movl %eax, OUT_ARG1(%esp) 16460 call dvmCheckInst # (dPC, self) 16461 movl rSELF, %ecx 16462 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16463 jmp *dvmAsmInstructionStart+(291*4) 16464 16465/* ------------------------------ */ 16466.L_ALT_OP_INVOKE_DIRECT_JUMBO: /* 0x124 */ 16467/* File: x86/alt_stub.S */ 16468/* 16469 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16470 * any interesting requests and then jump to the real instruction 16471 * handler. Unlike the Arm handler, we can't do this as a tail call 16472 * because rIBASE is caller save and we need to reload it. 16473 */ 16474 movl rSELF, %eax 16475 movl rPC, OUT_ARG0(%esp) 16476 movl %eax, OUT_ARG1(%esp) 16477 call dvmCheckInst # (dPC, self) 16478 movl rSELF, %ecx 16479 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16480 jmp *dvmAsmInstructionStart+(292*4) 16481 16482/* ------------------------------ */ 16483.L_ALT_OP_INVOKE_STATIC_JUMBO: /* 0x125 */ 16484/* File: x86/alt_stub.S */ 16485/* 16486 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16487 * any interesting requests and then jump to the real instruction 16488 * handler. Unlike the Arm handler, we can't do this as a tail call 16489 * because rIBASE is caller save and we need to reload it. 16490 */ 16491 movl rSELF, %eax 16492 movl rPC, OUT_ARG0(%esp) 16493 movl %eax, OUT_ARG1(%esp) 16494 call dvmCheckInst # (dPC, self) 16495 movl rSELF, %ecx 16496 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16497 jmp *dvmAsmInstructionStart+(293*4) 16498 16499/* ------------------------------ */ 16500.L_ALT_OP_INVOKE_INTERFACE_JUMBO: /* 0x126 */ 16501/* File: x86/alt_stub.S */ 16502/* 16503 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16504 * any interesting requests and then jump to the real instruction 16505 * handler. Unlike the Arm handler, we can't do this as a tail call 16506 * because rIBASE is caller save and we need to reload it. 16507 */ 16508 movl rSELF, %eax 16509 movl rPC, OUT_ARG0(%esp) 16510 movl %eax, OUT_ARG1(%esp) 16511 call dvmCheckInst # (dPC, self) 16512 movl rSELF, %ecx 16513 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16514 jmp *dvmAsmInstructionStart+(294*4) 16515 16516/* ------------------------------ */ 16517.L_ALT_OP_UNUSED_27FF: /* 0x127 */ 16518/* File: x86/alt_stub.S */ 16519/* 16520 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16521 * any interesting requests and then jump to the real instruction 16522 * handler. Unlike the Arm handler, we can't do this as a tail call 16523 * because rIBASE is caller save and we need to reload it. 16524 */ 16525 movl rSELF, %eax 16526 movl rPC, OUT_ARG0(%esp) 16527 movl %eax, OUT_ARG1(%esp) 16528 call dvmCheckInst # (dPC, self) 16529 movl rSELF, %ecx 16530 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16531 jmp *dvmAsmInstructionStart+(295*4) 16532 16533/* ------------------------------ */ 16534.L_ALT_OP_UNUSED_28FF: /* 0x128 */ 16535/* File: x86/alt_stub.S */ 16536/* 16537 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16538 * any interesting requests and then jump to the real instruction 16539 * handler. Unlike the Arm handler, we can't do this as a tail call 16540 * because rIBASE is caller save and we need to reload it. 16541 */ 16542 movl rSELF, %eax 16543 movl rPC, OUT_ARG0(%esp) 16544 movl %eax, OUT_ARG1(%esp) 16545 call dvmCheckInst # (dPC, self) 16546 movl rSELF, %ecx 16547 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16548 jmp *dvmAsmInstructionStart+(296*4) 16549 16550/* ------------------------------ */ 16551.L_ALT_OP_UNUSED_29FF: /* 0x129 */ 16552/* File: x86/alt_stub.S */ 16553/* 16554 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16555 * any interesting requests and then jump to the real instruction 16556 * handler. Unlike the Arm handler, we can't do this as a tail call 16557 * because rIBASE is caller save and we need to reload it. 16558 */ 16559 movl rSELF, %eax 16560 movl rPC, OUT_ARG0(%esp) 16561 movl %eax, OUT_ARG1(%esp) 16562 call dvmCheckInst # (dPC, self) 16563 movl rSELF, %ecx 16564 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16565 jmp *dvmAsmInstructionStart+(297*4) 16566 16567/* ------------------------------ */ 16568.L_ALT_OP_UNUSED_2AFF: /* 0x12a */ 16569/* File: x86/alt_stub.S */ 16570/* 16571 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16572 * any interesting requests and then jump to the real instruction 16573 * handler. Unlike the Arm handler, we can't do this as a tail call 16574 * because rIBASE is caller save and we need to reload it. 16575 */ 16576 movl rSELF, %eax 16577 movl rPC, OUT_ARG0(%esp) 16578 movl %eax, OUT_ARG1(%esp) 16579 call dvmCheckInst # (dPC, self) 16580 movl rSELF, %ecx 16581 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16582 jmp *dvmAsmInstructionStart+(298*4) 16583 16584/* ------------------------------ */ 16585.L_ALT_OP_UNUSED_2BFF: /* 0x12b */ 16586/* File: x86/alt_stub.S */ 16587/* 16588 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16589 * any interesting requests and then jump to the real instruction 16590 * handler. Unlike the Arm handler, we can't do this as a tail call 16591 * because rIBASE is caller save and we need to reload it. 16592 */ 16593 movl rSELF, %eax 16594 movl rPC, OUT_ARG0(%esp) 16595 movl %eax, OUT_ARG1(%esp) 16596 call dvmCheckInst # (dPC, self) 16597 movl rSELF, %ecx 16598 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16599 jmp *dvmAsmInstructionStart+(299*4) 16600 16601/* ------------------------------ */ 16602.L_ALT_OP_UNUSED_2CFF: /* 0x12c */ 16603/* File: x86/alt_stub.S */ 16604/* 16605 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16606 * any interesting requests and then jump to the real instruction 16607 * handler. Unlike the Arm handler, we can't do this as a tail call 16608 * because rIBASE is caller save and we need to reload it. 16609 */ 16610 movl rSELF, %eax 16611 movl rPC, OUT_ARG0(%esp) 16612 movl %eax, OUT_ARG1(%esp) 16613 call dvmCheckInst # (dPC, self) 16614 movl rSELF, %ecx 16615 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16616 jmp *dvmAsmInstructionStart+(300*4) 16617 16618/* ------------------------------ */ 16619.L_ALT_OP_UNUSED_2DFF: /* 0x12d */ 16620/* File: x86/alt_stub.S */ 16621/* 16622 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16623 * any interesting requests and then jump to the real instruction 16624 * handler. Unlike the Arm handler, we can't do this as a tail call 16625 * because rIBASE is caller save and we need to reload it. 16626 */ 16627 movl rSELF, %eax 16628 movl rPC, OUT_ARG0(%esp) 16629 movl %eax, OUT_ARG1(%esp) 16630 call dvmCheckInst # (dPC, self) 16631 movl rSELF, %ecx 16632 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16633 jmp *dvmAsmInstructionStart+(301*4) 16634 16635/* ------------------------------ */ 16636.L_ALT_OP_UNUSED_2EFF: /* 0x12e */ 16637/* File: x86/alt_stub.S */ 16638/* 16639 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16640 * any interesting requests and then jump to the real instruction 16641 * handler. Unlike the Arm handler, we can't do this as a tail call 16642 * because rIBASE is caller save and we need to reload it. 16643 */ 16644 movl rSELF, %eax 16645 movl rPC, OUT_ARG0(%esp) 16646 movl %eax, OUT_ARG1(%esp) 16647 call dvmCheckInst # (dPC, self) 16648 movl rSELF, %ecx 16649 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16650 jmp *dvmAsmInstructionStart+(302*4) 16651 16652/* ------------------------------ */ 16653.L_ALT_OP_UNUSED_2FFF: /* 0x12f */ 16654/* File: x86/alt_stub.S */ 16655/* 16656 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16657 * any interesting requests and then jump to the real instruction 16658 * handler. Unlike the Arm handler, we can't do this as a tail call 16659 * because rIBASE is caller save and we need to reload it. 16660 */ 16661 movl rSELF, %eax 16662 movl rPC, OUT_ARG0(%esp) 16663 movl %eax, OUT_ARG1(%esp) 16664 call dvmCheckInst # (dPC, self) 16665 movl rSELF, %ecx 16666 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16667 jmp *dvmAsmInstructionStart+(303*4) 16668 16669/* ------------------------------ */ 16670.L_ALT_OP_UNUSED_30FF: /* 0x130 */ 16671/* File: x86/alt_stub.S */ 16672/* 16673 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16674 * any interesting requests and then jump to the real instruction 16675 * handler. Unlike the Arm handler, we can't do this as a tail call 16676 * because rIBASE is caller save and we need to reload it. 16677 */ 16678 movl rSELF, %eax 16679 movl rPC, OUT_ARG0(%esp) 16680 movl %eax, OUT_ARG1(%esp) 16681 call dvmCheckInst # (dPC, self) 16682 movl rSELF, %ecx 16683 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16684 jmp *dvmAsmInstructionStart+(304*4) 16685 16686/* ------------------------------ */ 16687.L_ALT_OP_UNUSED_31FF: /* 0x131 */ 16688/* File: x86/alt_stub.S */ 16689/* 16690 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16691 * any interesting requests and then jump to the real instruction 16692 * handler. Unlike the Arm handler, we can't do this as a tail call 16693 * because rIBASE is caller save and we need to reload it. 16694 */ 16695 movl rSELF, %eax 16696 movl rPC, OUT_ARG0(%esp) 16697 movl %eax, OUT_ARG1(%esp) 16698 call dvmCheckInst # (dPC, self) 16699 movl rSELF, %ecx 16700 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16701 jmp *dvmAsmInstructionStart+(305*4) 16702 16703/* ------------------------------ */ 16704.L_ALT_OP_UNUSED_32FF: /* 0x132 */ 16705/* File: x86/alt_stub.S */ 16706/* 16707 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16708 * any interesting requests and then jump to the real instruction 16709 * handler. Unlike the Arm handler, we can't do this as a tail call 16710 * because rIBASE is caller save and we need to reload it. 16711 */ 16712 movl rSELF, %eax 16713 movl rPC, OUT_ARG0(%esp) 16714 movl %eax, OUT_ARG1(%esp) 16715 call dvmCheckInst # (dPC, self) 16716 movl rSELF, %ecx 16717 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16718 jmp *dvmAsmInstructionStart+(306*4) 16719 16720/* ------------------------------ */ 16721.L_ALT_OP_UNUSED_33FF: /* 0x133 */ 16722/* File: x86/alt_stub.S */ 16723/* 16724 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16725 * any interesting requests and then jump to the real instruction 16726 * handler. Unlike the Arm handler, we can't do this as a tail call 16727 * because rIBASE is caller save and we need to reload it. 16728 */ 16729 movl rSELF, %eax 16730 movl rPC, OUT_ARG0(%esp) 16731 movl %eax, OUT_ARG1(%esp) 16732 call dvmCheckInst # (dPC, self) 16733 movl rSELF, %ecx 16734 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16735 jmp *dvmAsmInstructionStart+(307*4) 16736 16737/* ------------------------------ */ 16738.L_ALT_OP_UNUSED_34FF: /* 0x134 */ 16739/* File: x86/alt_stub.S */ 16740/* 16741 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16742 * any interesting requests and then jump to the real instruction 16743 * handler. Unlike the Arm handler, we can't do this as a tail call 16744 * because rIBASE is caller save and we need to reload it. 16745 */ 16746 movl rSELF, %eax 16747 movl rPC, OUT_ARG0(%esp) 16748 movl %eax, OUT_ARG1(%esp) 16749 call dvmCheckInst # (dPC, self) 16750 movl rSELF, %ecx 16751 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16752 jmp *dvmAsmInstructionStart+(308*4) 16753 16754/* ------------------------------ */ 16755.L_ALT_OP_UNUSED_35FF: /* 0x135 */ 16756/* File: x86/alt_stub.S */ 16757/* 16758 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16759 * any interesting requests and then jump to the real instruction 16760 * handler. Unlike the Arm handler, we can't do this as a tail call 16761 * because rIBASE is caller save and we need to reload it. 16762 */ 16763 movl rSELF, %eax 16764 movl rPC, OUT_ARG0(%esp) 16765 movl %eax, OUT_ARG1(%esp) 16766 call dvmCheckInst # (dPC, self) 16767 movl rSELF, %ecx 16768 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16769 jmp *dvmAsmInstructionStart+(309*4) 16770 16771/* ------------------------------ */ 16772.L_ALT_OP_UNUSED_36FF: /* 0x136 */ 16773/* File: x86/alt_stub.S */ 16774/* 16775 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16776 * any interesting requests and then jump to the real instruction 16777 * handler. Unlike the Arm handler, we can't do this as a tail call 16778 * because rIBASE is caller save and we need to reload it. 16779 */ 16780 movl rSELF, %eax 16781 movl rPC, OUT_ARG0(%esp) 16782 movl %eax, OUT_ARG1(%esp) 16783 call dvmCheckInst # (dPC, self) 16784 movl rSELF, %ecx 16785 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16786 jmp *dvmAsmInstructionStart+(310*4) 16787 16788/* ------------------------------ */ 16789.L_ALT_OP_UNUSED_37FF: /* 0x137 */ 16790/* File: x86/alt_stub.S */ 16791/* 16792 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16793 * any interesting requests and then jump to the real instruction 16794 * handler. Unlike the Arm handler, we can't do this as a tail call 16795 * because rIBASE is caller save and we need to reload it. 16796 */ 16797 movl rSELF, %eax 16798 movl rPC, OUT_ARG0(%esp) 16799 movl %eax, OUT_ARG1(%esp) 16800 call dvmCheckInst # (dPC, self) 16801 movl rSELF, %ecx 16802 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16803 jmp *dvmAsmInstructionStart+(311*4) 16804 16805/* ------------------------------ */ 16806.L_ALT_OP_UNUSED_38FF: /* 0x138 */ 16807/* File: x86/alt_stub.S */ 16808/* 16809 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16810 * any interesting requests and then jump to the real instruction 16811 * handler. Unlike the Arm handler, we can't do this as a tail call 16812 * because rIBASE is caller save and we need to reload it. 16813 */ 16814 movl rSELF, %eax 16815 movl rPC, OUT_ARG0(%esp) 16816 movl %eax, OUT_ARG1(%esp) 16817 call dvmCheckInst # (dPC, self) 16818 movl rSELF, %ecx 16819 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16820 jmp *dvmAsmInstructionStart+(312*4) 16821 16822/* ------------------------------ */ 16823.L_ALT_OP_UNUSED_39FF: /* 0x139 */ 16824/* File: x86/alt_stub.S */ 16825/* 16826 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16827 * any interesting requests and then jump to the real instruction 16828 * handler. Unlike the Arm handler, we can't do this as a tail call 16829 * because rIBASE is caller save and we need to reload it. 16830 */ 16831 movl rSELF, %eax 16832 movl rPC, OUT_ARG0(%esp) 16833 movl %eax, OUT_ARG1(%esp) 16834 call dvmCheckInst # (dPC, self) 16835 movl rSELF, %ecx 16836 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16837 jmp *dvmAsmInstructionStart+(313*4) 16838 16839/* ------------------------------ */ 16840.L_ALT_OP_UNUSED_3AFF: /* 0x13a */ 16841/* File: x86/alt_stub.S */ 16842/* 16843 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16844 * any interesting requests and then jump to the real instruction 16845 * handler. Unlike the Arm handler, we can't do this as a tail call 16846 * because rIBASE is caller save and we need to reload it. 16847 */ 16848 movl rSELF, %eax 16849 movl rPC, OUT_ARG0(%esp) 16850 movl %eax, OUT_ARG1(%esp) 16851 call dvmCheckInst # (dPC, self) 16852 movl rSELF, %ecx 16853 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16854 jmp *dvmAsmInstructionStart+(314*4) 16855 16856/* ------------------------------ */ 16857.L_ALT_OP_UNUSED_3BFF: /* 0x13b */ 16858/* File: x86/alt_stub.S */ 16859/* 16860 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16861 * any interesting requests and then jump to the real instruction 16862 * handler. Unlike the Arm handler, we can't do this as a tail call 16863 * because rIBASE is caller save and we need to reload it. 16864 */ 16865 movl rSELF, %eax 16866 movl rPC, OUT_ARG0(%esp) 16867 movl %eax, OUT_ARG1(%esp) 16868 call dvmCheckInst # (dPC, self) 16869 movl rSELF, %ecx 16870 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16871 jmp *dvmAsmInstructionStart+(315*4) 16872 16873/* ------------------------------ */ 16874.L_ALT_OP_UNUSED_3CFF: /* 0x13c */ 16875/* File: x86/alt_stub.S */ 16876/* 16877 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16878 * any interesting requests and then jump to the real instruction 16879 * handler. Unlike the Arm handler, we can't do this as a tail call 16880 * because rIBASE is caller save and we need to reload it. 16881 */ 16882 movl rSELF, %eax 16883 movl rPC, OUT_ARG0(%esp) 16884 movl %eax, OUT_ARG1(%esp) 16885 call dvmCheckInst # (dPC, self) 16886 movl rSELF, %ecx 16887 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16888 jmp *dvmAsmInstructionStart+(316*4) 16889 16890/* ------------------------------ */ 16891.L_ALT_OP_UNUSED_3DFF: /* 0x13d */ 16892/* File: x86/alt_stub.S */ 16893/* 16894 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16895 * any interesting requests and then jump to the real instruction 16896 * handler. Unlike the Arm handler, we can't do this as a tail call 16897 * because rIBASE is caller save and we need to reload it. 16898 */ 16899 movl rSELF, %eax 16900 movl rPC, OUT_ARG0(%esp) 16901 movl %eax, OUT_ARG1(%esp) 16902 call dvmCheckInst # (dPC, self) 16903 movl rSELF, %ecx 16904 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16905 jmp *dvmAsmInstructionStart+(317*4) 16906 16907/* ------------------------------ */ 16908.L_ALT_OP_UNUSED_3EFF: /* 0x13e */ 16909/* File: x86/alt_stub.S */ 16910/* 16911 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16912 * any interesting requests and then jump to the real instruction 16913 * handler. Unlike the Arm handler, we can't do this as a tail call 16914 * because rIBASE is caller save and we need to reload it. 16915 */ 16916 movl rSELF, %eax 16917 movl rPC, OUT_ARG0(%esp) 16918 movl %eax, OUT_ARG1(%esp) 16919 call dvmCheckInst # (dPC, self) 16920 movl rSELF, %ecx 16921 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16922 jmp *dvmAsmInstructionStart+(318*4) 16923 16924/* ------------------------------ */ 16925.L_ALT_OP_UNUSED_3FFF: /* 0x13f */ 16926/* File: x86/alt_stub.S */ 16927/* 16928 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16929 * any interesting requests and then jump to the real instruction 16930 * handler. Unlike the Arm handler, we can't do this as a tail call 16931 * because rIBASE is caller save and we need to reload it. 16932 */ 16933 movl rSELF, %eax 16934 movl rPC, OUT_ARG0(%esp) 16935 movl %eax, OUT_ARG1(%esp) 16936 call dvmCheckInst # (dPC, self) 16937 movl rSELF, %ecx 16938 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16939 jmp *dvmAsmInstructionStart+(319*4) 16940 16941/* ------------------------------ */ 16942.L_ALT_OP_UNUSED_40FF: /* 0x140 */ 16943/* File: x86/alt_stub.S */ 16944/* 16945 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16946 * any interesting requests and then jump to the real instruction 16947 * handler. Unlike the Arm handler, we can't do this as a tail call 16948 * because rIBASE is caller save and we need to reload it. 16949 */ 16950 movl rSELF, %eax 16951 movl rPC, OUT_ARG0(%esp) 16952 movl %eax, OUT_ARG1(%esp) 16953 call dvmCheckInst # (dPC, self) 16954 movl rSELF, %ecx 16955 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16956 jmp *dvmAsmInstructionStart+(320*4) 16957 16958/* ------------------------------ */ 16959.L_ALT_OP_UNUSED_41FF: /* 0x141 */ 16960/* File: x86/alt_stub.S */ 16961/* 16962 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16963 * any interesting requests and then jump to the real instruction 16964 * handler. Unlike the Arm handler, we can't do this as a tail call 16965 * because rIBASE is caller save and we need to reload it. 16966 */ 16967 movl rSELF, %eax 16968 movl rPC, OUT_ARG0(%esp) 16969 movl %eax, OUT_ARG1(%esp) 16970 call dvmCheckInst # (dPC, self) 16971 movl rSELF, %ecx 16972 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16973 jmp *dvmAsmInstructionStart+(321*4) 16974 16975/* ------------------------------ */ 16976.L_ALT_OP_UNUSED_42FF: /* 0x142 */ 16977/* File: x86/alt_stub.S */ 16978/* 16979 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16980 * any interesting requests and then jump to the real instruction 16981 * handler. Unlike the Arm handler, we can't do this as a tail call 16982 * because rIBASE is caller save and we need to reload it. 16983 */ 16984 movl rSELF, %eax 16985 movl rPC, OUT_ARG0(%esp) 16986 movl %eax, OUT_ARG1(%esp) 16987 call dvmCheckInst # (dPC, self) 16988 movl rSELF, %ecx 16989 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16990 jmp *dvmAsmInstructionStart+(322*4) 16991 16992/* ------------------------------ */ 16993.L_ALT_OP_UNUSED_43FF: /* 0x143 */ 16994/* File: x86/alt_stub.S */ 16995/* 16996 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16997 * any interesting requests and then jump to the real instruction 16998 * handler. Unlike the Arm handler, we can't do this as a tail call 16999 * because rIBASE is caller save and we need to reload it. 17000 */ 17001 movl rSELF, %eax 17002 movl rPC, OUT_ARG0(%esp) 17003 movl %eax, OUT_ARG1(%esp) 17004 call dvmCheckInst # (dPC, self) 17005 movl rSELF, %ecx 17006 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17007 jmp *dvmAsmInstructionStart+(323*4) 17008 17009/* ------------------------------ */ 17010.L_ALT_OP_UNUSED_44FF: /* 0x144 */ 17011/* File: x86/alt_stub.S */ 17012/* 17013 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17014 * any interesting requests and then jump to the real instruction 17015 * handler. Unlike the Arm handler, we can't do this as a tail call 17016 * because rIBASE is caller save and we need to reload it. 17017 */ 17018 movl rSELF, %eax 17019 movl rPC, OUT_ARG0(%esp) 17020 movl %eax, OUT_ARG1(%esp) 17021 call dvmCheckInst # (dPC, self) 17022 movl rSELF, %ecx 17023 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17024 jmp *dvmAsmInstructionStart+(324*4) 17025 17026/* ------------------------------ */ 17027.L_ALT_OP_UNUSED_45FF: /* 0x145 */ 17028/* File: x86/alt_stub.S */ 17029/* 17030 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17031 * any interesting requests and then jump to the real instruction 17032 * handler. Unlike the Arm handler, we can't do this as a tail call 17033 * because rIBASE is caller save and we need to reload it. 17034 */ 17035 movl rSELF, %eax 17036 movl rPC, OUT_ARG0(%esp) 17037 movl %eax, OUT_ARG1(%esp) 17038 call dvmCheckInst # (dPC, self) 17039 movl rSELF, %ecx 17040 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17041 jmp *dvmAsmInstructionStart+(325*4) 17042 17043/* ------------------------------ */ 17044.L_ALT_OP_UNUSED_46FF: /* 0x146 */ 17045/* File: x86/alt_stub.S */ 17046/* 17047 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17048 * any interesting requests and then jump to the real instruction 17049 * handler. Unlike the Arm handler, we can't do this as a tail call 17050 * because rIBASE is caller save and we need to reload it. 17051 */ 17052 movl rSELF, %eax 17053 movl rPC, OUT_ARG0(%esp) 17054 movl %eax, OUT_ARG1(%esp) 17055 call dvmCheckInst # (dPC, self) 17056 movl rSELF, %ecx 17057 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17058 jmp *dvmAsmInstructionStart+(326*4) 17059 17060/* ------------------------------ */ 17061.L_ALT_OP_UNUSED_47FF: /* 0x147 */ 17062/* File: x86/alt_stub.S */ 17063/* 17064 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17065 * any interesting requests and then jump to the real instruction 17066 * handler. Unlike the Arm handler, we can't do this as a tail call 17067 * because rIBASE is caller save and we need to reload it. 17068 */ 17069 movl rSELF, %eax 17070 movl rPC, OUT_ARG0(%esp) 17071 movl %eax, OUT_ARG1(%esp) 17072 call dvmCheckInst # (dPC, self) 17073 movl rSELF, %ecx 17074 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17075 jmp *dvmAsmInstructionStart+(327*4) 17076 17077/* ------------------------------ */ 17078.L_ALT_OP_UNUSED_48FF: /* 0x148 */ 17079/* File: x86/alt_stub.S */ 17080/* 17081 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17082 * any interesting requests and then jump to the real instruction 17083 * handler. Unlike the Arm handler, we can't do this as a tail call 17084 * because rIBASE is caller save and we need to reload it. 17085 */ 17086 movl rSELF, %eax 17087 movl rPC, OUT_ARG0(%esp) 17088 movl %eax, OUT_ARG1(%esp) 17089 call dvmCheckInst # (dPC, self) 17090 movl rSELF, %ecx 17091 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17092 jmp *dvmAsmInstructionStart+(328*4) 17093 17094/* ------------------------------ */ 17095.L_ALT_OP_UNUSED_49FF: /* 0x149 */ 17096/* File: x86/alt_stub.S */ 17097/* 17098 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17099 * any interesting requests and then jump to the real instruction 17100 * handler. Unlike the Arm handler, we can't do this as a tail call 17101 * because rIBASE is caller save and we need to reload it. 17102 */ 17103 movl rSELF, %eax 17104 movl rPC, OUT_ARG0(%esp) 17105 movl %eax, OUT_ARG1(%esp) 17106 call dvmCheckInst # (dPC, self) 17107 movl rSELF, %ecx 17108 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17109 jmp *dvmAsmInstructionStart+(329*4) 17110 17111/* ------------------------------ */ 17112.L_ALT_OP_UNUSED_4AFF: /* 0x14a */ 17113/* File: x86/alt_stub.S */ 17114/* 17115 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17116 * any interesting requests and then jump to the real instruction 17117 * handler. Unlike the Arm handler, we can't do this as a tail call 17118 * because rIBASE is caller save and we need to reload it. 17119 */ 17120 movl rSELF, %eax 17121 movl rPC, OUT_ARG0(%esp) 17122 movl %eax, OUT_ARG1(%esp) 17123 call dvmCheckInst # (dPC, self) 17124 movl rSELF, %ecx 17125 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17126 jmp *dvmAsmInstructionStart+(330*4) 17127 17128/* ------------------------------ */ 17129.L_ALT_OP_UNUSED_4BFF: /* 0x14b */ 17130/* File: x86/alt_stub.S */ 17131/* 17132 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17133 * any interesting requests and then jump to the real instruction 17134 * handler. Unlike the Arm handler, we can't do this as a tail call 17135 * because rIBASE is caller save and we need to reload it. 17136 */ 17137 movl rSELF, %eax 17138 movl rPC, OUT_ARG0(%esp) 17139 movl %eax, OUT_ARG1(%esp) 17140 call dvmCheckInst # (dPC, self) 17141 movl rSELF, %ecx 17142 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17143 jmp *dvmAsmInstructionStart+(331*4) 17144 17145/* ------------------------------ */ 17146.L_ALT_OP_UNUSED_4CFF: /* 0x14c */ 17147/* File: x86/alt_stub.S */ 17148/* 17149 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17150 * any interesting requests and then jump to the real instruction 17151 * handler. Unlike the Arm handler, we can't do this as a tail call 17152 * because rIBASE is caller save and we need to reload it. 17153 */ 17154 movl rSELF, %eax 17155 movl rPC, OUT_ARG0(%esp) 17156 movl %eax, OUT_ARG1(%esp) 17157 call dvmCheckInst # (dPC, self) 17158 movl rSELF, %ecx 17159 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17160 jmp *dvmAsmInstructionStart+(332*4) 17161 17162/* ------------------------------ */ 17163.L_ALT_OP_UNUSED_4DFF: /* 0x14d */ 17164/* File: x86/alt_stub.S */ 17165/* 17166 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17167 * any interesting requests and then jump to the real instruction 17168 * handler. Unlike the Arm handler, we can't do this as a tail call 17169 * because rIBASE is caller save and we need to reload it. 17170 */ 17171 movl rSELF, %eax 17172 movl rPC, OUT_ARG0(%esp) 17173 movl %eax, OUT_ARG1(%esp) 17174 call dvmCheckInst # (dPC, self) 17175 movl rSELF, %ecx 17176 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17177 jmp *dvmAsmInstructionStart+(333*4) 17178 17179/* ------------------------------ */ 17180.L_ALT_OP_UNUSED_4EFF: /* 0x14e */ 17181/* File: x86/alt_stub.S */ 17182/* 17183 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17184 * any interesting requests and then jump to the real instruction 17185 * handler. Unlike the Arm handler, we can't do this as a tail call 17186 * because rIBASE is caller save and we need to reload it. 17187 */ 17188 movl rSELF, %eax 17189 movl rPC, OUT_ARG0(%esp) 17190 movl %eax, OUT_ARG1(%esp) 17191 call dvmCheckInst # (dPC, self) 17192 movl rSELF, %ecx 17193 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17194 jmp *dvmAsmInstructionStart+(334*4) 17195 17196/* ------------------------------ */ 17197.L_ALT_OP_UNUSED_4FFF: /* 0x14f */ 17198/* File: x86/alt_stub.S */ 17199/* 17200 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17201 * any interesting requests and then jump to the real instruction 17202 * handler. Unlike the Arm handler, we can't do this as a tail call 17203 * because rIBASE is caller save and we need to reload it. 17204 */ 17205 movl rSELF, %eax 17206 movl rPC, OUT_ARG0(%esp) 17207 movl %eax, OUT_ARG1(%esp) 17208 call dvmCheckInst # (dPC, self) 17209 movl rSELF, %ecx 17210 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17211 jmp *dvmAsmInstructionStart+(335*4) 17212 17213/* ------------------------------ */ 17214.L_ALT_OP_UNUSED_50FF: /* 0x150 */ 17215/* File: x86/alt_stub.S */ 17216/* 17217 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17218 * any interesting requests and then jump to the real instruction 17219 * handler. Unlike the Arm handler, we can't do this as a tail call 17220 * because rIBASE is caller save and we need to reload it. 17221 */ 17222 movl rSELF, %eax 17223 movl rPC, OUT_ARG0(%esp) 17224 movl %eax, OUT_ARG1(%esp) 17225 call dvmCheckInst # (dPC, self) 17226 movl rSELF, %ecx 17227 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17228 jmp *dvmAsmInstructionStart+(336*4) 17229 17230/* ------------------------------ */ 17231.L_ALT_OP_UNUSED_51FF: /* 0x151 */ 17232/* File: x86/alt_stub.S */ 17233/* 17234 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17235 * any interesting requests and then jump to the real instruction 17236 * handler. Unlike the Arm handler, we can't do this as a tail call 17237 * because rIBASE is caller save and we need to reload it. 17238 */ 17239 movl rSELF, %eax 17240 movl rPC, OUT_ARG0(%esp) 17241 movl %eax, OUT_ARG1(%esp) 17242 call dvmCheckInst # (dPC, self) 17243 movl rSELF, %ecx 17244 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17245 jmp *dvmAsmInstructionStart+(337*4) 17246 17247/* ------------------------------ */ 17248.L_ALT_OP_UNUSED_52FF: /* 0x152 */ 17249/* File: x86/alt_stub.S */ 17250/* 17251 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17252 * any interesting requests and then jump to the real instruction 17253 * handler. Unlike the Arm handler, we can't do this as a tail call 17254 * because rIBASE is caller save and we need to reload it. 17255 */ 17256 movl rSELF, %eax 17257 movl rPC, OUT_ARG0(%esp) 17258 movl %eax, OUT_ARG1(%esp) 17259 call dvmCheckInst # (dPC, self) 17260 movl rSELF, %ecx 17261 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17262 jmp *dvmAsmInstructionStart+(338*4) 17263 17264/* ------------------------------ */ 17265.L_ALT_OP_UNUSED_53FF: /* 0x153 */ 17266/* File: x86/alt_stub.S */ 17267/* 17268 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17269 * any interesting requests and then jump to the real instruction 17270 * handler. Unlike the Arm handler, we can't do this as a tail call 17271 * because rIBASE is caller save and we need to reload it. 17272 */ 17273 movl rSELF, %eax 17274 movl rPC, OUT_ARG0(%esp) 17275 movl %eax, OUT_ARG1(%esp) 17276 call dvmCheckInst # (dPC, self) 17277 movl rSELF, %ecx 17278 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17279 jmp *dvmAsmInstructionStart+(339*4) 17280 17281/* ------------------------------ */ 17282.L_ALT_OP_UNUSED_54FF: /* 0x154 */ 17283/* File: x86/alt_stub.S */ 17284/* 17285 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17286 * any interesting requests and then jump to the real instruction 17287 * handler. Unlike the Arm handler, we can't do this as a tail call 17288 * because rIBASE is caller save and we need to reload it. 17289 */ 17290 movl rSELF, %eax 17291 movl rPC, OUT_ARG0(%esp) 17292 movl %eax, OUT_ARG1(%esp) 17293 call dvmCheckInst # (dPC, self) 17294 movl rSELF, %ecx 17295 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17296 jmp *dvmAsmInstructionStart+(340*4) 17297 17298/* ------------------------------ */ 17299.L_ALT_OP_UNUSED_55FF: /* 0x155 */ 17300/* File: x86/alt_stub.S */ 17301/* 17302 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17303 * any interesting requests and then jump to the real instruction 17304 * handler. Unlike the Arm handler, we can't do this as a tail call 17305 * because rIBASE is caller save and we need to reload it. 17306 */ 17307 movl rSELF, %eax 17308 movl rPC, OUT_ARG0(%esp) 17309 movl %eax, OUT_ARG1(%esp) 17310 call dvmCheckInst # (dPC, self) 17311 movl rSELF, %ecx 17312 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17313 jmp *dvmAsmInstructionStart+(341*4) 17314 17315/* ------------------------------ */ 17316.L_ALT_OP_UNUSED_56FF: /* 0x156 */ 17317/* File: x86/alt_stub.S */ 17318/* 17319 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17320 * any interesting requests and then jump to the real instruction 17321 * handler. Unlike the Arm handler, we can't do this as a tail call 17322 * because rIBASE is caller save and we need to reload it. 17323 */ 17324 movl rSELF, %eax 17325 movl rPC, OUT_ARG0(%esp) 17326 movl %eax, OUT_ARG1(%esp) 17327 call dvmCheckInst # (dPC, self) 17328 movl rSELF, %ecx 17329 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17330 jmp *dvmAsmInstructionStart+(342*4) 17331 17332/* ------------------------------ */ 17333.L_ALT_OP_UNUSED_57FF: /* 0x157 */ 17334/* File: x86/alt_stub.S */ 17335/* 17336 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17337 * any interesting requests and then jump to the real instruction 17338 * handler. Unlike the Arm handler, we can't do this as a tail call 17339 * because rIBASE is caller save and we need to reload it. 17340 */ 17341 movl rSELF, %eax 17342 movl rPC, OUT_ARG0(%esp) 17343 movl %eax, OUT_ARG1(%esp) 17344 call dvmCheckInst # (dPC, self) 17345 movl rSELF, %ecx 17346 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17347 jmp *dvmAsmInstructionStart+(343*4) 17348 17349/* ------------------------------ */ 17350.L_ALT_OP_UNUSED_58FF: /* 0x158 */ 17351/* File: x86/alt_stub.S */ 17352/* 17353 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17354 * any interesting requests and then jump to the real instruction 17355 * handler. Unlike the Arm handler, we can't do this as a tail call 17356 * because rIBASE is caller save and we need to reload it. 17357 */ 17358 movl rSELF, %eax 17359 movl rPC, OUT_ARG0(%esp) 17360 movl %eax, OUT_ARG1(%esp) 17361 call dvmCheckInst # (dPC, self) 17362 movl rSELF, %ecx 17363 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17364 jmp *dvmAsmInstructionStart+(344*4) 17365 17366/* ------------------------------ */ 17367.L_ALT_OP_UNUSED_59FF: /* 0x159 */ 17368/* File: x86/alt_stub.S */ 17369/* 17370 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17371 * any interesting requests and then jump to the real instruction 17372 * handler. Unlike the Arm handler, we can't do this as a tail call 17373 * because rIBASE is caller save and we need to reload it. 17374 */ 17375 movl rSELF, %eax 17376 movl rPC, OUT_ARG0(%esp) 17377 movl %eax, OUT_ARG1(%esp) 17378 call dvmCheckInst # (dPC, self) 17379 movl rSELF, %ecx 17380 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17381 jmp *dvmAsmInstructionStart+(345*4) 17382 17383/* ------------------------------ */ 17384.L_ALT_OP_UNUSED_5AFF: /* 0x15a */ 17385/* File: x86/alt_stub.S */ 17386/* 17387 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17388 * any interesting requests and then jump to the real instruction 17389 * handler. Unlike the Arm handler, we can't do this as a tail call 17390 * because rIBASE is caller save and we need to reload it. 17391 */ 17392 movl rSELF, %eax 17393 movl rPC, OUT_ARG0(%esp) 17394 movl %eax, OUT_ARG1(%esp) 17395 call dvmCheckInst # (dPC, self) 17396 movl rSELF, %ecx 17397 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17398 jmp *dvmAsmInstructionStart+(346*4) 17399 17400/* ------------------------------ */ 17401.L_ALT_OP_UNUSED_5BFF: /* 0x15b */ 17402/* File: x86/alt_stub.S */ 17403/* 17404 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17405 * any interesting requests and then jump to the real instruction 17406 * handler. Unlike the Arm handler, we can't do this as a tail call 17407 * because rIBASE is caller save and we need to reload it. 17408 */ 17409 movl rSELF, %eax 17410 movl rPC, OUT_ARG0(%esp) 17411 movl %eax, OUT_ARG1(%esp) 17412 call dvmCheckInst # (dPC, self) 17413 movl rSELF, %ecx 17414 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17415 jmp *dvmAsmInstructionStart+(347*4) 17416 17417/* ------------------------------ */ 17418.L_ALT_OP_UNUSED_5CFF: /* 0x15c */ 17419/* File: x86/alt_stub.S */ 17420/* 17421 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17422 * any interesting requests and then jump to the real instruction 17423 * handler. Unlike the Arm handler, we can't do this as a tail call 17424 * because rIBASE is caller save and we need to reload it. 17425 */ 17426 movl rSELF, %eax 17427 movl rPC, OUT_ARG0(%esp) 17428 movl %eax, OUT_ARG1(%esp) 17429 call dvmCheckInst # (dPC, self) 17430 movl rSELF, %ecx 17431 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17432 jmp *dvmAsmInstructionStart+(348*4) 17433 17434/* ------------------------------ */ 17435.L_ALT_OP_UNUSED_5DFF: /* 0x15d */ 17436/* File: x86/alt_stub.S */ 17437/* 17438 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17439 * any interesting requests and then jump to the real instruction 17440 * handler. Unlike the Arm handler, we can't do this as a tail call 17441 * because rIBASE is caller save and we need to reload it. 17442 */ 17443 movl rSELF, %eax 17444 movl rPC, OUT_ARG0(%esp) 17445 movl %eax, OUT_ARG1(%esp) 17446 call dvmCheckInst # (dPC, self) 17447 movl rSELF, %ecx 17448 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17449 jmp *dvmAsmInstructionStart+(349*4) 17450 17451/* ------------------------------ */ 17452.L_ALT_OP_UNUSED_5EFF: /* 0x15e */ 17453/* File: x86/alt_stub.S */ 17454/* 17455 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17456 * any interesting requests and then jump to the real instruction 17457 * handler. Unlike the Arm handler, we can't do this as a tail call 17458 * because rIBASE is caller save and we need to reload it. 17459 */ 17460 movl rSELF, %eax 17461 movl rPC, OUT_ARG0(%esp) 17462 movl %eax, OUT_ARG1(%esp) 17463 call dvmCheckInst # (dPC, self) 17464 movl rSELF, %ecx 17465 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17466 jmp *dvmAsmInstructionStart+(350*4) 17467 17468/* ------------------------------ */ 17469.L_ALT_OP_UNUSED_5FFF: /* 0x15f */ 17470/* File: x86/alt_stub.S */ 17471/* 17472 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17473 * any interesting requests and then jump to the real instruction 17474 * handler. Unlike the Arm handler, we can't do this as a tail call 17475 * because rIBASE is caller save and we need to reload it. 17476 */ 17477 movl rSELF, %eax 17478 movl rPC, OUT_ARG0(%esp) 17479 movl %eax, OUT_ARG1(%esp) 17480 call dvmCheckInst # (dPC, self) 17481 movl rSELF, %ecx 17482 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17483 jmp *dvmAsmInstructionStart+(351*4) 17484 17485/* ------------------------------ */ 17486.L_ALT_OP_UNUSED_60FF: /* 0x160 */ 17487/* File: x86/alt_stub.S */ 17488/* 17489 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17490 * any interesting requests and then jump to the real instruction 17491 * handler. Unlike the Arm handler, we can't do this as a tail call 17492 * because rIBASE is caller save and we need to reload it. 17493 */ 17494 movl rSELF, %eax 17495 movl rPC, OUT_ARG0(%esp) 17496 movl %eax, OUT_ARG1(%esp) 17497 call dvmCheckInst # (dPC, self) 17498 movl rSELF, %ecx 17499 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17500 jmp *dvmAsmInstructionStart+(352*4) 17501 17502/* ------------------------------ */ 17503.L_ALT_OP_UNUSED_61FF: /* 0x161 */ 17504/* File: x86/alt_stub.S */ 17505/* 17506 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17507 * any interesting requests and then jump to the real instruction 17508 * handler. Unlike the Arm handler, we can't do this as a tail call 17509 * because rIBASE is caller save and we need to reload it. 17510 */ 17511 movl rSELF, %eax 17512 movl rPC, OUT_ARG0(%esp) 17513 movl %eax, OUT_ARG1(%esp) 17514 call dvmCheckInst # (dPC, self) 17515 movl rSELF, %ecx 17516 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17517 jmp *dvmAsmInstructionStart+(353*4) 17518 17519/* ------------------------------ */ 17520.L_ALT_OP_UNUSED_62FF: /* 0x162 */ 17521/* File: x86/alt_stub.S */ 17522/* 17523 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17524 * any interesting requests and then jump to the real instruction 17525 * handler. Unlike the Arm handler, we can't do this as a tail call 17526 * because rIBASE is caller save and we need to reload it. 17527 */ 17528 movl rSELF, %eax 17529 movl rPC, OUT_ARG0(%esp) 17530 movl %eax, OUT_ARG1(%esp) 17531 call dvmCheckInst # (dPC, self) 17532 movl rSELF, %ecx 17533 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17534 jmp *dvmAsmInstructionStart+(354*4) 17535 17536/* ------------------------------ */ 17537.L_ALT_OP_UNUSED_63FF: /* 0x163 */ 17538/* File: x86/alt_stub.S */ 17539/* 17540 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17541 * any interesting requests and then jump to the real instruction 17542 * handler. Unlike the Arm handler, we can't do this as a tail call 17543 * because rIBASE is caller save and we need to reload it. 17544 */ 17545 movl rSELF, %eax 17546 movl rPC, OUT_ARG0(%esp) 17547 movl %eax, OUT_ARG1(%esp) 17548 call dvmCheckInst # (dPC, self) 17549 movl rSELF, %ecx 17550 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17551 jmp *dvmAsmInstructionStart+(355*4) 17552 17553/* ------------------------------ */ 17554.L_ALT_OP_UNUSED_64FF: /* 0x164 */ 17555/* File: x86/alt_stub.S */ 17556/* 17557 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17558 * any interesting requests and then jump to the real instruction 17559 * handler. Unlike the Arm handler, we can't do this as a tail call 17560 * because rIBASE is caller save and we need to reload it. 17561 */ 17562 movl rSELF, %eax 17563 movl rPC, OUT_ARG0(%esp) 17564 movl %eax, OUT_ARG1(%esp) 17565 call dvmCheckInst # (dPC, self) 17566 movl rSELF, %ecx 17567 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17568 jmp *dvmAsmInstructionStart+(356*4) 17569 17570/* ------------------------------ */ 17571.L_ALT_OP_UNUSED_65FF: /* 0x165 */ 17572/* File: x86/alt_stub.S */ 17573/* 17574 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17575 * any interesting requests and then jump to the real instruction 17576 * handler. Unlike the Arm handler, we can't do this as a tail call 17577 * because rIBASE is caller save and we need to reload it. 17578 */ 17579 movl rSELF, %eax 17580 movl rPC, OUT_ARG0(%esp) 17581 movl %eax, OUT_ARG1(%esp) 17582 call dvmCheckInst # (dPC, self) 17583 movl rSELF, %ecx 17584 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17585 jmp *dvmAsmInstructionStart+(357*4) 17586 17587/* ------------------------------ */ 17588.L_ALT_OP_UNUSED_66FF: /* 0x166 */ 17589/* File: x86/alt_stub.S */ 17590/* 17591 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17592 * any interesting requests and then jump to the real instruction 17593 * handler. Unlike the Arm handler, we can't do this as a tail call 17594 * because rIBASE is caller save and we need to reload it. 17595 */ 17596 movl rSELF, %eax 17597 movl rPC, OUT_ARG0(%esp) 17598 movl %eax, OUT_ARG1(%esp) 17599 call dvmCheckInst # (dPC, self) 17600 movl rSELF, %ecx 17601 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17602 jmp *dvmAsmInstructionStart+(358*4) 17603 17604/* ------------------------------ */ 17605.L_ALT_OP_UNUSED_67FF: /* 0x167 */ 17606/* File: x86/alt_stub.S */ 17607/* 17608 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17609 * any interesting requests and then jump to the real instruction 17610 * handler. Unlike the Arm handler, we can't do this as a tail call 17611 * because rIBASE is caller save and we need to reload it. 17612 */ 17613 movl rSELF, %eax 17614 movl rPC, OUT_ARG0(%esp) 17615 movl %eax, OUT_ARG1(%esp) 17616 call dvmCheckInst # (dPC, self) 17617 movl rSELF, %ecx 17618 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17619 jmp *dvmAsmInstructionStart+(359*4) 17620 17621/* ------------------------------ */ 17622.L_ALT_OP_UNUSED_68FF: /* 0x168 */ 17623/* File: x86/alt_stub.S */ 17624/* 17625 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17626 * any interesting requests and then jump to the real instruction 17627 * handler. Unlike the Arm handler, we can't do this as a tail call 17628 * because rIBASE is caller save and we need to reload it. 17629 */ 17630 movl rSELF, %eax 17631 movl rPC, OUT_ARG0(%esp) 17632 movl %eax, OUT_ARG1(%esp) 17633 call dvmCheckInst # (dPC, self) 17634 movl rSELF, %ecx 17635 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17636 jmp *dvmAsmInstructionStart+(360*4) 17637 17638/* ------------------------------ */ 17639.L_ALT_OP_UNUSED_69FF: /* 0x169 */ 17640/* File: x86/alt_stub.S */ 17641/* 17642 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17643 * any interesting requests and then jump to the real instruction 17644 * handler. Unlike the Arm handler, we can't do this as a tail call 17645 * because rIBASE is caller save and we need to reload it. 17646 */ 17647 movl rSELF, %eax 17648 movl rPC, OUT_ARG0(%esp) 17649 movl %eax, OUT_ARG1(%esp) 17650 call dvmCheckInst # (dPC, self) 17651 movl rSELF, %ecx 17652 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17653 jmp *dvmAsmInstructionStart+(361*4) 17654 17655/* ------------------------------ */ 17656.L_ALT_OP_UNUSED_6AFF: /* 0x16a */ 17657/* File: x86/alt_stub.S */ 17658/* 17659 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17660 * any interesting requests and then jump to the real instruction 17661 * handler. Unlike the Arm handler, we can't do this as a tail call 17662 * because rIBASE is caller save and we need to reload it. 17663 */ 17664 movl rSELF, %eax 17665 movl rPC, OUT_ARG0(%esp) 17666 movl %eax, OUT_ARG1(%esp) 17667 call dvmCheckInst # (dPC, self) 17668 movl rSELF, %ecx 17669 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17670 jmp *dvmAsmInstructionStart+(362*4) 17671 17672/* ------------------------------ */ 17673.L_ALT_OP_UNUSED_6BFF: /* 0x16b */ 17674/* File: x86/alt_stub.S */ 17675/* 17676 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17677 * any interesting requests and then jump to the real instruction 17678 * handler. Unlike the Arm handler, we can't do this as a tail call 17679 * because rIBASE is caller save and we need to reload it. 17680 */ 17681 movl rSELF, %eax 17682 movl rPC, OUT_ARG0(%esp) 17683 movl %eax, OUT_ARG1(%esp) 17684 call dvmCheckInst # (dPC, self) 17685 movl rSELF, %ecx 17686 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17687 jmp *dvmAsmInstructionStart+(363*4) 17688 17689/* ------------------------------ */ 17690.L_ALT_OP_UNUSED_6CFF: /* 0x16c */ 17691/* File: x86/alt_stub.S */ 17692/* 17693 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17694 * any interesting requests and then jump to the real instruction 17695 * handler. Unlike the Arm handler, we can't do this as a tail call 17696 * because rIBASE is caller save and we need to reload it. 17697 */ 17698 movl rSELF, %eax 17699 movl rPC, OUT_ARG0(%esp) 17700 movl %eax, OUT_ARG1(%esp) 17701 call dvmCheckInst # (dPC, self) 17702 movl rSELF, %ecx 17703 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17704 jmp *dvmAsmInstructionStart+(364*4) 17705 17706/* ------------------------------ */ 17707.L_ALT_OP_UNUSED_6DFF: /* 0x16d */ 17708/* File: x86/alt_stub.S */ 17709/* 17710 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17711 * any interesting requests and then jump to the real instruction 17712 * handler. Unlike the Arm handler, we can't do this as a tail call 17713 * because rIBASE is caller save and we need to reload it. 17714 */ 17715 movl rSELF, %eax 17716 movl rPC, OUT_ARG0(%esp) 17717 movl %eax, OUT_ARG1(%esp) 17718 call dvmCheckInst # (dPC, self) 17719 movl rSELF, %ecx 17720 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17721 jmp *dvmAsmInstructionStart+(365*4) 17722 17723/* ------------------------------ */ 17724.L_ALT_OP_UNUSED_6EFF: /* 0x16e */ 17725/* File: x86/alt_stub.S */ 17726/* 17727 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17728 * any interesting requests and then jump to the real instruction 17729 * handler. Unlike the Arm handler, we can't do this as a tail call 17730 * because rIBASE is caller save and we need to reload it. 17731 */ 17732 movl rSELF, %eax 17733 movl rPC, OUT_ARG0(%esp) 17734 movl %eax, OUT_ARG1(%esp) 17735 call dvmCheckInst # (dPC, self) 17736 movl rSELF, %ecx 17737 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17738 jmp *dvmAsmInstructionStart+(366*4) 17739 17740/* ------------------------------ */ 17741.L_ALT_OP_UNUSED_6FFF: /* 0x16f */ 17742/* File: x86/alt_stub.S */ 17743/* 17744 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17745 * any interesting requests and then jump to the real instruction 17746 * handler. Unlike the Arm handler, we can't do this as a tail call 17747 * because rIBASE is caller save and we need to reload it. 17748 */ 17749 movl rSELF, %eax 17750 movl rPC, OUT_ARG0(%esp) 17751 movl %eax, OUT_ARG1(%esp) 17752 call dvmCheckInst # (dPC, self) 17753 movl rSELF, %ecx 17754 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17755 jmp *dvmAsmInstructionStart+(367*4) 17756 17757/* ------------------------------ */ 17758.L_ALT_OP_UNUSED_70FF: /* 0x170 */ 17759/* File: x86/alt_stub.S */ 17760/* 17761 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17762 * any interesting requests and then jump to the real instruction 17763 * handler. Unlike the Arm handler, we can't do this as a tail call 17764 * because rIBASE is caller save and we need to reload it. 17765 */ 17766 movl rSELF, %eax 17767 movl rPC, OUT_ARG0(%esp) 17768 movl %eax, OUT_ARG1(%esp) 17769 call dvmCheckInst # (dPC, self) 17770 movl rSELF, %ecx 17771 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17772 jmp *dvmAsmInstructionStart+(368*4) 17773 17774/* ------------------------------ */ 17775.L_ALT_OP_UNUSED_71FF: /* 0x171 */ 17776/* File: x86/alt_stub.S */ 17777/* 17778 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17779 * any interesting requests and then jump to the real instruction 17780 * handler. Unlike the Arm handler, we can't do this as a tail call 17781 * because rIBASE is caller save and we need to reload it. 17782 */ 17783 movl rSELF, %eax 17784 movl rPC, OUT_ARG0(%esp) 17785 movl %eax, OUT_ARG1(%esp) 17786 call dvmCheckInst # (dPC, self) 17787 movl rSELF, %ecx 17788 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17789 jmp *dvmAsmInstructionStart+(369*4) 17790 17791/* ------------------------------ */ 17792.L_ALT_OP_UNUSED_72FF: /* 0x172 */ 17793/* File: x86/alt_stub.S */ 17794/* 17795 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17796 * any interesting requests and then jump to the real instruction 17797 * handler. Unlike the Arm handler, we can't do this as a tail call 17798 * because rIBASE is caller save and we need to reload it. 17799 */ 17800 movl rSELF, %eax 17801 movl rPC, OUT_ARG0(%esp) 17802 movl %eax, OUT_ARG1(%esp) 17803 call dvmCheckInst # (dPC, self) 17804 movl rSELF, %ecx 17805 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17806 jmp *dvmAsmInstructionStart+(370*4) 17807 17808/* ------------------------------ */ 17809.L_ALT_OP_UNUSED_73FF: /* 0x173 */ 17810/* File: x86/alt_stub.S */ 17811/* 17812 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17813 * any interesting requests and then jump to the real instruction 17814 * handler. Unlike the Arm handler, we can't do this as a tail call 17815 * because rIBASE is caller save and we need to reload it. 17816 */ 17817 movl rSELF, %eax 17818 movl rPC, OUT_ARG0(%esp) 17819 movl %eax, OUT_ARG1(%esp) 17820 call dvmCheckInst # (dPC, self) 17821 movl rSELF, %ecx 17822 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17823 jmp *dvmAsmInstructionStart+(371*4) 17824 17825/* ------------------------------ */ 17826.L_ALT_OP_UNUSED_74FF: /* 0x174 */ 17827/* File: x86/alt_stub.S */ 17828/* 17829 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17830 * any interesting requests and then jump to the real instruction 17831 * handler. Unlike the Arm handler, we can't do this as a tail call 17832 * because rIBASE is caller save and we need to reload it. 17833 */ 17834 movl rSELF, %eax 17835 movl rPC, OUT_ARG0(%esp) 17836 movl %eax, OUT_ARG1(%esp) 17837 call dvmCheckInst # (dPC, self) 17838 movl rSELF, %ecx 17839 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17840 jmp *dvmAsmInstructionStart+(372*4) 17841 17842/* ------------------------------ */ 17843.L_ALT_OP_UNUSED_75FF: /* 0x175 */ 17844/* File: x86/alt_stub.S */ 17845/* 17846 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17847 * any interesting requests and then jump to the real instruction 17848 * handler. Unlike the Arm handler, we can't do this as a tail call 17849 * because rIBASE is caller save and we need to reload it. 17850 */ 17851 movl rSELF, %eax 17852 movl rPC, OUT_ARG0(%esp) 17853 movl %eax, OUT_ARG1(%esp) 17854 call dvmCheckInst # (dPC, self) 17855 movl rSELF, %ecx 17856 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17857 jmp *dvmAsmInstructionStart+(373*4) 17858 17859/* ------------------------------ */ 17860.L_ALT_OP_UNUSED_76FF: /* 0x176 */ 17861/* File: x86/alt_stub.S */ 17862/* 17863 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17864 * any interesting requests and then jump to the real instruction 17865 * handler. Unlike the Arm handler, we can't do this as a tail call 17866 * because rIBASE is caller save and we need to reload it. 17867 */ 17868 movl rSELF, %eax 17869 movl rPC, OUT_ARG0(%esp) 17870 movl %eax, OUT_ARG1(%esp) 17871 call dvmCheckInst # (dPC, self) 17872 movl rSELF, %ecx 17873 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17874 jmp *dvmAsmInstructionStart+(374*4) 17875 17876/* ------------------------------ */ 17877.L_ALT_OP_UNUSED_77FF: /* 0x177 */ 17878/* File: x86/alt_stub.S */ 17879/* 17880 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17881 * any interesting requests and then jump to the real instruction 17882 * handler. Unlike the Arm handler, we can't do this as a tail call 17883 * because rIBASE is caller save and we need to reload it. 17884 */ 17885 movl rSELF, %eax 17886 movl rPC, OUT_ARG0(%esp) 17887 movl %eax, OUT_ARG1(%esp) 17888 call dvmCheckInst # (dPC, self) 17889 movl rSELF, %ecx 17890 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17891 jmp *dvmAsmInstructionStart+(375*4) 17892 17893/* ------------------------------ */ 17894.L_ALT_OP_UNUSED_78FF: /* 0x178 */ 17895/* File: x86/alt_stub.S */ 17896/* 17897 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17898 * any interesting requests and then jump to the real instruction 17899 * handler. Unlike the Arm handler, we can't do this as a tail call 17900 * because rIBASE is caller save and we need to reload it. 17901 */ 17902 movl rSELF, %eax 17903 movl rPC, OUT_ARG0(%esp) 17904 movl %eax, OUT_ARG1(%esp) 17905 call dvmCheckInst # (dPC, self) 17906 movl rSELF, %ecx 17907 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17908 jmp *dvmAsmInstructionStart+(376*4) 17909 17910/* ------------------------------ */ 17911.L_ALT_OP_UNUSED_79FF: /* 0x179 */ 17912/* File: x86/alt_stub.S */ 17913/* 17914 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17915 * any interesting requests and then jump to the real instruction 17916 * handler. Unlike the Arm handler, we can't do this as a tail call 17917 * because rIBASE is caller save and we need to reload it. 17918 */ 17919 movl rSELF, %eax 17920 movl rPC, OUT_ARG0(%esp) 17921 movl %eax, OUT_ARG1(%esp) 17922 call dvmCheckInst # (dPC, self) 17923 movl rSELF, %ecx 17924 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17925 jmp *dvmAsmInstructionStart+(377*4) 17926 17927/* ------------------------------ */ 17928.L_ALT_OP_UNUSED_7AFF: /* 0x17a */ 17929/* File: x86/alt_stub.S */ 17930/* 17931 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17932 * any interesting requests and then jump to the real instruction 17933 * handler. Unlike the Arm handler, we can't do this as a tail call 17934 * because rIBASE is caller save and we need to reload it. 17935 */ 17936 movl rSELF, %eax 17937 movl rPC, OUT_ARG0(%esp) 17938 movl %eax, OUT_ARG1(%esp) 17939 call dvmCheckInst # (dPC, self) 17940 movl rSELF, %ecx 17941 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17942 jmp *dvmAsmInstructionStart+(378*4) 17943 17944/* ------------------------------ */ 17945.L_ALT_OP_UNUSED_7BFF: /* 0x17b */ 17946/* File: x86/alt_stub.S */ 17947/* 17948 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17949 * any interesting requests and then jump to the real instruction 17950 * handler. Unlike the Arm handler, we can't do this as a tail call 17951 * because rIBASE is caller save and we need to reload it. 17952 */ 17953 movl rSELF, %eax 17954 movl rPC, OUT_ARG0(%esp) 17955 movl %eax, OUT_ARG1(%esp) 17956 call dvmCheckInst # (dPC, self) 17957 movl rSELF, %ecx 17958 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17959 jmp *dvmAsmInstructionStart+(379*4) 17960 17961/* ------------------------------ */ 17962.L_ALT_OP_UNUSED_7CFF: /* 0x17c */ 17963/* File: x86/alt_stub.S */ 17964/* 17965 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17966 * any interesting requests and then jump to the real instruction 17967 * handler. Unlike the Arm handler, we can't do this as a tail call 17968 * because rIBASE is caller save and we need to reload it. 17969 */ 17970 movl rSELF, %eax 17971 movl rPC, OUT_ARG0(%esp) 17972 movl %eax, OUT_ARG1(%esp) 17973 call dvmCheckInst # (dPC, self) 17974 movl rSELF, %ecx 17975 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17976 jmp *dvmAsmInstructionStart+(380*4) 17977 17978/* ------------------------------ */ 17979.L_ALT_OP_UNUSED_7DFF: /* 0x17d */ 17980/* File: x86/alt_stub.S */ 17981/* 17982 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17983 * any interesting requests and then jump to the real instruction 17984 * handler. Unlike the Arm handler, we can't do this as a tail call 17985 * because rIBASE is caller save and we need to reload it. 17986 */ 17987 movl rSELF, %eax 17988 movl rPC, OUT_ARG0(%esp) 17989 movl %eax, OUT_ARG1(%esp) 17990 call dvmCheckInst # (dPC, self) 17991 movl rSELF, %ecx 17992 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17993 jmp *dvmAsmInstructionStart+(381*4) 17994 17995/* ------------------------------ */ 17996.L_ALT_OP_UNUSED_7EFF: /* 0x17e */ 17997/* File: x86/alt_stub.S */ 17998/* 17999 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18000 * any interesting requests and then jump to the real instruction 18001 * handler. Unlike the Arm handler, we can't do this as a tail call 18002 * because rIBASE is caller save and we need to reload it. 18003 */ 18004 movl rSELF, %eax 18005 movl rPC, OUT_ARG0(%esp) 18006 movl %eax, OUT_ARG1(%esp) 18007 call dvmCheckInst # (dPC, self) 18008 movl rSELF, %ecx 18009 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18010 jmp *dvmAsmInstructionStart+(382*4) 18011 18012/* ------------------------------ */ 18013.L_ALT_OP_UNUSED_7FFF: /* 0x17f */ 18014/* File: x86/alt_stub.S */ 18015/* 18016 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18017 * any interesting requests and then jump to the real instruction 18018 * handler. Unlike the Arm handler, we can't do this as a tail call 18019 * because rIBASE is caller save and we need to reload it. 18020 */ 18021 movl rSELF, %eax 18022 movl rPC, OUT_ARG0(%esp) 18023 movl %eax, OUT_ARG1(%esp) 18024 call dvmCheckInst # (dPC, self) 18025 movl rSELF, %ecx 18026 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18027 jmp *dvmAsmInstructionStart+(383*4) 18028 18029/* ------------------------------ */ 18030.L_ALT_OP_UNUSED_80FF: /* 0x180 */ 18031/* File: x86/alt_stub.S */ 18032/* 18033 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18034 * any interesting requests and then jump to the real instruction 18035 * handler. Unlike the Arm handler, we can't do this as a tail call 18036 * because rIBASE is caller save and we need to reload it. 18037 */ 18038 movl rSELF, %eax 18039 movl rPC, OUT_ARG0(%esp) 18040 movl %eax, OUT_ARG1(%esp) 18041 call dvmCheckInst # (dPC, self) 18042 movl rSELF, %ecx 18043 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18044 jmp *dvmAsmInstructionStart+(384*4) 18045 18046/* ------------------------------ */ 18047.L_ALT_OP_UNUSED_81FF: /* 0x181 */ 18048/* File: x86/alt_stub.S */ 18049/* 18050 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18051 * any interesting requests and then jump to the real instruction 18052 * handler. Unlike the Arm handler, we can't do this as a tail call 18053 * because rIBASE is caller save and we need to reload it. 18054 */ 18055 movl rSELF, %eax 18056 movl rPC, OUT_ARG0(%esp) 18057 movl %eax, OUT_ARG1(%esp) 18058 call dvmCheckInst # (dPC, self) 18059 movl rSELF, %ecx 18060 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18061 jmp *dvmAsmInstructionStart+(385*4) 18062 18063/* ------------------------------ */ 18064.L_ALT_OP_UNUSED_82FF: /* 0x182 */ 18065/* File: x86/alt_stub.S */ 18066/* 18067 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18068 * any interesting requests and then jump to the real instruction 18069 * handler. Unlike the Arm handler, we can't do this as a tail call 18070 * because rIBASE is caller save and we need to reload it. 18071 */ 18072 movl rSELF, %eax 18073 movl rPC, OUT_ARG0(%esp) 18074 movl %eax, OUT_ARG1(%esp) 18075 call dvmCheckInst # (dPC, self) 18076 movl rSELF, %ecx 18077 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18078 jmp *dvmAsmInstructionStart+(386*4) 18079 18080/* ------------------------------ */ 18081.L_ALT_OP_UNUSED_83FF: /* 0x183 */ 18082/* File: x86/alt_stub.S */ 18083/* 18084 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18085 * any interesting requests and then jump to the real instruction 18086 * handler. Unlike the Arm handler, we can't do this as a tail call 18087 * because rIBASE is caller save and we need to reload it. 18088 */ 18089 movl rSELF, %eax 18090 movl rPC, OUT_ARG0(%esp) 18091 movl %eax, OUT_ARG1(%esp) 18092 call dvmCheckInst # (dPC, self) 18093 movl rSELF, %ecx 18094 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18095 jmp *dvmAsmInstructionStart+(387*4) 18096 18097/* ------------------------------ */ 18098.L_ALT_OP_UNUSED_84FF: /* 0x184 */ 18099/* File: x86/alt_stub.S */ 18100/* 18101 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18102 * any interesting requests and then jump to the real instruction 18103 * handler. Unlike the Arm handler, we can't do this as a tail call 18104 * because rIBASE is caller save and we need to reload it. 18105 */ 18106 movl rSELF, %eax 18107 movl rPC, OUT_ARG0(%esp) 18108 movl %eax, OUT_ARG1(%esp) 18109 call dvmCheckInst # (dPC, self) 18110 movl rSELF, %ecx 18111 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18112 jmp *dvmAsmInstructionStart+(388*4) 18113 18114/* ------------------------------ */ 18115.L_ALT_OP_UNUSED_85FF: /* 0x185 */ 18116/* File: x86/alt_stub.S */ 18117/* 18118 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18119 * any interesting requests and then jump to the real instruction 18120 * handler. Unlike the Arm handler, we can't do this as a tail call 18121 * because rIBASE is caller save and we need to reload it. 18122 */ 18123 movl rSELF, %eax 18124 movl rPC, OUT_ARG0(%esp) 18125 movl %eax, OUT_ARG1(%esp) 18126 call dvmCheckInst # (dPC, self) 18127 movl rSELF, %ecx 18128 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18129 jmp *dvmAsmInstructionStart+(389*4) 18130 18131/* ------------------------------ */ 18132.L_ALT_OP_UNUSED_86FF: /* 0x186 */ 18133/* File: x86/alt_stub.S */ 18134/* 18135 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18136 * any interesting requests and then jump to the real instruction 18137 * handler. Unlike the Arm handler, we can't do this as a tail call 18138 * because rIBASE is caller save and we need to reload it. 18139 */ 18140 movl rSELF, %eax 18141 movl rPC, OUT_ARG0(%esp) 18142 movl %eax, OUT_ARG1(%esp) 18143 call dvmCheckInst # (dPC, self) 18144 movl rSELF, %ecx 18145 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18146 jmp *dvmAsmInstructionStart+(390*4) 18147 18148/* ------------------------------ */ 18149.L_ALT_OP_UNUSED_87FF: /* 0x187 */ 18150/* File: x86/alt_stub.S */ 18151/* 18152 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18153 * any interesting requests and then jump to the real instruction 18154 * handler. Unlike the Arm handler, we can't do this as a tail call 18155 * because rIBASE is caller save and we need to reload it. 18156 */ 18157 movl rSELF, %eax 18158 movl rPC, OUT_ARG0(%esp) 18159 movl %eax, OUT_ARG1(%esp) 18160 call dvmCheckInst # (dPC, self) 18161 movl rSELF, %ecx 18162 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18163 jmp *dvmAsmInstructionStart+(391*4) 18164 18165/* ------------------------------ */ 18166.L_ALT_OP_UNUSED_88FF: /* 0x188 */ 18167/* File: x86/alt_stub.S */ 18168/* 18169 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18170 * any interesting requests and then jump to the real instruction 18171 * handler. Unlike the Arm handler, we can't do this as a tail call 18172 * because rIBASE is caller save and we need to reload it. 18173 */ 18174 movl rSELF, %eax 18175 movl rPC, OUT_ARG0(%esp) 18176 movl %eax, OUT_ARG1(%esp) 18177 call dvmCheckInst # (dPC, self) 18178 movl rSELF, %ecx 18179 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18180 jmp *dvmAsmInstructionStart+(392*4) 18181 18182/* ------------------------------ */ 18183.L_ALT_OP_UNUSED_89FF: /* 0x189 */ 18184/* File: x86/alt_stub.S */ 18185/* 18186 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18187 * any interesting requests and then jump to the real instruction 18188 * handler. Unlike the Arm handler, we can't do this as a tail call 18189 * because rIBASE is caller save and we need to reload it. 18190 */ 18191 movl rSELF, %eax 18192 movl rPC, OUT_ARG0(%esp) 18193 movl %eax, OUT_ARG1(%esp) 18194 call dvmCheckInst # (dPC, self) 18195 movl rSELF, %ecx 18196 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18197 jmp *dvmAsmInstructionStart+(393*4) 18198 18199/* ------------------------------ */ 18200.L_ALT_OP_UNUSED_8AFF: /* 0x18a */ 18201/* File: x86/alt_stub.S */ 18202/* 18203 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18204 * any interesting requests and then jump to the real instruction 18205 * handler. Unlike the Arm handler, we can't do this as a tail call 18206 * because rIBASE is caller save and we need to reload it. 18207 */ 18208 movl rSELF, %eax 18209 movl rPC, OUT_ARG0(%esp) 18210 movl %eax, OUT_ARG1(%esp) 18211 call dvmCheckInst # (dPC, self) 18212 movl rSELF, %ecx 18213 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18214 jmp *dvmAsmInstructionStart+(394*4) 18215 18216/* ------------------------------ */ 18217.L_ALT_OP_UNUSED_8BFF: /* 0x18b */ 18218/* File: x86/alt_stub.S */ 18219/* 18220 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18221 * any interesting requests and then jump to the real instruction 18222 * handler. Unlike the Arm handler, we can't do this as a tail call 18223 * because rIBASE is caller save and we need to reload it. 18224 */ 18225 movl rSELF, %eax 18226 movl rPC, OUT_ARG0(%esp) 18227 movl %eax, OUT_ARG1(%esp) 18228 call dvmCheckInst # (dPC, self) 18229 movl rSELF, %ecx 18230 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18231 jmp *dvmAsmInstructionStart+(395*4) 18232 18233/* ------------------------------ */ 18234.L_ALT_OP_UNUSED_8CFF: /* 0x18c */ 18235/* File: x86/alt_stub.S */ 18236/* 18237 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18238 * any interesting requests and then jump to the real instruction 18239 * handler. Unlike the Arm handler, we can't do this as a tail call 18240 * because rIBASE is caller save and we need to reload it. 18241 */ 18242 movl rSELF, %eax 18243 movl rPC, OUT_ARG0(%esp) 18244 movl %eax, OUT_ARG1(%esp) 18245 call dvmCheckInst # (dPC, self) 18246 movl rSELF, %ecx 18247 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18248 jmp *dvmAsmInstructionStart+(396*4) 18249 18250/* ------------------------------ */ 18251.L_ALT_OP_UNUSED_8DFF: /* 0x18d */ 18252/* File: x86/alt_stub.S */ 18253/* 18254 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18255 * any interesting requests and then jump to the real instruction 18256 * handler. Unlike the Arm handler, we can't do this as a tail call 18257 * because rIBASE is caller save and we need to reload it. 18258 */ 18259 movl rSELF, %eax 18260 movl rPC, OUT_ARG0(%esp) 18261 movl %eax, OUT_ARG1(%esp) 18262 call dvmCheckInst # (dPC, self) 18263 movl rSELF, %ecx 18264 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18265 jmp *dvmAsmInstructionStart+(397*4) 18266 18267/* ------------------------------ */ 18268.L_ALT_OP_UNUSED_8EFF: /* 0x18e */ 18269/* File: x86/alt_stub.S */ 18270/* 18271 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18272 * any interesting requests and then jump to the real instruction 18273 * handler. Unlike the Arm handler, we can't do this as a tail call 18274 * because rIBASE is caller save and we need to reload it. 18275 */ 18276 movl rSELF, %eax 18277 movl rPC, OUT_ARG0(%esp) 18278 movl %eax, OUT_ARG1(%esp) 18279 call dvmCheckInst # (dPC, self) 18280 movl rSELF, %ecx 18281 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18282 jmp *dvmAsmInstructionStart+(398*4) 18283 18284/* ------------------------------ */ 18285.L_ALT_OP_UNUSED_8FFF: /* 0x18f */ 18286/* File: x86/alt_stub.S */ 18287/* 18288 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18289 * any interesting requests and then jump to the real instruction 18290 * handler. Unlike the Arm handler, we can't do this as a tail call 18291 * because rIBASE is caller save and we need to reload it. 18292 */ 18293 movl rSELF, %eax 18294 movl rPC, OUT_ARG0(%esp) 18295 movl %eax, OUT_ARG1(%esp) 18296 call dvmCheckInst # (dPC, self) 18297 movl rSELF, %ecx 18298 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18299 jmp *dvmAsmInstructionStart+(399*4) 18300 18301/* ------------------------------ */ 18302.L_ALT_OP_UNUSED_90FF: /* 0x190 */ 18303/* File: x86/alt_stub.S */ 18304/* 18305 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18306 * any interesting requests and then jump to the real instruction 18307 * handler. Unlike the Arm handler, we can't do this as a tail call 18308 * because rIBASE is caller save and we need to reload it. 18309 */ 18310 movl rSELF, %eax 18311 movl rPC, OUT_ARG0(%esp) 18312 movl %eax, OUT_ARG1(%esp) 18313 call dvmCheckInst # (dPC, self) 18314 movl rSELF, %ecx 18315 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18316 jmp *dvmAsmInstructionStart+(400*4) 18317 18318/* ------------------------------ */ 18319.L_ALT_OP_UNUSED_91FF: /* 0x191 */ 18320/* File: x86/alt_stub.S */ 18321/* 18322 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18323 * any interesting requests and then jump to the real instruction 18324 * handler. Unlike the Arm handler, we can't do this as a tail call 18325 * because rIBASE is caller save and we need to reload it. 18326 */ 18327 movl rSELF, %eax 18328 movl rPC, OUT_ARG0(%esp) 18329 movl %eax, OUT_ARG1(%esp) 18330 call dvmCheckInst # (dPC, self) 18331 movl rSELF, %ecx 18332 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18333 jmp *dvmAsmInstructionStart+(401*4) 18334 18335/* ------------------------------ */ 18336.L_ALT_OP_UNUSED_92FF: /* 0x192 */ 18337/* File: x86/alt_stub.S */ 18338/* 18339 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18340 * any interesting requests and then jump to the real instruction 18341 * handler. Unlike the Arm handler, we can't do this as a tail call 18342 * because rIBASE is caller save and we need to reload it. 18343 */ 18344 movl rSELF, %eax 18345 movl rPC, OUT_ARG0(%esp) 18346 movl %eax, OUT_ARG1(%esp) 18347 call dvmCheckInst # (dPC, self) 18348 movl rSELF, %ecx 18349 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18350 jmp *dvmAsmInstructionStart+(402*4) 18351 18352/* ------------------------------ */ 18353.L_ALT_OP_UNUSED_93FF: /* 0x193 */ 18354/* File: x86/alt_stub.S */ 18355/* 18356 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18357 * any interesting requests and then jump to the real instruction 18358 * handler. Unlike the Arm handler, we can't do this as a tail call 18359 * because rIBASE is caller save and we need to reload it. 18360 */ 18361 movl rSELF, %eax 18362 movl rPC, OUT_ARG0(%esp) 18363 movl %eax, OUT_ARG1(%esp) 18364 call dvmCheckInst # (dPC, self) 18365 movl rSELF, %ecx 18366 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18367 jmp *dvmAsmInstructionStart+(403*4) 18368 18369/* ------------------------------ */ 18370.L_ALT_OP_UNUSED_94FF: /* 0x194 */ 18371/* File: x86/alt_stub.S */ 18372/* 18373 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18374 * any interesting requests and then jump to the real instruction 18375 * handler. Unlike the Arm handler, we can't do this as a tail call 18376 * because rIBASE is caller save and we need to reload it. 18377 */ 18378 movl rSELF, %eax 18379 movl rPC, OUT_ARG0(%esp) 18380 movl %eax, OUT_ARG1(%esp) 18381 call dvmCheckInst # (dPC, self) 18382 movl rSELF, %ecx 18383 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18384 jmp *dvmAsmInstructionStart+(404*4) 18385 18386/* ------------------------------ */ 18387.L_ALT_OP_UNUSED_95FF: /* 0x195 */ 18388/* File: x86/alt_stub.S */ 18389/* 18390 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18391 * any interesting requests and then jump to the real instruction 18392 * handler. Unlike the Arm handler, we can't do this as a tail call 18393 * because rIBASE is caller save and we need to reload it. 18394 */ 18395 movl rSELF, %eax 18396 movl rPC, OUT_ARG0(%esp) 18397 movl %eax, OUT_ARG1(%esp) 18398 call dvmCheckInst # (dPC, self) 18399 movl rSELF, %ecx 18400 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18401 jmp *dvmAsmInstructionStart+(405*4) 18402 18403/* ------------------------------ */ 18404.L_ALT_OP_UNUSED_96FF: /* 0x196 */ 18405/* File: x86/alt_stub.S */ 18406/* 18407 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18408 * any interesting requests and then jump to the real instruction 18409 * handler. Unlike the Arm handler, we can't do this as a tail call 18410 * because rIBASE is caller save and we need to reload it. 18411 */ 18412 movl rSELF, %eax 18413 movl rPC, OUT_ARG0(%esp) 18414 movl %eax, OUT_ARG1(%esp) 18415 call dvmCheckInst # (dPC, self) 18416 movl rSELF, %ecx 18417 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18418 jmp *dvmAsmInstructionStart+(406*4) 18419 18420/* ------------------------------ */ 18421.L_ALT_OP_UNUSED_97FF: /* 0x197 */ 18422/* File: x86/alt_stub.S */ 18423/* 18424 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18425 * any interesting requests and then jump to the real instruction 18426 * handler. Unlike the Arm handler, we can't do this as a tail call 18427 * because rIBASE is caller save and we need to reload it. 18428 */ 18429 movl rSELF, %eax 18430 movl rPC, OUT_ARG0(%esp) 18431 movl %eax, OUT_ARG1(%esp) 18432 call dvmCheckInst # (dPC, self) 18433 movl rSELF, %ecx 18434 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18435 jmp *dvmAsmInstructionStart+(407*4) 18436 18437/* ------------------------------ */ 18438.L_ALT_OP_UNUSED_98FF: /* 0x198 */ 18439/* File: x86/alt_stub.S */ 18440/* 18441 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18442 * any interesting requests and then jump to the real instruction 18443 * handler. Unlike the Arm handler, we can't do this as a tail call 18444 * because rIBASE is caller save and we need to reload it. 18445 */ 18446 movl rSELF, %eax 18447 movl rPC, OUT_ARG0(%esp) 18448 movl %eax, OUT_ARG1(%esp) 18449 call dvmCheckInst # (dPC, self) 18450 movl rSELF, %ecx 18451 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18452 jmp *dvmAsmInstructionStart+(408*4) 18453 18454/* ------------------------------ */ 18455.L_ALT_OP_UNUSED_99FF: /* 0x199 */ 18456/* File: x86/alt_stub.S */ 18457/* 18458 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18459 * any interesting requests and then jump to the real instruction 18460 * handler. Unlike the Arm handler, we can't do this as a tail call 18461 * because rIBASE is caller save and we need to reload it. 18462 */ 18463 movl rSELF, %eax 18464 movl rPC, OUT_ARG0(%esp) 18465 movl %eax, OUT_ARG1(%esp) 18466 call dvmCheckInst # (dPC, self) 18467 movl rSELF, %ecx 18468 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18469 jmp *dvmAsmInstructionStart+(409*4) 18470 18471/* ------------------------------ */ 18472.L_ALT_OP_UNUSED_9AFF: /* 0x19a */ 18473/* File: x86/alt_stub.S */ 18474/* 18475 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18476 * any interesting requests and then jump to the real instruction 18477 * handler. Unlike the Arm handler, we can't do this as a tail call 18478 * because rIBASE is caller save and we need to reload it. 18479 */ 18480 movl rSELF, %eax 18481 movl rPC, OUT_ARG0(%esp) 18482 movl %eax, OUT_ARG1(%esp) 18483 call dvmCheckInst # (dPC, self) 18484 movl rSELF, %ecx 18485 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18486 jmp *dvmAsmInstructionStart+(410*4) 18487 18488/* ------------------------------ */ 18489.L_ALT_OP_UNUSED_9BFF: /* 0x19b */ 18490/* File: x86/alt_stub.S */ 18491/* 18492 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18493 * any interesting requests and then jump to the real instruction 18494 * handler. Unlike the Arm handler, we can't do this as a tail call 18495 * because rIBASE is caller save and we need to reload it. 18496 */ 18497 movl rSELF, %eax 18498 movl rPC, OUT_ARG0(%esp) 18499 movl %eax, OUT_ARG1(%esp) 18500 call dvmCheckInst # (dPC, self) 18501 movl rSELF, %ecx 18502 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18503 jmp *dvmAsmInstructionStart+(411*4) 18504 18505/* ------------------------------ */ 18506.L_ALT_OP_UNUSED_9CFF: /* 0x19c */ 18507/* File: x86/alt_stub.S */ 18508/* 18509 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18510 * any interesting requests and then jump to the real instruction 18511 * handler. Unlike the Arm handler, we can't do this as a tail call 18512 * because rIBASE is caller save and we need to reload it. 18513 */ 18514 movl rSELF, %eax 18515 movl rPC, OUT_ARG0(%esp) 18516 movl %eax, OUT_ARG1(%esp) 18517 call dvmCheckInst # (dPC, self) 18518 movl rSELF, %ecx 18519 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18520 jmp *dvmAsmInstructionStart+(412*4) 18521 18522/* ------------------------------ */ 18523.L_ALT_OP_UNUSED_9DFF: /* 0x19d */ 18524/* File: x86/alt_stub.S */ 18525/* 18526 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18527 * any interesting requests and then jump to the real instruction 18528 * handler. Unlike the Arm handler, we can't do this as a tail call 18529 * because rIBASE is caller save and we need to reload it. 18530 */ 18531 movl rSELF, %eax 18532 movl rPC, OUT_ARG0(%esp) 18533 movl %eax, OUT_ARG1(%esp) 18534 call dvmCheckInst # (dPC, self) 18535 movl rSELF, %ecx 18536 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18537 jmp *dvmAsmInstructionStart+(413*4) 18538 18539/* ------------------------------ */ 18540.L_ALT_OP_UNUSED_9EFF: /* 0x19e */ 18541/* File: x86/alt_stub.S */ 18542/* 18543 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18544 * any interesting requests and then jump to the real instruction 18545 * handler. Unlike the Arm handler, we can't do this as a tail call 18546 * because rIBASE is caller save and we need to reload it. 18547 */ 18548 movl rSELF, %eax 18549 movl rPC, OUT_ARG0(%esp) 18550 movl %eax, OUT_ARG1(%esp) 18551 call dvmCheckInst # (dPC, self) 18552 movl rSELF, %ecx 18553 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18554 jmp *dvmAsmInstructionStart+(414*4) 18555 18556/* ------------------------------ */ 18557.L_ALT_OP_UNUSED_9FFF: /* 0x19f */ 18558/* File: x86/alt_stub.S */ 18559/* 18560 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18561 * any interesting requests and then jump to the real instruction 18562 * handler. Unlike the Arm handler, we can't do this as a tail call 18563 * because rIBASE is caller save and we need to reload it. 18564 */ 18565 movl rSELF, %eax 18566 movl rPC, OUT_ARG0(%esp) 18567 movl %eax, OUT_ARG1(%esp) 18568 call dvmCheckInst # (dPC, self) 18569 movl rSELF, %ecx 18570 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18571 jmp *dvmAsmInstructionStart+(415*4) 18572 18573/* ------------------------------ */ 18574.L_ALT_OP_UNUSED_A0FF: /* 0x1a0 */ 18575/* File: x86/alt_stub.S */ 18576/* 18577 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18578 * any interesting requests and then jump to the real instruction 18579 * handler. Unlike the Arm handler, we can't do this as a tail call 18580 * because rIBASE is caller save and we need to reload it. 18581 */ 18582 movl rSELF, %eax 18583 movl rPC, OUT_ARG0(%esp) 18584 movl %eax, OUT_ARG1(%esp) 18585 call dvmCheckInst # (dPC, self) 18586 movl rSELF, %ecx 18587 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18588 jmp *dvmAsmInstructionStart+(416*4) 18589 18590/* ------------------------------ */ 18591.L_ALT_OP_UNUSED_A1FF: /* 0x1a1 */ 18592/* File: x86/alt_stub.S */ 18593/* 18594 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18595 * any interesting requests and then jump to the real instruction 18596 * handler. Unlike the Arm handler, we can't do this as a tail call 18597 * because rIBASE is caller save and we need to reload it. 18598 */ 18599 movl rSELF, %eax 18600 movl rPC, OUT_ARG0(%esp) 18601 movl %eax, OUT_ARG1(%esp) 18602 call dvmCheckInst # (dPC, self) 18603 movl rSELF, %ecx 18604 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18605 jmp *dvmAsmInstructionStart+(417*4) 18606 18607/* ------------------------------ */ 18608.L_ALT_OP_UNUSED_A2FF: /* 0x1a2 */ 18609/* File: x86/alt_stub.S */ 18610/* 18611 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18612 * any interesting requests and then jump to the real instruction 18613 * handler. Unlike the Arm handler, we can't do this as a tail call 18614 * because rIBASE is caller save and we need to reload it. 18615 */ 18616 movl rSELF, %eax 18617 movl rPC, OUT_ARG0(%esp) 18618 movl %eax, OUT_ARG1(%esp) 18619 call dvmCheckInst # (dPC, self) 18620 movl rSELF, %ecx 18621 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18622 jmp *dvmAsmInstructionStart+(418*4) 18623 18624/* ------------------------------ */ 18625.L_ALT_OP_UNUSED_A3FF: /* 0x1a3 */ 18626/* File: x86/alt_stub.S */ 18627/* 18628 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18629 * any interesting requests and then jump to the real instruction 18630 * handler. Unlike the Arm handler, we can't do this as a tail call 18631 * because rIBASE is caller save and we need to reload it. 18632 */ 18633 movl rSELF, %eax 18634 movl rPC, OUT_ARG0(%esp) 18635 movl %eax, OUT_ARG1(%esp) 18636 call dvmCheckInst # (dPC, self) 18637 movl rSELF, %ecx 18638 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18639 jmp *dvmAsmInstructionStart+(419*4) 18640 18641/* ------------------------------ */ 18642.L_ALT_OP_UNUSED_A4FF: /* 0x1a4 */ 18643/* File: x86/alt_stub.S */ 18644/* 18645 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18646 * any interesting requests and then jump to the real instruction 18647 * handler. Unlike the Arm handler, we can't do this as a tail call 18648 * because rIBASE is caller save and we need to reload it. 18649 */ 18650 movl rSELF, %eax 18651 movl rPC, OUT_ARG0(%esp) 18652 movl %eax, OUT_ARG1(%esp) 18653 call dvmCheckInst # (dPC, self) 18654 movl rSELF, %ecx 18655 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18656 jmp *dvmAsmInstructionStart+(420*4) 18657 18658/* ------------------------------ */ 18659.L_ALT_OP_UNUSED_A5FF: /* 0x1a5 */ 18660/* File: x86/alt_stub.S */ 18661/* 18662 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18663 * any interesting requests and then jump to the real instruction 18664 * handler. Unlike the Arm handler, we can't do this as a tail call 18665 * because rIBASE is caller save and we need to reload it. 18666 */ 18667 movl rSELF, %eax 18668 movl rPC, OUT_ARG0(%esp) 18669 movl %eax, OUT_ARG1(%esp) 18670 call dvmCheckInst # (dPC, self) 18671 movl rSELF, %ecx 18672 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18673 jmp *dvmAsmInstructionStart+(421*4) 18674 18675/* ------------------------------ */ 18676.L_ALT_OP_UNUSED_A6FF: /* 0x1a6 */ 18677/* File: x86/alt_stub.S */ 18678/* 18679 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18680 * any interesting requests and then jump to the real instruction 18681 * handler. Unlike the Arm handler, we can't do this as a tail call 18682 * because rIBASE is caller save and we need to reload it. 18683 */ 18684 movl rSELF, %eax 18685 movl rPC, OUT_ARG0(%esp) 18686 movl %eax, OUT_ARG1(%esp) 18687 call dvmCheckInst # (dPC, self) 18688 movl rSELF, %ecx 18689 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18690 jmp *dvmAsmInstructionStart+(422*4) 18691 18692/* ------------------------------ */ 18693.L_ALT_OP_UNUSED_A7FF: /* 0x1a7 */ 18694/* File: x86/alt_stub.S */ 18695/* 18696 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18697 * any interesting requests and then jump to the real instruction 18698 * handler. Unlike the Arm handler, we can't do this as a tail call 18699 * because rIBASE is caller save and we need to reload it. 18700 */ 18701 movl rSELF, %eax 18702 movl rPC, OUT_ARG0(%esp) 18703 movl %eax, OUT_ARG1(%esp) 18704 call dvmCheckInst # (dPC, self) 18705 movl rSELF, %ecx 18706 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18707 jmp *dvmAsmInstructionStart+(423*4) 18708 18709/* ------------------------------ */ 18710.L_ALT_OP_UNUSED_A8FF: /* 0x1a8 */ 18711/* File: x86/alt_stub.S */ 18712/* 18713 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18714 * any interesting requests and then jump to the real instruction 18715 * handler. Unlike the Arm handler, we can't do this as a tail call 18716 * because rIBASE is caller save and we need to reload it. 18717 */ 18718 movl rSELF, %eax 18719 movl rPC, OUT_ARG0(%esp) 18720 movl %eax, OUT_ARG1(%esp) 18721 call dvmCheckInst # (dPC, self) 18722 movl rSELF, %ecx 18723 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18724 jmp *dvmAsmInstructionStart+(424*4) 18725 18726/* ------------------------------ */ 18727.L_ALT_OP_UNUSED_A9FF: /* 0x1a9 */ 18728/* File: x86/alt_stub.S */ 18729/* 18730 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18731 * any interesting requests and then jump to the real instruction 18732 * handler. Unlike the Arm handler, we can't do this as a tail call 18733 * because rIBASE is caller save and we need to reload it. 18734 */ 18735 movl rSELF, %eax 18736 movl rPC, OUT_ARG0(%esp) 18737 movl %eax, OUT_ARG1(%esp) 18738 call dvmCheckInst # (dPC, self) 18739 movl rSELF, %ecx 18740 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18741 jmp *dvmAsmInstructionStart+(425*4) 18742 18743/* ------------------------------ */ 18744.L_ALT_OP_UNUSED_AAFF: /* 0x1aa */ 18745/* File: x86/alt_stub.S */ 18746/* 18747 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18748 * any interesting requests and then jump to the real instruction 18749 * handler. Unlike the Arm handler, we can't do this as a tail call 18750 * because rIBASE is caller save and we need to reload it. 18751 */ 18752 movl rSELF, %eax 18753 movl rPC, OUT_ARG0(%esp) 18754 movl %eax, OUT_ARG1(%esp) 18755 call dvmCheckInst # (dPC, self) 18756 movl rSELF, %ecx 18757 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18758 jmp *dvmAsmInstructionStart+(426*4) 18759 18760/* ------------------------------ */ 18761.L_ALT_OP_UNUSED_ABFF: /* 0x1ab */ 18762/* File: x86/alt_stub.S */ 18763/* 18764 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18765 * any interesting requests and then jump to the real instruction 18766 * handler. Unlike the Arm handler, we can't do this as a tail call 18767 * because rIBASE is caller save and we need to reload it. 18768 */ 18769 movl rSELF, %eax 18770 movl rPC, OUT_ARG0(%esp) 18771 movl %eax, OUT_ARG1(%esp) 18772 call dvmCheckInst # (dPC, self) 18773 movl rSELF, %ecx 18774 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18775 jmp *dvmAsmInstructionStart+(427*4) 18776 18777/* ------------------------------ */ 18778.L_ALT_OP_UNUSED_ACFF: /* 0x1ac */ 18779/* File: x86/alt_stub.S */ 18780/* 18781 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18782 * any interesting requests and then jump to the real instruction 18783 * handler. Unlike the Arm handler, we can't do this as a tail call 18784 * because rIBASE is caller save and we need to reload it. 18785 */ 18786 movl rSELF, %eax 18787 movl rPC, OUT_ARG0(%esp) 18788 movl %eax, OUT_ARG1(%esp) 18789 call dvmCheckInst # (dPC, self) 18790 movl rSELF, %ecx 18791 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18792 jmp *dvmAsmInstructionStart+(428*4) 18793 18794/* ------------------------------ */ 18795.L_ALT_OP_UNUSED_ADFF: /* 0x1ad */ 18796/* File: x86/alt_stub.S */ 18797/* 18798 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18799 * any interesting requests and then jump to the real instruction 18800 * handler. Unlike the Arm handler, we can't do this as a tail call 18801 * because rIBASE is caller save and we need to reload it. 18802 */ 18803 movl rSELF, %eax 18804 movl rPC, OUT_ARG0(%esp) 18805 movl %eax, OUT_ARG1(%esp) 18806 call dvmCheckInst # (dPC, self) 18807 movl rSELF, %ecx 18808 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18809 jmp *dvmAsmInstructionStart+(429*4) 18810 18811/* ------------------------------ */ 18812.L_ALT_OP_UNUSED_AEFF: /* 0x1ae */ 18813/* File: x86/alt_stub.S */ 18814/* 18815 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18816 * any interesting requests and then jump to the real instruction 18817 * handler. Unlike the Arm handler, we can't do this as a tail call 18818 * because rIBASE is caller save and we need to reload it. 18819 */ 18820 movl rSELF, %eax 18821 movl rPC, OUT_ARG0(%esp) 18822 movl %eax, OUT_ARG1(%esp) 18823 call dvmCheckInst # (dPC, self) 18824 movl rSELF, %ecx 18825 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18826 jmp *dvmAsmInstructionStart+(430*4) 18827 18828/* ------------------------------ */ 18829.L_ALT_OP_UNUSED_AFFF: /* 0x1af */ 18830/* File: x86/alt_stub.S */ 18831/* 18832 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18833 * any interesting requests and then jump to the real instruction 18834 * handler. Unlike the Arm handler, we can't do this as a tail call 18835 * because rIBASE is caller save and we need to reload it. 18836 */ 18837 movl rSELF, %eax 18838 movl rPC, OUT_ARG0(%esp) 18839 movl %eax, OUT_ARG1(%esp) 18840 call dvmCheckInst # (dPC, self) 18841 movl rSELF, %ecx 18842 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18843 jmp *dvmAsmInstructionStart+(431*4) 18844 18845/* ------------------------------ */ 18846.L_ALT_OP_UNUSED_B0FF: /* 0x1b0 */ 18847/* File: x86/alt_stub.S */ 18848/* 18849 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18850 * any interesting requests and then jump to the real instruction 18851 * handler. Unlike the Arm handler, we can't do this as a tail call 18852 * because rIBASE is caller save and we need to reload it. 18853 */ 18854 movl rSELF, %eax 18855 movl rPC, OUT_ARG0(%esp) 18856 movl %eax, OUT_ARG1(%esp) 18857 call dvmCheckInst # (dPC, self) 18858 movl rSELF, %ecx 18859 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18860 jmp *dvmAsmInstructionStart+(432*4) 18861 18862/* ------------------------------ */ 18863.L_ALT_OP_UNUSED_B1FF: /* 0x1b1 */ 18864/* File: x86/alt_stub.S */ 18865/* 18866 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18867 * any interesting requests and then jump to the real instruction 18868 * handler. Unlike the Arm handler, we can't do this as a tail call 18869 * because rIBASE is caller save and we need to reload it. 18870 */ 18871 movl rSELF, %eax 18872 movl rPC, OUT_ARG0(%esp) 18873 movl %eax, OUT_ARG1(%esp) 18874 call dvmCheckInst # (dPC, self) 18875 movl rSELF, %ecx 18876 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18877 jmp *dvmAsmInstructionStart+(433*4) 18878 18879/* ------------------------------ */ 18880.L_ALT_OP_UNUSED_B2FF: /* 0x1b2 */ 18881/* File: x86/alt_stub.S */ 18882/* 18883 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18884 * any interesting requests and then jump to the real instruction 18885 * handler. Unlike the Arm handler, we can't do this as a tail call 18886 * because rIBASE is caller save and we need to reload it. 18887 */ 18888 movl rSELF, %eax 18889 movl rPC, OUT_ARG0(%esp) 18890 movl %eax, OUT_ARG1(%esp) 18891 call dvmCheckInst # (dPC, self) 18892 movl rSELF, %ecx 18893 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18894 jmp *dvmAsmInstructionStart+(434*4) 18895 18896/* ------------------------------ */ 18897.L_ALT_OP_UNUSED_B3FF: /* 0x1b3 */ 18898/* File: x86/alt_stub.S */ 18899/* 18900 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18901 * any interesting requests and then jump to the real instruction 18902 * handler. Unlike the Arm handler, we can't do this as a tail call 18903 * because rIBASE is caller save and we need to reload it. 18904 */ 18905 movl rSELF, %eax 18906 movl rPC, OUT_ARG0(%esp) 18907 movl %eax, OUT_ARG1(%esp) 18908 call dvmCheckInst # (dPC, self) 18909 movl rSELF, %ecx 18910 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18911 jmp *dvmAsmInstructionStart+(435*4) 18912 18913/* ------------------------------ */ 18914.L_ALT_OP_UNUSED_B4FF: /* 0x1b4 */ 18915/* File: x86/alt_stub.S */ 18916/* 18917 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18918 * any interesting requests and then jump to the real instruction 18919 * handler. Unlike the Arm handler, we can't do this as a tail call 18920 * because rIBASE is caller save and we need to reload it. 18921 */ 18922 movl rSELF, %eax 18923 movl rPC, OUT_ARG0(%esp) 18924 movl %eax, OUT_ARG1(%esp) 18925 call dvmCheckInst # (dPC, self) 18926 movl rSELF, %ecx 18927 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18928 jmp *dvmAsmInstructionStart+(436*4) 18929 18930/* ------------------------------ */ 18931.L_ALT_OP_UNUSED_B5FF: /* 0x1b5 */ 18932/* File: x86/alt_stub.S */ 18933/* 18934 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18935 * any interesting requests and then jump to the real instruction 18936 * handler. Unlike the Arm handler, we can't do this as a tail call 18937 * because rIBASE is caller save and we need to reload it. 18938 */ 18939 movl rSELF, %eax 18940 movl rPC, OUT_ARG0(%esp) 18941 movl %eax, OUT_ARG1(%esp) 18942 call dvmCheckInst # (dPC, self) 18943 movl rSELF, %ecx 18944 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18945 jmp *dvmAsmInstructionStart+(437*4) 18946 18947/* ------------------------------ */ 18948.L_ALT_OP_UNUSED_B6FF: /* 0x1b6 */ 18949/* File: x86/alt_stub.S */ 18950/* 18951 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18952 * any interesting requests and then jump to the real instruction 18953 * handler. Unlike the Arm handler, we can't do this as a tail call 18954 * because rIBASE is caller save and we need to reload it. 18955 */ 18956 movl rSELF, %eax 18957 movl rPC, OUT_ARG0(%esp) 18958 movl %eax, OUT_ARG1(%esp) 18959 call dvmCheckInst # (dPC, self) 18960 movl rSELF, %ecx 18961 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18962 jmp *dvmAsmInstructionStart+(438*4) 18963 18964/* ------------------------------ */ 18965.L_ALT_OP_UNUSED_B7FF: /* 0x1b7 */ 18966/* File: x86/alt_stub.S */ 18967/* 18968 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18969 * any interesting requests and then jump to the real instruction 18970 * handler. Unlike the Arm handler, we can't do this as a tail call 18971 * because rIBASE is caller save and we need to reload it. 18972 */ 18973 movl rSELF, %eax 18974 movl rPC, OUT_ARG0(%esp) 18975 movl %eax, OUT_ARG1(%esp) 18976 call dvmCheckInst # (dPC, self) 18977 movl rSELF, %ecx 18978 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18979 jmp *dvmAsmInstructionStart+(439*4) 18980 18981/* ------------------------------ */ 18982.L_ALT_OP_UNUSED_B8FF: /* 0x1b8 */ 18983/* File: x86/alt_stub.S */ 18984/* 18985 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18986 * any interesting requests and then jump to the real instruction 18987 * handler. Unlike the Arm handler, we can't do this as a tail call 18988 * because rIBASE is caller save and we need to reload it. 18989 */ 18990 movl rSELF, %eax 18991 movl rPC, OUT_ARG0(%esp) 18992 movl %eax, OUT_ARG1(%esp) 18993 call dvmCheckInst # (dPC, self) 18994 movl rSELF, %ecx 18995 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18996 jmp *dvmAsmInstructionStart+(440*4) 18997 18998/* ------------------------------ */ 18999.L_ALT_OP_UNUSED_B9FF: /* 0x1b9 */ 19000/* File: x86/alt_stub.S */ 19001/* 19002 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19003 * any interesting requests and then jump to the real instruction 19004 * handler. Unlike the Arm handler, we can't do this as a tail call 19005 * because rIBASE is caller save and we need to reload it. 19006 */ 19007 movl rSELF, %eax 19008 movl rPC, OUT_ARG0(%esp) 19009 movl %eax, OUT_ARG1(%esp) 19010 call dvmCheckInst # (dPC, self) 19011 movl rSELF, %ecx 19012 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19013 jmp *dvmAsmInstructionStart+(441*4) 19014 19015/* ------------------------------ */ 19016.L_ALT_OP_UNUSED_BAFF: /* 0x1ba */ 19017/* File: x86/alt_stub.S */ 19018/* 19019 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19020 * any interesting requests and then jump to the real instruction 19021 * handler. Unlike the Arm handler, we can't do this as a tail call 19022 * because rIBASE is caller save and we need to reload it. 19023 */ 19024 movl rSELF, %eax 19025 movl rPC, OUT_ARG0(%esp) 19026 movl %eax, OUT_ARG1(%esp) 19027 call dvmCheckInst # (dPC, self) 19028 movl rSELF, %ecx 19029 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19030 jmp *dvmAsmInstructionStart+(442*4) 19031 19032/* ------------------------------ */ 19033.L_ALT_OP_UNUSED_BBFF: /* 0x1bb */ 19034/* File: x86/alt_stub.S */ 19035/* 19036 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19037 * any interesting requests and then jump to the real instruction 19038 * handler. Unlike the Arm handler, we can't do this as a tail call 19039 * because rIBASE is caller save and we need to reload it. 19040 */ 19041 movl rSELF, %eax 19042 movl rPC, OUT_ARG0(%esp) 19043 movl %eax, OUT_ARG1(%esp) 19044 call dvmCheckInst # (dPC, self) 19045 movl rSELF, %ecx 19046 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19047 jmp *dvmAsmInstructionStart+(443*4) 19048 19049/* ------------------------------ */ 19050.L_ALT_OP_UNUSED_BCFF: /* 0x1bc */ 19051/* File: x86/alt_stub.S */ 19052/* 19053 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19054 * any interesting requests and then jump to the real instruction 19055 * handler. Unlike the Arm handler, we can't do this as a tail call 19056 * because rIBASE is caller save and we need to reload it. 19057 */ 19058 movl rSELF, %eax 19059 movl rPC, OUT_ARG0(%esp) 19060 movl %eax, OUT_ARG1(%esp) 19061 call dvmCheckInst # (dPC, self) 19062 movl rSELF, %ecx 19063 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19064 jmp *dvmAsmInstructionStart+(444*4) 19065 19066/* ------------------------------ */ 19067.L_ALT_OP_UNUSED_BDFF: /* 0x1bd */ 19068/* File: x86/alt_stub.S */ 19069/* 19070 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19071 * any interesting requests and then jump to the real instruction 19072 * handler. Unlike the Arm handler, we can't do this as a tail call 19073 * because rIBASE is caller save and we need to reload it. 19074 */ 19075 movl rSELF, %eax 19076 movl rPC, OUT_ARG0(%esp) 19077 movl %eax, OUT_ARG1(%esp) 19078 call dvmCheckInst # (dPC, self) 19079 movl rSELF, %ecx 19080 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19081 jmp *dvmAsmInstructionStart+(445*4) 19082 19083/* ------------------------------ */ 19084.L_ALT_OP_UNUSED_BEFF: /* 0x1be */ 19085/* File: x86/alt_stub.S */ 19086/* 19087 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19088 * any interesting requests and then jump to the real instruction 19089 * handler. Unlike the Arm handler, we can't do this as a tail call 19090 * because rIBASE is caller save and we need to reload it. 19091 */ 19092 movl rSELF, %eax 19093 movl rPC, OUT_ARG0(%esp) 19094 movl %eax, OUT_ARG1(%esp) 19095 call dvmCheckInst # (dPC, self) 19096 movl rSELF, %ecx 19097 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19098 jmp *dvmAsmInstructionStart+(446*4) 19099 19100/* ------------------------------ */ 19101.L_ALT_OP_UNUSED_BFFF: /* 0x1bf */ 19102/* File: x86/alt_stub.S */ 19103/* 19104 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19105 * any interesting requests and then jump to the real instruction 19106 * handler. Unlike the Arm handler, we can't do this as a tail call 19107 * because rIBASE is caller save and we need to reload it. 19108 */ 19109 movl rSELF, %eax 19110 movl rPC, OUT_ARG0(%esp) 19111 movl %eax, OUT_ARG1(%esp) 19112 call dvmCheckInst # (dPC, self) 19113 movl rSELF, %ecx 19114 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19115 jmp *dvmAsmInstructionStart+(447*4) 19116 19117/* ------------------------------ */ 19118.L_ALT_OP_UNUSED_C0FF: /* 0x1c0 */ 19119/* File: x86/alt_stub.S */ 19120/* 19121 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19122 * any interesting requests and then jump to the real instruction 19123 * handler. Unlike the Arm handler, we can't do this as a tail call 19124 * because rIBASE is caller save and we need to reload it. 19125 */ 19126 movl rSELF, %eax 19127 movl rPC, OUT_ARG0(%esp) 19128 movl %eax, OUT_ARG1(%esp) 19129 call dvmCheckInst # (dPC, self) 19130 movl rSELF, %ecx 19131 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19132 jmp *dvmAsmInstructionStart+(448*4) 19133 19134/* ------------------------------ */ 19135.L_ALT_OP_UNUSED_C1FF: /* 0x1c1 */ 19136/* File: x86/alt_stub.S */ 19137/* 19138 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19139 * any interesting requests and then jump to the real instruction 19140 * handler. Unlike the Arm handler, we can't do this as a tail call 19141 * because rIBASE is caller save and we need to reload it. 19142 */ 19143 movl rSELF, %eax 19144 movl rPC, OUT_ARG0(%esp) 19145 movl %eax, OUT_ARG1(%esp) 19146 call dvmCheckInst # (dPC, self) 19147 movl rSELF, %ecx 19148 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19149 jmp *dvmAsmInstructionStart+(449*4) 19150 19151/* ------------------------------ */ 19152.L_ALT_OP_UNUSED_C2FF: /* 0x1c2 */ 19153/* File: x86/alt_stub.S */ 19154/* 19155 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19156 * any interesting requests and then jump to the real instruction 19157 * handler. Unlike the Arm handler, we can't do this as a tail call 19158 * because rIBASE is caller save and we need to reload it. 19159 */ 19160 movl rSELF, %eax 19161 movl rPC, OUT_ARG0(%esp) 19162 movl %eax, OUT_ARG1(%esp) 19163 call dvmCheckInst # (dPC, self) 19164 movl rSELF, %ecx 19165 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19166 jmp *dvmAsmInstructionStart+(450*4) 19167 19168/* ------------------------------ */ 19169.L_ALT_OP_UNUSED_C3FF: /* 0x1c3 */ 19170/* File: x86/alt_stub.S */ 19171/* 19172 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19173 * any interesting requests and then jump to the real instruction 19174 * handler. Unlike the Arm handler, we can't do this as a tail call 19175 * because rIBASE is caller save and we need to reload it. 19176 */ 19177 movl rSELF, %eax 19178 movl rPC, OUT_ARG0(%esp) 19179 movl %eax, OUT_ARG1(%esp) 19180 call dvmCheckInst # (dPC, self) 19181 movl rSELF, %ecx 19182 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19183 jmp *dvmAsmInstructionStart+(451*4) 19184 19185/* ------------------------------ */ 19186.L_ALT_OP_UNUSED_C4FF: /* 0x1c4 */ 19187/* File: x86/alt_stub.S */ 19188/* 19189 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19190 * any interesting requests and then jump to the real instruction 19191 * handler. Unlike the Arm handler, we can't do this as a tail call 19192 * because rIBASE is caller save and we need to reload it. 19193 */ 19194 movl rSELF, %eax 19195 movl rPC, OUT_ARG0(%esp) 19196 movl %eax, OUT_ARG1(%esp) 19197 call dvmCheckInst # (dPC, self) 19198 movl rSELF, %ecx 19199 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19200 jmp *dvmAsmInstructionStart+(452*4) 19201 19202/* ------------------------------ */ 19203.L_ALT_OP_UNUSED_C5FF: /* 0x1c5 */ 19204/* File: x86/alt_stub.S */ 19205/* 19206 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19207 * any interesting requests and then jump to the real instruction 19208 * handler. Unlike the Arm handler, we can't do this as a tail call 19209 * because rIBASE is caller save and we need to reload it. 19210 */ 19211 movl rSELF, %eax 19212 movl rPC, OUT_ARG0(%esp) 19213 movl %eax, OUT_ARG1(%esp) 19214 call dvmCheckInst # (dPC, self) 19215 movl rSELF, %ecx 19216 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19217 jmp *dvmAsmInstructionStart+(453*4) 19218 19219/* ------------------------------ */ 19220.L_ALT_OP_UNUSED_C6FF: /* 0x1c6 */ 19221/* File: x86/alt_stub.S */ 19222/* 19223 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19224 * any interesting requests and then jump to the real instruction 19225 * handler. Unlike the Arm handler, we can't do this as a tail call 19226 * because rIBASE is caller save and we need to reload it. 19227 */ 19228 movl rSELF, %eax 19229 movl rPC, OUT_ARG0(%esp) 19230 movl %eax, OUT_ARG1(%esp) 19231 call dvmCheckInst # (dPC, self) 19232 movl rSELF, %ecx 19233 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19234 jmp *dvmAsmInstructionStart+(454*4) 19235 19236/* ------------------------------ */ 19237.L_ALT_OP_UNUSED_C7FF: /* 0x1c7 */ 19238/* File: x86/alt_stub.S */ 19239/* 19240 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19241 * any interesting requests and then jump to the real instruction 19242 * handler. Unlike the Arm handler, we can't do this as a tail call 19243 * because rIBASE is caller save and we need to reload it. 19244 */ 19245 movl rSELF, %eax 19246 movl rPC, OUT_ARG0(%esp) 19247 movl %eax, OUT_ARG1(%esp) 19248 call dvmCheckInst # (dPC, self) 19249 movl rSELF, %ecx 19250 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19251 jmp *dvmAsmInstructionStart+(455*4) 19252 19253/* ------------------------------ */ 19254.L_ALT_OP_UNUSED_C8FF: /* 0x1c8 */ 19255/* File: x86/alt_stub.S */ 19256/* 19257 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19258 * any interesting requests and then jump to the real instruction 19259 * handler. Unlike the Arm handler, we can't do this as a tail call 19260 * because rIBASE is caller save and we need to reload it. 19261 */ 19262 movl rSELF, %eax 19263 movl rPC, OUT_ARG0(%esp) 19264 movl %eax, OUT_ARG1(%esp) 19265 call dvmCheckInst # (dPC, self) 19266 movl rSELF, %ecx 19267 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19268 jmp *dvmAsmInstructionStart+(456*4) 19269 19270/* ------------------------------ */ 19271.L_ALT_OP_UNUSED_C9FF: /* 0x1c9 */ 19272/* File: x86/alt_stub.S */ 19273/* 19274 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19275 * any interesting requests and then jump to the real instruction 19276 * handler. Unlike the Arm handler, we can't do this as a tail call 19277 * because rIBASE is caller save and we need to reload it. 19278 */ 19279 movl rSELF, %eax 19280 movl rPC, OUT_ARG0(%esp) 19281 movl %eax, OUT_ARG1(%esp) 19282 call dvmCheckInst # (dPC, self) 19283 movl rSELF, %ecx 19284 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19285 jmp *dvmAsmInstructionStart+(457*4) 19286 19287/* ------------------------------ */ 19288.L_ALT_OP_UNUSED_CAFF: /* 0x1ca */ 19289/* File: x86/alt_stub.S */ 19290/* 19291 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19292 * any interesting requests and then jump to the real instruction 19293 * handler. Unlike the Arm handler, we can't do this as a tail call 19294 * because rIBASE is caller save and we need to reload it. 19295 */ 19296 movl rSELF, %eax 19297 movl rPC, OUT_ARG0(%esp) 19298 movl %eax, OUT_ARG1(%esp) 19299 call dvmCheckInst # (dPC, self) 19300 movl rSELF, %ecx 19301 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19302 jmp *dvmAsmInstructionStart+(458*4) 19303 19304/* ------------------------------ */ 19305.L_ALT_OP_UNUSED_CBFF: /* 0x1cb */ 19306/* File: x86/alt_stub.S */ 19307/* 19308 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19309 * any interesting requests and then jump to the real instruction 19310 * handler. Unlike the Arm handler, we can't do this as a tail call 19311 * because rIBASE is caller save and we need to reload it. 19312 */ 19313 movl rSELF, %eax 19314 movl rPC, OUT_ARG0(%esp) 19315 movl %eax, OUT_ARG1(%esp) 19316 call dvmCheckInst # (dPC, self) 19317 movl rSELF, %ecx 19318 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19319 jmp *dvmAsmInstructionStart+(459*4) 19320 19321/* ------------------------------ */ 19322.L_ALT_OP_UNUSED_CCFF: /* 0x1cc */ 19323/* File: x86/alt_stub.S */ 19324/* 19325 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19326 * any interesting requests and then jump to the real instruction 19327 * handler. Unlike the Arm handler, we can't do this as a tail call 19328 * because rIBASE is caller save and we need to reload it. 19329 */ 19330 movl rSELF, %eax 19331 movl rPC, OUT_ARG0(%esp) 19332 movl %eax, OUT_ARG1(%esp) 19333 call dvmCheckInst # (dPC, self) 19334 movl rSELF, %ecx 19335 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19336 jmp *dvmAsmInstructionStart+(460*4) 19337 19338/* ------------------------------ */ 19339.L_ALT_OP_UNUSED_CDFF: /* 0x1cd */ 19340/* File: x86/alt_stub.S */ 19341/* 19342 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19343 * any interesting requests and then jump to the real instruction 19344 * handler. Unlike the Arm handler, we can't do this as a tail call 19345 * because rIBASE is caller save and we need to reload it. 19346 */ 19347 movl rSELF, %eax 19348 movl rPC, OUT_ARG0(%esp) 19349 movl %eax, OUT_ARG1(%esp) 19350 call dvmCheckInst # (dPC, self) 19351 movl rSELF, %ecx 19352 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19353 jmp *dvmAsmInstructionStart+(461*4) 19354 19355/* ------------------------------ */ 19356.L_ALT_OP_UNUSED_CEFF: /* 0x1ce */ 19357/* File: x86/alt_stub.S */ 19358/* 19359 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19360 * any interesting requests and then jump to the real instruction 19361 * handler. Unlike the Arm handler, we can't do this as a tail call 19362 * because rIBASE is caller save and we need to reload it. 19363 */ 19364 movl rSELF, %eax 19365 movl rPC, OUT_ARG0(%esp) 19366 movl %eax, OUT_ARG1(%esp) 19367 call dvmCheckInst # (dPC, self) 19368 movl rSELF, %ecx 19369 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19370 jmp *dvmAsmInstructionStart+(462*4) 19371 19372/* ------------------------------ */ 19373.L_ALT_OP_UNUSED_CFFF: /* 0x1cf */ 19374/* File: x86/alt_stub.S */ 19375/* 19376 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19377 * any interesting requests and then jump to the real instruction 19378 * handler. Unlike the Arm handler, we can't do this as a tail call 19379 * because rIBASE is caller save and we need to reload it. 19380 */ 19381 movl rSELF, %eax 19382 movl rPC, OUT_ARG0(%esp) 19383 movl %eax, OUT_ARG1(%esp) 19384 call dvmCheckInst # (dPC, self) 19385 movl rSELF, %ecx 19386 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19387 jmp *dvmAsmInstructionStart+(463*4) 19388 19389/* ------------------------------ */ 19390.L_ALT_OP_UNUSED_D0FF: /* 0x1d0 */ 19391/* File: x86/alt_stub.S */ 19392/* 19393 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19394 * any interesting requests and then jump to the real instruction 19395 * handler. Unlike the Arm handler, we can't do this as a tail call 19396 * because rIBASE is caller save and we need to reload it. 19397 */ 19398 movl rSELF, %eax 19399 movl rPC, OUT_ARG0(%esp) 19400 movl %eax, OUT_ARG1(%esp) 19401 call dvmCheckInst # (dPC, self) 19402 movl rSELF, %ecx 19403 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19404 jmp *dvmAsmInstructionStart+(464*4) 19405 19406/* ------------------------------ */ 19407.L_ALT_OP_UNUSED_D1FF: /* 0x1d1 */ 19408/* File: x86/alt_stub.S */ 19409/* 19410 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19411 * any interesting requests and then jump to the real instruction 19412 * handler. Unlike the Arm handler, we can't do this as a tail call 19413 * because rIBASE is caller save and we need to reload it. 19414 */ 19415 movl rSELF, %eax 19416 movl rPC, OUT_ARG0(%esp) 19417 movl %eax, OUT_ARG1(%esp) 19418 call dvmCheckInst # (dPC, self) 19419 movl rSELF, %ecx 19420 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19421 jmp *dvmAsmInstructionStart+(465*4) 19422 19423/* ------------------------------ */ 19424.L_ALT_OP_UNUSED_D2FF: /* 0x1d2 */ 19425/* File: x86/alt_stub.S */ 19426/* 19427 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19428 * any interesting requests and then jump to the real instruction 19429 * handler. Unlike the Arm handler, we can't do this as a tail call 19430 * because rIBASE is caller save and we need to reload it. 19431 */ 19432 movl rSELF, %eax 19433 movl rPC, OUT_ARG0(%esp) 19434 movl %eax, OUT_ARG1(%esp) 19435 call dvmCheckInst # (dPC, self) 19436 movl rSELF, %ecx 19437 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19438 jmp *dvmAsmInstructionStart+(466*4) 19439 19440/* ------------------------------ */ 19441.L_ALT_OP_UNUSED_D3FF: /* 0x1d3 */ 19442/* File: x86/alt_stub.S */ 19443/* 19444 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19445 * any interesting requests and then jump to the real instruction 19446 * handler. Unlike the Arm handler, we can't do this as a tail call 19447 * because rIBASE is caller save and we need to reload it. 19448 */ 19449 movl rSELF, %eax 19450 movl rPC, OUT_ARG0(%esp) 19451 movl %eax, OUT_ARG1(%esp) 19452 call dvmCheckInst # (dPC, self) 19453 movl rSELF, %ecx 19454 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19455 jmp *dvmAsmInstructionStart+(467*4) 19456 19457/* ------------------------------ */ 19458.L_ALT_OP_UNUSED_D4FF: /* 0x1d4 */ 19459/* File: x86/alt_stub.S */ 19460/* 19461 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19462 * any interesting requests and then jump to the real instruction 19463 * handler. Unlike the Arm handler, we can't do this as a tail call 19464 * because rIBASE is caller save and we need to reload it. 19465 */ 19466 movl rSELF, %eax 19467 movl rPC, OUT_ARG0(%esp) 19468 movl %eax, OUT_ARG1(%esp) 19469 call dvmCheckInst # (dPC, self) 19470 movl rSELF, %ecx 19471 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19472 jmp *dvmAsmInstructionStart+(468*4) 19473 19474/* ------------------------------ */ 19475.L_ALT_OP_UNUSED_D5FF: /* 0x1d5 */ 19476/* File: x86/alt_stub.S */ 19477/* 19478 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19479 * any interesting requests and then jump to the real instruction 19480 * handler. Unlike the Arm handler, we can't do this as a tail call 19481 * because rIBASE is caller save and we need to reload it. 19482 */ 19483 movl rSELF, %eax 19484 movl rPC, OUT_ARG0(%esp) 19485 movl %eax, OUT_ARG1(%esp) 19486 call dvmCheckInst # (dPC, self) 19487 movl rSELF, %ecx 19488 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19489 jmp *dvmAsmInstructionStart+(469*4) 19490 19491/* ------------------------------ */ 19492.L_ALT_OP_UNUSED_D6FF: /* 0x1d6 */ 19493/* File: x86/alt_stub.S */ 19494/* 19495 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19496 * any interesting requests and then jump to the real instruction 19497 * handler. Unlike the Arm handler, we can't do this as a tail call 19498 * because rIBASE is caller save and we need to reload it. 19499 */ 19500 movl rSELF, %eax 19501 movl rPC, OUT_ARG0(%esp) 19502 movl %eax, OUT_ARG1(%esp) 19503 call dvmCheckInst # (dPC, self) 19504 movl rSELF, %ecx 19505 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19506 jmp *dvmAsmInstructionStart+(470*4) 19507 19508/* ------------------------------ */ 19509.L_ALT_OP_UNUSED_D7FF: /* 0x1d7 */ 19510/* File: x86/alt_stub.S */ 19511/* 19512 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19513 * any interesting requests and then jump to the real instruction 19514 * handler. Unlike the Arm handler, we can't do this as a tail call 19515 * because rIBASE is caller save and we need to reload it. 19516 */ 19517 movl rSELF, %eax 19518 movl rPC, OUT_ARG0(%esp) 19519 movl %eax, OUT_ARG1(%esp) 19520 call dvmCheckInst # (dPC, self) 19521 movl rSELF, %ecx 19522 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19523 jmp *dvmAsmInstructionStart+(471*4) 19524 19525/* ------------------------------ */ 19526.L_ALT_OP_UNUSED_D8FF: /* 0x1d8 */ 19527/* File: x86/alt_stub.S */ 19528/* 19529 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19530 * any interesting requests and then jump to the real instruction 19531 * handler. Unlike the Arm handler, we can't do this as a tail call 19532 * because rIBASE is caller save and we need to reload it. 19533 */ 19534 movl rSELF, %eax 19535 movl rPC, OUT_ARG0(%esp) 19536 movl %eax, OUT_ARG1(%esp) 19537 call dvmCheckInst # (dPC, self) 19538 movl rSELF, %ecx 19539 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19540 jmp *dvmAsmInstructionStart+(472*4) 19541 19542/* ------------------------------ */ 19543.L_ALT_OP_UNUSED_D9FF: /* 0x1d9 */ 19544/* File: x86/alt_stub.S */ 19545/* 19546 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19547 * any interesting requests and then jump to the real instruction 19548 * handler. Unlike the Arm handler, we can't do this as a tail call 19549 * because rIBASE is caller save and we need to reload it. 19550 */ 19551 movl rSELF, %eax 19552 movl rPC, OUT_ARG0(%esp) 19553 movl %eax, OUT_ARG1(%esp) 19554 call dvmCheckInst # (dPC, self) 19555 movl rSELF, %ecx 19556 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19557 jmp *dvmAsmInstructionStart+(473*4) 19558 19559/* ------------------------------ */ 19560.L_ALT_OP_UNUSED_DAFF: /* 0x1da */ 19561/* File: x86/alt_stub.S */ 19562/* 19563 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19564 * any interesting requests and then jump to the real instruction 19565 * handler. Unlike the Arm handler, we can't do this as a tail call 19566 * because rIBASE is caller save and we need to reload it. 19567 */ 19568 movl rSELF, %eax 19569 movl rPC, OUT_ARG0(%esp) 19570 movl %eax, OUT_ARG1(%esp) 19571 call dvmCheckInst # (dPC, self) 19572 movl rSELF, %ecx 19573 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19574 jmp *dvmAsmInstructionStart+(474*4) 19575 19576/* ------------------------------ */ 19577.L_ALT_OP_UNUSED_DBFF: /* 0x1db */ 19578/* File: x86/alt_stub.S */ 19579/* 19580 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19581 * any interesting requests and then jump to the real instruction 19582 * handler. Unlike the Arm handler, we can't do this as a tail call 19583 * because rIBASE is caller save and we need to reload it. 19584 */ 19585 movl rSELF, %eax 19586 movl rPC, OUT_ARG0(%esp) 19587 movl %eax, OUT_ARG1(%esp) 19588 call dvmCheckInst # (dPC, self) 19589 movl rSELF, %ecx 19590 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19591 jmp *dvmAsmInstructionStart+(475*4) 19592 19593/* ------------------------------ */ 19594.L_ALT_OP_UNUSED_DCFF: /* 0x1dc */ 19595/* File: x86/alt_stub.S */ 19596/* 19597 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19598 * any interesting requests and then jump to the real instruction 19599 * handler. Unlike the Arm handler, we can't do this as a tail call 19600 * because rIBASE is caller save and we need to reload it. 19601 */ 19602 movl rSELF, %eax 19603 movl rPC, OUT_ARG0(%esp) 19604 movl %eax, OUT_ARG1(%esp) 19605 call dvmCheckInst # (dPC, self) 19606 movl rSELF, %ecx 19607 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19608 jmp *dvmAsmInstructionStart+(476*4) 19609 19610/* ------------------------------ */ 19611.L_ALT_OP_UNUSED_DDFF: /* 0x1dd */ 19612/* File: x86/alt_stub.S */ 19613/* 19614 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19615 * any interesting requests and then jump to the real instruction 19616 * handler. Unlike the Arm handler, we can't do this as a tail call 19617 * because rIBASE is caller save and we need to reload it. 19618 */ 19619 movl rSELF, %eax 19620 movl rPC, OUT_ARG0(%esp) 19621 movl %eax, OUT_ARG1(%esp) 19622 call dvmCheckInst # (dPC, self) 19623 movl rSELF, %ecx 19624 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19625 jmp *dvmAsmInstructionStart+(477*4) 19626 19627/* ------------------------------ */ 19628.L_ALT_OP_UNUSED_DEFF: /* 0x1de */ 19629/* File: x86/alt_stub.S */ 19630/* 19631 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19632 * any interesting requests and then jump to the real instruction 19633 * handler. Unlike the Arm handler, we can't do this as a tail call 19634 * because rIBASE is caller save and we need to reload it. 19635 */ 19636 movl rSELF, %eax 19637 movl rPC, OUT_ARG0(%esp) 19638 movl %eax, OUT_ARG1(%esp) 19639 call dvmCheckInst # (dPC, self) 19640 movl rSELF, %ecx 19641 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19642 jmp *dvmAsmInstructionStart+(478*4) 19643 19644/* ------------------------------ */ 19645.L_ALT_OP_UNUSED_DFFF: /* 0x1df */ 19646/* File: x86/alt_stub.S */ 19647/* 19648 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19649 * any interesting requests and then jump to the real instruction 19650 * handler. Unlike the Arm handler, we can't do this as a tail call 19651 * because rIBASE is caller save and we need to reload it. 19652 */ 19653 movl rSELF, %eax 19654 movl rPC, OUT_ARG0(%esp) 19655 movl %eax, OUT_ARG1(%esp) 19656 call dvmCheckInst # (dPC, self) 19657 movl rSELF, %ecx 19658 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19659 jmp *dvmAsmInstructionStart+(479*4) 19660 19661/* ------------------------------ */ 19662.L_ALT_OP_UNUSED_E0FF: /* 0x1e0 */ 19663/* File: x86/alt_stub.S */ 19664/* 19665 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19666 * any interesting requests and then jump to the real instruction 19667 * handler. Unlike the Arm handler, we can't do this as a tail call 19668 * because rIBASE is caller save and we need to reload it. 19669 */ 19670 movl rSELF, %eax 19671 movl rPC, OUT_ARG0(%esp) 19672 movl %eax, OUT_ARG1(%esp) 19673 call dvmCheckInst # (dPC, self) 19674 movl rSELF, %ecx 19675 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19676 jmp *dvmAsmInstructionStart+(480*4) 19677 19678/* ------------------------------ */ 19679.L_ALT_OP_UNUSED_E1FF: /* 0x1e1 */ 19680/* File: x86/alt_stub.S */ 19681/* 19682 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19683 * any interesting requests and then jump to the real instruction 19684 * handler. Unlike the Arm handler, we can't do this as a tail call 19685 * because rIBASE is caller save and we need to reload it. 19686 */ 19687 movl rSELF, %eax 19688 movl rPC, OUT_ARG0(%esp) 19689 movl %eax, OUT_ARG1(%esp) 19690 call dvmCheckInst # (dPC, self) 19691 movl rSELF, %ecx 19692 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19693 jmp *dvmAsmInstructionStart+(481*4) 19694 19695/* ------------------------------ */ 19696.L_ALT_OP_UNUSED_E2FF: /* 0x1e2 */ 19697/* File: x86/alt_stub.S */ 19698/* 19699 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19700 * any interesting requests and then jump to the real instruction 19701 * handler. Unlike the Arm handler, we can't do this as a tail call 19702 * because rIBASE is caller save and we need to reload it. 19703 */ 19704 movl rSELF, %eax 19705 movl rPC, OUT_ARG0(%esp) 19706 movl %eax, OUT_ARG1(%esp) 19707 call dvmCheckInst # (dPC, self) 19708 movl rSELF, %ecx 19709 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19710 jmp *dvmAsmInstructionStart+(482*4) 19711 19712/* ------------------------------ */ 19713.L_ALT_OP_UNUSED_E3FF: /* 0x1e3 */ 19714/* File: x86/alt_stub.S */ 19715/* 19716 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19717 * any interesting requests and then jump to the real instruction 19718 * handler. Unlike the Arm handler, we can't do this as a tail call 19719 * because rIBASE is caller save and we need to reload it. 19720 */ 19721 movl rSELF, %eax 19722 movl rPC, OUT_ARG0(%esp) 19723 movl %eax, OUT_ARG1(%esp) 19724 call dvmCheckInst # (dPC, self) 19725 movl rSELF, %ecx 19726 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19727 jmp *dvmAsmInstructionStart+(483*4) 19728 19729/* ------------------------------ */ 19730.L_ALT_OP_UNUSED_E4FF: /* 0x1e4 */ 19731/* File: x86/alt_stub.S */ 19732/* 19733 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19734 * any interesting requests and then jump to the real instruction 19735 * handler. Unlike the Arm handler, we can't do this as a tail call 19736 * because rIBASE is caller save and we need to reload it. 19737 */ 19738 movl rSELF, %eax 19739 movl rPC, OUT_ARG0(%esp) 19740 movl %eax, OUT_ARG1(%esp) 19741 call dvmCheckInst # (dPC, self) 19742 movl rSELF, %ecx 19743 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19744 jmp *dvmAsmInstructionStart+(484*4) 19745 19746/* ------------------------------ */ 19747.L_ALT_OP_UNUSED_E5FF: /* 0x1e5 */ 19748/* File: x86/alt_stub.S */ 19749/* 19750 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19751 * any interesting requests and then jump to the real instruction 19752 * handler. Unlike the Arm handler, we can't do this as a tail call 19753 * because rIBASE is caller save and we need to reload it. 19754 */ 19755 movl rSELF, %eax 19756 movl rPC, OUT_ARG0(%esp) 19757 movl %eax, OUT_ARG1(%esp) 19758 call dvmCheckInst # (dPC, self) 19759 movl rSELF, %ecx 19760 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19761 jmp *dvmAsmInstructionStart+(485*4) 19762 19763/* ------------------------------ */ 19764.L_ALT_OP_UNUSED_E6FF: /* 0x1e6 */ 19765/* File: x86/alt_stub.S */ 19766/* 19767 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19768 * any interesting requests and then jump to the real instruction 19769 * handler. Unlike the Arm handler, we can't do this as a tail call 19770 * because rIBASE is caller save and we need to reload it. 19771 */ 19772 movl rSELF, %eax 19773 movl rPC, OUT_ARG0(%esp) 19774 movl %eax, OUT_ARG1(%esp) 19775 call dvmCheckInst # (dPC, self) 19776 movl rSELF, %ecx 19777 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19778 jmp *dvmAsmInstructionStart+(486*4) 19779 19780/* ------------------------------ */ 19781.L_ALT_OP_UNUSED_E7FF: /* 0x1e7 */ 19782/* File: x86/alt_stub.S */ 19783/* 19784 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19785 * any interesting requests and then jump to the real instruction 19786 * handler. Unlike the Arm handler, we can't do this as a tail call 19787 * because rIBASE is caller save and we need to reload it. 19788 */ 19789 movl rSELF, %eax 19790 movl rPC, OUT_ARG0(%esp) 19791 movl %eax, OUT_ARG1(%esp) 19792 call dvmCheckInst # (dPC, self) 19793 movl rSELF, %ecx 19794 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19795 jmp *dvmAsmInstructionStart+(487*4) 19796 19797/* ------------------------------ */ 19798.L_ALT_OP_UNUSED_E8FF: /* 0x1e8 */ 19799/* File: x86/alt_stub.S */ 19800/* 19801 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19802 * any interesting requests and then jump to the real instruction 19803 * handler. Unlike the Arm handler, we can't do this as a tail call 19804 * because rIBASE is caller save and we need to reload it. 19805 */ 19806 movl rSELF, %eax 19807 movl rPC, OUT_ARG0(%esp) 19808 movl %eax, OUT_ARG1(%esp) 19809 call dvmCheckInst # (dPC, self) 19810 movl rSELF, %ecx 19811 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19812 jmp *dvmAsmInstructionStart+(488*4) 19813 19814/* ------------------------------ */ 19815.L_ALT_OP_UNUSED_E9FF: /* 0x1e9 */ 19816/* File: x86/alt_stub.S */ 19817/* 19818 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19819 * any interesting requests and then jump to the real instruction 19820 * handler. Unlike the Arm handler, we can't do this as a tail call 19821 * because rIBASE is caller save and we need to reload it. 19822 */ 19823 movl rSELF, %eax 19824 movl rPC, OUT_ARG0(%esp) 19825 movl %eax, OUT_ARG1(%esp) 19826 call dvmCheckInst # (dPC, self) 19827 movl rSELF, %ecx 19828 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19829 jmp *dvmAsmInstructionStart+(489*4) 19830 19831/* ------------------------------ */ 19832.L_ALT_OP_UNUSED_EAFF: /* 0x1ea */ 19833/* File: x86/alt_stub.S */ 19834/* 19835 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19836 * any interesting requests and then jump to the real instruction 19837 * handler. Unlike the Arm handler, we can't do this as a tail call 19838 * because rIBASE is caller save and we need to reload it. 19839 */ 19840 movl rSELF, %eax 19841 movl rPC, OUT_ARG0(%esp) 19842 movl %eax, OUT_ARG1(%esp) 19843 call dvmCheckInst # (dPC, self) 19844 movl rSELF, %ecx 19845 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19846 jmp *dvmAsmInstructionStart+(490*4) 19847 19848/* ------------------------------ */ 19849.L_ALT_OP_UNUSED_EBFF: /* 0x1eb */ 19850/* File: x86/alt_stub.S */ 19851/* 19852 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19853 * any interesting requests and then jump to the real instruction 19854 * handler. Unlike the Arm handler, we can't do this as a tail call 19855 * because rIBASE is caller save and we need to reload it. 19856 */ 19857 movl rSELF, %eax 19858 movl rPC, OUT_ARG0(%esp) 19859 movl %eax, OUT_ARG1(%esp) 19860 call dvmCheckInst # (dPC, self) 19861 movl rSELF, %ecx 19862 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19863 jmp *dvmAsmInstructionStart+(491*4) 19864 19865/* ------------------------------ */ 19866.L_ALT_OP_UNUSED_ECFF: /* 0x1ec */ 19867/* File: x86/alt_stub.S */ 19868/* 19869 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19870 * any interesting requests and then jump to the real instruction 19871 * handler. Unlike the Arm handler, we can't do this as a tail call 19872 * because rIBASE is caller save and we need to reload it. 19873 */ 19874 movl rSELF, %eax 19875 movl rPC, OUT_ARG0(%esp) 19876 movl %eax, OUT_ARG1(%esp) 19877 call dvmCheckInst # (dPC, self) 19878 movl rSELF, %ecx 19879 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19880 jmp *dvmAsmInstructionStart+(492*4) 19881 19882/* ------------------------------ */ 19883.L_ALT_OP_UNUSED_EDFF: /* 0x1ed */ 19884/* File: x86/alt_stub.S */ 19885/* 19886 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19887 * any interesting requests and then jump to the real instruction 19888 * handler. Unlike the Arm handler, we can't do this as a tail call 19889 * because rIBASE is caller save and we need to reload it. 19890 */ 19891 movl rSELF, %eax 19892 movl rPC, OUT_ARG0(%esp) 19893 movl %eax, OUT_ARG1(%esp) 19894 call dvmCheckInst # (dPC, self) 19895 movl rSELF, %ecx 19896 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19897 jmp *dvmAsmInstructionStart+(493*4) 19898 19899/* ------------------------------ */ 19900.L_ALT_OP_UNUSED_EEFF: /* 0x1ee */ 19901/* File: x86/alt_stub.S */ 19902/* 19903 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19904 * any interesting requests and then jump to the real instruction 19905 * handler. Unlike the Arm handler, we can't do this as a tail call 19906 * because rIBASE is caller save and we need to reload it. 19907 */ 19908 movl rSELF, %eax 19909 movl rPC, OUT_ARG0(%esp) 19910 movl %eax, OUT_ARG1(%esp) 19911 call dvmCheckInst # (dPC, self) 19912 movl rSELF, %ecx 19913 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19914 jmp *dvmAsmInstructionStart+(494*4) 19915 19916/* ------------------------------ */ 19917.L_ALT_OP_UNUSED_EFFF: /* 0x1ef */ 19918/* File: x86/alt_stub.S */ 19919/* 19920 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19921 * any interesting requests and then jump to the real instruction 19922 * handler. Unlike the Arm handler, we can't do this as a tail call 19923 * because rIBASE is caller save and we need to reload it. 19924 */ 19925 movl rSELF, %eax 19926 movl rPC, OUT_ARG0(%esp) 19927 movl %eax, OUT_ARG1(%esp) 19928 call dvmCheckInst # (dPC, self) 19929 movl rSELF, %ecx 19930 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19931 jmp *dvmAsmInstructionStart+(495*4) 19932 19933/* ------------------------------ */ 19934.L_ALT_OP_UNUSED_F0FF: /* 0x1f0 */ 19935/* File: x86/alt_stub.S */ 19936/* 19937 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19938 * any interesting requests and then jump to the real instruction 19939 * handler. Unlike the Arm handler, we can't do this as a tail call 19940 * because rIBASE is caller save and we need to reload it. 19941 */ 19942 movl rSELF, %eax 19943 movl rPC, OUT_ARG0(%esp) 19944 movl %eax, OUT_ARG1(%esp) 19945 call dvmCheckInst # (dPC, self) 19946 movl rSELF, %ecx 19947 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19948 jmp *dvmAsmInstructionStart+(496*4) 19949 19950/* ------------------------------ */ 19951.L_ALT_OP_UNUSED_F1FF: /* 0x1f1 */ 19952/* File: x86/alt_stub.S */ 19953/* 19954 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19955 * any interesting requests and then jump to the real instruction 19956 * handler. Unlike the Arm handler, we can't do this as a tail call 19957 * because rIBASE is caller save and we need to reload it. 19958 */ 19959 movl rSELF, %eax 19960 movl rPC, OUT_ARG0(%esp) 19961 movl %eax, OUT_ARG1(%esp) 19962 call dvmCheckInst # (dPC, self) 19963 movl rSELF, %ecx 19964 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19965 jmp *dvmAsmInstructionStart+(497*4) 19966 19967/* ------------------------------ */ 19968.L_ALT_OP_INVOKE_OBJECT_INIT_JUMBO: /* 0x1f2 */ 19969/* File: x86/alt_stub.S */ 19970/* 19971 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19972 * any interesting requests and then jump to the real instruction 19973 * handler. Unlike the Arm handler, we can't do this as a tail call 19974 * because rIBASE is caller save and we need to reload it. 19975 */ 19976 movl rSELF, %eax 19977 movl rPC, OUT_ARG0(%esp) 19978 movl %eax, OUT_ARG1(%esp) 19979 call dvmCheckInst # (dPC, self) 19980 movl rSELF, %ecx 19981 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19982 jmp *dvmAsmInstructionStart+(498*4) 19983 19984/* ------------------------------ */ 19985.L_ALT_OP_IGET_VOLATILE_JUMBO: /* 0x1f3 */ 19986/* File: x86/alt_stub.S */ 19987/* 19988 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19989 * any interesting requests and then jump to the real instruction 19990 * handler. Unlike the Arm handler, we can't do this as a tail call 19991 * because rIBASE is caller save and we need to reload it. 19992 */ 19993 movl rSELF, %eax 19994 movl rPC, OUT_ARG0(%esp) 19995 movl %eax, OUT_ARG1(%esp) 19996 call dvmCheckInst # (dPC, self) 19997 movl rSELF, %ecx 19998 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19999 jmp *dvmAsmInstructionStart+(499*4) 20000 20001/* ------------------------------ */ 20002.L_ALT_OP_IGET_WIDE_VOLATILE_JUMBO: /* 0x1f4 */ 20003/* File: x86/alt_stub.S */ 20004/* 20005 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 20006 * any interesting requests and then jump to the real instruction 20007 * handler. Unlike the Arm handler, we can't do this as a tail call 20008 * because rIBASE is caller save and we need to reload it. 20009 */ 20010 movl rSELF, %eax 20011 movl rPC, OUT_ARG0(%esp) 20012 movl %eax, OUT_ARG1(%esp) 20013 call dvmCheckInst # (dPC, self) 20014 movl rSELF, %ecx 20015 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 20016 jmp *dvmAsmInstructionStart+(500*4) 20017 20018/* ------------------------------ */ 20019.L_ALT_OP_IGET_OBJECT_VOLATILE_JUMBO: /* 0x1f5 */ 20020/* File: x86/alt_stub.S */ 20021/* 20022 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 20023 * any interesting requests and then jump to the real instruction 20024 * handler. Unlike the Arm handler, we can't do this as a tail call 20025 * because rIBASE is caller save and we need to reload it. 20026 */ 20027 movl rSELF, %eax 20028 movl rPC, OUT_ARG0(%esp) 20029 movl %eax, OUT_ARG1(%esp) 20030 call dvmCheckInst # (dPC, self) 20031 movl rSELF, %ecx 20032 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 20033 jmp *dvmAsmInstructionStart+(501*4) 20034 20035/* ------------------------------ */ 20036.L_ALT_OP_IPUT_VOLATILE_JUMBO: /* 0x1f6 */ 20037/* File: x86/alt_stub.S */ 20038/* 20039 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 20040 * any interesting requests and then jump to the real instruction 20041 * handler. Unlike the Arm handler, we can't do this as a tail call 20042 * because rIBASE is caller save and we need to reload it. 20043 */ 20044 movl rSELF, %eax 20045 movl rPC, OUT_ARG0(%esp) 20046 movl %eax, OUT_ARG1(%esp) 20047 call dvmCheckInst # (dPC, self) 20048 movl rSELF, %ecx 20049 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 20050 jmp *dvmAsmInstructionStart+(502*4) 20051 20052/* ------------------------------ */ 20053.L_ALT_OP_IPUT_WIDE_VOLATILE_JUMBO: /* 0x1f7 */ 20054/* File: x86/alt_stub.S */ 20055/* 20056 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 20057 * any interesting requests and then jump to the real instruction 20058 * handler. Unlike the Arm handler, we can't do this as a tail call 20059 * because rIBASE is caller save and we need to reload it. 20060 */ 20061 movl rSELF, %eax 20062 movl rPC, OUT_ARG0(%esp) 20063 movl %eax, OUT_ARG1(%esp) 20064 call dvmCheckInst # (dPC, self) 20065 movl rSELF, %ecx 20066 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 20067 jmp *dvmAsmInstructionStart+(503*4) 20068 20069/* ------------------------------ */ 20070.L_ALT_OP_IPUT_OBJECT_VOLATILE_JUMBO: /* 0x1f8 */ 20071/* File: x86/alt_stub.S */ 20072/* 20073 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 20074 * any interesting requests and then jump to the real instruction 20075 * handler. Unlike the Arm handler, we can't do this as a tail call 20076 * because rIBASE is caller save and we need to reload it. 20077 */ 20078 movl rSELF, %eax 20079 movl rPC, OUT_ARG0(%esp) 20080 movl %eax, OUT_ARG1(%esp) 20081 call dvmCheckInst # (dPC, self) 20082 movl rSELF, %ecx 20083 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 20084 jmp *dvmAsmInstructionStart+(504*4) 20085 20086/* ------------------------------ */ 20087.L_ALT_OP_SGET_VOLATILE_JUMBO: /* 0x1f9 */ 20088/* File: x86/alt_stub.S */ 20089/* 20090 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 20091 * any interesting requests and then jump to the real instruction 20092 * handler. Unlike the Arm handler, we can't do this as a tail call 20093 * because rIBASE is caller save and we need to reload it. 20094 */ 20095 movl rSELF, %eax 20096 movl rPC, OUT_ARG0(%esp) 20097 movl %eax, OUT_ARG1(%esp) 20098 call dvmCheckInst # (dPC, self) 20099 movl rSELF, %ecx 20100 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 20101 jmp *dvmAsmInstructionStart+(505*4) 20102 20103/* ------------------------------ */ 20104.L_ALT_OP_SGET_WIDE_VOLATILE_JUMBO: /* 0x1fa */ 20105/* File: x86/alt_stub.S */ 20106/* 20107 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 20108 * any interesting requests and then jump to the real instruction 20109 * handler. Unlike the Arm handler, we can't do this as a tail call 20110 * because rIBASE is caller save and we need to reload it. 20111 */ 20112 movl rSELF, %eax 20113 movl rPC, OUT_ARG0(%esp) 20114 movl %eax, OUT_ARG1(%esp) 20115 call dvmCheckInst # (dPC, self) 20116 movl rSELF, %ecx 20117 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 20118 jmp *dvmAsmInstructionStart+(506*4) 20119 20120/* ------------------------------ */ 20121.L_ALT_OP_SGET_OBJECT_VOLATILE_JUMBO: /* 0x1fb */ 20122/* File: x86/alt_stub.S */ 20123/* 20124 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 20125 * any interesting requests and then jump to the real instruction 20126 * handler. Unlike the Arm handler, we can't do this as a tail call 20127 * because rIBASE is caller save and we need to reload it. 20128 */ 20129 movl rSELF, %eax 20130 movl rPC, OUT_ARG0(%esp) 20131 movl %eax, OUT_ARG1(%esp) 20132 call dvmCheckInst # (dPC, self) 20133 movl rSELF, %ecx 20134 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 20135 jmp *dvmAsmInstructionStart+(507*4) 20136 20137/* ------------------------------ */ 20138.L_ALT_OP_SPUT_VOLATILE_JUMBO: /* 0x1fc */ 20139/* File: x86/alt_stub.S */ 20140/* 20141 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 20142 * any interesting requests and then jump to the real instruction 20143 * handler. Unlike the Arm handler, we can't do this as a tail call 20144 * because rIBASE is caller save and we need to reload it. 20145 */ 20146 movl rSELF, %eax 20147 movl rPC, OUT_ARG0(%esp) 20148 movl %eax, OUT_ARG1(%esp) 20149 call dvmCheckInst # (dPC, self) 20150 movl rSELF, %ecx 20151 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 20152 jmp *dvmAsmInstructionStart+(508*4) 20153 20154/* ------------------------------ */ 20155.L_ALT_OP_SPUT_WIDE_VOLATILE_JUMBO: /* 0x1fd */ 20156/* File: x86/alt_stub.S */ 20157/* 20158 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 20159 * any interesting requests and then jump to the real instruction 20160 * handler. Unlike the Arm handler, we can't do this as a tail call 20161 * because rIBASE is caller save and we need to reload it. 20162 */ 20163 movl rSELF, %eax 20164 movl rPC, OUT_ARG0(%esp) 20165 movl %eax, OUT_ARG1(%esp) 20166 call dvmCheckInst # (dPC, self) 20167 movl rSELF, %ecx 20168 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 20169 jmp *dvmAsmInstructionStart+(509*4) 20170 20171/* ------------------------------ */ 20172.L_ALT_OP_SPUT_OBJECT_VOLATILE_JUMBO: /* 0x1fe */ 20173/* File: x86/alt_stub.S */ 20174/* 20175 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 20176 * any interesting requests and then jump to the real instruction 20177 * handler. Unlike the Arm handler, we can't do this as a tail call 20178 * because rIBASE is caller save and we need to reload it. 20179 */ 20180 movl rSELF, %eax 20181 movl rPC, OUT_ARG0(%esp) 20182 movl %eax, OUT_ARG1(%esp) 20183 call dvmCheckInst # (dPC, self) 20184 movl rSELF, %ecx 20185 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 20186 jmp *dvmAsmInstructionStart+(510*4) 20187 20188/* ------------------------------ */ 20189.L_ALT_OP_THROW_VERIFICATION_ERROR_JUMBO: /* 0x1ff */ 20190/* File: x86/alt_stub.S */ 20191/* 20192 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 20193 * any interesting requests and then jump to the real instruction 20194 * handler. Unlike the Arm handler, we can't do this as a tail call 20195 * because rIBASE is caller save and we need to reload it. 20196 */ 20197 movl rSELF, %eax 20198 movl rPC, OUT_ARG0(%esp) 20199 movl %eax, OUT_ARG1(%esp) 20200 call dvmCheckInst # (dPC, self) 20201 movl rSELF, %ecx 20202 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 20203 jmp *dvmAsmInstructionStart+(511*4) 20204 20205 .size dvmAsmAltInstructionStartCode, .-dvmAsmAltInstructionStartCode 20206 .global dvmAsmAltInstructionEndCode 20207dvmAsmAltInstructionEndCode: 20208 20209 .global dvmAsmInstructionStart 20210 .text 20211dvmAsmInstructionStart: 20212 .long .L_OP_NOP /* 0x00 */ 20213 .long .L_OP_MOVE /* 0x01 */ 20214 .long .L_OP_MOVE_FROM16 /* 0x02 */ 20215 .long .L_OP_MOVE_16 /* 0x03 */ 20216 .long .L_OP_MOVE_WIDE /* 0x04 */ 20217 .long .L_OP_MOVE_WIDE_FROM16 /* 0x05 */ 20218 .long .L_OP_MOVE_WIDE_16 /* 0x06 */ 20219 .long .L_OP_MOVE_OBJECT /* 0x07 */ 20220 .long .L_OP_MOVE_OBJECT_FROM16 /* 0x08 */ 20221 .long .L_OP_MOVE_OBJECT_16 /* 0x09 */ 20222 .long .L_OP_MOVE_RESULT /* 0x0a */ 20223 .long .L_OP_MOVE_RESULT_WIDE /* 0x0b */ 20224 .long .L_OP_MOVE_RESULT_OBJECT /* 0x0c */ 20225 .long .L_OP_MOVE_EXCEPTION /* 0x0d */ 20226 .long .L_OP_RETURN_VOID /* 0x0e */ 20227 .long .L_OP_RETURN /* 0x0f */ 20228 .long .L_OP_RETURN_WIDE /* 0x10 */ 20229 .long .L_OP_RETURN_OBJECT /* 0x11 */ 20230 .long .L_OP_CONST_4 /* 0x12 */ 20231 .long .L_OP_CONST_16 /* 0x13 */ 20232 .long .L_OP_CONST /* 0x14 */ 20233 .long .L_OP_CONST_HIGH16 /* 0x15 */ 20234 .long .L_OP_CONST_WIDE_16 /* 0x16 */ 20235 .long .L_OP_CONST_WIDE_32 /* 0x17 */ 20236 .long .L_OP_CONST_WIDE /* 0x18 */ 20237 .long .L_OP_CONST_WIDE_HIGH16 /* 0x19 */ 20238 .long .L_OP_CONST_STRING /* 0x1a */ 20239 .long .L_OP_CONST_STRING_JUMBO /* 0x1b */ 20240 .long .L_OP_CONST_CLASS /* 0x1c */ 20241 .long .L_OP_MONITOR_ENTER /* 0x1d */ 20242 .long .L_OP_MONITOR_EXIT /* 0x1e */ 20243 .long .L_OP_CHECK_CAST /* 0x1f */ 20244 .long .L_OP_INSTANCE_OF /* 0x20 */ 20245 .long .L_OP_ARRAY_LENGTH /* 0x21 */ 20246 .long .L_OP_NEW_INSTANCE /* 0x22 */ 20247 .long .L_OP_NEW_ARRAY /* 0x23 */ 20248 .long .L_OP_FILLED_NEW_ARRAY /* 0x24 */ 20249 .long .L_OP_FILLED_NEW_ARRAY_RANGE /* 0x25 */ 20250 .long .L_OP_FILL_ARRAY_DATA /* 0x26 */ 20251 .long .L_OP_THROW /* 0x27 */ 20252 .long .L_OP_GOTO /* 0x28 */ 20253 .long .L_OP_GOTO_16 /* 0x29 */ 20254 .long .L_OP_GOTO_32 /* 0x2a */ 20255 .long .L_OP_PACKED_SWITCH /* 0x2b */ 20256 .long .L_OP_SPARSE_SWITCH /* 0x2c */ 20257 .long .L_OP_CMPL_FLOAT /* 0x2d */ 20258 .long .L_OP_CMPG_FLOAT /* 0x2e */ 20259 .long .L_OP_CMPL_DOUBLE /* 0x2f */ 20260 .long .L_OP_CMPG_DOUBLE /* 0x30 */ 20261 .long .L_OP_CMP_LONG /* 0x31 */ 20262 .long .L_OP_IF_EQ /* 0x32 */ 20263 .long .L_OP_IF_NE /* 0x33 */ 20264 .long .L_OP_IF_LT /* 0x34 */ 20265 .long .L_OP_IF_GE /* 0x35 */ 20266 .long .L_OP_IF_GT /* 0x36 */ 20267 .long .L_OP_IF_LE /* 0x37 */ 20268 .long .L_OP_IF_EQZ /* 0x38 */ 20269 .long .L_OP_IF_NEZ /* 0x39 */ 20270 .long .L_OP_IF_LTZ /* 0x3a */ 20271 .long .L_OP_IF_GEZ /* 0x3b */ 20272 .long .L_OP_IF_GTZ /* 0x3c */ 20273 .long .L_OP_IF_LEZ /* 0x3d */ 20274 .long .L_OP_UNUSED_3E /* 0x3e */ 20275 .long .L_OP_UNUSED_3F /* 0x3f */ 20276 .long .L_OP_UNUSED_40 /* 0x40 */ 20277 .long .L_OP_UNUSED_41 /* 0x41 */ 20278 .long .L_OP_UNUSED_42 /* 0x42 */ 20279 .long .L_OP_UNUSED_43 /* 0x43 */ 20280 .long .L_OP_AGET /* 0x44 */ 20281 .long .L_OP_AGET_WIDE /* 0x45 */ 20282 .long .L_OP_AGET_OBJECT /* 0x46 */ 20283 .long .L_OP_AGET_BOOLEAN /* 0x47 */ 20284 .long .L_OP_AGET_BYTE /* 0x48 */ 20285 .long .L_OP_AGET_CHAR /* 0x49 */ 20286 .long .L_OP_AGET_SHORT /* 0x4a */ 20287 .long .L_OP_APUT /* 0x4b */ 20288 .long .L_OP_APUT_WIDE /* 0x4c */ 20289 .long .L_OP_APUT_OBJECT /* 0x4d */ 20290 .long .L_OP_APUT_BOOLEAN /* 0x4e */ 20291 .long .L_OP_APUT_BYTE /* 0x4f */ 20292 .long .L_OP_APUT_CHAR /* 0x50 */ 20293 .long .L_OP_APUT_SHORT /* 0x51 */ 20294 .long .L_OP_IGET /* 0x52 */ 20295 .long .L_OP_IGET_WIDE /* 0x53 */ 20296 .long .L_OP_IGET_OBJECT /* 0x54 */ 20297 .long .L_OP_IGET_BOOLEAN /* 0x55 */ 20298 .long .L_OP_IGET_BYTE /* 0x56 */ 20299 .long .L_OP_IGET_CHAR /* 0x57 */ 20300 .long .L_OP_IGET_SHORT /* 0x58 */ 20301 .long .L_OP_IPUT /* 0x59 */ 20302 .long .L_OP_IPUT_WIDE /* 0x5a */ 20303 .long .L_OP_IPUT_OBJECT /* 0x5b */ 20304 .long .L_OP_IPUT_BOOLEAN /* 0x5c */ 20305 .long .L_OP_IPUT_BYTE /* 0x5d */ 20306 .long .L_OP_IPUT_CHAR /* 0x5e */ 20307 .long .L_OP_IPUT_SHORT /* 0x5f */ 20308 .long .L_OP_SGET /* 0x60 */ 20309 .long .L_OP_SGET_WIDE /* 0x61 */ 20310 .long .L_OP_SGET_OBJECT /* 0x62 */ 20311 .long .L_OP_SGET_BOOLEAN /* 0x63 */ 20312 .long .L_OP_SGET_BYTE /* 0x64 */ 20313 .long .L_OP_SGET_CHAR /* 0x65 */ 20314 .long .L_OP_SGET_SHORT /* 0x66 */ 20315 .long .L_OP_SPUT /* 0x67 */ 20316 .long .L_OP_SPUT_WIDE /* 0x68 */ 20317 .long .L_OP_SPUT_OBJECT /* 0x69 */ 20318 .long .L_OP_SPUT_BOOLEAN /* 0x6a */ 20319 .long .L_OP_SPUT_BYTE /* 0x6b */ 20320 .long .L_OP_SPUT_CHAR /* 0x6c */ 20321 .long .L_OP_SPUT_SHORT /* 0x6d */ 20322 .long .L_OP_INVOKE_VIRTUAL /* 0x6e */ 20323 .long .L_OP_INVOKE_SUPER /* 0x6f */ 20324 .long .L_OP_INVOKE_DIRECT /* 0x70 */ 20325 .long .L_OP_INVOKE_STATIC /* 0x71 */ 20326 .long .L_OP_INVOKE_INTERFACE /* 0x72 */ 20327 .long .L_OP_UNUSED_73 /* 0x73 */ 20328 .long .L_OP_INVOKE_VIRTUAL_RANGE /* 0x74 */ 20329 .long .L_OP_INVOKE_SUPER_RANGE /* 0x75 */ 20330 .long .L_OP_INVOKE_DIRECT_RANGE /* 0x76 */ 20331 .long .L_OP_INVOKE_STATIC_RANGE /* 0x77 */ 20332 .long .L_OP_INVOKE_INTERFACE_RANGE /* 0x78 */ 20333 .long .L_OP_UNUSED_79 /* 0x79 */ 20334 .long .L_OP_UNUSED_7A /* 0x7a */ 20335 .long .L_OP_NEG_INT /* 0x7b */ 20336 .long .L_OP_NOT_INT /* 0x7c */ 20337 .long .L_OP_NEG_LONG /* 0x7d */ 20338 .long .L_OP_NOT_LONG /* 0x7e */ 20339 .long .L_OP_NEG_FLOAT /* 0x7f */ 20340 .long .L_OP_NEG_DOUBLE /* 0x80 */ 20341 .long .L_OP_INT_TO_LONG /* 0x81 */ 20342 .long .L_OP_INT_TO_FLOAT /* 0x82 */ 20343 .long .L_OP_INT_TO_DOUBLE /* 0x83 */ 20344 .long .L_OP_LONG_TO_INT /* 0x84 */ 20345 .long .L_OP_LONG_TO_FLOAT /* 0x85 */ 20346 .long .L_OP_LONG_TO_DOUBLE /* 0x86 */ 20347 .long .L_OP_FLOAT_TO_INT /* 0x87 */ 20348 .long .L_OP_FLOAT_TO_LONG /* 0x88 */ 20349 .long .L_OP_FLOAT_TO_DOUBLE /* 0x89 */ 20350 .long .L_OP_DOUBLE_TO_INT /* 0x8a */ 20351 .long .L_OP_DOUBLE_TO_LONG /* 0x8b */ 20352 .long .L_OP_DOUBLE_TO_FLOAT /* 0x8c */ 20353 .long .L_OP_INT_TO_BYTE /* 0x8d */ 20354 .long .L_OP_INT_TO_CHAR /* 0x8e */ 20355 .long .L_OP_INT_TO_SHORT /* 0x8f */ 20356 .long .L_OP_ADD_INT /* 0x90 */ 20357 .long .L_OP_SUB_INT /* 0x91 */ 20358 .long .L_OP_MUL_INT /* 0x92 */ 20359 .long .L_OP_DIV_INT /* 0x93 */ 20360 .long .L_OP_REM_INT /* 0x94 */ 20361 .long .L_OP_AND_INT /* 0x95 */ 20362 .long .L_OP_OR_INT /* 0x96 */ 20363 .long .L_OP_XOR_INT /* 0x97 */ 20364 .long .L_OP_SHL_INT /* 0x98 */ 20365 .long .L_OP_SHR_INT /* 0x99 */ 20366 .long .L_OP_USHR_INT /* 0x9a */ 20367 .long .L_OP_ADD_LONG /* 0x9b */ 20368 .long .L_OP_SUB_LONG /* 0x9c */ 20369 .long .L_OP_MUL_LONG /* 0x9d */ 20370 .long .L_OP_DIV_LONG /* 0x9e */ 20371 .long .L_OP_REM_LONG /* 0x9f */ 20372 .long .L_OP_AND_LONG /* 0xa0 */ 20373 .long .L_OP_OR_LONG /* 0xa1 */ 20374 .long .L_OP_XOR_LONG /* 0xa2 */ 20375 .long .L_OP_SHL_LONG /* 0xa3 */ 20376 .long .L_OP_SHR_LONG /* 0xa4 */ 20377 .long .L_OP_USHR_LONG /* 0xa5 */ 20378 .long .L_OP_ADD_FLOAT /* 0xa6 */ 20379 .long .L_OP_SUB_FLOAT /* 0xa7 */ 20380 .long .L_OP_MUL_FLOAT /* 0xa8 */ 20381 .long .L_OP_DIV_FLOAT /* 0xa9 */ 20382 .long .L_OP_REM_FLOAT /* 0xaa */ 20383 .long .L_OP_ADD_DOUBLE /* 0xab */ 20384 .long .L_OP_SUB_DOUBLE /* 0xac */ 20385 .long .L_OP_MUL_DOUBLE /* 0xad */ 20386 .long .L_OP_DIV_DOUBLE /* 0xae */ 20387 .long .L_OP_REM_DOUBLE /* 0xaf */ 20388 .long .L_OP_ADD_INT_2ADDR /* 0xb0 */ 20389 .long .L_OP_SUB_INT_2ADDR /* 0xb1 */ 20390 .long .L_OP_MUL_INT_2ADDR /* 0xb2 */ 20391 .long .L_OP_DIV_INT_2ADDR /* 0xb3 */ 20392 .long .L_OP_REM_INT_2ADDR /* 0xb4 */ 20393 .long .L_OP_AND_INT_2ADDR /* 0xb5 */ 20394 .long .L_OP_OR_INT_2ADDR /* 0xb6 */ 20395 .long .L_OP_XOR_INT_2ADDR /* 0xb7 */ 20396 .long .L_OP_SHL_INT_2ADDR /* 0xb8 */ 20397 .long .L_OP_SHR_INT_2ADDR /* 0xb9 */ 20398 .long .L_OP_USHR_INT_2ADDR /* 0xba */ 20399 .long .L_OP_ADD_LONG_2ADDR /* 0xbb */ 20400 .long .L_OP_SUB_LONG_2ADDR /* 0xbc */ 20401 .long .L_OP_MUL_LONG_2ADDR /* 0xbd */ 20402 .long .L_OP_DIV_LONG_2ADDR /* 0xbe */ 20403 .long .L_OP_REM_LONG_2ADDR /* 0xbf */ 20404 .long .L_OP_AND_LONG_2ADDR /* 0xc0 */ 20405 .long .L_OP_OR_LONG_2ADDR /* 0xc1 */ 20406 .long .L_OP_XOR_LONG_2ADDR /* 0xc2 */ 20407 .long .L_OP_SHL_LONG_2ADDR /* 0xc3 */ 20408 .long .L_OP_SHR_LONG_2ADDR /* 0xc4 */ 20409 .long .L_OP_USHR_LONG_2ADDR /* 0xc5 */ 20410 .long .L_OP_ADD_FLOAT_2ADDR /* 0xc6 */ 20411 .long .L_OP_SUB_FLOAT_2ADDR /* 0xc7 */ 20412 .long .L_OP_MUL_FLOAT_2ADDR /* 0xc8 */ 20413 .long .L_OP_DIV_FLOAT_2ADDR /* 0xc9 */ 20414 .long .L_OP_REM_FLOAT_2ADDR /* 0xca */ 20415 .long .L_OP_ADD_DOUBLE_2ADDR /* 0xcb */ 20416 .long .L_OP_SUB_DOUBLE_2ADDR /* 0xcc */ 20417 .long .L_OP_MUL_DOUBLE_2ADDR /* 0xcd */ 20418 .long .L_OP_DIV_DOUBLE_2ADDR /* 0xce */ 20419 .long .L_OP_REM_DOUBLE_2ADDR /* 0xcf */ 20420 .long .L_OP_ADD_INT_LIT16 /* 0xd0 */ 20421 .long .L_OP_RSUB_INT /* 0xd1 */ 20422 .long .L_OP_MUL_INT_LIT16 /* 0xd2 */ 20423 .long .L_OP_DIV_INT_LIT16 /* 0xd3 */ 20424 .long .L_OP_REM_INT_LIT16 /* 0xd4 */ 20425 .long .L_OP_AND_INT_LIT16 /* 0xd5 */ 20426 .long .L_OP_OR_INT_LIT16 /* 0xd6 */ 20427 .long .L_OP_XOR_INT_LIT16 /* 0xd7 */ 20428 .long .L_OP_ADD_INT_LIT8 /* 0xd8 */ 20429 .long .L_OP_RSUB_INT_LIT8 /* 0xd9 */ 20430 .long .L_OP_MUL_INT_LIT8 /* 0xda */ 20431 .long .L_OP_DIV_INT_LIT8 /* 0xdb */ 20432 .long .L_OP_REM_INT_LIT8 /* 0xdc */ 20433 .long .L_OP_AND_INT_LIT8 /* 0xdd */ 20434 .long .L_OP_OR_INT_LIT8 /* 0xde */ 20435 .long .L_OP_XOR_INT_LIT8 /* 0xdf */ 20436 .long .L_OP_SHL_INT_LIT8 /* 0xe0 */ 20437 .long .L_OP_SHR_INT_LIT8 /* 0xe1 */ 20438 .long .L_OP_USHR_INT_LIT8 /* 0xe2 */ 20439 .long .L_OP_IGET_VOLATILE /* 0xe3 */ 20440 .long .L_OP_IPUT_VOLATILE /* 0xe4 */ 20441 .long .L_OP_SGET_VOLATILE /* 0xe5 */ 20442 .long .L_OP_SPUT_VOLATILE /* 0xe6 */ 20443 .long .L_OP_IGET_OBJECT_VOLATILE /* 0xe7 */ 20444 .long .L_OP_IGET_WIDE_VOLATILE /* 0xe8 */ 20445 .long .L_OP_IPUT_WIDE_VOLATILE /* 0xe9 */ 20446 .long .L_OP_SGET_WIDE_VOLATILE /* 0xea */ 20447 .long .L_OP_SPUT_WIDE_VOLATILE /* 0xeb */ 20448 .long .L_OP_BREAKPOINT /* 0xec */ 20449 .long .L_OP_THROW_VERIFICATION_ERROR /* 0xed */ 20450 .long .L_OP_EXECUTE_INLINE /* 0xee */ 20451 .long .L_OP_EXECUTE_INLINE_RANGE /* 0xef */ 20452 .long .L_OP_INVOKE_OBJECT_INIT_RANGE /* 0xf0 */ 20453 .long .L_OP_RETURN_VOID_BARRIER /* 0xf1 */ 20454 .long .L_OP_IGET_QUICK /* 0xf2 */ 20455 .long .L_OP_IGET_WIDE_QUICK /* 0xf3 */ 20456 .long .L_OP_IGET_OBJECT_QUICK /* 0xf4 */ 20457 .long .L_OP_IPUT_QUICK /* 0xf5 */ 20458 .long .L_OP_IPUT_WIDE_QUICK /* 0xf6 */ 20459 .long .L_OP_IPUT_OBJECT_QUICK /* 0xf7 */ 20460 .long .L_OP_INVOKE_VIRTUAL_QUICK /* 0xf8 */ 20461 .long .L_OP_INVOKE_VIRTUAL_QUICK_RANGE /* 0xf9 */ 20462 .long .L_OP_INVOKE_SUPER_QUICK /* 0xfa */ 20463 .long .L_OP_INVOKE_SUPER_QUICK_RANGE /* 0xfb */ 20464 .long .L_OP_IPUT_OBJECT_VOLATILE /* 0xfc */ 20465 .long .L_OP_SGET_OBJECT_VOLATILE /* 0xfd */ 20466 .long .L_OP_SPUT_OBJECT_VOLATILE /* 0xfe */ 20467 .long .L_OP_DISPATCH_FF /* 0xff */ 20468 .long .L_OP_CONST_CLASS_JUMBO /* 0x100 */ 20469 .long .L_OP_CHECK_CAST_JUMBO /* 0x101 */ 20470 .long .L_OP_INSTANCE_OF_JUMBO /* 0x102 */ 20471 .long .L_OP_NEW_INSTANCE_JUMBO /* 0x103 */ 20472 .long .L_OP_NEW_ARRAY_JUMBO /* 0x104 */ 20473 .long .L_OP_FILLED_NEW_ARRAY_JUMBO /* 0x105 */ 20474 .long .L_OP_IGET_JUMBO /* 0x106 */ 20475 .long .L_OP_IGET_WIDE_JUMBO /* 0x107 */ 20476 .long .L_OP_IGET_OBJECT_JUMBO /* 0x108 */ 20477 .long .L_OP_IGET_BOOLEAN_JUMBO /* 0x109 */ 20478 .long .L_OP_IGET_BYTE_JUMBO /* 0x10a */ 20479 .long .L_OP_IGET_CHAR_JUMBO /* 0x10b */ 20480 .long .L_OP_IGET_SHORT_JUMBO /* 0x10c */ 20481 .long .L_OP_IPUT_JUMBO /* 0x10d */ 20482 .long .L_OP_IPUT_WIDE_JUMBO /* 0x10e */ 20483 .long .L_OP_IPUT_OBJECT_JUMBO /* 0x10f */ 20484 .long .L_OP_IPUT_BOOLEAN_JUMBO /* 0x110 */ 20485 .long .L_OP_IPUT_BYTE_JUMBO /* 0x111 */ 20486 .long .L_OP_IPUT_CHAR_JUMBO /* 0x112 */ 20487 .long .L_OP_IPUT_SHORT_JUMBO /* 0x113 */ 20488 .long .L_OP_SGET_JUMBO /* 0x114 */ 20489 .long .L_OP_SGET_WIDE_JUMBO /* 0x115 */ 20490 .long .L_OP_SGET_OBJECT_JUMBO /* 0x116 */ 20491 .long .L_OP_SGET_BOOLEAN_JUMBO /* 0x117 */ 20492 .long .L_OP_SGET_BYTE_JUMBO /* 0x118 */ 20493 .long .L_OP_SGET_CHAR_JUMBO /* 0x119 */ 20494 .long .L_OP_SGET_SHORT_JUMBO /* 0x11a */ 20495 .long .L_OP_SPUT_JUMBO /* 0x11b */ 20496 .long .L_OP_SPUT_WIDE_JUMBO /* 0x11c */ 20497 .long .L_OP_SPUT_OBJECT_JUMBO /* 0x11d */ 20498 .long .L_OP_SPUT_BOOLEAN_JUMBO /* 0x11e */ 20499 .long .L_OP_SPUT_BYTE_JUMBO /* 0x11f */ 20500 .long .L_OP_SPUT_CHAR_JUMBO /* 0x120 */ 20501 .long .L_OP_SPUT_SHORT_JUMBO /* 0x121 */ 20502 .long .L_OP_INVOKE_VIRTUAL_JUMBO /* 0x122 */ 20503 .long .L_OP_INVOKE_SUPER_JUMBO /* 0x123 */ 20504 .long .L_OP_INVOKE_DIRECT_JUMBO /* 0x124 */ 20505 .long .L_OP_INVOKE_STATIC_JUMBO /* 0x125 */ 20506 .long .L_OP_INVOKE_INTERFACE_JUMBO /* 0x126 */ 20507 .long .L_OP_UNUSED_27FF /* 0x127 */ 20508 .long .L_OP_UNUSED_28FF /* 0x128 */ 20509 .long .L_OP_UNUSED_29FF /* 0x129 */ 20510 .long .L_OP_UNUSED_2AFF /* 0x12a */ 20511 .long .L_OP_UNUSED_2BFF /* 0x12b */ 20512 .long .L_OP_UNUSED_2CFF /* 0x12c */ 20513 .long .L_OP_UNUSED_2DFF /* 0x12d */ 20514 .long .L_OP_UNUSED_2EFF /* 0x12e */ 20515 .long .L_OP_UNUSED_2FFF /* 0x12f */ 20516 .long .L_OP_UNUSED_30FF /* 0x130 */ 20517 .long .L_OP_UNUSED_31FF /* 0x131 */ 20518 .long .L_OP_UNUSED_32FF /* 0x132 */ 20519 .long .L_OP_UNUSED_33FF /* 0x133 */ 20520 .long .L_OP_UNUSED_34FF /* 0x134 */ 20521 .long .L_OP_UNUSED_35FF /* 0x135 */ 20522 .long .L_OP_UNUSED_36FF /* 0x136 */ 20523 .long .L_OP_UNUSED_37FF /* 0x137 */ 20524 .long .L_OP_UNUSED_38FF /* 0x138 */ 20525 .long .L_OP_UNUSED_39FF /* 0x139 */ 20526 .long .L_OP_UNUSED_3AFF /* 0x13a */ 20527 .long .L_OP_UNUSED_3BFF /* 0x13b */ 20528 .long .L_OP_UNUSED_3CFF /* 0x13c */ 20529 .long .L_OP_UNUSED_3DFF /* 0x13d */ 20530 .long .L_OP_UNUSED_3EFF /* 0x13e */ 20531 .long .L_OP_UNUSED_3FFF /* 0x13f */ 20532 .long .L_OP_UNUSED_40FF /* 0x140 */ 20533 .long .L_OP_UNUSED_41FF /* 0x141 */ 20534 .long .L_OP_UNUSED_42FF /* 0x142 */ 20535 .long .L_OP_UNUSED_43FF /* 0x143 */ 20536 .long .L_OP_UNUSED_44FF /* 0x144 */ 20537 .long .L_OP_UNUSED_45FF /* 0x145 */ 20538 .long .L_OP_UNUSED_46FF /* 0x146 */ 20539 .long .L_OP_UNUSED_47FF /* 0x147 */ 20540 .long .L_OP_UNUSED_48FF /* 0x148 */ 20541 .long .L_OP_UNUSED_49FF /* 0x149 */ 20542 .long .L_OP_UNUSED_4AFF /* 0x14a */ 20543 .long .L_OP_UNUSED_4BFF /* 0x14b */ 20544 .long .L_OP_UNUSED_4CFF /* 0x14c */ 20545 .long .L_OP_UNUSED_4DFF /* 0x14d */ 20546 .long .L_OP_UNUSED_4EFF /* 0x14e */ 20547 .long .L_OP_UNUSED_4FFF /* 0x14f */ 20548 .long .L_OP_UNUSED_50FF /* 0x150 */ 20549 .long .L_OP_UNUSED_51FF /* 0x151 */ 20550 .long .L_OP_UNUSED_52FF /* 0x152 */ 20551 .long .L_OP_UNUSED_53FF /* 0x153 */ 20552 .long .L_OP_UNUSED_54FF /* 0x154 */ 20553 .long .L_OP_UNUSED_55FF /* 0x155 */ 20554 .long .L_OP_UNUSED_56FF /* 0x156 */ 20555 .long .L_OP_UNUSED_57FF /* 0x157 */ 20556 .long .L_OP_UNUSED_58FF /* 0x158 */ 20557 .long .L_OP_UNUSED_59FF /* 0x159 */ 20558 .long .L_OP_UNUSED_5AFF /* 0x15a */ 20559 .long .L_OP_UNUSED_5BFF /* 0x15b */ 20560 .long .L_OP_UNUSED_5CFF /* 0x15c */ 20561 .long .L_OP_UNUSED_5DFF /* 0x15d */ 20562 .long .L_OP_UNUSED_5EFF /* 0x15e */ 20563 .long .L_OP_UNUSED_5FFF /* 0x15f */ 20564 .long .L_OP_UNUSED_60FF /* 0x160 */ 20565 .long .L_OP_UNUSED_61FF /* 0x161 */ 20566 .long .L_OP_UNUSED_62FF /* 0x162 */ 20567 .long .L_OP_UNUSED_63FF /* 0x163 */ 20568 .long .L_OP_UNUSED_64FF /* 0x164 */ 20569 .long .L_OP_UNUSED_65FF /* 0x165 */ 20570 .long .L_OP_UNUSED_66FF /* 0x166 */ 20571 .long .L_OP_UNUSED_67FF /* 0x167 */ 20572 .long .L_OP_UNUSED_68FF /* 0x168 */ 20573 .long .L_OP_UNUSED_69FF /* 0x169 */ 20574 .long .L_OP_UNUSED_6AFF /* 0x16a */ 20575 .long .L_OP_UNUSED_6BFF /* 0x16b */ 20576 .long .L_OP_UNUSED_6CFF /* 0x16c */ 20577 .long .L_OP_UNUSED_6DFF /* 0x16d */ 20578 .long .L_OP_UNUSED_6EFF /* 0x16e */ 20579 .long .L_OP_UNUSED_6FFF /* 0x16f */ 20580 .long .L_OP_UNUSED_70FF /* 0x170 */ 20581 .long .L_OP_UNUSED_71FF /* 0x171 */ 20582 .long .L_OP_UNUSED_72FF /* 0x172 */ 20583 .long .L_OP_UNUSED_73FF /* 0x173 */ 20584 .long .L_OP_UNUSED_74FF /* 0x174 */ 20585 .long .L_OP_UNUSED_75FF /* 0x175 */ 20586 .long .L_OP_UNUSED_76FF /* 0x176 */ 20587 .long .L_OP_UNUSED_77FF /* 0x177 */ 20588 .long .L_OP_UNUSED_78FF /* 0x178 */ 20589 .long .L_OP_UNUSED_79FF /* 0x179 */ 20590 .long .L_OP_UNUSED_7AFF /* 0x17a */ 20591 .long .L_OP_UNUSED_7BFF /* 0x17b */ 20592 .long .L_OP_UNUSED_7CFF /* 0x17c */ 20593 .long .L_OP_UNUSED_7DFF /* 0x17d */ 20594 .long .L_OP_UNUSED_7EFF /* 0x17e */ 20595 .long .L_OP_UNUSED_7FFF /* 0x17f */ 20596 .long .L_OP_UNUSED_80FF /* 0x180 */ 20597 .long .L_OP_UNUSED_81FF /* 0x181 */ 20598 .long .L_OP_UNUSED_82FF /* 0x182 */ 20599 .long .L_OP_UNUSED_83FF /* 0x183 */ 20600 .long .L_OP_UNUSED_84FF /* 0x184 */ 20601 .long .L_OP_UNUSED_85FF /* 0x185 */ 20602 .long .L_OP_UNUSED_86FF /* 0x186 */ 20603 .long .L_OP_UNUSED_87FF /* 0x187 */ 20604 .long .L_OP_UNUSED_88FF /* 0x188 */ 20605 .long .L_OP_UNUSED_89FF /* 0x189 */ 20606 .long .L_OP_UNUSED_8AFF /* 0x18a */ 20607 .long .L_OP_UNUSED_8BFF /* 0x18b */ 20608 .long .L_OP_UNUSED_8CFF /* 0x18c */ 20609 .long .L_OP_UNUSED_8DFF /* 0x18d */ 20610 .long .L_OP_UNUSED_8EFF /* 0x18e */ 20611 .long .L_OP_UNUSED_8FFF /* 0x18f */ 20612 .long .L_OP_UNUSED_90FF /* 0x190 */ 20613 .long .L_OP_UNUSED_91FF /* 0x191 */ 20614 .long .L_OP_UNUSED_92FF /* 0x192 */ 20615 .long .L_OP_UNUSED_93FF /* 0x193 */ 20616 .long .L_OP_UNUSED_94FF /* 0x194 */ 20617 .long .L_OP_UNUSED_95FF /* 0x195 */ 20618 .long .L_OP_UNUSED_96FF /* 0x196 */ 20619 .long .L_OP_UNUSED_97FF /* 0x197 */ 20620 .long .L_OP_UNUSED_98FF /* 0x198 */ 20621 .long .L_OP_UNUSED_99FF /* 0x199 */ 20622 .long .L_OP_UNUSED_9AFF /* 0x19a */ 20623 .long .L_OP_UNUSED_9BFF /* 0x19b */ 20624 .long .L_OP_UNUSED_9CFF /* 0x19c */ 20625 .long .L_OP_UNUSED_9DFF /* 0x19d */ 20626 .long .L_OP_UNUSED_9EFF /* 0x19e */ 20627 .long .L_OP_UNUSED_9FFF /* 0x19f */ 20628 .long .L_OP_UNUSED_A0FF /* 0x1a0 */ 20629 .long .L_OP_UNUSED_A1FF /* 0x1a1 */ 20630 .long .L_OP_UNUSED_A2FF /* 0x1a2 */ 20631 .long .L_OP_UNUSED_A3FF /* 0x1a3 */ 20632 .long .L_OP_UNUSED_A4FF /* 0x1a4 */ 20633 .long .L_OP_UNUSED_A5FF /* 0x1a5 */ 20634 .long .L_OP_UNUSED_A6FF /* 0x1a6 */ 20635 .long .L_OP_UNUSED_A7FF /* 0x1a7 */ 20636 .long .L_OP_UNUSED_A8FF /* 0x1a8 */ 20637 .long .L_OP_UNUSED_A9FF /* 0x1a9 */ 20638 .long .L_OP_UNUSED_AAFF /* 0x1aa */ 20639 .long .L_OP_UNUSED_ABFF /* 0x1ab */ 20640 .long .L_OP_UNUSED_ACFF /* 0x1ac */ 20641 .long .L_OP_UNUSED_ADFF /* 0x1ad */ 20642 .long .L_OP_UNUSED_AEFF /* 0x1ae */ 20643 .long .L_OP_UNUSED_AFFF /* 0x1af */ 20644 .long .L_OP_UNUSED_B0FF /* 0x1b0 */ 20645 .long .L_OP_UNUSED_B1FF /* 0x1b1 */ 20646 .long .L_OP_UNUSED_B2FF /* 0x1b2 */ 20647 .long .L_OP_UNUSED_B3FF /* 0x1b3 */ 20648 .long .L_OP_UNUSED_B4FF /* 0x1b4 */ 20649 .long .L_OP_UNUSED_B5FF /* 0x1b5 */ 20650 .long .L_OP_UNUSED_B6FF /* 0x1b6 */ 20651 .long .L_OP_UNUSED_B7FF /* 0x1b7 */ 20652 .long .L_OP_UNUSED_B8FF /* 0x1b8 */ 20653 .long .L_OP_UNUSED_B9FF /* 0x1b9 */ 20654 .long .L_OP_UNUSED_BAFF /* 0x1ba */ 20655 .long .L_OP_UNUSED_BBFF /* 0x1bb */ 20656 .long .L_OP_UNUSED_BCFF /* 0x1bc */ 20657 .long .L_OP_UNUSED_BDFF /* 0x1bd */ 20658 .long .L_OP_UNUSED_BEFF /* 0x1be */ 20659 .long .L_OP_UNUSED_BFFF /* 0x1bf */ 20660 .long .L_OP_UNUSED_C0FF /* 0x1c0 */ 20661 .long .L_OP_UNUSED_C1FF /* 0x1c1 */ 20662 .long .L_OP_UNUSED_C2FF /* 0x1c2 */ 20663 .long .L_OP_UNUSED_C3FF /* 0x1c3 */ 20664 .long .L_OP_UNUSED_C4FF /* 0x1c4 */ 20665 .long .L_OP_UNUSED_C5FF /* 0x1c5 */ 20666 .long .L_OP_UNUSED_C6FF /* 0x1c6 */ 20667 .long .L_OP_UNUSED_C7FF /* 0x1c7 */ 20668 .long .L_OP_UNUSED_C8FF /* 0x1c8 */ 20669 .long .L_OP_UNUSED_C9FF /* 0x1c9 */ 20670 .long .L_OP_UNUSED_CAFF /* 0x1ca */ 20671 .long .L_OP_UNUSED_CBFF /* 0x1cb */ 20672 .long .L_OP_UNUSED_CCFF /* 0x1cc */ 20673 .long .L_OP_UNUSED_CDFF /* 0x1cd */ 20674 .long .L_OP_UNUSED_CEFF /* 0x1ce */ 20675 .long .L_OP_UNUSED_CFFF /* 0x1cf */ 20676 .long .L_OP_UNUSED_D0FF /* 0x1d0 */ 20677 .long .L_OP_UNUSED_D1FF /* 0x1d1 */ 20678 .long .L_OP_UNUSED_D2FF /* 0x1d2 */ 20679 .long .L_OP_UNUSED_D3FF /* 0x1d3 */ 20680 .long .L_OP_UNUSED_D4FF /* 0x1d4 */ 20681 .long .L_OP_UNUSED_D5FF /* 0x1d5 */ 20682 .long .L_OP_UNUSED_D6FF /* 0x1d6 */ 20683 .long .L_OP_UNUSED_D7FF /* 0x1d7 */ 20684 .long .L_OP_UNUSED_D8FF /* 0x1d8 */ 20685 .long .L_OP_UNUSED_D9FF /* 0x1d9 */ 20686 .long .L_OP_UNUSED_DAFF /* 0x1da */ 20687 .long .L_OP_UNUSED_DBFF /* 0x1db */ 20688 .long .L_OP_UNUSED_DCFF /* 0x1dc */ 20689 .long .L_OP_UNUSED_DDFF /* 0x1dd */ 20690 .long .L_OP_UNUSED_DEFF /* 0x1de */ 20691 .long .L_OP_UNUSED_DFFF /* 0x1df */ 20692 .long .L_OP_UNUSED_E0FF /* 0x1e0 */ 20693 .long .L_OP_UNUSED_E1FF /* 0x1e1 */ 20694 .long .L_OP_UNUSED_E2FF /* 0x1e2 */ 20695 .long .L_OP_UNUSED_E3FF /* 0x1e3 */ 20696 .long .L_OP_UNUSED_E4FF /* 0x1e4 */ 20697 .long .L_OP_UNUSED_E5FF /* 0x1e5 */ 20698 .long .L_OP_UNUSED_E6FF /* 0x1e6 */ 20699 .long .L_OP_UNUSED_E7FF /* 0x1e7 */ 20700 .long .L_OP_UNUSED_E8FF /* 0x1e8 */ 20701 .long .L_OP_UNUSED_E9FF /* 0x1e9 */ 20702 .long .L_OP_UNUSED_EAFF /* 0x1ea */ 20703 .long .L_OP_UNUSED_EBFF /* 0x1eb */ 20704 .long .L_OP_UNUSED_ECFF /* 0x1ec */ 20705 .long .L_OP_UNUSED_EDFF /* 0x1ed */ 20706 .long .L_OP_UNUSED_EEFF /* 0x1ee */ 20707 .long .L_OP_UNUSED_EFFF /* 0x1ef */ 20708 .long .L_OP_UNUSED_F0FF /* 0x1f0 */ 20709 .long .L_OP_UNUSED_F1FF /* 0x1f1 */ 20710 .long .L_OP_INVOKE_OBJECT_INIT_JUMBO /* 0x1f2 */ 20711 .long .L_OP_IGET_VOLATILE_JUMBO /* 0x1f3 */ 20712 .long .L_OP_IGET_WIDE_VOLATILE_JUMBO /* 0x1f4 */ 20713 .long .L_OP_IGET_OBJECT_VOLATILE_JUMBO /* 0x1f5 */ 20714 .long .L_OP_IPUT_VOLATILE_JUMBO /* 0x1f6 */ 20715 .long .L_OP_IPUT_WIDE_VOLATILE_JUMBO /* 0x1f7 */ 20716 .long .L_OP_IPUT_OBJECT_VOLATILE_JUMBO /* 0x1f8 */ 20717 .long .L_OP_SGET_VOLATILE_JUMBO /* 0x1f9 */ 20718 .long .L_OP_SGET_WIDE_VOLATILE_JUMBO /* 0x1fa */ 20719 .long .L_OP_SGET_OBJECT_VOLATILE_JUMBO /* 0x1fb */ 20720 .long .L_OP_SPUT_VOLATILE_JUMBO /* 0x1fc */ 20721 .long .L_OP_SPUT_WIDE_VOLATILE_JUMBO /* 0x1fd */ 20722 .long .L_OP_SPUT_OBJECT_VOLATILE_JUMBO /* 0x1fe */ 20723 .long .L_OP_THROW_VERIFICATION_ERROR_JUMBO /* 0x1ff */ 20724 20725 .global dvmAsmAltInstructionStart 20726 .text 20727dvmAsmAltInstructionStart: 20728 .long .L_ALT_OP_NOP /* 0x00 */ 20729 .long .L_ALT_OP_MOVE /* 0x01 */ 20730 .long .L_ALT_OP_MOVE_FROM16 /* 0x02 */ 20731 .long .L_ALT_OP_MOVE_16 /* 0x03 */ 20732 .long .L_ALT_OP_MOVE_WIDE /* 0x04 */ 20733 .long .L_ALT_OP_MOVE_WIDE_FROM16 /* 0x05 */ 20734 .long .L_ALT_OP_MOVE_WIDE_16 /* 0x06 */ 20735 .long .L_ALT_OP_MOVE_OBJECT /* 0x07 */ 20736 .long .L_ALT_OP_MOVE_OBJECT_FROM16 /* 0x08 */ 20737 .long .L_ALT_OP_MOVE_OBJECT_16 /* 0x09 */ 20738 .long .L_ALT_OP_MOVE_RESULT /* 0x0a */ 20739 .long .L_ALT_OP_MOVE_RESULT_WIDE /* 0x0b */ 20740 .long .L_ALT_OP_MOVE_RESULT_OBJECT /* 0x0c */ 20741 .long .L_ALT_OP_MOVE_EXCEPTION /* 0x0d */ 20742 .long .L_ALT_OP_RETURN_VOID /* 0x0e */ 20743 .long .L_ALT_OP_RETURN /* 0x0f */ 20744 .long .L_ALT_OP_RETURN_WIDE /* 0x10 */ 20745 .long .L_ALT_OP_RETURN_OBJECT /* 0x11 */ 20746 .long .L_ALT_OP_CONST_4 /* 0x12 */ 20747 .long .L_ALT_OP_CONST_16 /* 0x13 */ 20748 .long .L_ALT_OP_CONST /* 0x14 */ 20749 .long .L_ALT_OP_CONST_HIGH16 /* 0x15 */ 20750 .long .L_ALT_OP_CONST_WIDE_16 /* 0x16 */ 20751 .long .L_ALT_OP_CONST_WIDE_32 /* 0x17 */ 20752 .long .L_ALT_OP_CONST_WIDE /* 0x18 */ 20753 .long .L_ALT_OP_CONST_WIDE_HIGH16 /* 0x19 */ 20754 .long .L_ALT_OP_CONST_STRING /* 0x1a */ 20755 .long .L_ALT_OP_CONST_STRING_JUMBO /* 0x1b */ 20756 .long .L_ALT_OP_CONST_CLASS /* 0x1c */ 20757 .long .L_ALT_OP_MONITOR_ENTER /* 0x1d */ 20758 .long .L_ALT_OP_MONITOR_EXIT /* 0x1e */ 20759 .long .L_ALT_OP_CHECK_CAST /* 0x1f */ 20760 .long .L_ALT_OP_INSTANCE_OF /* 0x20 */ 20761 .long .L_ALT_OP_ARRAY_LENGTH /* 0x21 */ 20762 .long .L_ALT_OP_NEW_INSTANCE /* 0x22 */ 20763 .long .L_ALT_OP_NEW_ARRAY /* 0x23 */ 20764 .long .L_ALT_OP_FILLED_NEW_ARRAY /* 0x24 */ 20765 .long .L_ALT_OP_FILLED_NEW_ARRAY_RANGE /* 0x25 */ 20766 .long .L_ALT_OP_FILL_ARRAY_DATA /* 0x26 */ 20767 .long .L_ALT_OP_THROW /* 0x27 */ 20768 .long .L_ALT_OP_GOTO /* 0x28 */ 20769 .long .L_ALT_OP_GOTO_16 /* 0x29 */ 20770 .long .L_ALT_OP_GOTO_32 /* 0x2a */ 20771 .long .L_ALT_OP_PACKED_SWITCH /* 0x2b */ 20772 .long .L_ALT_OP_SPARSE_SWITCH /* 0x2c */ 20773 .long .L_ALT_OP_CMPL_FLOAT /* 0x2d */ 20774 .long .L_ALT_OP_CMPG_FLOAT /* 0x2e */ 20775 .long .L_ALT_OP_CMPL_DOUBLE /* 0x2f */ 20776 .long .L_ALT_OP_CMPG_DOUBLE /* 0x30 */ 20777 .long .L_ALT_OP_CMP_LONG /* 0x31 */ 20778 .long .L_ALT_OP_IF_EQ /* 0x32 */ 20779 .long .L_ALT_OP_IF_NE /* 0x33 */ 20780 .long .L_ALT_OP_IF_LT /* 0x34 */ 20781 .long .L_ALT_OP_IF_GE /* 0x35 */ 20782 .long .L_ALT_OP_IF_GT /* 0x36 */ 20783 .long .L_ALT_OP_IF_LE /* 0x37 */ 20784 .long .L_ALT_OP_IF_EQZ /* 0x38 */ 20785 .long .L_ALT_OP_IF_NEZ /* 0x39 */ 20786 .long .L_ALT_OP_IF_LTZ /* 0x3a */ 20787 .long .L_ALT_OP_IF_GEZ /* 0x3b */ 20788 .long .L_ALT_OP_IF_GTZ /* 0x3c */ 20789 .long .L_ALT_OP_IF_LEZ /* 0x3d */ 20790 .long .L_ALT_OP_UNUSED_3E /* 0x3e */ 20791 .long .L_ALT_OP_UNUSED_3F /* 0x3f */ 20792 .long .L_ALT_OP_UNUSED_40 /* 0x40 */ 20793 .long .L_ALT_OP_UNUSED_41 /* 0x41 */ 20794 .long .L_ALT_OP_UNUSED_42 /* 0x42 */ 20795 .long .L_ALT_OP_UNUSED_43 /* 0x43 */ 20796 .long .L_ALT_OP_AGET /* 0x44 */ 20797 .long .L_ALT_OP_AGET_WIDE /* 0x45 */ 20798 .long .L_ALT_OP_AGET_OBJECT /* 0x46 */ 20799 .long .L_ALT_OP_AGET_BOOLEAN /* 0x47 */ 20800 .long .L_ALT_OP_AGET_BYTE /* 0x48 */ 20801 .long .L_ALT_OP_AGET_CHAR /* 0x49 */ 20802 .long .L_ALT_OP_AGET_SHORT /* 0x4a */ 20803 .long .L_ALT_OP_APUT /* 0x4b */ 20804 .long .L_ALT_OP_APUT_WIDE /* 0x4c */ 20805 .long .L_ALT_OP_APUT_OBJECT /* 0x4d */ 20806 .long .L_ALT_OP_APUT_BOOLEAN /* 0x4e */ 20807 .long .L_ALT_OP_APUT_BYTE /* 0x4f */ 20808 .long .L_ALT_OP_APUT_CHAR /* 0x50 */ 20809 .long .L_ALT_OP_APUT_SHORT /* 0x51 */ 20810 .long .L_ALT_OP_IGET /* 0x52 */ 20811 .long .L_ALT_OP_IGET_WIDE /* 0x53 */ 20812 .long .L_ALT_OP_IGET_OBJECT /* 0x54 */ 20813 .long .L_ALT_OP_IGET_BOOLEAN /* 0x55 */ 20814 .long .L_ALT_OP_IGET_BYTE /* 0x56 */ 20815 .long .L_ALT_OP_IGET_CHAR /* 0x57 */ 20816 .long .L_ALT_OP_IGET_SHORT /* 0x58 */ 20817 .long .L_ALT_OP_IPUT /* 0x59 */ 20818 .long .L_ALT_OP_IPUT_WIDE /* 0x5a */ 20819 .long .L_ALT_OP_IPUT_OBJECT /* 0x5b */ 20820 .long .L_ALT_OP_IPUT_BOOLEAN /* 0x5c */ 20821 .long .L_ALT_OP_IPUT_BYTE /* 0x5d */ 20822 .long .L_ALT_OP_IPUT_CHAR /* 0x5e */ 20823 .long .L_ALT_OP_IPUT_SHORT /* 0x5f */ 20824 .long .L_ALT_OP_SGET /* 0x60 */ 20825 .long .L_ALT_OP_SGET_WIDE /* 0x61 */ 20826 .long .L_ALT_OP_SGET_OBJECT /* 0x62 */ 20827 .long .L_ALT_OP_SGET_BOOLEAN /* 0x63 */ 20828 .long .L_ALT_OP_SGET_BYTE /* 0x64 */ 20829 .long .L_ALT_OP_SGET_CHAR /* 0x65 */ 20830 .long .L_ALT_OP_SGET_SHORT /* 0x66 */ 20831 .long .L_ALT_OP_SPUT /* 0x67 */ 20832 .long .L_ALT_OP_SPUT_WIDE /* 0x68 */ 20833 .long .L_ALT_OP_SPUT_OBJECT /* 0x69 */ 20834 .long .L_ALT_OP_SPUT_BOOLEAN /* 0x6a */ 20835 .long .L_ALT_OP_SPUT_BYTE /* 0x6b */ 20836 .long .L_ALT_OP_SPUT_CHAR /* 0x6c */ 20837 .long .L_ALT_OP_SPUT_SHORT /* 0x6d */ 20838 .long .L_ALT_OP_INVOKE_VIRTUAL /* 0x6e */ 20839 .long .L_ALT_OP_INVOKE_SUPER /* 0x6f */ 20840 .long .L_ALT_OP_INVOKE_DIRECT /* 0x70 */ 20841 .long .L_ALT_OP_INVOKE_STATIC /* 0x71 */ 20842 .long .L_ALT_OP_INVOKE_INTERFACE /* 0x72 */ 20843 .long .L_ALT_OP_UNUSED_73 /* 0x73 */ 20844 .long .L_ALT_OP_INVOKE_VIRTUAL_RANGE /* 0x74 */ 20845 .long .L_ALT_OP_INVOKE_SUPER_RANGE /* 0x75 */ 20846 .long .L_ALT_OP_INVOKE_DIRECT_RANGE /* 0x76 */ 20847 .long .L_ALT_OP_INVOKE_STATIC_RANGE /* 0x77 */ 20848 .long .L_ALT_OP_INVOKE_INTERFACE_RANGE /* 0x78 */ 20849 .long .L_ALT_OP_UNUSED_79 /* 0x79 */ 20850 .long .L_ALT_OP_UNUSED_7A /* 0x7a */ 20851 .long .L_ALT_OP_NEG_INT /* 0x7b */ 20852 .long .L_ALT_OP_NOT_INT /* 0x7c */ 20853 .long .L_ALT_OP_NEG_LONG /* 0x7d */ 20854 .long .L_ALT_OP_NOT_LONG /* 0x7e */ 20855 .long .L_ALT_OP_NEG_FLOAT /* 0x7f */ 20856 .long .L_ALT_OP_NEG_DOUBLE /* 0x80 */ 20857 .long .L_ALT_OP_INT_TO_LONG /* 0x81 */ 20858 .long .L_ALT_OP_INT_TO_FLOAT /* 0x82 */ 20859 .long .L_ALT_OP_INT_TO_DOUBLE /* 0x83 */ 20860 .long .L_ALT_OP_LONG_TO_INT /* 0x84 */ 20861 .long .L_ALT_OP_LONG_TO_FLOAT /* 0x85 */ 20862 .long .L_ALT_OP_LONG_TO_DOUBLE /* 0x86 */ 20863 .long .L_ALT_OP_FLOAT_TO_INT /* 0x87 */ 20864 .long .L_ALT_OP_FLOAT_TO_LONG /* 0x88 */ 20865 .long .L_ALT_OP_FLOAT_TO_DOUBLE /* 0x89 */ 20866 .long .L_ALT_OP_DOUBLE_TO_INT /* 0x8a */ 20867 .long .L_ALT_OP_DOUBLE_TO_LONG /* 0x8b */ 20868 .long .L_ALT_OP_DOUBLE_TO_FLOAT /* 0x8c */ 20869 .long .L_ALT_OP_INT_TO_BYTE /* 0x8d */ 20870 .long .L_ALT_OP_INT_TO_CHAR /* 0x8e */ 20871 .long .L_ALT_OP_INT_TO_SHORT /* 0x8f */ 20872 .long .L_ALT_OP_ADD_INT /* 0x90 */ 20873 .long .L_ALT_OP_SUB_INT /* 0x91 */ 20874 .long .L_ALT_OP_MUL_INT /* 0x92 */ 20875 .long .L_ALT_OP_DIV_INT /* 0x93 */ 20876 .long .L_ALT_OP_REM_INT /* 0x94 */ 20877 .long .L_ALT_OP_AND_INT /* 0x95 */ 20878 .long .L_ALT_OP_OR_INT /* 0x96 */ 20879 .long .L_ALT_OP_XOR_INT /* 0x97 */ 20880 .long .L_ALT_OP_SHL_INT /* 0x98 */ 20881 .long .L_ALT_OP_SHR_INT /* 0x99 */ 20882 .long .L_ALT_OP_USHR_INT /* 0x9a */ 20883 .long .L_ALT_OP_ADD_LONG /* 0x9b */ 20884 .long .L_ALT_OP_SUB_LONG /* 0x9c */ 20885 .long .L_ALT_OP_MUL_LONG /* 0x9d */ 20886 .long .L_ALT_OP_DIV_LONG /* 0x9e */ 20887 .long .L_ALT_OP_REM_LONG /* 0x9f */ 20888 .long .L_ALT_OP_AND_LONG /* 0xa0 */ 20889 .long .L_ALT_OP_OR_LONG /* 0xa1 */ 20890 .long .L_ALT_OP_XOR_LONG /* 0xa2 */ 20891 .long .L_ALT_OP_SHL_LONG /* 0xa3 */ 20892 .long .L_ALT_OP_SHR_LONG /* 0xa4 */ 20893 .long .L_ALT_OP_USHR_LONG /* 0xa5 */ 20894 .long .L_ALT_OP_ADD_FLOAT /* 0xa6 */ 20895 .long .L_ALT_OP_SUB_FLOAT /* 0xa7 */ 20896 .long .L_ALT_OP_MUL_FLOAT /* 0xa8 */ 20897 .long .L_ALT_OP_DIV_FLOAT /* 0xa9 */ 20898 .long .L_ALT_OP_REM_FLOAT /* 0xaa */ 20899 .long .L_ALT_OP_ADD_DOUBLE /* 0xab */ 20900 .long .L_ALT_OP_SUB_DOUBLE /* 0xac */ 20901 .long .L_ALT_OP_MUL_DOUBLE /* 0xad */ 20902 .long .L_ALT_OP_DIV_DOUBLE /* 0xae */ 20903 .long .L_ALT_OP_REM_DOUBLE /* 0xaf */ 20904 .long .L_ALT_OP_ADD_INT_2ADDR /* 0xb0 */ 20905 .long .L_ALT_OP_SUB_INT_2ADDR /* 0xb1 */ 20906 .long .L_ALT_OP_MUL_INT_2ADDR /* 0xb2 */ 20907 .long .L_ALT_OP_DIV_INT_2ADDR /* 0xb3 */ 20908 .long .L_ALT_OP_REM_INT_2ADDR /* 0xb4 */ 20909 .long .L_ALT_OP_AND_INT_2ADDR /* 0xb5 */ 20910 .long .L_ALT_OP_OR_INT_2ADDR /* 0xb6 */ 20911 .long .L_ALT_OP_XOR_INT_2ADDR /* 0xb7 */ 20912 .long .L_ALT_OP_SHL_INT_2ADDR /* 0xb8 */ 20913 .long .L_ALT_OP_SHR_INT_2ADDR /* 0xb9 */ 20914 .long .L_ALT_OP_USHR_INT_2ADDR /* 0xba */ 20915 .long .L_ALT_OP_ADD_LONG_2ADDR /* 0xbb */ 20916 .long .L_ALT_OP_SUB_LONG_2ADDR /* 0xbc */ 20917 .long .L_ALT_OP_MUL_LONG_2ADDR /* 0xbd */ 20918 .long .L_ALT_OP_DIV_LONG_2ADDR /* 0xbe */ 20919 .long .L_ALT_OP_REM_LONG_2ADDR /* 0xbf */ 20920 .long .L_ALT_OP_AND_LONG_2ADDR /* 0xc0 */ 20921 .long .L_ALT_OP_OR_LONG_2ADDR /* 0xc1 */ 20922 .long .L_ALT_OP_XOR_LONG_2ADDR /* 0xc2 */ 20923 .long .L_ALT_OP_SHL_LONG_2ADDR /* 0xc3 */ 20924 .long .L_ALT_OP_SHR_LONG_2ADDR /* 0xc4 */ 20925 .long .L_ALT_OP_USHR_LONG_2ADDR /* 0xc5 */ 20926 .long .L_ALT_OP_ADD_FLOAT_2ADDR /* 0xc6 */ 20927 .long .L_ALT_OP_SUB_FLOAT_2ADDR /* 0xc7 */ 20928 .long .L_ALT_OP_MUL_FLOAT_2ADDR /* 0xc8 */ 20929 .long .L_ALT_OP_DIV_FLOAT_2ADDR /* 0xc9 */ 20930 .long .L_ALT_OP_REM_FLOAT_2ADDR /* 0xca */ 20931 .long .L_ALT_OP_ADD_DOUBLE_2ADDR /* 0xcb */ 20932 .long .L_ALT_OP_SUB_DOUBLE_2ADDR /* 0xcc */ 20933 .long .L_ALT_OP_MUL_DOUBLE_2ADDR /* 0xcd */ 20934 .long .L_ALT_OP_DIV_DOUBLE_2ADDR /* 0xce */ 20935 .long .L_ALT_OP_REM_DOUBLE_2ADDR /* 0xcf */ 20936 .long .L_ALT_OP_ADD_INT_LIT16 /* 0xd0 */ 20937 .long .L_ALT_OP_RSUB_INT /* 0xd1 */ 20938 .long .L_ALT_OP_MUL_INT_LIT16 /* 0xd2 */ 20939 .long .L_ALT_OP_DIV_INT_LIT16 /* 0xd3 */ 20940 .long .L_ALT_OP_REM_INT_LIT16 /* 0xd4 */ 20941 .long .L_ALT_OP_AND_INT_LIT16 /* 0xd5 */ 20942 .long .L_ALT_OP_OR_INT_LIT16 /* 0xd6 */ 20943 .long .L_ALT_OP_XOR_INT_LIT16 /* 0xd7 */ 20944 .long .L_ALT_OP_ADD_INT_LIT8 /* 0xd8 */ 20945 .long .L_ALT_OP_RSUB_INT_LIT8 /* 0xd9 */ 20946 .long .L_ALT_OP_MUL_INT_LIT8 /* 0xda */ 20947 .long .L_ALT_OP_DIV_INT_LIT8 /* 0xdb */ 20948 .long .L_ALT_OP_REM_INT_LIT8 /* 0xdc */ 20949 .long .L_ALT_OP_AND_INT_LIT8 /* 0xdd */ 20950 .long .L_ALT_OP_OR_INT_LIT8 /* 0xde */ 20951 .long .L_ALT_OP_XOR_INT_LIT8 /* 0xdf */ 20952 .long .L_ALT_OP_SHL_INT_LIT8 /* 0xe0 */ 20953 .long .L_ALT_OP_SHR_INT_LIT8 /* 0xe1 */ 20954 .long .L_ALT_OP_USHR_INT_LIT8 /* 0xe2 */ 20955 .long .L_ALT_OP_IGET_VOLATILE /* 0xe3 */ 20956 .long .L_ALT_OP_IPUT_VOLATILE /* 0xe4 */ 20957 .long .L_ALT_OP_SGET_VOLATILE /* 0xe5 */ 20958 .long .L_ALT_OP_SPUT_VOLATILE /* 0xe6 */ 20959 .long .L_ALT_OP_IGET_OBJECT_VOLATILE /* 0xe7 */ 20960 .long .L_ALT_OP_IGET_WIDE_VOLATILE /* 0xe8 */ 20961 .long .L_ALT_OP_IPUT_WIDE_VOLATILE /* 0xe9 */ 20962 .long .L_ALT_OP_SGET_WIDE_VOLATILE /* 0xea */ 20963 .long .L_ALT_OP_SPUT_WIDE_VOLATILE /* 0xeb */ 20964 .long .L_ALT_OP_BREAKPOINT /* 0xec */ 20965 .long .L_ALT_OP_THROW_VERIFICATION_ERROR /* 0xed */ 20966 .long .L_ALT_OP_EXECUTE_INLINE /* 0xee */ 20967 .long .L_ALT_OP_EXECUTE_INLINE_RANGE /* 0xef */ 20968 .long .L_ALT_OP_INVOKE_OBJECT_INIT_RANGE /* 0xf0 */ 20969 .long .L_ALT_OP_RETURN_VOID_BARRIER /* 0xf1 */ 20970 .long .L_ALT_OP_IGET_QUICK /* 0xf2 */ 20971 .long .L_ALT_OP_IGET_WIDE_QUICK /* 0xf3 */ 20972 .long .L_ALT_OP_IGET_OBJECT_QUICK /* 0xf4 */ 20973 .long .L_ALT_OP_IPUT_QUICK /* 0xf5 */ 20974 .long .L_ALT_OP_IPUT_WIDE_QUICK /* 0xf6 */ 20975 .long .L_ALT_OP_IPUT_OBJECT_QUICK /* 0xf7 */ 20976 .long .L_ALT_OP_INVOKE_VIRTUAL_QUICK /* 0xf8 */ 20977 .long .L_ALT_OP_INVOKE_VIRTUAL_QUICK_RANGE /* 0xf9 */ 20978 .long .L_ALT_OP_INVOKE_SUPER_QUICK /* 0xfa */ 20979 .long .L_ALT_OP_INVOKE_SUPER_QUICK_RANGE /* 0xfb */ 20980 .long .L_ALT_OP_IPUT_OBJECT_VOLATILE /* 0xfc */ 20981 .long .L_ALT_OP_SGET_OBJECT_VOLATILE /* 0xfd */ 20982 .long .L_ALT_OP_SPUT_OBJECT_VOLATILE /* 0xfe */ 20983 .long .L_ALT_OP_DISPATCH_FF /* 0xff */ 20984 .long .L_ALT_OP_CONST_CLASS_JUMBO /* 0x100 */ 20985 .long .L_ALT_OP_CHECK_CAST_JUMBO /* 0x101 */ 20986 .long .L_ALT_OP_INSTANCE_OF_JUMBO /* 0x102 */ 20987 .long .L_ALT_OP_NEW_INSTANCE_JUMBO /* 0x103 */ 20988 .long .L_ALT_OP_NEW_ARRAY_JUMBO /* 0x104 */ 20989 .long .L_ALT_OP_FILLED_NEW_ARRAY_JUMBO /* 0x105 */ 20990 .long .L_ALT_OP_IGET_JUMBO /* 0x106 */ 20991 .long .L_ALT_OP_IGET_WIDE_JUMBO /* 0x107 */ 20992 .long .L_ALT_OP_IGET_OBJECT_JUMBO /* 0x108 */ 20993 .long .L_ALT_OP_IGET_BOOLEAN_JUMBO /* 0x109 */ 20994 .long .L_ALT_OP_IGET_BYTE_JUMBO /* 0x10a */ 20995 .long .L_ALT_OP_IGET_CHAR_JUMBO /* 0x10b */ 20996 .long .L_ALT_OP_IGET_SHORT_JUMBO /* 0x10c */ 20997 .long .L_ALT_OP_IPUT_JUMBO /* 0x10d */ 20998 .long .L_ALT_OP_IPUT_WIDE_JUMBO /* 0x10e */ 20999 .long .L_ALT_OP_IPUT_OBJECT_JUMBO /* 0x10f */ 21000 .long .L_ALT_OP_IPUT_BOOLEAN_JUMBO /* 0x110 */ 21001 .long .L_ALT_OP_IPUT_BYTE_JUMBO /* 0x111 */ 21002 .long .L_ALT_OP_IPUT_CHAR_JUMBO /* 0x112 */ 21003 .long .L_ALT_OP_IPUT_SHORT_JUMBO /* 0x113 */ 21004 .long .L_ALT_OP_SGET_JUMBO /* 0x114 */ 21005 .long .L_ALT_OP_SGET_WIDE_JUMBO /* 0x115 */ 21006 .long .L_ALT_OP_SGET_OBJECT_JUMBO /* 0x116 */ 21007 .long .L_ALT_OP_SGET_BOOLEAN_JUMBO /* 0x117 */ 21008 .long .L_ALT_OP_SGET_BYTE_JUMBO /* 0x118 */ 21009 .long .L_ALT_OP_SGET_CHAR_JUMBO /* 0x119 */ 21010 .long .L_ALT_OP_SGET_SHORT_JUMBO /* 0x11a */ 21011 .long .L_ALT_OP_SPUT_JUMBO /* 0x11b */ 21012 .long .L_ALT_OP_SPUT_WIDE_JUMBO /* 0x11c */ 21013 .long .L_ALT_OP_SPUT_OBJECT_JUMBO /* 0x11d */ 21014 .long .L_ALT_OP_SPUT_BOOLEAN_JUMBO /* 0x11e */ 21015 .long .L_ALT_OP_SPUT_BYTE_JUMBO /* 0x11f */ 21016 .long .L_ALT_OP_SPUT_CHAR_JUMBO /* 0x120 */ 21017 .long .L_ALT_OP_SPUT_SHORT_JUMBO /* 0x121 */ 21018 .long .L_ALT_OP_INVOKE_VIRTUAL_JUMBO /* 0x122 */ 21019 .long .L_ALT_OP_INVOKE_SUPER_JUMBO /* 0x123 */ 21020 .long .L_ALT_OP_INVOKE_DIRECT_JUMBO /* 0x124 */ 21021 .long .L_ALT_OP_INVOKE_STATIC_JUMBO /* 0x125 */ 21022 .long .L_ALT_OP_INVOKE_INTERFACE_JUMBO /* 0x126 */ 21023 .long .L_ALT_OP_UNUSED_27FF /* 0x127 */ 21024 .long .L_ALT_OP_UNUSED_28FF /* 0x128 */ 21025 .long .L_ALT_OP_UNUSED_29FF /* 0x129 */ 21026 .long .L_ALT_OP_UNUSED_2AFF /* 0x12a */ 21027 .long .L_ALT_OP_UNUSED_2BFF /* 0x12b */ 21028 .long .L_ALT_OP_UNUSED_2CFF /* 0x12c */ 21029 .long .L_ALT_OP_UNUSED_2DFF /* 0x12d */ 21030 .long .L_ALT_OP_UNUSED_2EFF /* 0x12e */ 21031 .long .L_ALT_OP_UNUSED_2FFF /* 0x12f */ 21032 .long .L_ALT_OP_UNUSED_30FF /* 0x130 */ 21033 .long .L_ALT_OP_UNUSED_31FF /* 0x131 */ 21034 .long .L_ALT_OP_UNUSED_32FF /* 0x132 */ 21035 .long .L_ALT_OP_UNUSED_33FF /* 0x133 */ 21036 .long .L_ALT_OP_UNUSED_34FF /* 0x134 */ 21037 .long .L_ALT_OP_UNUSED_35FF /* 0x135 */ 21038 .long .L_ALT_OP_UNUSED_36FF /* 0x136 */ 21039 .long .L_ALT_OP_UNUSED_37FF /* 0x137 */ 21040 .long .L_ALT_OP_UNUSED_38FF /* 0x138 */ 21041 .long .L_ALT_OP_UNUSED_39FF /* 0x139 */ 21042 .long .L_ALT_OP_UNUSED_3AFF /* 0x13a */ 21043 .long .L_ALT_OP_UNUSED_3BFF /* 0x13b */ 21044 .long .L_ALT_OP_UNUSED_3CFF /* 0x13c */ 21045 .long .L_ALT_OP_UNUSED_3DFF /* 0x13d */ 21046 .long .L_ALT_OP_UNUSED_3EFF /* 0x13e */ 21047 .long .L_ALT_OP_UNUSED_3FFF /* 0x13f */ 21048 .long .L_ALT_OP_UNUSED_40FF /* 0x140 */ 21049 .long .L_ALT_OP_UNUSED_41FF /* 0x141 */ 21050 .long .L_ALT_OP_UNUSED_42FF /* 0x142 */ 21051 .long .L_ALT_OP_UNUSED_43FF /* 0x143 */ 21052 .long .L_ALT_OP_UNUSED_44FF /* 0x144 */ 21053 .long .L_ALT_OP_UNUSED_45FF /* 0x145 */ 21054 .long .L_ALT_OP_UNUSED_46FF /* 0x146 */ 21055 .long .L_ALT_OP_UNUSED_47FF /* 0x147 */ 21056 .long .L_ALT_OP_UNUSED_48FF /* 0x148 */ 21057 .long .L_ALT_OP_UNUSED_49FF /* 0x149 */ 21058 .long .L_ALT_OP_UNUSED_4AFF /* 0x14a */ 21059 .long .L_ALT_OP_UNUSED_4BFF /* 0x14b */ 21060 .long .L_ALT_OP_UNUSED_4CFF /* 0x14c */ 21061 .long .L_ALT_OP_UNUSED_4DFF /* 0x14d */ 21062 .long .L_ALT_OP_UNUSED_4EFF /* 0x14e */ 21063 .long .L_ALT_OP_UNUSED_4FFF /* 0x14f */ 21064 .long .L_ALT_OP_UNUSED_50FF /* 0x150 */ 21065 .long .L_ALT_OP_UNUSED_51FF /* 0x151 */ 21066 .long .L_ALT_OP_UNUSED_52FF /* 0x152 */ 21067 .long .L_ALT_OP_UNUSED_53FF /* 0x153 */ 21068 .long .L_ALT_OP_UNUSED_54FF /* 0x154 */ 21069 .long .L_ALT_OP_UNUSED_55FF /* 0x155 */ 21070 .long .L_ALT_OP_UNUSED_56FF /* 0x156 */ 21071 .long .L_ALT_OP_UNUSED_57FF /* 0x157 */ 21072 .long .L_ALT_OP_UNUSED_58FF /* 0x158 */ 21073 .long .L_ALT_OP_UNUSED_59FF /* 0x159 */ 21074 .long .L_ALT_OP_UNUSED_5AFF /* 0x15a */ 21075 .long .L_ALT_OP_UNUSED_5BFF /* 0x15b */ 21076 .long .L_ALT_OP_UNUSED_5CFF /* 0x15c */ 21077 .long .L_ALT_OP_UNUSED_5DFF /* 0x15d */ 21078 .long .L_ALT_OP_UNUSED_5EFF /* 0x15e */ 21079 .long .L_ALT_OP_UNUSED_5FFF /* 0x15f */ 21080 .long .L_ALT_OP_UNUSED_60FF /* 0x160 */ 21081 .long .L_ALT_OP_UNUSED_61FF /* 0x161 */ 21082 .long .L_ALT_OP_UNUSED_62FF /* 0x162 */ 21083 .long .L_ALT_OP_UNUSED_63FF /* 0x163 */ 21084 .long .L_ALT_OP_UNUSED_64FF /* 0x164 */ 21085 .long .L_ALT_OP_UNUSED_65FF /* 0x165 */ 21086 .long .L_ALT_OP_UNUSED_66FF /* 0x166 */ 21087 .long .L_ALT_OP_UNUSED_67FF /* 0x167 */ 21088 .long .L_ALT_OP_UNUSED_68FF /* 0x168 */ 21089 .long .L_ALT_OP_UNUSED_69FF /* 0x169 */ 21090 .long .L_ALT_OP_UNUSED_6AFF /* 0x16a */ 21091 .long .L_ALT_OP_UNUSED_6BFF /* 0x16b */ 21092 .long .L_ALT_OP_UNUSED_6CFF /* 0x16c */ 21093 .long .L_ALT_OP_UNUSED_6DFF /* 0x16d */ 21094 .long .L_ALT_OP_UNUSED_6EFF /* 0x16e */ 21095 .long .L_ALT_OP_UNUSED_6FFF /* 0x16f */ 21096 .long .L_ALT_OP_UNUSED_70FF /* 0x170 */ 21097 .long .L_ALT_OP_UNUSED_71FF /* 0x171 */ 21098 .long .L_ALT_OP_UNUSED_72FF /* 0x172 */ 21099 .long .L_ALT_OP_UNUSED_73FF /* 0x173 */ 21100 .long .L_ALT_OP_UNUSED_74FF /* 0x174 */ 21101 .long .L_ALT_OP_UNUSED_75FF /* 0x175 */ 21102 .long .L_ALT_OP_UNUSED_76FF /* 0x176 */ 21103 .long .L_ALT_OP_UNUSED_77FF /* 0x177 */ 21104 .long .L_ALT_OP_UNUSED_78FF /* 0x178 */ 21105 .long .L_ALT_OP_UNUSED_79FF /* 0x179 */ 21106 .long .L_ALT_OP_UNUSED_7AFF /* 0x17a */ 21107 .long .L_ALT_OP_UNUSED_7BFF /* 0x17b */ 21108 .long .L_ALT_OP_UNUSED_7CFF /* 0x17c */ 21109 .long .L_ALT_OP_UNUSED_7DFF /* 0x17d */ 21110 .long .L_ALT_OP_UNUSED_7EFF /* 0x17e */ 21111 .long .L_ALT_OP_UNUSED_7FFF /* 0x17f */ 21112 .long .L_ALT_OP_UNUSED_80FF /* 0x180 */ 21113 .long .L_ALT_OP_UNUSED_81FF /* 0x181 */ 21114 .long .L_ALT_OP_UNUSED_82FF /* 0x182 */ 21115 .long .L_ALT_OP_UNUSED_83FF /* 0x183 */ 21116 .long .L_ALT_OP_UNUSED_84FF /* 0x184 */ 21117 .long .L_ALT_OP_UNUSED_85FF /* 0x185 */ 21118 .long .L_ALT_OP_UNUSED_86FF /* 0x186 */ 21119 .long .L_ALT_OP_UNUSED_87FF /* 0x187 */ 21120 .long .L_ALT_OP_UNUSED_88FF /* 0x188 */ 21121 .long .L_ALT_OP_UNUSED_89FF /* 0x189 */ 21122 .long .L_ALT_OP_UNUSED_8AFF /* 0x18a */ 21123 .long .L_ALT_OP_UNUSED_8BFF /* 0x18b */ 21124 .long .L_ALT_OP_UNUSED_8CFF /* 0x18c */ 21125 .long .L_ALT_OP_UNUSED_8DFF /* 0x18d */ 21126 .long .L_ALT_OP_UNUSED_8EFF /* 0x18e */ 21127 .long .L_ALT_OP_UNUSED_8FFF /* 0x18f */ 21128 .long .L_ALT_OP_UNUSED_90FF /* 0x190 */ 21129 .long .L_ALT_OP_UNUSED_91FF /* 0x191 */ 21130 .long .L_ALT_OP_UNUSED_92FF /* 0x192 */ 21131 .long .L_ALT_OP_UNUSED_93FF /* 0x193 */ 21132 .long .L_ALT_OP_UNUSED_94FF /* 0x194 */ 21133 .long .L_ALT_OP_UNUSED_95FF /* 0x195 */ 21134 .long .L_ALT_OP_UNUSED_96FF /* 0x196 */ 21135 .long .L_ALT_OP_UNUSED_97FF /* 0x197 */ 21136 .long .L_ALT_OP_UNUSED_98FF /* 0x198 */ 21137 .long .L_ALT_OP_UNUSED_99FF /* 0x199 */ 21138 .long .L_ALT_OP_UNUSED_9AFF /* 0x19a */ 21139 .long .L_ALT_OP_UNUSED_9BFF /* 0x19b */ 21140 .long .L_ALT_OP_UNUSED_9CFF /* 0x19c */ 21141 .long .L_ALT_OP_UNUSED_9DFF /* 0x19d */ 21142 .long .L_ALT_OP_UNUSED_9EFF /* 0x19e */ 21143 .long .L_ALT_OP_UNUSED_9FFF /* 0x19f */ 21144 .long .L_ALT_OP_UNUSED_A0FF /* 0x1a0 */ 21145 .long .L_ALT_OP_UNUSED_A1FF /* 0x1a1 */ 21146 .long .L_ALT_OP_UNUSED_A2FF /* 0x1a2 */ 21147 .long .L_ALT_OP_UNUSED_A3FF /* 0x1a3 */ 21148 .long .L_ALT_OP_UNUSED_A4FF /* 0x1a4 */ 21149 .long .L_ALT_OP_UNUSED_A5FF /* 0x1a5 */ 21150 .long .L_ALT_OP_UNUSED_A6FF /* 0x1a6 */ 21151 .long .L_ALT_OP_UNUSED_A7FF /* 0x1a7 */ 21152 .long .L_ALT_OP_UNUSED_A8FF /* 0x1a8 */ 21153 .long .L_ALT_OP_UNUSED_A9FF /* 0x1a9 */ 21154 .long .L_ALT_OP_UNUSED_AAFF /* 0x1aa */ 21155 .long .L_ALT_OP_UNUSED_ABFF /* 0x1ab */ 21156 .long .L_ALT_OP_UNUSED_ACFF /* 0x1ac */ 21157 .long .L_ALT_OP_UNUSED_ADFF /* 0x1ad */ 21158 .long .L_ALT_OP_UNUSED_AEFF /* 0x1ae */ 21159 .long .L_ALT_OP_UNUSED_AFFF /* 0x1af */ 21160 .long .L_ALT_OP_UNUSED_B0FF /* 0x1b0 */ 21161 .long .L_ALT_OP_UNUSED_B1FF /* 0x1b1 */ 21162 .long .L_ALT_OP_UNUSED_B2FF /* 0x1b2 */ 21163 .long .L_ALT_OP_UNUSED_B3FF /* 0x1b3 */ 21164 .long .L_ALT_OP_UNUSED_B4FF /* 0x1b4 */ 21165 .long .L_ALT_OP_UNUSED_B5FF /* 0x1b5 */ 21166 .long .L_ALT_OP_UNUSED_B6FF /* 0x1b6 */ 21167 .long .L_ALT_OP_UNUSED_B7FF /* 0x1b7 */ 21168 .long .L_ALT_OP_UNUSED_B8FF /* 0x1b8 */ 21169 .long .L_ALT_OP_UNUSED_B9FF /* 0x1b9 */ 21170 .long .L_ALT_OP_UNUSED_BAFF /* 0x1ba */ 21171 .long .L_ALT_OP_UNUSED_BBFF /* 0x1bb */ 21172 .long .L_ALT_OP_UNUSED_BCFF /* 0x1bc */ 21173 .long .L_ALT_OP_UNUSED_BDFF /* 0x1bd */ 21174 .long .L_ALT_OP_UNUSED_BEFF /* 0x1be */ 21175 .long .L_ALT_OP_UNUSED_BFFF /* 0x1bf */ 21176 .long .L_ALT_OP_UNUSED_C0FF /* 0x1c0 */ 21177 .long .L_ALT_OP_UNUSED_C1FF /* 0x1c1 */ 21178 .long .L_ALT_OP_UNUSED_C2FF /* 0x1c2 */ 21179 .long .L_ALT_OP_UNUSED_C3FF /* 0x1c3 */ 21180 .long .L_ALT_OP_UNUSED_C4FF /* 0x1c4 */ 21181 .long .L_ALT_OP_UNUSED_C5FF /* 0x1c5 */ 21182 .long .L_ALT_OP_UNUSED_C6FF /* 0x1c6 */ 21183 .long .L_ALT_OP_UNUSED_C7FF /* 0x1c7 */ 21184 .long .L_ALT_OP_UNUSED_C8FF /* 0x1c8 */ 21185 .long .L_ALT_OP_UNUSED_C9FF /* 0x1c9 */ 21186 .long .L_ALT_OP_UNUSED_CAFF /* 0x1ca */ 21187 .long .L_ALT_OP_UNUSED_CBFF /* 0x1cb */ 21188 .long .L_ALT_OP_UNUSED_CCFF /* 0x1cc */ 21189 .long .L_ALT_OP_UNUSED_CDFF /* 0x1cd */ 21190 .long .L_ALT_OP_UNUSED_CEFF /* 0x1ce */ 21191 .long .L_ALT_OP_UNUSED_CFFF /* 0x1cf */ 21192 .long .L_ALT_OP_UNUSED_D0FF /* 0x1d0 */ 21193 .long .L_ALT_OP_UNUSED_D1FF /* 0x1d1 */ 21194 .long .L_ALT_OP_UNUSED_D2FF /* 0x1d2 */ 21195 .long .L_ALT_OP_UNUSED_D3FF /* 0x1d3 */ 21196 .long .L_ALT_OP_UNUSED_D4FF /* 0x1d4 */ 21197 .long .L_ALT_OP_UNUSED_D5FF /* 0x1d5 */ 21198 .long .L_ALT_OP_UNUSED_D6FF /* 0x1d6 */ 21199 .long .L_ALT_OP_UNUSED_D7FF /* 0x1d7 */ 21200 .long .L_ALT_OP_UNUSED_D8FF /* 0x1d8 */ 21201 .long .L_ALT_OP_UNUSED_D9FF /* 0x1d9 */ 21202 .long .L_ALT_OP_UNUSED_DAFF /* 0x1da */ 21203 .long .L_ALT_OP_UNUSED_DBFF /* 0x1db */ 21204 .long .L_ALT_OP_UNUSED_DCFF /* 0x1dc */ 21205 .long .L_ALT_OP_UNUSED_DDFF /* 0x1dd */ 21206 .long .L_ALT_OP_UNUSED_DEFF /* 0x1de */ 21207 .long .L_ALT_OP_UNUSED_DFFF /* 0x1df */ 21208 .long .L_ALT_OP_UNUSED_E0FF /* 0x1e0 */ 21209 .long .L_ALT_OP_UNUSED_E1FF /* 0x1e1 */ 21210 .long .L_ALT_OP_UNUSED_E2FF /* 0x1e2 */ 21211 .long .L_ALT_OP_UNUSED_E3FF /* 0x1e3 */ 21212 .long .L_ALT_OP_UNUSED_E4FF /* 0x1e4 */ 21213 .long .L_ALT_OP_UNUSED_E5FF /* 0x1e5 */ 21214 .long .L_ALT_OP_UNUSED_E6FF /* 0x1e6 */ 21215 .long .L_ALT_OP_UNUSED_E7FF /* 0x1e7 */ 21216 .long .L_ALT_OP_UNUSED_E8FF /* 0x1e8 */ 21217 .long .L_ALT_OP_UNUSED_E9FF /* 0x1e9 */ 21218 .long .L_ALT_OP_UNUSED_EAFF /* 0x1ea */ 21219 .long .L_ALT_OP_UNUSED_EBFF /* 0x1eb */ 21220 .long .L_ALT_OP_UNUSED_ECFF /* 0x1ec */ 21221 .long .L_ALT_OP_UNUSED_EDFF /* 0x1ed */ 21222 .long .L_ALT_OP_UNUSED_EEFF /* 0x1ee */ 21223 .long .L_ALT_OP_UNUSED_EFFF /* 0x1ef */ 21224 .long .L_ALT_OP_UNUSED_F0FF /* 0x1f0 */ 21225 .long .L_ALT_OP_UNUSED_F1FF /* 0x1f1 */ 21226 .long .L_ALT_OP_INVOKE_OBJECT_INIT_JUMBO /* 0x1f2 */ 21227 .long .L_ALT_OP_IGET_VOLATILE_JUMBO /* 0x1f3 */ 21228 .long .L_ALT_OP_IGET_WIDE_VOLATILE_JUMBO /* 0x1f4 */ 21229 .long .L_ALT_OP_IGET_OBJECT_VOLATILE_JUMBO /* 0x1f5 */ 21230 .long .L_ALT_OP_IPUT_VOLATILE_JUMBO /* 0x1f6 */ 21231 .long .L_ALT_OP_IPUT_WIDE_VOLATILE_JUMBO /* 0x1f7 */ 21232 .long .L_ALT_OP_IPUT_OBJECT_VOLATILE_JUMBO /* 0x1f8 */ 21233 .long .L_ALT_OP_SGET_VOLATILE_JUMBO /* 0x1f9 */ 21234 .long .L_ALT_OP_SGET_WIDE_VOLATILE_JUMBO /* 0x1fa */ 21235 .long .L_ALT_OP_SGET_OBJECT_VOLATILE_JUMBO /* 0x1fb */ 21236 .long .L_ALT_OP_SPUT_VOLATILE_JUMBO /* 0x1fc */ 21237 .long .L_ALT_OP_SPUT_WIDE_VOLATILE_JUMBO /* 0x1fd */ 21238 .long .L_ALT_OP_SPUT_OBJECT_VOLATILE_JUMBO /* 0x1fe */ 21239 .long .L_ALT_OP_THROW_VERIFICATION_ERROR_JUMBO /* 0x1ff */ 21240/* File: x86/entry.S */ 21241/* 21242 * Copyright (C) 2008 The Android Open Source Project 21243 * 21244 * Licensed under the Apache License, Version 2.0 (the "License"); 21245 * you may not use this file except in compliance with the License. 21246 * You may obtain a copy of the License at 21247 * 21248 * http://www.apache.org/licenses/LICENSE-2.0 21249 * 21250 * Unless required by applicable law or agreed to in writing, software 21251 * distributed under the License is distributed on an "AS IS" BASIS, 21252 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 21253 * See the License for the specific language governing permissions and 21254 * limitations under the License. 21255 */ 21256 21257 21258 .text 21259 .global dvmMterpStdRun 21260 .type dvmMterpStdRun, %function 21261/* 21262 * bool dvmMterpStdRun(Thread* self) 21263 * 21264 * Interpreter entry point. Returns changeInterp. 21265 * 21266 */ 21267dvmMterpStdRun: 21268 movl 4(%esp), %ecx # get incoming rSELF 21269 push %ebp # save caller base pointer 21270 push %ecx # save rSELF at (%ebp) 21271 movl %esp, %ebp # set our %ebp 21272/* 21273 * At this point we've allocated two slots on the stack 21274 * via push and stack is 8-byte aligned. Allocate space 21275 * for 8 spill slots, 3 local slots, 5 arg slots + 2 slots for 21276 * padding to bring us to 16-byte alignment 21277 */ 21278 subl $(FRAME_SIZE-8), %esp 21279 21280/* Spill callee save regs */ 21281 movl %edi,EDI_SPILL(%ebp) 21282 movl %esi,ESI_SPILL(%ebp) 21283 movl %ebx,EBX_SPILL(%ebp) 21284 21285/* Set up "named" registers */ 21286 movl offThread_pc(%ecx),rPC 21287 movl offThread_fp(%ecx),rFP 21288 movl offThread_curHandlerTable(%ecx),rIBASE 21289 21290/* Remember %esp for future "longjmp" */ 21291 movl %esp,offThread_bailPtr(%ecx) 21292 21293/* How to start? */ 21294 movb offThread_entryPoint(%ecx),%al 21295 21296/* Normal start? */ 21297 cmpb $kInterpEntryInstr,%al 21298 jne .Lnot_instr 21299 21300 /* Normal case: start executing the instruction at rPC */ 21301 FETCH_INST 21302 GOTO_NEXT 21303 21304.Lnot_instr: 21305 /* Reset to normal case */ 21306 movb $kInterpEntryInstr,offThread_entryPoint(%ecx) 21307 cmpb $kInterpEntryReturn,%al 21308 je common_returnFromMethod 21309 cmpb $kInterpEntryThrow,%al 21310 je common_exceptionThrown 21311 movzx %al,%eax 21312 movl %eax,OUT_ARG1(%esp) 21313 movl $.LstrBadEntryPoint,OUT_ARG0(%esp) 21314 call printf 21315 call dvmAbort 21316 /* Not reached */ 21317 21318 21319 .global dvmMterpStdBail 21320 .type dvmMterpStdBail, %function 21321/* 21322 * void dvmMterpStdBail(Thread* self, bool changeInterp) 21323 * 21324 * Restore the stack pointer and PC from the save point established on entry. 21325 * This is essentially the same as a longjmp, but should be cheaper. The 21326 * last instruction causes us to return to whoever called dvmMterpStdRun. 21327 * 21328 * We're not going to build a standard frame here, so the arg accesses will 21329 * look a little strange. 21330 * 21331 * On entry: 21332 * esp+4 (arg0) Thread* self 21333 * esp+8 (arg1) bool changeInterp 21334 */ 21335dvmMterpStdBail: 21336 movl 4(%esp),%ecx # grab self 21337 movl 8(%esp),%eax # changeInterp to return reg 21338 movl offThread_bailPtr(%ecx),%esp # Restore "setjmp" esp 21339 movl %esp,%ebp 21340 addl $(FRAME_SIZE-8), %ebp # Restore %ebp at point of setjmp 21341 movl EDI_SPILL(%ebp),%edi 21342 movl ESI_SPILL(%ebp),%esi 21343 movl EBX_SPILL(%ebp),%ebx 21344 movl PREV_FP(%ebp),%ebp # restore caller's ebp 21345 addl $FRAME_SIZE,%esp # strip frame 21346 ret # return to dvmMterpStdRun's caller 21347 21348 21349/* 21350 * Strings 21351 */ 21352 .section .rodata 21353.LstrBadEntryPoint: 21354 .asciz "Bad entry point %d\n" 21355 21356 21357/* File: x86/footer.S */ 21358/* 21359 * Copyright (C) 2008 The Android Open Source Project 21360 * 21361 * Licensed under the Apache License, Version 2.0 (the "License"); 21362 * you may not use this file except in compliance with the License. 21363 * You may obtain a copy of the License at 21364 * 21365 * http://www.apache.org/licenses/LICENSE-2.0 21366 * 21367 * Unless required by applicable law or agreed to in writing, software 21368 * distributed under the License is distributed on an "AS IS" BASIS, 21369 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 21370 * See the License for the specific language governing permissions and 21371 * limitations under the License. 21372 */ 21373/* 21374 * Common subroutines and data. 21375 */ 21376 21377#if defined(WITH_JIT) 21378/* 21379 * JIT-related re-entries into the interpreter. In general, if the 21380 * exit from a translation can at some point be chained, the entry 21381 * here requires that control arrived via a call, and that the "rp" 21382 * on TOS is actually a pointer to a 32-bit cell containing the Dalvik PC 21383 * of the next insn to handle. If no chaining will happen, the entry 21384 * should be reached via a direct jump and rPC set beforehand. 21385 */ 21386 21387 .global dvmJitToInterpPunt 21388/* 21389 * The compiler will generate a jump to this entry point when it is 21390 * having difficulty translating a Dalvik instruction. We must skip 21391 * the code cache lookup & prevent chaining to avoid bouncing between 21392 * the interpreter and code cache. rPC must be set on entry. 21393 */ 21394dvmJitToInterpPunt: 21395#if defined(WITH_JIT_TUNING) 21396 movl rPC, OUT_ARG0(%esp) 21397 call dvmBumpPunt 21398#endif 21399 movl rSELF, %ecx 21400 movl offThread_curHandlerTable(%ecx),rIBASE 21401 FETCH_INST_R %ecx 21402 GOTO_NEXT_R %ecx 21403 21404 .global dvmJitToInterpSingleStep 21405/* 21406 * Return to the interpreter to handle a single instruction. 21407 * Should be reached via a call. 21408 * On entry: 21409 * 0(%esp) <= native return address within trace 21410 * rPC <= Dalvik PC of this instruction 21411 * OUT_ARG0+4(%esp) <= Dalvik PC of next instruction 21412 */ 21413dvmJitToInterpSingleStep: 21414 pop %eax 21415 movl rSELF, %ecx 21416 movl OUT_ARG0(%esp), %edx 21417 movl %eax,offThread_jitResumeNPC(%ecx) 21418 movl %edx,offThread_jitResumeDPC(%ecx) 21419 movl $kInterpEntryInstr,offThread_entryPoint(%ecx) 21420 movl $1,rINST # changeInterp <= true 21421 jmp common_gotoBail 21422 21423 .global dvmJitToInterpNoChainNoProfile 21424/* 21425 * Return from the translation cache to the interpreter to do method 21426 * invocation. Check if the translation exists for the callee, but don't 21427 * chain to it. rPC must be set on entry. 21428 */ 21429dvmJitToInterpNoChainNoProfile: 21430#if defined(WITH_JIT_TUNING) 21431 call dvmBumpNoChain 21432#endif 21433 movl rPC,OUT_ARG0(%esp) 21434 call dvmJitGetTraceAddr # is there a translation? 21435 movl rSELF,%ecx # ecx <- self 21436 movl %eax,offThread_inJitCodeCache(%ecx) # set inJitCodeCache flag 21437 cmpl $0, %eax 21438 jz 1f 21439 call *%eax # exec translation if we've got one 21440 # won't return 214411: 21442 movl rSELF, %ecx 21443 movl offThread_curHandlerTable(%ecx),rIBASE 21444 FETCH_INST_R %ecx 21445 GOTO_NEXT_R %ecx 21446 21447/* 21448 * Return from the translation cache and immediately request a 21449 * translation fro the exit target, but don't attempt to chain. 21450 * rPC set on entry. 21451 */ 21452 .global dvmJitToInterpTraceSelectNoChain 21453dvmJitToInterpTraceSelectNoChain: 21454#if defined(WITH_JIT_TUNING) 21455 call dvmBumpNoChain 21456#endif 21457 movl rPC,OUT_ARG0(%esp) 21458 call dvmJitGetTraceAddr # is there a translation? 21459 movl rSELF,%ecx 21460 cmpl $0,%eax 21461 movl %eax,offThread_inJitCodeCache(%ecx) # set inJitCodeCache flag 21462 jz 1f 21463 call *%eax # jump to tranlation 21464 # won't return 21465 21466/* No Translation - request one */ 214671: 21468 GET_JIT_PROF_TABLE %ecx %eax 21469 cmpl $0, %eax # JIT enabled? 21470 jnz 2f # Request one if so 21471 movl rSELF, %ecx 21472 movl offThread_curHandlerTable(%ecx),rIBASE 21473 FETCH_INST_R %ecx # Continue interpreting if not 21474 GOTO_NEXT_R %ecx 214752: 21476 movl $kJitTSelectRequestHot,rINST # ask for trace select 21477 jmp common_selectTrace 21478 21479/* 21480 * Return from the translation cache and immediately request a 21481 * translation for the exit target. Reached via a call, and 21482 * (TOS)->rPC. 21483 */ 21484 .global dvmJitToInterpTraceSelect 21485dvmJitToInterpTraceSelect: 21486 pop rINST # save chain cell address in callee save reg 21487 movl (rINST),rPC 21488 movl rPC,OUT_ARG0(%esp) 21489 call dvmJitGetTraceAddr # is there a translation? 21490 cmpl $0,%eax 21491 jz 1b # no - ask for one 21492 movl %eax,OUT_ARG0(%esp) 21493# FIXME - need to adjust rINST to beginning of sequence 21494 movl rINST,OUT_ARG1(%esp) 21495 call dvmJitChain # Attempt dvmJitChain(codeAddr,chainAddr) 21496 cmpl $0,%eax # Success? 21497 jz toInterpreter # didn't chain - interpret 21498 call *%eax 21499 # won't return 21500 21501/* 21502 * Placeholder entries for x86 JIT 21503 */ 21504 .global dvmJitToInterpBackwardBranch 21505dvmJitToInterpBackwardBranch: 21506 .global dvmJitToInterpNormal 21507dvmJitToInterpNormal: 21508 .global dvmJitToInterpNoChain 21509dvmJitToInterpNoChain: 21510toInterpreter: 21511 jmp common_abort 21512#endif 21513 21514/* 21515 * Common code when a backwards branch is taken 21516 * 21517 * On entry: 21518 * ebx (a.k.a. rINST) -> PC adjustment in 16-bit words 21519 */ 21520common_backwardBranch: 21521 movl rSELF,%ecx 21522 call common_periodicChecks # rPC and ecx/rSELF preserved 21523#if defined(WITH_JIT) 21524 GET_JIT_PROF_TABLE %ecx rIBASE 21525 ADVANCE_PC_INDEXED rINST 21526 cmpl $0,rIBASE 21527 movl offThread_curHandlerTable(%ecx),rIBASE 21528 FETCH_INST 21529 jz 1f # Profiling off - continue 21530 .global updateProfile 21531updateProfile: 21532common_updateProfile: 21533 # quick & dirty hash 21534 movl rPC, %eax 21535 shrl $12, %eax 21536 xorl rPC, %eax 21537 andl $((1<<JIT_PROF_SIZE_LOG_2)-1),%eax 21538 decb (%edx,%eax) 21539 jz 2f 215401: 21541 GOTO_NEXT 215422: 21543/* 21544 * Here, we switch to the debug interpreter to request 21545 * trace selection. First, though, check to see if there 21546 * is already a native translation in place (and, if so, 21547 * jump to it now. 21548 */ 21549 GET_JIT_THRESHOLD %ecx rINST # leaves rSELF in %ecx 21550 EXPORT_PC 21551 movb rINSTbl,(%edx,%eax) # reset counter 21552 movl %ecx,rINST # preserve rSELF 21553 movl rPC,OUT_ARG0(%esp) 21554 call dvmJitGetTraceAddr # already have one? 21555 movl %eax,offThread_inJitCodeCache(rINST) # set the inJitCodeCache flag 21556 cmpl $0,%eax 21557 jz 1f 21558 call *%eax # FIXME: decide call vs/ jmp!. No return either way 215591: 21560 movl $kJitTSelectRequest,%eax 21561 # On entry, eax<- jitState, rPC valid 21562common_selectTrace: 21563 21564 movl rSELF,%ecx 21565 movl %eax,offThread_jitState(%ecx) 21566 movl $kInterpEntryInstr,offThread_entryPoint(%ecx) 21567 movl $1,rINST 21568 jmp common_gotoBail 21569#else 21570 movl offThread_curHandlerTable(%ecx),rIBASE 21571 ADVANCE_PC_INDEXED rINST 21572 FETCH_INST 21573 GOTO_NEXT 21574#endif 21575 21576 21577 21578/* 21579 * Common code for jumbo method invocation. 21580 * 21581 * On entry: 21582 * eax = Method* methodToCall 21583 * rINSTw trashed, must reload 21584 * rIBASE trashed, must reload before resuming interpreter 21585 */ 21586 21587common_invokeMethodJumbo: 21588.LinvokeNewJumbo: 21589 21590 /* 21591 * prepare to copy args to "outs" area of current frame 21592 */ 21593 movzwl 6(rPC),rINST # rINST<- BBBB 21594 movzwl 8(rPC), %ecx # %ecx<- CCCC 21595 ADVANCE_PC 2 # adjust pc to make return similar 21596 SAVEAREA_FROM_FP %edx # %edx<- &StackSaveArea 21597 test rINST, rINST 21598 movl rINST, LOCAL0_OFFSET(%ebp) # LOCAL0_OFFSET(%ebp)<- BBBB 21599 jz .LinvokeArgsDone # no args; jump to args done 21600 jmp .LinvokeRangeArgs # handle args like invoke range 21601 21602/* 21603 * Common code for method invocation with range. 21604 * 21605 * On entry: 21606 * eax = Method* methodToCall 21607 * rINSTw trashed, must reload 21608 * rIBASE trashed, must reload before resuming interpreter 21609 */ 21610 21611common_invokeMethodRange: 21612.LinvokeNewRange: 21613 21614 /* 21615 * prepare to copy args to "outs" area of current frame 21616 */ 21617 21618 movzbl 1(rPC),rINST # rINST<- AA 21619 movzwl 4(rPC), %ecx # %ecx<- CCCC 21620 SAVEAREA_FROM_FP %edx # %edx<- &StackSaveArea 21621 test rINST, rINST 21622 movl rINST, LOCAL0_OFFSET(%ebp) # LOCAL0_OFFSET(%ebp)<- AA 21623 jz .LinvokeArgsDone # no args; jump to args done 21624 21625 21626 /* 21627 * %eax=methodToCall, %ecx=CCCC, LOCAL0_OFFSET(%ebp)=count, %edx=&outs (&stackSaveArea) 21628 * (very few methods have > 10 args; could unroll for common cases) 21629 */ 21630 21631.LinvokeRangeArgs: 21632 movl %ebx, LOCAL1_OFFSET(%ebp) # LOCAL1_OFFSET(%ebp)<- save %ebx 21633 lea (rFP, %ecx, 4), %ecx # %ecx<- &vCCCC 21634 shll $2, LOCAL0_OFFSET(%ebp) # LOCAL0_OFFSET(%ebp)<- offset 21635 subl LOCAL0_OFFSET(%ebp), %edx # %edx<- update &outs 21636 shrl $2, LOCAL0_OFFSET(%ebp) # LOCAL0_OFFSET(%ebp)<- offset 216371: 21638 movl (%ecx), %ebx # %ebx<- vCCCC 21639 lea 4(%ecx), %ecx # %ecx<- &vCCCC++ 21640 subl $1, LOCAL0_OFFSET(%ebp) # LOCAL0_OFFSET<- LOCAL0_OFFSET-- 21641 movl %ebx, (%edx) # *outs<- vCCCC 21642 lea 4(%edx), %edx # outs++ 21643 jne 1b # loop if count (LOCAL0_OFFSET(%ebp)) not zero 21644 movl LOCAL1_OFFSET(%ebp), %ebx # %ebx<- restore %ebx 21645 jmp .LinvokeArgsDone # continue 21646 21647 /* 21648 * %eax is "Method* methodToCall", the method we're trying to call 21649 * prepare to copy args to "outs" area of current frame 21650 * rIBASE trashed, must reload before resuming interpreter 21651 */ 21652 21653common_invokeMethodNoRange: 21654.LinvokeNewNoRange: 21655 movzbl 1(rPC),rINST # rINST<- BA 21656 movl rINST, LOCAL0_OFFSET(%ebp) # LOCAL0_OFFSET(%ebp)<- BA 21657 shrl $4, LOCAL0_OFFSET(%ebp) # LOCAL0_OFFSET(%ebp)<- B 21658 je .LinvokeArgsDone # no args; jump to args done 21659 movzwl 4(rPC), %ecx # %ecx<- GFED 21660 SAVEAREA_FROM_FP %edx # %edx<- &StackSaveArea 21661 21662 /* 21663 * %eax=methodToCall, %ecx=GFED, LOCAL0_OFFSET(%ebp)=count, %edx=outs 21664 */ 21665 21666.LinvokeNonRange: 21667 cmp $2, LOCAL0_OFFSET(%ebp) # compare LOCAL0_OFFSET(%ebp) to 2 21668 movl %ecx, LOCAL1_OFFSET(%ebp) # LOCAL1_OFFSET(%ebp)<- GFED 21669 jl 1f # handle 1 arg 21670 je 2f # handle 2 args 21671 cmp $4, LOCAL0_OFFSET(%ebp) # compare LOCAL0_OFFSET(%ebp) to 4 21672 jl 3f # handle 3 args 21673 je 4f # handle 4 args 216745: 21675 andl $15, rINST # rINSTw<- A 21676 lea -4(%edx), %edx # %edx<- update &outs; &outs-- 21677 movl (rFP, rINST, 4), %ecx # %ecx<- vA 21678 movl %ecx, (%edx) # *outs<- vA 21679 movl LOCAL1_OFFSET(%ebp), %ecx # %ecx<- GFED 216804: 21681 shr $12, %ecx # %ecx<- G 21682 lea -4(%edx), %edx # %edx<- update &outs; &outs-- 21683 movl (rFP, %ecx, 4), %ecx # %ecx<- vG 21684 movl %ecx, (%edx) # *outs<- vG 21685 movl LOCAL1_OFFSET(%ebp), %ecx # %ecx<- GFED 216863: 21687 and $0x0f00, %ecx # %ecx<- 0F00 21688 shr $8, %ecx # %ecx<- F 21689 lea -4(%edx), %edx # %edx<- update &outs; &outs-- 21690 movl (rFP, %ecx, 4), %ecx # %ecx<- vF 21691 movl %ecx, (%edx) # *outs<- vF 21692 movl LOCAL1_OFFSET(%ebp), %ecx # %ecx<- GFED 216932: 21694 and $0x00f0, %ecx # %ecx<- 00E0 21695 shr $4, %ecx # %ecx<- E 21696 lea -4(%edx), %edx # %edx<- update &outs; &outs-- 21697 movl (rFP, %ecx, 4), %ecx # %ecx<- vE 21698 movl %ecx, (%edx) # *outs<- vE 21699 movl LOCAL1_OFFSET(%ebp), %ecx # %ecx<- GFED 217001: 21701 and $0x000f, %ecx # %ecx<- 000D 21702 movl (rFP, %ecx, 4), %ecx # %ecx<- vD 21703 movl %ecx, -4(%edx) # *--outs<- vD 217040: 21705 21706 /* 21707 * %eax is "Method* methodToCall", the method we're trying to call 21708 * find space for the new stack frame, check for overflow 21709 */ 21710 21711.LinvokeArgsDone: 21712 movzwl offMethod_registersSize(%eax), %edx # %edx<- methodToCall->regsSize 21713 movzwl offMethod_outsSize(%eax), %ecx # %ecx<- methodToCall->outsSize 21714 movl %eax, LOCAL0_OFFSET(%ebp) # LOCAL0_OFFSET<- methodToCall 21715 shl $2, %edx # %edx<- update offset 21716 SAVEAREA_FROM_FP %eax # %eax<- &StackSaveArea 21717 subl %edx, %eax # %eax<- newFP; (old savearea - regsSize) 21718 movl rSELF,%edx # %edx<- pthread 21719 movl %eax, LOCAL1_OFFSET(%ebp) # LOCAL1_OFFSET(%ebp)<- &outs 21720 subl $sizeofStackSaveArea, %eax # %eax<- newSaveArea (stack save area using newFP) 21721 movl offThread_interpStackEnd(%edx), %edx # %edx<- self->interpStackEnd 21722 movl %edx, LOCAL2_OFFSET(%ebp) # LOCAL2_OFFSET<- self->interpStackEnd 21723 shl $2, %ecx # %ecx<- update offset for outsSize 21724 movl %eax, %edx # %edx<- newSaveArea 21725 sub %ecx, %eax # %eax<- bottom; (newSaveArea - outsSize) 21726 cmp LOCAL2_OFFSET(%ebp), %eax # compare interpStackEnd and bottom 21727 movl LOCAL0_OFFSET(%ebp), %eax # %eax<- restore methodToCall 21728 jl .LstackOverflow # handle frame overflow 21729 21730 /* 21731 * set up newSaveArea 21732 */ 21733 21734#ifdef EASY_GDB 21735 SAVEAREA_FROM_FP %ecx # %ecx<- &StackSaveArea 21736 movl %ecx, offStackSaveArea_prevSave(%edx) # newSaveArea->prevSave<- &outs 21737#endif 21738 movl rFP, offStackSaveArea_prevFrame(%edx) # newSaveArea->prevFrame<- rFP 21739 movl rPC, offStackSaveArea_savedPc(%edx) # newSaveArea->savedPc<- rPC 21740 testl $ACC_NATIVE, offMethod_accessFlags(%eax) # check for native call 21741 movl %eax, offStackSaveArea_method(%edx) # newSaveArea->method<- method to call 21742 jne .LinvokeNative # handle native call 21743 21744 /* 21745 * Update "self" values for the new method 21746 * %eax=methodToCall, LOCAL1_OFFSET(%ebp)=newFp 21747 */ 21748 21749 movl offMethod_clazz(%eax), %edx # %edx<- method->clazz 21750 movl rSELF,%ecx # %ecx<- pthread 21751 movl offClassObject_pDvmDex(%edx), %edx # %edx<- method->clazz->pDvmDex 21752 movl %eax, offThread_method(%ecx) # self->method<- methodToCall 21753 movl %edx, offThread_methodClassDex(%ecx) # self->methodClassDex<- method->clazz->pDvmDex 21754 movl offMethod_insns(%eax), rPC # rPC<- methodToCall->insns 21755 movl LOCAL1_OFFSET(%ebp), rFP # rFP<- newFP 21756 movl rFP, offThread_curFrame(%ecx) # self->curFrame<- newFP 21757 movl offThread_curHandlerTable(%ecx),rIBASE 21758 FETCH_INST 21759 GOTO_NEXT # jump to methodToCall->insns 21760 21761 /* 21762 * Prep for the native call 21763 * %eax=methodToCall, LOCAL1_OFFSET(%ebp)=newFP, %edx=newSaveArea 21764 */ 21765 21766.LinvokeNative: 21767 movl rSELF,%ecx # %ecx<- pthread 21768 movl %eax, OUT_ARG1(%esp) # push parameter methodToCall 21769 movl offThread_jniLocal_topCookie(%ecx), %eax # %eax<- self->localRef->... 21770 movl %eax, offStackSaveArea_localRefCookie(%edx) # newSaveArea->localRefCookie<- top 21771 movl %edx, OUT_ARG4(%esp) # save newSaveArea 21772 movl LOCAL1_OFFSET(%ebp), %edx # %edx<- newFP 21773 movl %edx, offThread_curFrame(%ecx) # self->curFrame<- newFP 21774 movl %ecx, OUT_ARG3(%esp) # save self 21775 movl %ecx, OUT_ARG2(%esp) # push parameter self 21776 movl rSELF,%ecx # %ecx<- pthread 21777 movl OUT_ARG1(%esp), %eax # %eax<- methodToCall 21778 lea offThread_retval(%ecx), %ecx # %ecx<- &retval 21779 movl %ecx, OUT_ARG0(%esp) # push parameter pthread 21780 push %edx # push parameter newFP 21781 21782 call *offMethod_nativeFunc(%eax) # call methodToCall->nativeFunc 21783 lea 4(%esp), %esp 21784 movl OUT_ARG4(%esp), %ecx # %ecx<- newSaveArea 21785 movl OUT_ARG3(%esp), %eax # %eax<- self 21786 movl offStackSaveArea_localRefCookie(%ecx), %edx # %edx<- old top 21787 cmp $0, offThread_exception(%eax) # check for exception 21788 movl rFP, offThread_curFrame(%eax) # self->curFrame<- rFP 21789 movl %edx, offThread_jniLocal_topCookie(%eax) # new top <- old top 21790 jne common_exceptionThrown # handle exception 21791 movl offThread_curHandlerTable(%eax),rIBASE 21792 FETCH_INST_OPCODE 3 %ecx 21793 ADVANCE_PC 3 21794 GOTO_NEXT_R %ecx # jump to next instruction 21795 21796.LstackOverflow: # eax=methodToCall 21797 movl %eax, OUT_ARG1(%esp) # push parameter methodToCall 21798 movl rSELF,%eax # %eax<- self 21799 movl %eax, OUT_ARG0(%esp) # push parameter self 21800 call dvmHandleStackOverflow # call: (Thread* self, Method* meth) 21801 jmp common_exceptionThrown # handle exception 21802 21803 21804/* 21805 * Do we need the thread to be suspended or have debugger/profiling activity? 21806 * 21807 * On entry: 21808 * ebx -> PC adjustment in 16-bit words (must be preserved) 21809 * ecx -> SELF pointer 21810 * reentry type, e.g. kInterpEntryInstr stored in rSELF->entryPoint 21811 * 21812 * Note: A call will normally kill %eax and %ecx. To 21813 * streamline the normal case, this routine will preserve 21814 * %ecx in addition to the normal caller save regs. The save/restore 21815 * is a bit ugly, but will happen in the relatively uncommon path. 21816 * TODO: Basic-block style Jit will need a hook here as well. Fold it into 21817 * the suspendCount check so we can get both in 1 shot. 21818 * TUNING: Improve scheduling here & do initial single test for all. 21819 */ 21820common_periodicChecks: 21821 cmpl $0,offThread_suspendCount(%ecx) # non-zero suspendCount? 21822 jne 1f 21823 218246: 21825 movl offThread_pInterpBreak(%ecx),%eax # eax <- &interpBreak 21826 cmpl $0,(%eax) # something interesting happening? 21827 jne 3f # yes - switch interpreters 21828 ret 21829 21830 /* Check for suspend */ 218311: 21832 /* At this point, the return pointer to the caller of 21833 * common_periodicChecks is on the top of stack. We need to preserve 21834 * SELF(ecx). 21835 * The outgoing profile is: 21836 * bool dvmCheckSuspendPending(Thread* self) 21837 * Because we reached here via a call, go ahead and build a new frame. 21838 */ 21839 EXPORT_PC # need for precise GC 21840 movl %ecx,%eax # eax<- self 21841 push %ebp 21842 movl %esp,%ebp 21843 subl $24,%esp 21844 movl %eax,OUT_ARG0(%esp) 21845 call dvmCheckSuspendPending 21846 addl $24,%esp 21847 pop %ebp 21848 movl rSELF,%ecx 21849 21850 /* 21851 * Need to check to see if debugger or profiler flags got set 21852 * while we were suspended. 21853 */ 21854 jmp 6b 21855 21856 /* Switch interpreters */ 21857 /* Note: %ebx contains the 16-bit word offset to be applied to rPC to 21858 * "complete" the interpretation of backwards branches. In effect, we 21859 * are completing the interpretation of the branch instruction here, 21860 * and the new interpreter will resume interpretation at the branch 21861 * target. However, a switch request recognized during the handling 21862 * of a return from method instruction results in an immediate abort, 21863 * and the new interpreter will resume by re-interpreting the return 21864 * instruction. 21865 */ 218663: 21867 leal (rPC,%ebx,2),rPC # adjust pc to show target 21868 movl rSELF,%ecx # bail expect SELF already loaded 21869 movl $1,rINST # set changeInterp to true 21870 jmp common_gotoBail 21871 21872 21873/* 21874 * Common code for handling a return instruction 21875 */ 21876common_returnFromMethod: 21877 movl rSELF,%ecx 21878 /* Set entry mode in case we bail */ 21879 movb $kInterpEntryReturn,offThread_entryPoint(%ecx) 21880 xorl rINST,rINST # zero offset in case we switch interps 21881 call common_periodicChecks # Note: expects %ecx to be preserved 21882 21883 SAVEAREA_FROM_FP %eax # eax<- saveArea (old) 21884 movl offStackSaveArea_prevFrame(%eax),rFP # rFP<- prevFrame 21885 movl (offStackSaveArea_method-sizeofStackSaveArea)(rFP),rINST 21886 cmpl $0,rINST # break? 21887 je common_gotoBail # break frame, bail out completely 21888 21889 movl offStackSaveArea_savedPc(%eax),rPC # pc<- saveArea->savedPC 21890 movl rINST,offThread_method(%ecx) # self->method = newSave->meethod 21891 movl rFP,offThread_curFrame(%ecx) # self->curFrame = fp 21892 movl offMethod_clazz(rINST),%eax # eax<- method->clazz 21893 movl offThread_curHandlerTable(%ecx),rIBASE 21894 movl offClassObject_pDvmDex(%eax),rINST # rINST<- method->clazz->pDvmDex 21895 FETCH_INST_OPCODE 3 %eax 21896 movl rINST,offThread_methodClassDex(%ecx) 21897 ADVANCE_PC 3 21898 /* not bailing - restore entry mode to default */ 21899 movb $kInterpEntryInstr,offThread_entryPoint(%ecx) 21900 GOTO_NEXT_R %eax 21901 21902/* 21903 * Prepare to strip the current frame and "longjump" back to caller of 21904 * dvmMterpStdRun. 21905 * 21906 * on entry: 21907 * rINST holds changeInterp 21908 * ecx holds self pointer 21909 * 21910 * expected profile: dvmMterpStdBail(Thread *self, bool changeInterp) 21911 */ 21912common_gotoBail: 21913 movl rPC,offThread_pc(%ecx) # export state to self 21914 movl rFP,offThread_fp(%ecx) 21915 movl %ecx,OUT_ARG0(%esp) # self in arg0 21916 movl rINST,OUT_ARG1(%esp) # changeInterp in arg1 21917 call dvmMterpStdBail # bail out.... 21918 21919 21920/* 21921 * After returning from a "selfd" function, pull out the updated values 21922 * and start executing at the next instruction. 21923 */ 21924 common_resumeAfterGlueCall: 21925 movl rSELF, %eax 21926 movl offThread_pc(%eax),rPC 21927 movl offThread_fp(%eax),rFP 21928 movl offThread_curHandlerTable(%eax),rIBASE 21929 FETCH_INST 21930 GOTO_NEXT 21931 21932/* 21933 * Integer divide or mod by zero 21934 */ 21935common_errDivideByZero: 21936 EXPORT_PC 21937 movl $.LstrDivideByZero,%eax 21938 movl %eax,OUT_ARG0(%esp) 21939 call dvmThrowArithmeticException 21940 jmp common_exceptionThrown 21941 21942/* 21943 * Attempt to allocate an array with a negative size. 21944 * On entry, len in eax 21945 */ 21946common_errNegativeArraySize: 21947 EXPORT_PC 21948 movl %eax,OUT_ARG0(%esp) # arg0<- len 21949 call dvmThrowNegativeArraySizeException # (len) 21950 jmp common_exceptionThrown 21951 21952/* 21953 * Attempt to allocate an array with a negative size. 21954 * On entry, method name in eax 21955 */ 21956common_errNoSuchMethod: 21957 21958 EXPORT_PC 21959 movl %eax,OUT_ARG0(%esp) 21960 call dvmThrowNoSuchMethodError 21961 jmp common_exceptionThrown 21962 21963/* 21964 * Hit a null object when we weren't expecting one. Export the PC, throw a 21965 * NullPointerException and goto the exception processing code. 21966 */ 21967common_errNullObject: 21968 EXPORT_PC 21969 xorl %eax,%eax 21970 movl %eax,OUT_ARG0(%esp) 21971 call dvmThrowNullPointerException 21972 jmp common_exceptionThrown 21973 21974/* 21975 * Array index exceeds max. 21976 * On entry: 21977 * eax <- array object 21978 * ecx <- index 21979 */ 21980common_errArrayIndex: 21981 EXPORT_PC 21982 movl offArrayObject_length(%eax), %eax 21983 movl %eax,OUT_ARG0(%esp) 21984 movl %ecx,OUT_ARG1(%esp) 21985 call dvmThrowArrayIndexOutOfBoundsException # args (length, index) 21986 jmp common_exceptionThrown 21987 21988/* 21989 * Somebody has thrown an exception. Handle it. 21990 * 21991 * If the exception processing code returns to us (instead of falling 21992 * out of the interpreter), continue with whatever the next instruction 21993 * now happens to be. 21994 * 21995 * This does not return. 21996 */ 21997common_exceptionThrown: 21998 movl rSELF,%ecx 21999 movl rPC,offThread_pc(%ecx) 22000 movl rFP,offThread_fp(%ecx) 22001 movl %ecx,OUT_ARG0(%esp) 22002 call dvmMterp_exceptionThrown 22003 jmp common_resumeAfterGlueCall 22004 22005common_abort: 22006 movl $0xdeadf00d,%eax 22007 call *%eax 22008 22009 22010/* 22011 * Strings 22012 */ 22013 22014 .section .rodata 22015.LstrDivideByZero: 22016 .asciz "divide by zero" 22017.LstrFilledNewArrayNotImplA: 22018 .asciz "filled-new-array only implemented for 'int'" 22019 22020