InterpAsm-x86.S revision 6a52d1d4061950c5358b67e180e25e8c55cbdda7
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 dvmThrowArrayStoreException # ...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_UNUSED_F2FF: /* 0x1f2 */ 11332/* File: x86/OP_UNUSED_F2FF.S */ 11333/* File: x86/unused.S */ 11334 jmp common_abort 11335 11336 11337/* ------------------------------ */ 11338.L_OP_UNUSED_F3FF: /* 0x1f3 */ 11339/* File: x86/OP_UNUSED_F3FF.S */ 11340/* File: x86/unused.S */ 11341 jmp common_abort 11342 11343 11344/* ------------------------------ */ 11345.L_OP_UNUSED_F4FF: /* 0x1f4 */ 11346/* File: x86/OP_UNUSED_F4FF.S */ 11347/* File: x86/unused.S */ 11348 jmp common_abort 11349 11350 11351/* ------------------------------ */ 11352.L_OP_UNUSED_F5FF: /* 0x1f5 */ 11353/* File: x86/OP_UNUSED_F5FF.S */ 11354/* File: x86/unused.S */ 11355 jmp common_abort 11356 11357 11358/* ------------------------------ */ 11359.L_OP_UNUSED_F6FF: /* 0x1f6 */ 11360/* File: x86/OP_UNUSED_F6FF.S */ 11361/* File: x86/unused.S */ 11362 jmp common_abort 11363 11364 11365/* ------------------------------ */ 11366.L_OP_UNUSED_F7FF: /* 0x1f7 */ 11367/* File: x86/OP_UNUSED_F7FF.S */ 11368/* File: x86/unused.S */ 11369 jmp common_abort 11370 11371 11372/* ------------------------------ */ 11373.L_OP_UNUSED_F8FF: /* 0x1f8 */ 11374/* File: x86/OP_UNUSED_F8FF.S */ 11375/* File: x86/unused.S */ 11376 jmp common_abort 11377 11378 11379/* ------------------------------ */ 11380.L_OP_UNUSED_F9FF: /* 0x1f9 */ 11381/* File: x86/OP_UNUSED_F9FF.S */ 11382/* File: x86/unused.S */ 11383 jmp common_abort 11384 11385 11386/* ------------------------------ */ 11387.L_OP_UNUSED_FAFF: /* 0x1fa */ 11388/* File: x86/OP_UNUSED_FAFF.S */ 11389/* File: x86/unused.S */ 11390 jmp common_abort 11391 11392 11393/* ------------------------------ */ 11394.L_OP_UNUSED_FBFF: /* 0x1fb */ 11395/* File: x86/OP_UNUSED_FBFF.S */ 11396/* File: x86/unused.S */ 11397 jmp common_abort 11398 11399 11400/* ------------------------------ */ 11401.L_OP_UNUSED_FCFF: /* 0x1fc */ 11402/* File: x86/OP_UNUSED_FCFF.S */ 11403/* File: x86/unused.S */ 11404 jmp common_abort 11405 11406 11407/* ------------------------------ */ 11408.L_OP_UNUSED_FDFF: /* 0x1fd */ 11409/* File: x86/OP_UNUSED_FDFF.S */ 11410/* File: x86/unused.S */ 11411 jmp common_abort 11412 11413 11414/* ------------------------------ */ 11415.L_OP_UNUSED_FEFF: /* 0x1fe */ 11416/* File: x86/OP_UNUSED_FEFF.S */ 11417/* File: x86/unused.S */ 11418 jmp common_abort 11419 11420 11421/* ------------------------------ */ 11422.L_OP_THROW_VERIFICATION_ERROR_JUMBO: /* 0x1ff */ 11423/* File: x86/OP_THROW_VERIFICATION_ERROR_JUMBO.S */ 11424 /* 11425 * Handle a jumbo throw-verification-error instruction. This throws an 11426 * exception for an error discovered during verification. The 11427 * exception is indicated by BBBB, with some detail provided by AAAAAAAA. 11428 */ 11429 /* exop BBBB, ref@AAAAAAAA */ 11430 movl rSELF,%ecx 11431 movl 2(rPC),%eax # eax<- AAAAAAAA 11432 movl offThread_method(%ecx),%ecx # ecx<- self->method 11433 EXPORT_PC 11434 movl %eax,OUT_ARG2(%esp) # arg2<- AAAAAAAA 11435 movl rINST,OUT_ARG1(%esp) # arg1<- BBBB 11436 movl %ecx,OUT_ARG0(%esp) # arg0<- method 11437 call dvmThrowVerificationError # call(method, kind, ref) 11438 jmp common_exceptionThrown # handle exception 11439 11440 .size dvmAsmInstructionStartCode, .-dvmAsmInstructionStartCode 11441 .global dvmAsmInstructionEndCode 11442dvmAsmInstructionEndCode: 11443 11444 .global dvmAsmAltInstructionStartCode 11445 .type dvmAsmAltInstructionStartCode, %function 11446dvmAsmAltInstructionStartCode: 11447 .text 11448 11449/* ------------------------------ */ 11450.L_ALT_OP_NOP: /* 0x00 */ 11451/* File: x86/alt_stub.S */ 11452/* 11453 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11454 * any interesting requests and then jump to the real instruction 11455 * handler. Unlike the Arm handler, we can't do this as a tail call 11456 * because rIBASE is caller save and we need to reload it. 11457 */ 11458 movl rSELF, %eax 11459 movl rPC, OUT_ARG0(%esp) 11460 movl %eax, OUT_ARG1(%esp) 11461 call dvmCheckInst # (dPC, self) 11462 movl rSELF, %ecx 11463 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11464 jmp *dvmAsmInstructionStart+(0*4) 11465 11466/* ------------------------------ */ 11467.L_ALT_OP_MOVE: /* 0x01 */ 11468/* File: x86/alt_stub.S */ 11469/* 11470 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11471 * any interesting requests and then jump to the real instruction 11472 * handler. Unlike the Arm handler, we can't do this as a tail call 11473 * because rIBASE is caller save and we need to reload it. 11474 */ 11475 movl rSELF, %eax 11476 movl rPC, OUT_ARG0(%esp) 11477 movl %eax, OUT_ARG1(%esp) 11478 call dvmCheckInst # (dPC, self) 11479 movl rSELF, %ecx 11480 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11481 jmp *dvmAsmInstructionStart+(1*4) 11482 11483/* ------------------------------ */ 11484.L_ALT_OP_MOVE_FROM16: /* 0x02 */ 11485/* File: x86/alt_stub.S */ 11486/* 11487 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11488 * any interesting requests and then jump to the real instruction 11489 * handler. Unlike the Arm handler, we can't do this as a tail call 11490 * because rIBASE is caller save and we need to reload it. 11491 */ 11492 movl rSELF, %eax 11493 movl rPC, OUT_ARG0(%esp) 11494 movl %eax, OUT_ARG1(%esp) 11495 call dvmCheckInst # (dPC, self) 11496 movl rSELF, %ecx 11497 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11498 jmp *dvmAsmInstructionStart+(2*4) 11499 11500/* ------------------------------ */ 11501.L_ALT_OP_MOVE_16: /* 0x03 */ 11502/* File: x86/alt_stub.S */ 11503/* 11504 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11505 * any interesting requests and then jump to the real instruction 11506 * handler. Unlike the Arm handler, we can't do this as a tail call 11507 * because rIBASE is caller save and we need to reload it. 11508 */ 11509 movl rSELF, %eax 11510 movl rPC, OUT_ARG0(%esp) 11511 movl %eax, OUT_ARG1(%esp) 11512 call dvmCheckInst # (dPC, self) 11513 movl rSELF, %ecx 11514 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11515 jmp *dvmAsmInstructionStart+(3*4) 11516 11517/* ------------------------------ */ 11518.L_ALT_OP_MOVE_WIDE: /* 0x04 */ 11519/* File: x86/alt_stub.S */ 11520/* 11521 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11522 * any interesting requests and then jump to the real instruction 11523 * handler. Unlike the Arm handler, we can't do this as a tail call 11524 * because rIBASE is caller save and we need to reload it. 11525 */ 11526 movl rSELF, %eax 11527 movl rPC, OUT_ARG0(%esp) 11528 movl %eax, OUT_ARG1(%esp) 11529 call dvmCheckInst # (dPC, self) 11530 movl rSELF, %ecx 11531 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11532 jmp *dvmAsmInstructionStart+(4*4) 11533 11534/* ------------------------------ */ 11535.L_ALT_OP_MOVE_WIDE_FROM16: /* 0x05 */ 11536/* File: x86/alt_stub.S */ 11537/* 11538 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11539 * any interesting requests and then jump to the real instruction 11540 * handler. Unlike the Arm handler, we can't do this as a tail call 11541 * because rIBASE is caller save and we need to reload it. 11542 */ 11543 movl rSELF, %eax 11544 movl rPC, OUT_ARG0(%esp) 11545 movl %eax, OUT_ARG1(%esp) 11546 call dvmCheckInst # (dPC, self) 11547 movl rSELF, %ecx 11548 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11549 jmp *dvmAsmInstructionStart+(5*4) 11550 11551/* ------------------------------ */ 11552.L_ALT_OP_MOVE_WIDE_16: /* 0x06 */ 11553/* File: x86/alt_stub.S */ 11554/* 11555 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11556 * any interesting requests and then jump to the real instruction 11557 * handler. Unlike the Arm handler, we can't do this as a tail call 11558 * because rIBASE is caller save and we need to reload it. 11559 */ 11560 movl rSELF, %eax 11561 movl rPC, OUT_ARG0(%esp) 11562 movl %eax, OUT_ARG1(%esp) 11563 call dvmCheckInst # (dPC, self) 11564 movl rSELF, %ecx 11565 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11566 jmp *dvmAsmInstructionStart+(6*4) 11567 11568/* ------------------------------ */ 11569.L_ALT_OP_MOVE_OBJECT: /* 0x07 */ 11570/* File: x86/alt_stub.S */ 11571/* 11572 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11573 * any interesting requests and then jump to the real instruction 11574 * handler. Unlike the Arm handler, we can't do this as a tail call 11575 * because rIBASE is caller save and we need to reload it. 11576 */ 11577 movl rSELF, %eax 11578 movl rPC, OUT_ARG0(%esp) 11579 movl %eax, OUT_ARG1(%esp) 11580 call dvmCheckInst # (dPC, self) 11581 movl rSELF, %ecx 11582 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11583 jmp *dvmAsmInstructionStart+(7*4) 11584 11585/* ------------------------------ */ 11586.L_ALT_OP_MOVE_OBJECT_FROM16: /* 0x08 */ 11587/* File: x86/alt_stub.S */ 11588/* 11589 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11590 * any interesting requests and then jump to the real instruction 11591 * handler. Unlike the Arm handler, we can't do this as a tail call 11592 * because rIBASE is caller save and we need to reload it. 11593 */ 11594 movl rSELF, %eax 11595 movl rPC, OUT_ARG0(%esp) 11596 movl %eax, OUT_ARG1(%esp) 11597 call dvmCheckInst # (dPC, self) 11598 movl rSELF, %ecx 11599 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11600 jmp *dvmAsmInstructionStart+(8*4) 11601 11602/* ------------------------------ */ 11603.L_ALT_OP_MOVE_OBJECT_16: /* 0x09 */ 11604/* File: x86/alt_stub.S */ 11605/* 11606 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11607 * any interesting requests and then jump to the real instruction 11608 * handler. Unlike the Arm handler, we can't do this as a tail call 11609 * because rIBASE is caller save and we need to reload it. 11610 */ 11611 movl rSELF, %eax 11612 movl rPC, OUT_ARG0(%esp) 11613 movl %eax, OUT_ARG1(%esp) 11614 call dvmCheckInst # (dPC, self) 11615 movl rSELF, %ecx 11616 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11617 jmp *dvmAsmInstructionStart+(9*4) 11618 11619/* ------------------------------ */ 11620.L_ALT_OP_MOVE_RESULT: /* 0x0a */ 11621/* File: x86/alt_stub.S */ 11622/* 11623 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11624 * any interesting requests and then jump to the real instruction 11625 * handler. Unlike the Arm handler, we can't do this as a tail call 11626 * because rIBASE is caller save and we need to reload it. 11627 */ 11628 movl rSELF, %eax 11629 movl rPC, OUT_ARG0(%esp) 11630 movl %eax, OUT_ARG1(%esp) 11631 call dvmCheckInst # (dPC, self) 11632 movl rSELF, %ecx 11633 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11634 jmp *dvmAsmInstructionStart+(10*4) 11635 11636/* ------------------------------ */ 11637.L_ALT_OP_MOVE_RESULT_WIDE: /* 0x0b */ 11638/* File: x86/alt_stub.S */ 11639/* 11640 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11641 * any interesting requests and then jump to the real instruction 11642 * handler. Unlike the Arm handler, we can't do this as a tail call 11643 * because rIBASE is caller save and we need to reload it. 11644 */ 11645 movl rSELF, %eax 11646 movl rPC, OUT_ARG0(%esp) 11647 movl %eax, OUT_ARG1(%esp) 11648 call dvmCheckInst # (dPC, self) 11649 movl rSELF, %ecx 11650 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11651 jmp *dvmAsmInstructionStart+(11*4) 11652 11653/* ------------------------------ */ 11654.L_ALT_OP_MOVE_RESULT_OBJECT: /* 0x0c */ 11655/* File: x86/alt_stub.S */ 11656/* 11657 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11658 * any interesting requests and then jump to the real instruction 11659 * handler. Unlike the Arm handler, we can't do this as a tail call 11660 * because rIBASE is caller save and we need to reload it. 11661 */ 11662 movl rSELF, %eax 11663 movl rPC, OUT_ARG0(%esp) 11664 movl %eax, OUT_ARG1(%esp) 11665 call dvmCheckInst # (dPC, self) 11666 movl rSELF, %ecx 11667 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11668 jmp *dvmAsmInstructionStart+(12*4) 11669 11670/* ------------------------------ */ 11671.L_ALT_OP_MOVE_EXCEPTION: /* 0x0d */ 11672/* File: x86/alt_stub.S */ 11673/* 11674 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11675 * any interesting requests and then jump to the real instruction 11676 * handler. Unlike the Arm handler, we can't do this as a tail call 11677 * because rIBASE is caller save and we need to reload it. 11678 */ 11679 movl rSELF, %eax 11680 movl rPC, OUT_ARG0(%esp) 11681 movl %eax, OUT_ARG1(%esp) 11682 call dvmCheckInst # (dPC, self) 11683 movl rSELF, %ecx 11684 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11685 jmp *dvmAsmInstructionStart+(13*4) 11686 11687/* ------------------------------ */ 11688.L_ALT_OP_RETURN_VOID: /* 0x0e */ 11689/* File: x86/alt_stub.S */ 11690/* 11691 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11692 * any interesting requests and then jump to the real instruction 11693 * handler. Unlike the Arm handler, we can't do this as a tail call 11694 * because rIBASE is caller save and we need to reload it. 11695 */ 11696 movl rSELF, %eax 11697 movl rPC, OUT_ARG0(%esp) 11698 movl %eax, OUT_ARG1(%esp) 11699 call dvmCheckInst # (dPC, self) 11700 movl rSELF, %ecx 11701 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11702 jmp *dvmAsmInstructionStart+(14*4) 11703 11704/* ------------------------------ */ 11705.L_ALT_OP_RETURN: /* 0x0f */ 11706/* File: x86/alt_stub.S */ 11707/* 11708 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11709 * any interesting requests and then jump to the real instruction 11710 * handler. Unlike the Arm handler, we can't do this as a tail call 11711 * because rIBASE is caller save and we need to reload it. 11712 */ 11713 movl rSELF, %eax 11714 movl rPC, OUT_ARG0(%esp) 11715 movl %eax, OUT_ARG1(%esp) 11716 call dvmCheckInst # (dPC, self) 11717 movl rSELF, %ecx 11718 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11719 jmp *dvmAsmInstructionStart+(15*4) 11720 11721/* ------------------------------ */ 11722.L_ALT_OP_RETURN_WIDE: /* 0x10 */ 11723/* File: x86/alt_stub.S */ 11724/* 11725 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11726 * any interesting requests and then jump to the real instruction 11727 * handler. Unlike the Arm handler, we can't do this as a tail call 11728 * because rIBASE is caller save and we need to reload it. 11729 */ 11730 movl rSELF, %eax 11731 movl rPC, OUT_ARG0(%esp) 11732 movl %eax, OUT_ARG1(%esp) 11733 call dvmCheckInst # (dPC, self) 11734 movl rSELF, %ecx 11735 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11736 jmp *dvmAsmInstructionStart+(16*4) 11737 11738/* ------------------------------ */ 11739.L_ALT_OP_RETURN_OBJECT: /* 0x11 */ 11740/* File: x86/alt_stub.S */ 11741/* 11742 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11743 * any interesting requests and then jump to the real instruction 11744 * handler. Unlike the Arm handler, we can't do this as a tail call 11745 * because rIBASE is caller save and we need to reload it. 11746 */ 11747 movl rSELF, %eax 11748 movl rPC, OUT_ARG0(%esp) 11749 movl %eax, OUT_ARG1(%esp) 11750 call dvmCheckInst # (dPC, self) 11751 movl rSELF, %ecx 11752 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11753 jmp *dvmAsmInstructionStart+(17*4) 11754 11755/* ------------------------------ */ 11756.L_ALT_OP_CONST_4: /* 0x12 */ 11757/* File: x86/alt_stub.S */ 11758/* 11759 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11760 * any interesting requests and then jump to the real instruction 11761 * handler. Unlike the Arm handler, we can't do this as a tail call 11762 * because rIBASE is caller save and we need to reload it. 11763 */ 11764 movl rSELF, %eax 11765 movl rPC, OUT_ARG0(%esp) 11766 movl %eax, OUT_ARG1(%esp) 11767 call dvmCheckInst # (dPC, self) 11768 movl rSELF, %ecx 11769 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11770 jmp *dvmAsmInstructionStart+(18*4) 11771 11772/* ------------------------------ */ 11773.L_ALT_OP_CONST_16: /* 0x13 */ 11774/* File: x86/alt_stub.S */ 11775/* 11776 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11777 * any interesting requests and then jump to the real instruction 11778 * handler. Unlike the Arm handler, we can't do this as a tail call 11779 * because rIBASE is caller save and we need to reload it. 11780 */ 11781 movl rSELF, %eax 11782 movl rPC, OUT_ARG0(%esp) 11783 movl %eax, OUT_ARG1(%esp) 11784 call dvmCheckInst # (dPC, self) 11785 movl rSELF, %ecx 11786 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11787 jmp *dvmAsmInstructionStart+(19*4) 11788 11789/* ------------------------------ */ 11790.L_ALT_OP_CONST: /* 0x14 */ 11791/* File: x86/alt_stub.S */ 11792/* 11793 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11794 * any interesting requests and then jump to the real instruction 11795 * handler. Unlike the Arm handler, we can't do this as a tail call 11796 * because rIBASE is caller save and we need to reload it. 11797 */ 11798 movl rSELF, %eax 11799 movl rPC, OUT_ARG0(%esp) 11800 movl %eax, OUT_ARG1(%esp) 11801 call dvmCheckInst # (dPC, self) 11802 movl rSELF, %ecx 11803 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11804 jmp *dvmAsmInstructionStart+(20*4) 11805 11806/* ------------------------------ */ 11807.L_ALT_OP_CONST_HIGH16: /* 0x15 */ 11808/* File: x86/alt_stub.S */ 11809/* 11810 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11811 * any interesting requests and then jump to the real instruction 11812 * handler. Unlike the Arm handler, we can't do this as a tail call 11813 * because rIBASE is caller save and we need to reload it. 11814 */ 11815 movl rSELF, %eax 11816 movl rPC, OUT_ARG0(%esp) 11817 movl %eax, OUT_ARG1(%esp) 11818 call dvmCheckInst # (dPC, self) 11819 movl rSELF, %ecx 11820 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11821 jmp *dvmAsmInstructionStart+(21*4) 11822 11823/* ------------------------------ */ 11824.L_ALT_OP_CONST_WIDE_16: /* 0x16 */ 11825/* File: x86/alt_stub.S */ 11826/* 11827 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11828 * any interesting requests and then jump to the real instruction 11829 * handler. Unlike the Arm handler, we can't do this as a tail call 11830 * because rIBASE is caller save and we need to reload it. 11831 */ 11832 movl rSELF, %eax 11833 movl rPC, OUT_ARG0(%esp) 11834 movl %eax, OUT_ARG1(%esp) 11835 call dvmCheckInst # (dPC, self) 11836 movl rSELF, %ecx 11837 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11838 jmp *dvmAsmInstructionStart+(22*4) 11839 11840/* ------------------------------ */ 11841.L_ALT_OP_CONST_WIDE_32: /* 0x17 */ 11842/* File: x86/alt_stub.S */ 11843/* 11844 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11845 * any interesting requests and then jump to the real instruction 11846 * handler. Unlike the Arm handler, we can't do this as a tail call 11847 * because rIBASE is caller save and we need to reload it. 11848 */ 11849 movl rSELF, %eax 11850 movl rPC, OUT_ARG0(%esp) 11851 movl %eax, OUT_ARG1(%esp) 11852 call dvmCheckInst # (dPC, self) 11853 movl rSELF, %ecx 11854 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11855 jmp *dvmAsmInstructionStart+(23*4) 11856 11857/* ------------------------------ */ 11858.L_ALT_OP_CONST_WIDE: /* 0x18 */ 11859/* File: x86/alt_stub.S */ 11860/* 11861 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11862 * any interesting requests and then jump to the real instruction 11863 * handler. Unlike the Arm handler, we can't do this as a tail call 11864 * because rIBASE is caller save and we need to reload it. 11865 */ 11866 movl rSELF, %eax 11867 movl rPC, OUT_ARG0(%esp) 11868 movl %eax, OUT_ARG1(%esp) 11869 call dvmCheckInst # (dPC, self) 11870 movl rSELF, %ecx 11871 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11872 jmp *dvmAsmInstructionStart+(24*4) 11873 11874/* ------------------------------ */ 11875.L_ALT_OP_CONST_WIDE_HIGH16: /* 0x19 */ 11876/* File: x86/alt_stub.S */ 11877/* 11878 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11879 * any interesting requests and then jump to the real instruction 11880 * handler. Unlike the Arm handler, we can't do this as a tail call 11881 * because rIBASE is caller save and we need to reload it. 11882 */ 11883 movl rSELF, %eax 11884 movl rPC, OUT_ARG0(%esp) 11885 movl %eax, OUT_ARG1(%esp) 11886 call dvmCheckInst # (dPC, self) 11887 movl rSELF, %ecx 11888 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11889 jmp *dvmAsmInstructionStart+(25*4) 11890 11891/* ------------------------------ */ 11892.L_ALT_OP_CONST_STRING: /* 0x1a */ 11893/* File: x86/alt_stub.S */ 11894/* 11895 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11896 * any interesting requests and then jump to the real instruction 11897 * handler. Unlike the Arm handler, we can't do this as a tail call 11898 * because rIBASE is caller save and we need to reload it. 11899 */ 11900 movl rSELF, %eax 11901 movl rPC, OUT_ARG0(%esp) 11902 movl %eax, OUT_ARG1(%esp) 11903 call dvmCheckInst # (dPC, self) 11904 movl rSELF, %ecx 11905 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11906 jmp *dvmAsmInstructionStart+(26*4) 11907 11908/* ------------------------------ */ 11909.L_ALT_OP_CONST_STRING_JUMBO: /* 0x1b */ 11910/* File: x86/alt_stub.S */ 11911/* 11912 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11913 * any interesting requests and then jump to the real instruction 11914 * handler. Unlike the Arm handler, we can't do this as a tail call 11915 * because rIBASE is caller save and we need to reload it. 11916 */ 11917 movl rSELF, %eax 11918 movl rPC, OUT_ARG0(%esp) 11919 movl %eax, OUT_ARG1(%esp) 11920 call dvmCheckInst # (dPC, self) 11921 movl rSELF, %ecx 11922 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11923 jmp *dvmAsmInstructionStart+(27*4) 11924 11925/* ------------------------------ */ 11926.L_ALT_OP_CONST_CLASS: /* 0x1c */ 11927/* File: x86/alt_stub.S */ 11928/* 11929 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11930 * any interesting requests and then jump to the real instruction 11931 * handler. Unlike the Arm handler, we can't do this as a tail call 11932 * because rIBASE is caller save and we need to reload it. 11933 */ 11934 movl rSELF, %eax 11935 movl rPC, OUT_ARG0(%esp) 11936 movl %eax, OUT_ARG1(%esp) 11937 call dvmCheckInst # (dPC, self) 11938 movl rSELF, %ecx 11939 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11940 jmp *dvmAsmInstructionStart+(28*4) 11941 11942/* ------------------------------ */ 11943.L_ALT_OP_MONITOR_ENTER: /* 0x1d */ 11944/* File: x86/alt_stub.S */ 11945/* 11946 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11947 * any interesting requests and then jump to the real instruction 11948 * handler. Unlike the Arm handler, we can't do this as a tail call 11949 * because rIBASE is caller save and we need to reload it. 11950 */ 11951 movl rSELF, %eax 11952 movl rPC, OUT_ARG0(%esp) 11953 movl %eax, OUT_ARG1(%esp) 11954 call dvmCheckInst # (dPC, self) 11955 movl rSELF, %ecx 11956 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11957 jmp *dvmAsmInstructionStart+(29*4) 11958 11959/* ------------------------------ */ 11960.L_ALT_OP_MONITOR_EXIT: /* 0x1e */ 11961/* File: x86/alt_stub.S */ 11962/* 11963 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11964 * any interesting requests and then jump to the real instruction 11965 * handler. Unlike the Arm handler, we can't do this as a tail call 11966 * because rIBASE is caller save and we need to reload it. 11967 */ 11968 movl rSELF, %eax 11969 movl rPC, OUT_ARG0(%esp) 11970 movl %eax, OUT_ARG1(%esp) 11971 call dvmCheckInst # (dPC, self) 11972 movl rSELF, %ecx 11973 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11974 jmp *dvmAsmInstructionStart+(30*4) 11975 11976/* ------------------------------ */ 11977.L_ALT_OP_CHECK_CAST: /* 0x1f */ 11978/* File: x86/alt_stub.S */ 11979/* 11980 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11981 * any interesting requests and then jump to the real instruction 11982 * handler. Unlike the Arm handler, we can't do this as a tail call 11983 * because rIBASE is caller save and we need to reload it. 11984 */ 11985 movl rSELF, %eax 11986 movl rPC, OUT_ARG0(%esp) 11987 movl %eax, OUT_ARG1(%esp) 11988 call dvmCheckInst # (dPC, self) 11989 movl rSELF, %ecx 11990 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11991 jmp *dvmAsmInstructionStart+(31*4) 11992 11993/* ------------------------------ */ 11994.L_ALT_OP_INSTANCE_OF: /* 0x20 */ 11995/* File: x86/alt_stub.S */ 11996/* 11997 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11998 * any interesting requests and then jump to the real instruction 11999 * handler. Unlike the Arm handler, we can't do this as a tail call 12000 * because rIBASE is caller save and we need to reload it. 12001 */ 12002 movl rSELF, %eax 12003 movl rPC, OUT_ARG0(%esp) 12004 movl %eax, OUT_ARG1(%esp) 12005 call dvmCheckInst # (dPC, self) 12006 movl rSELF, %ecx 12007 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12008 jmp *dvmAsmInstructionStart+(32*4) 12009 12010/* ------------------------------ */ 12011.L_ALT_OP_ARRAY_LENGTH: /* 0x21 */ 12012/* File: x86/alt_stub.S */ 12013/* 12014 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12015 * any interesting requests and then jump to the real instruction 12016 * handler. Unlike the Arm handler, we can't do this as a tail call 12017 * because rIBASE is caller save and we need to reload it. 12018 */ 12019 movl rSELF, %eax 12020 movl rPC, OUT_ARG0(%esp) 12021 movl %eax, OUT_ARG1(%esp) 12022 call dvmCheckInst # (dPC, self) 12023 movl rSELF, %ecx 12024 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12025 jmp *dvmAsmInstructionStart+(33*4) 12026 12027/* ------------------------------ */ 12028.L_ALT_OP_NEW_INSTANCE: /* 0x22 */ 12029/* File: x86/alt_stub.S */ 12030/* 12031 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12032 * any interesting requests and then jump to the real instruction 12033 * handler. Unlike the Arm handler, we can't do this as a tail call 12034 * because rIBASE is caller save and we need to reload it. 12035 */ 12036 movl rSELF, %eax 12037 movl rPC, OUT_ARG0(%esp) 12038 movl %eax, OUT_ARG1(%esp) 12039 call dvmCheckInst # (dPC, self) 12040 movl rSELF, %ecx 12041 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12042 jmp *dvmAsmInstructionStart+(34*4) 12043 12044/* ------------------------------ */ 12045.L_ALT_OP_NEW_ARRAY: /* 0x23 */ 12046/* File: x86/alt_stub.S */ 12047/* 12048 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12049 * any interesting requests and then jump to the real instruction 12050 * handler. Unlike the Arm handler, we can't do this as a tail call 12051 * because rIBASE is caller save and we need to reload it. 12052 */ 12053 movl rSELF, %eax 12054 movl rPC, OUT_ARG0(%esp) 12055 movl %eax, OUT_ARG1(%esp) 12056 call dvmCheckInst # (dPC, self) 12057 movl rSELF, %ecx 12058 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12059 jmp *dvmAsmInstructionStart+(35*4) 12060 12061/* ------------------------------ */ 12062.L_ALT_OP_FILLED_NEW_ARRAY: /* 0x24 */ 12063/* File: x86/alt_stub.S */ 12064/* 12065 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12066 * any interesting requests and then jump to the real instruction 12067 * handler. Unlike the Arm handler, we can't do this as a tail call 12068 * because rIBASE is caller save and we need to reload it. 12069 */ 12070 movl rSELF, %eax 12071 movl rPC, OUT_ARG0(%esp) 12072 movl %eax, OUT_ARG1(%esp) 12073 call dvmCheckInst # (dPC, self) 12074 movl rSELF, %ecx 12075 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12076 jmp *dvmAsmInstructionStart+(36*4) 12077 12078/* ------------------------------ */ 12079.L_ALT_OP_FILLED_NEW_ARRAY_RANGE: /* 0x25 */ 12080/* File: x86/alt_stub.S */ 12081/* 12082 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12083 * any interesting requests and then jump to the real instruction 12084 * handler. Unlike the Arm handler, we can't do this as a tail call 12085 * because rIBASE is caller save and we need to reload it. 12086 */ 12087 movl rSELF, %eax 12088 movl rPC, OUT_ARG0(%esp) 12089 movl %eax, OUT_ARG1(%esp) 12090 call dvmCheckInst # (dPC, self) 12091 movl rSELF, %ecx 12092 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12093 jmp *dvmAsmInstructionStart+(37*4) 12094 12095/* ------------------------------ */ 12096.L_ALT_OP_FILL_ARRAY_DATA: /* 0x26 */ 12097/* File: x86/alt_stub.S */ 12098/* 12099 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12100 * any interesting requests and then jump to the real instruction 12101 * handler. Unlike the Arm handler, we can't do this as a tail call 12102 * because rIBASE is caller save and we need to reload it. 12103 */ 12104 movl rSELF, %eax 12105 movl rPC, OUT_ARG0(%esp) 12106 movl %eax, OUT_ARG1(%esp) 12107 call dvmCheckInst # (dPC, self) 12108 movl rSELF, %ecx 12109 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12110 jmp *dvmAsmInstructionStart+(38*4) 12111 12112/* ------------------------------ */ 12113.L_ALT_OP_THROW: /* 0x27 */ 12114/* File: x86/alt_stub.S */ 12115/* 12116 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12117 * any interesting requests and then jump to the real instruction 12118 * handler. Unlike the Arm handler, we can't do this as a tail call 12119 * because rIBASE is caller save and we need to reload it. 12120 */ 12121 movl rSELF, %eax 12122 movl rPC, OUT_ARG0(%esp) 12123 movl %eax, OUT_ARG1(%esp) 12124 call dvmCheckInst # (dPC, self) 12125 movl rSELF, %ecx 12126 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12127 jmp *dvmAsmInstructionStart+(39*4) 12128 12129/* ------------------------------ */ 12130.L_ALT_OP_GOTO: /* 0x28 */ 12131/* File: x86/alt_stub.S */ 12132/* 12133 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12134 * any interesting requests and then jump to the real instruction 12135 * handler. Unlike the Arm handler, we can't do this as a tail call 12136 * because rIBASE is caller save and we need to reload it. 12137 */ 12138 movl rSELF, %eax 12139 movl rPC, OUT_ARG0(%esp) 12140 movl %eax, OUT_ARG1(%esp) 12141 call dvmCheckInst # (dPC, self) 12142 movl rSELF, %ecx 12143 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12144 jmp *dvmAsmInstructionStart+(40*4) 12145 12146/* ------------------------------ */ 12147.L_ALT_OP_GOTO_16: /* 0x29 */ 12148/* File: x86/alt_stub.S */ 12149/* 12150 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12151 * any interesting requests and then jump to the real instruction 12152 * handler. Unlike the Arm handler, we can't do this as a tail call 12153 * because rIBASE is caller save and we need to reload it. 12154 */ 12155 movl rSELF, %eax 12156 movl rPC, OUT_ARG0(%esp) 12157 movl %eax, OUT_ARG1(%esp) 12158 call dvmCheckInst # (dPC, self) 12159 movl rSELF, %ecx 12160 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12161 jmp *dvmAsmInstructionStart+(41*4) 12162 12163/* ------------------------------ */ 12164.L_ALT_OP_GOTO_32: /* 0x2a */ 12165/* File: x86/alt_stub.S */ 12166/* 12167 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12168 * any interesting requests and then jump to the real instruction 12169 * handler. Unlike the Arm handler, we can't do this as a tail call 12170 * because rIBASE is caller save and we need to reload it. 12171 */ 12172 movl rSELF, %eax 12173 movl rPC, OUT_ARG0(%esp) 12174 movl %eax, OUT_ARG1(%esp) 12175 call dvmCheckInst # (dPC, self) 12176 movl rSELF, %ecx 12177 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12178 jmp *dvmAsmInstructionStart+(42*4) 12179 12180/* ------------------------------ */ 12181.L_ALT_OP_PACKED_SWITCH: /* 0x2b */ 12182/* File: x86/alt_stub.S */ 12183/* 12184 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12185 * any interesting requests and then jump to the real instruction 12186 * handler. Unlike the Arm handler, we can't do this as a tail call 12187 * because rIBASE is caller save and we need to reload it. 12188 */ 12189 movl rSELF, %eax 12190 movl rPC, OUT_ARG0(%esp) 12191 movl %eax, OUT_ARG1(%esp) 12192 call dvmCheckInst # (dPC, self) 12193 movl rSELF, %ecx 12194 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12195 jmp *dvmAsmInstructionStart+(43*4) 12196 12197/* ------------------------------ */ 12198.L_ALT_OP_SPARSE_SWITCH: /* 0x2c */ 12199/* File: x86/alt_stub.S */ 12200/* 12201 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12202 * any interesting requests and then jump to the real instruction 12203 * handler. Unlike the Arm handler, we can't do this as a tail call 12204 * because rIBASE is caller save and we need to reload it. 12205 */ 12206 movl rSELF, %eax 12207 movl rPC, OUT_ARG0(%esp) 12208 movl %eax, OUT_ARG1(%esp) 12209 call dvmCheckInst # (dPC, self) 12210 movl rSELF, %ecx 12211 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12212 jmp *dvmAsmInstructionStart+(44*4) 12213 12214/* ------------------------------ */ 12215.L_ALT_OP_CMPL_FLOAT: /* 0x2d */ 12216/* File: x86/alt_stub.S */ 12217/* 12218 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12219 * any interesting requests and then jump to the real instruction 12220 * handler. Unlike the Arm handler, we can't do this as a tail call 12221 * because rIBASE is caller save and we need to reload it. 12222 */ 12223 movl rSELF, %eax 12224 movl rPC, OUT_ARG0(%esp) 12225 movl %eax, OUT_ARG1(%esp) 12226 call dvmCheckInst # (dPC, self) 12227 movl rSELF, %ecx 12228 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12229 jmp *dvmAsmInstructionStart+(45*4) 12230 12231/* ------------------------------ */ 12232.L_ALT_OP_CMPG_FLOAT: /* 0x2e */ 12233/* File: x86/alt_stub.S */ 12234/* 12235 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12236 * any interesting requests and then jump to the real instruction 12237 * handler. Unlike the Arm handler, we can't do this as a tail call 12238 * because rIBASE is caller save and we need to reload it. 12239 */ 12240 movl rSELF, %eax 12241 movl rPC, OUT_ARG0(%esp) 12242 movl %eax, OUT_ARG1(%esp) 12243 call dvmCheckInst # (dPC, self) 12244 movl rSELF, %ecx 12245 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12246 jmp *dvmAsmInstructionStart+(46*4) 12247 12248/* ------------------------------ */ 12249.L_ALT_OP_CMPL_DOUBLE: /* 0x2f */ 12250/* File: x86/alt_stub.S */ 12251/* 12252 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12253 * any interesting requests and then jump to the real instruction 12254 * handler. Unlike the Arm handler, we can't do this as a tail call 12255 * because rIBASE is caller save and we need to reload it. 12256 */ 12257 movl rSELF, %eax 12258 movl rPC, OUT_ARG0(%esp) 12259 movl %eax, OUT_ARG1(%esp) 12260 call dvmCheckInst # (dPC, self) 12261 movl rSELF, %ecx 12262 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12263 jmp *dvmAsmInstructionStart+(47*4) 12264 12265/* ------------------------------ */ 12266.L_ALT_OP_CMPG_DOUBLE: /* 0x30 */ 12267/* File: x86/alt_stub.S */ 12268/* 12269 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12270 * any interesting requests and then jump to the real instruction 12271 * handler. Unlike the Arm handler, we can't do this as a tail call 12272 * because rIBASE is caller save and we need to reload it. 12273 */ 12274 movl rSELF, %eax 12275 movl rPC, OUT_ARG0(%esp) 12276 movl %eax, OUT_ARG1(%esp) 12277 call dvmCheckInst # (dPC, self) 12278 movl rSELF, %ecx 12279 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12280 jmp *dvmAsmInstructionStart+(48*4) 12281 12282/* ------------------------------ */ 12283.L_ALT_OP_CMP_LONG: /* 0x31 */ 12284/* File: x86/alt_stub.S */ 12285/* 12286 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12287 * any interesting requests and then jump to the real instruction 12288 * handler. Unlike the Arm handler, we can't do this as a tail call 12289 * because rIBASE is caller save and we need to reload it. 12290 */ 12291 movl rSELF, %eax 12292 movl rPC, OUT_ARG0(%esp) 12293 movl %eax, OUT_ARG1(%esp) 12294 call dvmCheckInst # (dPC, self) 12295 movl rSELF, %ecx 12296 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12297 jmp *dvmAsmInstructionStart+(49*4) 12298 12299/* ------------------------------ */ 12300.L_ALT_OP_IF_EQ: /* 0x32 */ 12301/* File: x86/alt_stub.S */ 12302/* 12303 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12304 * any interesting requests and then jump to the real instruction 12305 * handler. Unlike the Arm handler, we can't do this as a tail call 12306 * because rIBASE is caller save and we need to reload it. 12307 */ 12308 movl rSELF, %eax 12309 movl rPC, OUT_ARG0(%esp) 12310 movl %eax, OUT_ARG1(%esp) 12311 call dvmCheckInst # (dPC, self) 12312 movl rSELF, %ecx 12313 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12314 jmp *dvmAsmInstructionStart+(50*4) 12315 12316/* ------------------------------ */ 12317.L_ALT_OP_IF_NE: /* 0x33 */ 12318/* File: x86/alt_stub.S */ 12319/* 12320 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12321 * any interesting requests and then jump to the real instruction 12322 * handler. Unlike the Arm handler, we can't do this as a tail call 12323 * because rIBASE is caller save and we need to reload it. 12324 */ 12325 movl rSELF, %eax 12326 movl rPC, OUT_ARG0(%esp) 12327 movl %eax, OUT_ARG1(%esp) 12328 call dvmCheckInst # (dPC, self) 12329 movl rSELF, %ecx 12330 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12331 jmp *dvmAsmInstructionStart+(51*4) 12332 12333/* ------------------------------ */ 12334.L_ALT_OP_IF_LT: /* 0x34 */ 12335/* File: x86/alt_stub.S */ 12336/* 12337 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12338 * any interesting requests and then jump to the real instruction 12339 * handler. Unlike the Arm handler, we can't do this as a tail call 12340 * because rIBASE is caller save and we need to reload it. 12341 */ 12342 movl rSELF, %eax 12343 movl rPC, OUT_ARG0(%esp) 12344 movl %eax, OUT_ARG1(%esp) 12345 call dvmCheckInst # (dPC, self) 12346 movl rSELF, %ecx 12347 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12348 jmp *dvmAsmInstructionStart+(52*4) 12349 12350/* ------------------------------ */ 12351.L_ALT_OP_IF_GE: /* 0x35 */ 12352/* File: x86/alt_stub.S */ 12353/* 12354 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12355 * any interesting requests and then jump to the real instruction 12356 * handler. Unlike the Arm handler, we can't do this as a tail call 12357 * because rIBASE is caller save and we need to reload it. 12358 */ 12359 movl rSELF, %eax 12360 movl rPC, OUT_ARG0(%esp) 12361 movl %eax, OUT_ARG1(%esp) 12362 call dvmCheckInst # (dPC, self) 12363 movl rSELF, %ecx 12364 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12365 jmp *dvmAsmInstructionStart+(53*4) 12366 12367/* ------------------------------ */ 12368.L_ALT_OP_IF_GT: /* 0x36 */ 12369/* File: x86/alt_stub.S */ 12370/* 12371 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12372 * any interesting requests and then jump to the real instruction 12373 * handler. Unlike the Arm handler, we can't do this as a tail call 12374 * because rIBASE is caller save and we need to reload it. 12375 */ 12376 movl rSELF, %eax 12377 movl rPC, OUT_ARG0(%esp) 12378 movl %eax, OUT_ARG1(%esp) 12379 call dvmCheckInst # (dPC, self) 12380 movl rSELF, %ecx 12381 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12382 jmp *dvmAsmInstructionStart+(54*4) 12383 12384/* ------------------------------ */ 12385.L_ALT_OP_IF_LE: /* 0x37 */ 12386/* File: x86/alt_stub.S */ 12387/* 12388 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12389 * any interesting requests and then jump to the real instruction 12390 * handler. Unlike the Arm handler, we can't do this as a tail call 12391 * because rIBASE is caller save and we need to reload it. 12392 */ 12393 movl rSELF, %eax 12394 movl rPC, OUT_ARG0(%esp) 12395 movl %eax, OUT_ARG1(%esp) 12396 call dvmCheckInst # (dPC, self) 12397 movl rSELF, %ecx 12398 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12399 jmp *dvmAsmInstructionStart+(55*4) 12400 12401/* ------------------------------ */ 12402.L_ALT_OP_IF_EQZ: /* 0x38 */ 12403/* File: x86/alt_stub.S */ 12404/* 12405 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12406 * any interesting requests and then jump to the real instruction 12407 * handler. Unlike the Arm handler, we can't do this as a tail call 12408 * because rIBASE is caller save and we need to reload it. 12409 */ 12410 movl rSELF, %eax 12411 movl rPC, OUT_ARG0(%esp) 12412 movl %eax, OUT_ARG1(%esp) 12413 call dvmCheckInst # (dPC, self) 12414 movl rSELF, %ecx 12415 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12416 jmp *dvmAsmInstructionStart+(56*4) 12417 12418/* ------------------------------ */ 12419.L_ALT_OP_IF_NEZ: /* 0x39 */ 12420/* File: x86/alt_stub.S */ 12421/* 12422 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12423 * any interesting requests and then jump to the real instruction 12424 * handler. Unlike the Arm handler, we can't do this as a tail call 12425 * because rIBASE is caller save and we need to reload it. 12426 */ 12427 movl rSELF, %eax 12428 movl rPC, OUT_ARG0(%esp) 12429 movl %eax, OUT_ARG1(%esp) 12430 call dvmCheckInst # (dPC, self) 12431 movl rSELF, %ecx 12432 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12433 jmp *dvmAsmInstructionStart+(57*4) 12434 12435/* ------------------------------ */ 12436.L_ALT_OP_IF_LTZ: /* 0x3a */ 12437/* File: x86/alt_stub.S */ 12438/* 12439 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12440 * any interesting requests and then jump to the real instruction 12441 * handler. Unlike the Arm handler, we can't do this as a tail call 12442 * because rIBASE is caller save and we need to reload it. 12443 */ 12444 movl rSELF, %eax 12445 movl rPC, OUT_ARG0(%esp) 12446 movl %eax, OUT_ARG1(%esp) 12447 call dvmCheckInst # (dPC, self) 12448 movl rSELF, %ecx 12449 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12450 jmp *dvmAsmInstructionStart+(58*4) 12451 12452/* ------------------------------ */ 12453.L_ALT_OP_IF_GEZ: /* 0x3b */ 12454/* File: x86/alt_stub.S */ 12455/* 12456 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12457 * any interesting requests and then jump to the real instruction 12458 * handler. Unlike the Arm handler, we can't do this as a tail call 12459 * because rIBASE is caller save and we need to reload it. 12460 */ 12461 movl rSELF, %eax 12462 movl rPC, OUT_ARG0(%esp) 12463 movl %eax, OUT_ARG1(%esp) 12464 call dvmCheckInst # (dPC, self) 12465 movl rSELF, %ecx 12466 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12467 jmp *dvmAsmInstructionStart+(59*4) 12468 12469/* ------------------------------ */ 12470.L_ALT_OP_IF_GTZ: /* 0x3c */ 12471/* File: x86/alt_stub.S */ 12472/* 12473 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12474 * any interesting requests and then jump to the real instruction 12475 * handler. Unlike the Arm handler, we can't do this as a tail call 12476 * because rIBASE is caller save and we need to reload it. 12477 */ 12478 movl rSELF, %eax 12479 movl rPC, OUT_ARG0(%esp) 12480 movl %eax, OUT_ARG1(%esp) 12481 call dvmCheckInst # (dPC, self) 12482 movl rSELF, %ecx 12483 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12484 jmp *dvmAsmInstructionStart+(60*4) 12485 12486/* ------------------------------ */ 12487.L_ALT_OP_IF_LEZ: /* 0x3d */ 12488/* File: x86/alt_stub.S */ 12489/* 12490 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12491 * any interesting requests and then jump to the real instruction 12492 * handler. Unlike the Arm handler, we can't do this as a tail call 12493 * because rIBASE is caller save and we need to reload it. 12494 */ 12495 movl rSELF, %eax 12496 movl rPC, OUT_ARG0(%esp) 12497 movl %eax, OUT_ARG1(%esp) 12498 call dvmCheckInst # (dPC, self) 12499 movl rSELF, %ecx 12500 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12501 jmp *dvmAsmInstructionStart+(61*4) 12502 12503/* ------------------------------ */ 12504.L_ALT_OP_UNUSED_3E: /* 0x3e */ 12505/* File: x86/alt_stub.S */ 12506/* 12507 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12508 * any interesting requests and then jump to the real instruction 12509 * handler. Unlike the Arm handler, we can't do this as a tail call 12510 * because rIBASE is caller save and we need to reload it. 12511 */ 12512 movl rSELF, %eax 12513 movl rPC, OUT_ARG0(%esp) 12514 movl %eax, OUT_ARG1(%esp) 12515 call dvmCheckInst # (dPC, self) 12516 movl rSELF, %ecx 12517 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12518 jmp *dvmAsmInstructionStart+(62*4) 12519 12520/* ------------------------------ */ 12521.L_ALT_OP_UNUSED_3F: /* 0x3f */ 12522/* File: x86/alt_stub.S */ 12523/* 12524 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12525 * any interesting requests and then jump to the real instruction 12526 * handler. Unlike the Arm handler, we can't do this as a tail call 12527 * because rIBASE is caller save and we need to reload it. 12528 */ 12529 movl rSELF, %eax 12530 movl rPC, OUT_ARG0(%esp) 12531 movl %eax, OUT_ARG1(%esp) 12532 call dvmCheckInst # (dPC, self) 12533 movl rSELF, %ecx 12534 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12535 jmp *dvmAsmInstructionStart+(63*4) 12536 12537/* ------------------------------ */ 12538.L_ALT_OP_UNUSED_40: /* 0x40 */ 12539/* File: x86/alt_stub.S */ 12540/* 12541 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12542 * any interesting requests and then jump to the real instruction 12543 * handler. Unlike the Arm handler, we can't do this as a tail call 12544 * because rIBASE is caller save and we need to reload it. 12545 */ 12546 movl rSELF, %eax 12547 movl rPC, OUT_ARG0(%esp) 12548 movl %eax, OUT_ARG1(%esp) 12549 call dvmCheckInst # (dPC, self) 12550 movl rSELF, %ecx 12551 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12552 jmp *dvmAsmInstructionStart+(64*4) 12553 12554/* ------------------------------ */ 12555.L_ALT_OP_UNUSED_41: /* 0x41 */ 12556/* File: x86/alt_stub.S */ 12557/* 12558 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12559 * any interesting requests and then jump to the real instruction 12560 * handler. Unlike the Arm handler, we can't do this as a tail call 12561 * because rIBASE is caller save and we need to reload it. 12562 */ 12563 movl rSELF, %eax 12564 movl rPC, OUT_ARG0(%esp) 12565 movl %eax, OUT_ARG1(%esp) 12566 call dvmCheckInst # (dPC, self) 12567 movl rSELF, %ecx 12568 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12569 jmp *dvmAsmInstructionStart+(65*4) 12570 12571/* ------------------------------ */ 12572.L_ALT_OP_UNUSED_42: /* 0x42 */ 12573/* File: x86/alt_stub.S */ 12574/* 12575 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12576 * any interesting requests and then jump to the real instruction 12577 * handler. Unlike the Arm handler, we can't do this as a tail call 12578 * because rIBASE is caller save and we need to reload it. 12579 */ 12580 movl rSELF, %eax 12581 movl rPC, OUT_ARG0(%esp) 12582 movl %eax, OUT_ARG1(%esp) 12583 call dvmCheckInst # (dPC, self) 12584 movl rSELF, %ecx 12585 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12586 jmp *dvmAsmInstructionStart+(66*4) 12587 12588/* ------------------------------ */ 12589.L_ALT_OP_UNUSED_43: /* 0x43 */ 12590/* File: x86/alt_stub.S */ 12591/* 12592 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12593 * any interesting requests and then jump to the real instruction 12594 * handler. Unlike the Arm handler, we can't do this as a tail call 12595 * because rIBASE is caller save and we need to reload it. 12596 */ 12597 movl rSELF, %eax 12598 movl rPC, OUT_ARG0(%esp) 12599 movl %eax, OUT_ARG1(%esp) 12600 call dvmCheckInst # (dPC, self) 12601 movl rSELF, %ecx 12602 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12603 jmp *dvmAsmInstructionStart+(67*4) 12604 12605/* ------------------------------ */ 12606.L_ALT_OP_AGET: /* 0x44 */ 12607/* File: x86/alt_stub.S */ 12608/* 12609 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12610 * any interesting requests and then jump to the real instruction 12611 * handler. Unlike the Arm handler, we can't do this as a tail call 12612 * because rIBASE is caller save and we need to reload it. 12613 */ 12614 movl rSELF, %eax 12615 movl rPC, OUT_ARG0(%esp) 12616 movl %eax, OUT_ARG1(%esp) 12617 call dvmCheckInst # (dPC, self) 12618 movl rSELF, %ecx 12619 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12620 jmp *dvmAsmInstructionStart+(68*4) 12621 12622/* ------------------------------ */ 12623.L_ALT_OP_AGET_WIDE: /* 0x45 */ 12624/* File: x86/alt_stub.S */ 12625/* 12626 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12627 * any interesting requests and then jump to the real instruction 12628 * handler. Unlike the Arm handler, we can't do this as a tail call 12629 * because rIBASE is caller save and we need to reload it. 12630 */ 12631 movl rSELF, %eax 12632 movl rPC, OUT_ARG0(%esp) 12633 movl %eax, OUT_ARG1(%esp) 12634 call dvmCheckInst # (dPC, self) 12635 movl rSELF, %ecx 12636 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12637 jmp *dvmAsmInstructionStart+(69*4) 12638 12639/* ------------------------------ */ 12640.L_ALT_OP_AGET_OBJECT: /* 0x46 */ 12641/* File: x86/alt_stub.S */ 12642/* 12643 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12644 * any interesting requests and then jump to the real instruction 12645 * handler. Unlike the Arm handler, we can't do this as a tail call 12646 * because rIBASE is caller save and we need to reload it. 12647 */ 12648 movl rSELF, %eax 12649 movl rPC, OUT_ARG0(%esp) 12650 movl %eax, OUT_ARG1(%esp) 12651 call dvmCheckInst # (dPC, self) 12652 movl rSELF, %ecx 12653 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12654 jmp *dvmAsmInstructionStart+(70*4) 12655 12656/* ------------------------------ */ 12657.L_ALT_OP_AGET_BOOLEAN: /* 0x47 */ 12658/* File: x86/alt_stub.S */ 12659/* 12660 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12661 * any interesting requests and then jump to the real instruction 12662 * handler. Unlike the Arm handler, we can't do this as a tail call 12663 * because rIBASE is caller save and we need to reload it. 12664 */ 12665 movl rSELF, %eax 12666 movl rPC, OUT_ARG0(%esp) 12667 movl %eax, OUT_ARG1(%esp) 12668 call dvmCheckInst # (dPC, self) 12669 movl rSELF, %ecx 12670 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12671 jmp *dvmAsmInstructionStart+(71*4) 12672 12673/* ------------------------------ */ 12674.L_ALT_OP_AGET_BYTE: /* 0x48 */ 12675/* File: x86/alt_stub.S */ 12676/* 12677 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12678 * any interesting requests and then jump to the real instruction 12679 * handler. Unlike the Arm handler, we can't do this as a tail call 12680 * because rIBASE is caller save and we need to reload it. 12681 */ 12682 movl rSELF, %eax 12683 movl rPC, OUT_ARG0(%esp) 12684 movl %eax, OUT_ARG1(%esp) 12685 call dvmCheckInst # (dPC, self) 12686 movl rSELF, %ecx 12687 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12688 jmp *dvmAsmInstructionStart+(72*4) 12689 12690/* ------------------------------ */ 12691.L_ALT_OP_AGET_CHAR: /* 0x49 */ 12692/* File: x86/alt_stub.S */ 12693/* 12694 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12695 * any interesting requests and then jump to the real instruction 12696 * handler. Unlike the Arm handler, we can't do this as a tail call 12697 * because rIBASE is caller save and we need to reload it. 12698 */ 12699 movl rSELF, %eax 12700 movl rPC, OUT_ARG0(%esp) 12701 movl %eax, OUT_ARG1(%esp) 12702 call dvmCheckInst # (dPC, self) 12703 movl rSELF, %ecx 12704 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12705 jmp *dvmAsmInstructionStart+(73*4) 12706 12707/* ------------------------------ */ 12708.L_ALT_OP_AGET_SHORT: /* 0x4a */ 12709/* File: x86/alt_stub.S */ 12710/* 12711 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12712 * any interesting requests and then jump to the real instruction 12713 * handler. Unlike the Arm handler, we can't do this as a tail call 12714 * because rIBASE is caller save and we need to reload it. 12715 */ 12716 movl rSELF, %eax 12717 movl rPC, OUT_ARG0(%esp) 12718 movl %eax, OUT_ARG1(%esp) 12719 call dvmCheckInst # (dPC, self) 12720 movl rSELF, %ecx 12721 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12722 jmp *dvmAsmInstructionStart+(74*4) 12723 12724/* ------------------------------ */ 12725.L_ALT_OP_APUT: /* 0x4b */ 12726/* File: x86/alt_stub.S */ 12727/* 12728 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12729 * any interesting requests and then jump to the real instruction 12730 * handler. Unlike the Arm handler, we can't do this as a tail call 12731 * because rIBASE is caller save and we need to reload it. 12732 */ 12733 movl rSELF, %eax 12734 movl rPC, OUT_ARG0(%esp) 12735 movl %eax, OUT_ARG1(%esp) 12736 call dvmCheckInst # (dPC, self) 12737 movl rSELF, %ecx 12738 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12739 jmp *dvmAsmInstructionStart+(75*4) 12740 12741/* ------------------------------ */ 12742.L_ALT_OP_APUT_WIDE: /* 0x4c */ 12743/* File: x86/alt_stub.S */ 12744/* 12745 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12746 * any interesting requests and then jump to the real instruction 12747 * handler. Unlike the Arm handler, we can't do this as a tail call 12748 * because rIBASE is caller save and we need to reload it. 12749 */ 12750 movl rSELF, %eax 12751 movl rPC, OUT_ARG0(%esp) 12752 movl %eax, OUT_ARG1(%esp) 12753 call dvmCheckInst # (dPC, self) 12754 movl rSELF, %ecx 12755 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12756 jmp *dvmAsmInstructionStart+(76*4) 12757 12758/* ------------------------------ */ 12759.L_ALT_OP_APUT_OBJECT: /* 0x4d */ 12760/* File: x86/alt_stub.S */ 12761/* 12762 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12763 * any interesting requests and then jump to the real instruction 12764 * handler. Unlike the Arm handler, we can't do this as a tail call 12765 * because rIBASE is caller save and we need to reload it. 12766 */ 12767 movl rSELF, %eax 12768 movl rPC, OUT_ARG0(%esp) 12769 movl %eax, OUT_ARG1(%esp) 12770 call dvmCheckInst # (dPC, self) 12771 movl rSELF, %ecx 12772 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12773 jmp *dvmAsmInstructionStart+(77*4) 12774 12775/* ------------------------------ */ 12776.L_ALT_OP_APUT_BOOLEAN: /* 0x4e */ 12777/* File: x86/alt_stub.S */ 12778/* 12779 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12780 * any interesting requests and then jump to the real instruction 12781 * handler. Unlike the Arm handler, we can't do this as a tail call 12782 * because rIBASE is caller save and we need to reload it. 12783 */ 12784 movl rSELF, %eax 12785 movl rPC, OUT_ARG0(%esp) 12786 movl %eax, OUT_ARG1(%esp) 12787 call dvmCheckInst # (dPC, self) 12788 movl rSELF, %ecx 12789 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12790 jmp *dvmAsmInstructionStart+(78*4) 12791 12792/* ------------------------------ */ 12793.L_ALT_OP_APUT_BYTE: /* 0x4f */ 12794/* File: x86/alt_stub.S */ 12795/* 12796 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12797 * any interesting requests and then jump to the real instruction 12798 * handler. Unlike the Arm handler, we can't do this as a tail call 12799 * because rIBASE is caller save and we need to reload it. 12800 */ 12801 movl rSELF, %eax 12802 movl rPC, OUT_ARG0(%esp) 12803 movl %eax, OUT_ARG1(%esp) 12804 call dvmCheckInst # (dPC, self) 12805 movl rSELF, %ecx 12806 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12807 jmp *dvmAsmInstructionStart+(79*4) 12808 12809/* ------------------------------ */ 12810.L_ALT_OP_APUT_CHAR: /* 0x50 */ 12811/* File: x86/alt_stub.S */ 12812/* 12813 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12814 * any interesting requests and then jump to the real instruction 12815 * handler. Unlike the Arm handler, we can't do this as a tail call 12816 * because rIBASE is caller save and we need to reload it. 12817 */ 12818 movl rSELF, %eax 12819 movl rPC, OUT_ARG0(%esp) 12820 movl %eax, OUT_ARG1(%esp) 12821 call dvmCheckInst # (dPC, self) 12822 movl rSELF, %ecx 12823 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12824 jmp *dvmAsmInstructionStart+(80*4) 12825 12826/* ------------------------------ */ 12827.L_ALT_OP_APUT_SHORT: /* 0x51 */ 12828/* File: x86/alt_stub.S */ 12829/* 12830 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12831 * any interesting requests and then jump to the real instruction 12832 * handler. Unlike the Arm handler, we can't do this as a tail call 12833 * because rIBASE is caller save and we need to reload it. 12834 */ 12835 movl rSELF, %eax 12836 movl rPC, OUT_ARG0(%esp) 12837 movl %eax, OUT_ARG1(%esp) 12838 call dvmCheckInst # (dPC, self) 12839 movl rSELF, %ecx 12840 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12841 jmp *dvmAsmInstructionStart+(81*4) 12842 12843/* ------------------------------ */ 12844.L_ALT_OP_IGET: /* 0x52 */ 12845/* File: x86/alt_stub.S */ 12846/* 12847 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12848 * any interesting requests and then jump to the real instruction 12849 * handler. Unlike the Arm handler, we can't do this as a tail call 12850 * because rIBASE is caller save and we need to reload it. 12851 */ 12852 movl rSELF, %eax 12853 movl rPC, OUT_ARG0(%esp) 12854 movl %eax, OUT_ARG1(%esp) 12855 call dvmCheckInst # (dPC, self) 12856 movl rSELF, %ecx 12857 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12858 jmp *dvmAsmInstructionStart+(82*4) 12859 12860/* ------------------------------ */ 12861.L_ALT_OP_IGET_WIDE: /* 0x53 */ 12862/* File: x86/alt_stub.S */ 12863/* 12864 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12865 * any interesting requests and then jump to the real instruction 12866 * handler. Unlike the Arm handler, we can't do this as a tail call 12867 * because rIBASE is caller save and we need to reload it. 12868 */ 12869 movl rSELF, %eax 12870 movl rPC, OUT_ARG0(%esp) 12871 movl %eax, OUT_ARG1(%esp) 12872 call dvmCheckInst # (dPC, self) 12873 movl rSELF, %ecx 12874 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12875 jmp *dvmAsmInstructionStart+(83*4) 12876 12877/* ------------------------------ */ 12878.L_ALT_OP_IGET_OBJECT: /* 0x54 */ 12879/* File: x86/alt_stub.S */ 12880/* 12881 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12882 * any interesting requests and then jump to the real instruction 12883 * handler. Unlike the Arm handler, we can't do this as a tail call 12884 * because rIBASE is caller save and we need to reload it. 12885 */ 12886 movl rSELF, %eax 12887 movl rPC, OUT_ARG0(%esp) 12888 movl %eax, OUT_ARG1(%esp) 12889 call dvmCheckInst # (dPC, self) 12890 movl rSELF, %ecx 12891 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12892 jmp *dvmAsmInstructionStart+(84*4) 12893 12894/* ------------------------------ */ 12895.L_ALT_OP_IGET_BOOLEAN: /* 0x55 */ 12896/* File: x86/alt_stub.S */ 12897/* 12898 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12899 * any interesting requests and then jump to the real instruction 12900 * handler. Unlike the Arm handler, we can't do this as a tail call 12901 * because rIBASE is caller save and we need to reload it. 12902 */ 12903 movl rSELF, %eax 12904 movl rPC, OUT_ARG0(%esp) 12905 movl %eax, OUT_ARG1(%esp) 12906 call dvmCheckInst # (dPC, self) 12907 movl rSELF, %ecx 12908 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12909 jmp *dvmAsmInstructionStart+(85*4) 12910 12911/* ------------------------------ */ 12912.L_ALT_OP_IGET_BYTE: /* 0x56 */ 12913/* File: x86/alt_stub.S */ 12914/* 12915 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12916 * any interesting requests and then jump to the real instruction 12917 * handler. Unlike the Arm handler, we can't do this as a tail call 12918 * because rIBASE is caller save and we need to reload it. 12919 */ 12920 movl rSELF, %eax 12921 movl rPC, OUT_ARG0(%esp) 12922 movl %eax, OUT_ARG1(%esp) 12923 call dvmCheckInst # (dPC, self) 12924 movl rSELF, %ecx 12925 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12926 jmp *dvmAsmInstructionStart+(86*4) 12927 12928/* ------------------------------ */ 12929.L_ALT_OP_IGET_CHAR: /* 0x57 */ 12930/* File: x86/alt_stub.S */ 12931/* 12932 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12933 * any interesting requests and then jump to the real instruction 12934 * handler. Unlike the Arm handler, we can't do this as a tail call 12935 * because rIBASE is caller save and we need to reload it. 12936 */ 12937 movl rSELF, %eax 12938 movl rPC, OUT_ARG0(%esp) 12939 movl %eax, OUT_ARG1(%esp) 12940 call dvmCheckInst # (dPC, self) 12941 movl rSELF, %ecx 12942 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12943 jmp *dvmAsmInstructionStart+(87*4) 12944 12945/* ------------------------------ */ 12946.L_ALT_OP_IGET_SHORT: /* 0x58 */ 12947/* File: x86/alt_stub.S */ 12948/* 12949 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12950 * any interesting requests and then jump to the real instruction 12951 * handler. Unlike the Arm handler, we can't do this as a tail call 12952 * because rIBASE is caller save and we need to reload it. 12953 */ 12954 movl rSELF, %eax 12955 movl rPC, OUT_ARG0(%esp) 12956 movl %eax, OUT_ARG1(%esp) 12957 call dvmCheckInst # (dPC, self) 12958 movl rSELF, %ecx 12959 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12960 jmp *dvmAsmInstructionStart+(88*4) 12961 12962/* ------------------------------ */ 12963.L_ALT_OP_IPUT: /* 0x59 */ 12964/* File: x86/alt_stub.S */ 12965/* 12966 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12967 * any interesting requests and then jump to the real instruction 12968 * handler. Unlike the Arm handler, we can't do this as a tail call 12969 * because rIBASE is caller save and we need to reload it. 12970 */ 12971 movl rSELF, %eax 12972 movl rPC, OUT_ARG0(%esp) 12973 movl %eax, OUT_ARG1(%esp) 12974 call dvmCheckInst # (dPC, self) 12975 movl rSELF, %ecx 12976 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12977 jmp *dvmAsmInstructionStart+(89*4) 12978 12979/* ------------------------------ */ 12980.L_ALT_OP_IPUT_WIDE: /* 0x5a */ 12981/* File: x86/alt_stub.S */ 12982/* 12983 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12984 * any interesting requests and then jump to the real instruction 12985 * handler. Unlike the Arm handler, we can't do this as a tail call 12986 * because rIBASE is caller save and we need to reload it. 12987 */ 12988 movl rSELF, %eax 12989 movl rPC, OUT_ARG0(%esp) 12990 movl %eax, OUT_ARG1(%esp) 12991 call dvmCheckInst # (dPC, self) 12992 movl rSELF, %ecx 12993 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12994 jmp *dvmAsmInstructionStart+(90*4) 12995 12996/* ------------------------------ */ 12997.L_ALT_OP_IPUT_OBJECT: /* 0x5b */ 12998/* File: x86/alt_stub.S */ 12999/* 13000 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13001 * any interesting requests and then jump to the real instruction 13002 * handler. Unlike the Arm handler, we can't do this as a tail call 13003 * because rIBASE is caller save and we need to reload it. 13004 */ 13005 movl rSELF, %eax 13006 movl rPC, OUT_ARG0(%esp) 13007 movl %eax, OUT_ARG1(%esp) 13008 call dvmCheckInst # (dPC, self) 13009 movl rSELF, %ecx 13010 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13011 jmp *dvmAsmInstructionStart+(91*4) 13012 13013/* ------------------------------ */ 13014.L_ALT_OP_IPUT_BOOLEAN: /* 0x5c */ 13015/* File: x86/alt_stub.S */ 13016/* 13017 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13018 * any interesting requests and then jump to the real instruction 13019 * handler. Unlike the Arm handler, we can't do this as a tail call 13020 * because rIBASE is caller save and we need to reload it. 13021 */ 13022 movl rSELF, %eax 13023 movl rPC, OUT_ARG0(%esp) 13024 movl %eax, OUT_ARG1(%esp) 13025 call dvmCheckInst # (dPC, self) 13026 movl rSELF, %ecx 13027 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13028 jmp *dvmAsmInstructionStart+(92*4) 13029 13030/* ------------------------------ */ 13031.L_ALT_OP_IPUT_BYTE: /* 0x5d */ 13032/* File: x86/alt_stub.S */ 13033/* 13034 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13035 * any interesting requests and then jump to the real instruction 13036 * handler. Unlike the Arm handler, we can't do this as a tail call 13037 * because rIBASE is caller save and we need to reload it. 13038 */ 13039 movl rSELF, %eax 13040 movl rPC, OUT_ARG0(%esp) 13041 movl %eax, OUT_ARG1(%esp) 13042 call dvmCheckInst # (dPC, self) 13043 movl rSELF, %ecx 13044 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13045 jmp *dvmAsmInstructionStart+(93*4) 13046 13047/* ------------------------------ */ 13048.L_ALT_OP_IPUT_CHAR: /* 0x5e */ 13049/* File: x86/alt_stub.S */ 13050/* 13051 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13052 * any interesting requests and then jump to the real instruction 13053 * handler. Unlike the Arm handler, we can't do this as a tail call 13054 * because rIBASE is caller save and we need to reload it. 13055 */ 13056 movl rSELF, %eax 13057 movl rPC, OUT_ARG0(%esp) 13058 movl %eax, OUT_ARG1(%esp) 13059 call dvmCheckInst # (dPC, self) 13060 movl rSELF, %ecx 13061 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13062 jmp *dvmAsmInstructionStart+(94*4) 13063 13064/* ------------------------------ */ 13065.L_ALT_OP_IPUT_SHORT: /* 0x5f */ 13066/* File: x86/alt_stub.S */ 13067/* 13068 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13069 * any interesting requests and then jump to the real instruction 13070 * handler. Unlike the Arm handler, we can't do this as a tail call 13071 * because rIBASE is caller save and we need to reload it. 13072 */ 13073 movl rSELF, %eax 13074 movl rPC, OUT_ARG0(%esp) 13075 movl %eax, OUT_ARG1(%esp) 13076 call dvmCheckInst # (dPC, self) 13077 movl rSELF, %ecx 13078 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13079 jmp *dvmAsmInstructionStart+(95*4) 13080 13081/* ------------------------------ */ 13082.L_ALT_OP_SGET: /* 0x60 */ 13083/* File: x86/alt_stub.S */ 13084/* 13085 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13086 * any interesting requests and then jump to the real instruction 13087 * handler. Unlike the Arm handler, we can't do this as a tail call 13088 * because rIBASE is caller save and we need to reload it. 13089 */ 13090 movl rSELF, %eax 13091 movl rPC, OUT_ARG0(%esp) 13092 movl %eax, OUT_ARG1(%esp) 13093 call dvmCheckInst # (dPC, self) 13094 movl rSELF, %ecx 13095 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13096 jmp *dvmAsmInstructionStart+(96*4) 13097 13098/* ------------------------------ */ 13099.L_ALT_OP_SGET_WIDE: /* 0x61 */ 13100/* File: x86/alt_stub.S */ 13101/* 13102 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13103 * any interesting requests and then jump to the real instruction 13104 * handler. Unlike the Arm handler, we can't do this as a tail call 13105 * because rIBASE is caller save and we need to reload it. 13106 */ 13107 movl rSELF, %eax 13108 movl rPC, OUT_ARG0(%esp) 13109 movl %eax, OUT_ARG1(%esp) 13110 call dvmCheckInst # (dPC, self) 13111 movl rSELF, %ecx 13112 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13113 jmp *dvmAsmInstructionStart+(97*4) 13114 13115/* ------------------------------ */ 13116.L_ALT_OP_SGET_OBJECT: /* 0x62 */ 13117/* File: x86/alt_stub.S */ 13118/* 13119 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13120 * any interesting requests and then jump to the real instruction 13121 * handler. Unlike the Arm handler, we can't do this as a tail call 13122 * because rIBASE is caller save and we need to reload it. 13123 */ 13124 movl rSELF, %eax 13125 movl rPC, OUT_ARG0(%esp) 13126 movl %eax, OUT_ARG1(%esp) 13127 call dvmCheckInst # (dPC, self) 13128 movl rSELF, %ecx 13129 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13130 jmp *dvmAsmInstructionStart+(98*4) 13131 13132/* ------------------------------ */ 13133.L_ALT_OP_SGET_BOOLEAN: /* 0x63 */ 13134/* File: x86/alt_stub.S */ 13135/* 13136 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13137 * any interesting requests and then jump to the real instruction 13138 * handler. Unlike the Arm handler, we can't do this as a tail call 13139 * because rIBASE is caller save and we need to reload it. 13140 */ 13141 movl rSELF, %eax 13142 movl rPC, OUT_ARG0(%esp) 13143 movl %eax, OUT_ARG1(%esp) 13144 call dvmCheckInst # (dPC, self) 13145 movl rSELF, %ecx 13146 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13147 jmp *dvmAsmInstructionStart+(99*4) 13148 13149/* ------------------------------ */ 13150.L_ALT_OP_SGET_BYTE: /* 0x64 */ 13151/* File: x86/alt_stub.S */ 13152/* 13153 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13154 * any interesting requests and then jump to the real instruction 13155 * handler. Unlike the Arm handler, we can't do this as a tail call 13156 * because rIBASE is caller save and we need to reload it. 13157 */ 13158 movl rSELF, %eax 13159 movl rPC, OUT_ARG0(%esp) 13160 movl %eax, OUT_ARG1(%esp) 13161 call dvmCheckInst # (dPC, self) 13162 movl rSELF, %ecx 13163 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13164 jmp *dvmAsmInstructionStart+(100*4) 13165 13166/* ------------------------------ */ 13167.L_ALT_OP_SGET_CHAR: /* 0x65 */ 13168/* File: x86/alt_stub.S */ 13169/* 13170 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13171 * any interesting requests and then jump to the real instruction 13172 * handler. Unlike the Arm handler, we can't do this as a tail call 13173 * because rIBASE is caller save and we need to reload it. 13174 */ 13175 movl rSELF, %eax 13176 movl rPC, OUT_ARG0(%esp) 13177 movl %eax, OUT_ARG1(%esp) 13178 call dvmCheckInst # (dPC, self) 13179 movl rSELF, %ecx 13180 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13181 jmp *dvmAsmInstructionStart+(101*4) 13182 13183/* ------------------------------ */ 13184.L_ALT_OP_SGET_SHORT: /* 0x66 */ 13185/* File: x86/alt_stub.S */ 13186/* 13187 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13188 * any interesting requests and then jump to the real instruction 13189 * handler. Unlike the Arm handler, we can't do this as a tail call 13190 * because rIBASE is caller save and we need to reload it. 13191 */ 13192 movl rSELF, %eax 13193 movl rPC, OUT_ARG0(%esp) 13194 movl %eax, OUT_ARG1(%esp) 13195 call dvmCheckInst # (dPC, self) 13196 movl rSELF, %ecx 13197 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13198 jmp *dvmAsmInstructionStart+(102*4) 13199 13200/* ------------------------------ */ 13201.L_ALT_OP_SPUT: /* 0x67 */ 13202/* File: x86/alt_stub.S */ 13203/* 13204 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13205 * any interesting requests and then jump to the real instruction 13206 * handler. Unlike the Arm handler, we can't do this as a tail call 13207 * because rIBASE is caller save and we need to reload it. 13208 */ 13209 movl rSELF, %eax 13210 movl rPC, OUT_ARG0(%esp) 13211 movl %eax, OUT_ARG1(%esp) 13212 call dvmCheckInst # (dPC, self) 13213 movl rSELF, %ecx 13214 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13215 jmp *dvmAsmInstructionStart+(103*4) 13216 13217/* ------------------------------ */ 13218.L_ALT_OP_SPUT_WIDE: /* 0x68 */ 13219/* File: x86/alt_stub.S */ 13220/* 13221 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13222 * any interesting requests and then jump to the real instruction 13223 * handler. Unlike the Arm handler, we can't do this as a tail call 13224 * because rIBASE is caller save and we need to reload it. 13225 */ 13226 movl rSELF, %eax 13227 movl rPC, OUT_ARG0(%esp) 13228 movl %eax, OUT_ARG1(%esp) 13229 call dvmCheckInst # (dPC, self) 13230 movl rSELF, %ecx 13231 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13232 jmp *dvmAsmInstructionStart+(104*4) 13233 13234/* ------------------------------ */ 13235.L_ALT_OP_SPUT_OBJECT: /* 0x69 */ 13236/* File: x86/alt_stub.S */ 13237/* 13238 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13239 * any interesting requests and then jump to the real instruction 13240 * handler. Unlike the Arm handler, we can't do this as a tail call 13241 * because rIBASE is caller save and we need to reload it. 13242 */ 13243 movl rSELF, %eax 13244 movl rPC, OUT_ARG0(%esp) 13245 movl %eax, OUT_ARG1(%esp) 13246 call dvmCheckInst # (dPC, self) 13247 movl rSELF, %ecx 13248 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13249 jmp *dvmAsmInstructionStart+(105*4) 13250 13251/* ------------------------------ */ 13252.L_ALT_OP_SPUT_BOOLEAN: /* 0x6a */ 13253/* File: x86/alt_stub.S */ 13254/* 13255 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13256 * any interesting requests and then jump to the real instruction 13257 * handler. Unlike the Arm handler, we can't do this as a tail call 13258 * because rIBASE is caller save and we need to reload it. 13259 */ 13260 movl rSELF, %eax 13261 movl rPC, OUT_ARG0(%esp) 13262 movl %eax, OUT_ARG1(%esp) 13263 call dvmCheckInst # (dPC, self) 13264 movl rSELF, %ecx 13265 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13266 jmp *dvmAsmInstructionStart+(106*4) 13267 13268/* ------------------------------ */ 13269.L_ALT_OP_SPUT_BYTE: /* 0x6b */ 13270/* File: x86/alt_stub.S */ 13271/* 13272 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13273 * any interesting requests and then jump to the real instruction 13274 * handler. Unlike the Arm handler, we can't do this as a tail call 13275 * because rIBASE is caller save and we need to reload it. 13276 */ 13277 movl rSELF, %eax 13278 movl rPC, OUT_ARG0(%esp) 13279 movl %eax, OUT_ARG1(%esp) 13280 call dvmCheckInst # (dPC, self) 13281 movl rSELF, %ecx 13282 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13283 jmp *dvmAsmInstructionStart+(107*4) 13284 13285/* ------------------------------ */ 13286.L_ALT_OP_SPUT_CHAR: /* 0x6c */ 13287/* File: x86/alt_stub.S */ 13288/* 13289 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13290 * any interesting requests and then jump to the real instruction 13291 * handler. Unlike the Arm handler, we can't do this as a tail call 13292 * because rIBASE is caller save and we need to reload it. 13293 */ 13294 movl rSELF, %eax 13295 movl rPC, OUT_ARG0(%esp) 13296 movl %eax, OUT_ARG1(%esp) 13297 call dvmCheckInst # (dPC, self) 13298 movl rSELF, %ecx 13299 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13300 jmp *dvmAsmInstructionStart+(108*4) 13301 13302/* ------------------------------ */ 13303.L_ALT_OP_SPUT_SHORT: /* 0x6d */ 13304/* File: x86/alt_stub.S */ 13305/* 13306 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13307 * any interesting requests and then jump to the real instruction 13308 * handler. Unlike the Arm handler, we can't do this as a tail call 13309 * because rIBASE is caller save and we need to reload it. 13310 */ 13311 movl rSELF, %eax 13312 movl rPC, OUT_ARG0(%esp) 13313 movl %eax, OUT_ARG1(%esp) 13314 call dvmCheckInst # (dPC, self) 13315 movl rSELF, %ecx 13316 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13317 jmp *dvmAsmInstructionStart+(109*4) 13318 13319/* ------------------------------ */ 13320.L_ALT_OP_INVOKE_VIRTUAL: /* 0x6e */ 13321/* File: x86/alt_stub.S */ 13322/* 13323 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13324 * any interesting requests and then jump to the real instruction 13325 * handler. Unlike the Arm handler, we can't do this as a tail call 13326 * because rIBASE is caller save and we need to reload it. 13327 */ 13328 movl rSELF, %eax 13329 movl rPC, OUT_ARG0(%esp) 13330 movl %eax, OUT_ARG1(%esp) 13331 call dvmCheckInst # (dPC, self) 13332 movl rSELF, %ecx 13333 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13334 jmp *dvmAsmInstructionStart+(110*4) 13335 13336/* ------------------------------ */ 13337.L_ALT_OP_INVOKE_SUPER: /* 0x6f */ 13338/* File: x86/alt_stub.S */ 13339/* 13340 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13341 * any interesting requests and then jump to the real instruction 13342 * handler. Unlike the Arm handler, we can't do this as a tail call 13343 * because rIBASE is caller save and we need to reload it. 13344 */ 13345 movl rSELF, %eax 13346 movl rPC, OUT_ARG0(%esp) 13347 movl %eax, OUT_ARG1(%esp) 13348 call dvmCheckInst # (dPC, self) 13349 movl rSELF, %ecx 13350 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13351 jmp *dvmAsmInstructionStart+(111*4) 13352 13353/* ------------------------------ */ 13354.L_ALT_OP_INVOKE_DIRECT: /* 0x70 */ 13355/* File: x86/alt_stub.S */ 13356/* 13357 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13358 * any interesting requests and then jump to the real instruction 13359 * handler. Unlike the Arm handler, we can't do this as a tail call 13360 * because rIBASE is caller save and we need to reload it. 13361 */ 13362 movl rSELF, %eax 13363 movl rPC, OUT_ARG0(%esp) 13364 movl %eax, OUT_ARG1(%esp) 13365 call dvmCheckInst # (dPC, self) 13366 movl rSELF, %ecx 13367 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13368 jmp *dvmAsmInstructionStart+(112*4) 13369 13370/* ------------------------------ */ 13371.L_ALT_OP_INVOKE_STATIC: /* 0x71 */ 13372/* File: x86/alt_stub.S */ 13373/* 13374 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13375 * any interesting requests and then jump to the real instruction 13376 * handler. Unlike the Arm handler, we can't do this as a tail call 13377 * because rIBASE is caller save and we need to reload it. 13378 */ 13379 movl rSELF, %eax 13380 movl rPC, OUT_ARG0(%esp) 13381 movl %eax, OUT_ARG1(%esp) 13382 call dvmCheckInst # (dPC, self) 13383 movl rSELF, %ecx 13384 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13385 jmp *dvmAsmInstructionStart+(113*4) 13386 13387/* ------------------------------ */ 13388.L_ALT_OP_INVOKE_INTERFACE: /* 0x72 */ 13389/* File: x86/alt_stub.S */ 13390/* 13391 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13392 * any interesting requests and then jump to the real instruction 13393 * handler. Unlike the Arm handler, we can't do this as a tail call 13394 * because rIBASE is caller save and we need to reload it. 13395 */ 13396 movl rSELF, %eax 13397 movl rPC, OUT_ARG0(%esp) 13398 movl %eax, OUT_ARG1(%esp) 13399 call dvmCheckInst # (dPC, self) 13400 movl rSELF, %ecx 13401 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13402 jmp *dvmAsmInstructionStart+(114*4) 13403 13404/* ------------------------------ */ 13405.L_ALT_OP_UNUSED_73: /* 0x73 */ 13406/* File: x86/alt_stub.S */ 13407/* 13408 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13409 * any interesting requests and then jump to the real instruction 13410 * handler. Unlike the Arm handler, we can't do this as a tail call 13411 * because rIBASE is caller save and we need to reload it. 13412 */ 13413 movl rSELF, %eax 13414 movl rPC, OUT_ARG0(%esp) 13415 movl %eax, OUT_ARG1(%esp) 13416 call dvmCheckInst # (dPC, self) 13417 movl rSELF, %ecx 13418 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13419 jmp *dvmAsmInstructionStart+(115*4) 13420 13421/* ------------------------------ */ 13422.L_ALT_OP_INVOKE_VIRTUAL_RANGE: /* 0x74 */ 13423/* File: x86/alt_stub.S */ 13424/* 13425 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13426 * any interesting requests and then jump to the real instruction 13427 * handler. Unlike the Arm handler, we can't do this as a tail call 13428 * because rIBASE is caller save and we need to reload it. 13429 */ 13430 movl rSELF, %eax 13431 movl rPC, OUT_ARG0(%esp) 13432 movl %eax, OUT_ARG1(%esp) 13433 call dvmCheckInst # (dPC, self) 13434 movl rSELF, %ecx 13435 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13436 jmp *dvmAsmInstructionStart+(116*4) 13437 13438/* ------------------------------ */ 13439.L_ALT_OP_INVOKE_SUPER_RANGE: /* 0x75 */ 13440/* File: x86/alt_stub.S */ 13441/* 13442 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13443 * any interesting requests and then jump to the real instruction 13444 * handler. Unlike the Arm handler, we can't do this as a tail call 13445 * because rIBASE is caller save and we need to reload it. 13446 */ 13447 movl rSELF, %eax 13448 movl rPC, OUT_ARG0(%esp) 13449 movl %eax, OUT_ARG1(%esp) 13450 call dvmCheckInst # (dPC, self) 13451 movl rSELF, %ecx 13452 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13453 jmp *dvmAsmInstructionStart+(117*4) 13454 13455/* ------------------------------ */ 13456.L_ALT_OP_INVOKE_DIRECT_RANGE: /* 0x76 */ 13457/* File: x86/alt_stub.S */ 13458/* 13459 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13460 * any interesting requests and then jump to the real instruction 13461 * handler. Unlike the Arm handler, we can't do this as a tail call 13462 * because rIBASE is caller save and we need to reload it. 13463 */ 13464 movl rSELF, %eax 13465 movl rPC, OUT_ARG0(%esp) 13466 movl %eax, OUT_ARG1(%esp) 13467 call dvmCheckInst # (dPC, self) 13468 movl rSELF, %ecx 13469 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13470 jmp *dvmAsmInstructionStart+(118*4) 13471 13472/* ------------------------------ */ 13473.L_ALT_OP_INVOKE_STATIC_RANGE: /* 0x77 */ 13474/* File: x86/alt_stub.S */ 13475/* 13476 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13477 * any interesting requests and then jump to the real instruction 13478 * handler. Unlike the Arm handler, we can't do this as a tail call 13479 * because rIBASE is caller save and we need to reload it. 13480 */ 13481 movl rSELF, %eax 13482 movl rPC, OUT_ARG0(%esp) 13483 movl %eax, OUT_ARG1(%esp) 13484 call dvmCheckInst # (dPC, self) 13485 movl rSELF, %ecx 13486 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13487 jmp *dvmAsmInstructionStart+(119*4) 13488 13489/* ------------------------------ */ 13490.L_ALT_OP_INVOKE_INTERFACE_RANGE: /* 0x78 */ 13491/* File: x86/alt_stub.S */ 13492/* 13493 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13494 * any interesting requests and then jump to the real instruction 13495 * handler. Unlike the Arm handler, we can't do this as a tail call 13496 * because rIBASE is caller save and we need to reload it. 13497 */ 13498 movl rSELF, %eax 13499 movl rPC, OUT_ARG0(%esp) 13500 movl %eax, OUT_ARG1(%esp) 13501 call dvmCheckInst # (dPC, self) 13502 movl rSELF, %ecx 13503 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13504 jmp *dvmAsmInstructionStart+(120*4) 13505 13506/* ------------------------------ */ 13507.L_ALT_OP_UNUSED_79: /* 0x79 */ 13508/* File: x86/alt_stub.S */ 13509/* 13510 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13511 * any interesting requests and then jump to the real instruction 13512 * handler. Unlike the Arm handler, we can't do this as a tail call 13513 * because rIBASE is caller save and we need to reload it. 13514 */ 13515 movl rSELF, %eax 13516 movl rPC, OUT_ARG0(%esp) 13517 movl %eax, OUT_ARG1(%esp) 13518 call dvmCheckInst # (dPC, self) 13519 movl rSELF, %ecx 13520 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13521 jmp *dvmAsmInstructionStart+(121*4) 13522 13523/* ------------------------------ */ 13524.L_ALT_OP_UNUSED_7A: /* 0x7a */ 13525/* File: x86/alt_stub.S */ 13526/* 13527 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13528 * any interesting requests and then jump to the real instruction 13529 * handler. Unlike the Arm handler, we can't do this as a tail call 13530 * because rIBASE is caller save and we need to reload it. 13531 */ 13532 movl rSELF, %eax 13533 movl rPC, OUT_ARG0(%esp) 13534 movl %eax, OUT_ARG1(%esp) 13535 call dvmCheckInst # (dPC, self) 13536 movl rSELF, %ecx 13537 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13538 jmp *dvmAsmInstructionStart+(122*4) 13539 13540/* ------------------------------ */ 13541.L_ALT_OP_NEG_INT: /* 0x7b */ 13542/* File: x86/alt_stub.S */ 13543/* 13544 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13545 * any interesting requests and then jump to the real instruction 13546 * handler. Unlike the Arm handler, we can't do this as a tail call 13547 * because rIBASE is caller save and we need to reload it. 13548 */ 13549 movl rSELF, %eax 13550 movl rPC, OUT_ARG0(%esp) 13551 movl %eax, OUT_ARG1(%esp) 13552 call dvmCheckInst # (dPC, self) 13553 movl rSELF, %ecx 13554 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13555 jmp *dvmAsmInstructionStart+(123*4) 13556 13557/* ------------------------------ */ 13558.L_ALT_OP_NOT_INT: /* 0x7c */ 13559/* File: x86/alt_stub.S */ 13560/* 13561 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13562 * any interesting requests and then jump to the real instruction 13563 * handler. Unlike the Arm handler, we can't do this as a tail call 13564 * because rIBASE is caller save and we need to reload it. 13565 */ 13566 movl rSELF, %eax 13567 movl rPC, OUT_ARG0(%esp) 13568 movl %eax, OUT_ARG1(%esp) 13569 call dvmCheckInst # (dPC, self) 13570 movl rSELF, %ecx 13571 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13572 jmp *dvmAsmInstructionStart+(124*4) 13573 13574/* ------------------------------ */ 13575.L_ALT_OP_NEG_LONG: /* 0x7d */ 13576/* File: x86/alt_stub.S */ 13577/* 13578 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13579 * any interesting requests and then jump to the real instruction 13580 * handler. Unlike the Arm handler, we can't do this as a tail call 13581 * because rIBASE is caller save and we need to reload it. 13582 */ 13583 movl rSELF, %eax 13584 movl rPC, OUT_ARG0(%esp) 13585 movl %eax, OUT_ARG1(%esp) 13586 call dvmCheckInst # (dPC, self) 13587 movl rSELF, %ecx 13588 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13589 jmp *dvmAsmInstructionStart+(125*4) 13590 13591/* ------------------------------ */ 13592.L_ALT_OP_NOT_LONG: /* 0x7e */ 13593/* File: x86/alt_stub.S */ 13594/* 13595 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13596 * any interesting requests and then jump to the real instruction 13597 * handler. Unlike the Arm handler, we can't do this as a tail call 13598 * because rIBASE is caller save and we need to reload it. 13599 */ 13600 movl rSELF, %eax 13601 movl rPC, OUT_ARG0(%esp) 13602 movl %eax, OUT_ARG1(%esp) 13603 call dvmCheckInst # (dPC, self) 13604 movl rSELF, %ecx 13605 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13606 jmp *dvmAsmInstructionStart+(126*4) 13607 13608/* ------------------------------ */ 13609.L_ALT_OP_NEG_FLOAT: /* 0x7f */ 13610/* File: x86/alt_stub.S */ 13611/* 13612 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13613 * any interesting requests and then jump to the real instruction 13614 * handler. Unlike the Arm handler, we can't do this as a tail call 13615 * because rIBASE is caller save and we need to reload it. 13616 */ 13617 movl rSELF, %eax 13618 movl rPC, OUT_ARG0(%esp) 13619 movl %eax, OUT_ARG1(%esp) 13620 call dvmCheckInst # (dPC, self) 13621 movl rSELF, %ecx 13622 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13623 jmp *dvmAsmInstructionStart+(127*4) 13624 13625/* ------------------------------ */ 13626.L_ALT_OP_NEG_DOUBLE: /* 0x80 */ 13627/* File: x86/alt_stub.S */ 13628/* 13629 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13630 * any interesting requests and then jump to the real instruction 13631 * handler. Unlike the Arm handler, we can't do this as a tail call 13632 * because rIBASE is caller save and we need to reload it. 13633 */ 13634 movl rSELF, %eax 13635 movl rPC, OUT_ARG0(%esp) 13636 movl %eax, OUT_ARG1(%esp) 13637 call dvmCheckInst # (dPC, self) 13638 movl rSELF, %ecx 13639 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13640 jmp *dvmAsmInstructionStart+(128*4) 13641 13642/* ------------------------------ */ 13643.L_ALT_OP_INT_TO_LONG: /* 0x81 */ 13644/* File: x86/alt_stub.S */ 13645/* 13646 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13647 * any interesting requests and then jump to the real instruction 13648 * handler. Unlike the Arm handler, we can't do this as a tail call 13649 * because rIBASE is caller save and we need to reload it. 13650 */ 13651 movl rSELF, %eax 13652 movl rPC, OUT_ARG0(%esp) 13653 movl %eax, OUT_ARG1(%esp) 13654 call dvmCheckInst # (dPC, self) 13655 movl rSELF, %ecx 13656 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13657 jmp *dvmAsmInstructionStart+(129*4) 13658 13659/* ------------------------------ */ 13660.L_ALT_OP_INT_TO_FLOAT: /* 0x82 */ 13661/* File: x86/alt_stub.S */ 13662/* 13663 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13664 * any interesting requests and then jump to the real instruction 13665 * handler. Unlike the Arm handler, we can't do this as a tail call 13666 * because rIBASE is caller save and we need to reload it. 13667 */ 13668 movl rSELF, %eax 13669 movl rPC, OUT_ARG0(%esp) 13670 movl %eax, OUT_ARG1(%esp) 13671 call dvmCheckInst # (dPC, self) 13672 movl rSELF, %ecx 13673 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13674 jmp *dvmAsmInstructionStart+(130*4) 13675 13676/* ------------------------------ */ 13677.L_ALT_OP_INT_TO_DOUBLE: /* 0x83 */ 13678/* File: x86/alt_stub.S */ 13679/* 13680 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13681 * any interesting requests and then jump to the real instruction 13682 * handler. Unlike the Arm handler, we can't do this as a tail call 13683 * because rIBASE is caller save and we need to reload it. 13684 */ 13685 movl rSELF, %eax 13686 movl rPC, OUT_ARG0(%esp) 13687 movl %eax, OUT_ARG1(%esp) 13688 call dvmCheckInst # (dPC, self) 13689 movl rSELF, %ecx 13690 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13691 jmp *dvmAsmInstructionStart+(131*4) 13692 13693/* ------------------------------ */ 13694.L_ALT_OP_LONG_TO_INT: /* 0x84 */ 13695/* File: x86/alt_stub.S */ 13696/* 13697 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13698 * any interesting requests and then jump to the real instruction 13699 * handler. Unlike the Arm handler, we can't do this as a tail call 13700 * because rIBASE is caller save and we need to reload it. 13701 */ 13702 movl rSELF, %eax 13703 movl rPC, OUT_ARG0(%esp) 13704 movl %eax, OUT_ARG1(%esp) 13705 call dvmCheckInst # (dPC, self) 13706 movl rSELF, %ecx 13707 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13708 jmp *dvmAsmInstructionStart+(132*4) 13709 13710/* ------------------------------ */ 13711.L_ALT_OP_LONG_TO_FLOAT: /* 0x85 */ 13712/* File: x86/alt_stub.S */ 13713/* 13714 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13715 * any interesting requests and then jump to the real instruction 13716 * handler. Unlike the Arm handler, we can't do this as a tail call 13717 * because rIBASE is caller save and we need to reload it. 13718 */ 13719 movl rSELF, %eax 13720 movl rPC, OUT_ARG0(%esp) 13721 movl %eax, OUT_ARG1(%esp) 13722 call dvmCheckInst # (dPC, self) 13723 movl rSELF, %ecx 13724 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13725 jmp *dvmAsmInstructionStart+(133*4) 13726 13727/* ------------------------------ */ 13728.L_ALT_OP_LONG_TO_DOUBLE: /* 0x86 */ 13729/* File: x86/alt_stub.S */ 13730/* 13731 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13732 * any interesting requests and then jump to the real instruction 13733 * handler. Unlike the Arm handler, we can't do this as a tail call 13734 * because rIBASE is caller save and we need to reload it. 13735 */ 13736 movl rSELF, %eax 13737 movl rPC, OUT_ARG0(%esp) 13738 movl %eax, OUT_ARG1(%esp) 13739 call dvmCheckInst # (dPC, self) 13740 movl rSELF, %ecx 13741 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13742 jmp *dvmAsmInstructionStart+(134*4) 13743 13744/* ------------------------------ */ 13745.L_ALT_OP_FLOAT_TO_INT: /* 0x87 */ 13746/* File: x86/alt_stub.S */ 13747/* 13748 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13749 * any interesting requests and then jump to the real instruction 13750 * handler. Unlike the Arm handler, we can't do this as a tail call 13751 * because rIBASE is caller save and we need to reload it. 13752 */ 13753 movl rSELF, %eax 13754 movl rPC, OUT_ARG0(%esp) 13755 movl %eax, OUT_ARG1(%esp) 13756 call dvmCheckInst # (dPC, self) 13757 movl rSELF, %ecx 13758 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13759 jmp *dvmAsmInstructionStart+(135*4) 13760 13761/* ------------------------------ */ 13762.L_ALT_OP_FLOAT_TO_LONG: /* 0x88 */ 13763/* File: x86/alt_stub.S */ 13764/* 13765 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13766 * any interesting requests and then jump to the real instruction 13767 * handler. Unlike the Arm handler, we can't do this as a tail call 13768 * because rIBASE is caller save and we need to reload it. 13769 */ 13770 movl rSELF, %eax 13771 movl rPC, OUT_ARG0(%esp) 13772 movl %eax, OUT_ARG1(%esp) 13773 call dvmCheckInst # (dPC, self) 13774 movl rSELF, %ecx 13775 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13776 jmp *dvmAsmInstructionStart+(136*4) 13777 13778/* ------------------------------ */ 13779.L_ALT_OP_FLOAT_TO_DOUBLE: /* 0x89 */ 13780/* File: x86/alt_stub.S */ 13781/* 13782 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13783 * any interesting requests and then jump to the real instruction 13784 * handler. Unlike the Arm handler, we can't do this as a tail call 13785 * because rIBASE is caller save and we need to reload it. 13786 */ 13787 movl rSELF, %eax 13788 movl rPC, OUT_ARG0(%esp) 13789 movl %eax, OUT_ARG1(%esp) 13790 call dvmCheckInst # (dPC, self) 13791 movl rSELF, %ecx 13792 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13793 jmp *dvmAsmInstructionStart+(137*4) 13794 13795/* ------------------------------ */ 13796.L_ALT_OP_DOUBLE_TO_INT: /* 0x8a */ 13797/* File: x86/alt_stub.S */ 13798/* 13799 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13800 * any interesting requests and then jump to the real instruction 13801 * handler. Unlike the Arm handler, we can't do this as a tail call 13802 * because rIBASE is caller save and we need to reload it. 13803 */ 13804 movl rSELF, %eax 13805 movl rPC, OUT_ARG0(%esp) 13806 movl %eax, OUT_ARG1(%esp) 13807 call dvmCheckInst # (dPC, self) 13808 movl rSELF, %ecx 13809 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13810 jmp *dvmAsmInstructionStart+(138*4) 13811 13812/* ------------------------------ */ 13813.L_ALT_OP_DOUBLE_TO_LONG: /* 0x8b */ 13814/* File: x86/alt_stub.S */ 13815/* 13816 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13817 * any interesting requests and then jump to the real instruction 13818 * handler. Unlike the Arm handler, we can't do this as a tail call 13819 * because rIBASE is caller save and we need to reload it. 13820 */ 13821 movl rSELF, %eax 13822 movl rPC, OUT_ARG0(%esp) 13823 movl %eax, OUT_ARG1(%esp) 13824 call dvmCheckInst # (dPC, self) 13825 movl rSELF, %ecx 13826 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13827 jmp *dvmAsmInstructionStart+(139*4) 13828 13829/* ------------------------------ */ 13830.L_ALT_OP_DOUBLE_TO_FLOAT: /* 0x8c */ 13831/* File: x86/alt_stub.S */ 13832/* 13833 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13834 * any interesting requests and then jump to the real instruction 13835 * handler. Unlike the Arm handler, we can't do this as a tail call 13836 * because rIBASE is caller save and we need to reload it. 13837 */ 13838 movl rSELF, %eax 13839 movl rPC, OUT_ARG0(%esp) 13840 movl %eax, OUT_ARG1(%esp) 13841 call dvmCheckInst # (dPC, self) 13842 movl rSELF, %ecx 13843 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13844 jmp *dvmAsmInstructionStart+(140*4) 13845 13846/* ------------------------------ */ 13847.L_ALT_OP_INT_TO_BYTE: /* 0x8d */ 13848/* File: x86/alt_stub.S */ 13849/* 13850 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13851 * any interesting requests and then jump to the real instruction 13852 * handler. Unlike the Arm handler, we can't do this as a tail call 13853 * because rIBASE is caller save and we need to reload it. 13854 */ 13855 movl rSELF, %eax 13856 movl rPC, OUT_ARG0(%esp) 13857 movl %eax, OUT_ARG1(%esp) 13858 call dvmCheckInst # (dPC, self) 13859 movl rSELF, %ecx 13860 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13861 jmp *dvmAsmInstructionStart+(141*4) 13862 13863/* ------------------------------ */ 13864.L_ALT_OP_INT_TO_CHAR: /* 0x8e */ 13865/* File: x86/alt_stub.S */ 13866/* 13867 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13868 * any interesting requests and then jump to the real instruction 13869 * handler. Unlike the Arm handler, we can't do this as a tail call 13870 * because rIBASE is caller save and we need to reload it. 13871 */ 13872 movl rSELF, %eax 13873 movl rPC, OUT_ARG0(%esp) 13874 movl %eax, OUT_ARG1(%esp) 13875 call dvmCheckInst # (dPC, self) 13876 movl rSELF, %ecx 13877 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13878 jmp *dvmAsmInstructionStart+(142*4) 13879 13880/* ------------------------------ */ 13881.L_ALT_OP_INT_TO_SHORT: /* 0x8f */ 13882/* File: x86/alt_stub.S */ 13883/* 13884 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13885 * any interesting requests and then jump to the real instruction 13886 * handler. Unlike the Arm handler, we can't do this as a tail call 13887 * because rIBASE is caller save and we need to reload it. 13888 */ 13889 movl rSELF, %eax 13890 movl rPC, OUT_ARG0(%esp) 13891 movl %eax, OUT_ARG1(%esp) 13892 call dvmCheckInst # (dPC, self) 13893 movl rSELF, %ecx 13894 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13895 jmp *dvmAsmInstructionStart+(143*4) 13896 13897/* ------------------------------ */ 13898.L_ALT_OP_ADD_INT: /* 0x90 */ 13899/* File: x86/alt_stub.S */ 13900/* 13901 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13902 * any interesting requests and then jump to the real instruction 13903 * handler. Unlike the Arm handler, we can't do this as a tail call 13904 * because rIBASE is caller save and we need to reload it. 13905 */ 13906 movl rSELF, %eax 13907 movl rPC, OUT_ARG0(%esp) 13908 movl %eax, OUT_ARG1(%esp) 13909 call dvmCheckInst # (dPC, self) 13910 movl rSELF, %ecx 13911 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13912 jmp *dvmAsmInstructionStart+(144*4) 13913 13914/* ------------------------------ */ 13915.L_ALT_OP_SUB_INT: /* 0x91 */ 13916/* File: x86/alt_stub.S */ 13917/* 13918 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13919 * any interesting requests and then jump to the real instruction 13920 * handler. Unlike the Arm handler, we can't do this as a tail call 13921 * because rIBASE is caller save and we need to reload it. 13922 */ 13923 movl rSELF, %eax 13924 movl rPC, OUT_ARG0(%esp) 13925 movl %eax, OUT_ARG1(%esp) 13926 call dvmCheckInst # (dPC, self) 13927 movl rSELF, %ecx 13928 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13929 jmp *dvmAsmInstructionStart+(145*4) 13930 13931/* ------------------------------ */ 13932.L_ALT_OP_MUL_INT: /* 0x92 */ 13933/* File: x86/alt_stub.S */ 13934/* 13935 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13936 * any interesting requests and then jump to the real instruction 13937 * handler. Unlike the Arm handler, we can't do this as a tail call 13938 * because rIBASE is caller save and we need to reload it. 13939 */ 13940 movl rSELF, %eax 13941 movl rPC, OUT_ARG0(%esp) 13942 movl %eax, OUT_ARG1(%esp) 13943 call dvmCheckInst # (dPC, self) 13944 movl rSELF, %ecx 13945 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13946 jmp *dvmAsmInstructionStart+(146*4) 13947 13948/* ------------------------------ */ 13949.L_ALT_OP_DIV_INT: /* 0x93 */ 13950/* File: x86/alt_stub.S */ 13951/* 13952 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13953 * any interesting requests and then jump to the real instruction 13954 * handler. Unlike the Arm handler, we can't do this as a tail call 13955 * because rIBASE is caller save and we need to reload it. 13956 */ 13957 movl rSELF, %eax 13958 movl rPC, OUT_ARG0(%esp) 13959 movl %eax, OUT_ARG1(%esp) 13960 call dvmCheckInst # (dPC, self) 13961 movl rSELF, %ecx 13962 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13963 jmp *dvmAsmInstructionStart+(147*4) 13964 13965/* ------------------------------ */ 13966.L_ALT_OP_REM_INT: /* 0x94 */ 13967/* File: x86/alt_stub.S */ 13968/* 13969 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13970 * any interesting requests and then jump to the real instruction 13971 * handler. Unlike the Arm handler, we can't do this as a tail call 13972 * because rIBASE is caller save and we need to reload it. 13973 */ 13974 movl rSELF, %eax 13975 movl rPC, OUT_ARG0(%esp) 13976 movl %eax, OUT_ARG1(%esp) 13977 call dvmCheckInst # (dPC, self) 13978 movl rSELF, %ecx 13979 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13980 jmp *dvmAsmInstructionStart+(148*4) 13981 13982/* ------------------------------ */ 13983.L_ALT_OP_AND_INT: /* 0x95 */ 13984/* File: x86/alt_stub.S */ 13985/* 13986 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13987 * any interesting requests and then jump to the real instruction 13988 * handler. Unlike the Arm handler, we can't do this as a tail call 13989 * because rIBASE is caller save and we need to reload it. 13990 */ 13991 movl rSELF, %eax 13992 movl rPC, OUT_ARG0(%esp) 13993 movl %eax, OUT_ARG1(%esp) 13994 call dvmCheckInst # (dPC, self) 13995 movl rSELF, %ecx 13996 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13997 jmp *dvmAsmInstructionStart+(149*4) 13998 13999/* ------------------------------ */ 14000.L_ALT_OP_OR_INT: /* 0x96 */ 14001/* File: x86/alt_stub.S */ 14002/* 14003 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14004 * any interesting requests and then jump to the real instruction 14005 * handler. Unlike the Arm handler, we can't do this as a tail call 14006 * because rIBASE is caller save and we need to reload it. 14007 */ 14008 movl rSELF, %eax 14009 movl rPC, OUT_ARG0(%esp) 14010 movl %eax, OUT_ARG1(%esp) 14011 call dvmCheckInst # (dPC, self) 14012 movl rSELF, %ecx 14013 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14014 jmp *dvmAsmInstructionStart+(150*4) 14015 14016/* ------------------------------ */ 14017.L_ALT_OP_XOR_INT: /* 0x97 */ 14018/* File: x86/alt_stub.S */ 14019/* 14020 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14021 * any interesting requests and then jump to the real instruction 14022 * handler. Unlike the Arm handler, we can't do this as a tail call 14023 * because rIBASE is caller save and we need to reload it. 14024 */ 14025 movl rSELF, %eax 14026 movl rPC, OUT_ARG0(%esp) 14027 movl %eax, OUT_ARG1(%esp) 14028 call dvmCheckInst # (dPC, self) 14029 movl rSELF, %ecx 14030 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14031 jmp *dvmAsmInstructionStart+(151*4) 14032 14033/* ------------------------------ */ 14034.L_ALT_OP_SHL_INT: /* 0x98 */ 14035/* File: x86/alt_stub.S */ 14036/* 14037 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14038 * any interesting requests and then jump to the real instruction 14039 * handler. Unlike the Arm handler, we can't do this as a tail call 14040 * because rIBASE is caller save and we need to reload it. 14041 */ 14042 movl rSELF, %eax 14043 movl rPC, OUT_ARG0(%esp) 14044 movl %eax, OUT_ARG1(%esp) 14045 call dvmCheckInst # (dPC, self) 14046 movl rSELF, %ecx 14047 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14048 jmp *dvmAsmInstructionStart+(152*4) 14049 14050/* ------------------------------ */ 14051.L_ALT_OP_SHR_INT: /* 0x99 */ 14052/* File: x86/alt_stub.S */ 14053/* 14054 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14055 * any interesting requests and then jump to the real instruction 14056 * handler. Unlike the Arm handler, we can't do this as a tail call 14057 * because rIBASE is caller save and we need to reload it. 14058 */ 14059 movl rSELF, %eax 14060 movl rPC, OUT_ARG0(%esp) 14061 movl %eax, OUT_ARG1(%esp) 14062 call dvmCheckInst # (dPC, self) 14063 movl rSELF, %ecx 14064 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14065 jmp *dvmAsmInstructionStart+(153*4) 14066 14067/* ------------------------------ */ 14068.L_ALT_OP_USHR_INT: /* 0x9a */ 14069/* File: x86/alt_stub.S */ 14070/* 14071 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14072 * any interesting requests and then jump to the real instruction 14073 * handler. Unlike the Arm handler, we can't do this as a tail call 14074 * because rIBASE is caller save and we need to reload it. 14075 */ 14076 movl rSELF, %eax 14077 movl rPC, OUT_ARG0(%esp) 14078 movl %eax, OUT_ARG1(%esp) 14079 call dvmCheckInst # (dPC, self) 14080 movl rSELF, %ecx 14081 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14082 jmp *dvmAsmInstructionStart+(154*4) 14083 14084/* ------------------------------ */ 14085.L_ALT_OP_ADD_LONG: /* 0x9b */ 14086/* File: x86/alt_stub.S */ 14087/* 14088 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14089 * any interesting requests and then jump to the real instruction 14090 * handler. Unlike the Arm handler, we can't do this as a tail call 14091 * because rIBASE is caller save and we need to reload it. 14092 */ 14093 movl rSELF, %eax 14094 movl rPC, OUT_ARG0(%esp) 14095 movl %eax, OUT_ARG1(%esp) 14096 call dvmCheckInst # (dPC, self) 14097 movl rSELF, %ecx 14098 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14099 jmp *dvmAsmInstructionStart+(155*4) 14100 14101/* ------------------------------ */ 14102.L_ALT_OP_SUB_LONG: /* 0x9c */ 14103/* File: x86/alt_stub.S */ 14104/* 14105 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14106 * any interesting requests and then jump to the real instruction 14107 * handler. Unlike the Arm handler, we can't do this as a tail call 14108 * because rIBASE is caller save and we need to reload it. 14109 */ 14110 movl rSELF, %eax 14111 movl rPC, OUT_ARG0(%esp) 14112 movl %eax, OUT_ARG1(%esp) 14113 call dvmCheckInst # (dPC, self) 14114 movl rSELF, %ecx 14115 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14116 jmp *dvmAsmInstructionStart+(156*4) 14117 14118/* ------------------------------ */ 14119.L_ALT_OP_MUL_LONG: /* 0x9d */ 14120/* File: x86/alt_stub.S */ 14121/* 14122 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14123 * any interesting requests and then jump to the real instruction 14124 * handler. Unlike the Arm handler, we can't do this as a tail call 14125 * because rIBASE is caller save and we need to reload it. 14126 */ 14127 movl rSELF, %eax 14128 movl rPC, OUT_ARG0(%esp) 14129 movl %eax, OUT_ARG1(%esp) 14130 call dvmCheckInst # (dPC, self) 14131 movl rSELF, %ecx 14132 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14133 jmp *dvmAsmInstructionStart+(157*4) 14134 14135/* ------------------------------ */ 14136.L_ALT_OP_DIV_LONG: /* 0x9e */ 14137/* File: x86/alt_stub.S */ 14138/* 14139 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14140 * any interesting requests and then jump to the real instruction 14141 * handler. Unlike the Arm handler, we can't do this as a tail call 14142 * because rIBASE is caller save and we need to reload it. 14143 */ 14144 movl rSELF, %eax 14145 movl rPC, OUT_ARG0(%esp) 14146 movl %eax, OUT_ARG1(%esp) 14147 call dvmCheckInst # (dPC, self) 14148 movl rSELF, %ecx 14149 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14150 jmp *dvmAsmInstructionStart+(158*4) 14151 14152/* ------------------------------ */ 14153.L_ALT_OP_REM_LONG: /* 0x9f */ 14154/* File: x86/alt_stub.S */ 14155/* 14156 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14157 * any interesting requests and then jump to the real instruction 14158 * handler. Unlike the Arm handler, we can't do this as a tail call 14159 * because rIBASE is caller save and we need to reload it. 14160 */ 14161 movl rSELF, %eax 14162 movl rPC, OUT_ARG0(%esp) 14163 movl %eax, OUT_ARG1(%esp) 14164 call dvmCheckInst # (dPC, self) 14165 movl rSELF, %ecx 14166 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14167 jmp *dvmAsmInstructionStart+(159*4) 14168 14169/* ------------------------------ */ 14170.L_ALT_OP_AND_LONG: /* 0xa0 */ 14171/* File: x86/alt_stub.S */ 14172/* 14173 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14174 * any interesting requests and then jump to the real instruction 14175 * handler. Unlike the Arm handler, we can't do this as a tail call 14176 * because rIBASE is caller save and we need to reload it. 14177 */ 14178 movl rSELF, %eax 14179 movl rPC, OUT_ARG0(%esp) 14180 movl %eax, OUT_ARG1(%esp) 14181 call dvmCheckInst # (dPC, self) 14182 movl rSELF, %ecx 14183 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14184 jmp *dvmAsmInstructionStart+(160*4) 14185 14186/* ------------------------------ */ 14187.L_ALT_OP_OR_LONG: /* 0xa1 */ 14188/* File: x86/alt_stub.S */ 14189/* 14190 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14191 * any interesting requests and then jump to the real instruction 14192 * handler. Unlike the Arm handler, we can't do this as a tail call 14193 * because rIBASE is caller save and we need to reload it. 14194 */ 14195 movl rSELF, %eax 14196 movl rPC, OUT_ARG0(%esp) 14197 movl %eax, OUT_ARG1(%esp) 14198 call dvmCheckInst # (dPC, self) 14199 movl rSELF, %ecx 14200 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14201 jmp *dvmAsmInstructionStart+(161*4) 14202 14203/* ------------------------------ */ 14204.L_ALT_OP_XOR_LONG: /* 0xa2 */ 14205/* File: x86/alt_stub.S */ 14206/* 14207 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14208 * any interesting requests and then jump to the real instruction 14209 * handler. Unlike the Arm handler, we can't do this as a tail call 14210 * because rIBASE is caller save and we need to reload it. 14211 */ 14212 movl rSELF, %eax 14213 movl rPC, OUT_ARG0(%esp) 14214 movl %eax, OUT_ARG1(%esp) 14215 call dvmCheckInst # (dPC, self) 14216 movl rSELF, %ecx 14217 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14218 jmp *dvmAsmInstructionStart+(162*4) 14219 14220/* ------------------------------ */ 14221.L_ALT_OP_SHL_LONG: /* 0xa3 */ 14222/* File: x86/alt_stub.S */ 14223/* 14224 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14225 * any interesting requests and then jump to the real instruction 14226 * handler. Unlike the Arm handler, we can't do this as a tail call 14227 * because rIBASE is caller save and we need to reload it. 14228 */ 14229 movl rSELF, %eax 14230 movl rPC, OUT_ARG0(%esp) 14231 movl %eax, OUT_ARG1(%esp) 14232 call dvmCheckInst # (dPC, self) 14233 movl rSELF, %ecx 14234 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14235 jmp *dvmAsmInstructionStart+(163*4) 14236 14237/* ------------------------------ */ 14238.L_ALT_OP_SHR_LONG: /* 0xa4 */ 14239/* File: x86/alt_stub.S */ 14240/* 14241 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14242 * any interesting requests and then jump to the real instruction 14243 * handler. Unlike the Arm handler, we can't do this as a tail call 14244 * because rIBASE is caller save and we need to reload it. 14245 */ 14246 movl rSELF, %eax 14247 movl rPC, OUT_ARG0(%esp) 14248 movl %eax, OUT_ARG1(%esp) 14249 call dvmCheckInst # (dPC, self) 14250 movl rSELF, %ecx 14251 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14252 jmp *dvmAsmInstructionStart+(164*4) 14253 14254/* ------------------------------ */ 14255.L_ALT_OP_USHR_LONG: /* 0xa5 */ 14256/* File: x86/alt_stub.S */ 14257/* 14258 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14259 * any interesting requests and then jump to the real instruction 14260 * handler. Unlike the Arm handler, we can't do this as a tail call 14261 * because rIBASE is caller save and we need to reload it. 14262 */ 14263 movl rSELF, %eax 14264 movl rPC, OUT_ARG0(%esp) 14265 movl %eax, OUT_ARG1(%esp) 14266 call dvmCheckInst # (dPC, self) 14267 movl rSELF, %ecx 14268 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14269 jmp *dvmAsmInstructionStart+(165*4) 14270 14271/* ------------------------------ */ 14272.L_ALT_OP_ADD_FLOAT: /* 0xa6 */ 14273/* File: x86/alt_stub.S */ 14274/* 14275 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14276 * any interesting requests and then jump to the real instruction 14277 * handler. Unlike the Arm handler, we can't do this as a tail call 14278 * because rIBASE is caller save and we need to reload it. 14279 */ 14280 movl rSELF, %eax 14281 movl rPC, OUT_ARG0(%esp) 14282 movl %eax, OUT_ARG1(%esp) 14283 call dvmCheckInst # (dPC, self) 14284 movl rSELF, %ecx 14285 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14286 jmp *dvmAsmInstructionStart+(166*4) 14287 14288/* ------------------------------ */ 14289.L_ALT_OP_SUB_FLOAT: /* 0xa7 */ 14290/* File: x86/alt_stub.S */ 14291/* 14292 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14293 * any interesting requests and then jump to the real instruction 14294 * handler. Unlike the Arm handler, we can't do this as a tail call 14295 * because rIBASE is caller save and we need to reload it. 14296 */ 14297 movl rSELF, %eax 14298 movl rPC, OUT_ARG0(%esp) 14299 movl %eax, OUT_ARG1(%esp) 14300 call dvmCheckInst # (dPC, self) 14301 movl rSELF, %ecx 14302 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14303 jmp *dvmAsmInstructionStart+(167*4) 14304 14305/* ------------------------------ */ 14306.L_ALT_OP_MUL_FLOAT: /* 0xa8 */ 14307/* File: x86/alt_stub.S */ 14308/* 14309 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14310 * any interesting requests and then jump to the real instruction 14311 * handler. Unlike the Arm handler, we can't do this as a tail call 14312 * because rIBASE is caller save and we need to reload it. 14313 */ 14314 movl rSELF, %eax 14315 movl rPC, OUT_ARG0(%esp) 14316 movl %eax, OUT_ARG1(%esp) 14317 call dvmCheckInst # (dPC, self) 14318 movl rSELF, %ecx 14319 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14320 jmp *dvmAsmInstructionStart+(168*4) 14321 14322/* ------------------------------ */ 14323.L_ALT_OP_DIV_FLOAT: /* 0xa9 */ 14324/* File: x86/alt_stub.S */ 14325/* 14326 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14327 * any interesting requests and then jump to the real instruction 14328 * handler. Unlike the Arm handler, we can't do this as a tail call 14329 * because rIBASE is caller save and we need to reload it. 14330 */ 14331 movl rSELF, %eax 14332 movl rPC, OUT_ARG0(%esp) 14333 movl %eax, OUT_ARG1(%esp) 14334 call dvmCheckInst # (dPC, self) 14335 movl rSELF, %ecx 14336 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14337 jmp *dvmAsmInstructionStart+(169*4) 14338 14339/* ------------------------------ */ 14340.L_ALT_OP_REM_FLOAT: /* 0xaa */ 14341/* File: x86/alt_stub.S */ 14342/* 14343 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14344 * any interesting requests and then jump to the real instruction 14345 * handler. Unlike the Arm handler, we can't do this as a tail call 14346 * because rIBASE is caller save and we need to reload it. 14347 */ 14348 movl rSELF, %eax 14349 movl rPC, OUT_ARG0(%esp) 14350 movl %eax, OUT_ARG1(%esp) 14351 call dvmCheckInst # (dPC, self) 14352 movl rSELF, %ecx 14353 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14354 jmp *dvmAsmInstructionStart+(170*4) 14355 14356/* ------------------------------ */ 14357.L_ALT_OP_ADD_DOUBLE: /* 0xab */ 14358/* File: x86/alt_stub.S */ 14359/* 14360 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14361 * any interesting requests and then jump to the real instruction 14362 * handler. Unlike the Arm handler, we can't do this as a tail call 14363 * because rIBASE is caller save and we need to reload it. 14364 */ 14365 movl rSELF, %eax 14366 movl rPC, OUT_ARG0(%esp) 14367 movl %eax, OUT_ARG1(%esp) 14368 call dvmCheckInst # (dPC, self) 14369 movl rSELF, %ecx 14370 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14371 jmp *dvmAsmInstructionStart+(171*4) 14372 14373/* ------------------------------ */ 14374.L_ALT_OP_SUB_DOUBLE: /* 0xac */ 14375/* File: x86/alt_stub.S */ 14376/* 14377 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14378 * any interesting requests and then jump to the real instruction 14379 * handler. Unlike the Arm handler, we can't do this as a tail call 14380 * because rIBASE is caller save and we need to reload it. 14381 */ 14382 movl rSELF, %eax 14383 movl rPC, OUT_ARG0(%esp) 14384 movl %eax, OUT_ARG1(%esp) 14385 call dvmCheckInst # (dPC, self) 14386 movl rSELF, %ecx 14387 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14388 jmp *dvmAsmInstructionStart+(172*4) 14389 14390/* ------------------------------ */ 14391.L_ALT_OP_MUL_DOUBLE: /* 0xad */ 14392/* File: x86/alt_stub.S */ 14393/* 14394 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14395 * any interesting requests and then jump to the real instruction 14396 * handler. Unlike the Arm handler, we can't do this as a tail call 14397 * because rIBASE is caller save and we need to reload it. 14398 */ 14399 movl rSELF, %eax 14400 movl rPC, OUT_ARG0(%esp) 14401 movl %eax, OUT_ARG1(%esp) 14402 call dvmCheckInst # (dPC, self) 14403 movl rSELF, %ecx 14404 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14405 jmp *dvmAsmInstructionStart+(173*4) 14406 14407/* ------------------------------ */ 14408.L_ALT_OP_DIV_DOUBLE: /* 0xae */ 14409/* File: x86/alt_stub.S */ 14410/* 14411 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14412 * any interesting requests and then jump to the real instruction 14413 * handler. Unlike the Arm handler, we can't do this as a tail call 14414 * because rIBASE is caller save and we need to reload it. 14415 */ 14416 movl rSELF, %eax 14417 movl rPC, OUT_ARG0(%esp) 14418 movl %eax, OUT_ARG1(%esp) 14419 call dvmCheckInst # (dPC, self) 14420 movl rSELF, %ecx 14421 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14422 jmp *dvmAsmInstructionStart+(174*4) 14423 14424/* ------------------------------ */ 14425.L_ALT_OP_REM_DOUBLE: /* 0xaf */ 14426/* File: x86/alt_stub.S */ 14427/* 14428 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14429 * any interesting requests and then jump to the real instruction 14430 * handler. Unlike the Arm handler, we can't do this as a tail call 14431 * because rIBASE is caller save and we need to reload it. 14432 */ 14433 movl rSELF, %eax 14434 movl rPC, OUT_ARG0(%esp) 14435 movl %eax, OUT_ARG1(%esp) 14436 call dvmCheckInst # (dPC, self) 14437 movl rSELF, %ecx 14438 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14439 jmp *dvmAsmInstructionStart+(175*4) 14440 14441/* ------------------------------ */ 14442.L_ALT_OP_ADD_INT_2ADDR: /* 0xb0 */ 14443/* File: x86/alt_stub.S */ 14444/* 14445 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14446 * any interesting requests and then jump to the real instruction 14447 * handler. Unlike the Arm handler, we can't do this as a tail call 14448 * because rIBASE is caller save and we need to reload it. 14449 */ 14450 movl rSELF, %eax 14451 movl rPC, OUT_ARG0(%esp) 14452 movl %eax, OUT_ARG1(%esp) 14453 call dvmCheckInst # (dPC, self) 14454 movl rSELF, %ecx 14455 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14456 jmp *dvmAsmInstructionStart+(176*4) 14457 14458/* ------------------------------ */ 14459.L_ALT_OP_SUB_INT_2ADDR: /* 0xb1 */ 14460/* File: x86/alt_stub.S */ 14461/* 14462 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14463 * any interesting requests and then jump to the real instruction 14464 * handler. Unlike the Arm handler, we can't do this as a tail call 14465 * because rIBASE is caller save and we need to reload it. 14466 */ 14467 movl rSELF, %eax 14468 movl rPC, OUT_ARG0(%esp) 14469 movl %eax, OUT_ARG1(%esp) 14470 call dvmCheckInst # (dPC, self) 14471 movl rSELF, %ecx 14472 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14473 jmp *dvmAsmInstructionStart+(177*4) 14474 14475/* ------------------------------ */ 14476.L_ALT_OP_MUL_INT_2ADDR: /* 0xb2 */ 14477/* File: x86/alt_stub.S */ 14478/* 14479 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14480 * any interesting requests and then jump to the real instruction 14481 * handler. Unlike the Arm handler, we can't do this as a tail call 14482 * because rIBASE is caller save and we need to reload it. 14483 */ 14484 movl rSELF, %eax 14485 movl rPC, OUT_ARG0(%esp) 14486 movl %eax, OUT_ARG1(%esp) 14487 call dvmCheckInst # (dPC, self) 14488 movl rSELF, %ecx 14489 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14490 jmp *dvmAsmInstructionStart+(178*4) 14491 14492/* ------------------------------ */ 14493.L_ALT_OP_DIV_INT_2ADDR: /* 0xb3 */ 14494/* File: x86/alt_stub.S */ 14495/* 14496 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14497 * any interesting requests and then jump to the real instruction 14498 * handler. Unlike the Arm handler, we can't do this as a tail call 14499 * because rIBASE is caller save and we need to reload it. 14500 */ 14501 movl rSELF, %eax 14502 movl rPC, OUT_ARG0(%esp) 14503 movl %eax, OUT_ARG1(%esp) 14504 call dvmCheckInst # (dPC, self) 14505 movl rSELF, %ecx 14506 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14507 jmp *dvmAsmInstructionStart+(179*4) 14508 14509/* ------------------------------ */ 14510.L_ALT_OP_REM_INT_2ADDR: /* 0xb4 */ 14511/* File: x86/alt_stub.S */ 14512/* 14513 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14514 * any interesting requests and then jump to the real instruction 14515 * handler. Unlike the Arm handler, we can't do this as a tail call 14516 * because rIBASE is caller save and we need to reload it. 14517 */ 14518 movl rSELF, %eax 14519 movl rPC, OUT_ARG0(%esp) 14520 movl %eax, OUT_ARG1(%esp) 14521 call dvmCheckInst # (dPC, self) 14522 movl rSELF, %ecx 14523 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14524 jmp *dvmAsmInstructionStart+(180*4) 14525 14526/* ------------------------------ */ 14527.L_ALT_OP_AND_INT_2ADDR: /* 0xb5 */ 14528/* File: x86/alt_stub.S */ 14529/* 14530 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14531 * any interesting requests and then jump to the real instruction 14532 * handler. Unlike the Arm handler, we can't do this as a tail call 14533 * because rIBASE is caller save and we need to reload it. 14534 */ 14535 movl rSELF, %eax 14536 movl rPC, OUT_ARG0(%esp) 14537 movl %eax, OUT_ARG1(%esp) 14538 call dvmCheckInst # (dPC, self) 14539 movl rSELF, %ecx 14540 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14541 jmp *dvmAsmInstructionStart+(181*4) 14542 14543/* ------------------------------ */ 14544.L_ALT_OP_OR_INT_2ADDR: /* 0xb6 */ 14545/* File: x86/alt_stub.S */ 14546/* 14547 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14548 * any interesting requests and then jump to the real instruction 14549 * handler. Unlike the Arm handler, we can't do this as a tail call 14550 * because rIBASE is caller save and we need to reload it. 14551 */ 14552 movl rSELF, %eax 14553 movl rPC, OUT_ARG0(%esp) 14554 movl %eax, OUT_ARG1(%esp) 14555 call dvmCheckInst # (dPC, self) 14556 movl rSELF, %ecx 14557 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14558 jmp *dvmAsmInstructionStart+(182*4) 14559 14560/* ------------------------------ */ 14561.L_ALT_OP_XOR_INT_2ADDR: /* 0xb7 */ 14562/* File: x86/alt_stub.S */ 14563/* 14564 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14565 * any interesting requests and then jump to the real instruction 14566 * handler. Unlike the Arm handler, we can't do this as a tail call 14567 * because rIBASE is caller save and we need to reload it. 14568 */ 14569 movl rSELF, %eax 14570 movl rPC, OUT_ARG0(%esp) 14571 movl %eax, OUT_ARG1(%esp) 14572 call dvmCheckInst # (dPC, self) 14573 movl rSELF, %ecx 14574 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14575 jmp *dvmAsmInstructionStart+(183*4) 14576 14577/* ------------------------------ */ 14578.L_ALT_OP_SHL_INT_2ADDR: /* 0xb8 */ 14579/* File: x86/alt_stub.S */ 14580/* 14581 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14582 * any interesting requests and then jump to the real instruction 14583 * handler. Unlike the Arm handler, we can't do this as a tail call 14584 * because rIBASE is caller save and we need to reload it. 14585 */ 14586 movl rSELF, %eax 14587 movl rPC, OUT_ARG0(%esp) 14588 movl %eax, OUT_ARG1(%esp) 14589 call dvmCheckInst # (dPC, self) 14590 movl rSELF, %ecx 14591 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14592 jmp *dvmAsmInstructionStart+(184*4) 14593 14594/* ------------------------------ */ 14595.L_ALT_OP_SHR_INT_2ADDR: /* 0xb9 */ 14596/* File: x86/alt_stub.S */ 14597/* 14598 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14599 * any interesting requests and then jump to the real instruction 14600 * handler. Unlike the Arm handler, we can't do this as a tail call 14601 * because rIBASE is caller save and we need to reload it. 14602 */ 14603 movl rSELF, %eax 14604 movl rPC, OUT_ARG0(%esp) 14605 movl %eax, OUT_ARG1(%esp) 14606 call dvmCheckInst # (dPC, self) 14607 movl rSELF, %ecx 14608 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14609 jmp *dvmAsmInstructionStart+(185*4) 14610 14611/* ------------------------------ */ 14612.L_ALT_OP_USHR_INT_2ADDR: /* 0xba */ 14613/* File: x86/alt_stub.S */ 14614/* 14615 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14616 * any interesting requests and then jump to the real instruction 14617 * handler. Unlike the Arm handler, we can't do this as a tail call 14618 * because rIBASE is caller save and we need to reload it. 14619 */ 14620 movl rSELF, %eax 14621 movl rPC, OUT_ARG0(%esp) 14622 movl %eax, OUT_ARG1(%esp) 14623 call dvmCheckInst # (dPC, self) 14624 movl rSELF, %ecx 14625 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14626 jmp *dvmAsmInstructionStart+(186*4) 14627 14628/* ------------------------------ */ 14629.L_ALT_OP_ADD_LONG_2ADDR: /* 0xbb */ 14630/* File: x86/alt_stub.S */ 14631/* 14632 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14633 * any interesting requests and then jump to the real instruction 14634 * handler. Unlike the Arm handler, we can't do this as a tail call 14635 * because rIBASE is caller save and we need to reload it. 14636 */ 14637 movl rSELF, %eax 14638 movl rPC, OUT_ARG0(%esp) 14639 movl %eax, OUT_ARG1(%esp) 14640 call dvmCheckInst # (dPC, self) 14641 movl rSELF, %ecx 14642 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14643 jmp *dvmAsmInstructionStart+(187*4) 14644 14645/* ------------------------------ */ 14646.L_ALT_OP_SUB_LONG_2ADDR: /* 0xbc */ 14647/* File: x86/alt_stub.S */ 14648/* 14649 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14650 * any interesting requests and then jump to the real instruction 14651 * handler. Unlike the Arm handler, we can't do this as a tail call 14652 * because rIBASE is caller save and we need to reload it. 14653 */ 14654 movl rSELF, %eax 14655 movl rPC, OUT_ARG0(%esp) 14656 movl %eax, OUT_ARG1(%esp) 14657 call dvmCheckInst # (dPC, self) 14658 movl rSELF, %ecx 14659 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14660 jmp *dvmAsmInstructionStart+(188*4) 14661 14662/* ------------------------------ */ 14663.L_ALT_OP_MUL_LONG_2ADDR: /* 0xbd */ 14664/* File: x86/alt_stub.S */ 14665/* 14666 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14667 * any interesting requests and then jump to the real instruction 14668 * handler. Unlike the Arm handler, we can't do this as a tail call 14669 * because rIBASE is caller save and we need to reload it. 14670 */ 14671 movl rSELF, %eax 14672 movl rPC, OUT_ARG0(%esp) 14673 movl %eax, OUT_ARG1(%esp) 14674 call dvmCheckInst # (dPC, self) 14675 movl rSELF, %ecx 14676 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14677 jmp *dvmAsmInstructionStart+(189*4) 14678 14679/* ------------------------------ */ 14680.L_ALT_OP_DIV_LONG_2ADDR: /* 0xbe */ 14681/* File: x86/alt_stub.S */ 14682/* 14683 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14684 * any interesting requests and then jump to the real instruction 14685 * handler. Unlike the Arm handler, we can't do this as a tail call 14686 * because rIBASE is caller save and we need to reload it. 14687 */ 14688 movl rSELF, %eax 14689 movl rPC, OUT_ARG0(%esp) 14690 movl %eax, OUT_ARG1(%esp) 14691 call dvmCheckInst # (dPC, self) 14692 movl rSELF, %ecx 14693 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14694 jmp *dvmAsmInstructionStart+(190*4) 14695 14696/* ------------------------------ */ 14697.L_ALT_OP_REM_LONG_2ADDR: /* 0xbf */ 14698/* File: x86/alt_stub.S */ 14699/* 14700 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14701 * any interesting requests and then jump to the real instruction 14702 * handler. Unlike the Arm handler, we can't do this as a tail call 14703 * because rIBASE is caller save and we need to reload it. 14704 */ 14705 movl rSELF, %eax 14706 movl rPC, OUT_ARG0(%esp) 14707 movl %eax, OUT_ARG1(%esp) 14708 call dvmCheckInst # (dPC, self) 14709 movl rSELF, %ecx 14710 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14711 jmp *dvmAsmInstructionStart+(191*4) 14712 14713/* ------------------------------ */ 14714.L_ALT_OP_AND_LONG_2ADDR: /* 0xc0 */ 14715/* File: x86/alt_stub.S */ 14716/* 14717 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14718 * any interesting requests and then jump to the real instruction 14719 * handler. Unlike the Arm handler, we can't do this as a tail call 14720 * because rIBASE is caller save and we need to reload it. 14721 */ 14722 movl rSELF, %eax 14723 movl rPC, OUT_ARG0(%esp) 14724 movl %eax, OUT_ARG1(%esp) 14725 call dvmCheckInst # (dPC, self) 14726 movl rSELF, %ecx 14727 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14728 jmp *dvmAsmInstructionStart+(192*4) 14729 14730/* ------------------------------ */ 14731.L_ALT_OP_OR_LONG_2ADDR: /* 0xc1 */ 14732/* File: x86/alt_stub.S */ 14733/* 14734 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14735 * any interesting requests and then jump to the real instruction 14736 * handler. Unlike the Arm handler, we can't do this as a tail call 14737 * because rIBASE is caller save and we need to reload it. 14738 */ 14739 movl rSELF, %eax 14740 movl rPC, OUT_ARG0(%esp) 14741 movl %eax, OUT_ARG1(%esp) 14742 call dvmCheckInst # (dPC, self) 14743 movl rSELF, %ecx 14744 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14745 jmp *dvmAsmInstructionStart+(193*4) 14746 14747/* ------------------------------ */ 14748.L_ALT_OP_XOR_LONG_2ADDR: /* 0xc2 */ 14749/* File: x86/alt_stub.S */ 14750/* 14751 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14752 * any interesting requests and then jump to the real instruction 14753 * handler. Unlike the Arm handler, we can't do this as a tail call 14754 * because rIBASE is caller save and we need to reload it. 14755 */ 14756 movl rSELF, %eax 14757 movl rPC, OUT_ARG0(%esp) 14758 movl %eax, OUT_ARG1(%esp) 14759 call dvmCheckInst # (dPC, self) 14760 movl rSELF, %ecx 14761 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14762 jmp *dvmAsmInstructionStart+(194*4) 14763 14764/* ------------------------------ */ 14765.L_ALT_OP_SHL_LONG_2ADDR: /* 0xc3 */ 14766/* File: x86/alt_stub.S */ 14767/* 14768 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14769 * any interesting requests and then jump to the real instruction 14770 * handler. Unlike the Arm handler, we can't do this as a tail call 14771 * because rIBASE is caller save and we need to reload it. 14772 */ 14773 movl rSELF, %eax 14774 movl rPC, OUT_ARG0(%esp) 14775 movl %eax, OUT_ARG1(%esp) 14776 call dvmCheckInst # (dPC, self) 14777 movl rSELF, %ecx 14778 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14779 jmp *dvmAsmInstructionStart+(195*4) 14780 14781/* ------------------------------ */ 14782.L_ALT_OP_SHR_LONG_2ADDR: /* 0xc4 */ 14783/* File: x86/alt_stub.S */ 14784/* 14785 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14786 * any interesting requests and then jump to the real instruction 14787 * handler. Unlike the Arm handler, we can't do this as a tail call 14788 * because rIBASE is caller save and we need to reload it. 14789 */ 14790 movl rSELF, %eax 14791 movl rPC, OUT_ARG0(%esp) 14792 movl %eax, OUT_ARG1(%esp) 14793 call dvmCheckInst # (dPC, self) 14794 movl rSELF, %ecx 14795 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14796 jmp *dvmAsmInstructionStart+(196*4) 14797 14798/* ------------------------------ */ 14799.L_ALT_OP_USHR_LONG_2ADDR: /* 0xc5 */ 14800/* File: x86/alt_stub.S */ 14801/* 14802 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14803 * any interesting requests and then jump to the real instruction 14804 * handler. Unlike the Arm handler, we can't do this as a tail call 14805 * because rIBASE is caller save and we need to reload it. 14806 */ 14807 movl rSELF, %eax 14808 movl rPC, OUT_ARG0(%esp) 14809 movl %eax, OUT_ARG1(%esp) 14810 call dvmCheckInst # (dPC, self) 14811 movl rSELF, %ecx 14812 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14813 jmp *dvmAsmInstructionStart+(197*4) 14814 14815/* ------------------------------ */ 14816.L_ALT_OP_ADD_FLOAT_2ADDR: /* 0xc6 */ 14817/* File: x86/alt_stub.S */ 14818/* 14819 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14820 * any interesting requests and then jump to the real instruction 14821 * handler. Unlike the Arm handler, we can't do this as a tail call 14822 * because rIBASE is caller save and we need to reload it. 14823 */ 14824 movl rSELF, %eax 14825 movl rPC, OUT_ARG0(%esp) 14826 movl %eax, OUT_ARG1(%esp) 14827 call dvmCheckInst # (dPC, self) 14828 movl rSELF, %ecx 14829 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14830 jmp *dvmAsmInstructionStart+(198*4) 14831 14832/* ------------------------------ */ 14833.L_ALT_OP_SUB_FLOAT_2ADDR: /* 0xc7 */ 14834/* File: x86/alt_stub.S */ 14835/* 14836 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14837 * any interesting requests and then jump to the real instruction 14838 * handler. Unlike the Arm handler, we can't do this as a tail call 14839 * because rIBASE is caller save and we need to reload it. 14840 */ 14841 movl rSELF, %eax 14842 movl rPC, OUT_ARG0(%esp) 14843 movl %eax, OUT_ARG1(%esp) 14844 call dvmCheckInst # (dPC, self) 14845 movl rSELF, %ecx 14846 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14847 jmp *dvmAsmInstructionStart+(199*4) 14848 14849/* ------------------------------ */ 14850.L_ALT_OP_MUL_FLOAT_2ADDR: /* 0xc8 */ 14851/* File: x86/alt_stub.S */ 14852/* 14853 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14854 * any interesting requests and then jump to the real instruction 14855 * handler. Unlike the Arm handler, we can't do this as a tail call 14856 * because rIBASE is caller save and we need to reload it. 14857 */ 14858 movl rSELF, %eax 14859 movl rPC, OUT_ARG0(%esp) 14860 movl %eax, OUT_ARG1(%esp) 14861 call dvmCheckInst # (dPC, self) 14862 movl rSELF, %ecx 14863 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14864 jmp *dvmAsmInstructionStart+(200*4) 14865 14866/* ------------------------------ */ 14867.L_ALT_OP_DIV_FLOAT_2ADDR: /* 0xc9 */ 14868/* File: x86/alt_stub.S */ 14869/* 14870 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14871 * any interesting requests and then jump to the real instruction 14872 * handler. Unlike the Arm handler, we can't do this as a tail call 14873 * because rIBASE is caller save and we need to reload it. 14874 */ 14875 movl rSELF, %eax 14876 movl rPC, OUT_ARG0(%esp) 14877 movl %eax, OUT_ARG1(%esp) 14878 call dvmCheckInst # (dPC, self) 14879 movl rSELF, %ecx 14880 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14881 jmp *dvmAsmInstructionStart+(201*4) 14882 14883/* ------------------------------ */ 14884.L_ALT_OP_REM_FLOAT_2ADDR: /* 0xca */ 14885/* File: x86/alt_stub.S */ 14886/* 14887 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14888 * any interesting requests and then jump to the real instruction 14889 * handler. Unlike the Arm handler, we can't do this as a tail call 14890 * because rIBASE is caller save and we need to reload it. 14891 */ 14892 movl rSELF, %eax 14893 movl rPC, OUT_ARG0(%esp) 14894 movl %eax, OUT_ARG1(%esp) 14895 call dvmCheckInst # (dPC, self) 14896 movl rSELF, %ecx 14897 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14898 jmp *dvmAsmInstructionStart+(202*4) 14899 14900/* ------------------------------ */ 14901.L_ALT_OP_ADD_DOUBLE_2ADDR: /* 0xcb */ 14902/* File: x86/alt_stub.S */ 14903/* 14904 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14905 * any interesting requests and then jump to the real instruction 14906 * handler. Unlike the Arm handler, we can't do this as a tail call 14907 * because rIBASE is caller save and we need to reload it. 14908 */ 14909 movl rSELF, %eax 14910 movl rPC, OUT_ARG0(%esp) 14911 movl %eax, OUT_ARG1(%esp) 14912 call dvmCheckInst # (dPC, self) 14913 movl rSELF, %ecx 14914 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14915 jmp *dvmAsmInstructionStart+(203*4) 14916 14917/* ------------------------------ */ 14918.L_ALT_OP_SUB_DOUBLE_2ADDR: /* 0xcc */ 14919/* File: x86/alt_stub.S */ 14920/* 14921 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14922 * any interesting requests and then jump to the real instruction 14923 * handler. Unlike the Arm handler, we can't do this as a tail call 14924 * because rIBASE is caller save and we need to reload it. 14925 */ 14926 movl rSELF, %eax 14927 movl rPC, OUT_ARG0(%esp) 14928 movl %eax, OUT_ARG1(%esp) 14929 call dvmCheckInst # (dPC, self) 14930 movl rSELF, %ecx 14931 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14932 jmp *dvmAsmInstructionStart+(204*4) 14933 14934/* ------------------------------ */ 14935.L_ALT_OP_MUL_DOUBLE_2ADDR: /* 0xcd */ 14936/* File: x86/alt_stub.S */ 14937/* 14938 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14939 * any interesting requests and then jump to the real instruction 14940 * handler. Unlike the Arm handler, we can't do this as a tail call 14941 * because rIBASE is caller save and we need to reload it. 14942 */ 14943 movl rSELF, %eax 14944 movl rPC, OUT_ARG0(%esp) 14945 movl %eax, OUT_ARG1(%esp) 14946 call dvmCheckInst # (dPC, self) 14947 movl rSELF, %ecx 14948 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14949 jmp *dvmAsmInstructionStart+(205*4) 14950 14951/* ------------------------------ */ 14952.L_ALT_OP_DIV_DOUBLE_2ADDR: /* 0xce */ 14953/* File: x86/alt_stub.S */ 14954/* 14955 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14956 * any interesting requests and then jump to the real instruction 14957 * handler. Unlike the Arm handler, we can't do this as a tail call 14958 * because rIBASE is caller save and we need to reload it. 14959 */ 14960 movl rSELF, %eax 14961 movl rPC, OUT_ARG0(%esp) 14962 movl %eax, OUT_ARG1(%esp) 14963 call dvmCheckInst # (dPC, self) 14964 movl rSELF, %ecx 14965 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14966 jmp *dvmAsmInstructionStart+(206*4) 14967 14968/* ------------------------------ */ 14969.L_ALT_OP_REM_DOUBLE_2ADDR: /* 0xcf */ 14970/* File: x86/alt_stub.S */ 14971/* 14972 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14973 * any interesting requests and then jump to the real instruction 14974 * handler. Unlike the Arm handler, we can't do this as a tail call 14975 * because rIBASE is caller save and we need to reload it. 14976 */ 14977 movl rSELF, %eax 14978 movl rPC, OUT_ARG0(%esp) 14979 movl %eax, OUT_ARG1(%esp) 14980 call dvmCheckInst # (dPC, self) 14981 movl rSELF, %ecx 14982 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14983 jmp *dvmAsmInstructionStart+(207*4) 14984 14985/* ------------------------------ */ 14986.L_ALT_OP_ADD_INT_LIT16: /* 0xd0 */ 14987/* File: x86/alt_stub.S */ 14988/* 14989 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14990 * any interesting requests and then jump to the real instruction 14991 * handler. Unlike the Arm handler, we can't do this as a tail call 14992 * because rIBASE is caller save and we need to reload it. 14993 */ 14994 movl rSELF, %eax 14995 movl rPC, OUT_ARG0(%esp) 14996 movl %eax, OUT_ARG1(%esp) 14997 call dvmCheckInst # (dPC, self) 14998 movl rSELF, %ecx 14999 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15000 jmp *dvmAsmInstructionStart+(208*4) 15001 15002/* ------------------------------ */ 15003.L_ALT_OP_RSUB_INT: /* 0xd1 */ 15004/* File: x86/alt_stub.S */ 15005/* 15006 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15007 * any interesting requests and then jump to the real instruction 15008 * handler. Unlike the Arm handler, we can't do this as a tail call 15009 * because rIBASE is caller save and we need to reload it. 15010 */ 15011 movl rSELF, %eax 15012 movl rPC, OUT_ARG0(%esp) 15013 movl %eax, OUT_ARG1(%esp) 15014 call dvmCheckInst # (dPC, self) 15015 movl rSELF, %ecx 15016 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15017 jmp *dvmAsmInstructionStart+(209*4) 15018 15019/* ------------------------------ */ 15020.L_ALT_OP_MUL_INT_LIT16: /* 0xd2 */ 15021/* File: x86/alt_stub.S */ 15022/* 15023 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15024 * any interesting requests and then jump to the real instruction 15025 * handler. Unlike the Arm handler, we can't do this as a tail call 15026 * because rIBASE is caller save and we need to reload it. 15027 */ 15028 movl rSELF, %eax 15029 movl rPC, OUT_ARG0(%esp) 15030 movl %eax, OUT_ARG1(%esp) 15031 call dvmCheckInst # (dPC, self) 15032 movl rSELF, %ecx 15033 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15034 jmp *dvmAsmInstructionStart+(210*4) 15035 15036/* ------------------------------ */ 15037.L_ALT_OP_DIV_INT_LIT16: /* 0xd3 */ 15038/* File: x86/alt_stub.S */ 15039/* 15040 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15041 * any interesting requests and then jump to the real instruction 15042 * handler. Unlike the Arm handler, we can't do this as a tail call 15043 * because rIBASE is caller save and we need to reload it. 15044 */ 15045 movl rSELF, %eax 15046 movl rPC, OUT_ARG0(%esp) 15047 movl %eax, OUT_ARG1(%esp) 15048 call dvmCheckInst # (dPC, self) 15049 movl rSELF, %ecx 15050 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15051 jmp *dvmAsmInstructionStart+(211*4) 15052 15053/* ------------------------------ */ 15054.L_ALT_OP_REM_INT_LIT16: /* 0xd4 */ 15055/* File: x86/alt_stub.S */ 15056/* 15057 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15058 * any interesting requests and then jump to the real instruction 15059 * handler. Unlike the Arm handler, we can't do this as a tail call 15060 * because rIBASE is caller save and we need to reload it. 15061 */ 15062 movl rSELF, %eax 15063 movl rPC, OUT_ARG0(%esp) 15064 movl %eax, OUT_ARG1(%esp) 15065 call dvmCheckInst # (dPC, self) 15066 movl rSELF, %ecx 15067 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15068 jmp *dvmAsmInstructionStart+(212*4) 15069 15070/* ------------------------------ */ 15071.L_ALT_OP_AND_INT_LIT16: /* 0xd5 */ 15072/* File: x86/alt_stub.S */ 15073/* 15074 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15075 * any interesting requests and then jump to the real instruction 15076 * handler. Unlike the Arm handler, we can't do this as a tail call 15077 * because rIBASE is caller save and we need to reload it. 15078 */ 15079 movl rSELF, %eax 15080 movl rPC, OUT_ARG0(%esp) 15081 movl %eax, OUT_ARG1(%esp) 15082 call dvmCheckInst # (dPC, self) 15083 movl rSELF, %ecx 15084 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15085 jmp *dvmAsmInstructionStart+(213*4) 15086 15087/* ------------------------------ */ 15088.L_ALT_OP_OR_INT_LIT16: /* 0xd6 */ 15089/* File: x86/alt_stub.S */ 15090/* 15091 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15092 * any interesting requests and then jump to the real instruction 15093 * handler. Unlike the Arm handler, we can't do this as a tail call 15094 * because rIBASE is caller save and we need to reload it. 15095 */ 15096 movl rSELF, %eax 15097 movl rPC, OUT_ARG0(%esp) 15098 movl %eax, OUT_ARG1(%esp) 15099 call dvmCheckInst # (dPC, self) 15100 movl rSELF, %ecx 15101 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15102 jmp *dvmAsmInstructionStart+(214*4) 15103 15104/* ------------------------------ */ 15105.L_ALT_OP_XOR_INT_LIT16: /* 0xd7 */ 15106/* File: x86/alt_stub.S */ 15107/* 15108 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15109 * any interesting requests and then jump to the real instruction 15110 * handler. Unlike the Arm handler, we can't do this as a tail call 15111 * because rIBASE is caller save and we need to reload it. 15112 */ 15113 movl rSELF, %eax 15114 movl rPC, OUT_ARG0(%esp) 15115 movl %eax, OUT_ARG1(%esp) 15116 call dvmCheckInst # (dPC, self) 15117 movl rSELF, %ecx 15118 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15119 jmp *dvmAsmInstructionStart+(215*4) 15120 15121/* ------------------------------ */ 15122.L_ALT_OP_ADD_INT_LIT8: /* 0xd8 */ 15123/* File: x86/alt_stub.S */ 15124/* 15125 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15126 * any interesting requests and then jump to the real instruction 15127 * handler. Unlike the Arm handler, we can't do this as a tail call 15128 * because rIBASE is caller save and we need to reload it. 15129 */ 15130 movl rSELF, %eax 15131 movl rPC, OUT_ARG0(%esp) 15132 movl %eax, OUT_ARG1(%esp) 15133 call dvmCheckInst # (dPC, self) 15134 movl rSELF, %ecx 15135 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15136 jmp *dvmAsmInstructionStart+(216*4) 15137 15138/* ------------------------------ */ 15139.L_ALT_OP_RSUB_INT_LIT8: /* 0xd9 */ 15140/* File: x86/alt_stub.S */ 15141/* 15142 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15143 * any interesting requests and then jump to the real instruction 15144 * handler. Unlike the Arm handler, we can't do this as a tail call 15145 * because rIBASE is caller save and we need to reload it. 15146 */ 15147 movl rSELF, %eax 15148 movl rPC, OUT_ARG0(%esp) 15149 movl %eax, OUT_ARG1(%esp) 15150 call dvmCheckInst # (dPC, self) 15151 movl rSELF, %ecx 15152 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15153 jmp *dvmAsmInstructionStart+(217*4) 15154 15155/* ------------------------------ */ 15156.L_ALT_OP_MUL_INT_LIT8: /* 0xda */ 15157/* File: x86/alt_stub.S */ 15158/* 15159 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15160 * any interesting requests and then jump to the real instruction 15161 * handler. Unlike the Arm handler, we can't do this as a tail call 15162 * because rIBASE is caller save and we need to reload it. 15163 */ 15164 movl rSELF, %eax 15165 movl rPC, OUT_ARG0(%esp) 15166 movl %eax, OUT_ARG1(%esp) 15167 call dvmCheckInst # (dPC, self) 15168 movl rSELF, %ecx 15169 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15170 jmp *dvmAsmInstructionStart+(218*4) 15171 15172/* ------------------------------ */ 15173.L_ALT_OP_DIV_INT_LIT8: /* 0xdb */ 15174/* File: x86/alt_stub.S */ 15175/* 15176 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15177 * any interesting requests and then jump to the real instruction 15178 * handler. Unlike the Arm handler, we can't do this as a tail call 15179 * because rIBASE is caller save and we need to reload it. 15180 */ 15181 movl rSELF, %eax 15182 movl rPC, OUT_ARG0(%esp) 15183 movl %eax, OUT_ARG1(%esp) 15184 call dvmCheckInst # (dPC, self) 15185 movl rSELF, %ecx 15186 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15187 jmp *dvmAsmInstructionStart+(219*4) 15188 15189/* ------------------------------ */ 15190.L_ALT_OP_REM_INT_LIT8: /* 0xdc */ 15191/* File: x86/alt_stub.S */ 15192/* 15193 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15194 * any interesting requests and then jump to the real instruction 15195 * handler. Unlike the Arm handler, we can't do this as a tail call 15196 * because rIBASE is caller save and we need to reload it. 15197 */ 15198 movl rSELF, %eax 15199 movl rPC, OUT_ARG0(%esp) 15200 movl %eax, OUT_ARG1(%esp) 15201 call dvmCheckInst # (dPC, self) 15202 movl rSELF, %ecx 15203 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15204 jmp *dvmAsmInstructionStart+(220*4) 15205 15206/* ------------------------------ */ 15207.L_ALT_OP_AND_INT_LIT8: /* 0xdd */ 15208/* File: x86/alt_stub.S */ 15209/* 15210 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15211 * any interesting requests and then jump to the real instruction 15212 * handler. Unlike the Arm handler, we can't do this as a tail call 15213 * because rIBASE is caller save and we need to reload it. 15214 */ 15215 movl rSELF, %eax 15216 movl rPC, OUT_ARG0(%esp) 15217 movl %eax, OUT_ARG1(%esp) 15218 call dvmCheckInst # (dPC, self) 15219 movl rSELF, %ecx 15220 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15221 jmp *dvmAsmInstructionStart+(221*4) 15222 15223/* ------------------------------ */ 15224.L_ALT_OP_OR_INT_LIT8: /* 0xde */ 15225/* File: x86/alt_stub.S */ 15226/* 15227 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15228 * any interesting requests and then jump to the real instruction 15229 * handler. Unlike the Arm handler, we can't do this as a tail call 15230 * because rIBASE is caller save and we need to reload it. 15231 */ 15232 movl rSELF, %eax 15233 movl rPC, OUT_ARG0(%esp) 15234 movl %eax, OUT_ARG1(%esp) 15235 call dvmCheckInst # (dPC, self) 15236 movl rSELF, %ecx 15237 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15238 jmp *dvmAsmInstructionStart+(222*4) 15239 15240/* ------------------------------ */ 15241.L_ALT_OP_XOR_INT_LIT8: /* 0xdf */ 15242/* File: x86/alt_stub.S */ 15243/* 15244 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15245 * any interesting requests and then jump to the real instruction 15246 * handler. Unlike the Arm handler, we can't do this as a tail call 15247 * because rIBASE is caller save and we need to reload it. 15248 */ 15249 movl rSELF, %eax 15250 movl rPC, OUT_ARG0(%esp) 15251 movl %eax, OUT_ARG1(%esp) 15252 call dvmCheckInst # (dPC, self) 15253 movl rSELF, %ecx 15254 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15255 jmp *dvmAsmInstructionStart+(223*4) 15256 15257/* ------------------------------ */ 15258.L_ALT_OP_SHL_INT_LIT8: /* 0xe0 */ 15259/* File: x86/alt_stub.S */ 15260/* 15261 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15262 * any interesting requests and then jump to the real instruction 15263 * handler. Unlike the Arm handler, we can't do this as a tail call 15264 * because rIBASE is caller save and we need to reload it. 15265 */ 15266 movl rSELF, %eax 15267 movl rPC, OUT_ARG0(%esp) 15268 movl %eax, OUT_ARG1(%esp) 15269 call dvmCheckInst # (dPC, self) 15270 movl rSELF, %ecx 15271 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15272 jmp *dvmAsmInstructionStart+(224*4) 15273 15274/* ------------------------------ */ 15275.L_ALT_OP_SHR_INT_LIT8: /* 0xe1 */ 15276/* File: x86/alt_stub.S */ 15277/* 15278 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15279 * any interesting requests and then jump to the real instruction 15280 * handler. Unlike the Arm handler, we can't do this as a tail call 15281 * because rIBASE is caller save and we need to reload it. 15282 */ 15283 movl rSELF, %eax 15284 movl rPC, OUT_ARG0(%esp) 15285 movl %eax, OUT_ARG1(%esp) 15286 call dvmCheckInst # (dPC, self) 15287 movl rSELF, %ecx 15288 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15289 jmp *dvmAsmInstructionStart+(225*4) 15290 15291/* ------------------------------ */ 15292.L_ALT_OP_USHR_INT_LIT8: /* 0xe2 */ 15293/* File: x86/alt_stub.S */ 15294/* 15295 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15296 * any interesting requests and then jump to the real instruction 15297 * handler. Unlike the Arm handler, we can't do this as a tail call 15298 * because rIBASE is caller save and we need to reload it. 15299 */ 15300 movl rSELF, %eax 15301 movl rPC, OUT_ARG0(%esp) 15302 movl %eax, OUT_ARG1(%esp) 15303 call dvmCheckInst # (dPC, self) 15304 movl rSELF, %ecx 15305 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15306 jmp *dvmAsmInstructionStart+(226*4) 15307 15308/* ------------------------------ */ 15309.L_ALT_OP_IGET_VOLATILE: /* 0xe3 */ 15310/* File: x86/alt_stub.S */ 15311/* 15312 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15313 * any interesting requests and then jump to the real instruction 15314 * handler. Unlike the Arm handler, we can't do this as a tail call 15315 * because rIBASE is caller save and we need to reload it. 15316 */ 15317 movl rSELF, %eax 15318 movl rPC, OUT_ARG0(%esp) 15319 movl %eax, OUT_ARG1(%esp) 15320 call dvmCheckInst # (dPC, self) 15321 movl rSELF, %ecx 15322 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15323 jmp *dvmAsmInstructionStart+(227*4) 15324 15325/* ------------------------------ */ 15326.L_ALT_OP_IPUT_VOLATILE: /* 0xe4 */ 15327/* File: x86/alt_stub.S */ 15328/* 15329 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15330 * any interesting requests and then jump to the real instruction 15331 * handler. Unlike the Arm handler, we can't do this as a tail call 15332 * because rIBASE is caller save and we need to reload it. 15333 */ 15334 movl rSELF, %eax 15335 movl rPC, OUT_ARG0(%esp) 15336 movl %eax, OUT_ARG1(%esp) 15337 call dvmCheckInst # (dPC, self) 15338 movl rSELF, %ecx 15339 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15340 jmp *dvmAsmInstructionStart+(228*4) 15341 15342/* ------------------------------ */ 15343.L_ALT_OP_SGET_VOLATILE: /* 0xe5 */ 15344/* File: x86/alt_stub.S */ 15345/* 15346 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15347 * any interesting requests and then jump to the real instruction 15348 * handler. Unlike the Arm handler, we can't do this as a tail call 15349 * because rIBASE is caller save and we need to reload it. 15350 */ 15351 movl rSELF, %eax 15352 movl rPC, OUT_ARG0(%esp) 15353 movl %eax, OUT_ARG1(%esp) 15354 call dvmCheckInst # (dPC, self) 15355 movl rSELF, %ecx 15356 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15357 jmp *dvmAsmInstructionStart+(229*4) 15358 15359/* ------------------------------ */ 15360.L_ALT_OP_SPUT_VOLATILE: /* 0xe6 */ 15361/* File: x86/alt_stub.S */ 15362/* 15363 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15364 * any interesting requests and then jump to the real instruction 15365 * handler. Unlike the Arm handler, we can't do this as a tail call 15366 * because rIBASE is caller save and we need to reload it. 15367 */ 15368 movl rSELF, %eax 15369 movl rPC, OUT_ARG0(%esp) 15370 movl %eax, OUT_ARG1(%esp) 15371 call dvmCheckInst # (dPC, self) 15372 movl rSELF, %ecx 15373 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15374 jmp *dvmAsmInstructionStart+(230*4) 15375 15376/* ------------------------------ */ 15377.L_ALT_OP_IGET_OBJECT_VOLATILE: /* 0xe7 */ 15378/* File: x86/alt_stub.S */ 15379/* 15380 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15381 * any interesting requests and then jump to the real instruction 15382 * handler. Unlike the Arm handler, we can't do this as a tail call 15383 * because rIBASE is caller save and we need to reload it. 15384 */ 15385 movl rSELF, %eax 15386 movl rPC, OUT_ARG0(%esp) 15387 movl %eax, OUT_ARG1(%esp) 15388 call dvmCheckInst # (dPC, self) 15389 movl rSELF, %ecx 15390 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15391 jmp *dvmAsmInstructionStart+(231*4) 15392 15393/* ------------------------------ */ 15394.L_ALT_OP_IGET_WIDE_VOLATILE: /* 0xe8 */ 15395/* File: x86/alt_stub.S */ 15396/* 15397 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15398 * any interesting requests and then jump to the real instruction 15399 * handler. Unlike the Arm handler, we can't do this as a tail call 15400 * because rIBASE is caller save and we need to reload it. 15401 */ 15402 movl rSELF, %eax 15403 movl rPC, OUT_ARG0(%esp) 15404 movl %eax, OUT_ARG1(%esp) 15405 call dvmCheckInst # (dPC, self) 15406 movl rSELF, %ecx 15407 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15408 jmp *dvmAsmInstructionStart+(232*4) 15409 15410/* ------------------------------ */ 15411.L_ALT_OP_IPUT_WIDE_VOLATILE: /* 0xe9 */ 15412/* File: x86/alt_stub.S */ 15413/* 15414 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15415 * any interesting requests and then jump to the real instruction 15416 * handler. Unlike the Arm handler, we can't do this as a tail call 15417 * because rIBASE is caller save and we need to reload it. 15418 */ 15419 movl rSELF, %eax 15420 movl rPC, OUT_ARG0(%esp) 15421 movl %eax, OUT_ARG1(%esp) 15422 call dvmCheckInst # (dPC, self) 15423 movl rSELF, %ecx 15424 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15425 jmp *dvmAsmInstructionStart+(233*4) 15426 15427/* ------------------------------ */ 15428.L_ALT_OP_SGET_WIDE_VOLATILE: /* 0xea */ 15429/* File: x86/alt_stub.S */ 15430/* 15431 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15432 * any interesting requests and then jump to the real instruction 15433 * handler. Unlike the Arm handler, we can't do this as a tail call 15434 * because rIBASE is caller save and we need to reload it. 15435 */ 15436 movl rSELF, %eax 15437 movl rPC, OUT_ARG0(%esp) 15438 movl %eax, OUT_ARG1(%esp) 15439 call dvmCheckInst # (dPC, self) 15440 movl rSELF, %ecx 15441 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15442 jmp *dvmAsmInstructionStart+(234*4) 15443 15444/* ------------------------------ */ 15445.L_ALT_OP_SPUT_WIDE_VOLATILE: /* 0xeb */ 15446/* File: x86/alt_stub.S */ 15447/* 15448 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15449 * any interesting requests and then jump to the real instruction 15450 * handler. Unlike the Arm handler, we can't do this as a tail call 15451 * because rIBASE is caller save and we need to reload it. 15452 */ 15453 movl rSELF, %eax 15454 movl rPC, OUT_ARG0(%esp) 15455 movl %eax, OUT_ARG1(%esp) 15456 call dvmCheckInst # (dPC, self) 15457 movl rSELF, %ecx 15458 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15459 jmp *dvmAsmInstructionStart+(235*4) 15460 15461/* ------------------------------ */ 15462.L_ALT_OP_BREAKPOINT: /* 0xec */ 15463/* File: x86/alt_stub.S */ 15464/* 15465 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15466 * any interesting requests and then jump to the real instruction 15467 * handler. Unlike the Arm handler, we can't do this as a tail call 15468 * because rIBASE is caller save and we need to reload it. 15469 */ 15470 movl rSELF, %eax 15471 movl rPC, OUT_ARG0(%esp) 15472 movl %eax, OUT_ARG1(%esp) 15473 call dvmCheckInst # (dPC, self) 15474 movl rSELF, %ecx 15475 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15476 jmp *dvmAsmInstructionStart+(236*4) 15477 15478/* ------------------------------ */ 15479.L_ALT_OP_THROW_VERIFICATION_ERROR: /* 0xed */ 15480/* File: x86/alt_stub.S */ 15481/* 15482 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15483 * any interesting requests and then jump to the real instruction 15484 * handler. Unlike the Arm handler, we can't do this as a tail call 15485 * because rIBASE is caller save and we need to reload it. 15486 */ 15487 movl rSELF, %eax 15488 movl rPC, OUT_ARG0(%esp) 15489 movl %eax, OUT_ARG1(%esp) 15490 call dvmCheckInst # (dPC, self) 15491 movl rSELF, %ecx 15492 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15493 jmp *dvmAsmInstructionStart+(237*4) 15494 15495/* ------------------------------ */ 15496.L_ALT_OP_EXECUTE_INLINE: /* 0xee */ 15497/* File: x86/alt_stub.S */ 15498/* 15499 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15500 * any interesting requests and then jump to the real instruction 15501 * handler. Unlike the Arm handler, we can't do this as a tail call 15502 * because rIBASE is caller save and we need to reload it. 15503 */ 15504 movl rSELF, %eax 15505 movl rPC, OUT_ARG0(%esp) 15506 movl %eax, OUT_ARG1(%esp) 15507 call dvmCheckInst # (dPC, self) 15508 movl rSELF, %ecx 15509 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15510 jmp *dvmAsmInstructionStart+(238*4) 15511 15512/* ------------------------------ */ 15513.L_ALT_OP_EXECUTE_INLINE_RANGE: /* 0xef */ 15514/* File: x86/alt_stub.S */ 15515/* 15516 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15517 * any interesting requests and then jump to the real instruction 15518 * handler. Unlike the Arm handler, we can't do this as a tail call 15519 * because rIBASE is caller save and we need to reload it. 15520 */ 15521 movl rSELF, %eax 15522 movl rPC, OUT_ARG0(%esp) 15523 movl %eax, OUT_ARG1(%esp) 15524 call dvmCheckInst # (dPC, self) 15525 movl rSELF, %ecx 15526 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15527 jmp *dvmAsmInstructionStart+(239*4) 15528 15529/* ------------------------------ */ 15530.L_ALT_OP_INVOKE_OBJECT_INIT_RANGE: /* 0xf0 */ 15531/* File: x86/alt_stub.S */ 15532/* 15533 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15534 * any interesting requests and then jump to the real instruction 15535 * handler. Unlike the Arm handler, we can't do this as a tail call 15536 * because rIBASE is caller save and we need to reload it. 15537 */ 15538 movl rSELF, %eax 15539 movl rPC, OUT_ARG0(%esp) 15540 movl %eax, OUT_ARG1(%esp) 15541 call dvmCheckInst # (dPC, self) 15542 movl rSELF, %ecx 15543 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15544 jmp *dvmAsmInstructionStart+(240*4) 15545 15546/* ------------------------------ */ 15547.L_ALT_OP_RETURN_VOID_BARRIER: /* 0xf1 */ 15548/* File: x86/alt_stub.S */ 15549/* 15550 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15551 * any interesting requests and then jump to the real instruction 15552 * handler. Unlike the Arm handler, we can't do this as a tail call 15553 * because rIBASE is caller save and we need to reload it. 15554 */ 15555 movl rSELF, %eax 15556 movl rPC, OUT_ARG0(%esp) 15557 movl %eax, OUT_ARG1(%esp) 15558 call dvmCheckInst # (dPC, self) 15559 movl rSELF, %ecx 15560 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15561 jmp *dvmAsmInstructionStart+(241*4) 15562 15563/* ------------------------------ */ 15564.L_ALT_OP_IGET_QUICK: /* 0xf2 */ 15565/* File: x86/alt_stub.S */ 15566/* 15567 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15568 * any interesting requests and then jump to the real instruction 15569 * handler. Unlike the Arm handler, we can't do this as a tail call 15570 * because rIBASE is caller save and we need to reload it. 15571 */ 15572 movl rSELF, %eax 15573 movl rPC, OUT_ARG0(%esp) 15574 movl %eax, OUT_ARG1(%esp) 15575 call dvmCheckInst # (dPC, self) 15576 movl rSELF, %ecx 15577 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15578 jmp *dvmAsmInstructionStart+(242*4) 15579 15580/* ------------------------------ */ 15581.L_ALT_OP_IGET_WIDE_QUICK: /* 0xf3 */ 15582/* File: x86/alt_stub.S */ 15583/* 15584 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15585 * any interesting requests and then jump to the real instruction 15586 * handler. Unlike the Arm handler, we can't do this as a tail call 15587 * because rIBASE is caller save and we need to reload it. 15588 */ 15589 movl rSELF, %eax 15590 movl rPC, OUT_ARG0(%esp) 15591 movl %eax, OUT_ARG1(%esp) 15592 call dvmCheckInst # (dPC, self) 15593 movl rSELF, %ecx 15594 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15595 jmp *dvmAsmInstructionStart+(243*4) 15596 15597/* ------------------------------ */ 15598.L_ALT_OP_IGET_OBJECT_QUICK: /* 0xf4 */ 15599/* File: x86/alt_stub.S */ 15600/* 15601 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15602 * any interesting requests and then jump to the real instruction 15603 * handler. Unlike the Arm handler, we can't do this as a tail call 15604 * because rIBASE is caller save and we need to reload it. 15605 */ 15606 movl rSELF, %eax 15607 movl rPC, OUT_ARG0(%esp) 15608 movl %eax, OUT_ARG1(%esp) 15609 call dvmCheckInst # (dPC, self) 15610 movl rSELF, %ecx 15611 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15612 jmp *dvmAsmInstructionStart+(244*4) 15613 15614/* ------------------------------ */ 15615.L_ALT_OP_IPUT_QUICK: /* 0xf5 */ 15616/* File: x86/alt_stub.S */ 15617/* 15618 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15619 * any interesting requests and then jump to the real instruction 15620 * handler. Unlike the Arm handler, we can't do this as a tail call 15621 * because rIBASE is caller save and we need to reload it. 15622 */ 15623 movl rSELF, %eax 15624 movl rPC, OUT_ARG0(%esp) 15625 movl %eax, OUT_ARG1(%esp) 15626 call dvmCheckInst # (dPC, self) 15627 movl rSELF, %ecx 15628 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15629 jmp *dvmAsmInstructionStart+(245*4) 15630 15631/* ------------------------------ */ 15632.L_ALT_OP_IPUT_WIDE_QUICK: /* 0xf6 */ 15633/* File: x86/alt_stub.S */ 15634/* 15635 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15636 * any interesting requests and then jump to the real instruction 15637 * handler. Unlike the Arm handler, we can't do this as a tail call 15638 * because rIBASE is caller save and we need to reload it. 15639 */ 15640 movl rSELF, %eax 15641 movl rPC, OUT_ARG0(%esp) 15642 movl %eax, OUT_ARG1(%esp) 15643 call dvmCheckInst # (dPC, self) 15644 movl rSELF, %ecx 15645 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15646 jmp *dvmAsmInstructionStart+(246*4) 15647 15648/* ------------------------------ */ 15649.L_ALT_OP_IPUT_OBJECT_QUICK: /* 0xf7 */ 15650/* File: x86/alt_stub.S */ 15651/* 15652 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15653 * any interesting requests and then jump to the real instruction 15654 * handler. Unlike the Arm handler, we can't do this as a tail call 15655 * because rIBASE is caller save and we need to reload it. 15656 */ 15657 movl rSELF, %eax 15658 movl rPC, OUT_ARG0(%esp) 15659 movl %eax, OUT_ARG1(%esp) 15660 call dvmCheckInst # (dPC, self) 15661 movl rSELF, %ecx 15662 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15663 jmp *dvmAsmInstructionStart+(247*4) 15664 15665/* ------------------------------ */ 15666.L_ALT_OP_INVOKE_VIRTUAL_QUICK: /* 0xf8 */ 15667/* File: x86/alt_stub.S */ 15668/* 15669 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15670 * any interesting requests and then jump to the real instruction 15671 * handler. Unlike the Arm handler, we can't do this as a tail call 15672 * because rIBASE is caller save and we need to reload it. 15673 */ 15674 movl rSELF, %eax 15675 movl rPC, OUT_ARG0(%esp) 15676 movl %eax, OUT_ARG1(%esp) 15677 call dvmCheckInst # (dPC, self) 15678 movl rSELF, %ecx 15679 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15680 jmp *dvmAsmInstructionStart+(248*4) 15681 15682/* ------------------------------ */ 15683.L_ALT_OP_INVOKE_VIRTUAL_QUICK_RANGE: /* 0xf9 */ 15684/* File: x86/alt_stub.S */ 15685/* 15686 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15687 * any interesting requests and then jump to the real instruction 15688 * handler. Unlike the Arm handler, we can't do this as a tail call 15689 * because rIBASE is caller save and we need to reload it. 15690 */ 15691 movl rSELF, %eax 15692 movl rPC, OUT_ARG0(%esp) 15693 movl %eax, OUT_ARG1(%esp) 15694 call dvmCheckInst # (dPC, self) 15695 movl rSELF, %ecx 15696 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15697 jmp *dvmAsmInstructionStart+(249*4) 15698 15699/* ------------------------------ */ 15700.L_ALT_OP_INVOKE_SUPER_QUICK: /* 0xfa */ 15701/* File: x86/alt_stub.S */ 15702/* 15703 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15704 * any interesting requests and then jump to the real instruction 15705 * handler. Unlike the Arm handler, we can't do this as a tail call 15706 * because rIBASE is caller save and we need to reload it. 15707 */ 15708 movl rSELF, %eax 15709 movl rPC, OUT_ARG0(%esp) 15710 movl %eax, OUT_ARG1(%esp) 15711 call dvmCheckInst # (dPC, self) 15712 movl rSELF, %ecx 15713 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15714 jmp *dvmAsmInstructionStart+(250*4) 15715 15716/* ------------------------------ */ 15717.L_ALT_OP_INVOKE_SUPER_QUICK_RANGE: /* 0xfb */ 15718/* File: x86/alt_stub.S */ 15719/* 15720 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15721 * any interesting requests and then jump to the real instruction 15722 * handler. Unlike the Arm handler, we can't do this as a tail call 15723 * because rIBASE is caller save and we need to reload it. 15724 */ 15725 movl rSELF, %eax 15726 movl rPC, OUT_ARG0(%esp) 15727 movl %eax, OUT_ARG1(%esp) 15728 call dvmCheckInst # (dPC, self) 15729 movl rSELF, %ecx 15730 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15731 jmp *dvmAsmInstructionStart+(251*4) 15732 15733/* ------------------------------ */ 15734.L_ALT_OP_IPUT_OBJECT_VOLATILE: /* 0xfc */ 15735/* File: x86/alt_stub.S */ 15736/* 15737 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15738 * any interesting requests and then jump to the real instruction 15739 * handler. Unlike the Arm handler, we can't do this as a tail call 15740 * because rIBASE is caller save and we need to reload it. 15741 */ 15742 movl rSELF, %eax 15743 movl rPC, OUT_ARG0(%esp) 15744 movl %eax, OUT_ARG1(%esp) 15745 call dvmCheckInst # (dPC, self) 15746 movl rSELF, %ecx 15747 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15748 jmp *dvmAsmInstructionStart+(252*4) 15749 15750/* ------------------------------ */ 15751.L_ALT_OP_SGET_OBJECT_VOLATILE: /* 0xfd */ 15752/* File: x86/alt_stub.S */ 15753/* 15754 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15755 * any interesting requests and then jump to the real instruction 15756 * handler. Unlike the Arm handler, we can't do this as a tail call 15757 * because rIBASE is caller save and we need to reload it. 15758 */ 15759 movl rSELF, %eax 15760 movl rPC, OUT_ARG0(%esp) 15761 movl %eax, OUT_ARG1(%esp) 15762 call dvmCheckInst # (dPC, self) 15763 movl rSELF, %ecx 15764 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15765 jmp *dvmAsmInstructionStart+(253*4) 15766 15767/* ------------------------------ */ 15768.L_ALT_OP_SPUT_OBJECT_VOLATILE: /* 0xfe */ 15769/* File: x86/alt_stub.S */ 15770/* 15771 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15772 * any interesting requests and then jump to the real instruction 15773 * handler. Unlike the Arm handler, we can't do this as a tail call 15774 * because rIBASE is caller save and we need to reload it. 15775 */ 15776 movl rSELF, %eax 15777 movl rPC, OUT_ARG0(%esp) 15778 movl %eax, OUT_ARG1(%esp) 15779 call dvmCheckInst # (dPC, self) 15780 movl rSELF, %ecx 15781 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15782 jmp *dvmAsmInstructionStart+(254*4) 15783 15784/* ------------------------------ */ 15785.L_ALT_OP_DISPATCH_FF: /* 0xff */ 15786/* File: x86/alt_stub.S */ 15787/* 15788 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15789 * any interesting requests and then jump to the real instruction 15790 * handler. Unlike the Arm handler, we can't do this as a tail call 15791 * because rIBASE is caller save and we need to reload it. 15792 */ 15793 movl rSELF, %eax 15794 movl rPC, OUT_ARG0(%esp) 15795 movl %eax, OUT_ARG1(%esp) 15796 call dvmCheckInst # (dPC, self) 15797 movl rSELF, %ecx 15798 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15799 jmp *dvmAsmInstructionStart+(255*4) 15800 15801/* ------------------------------ */ 15802.L_ALT_OP_CONST_CLASS_JUMBO: /* 0x100 */ 15803/* File: x86/alt_stub.S */ 15804/* 15805 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15806 * any interesting requests and then jump to the real instruction 15807 * handler. Unlike the Arm handler, we can't do this as a tail call 15808 * because rIBASE is caller save and we need to reload it. 15809 */ 15810 movl rSELF, %eax 15811 movl rPC, OUT_ARG0(%esp) 15812 movl %eax, OUT_ARG1(%esp) 15813 call dvmCheckInst # (dPC, self) 15814 movl rSELF, %ecx 15815 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15816 jmp *dvmAsmInstructionStart+(256*4) 15817 15818/* ------------------------------ */ 15819.L_ALT_OP_CHECK_CAST_JUMBO: /* 0x101 */ 15820/* File: x86/alt_stub.S */ 15821/* 15822 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15823 * any interesting requests and then jump to the real instruction 15824 * handler. Unlike the Arm handler, we can't do this as a tail call 15825 * because rIBASE is caller save and we need to reload it. 15826 */ 15827 movl rSELF, %eax 15828 movl rPC, OUT_ARG0(%esp) 15829 movl %eax, OUT_ARG1(%esp) 15830 call dvmCheckInst # (dPC, self) 15831 movl rSELF, %ecx 15832 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15833 jmp *dvmAsmInstructionStart+(257*4) 15834 15835/* ------------------------------ */ 15836.L_ALT_OP_INSTANCE_OF_JUMBO: /* 0x102 */ 15837/* File: x86/alt_stub.S */ 15838/* 15839 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15840 * any interesting requests and then jump to the real instruction 15841 * handler. Unlike the Arm handler, we can't do this as a tail call 15842 * because rIBASE is caller save and we need to reload it. 15843 */ 15844 movl rSELF, %eax 15845 movl rPC, OUT_ARG0(%esp) 15846 movl %eax, OUT_ARG1(%esp) 15847 call dvmCheckInst # (dPC, self) 15848 movl rSELF, %ecx 15849 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15850 jmp *dvmAsmInstructionStart+(258*4) 15851 15852/* ------------------------------ */ 15853.L_ALT_OP_NEW_INSTANCE_JUMBO: /* 0x103 */ 15854/* File: x86/alt_stub.S */ 15855/* 15856 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15857 * any interesting requests and then jump to the real instruction 15858 * handler. Unlike the Arm handler, we can't do this as a tail call 15859 * because rIBASE is caller save and we need to reload it. 15860 */ 15861 movl rSELF, %eax 15862 movl rPC, OUT_ARG0(%esp) 15863 movl %eax, OUT_ARG1(%esp) 15864 call dvmCheckInst # (dPC, self) 15865 movl rSELF, %ecx 15866 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15867 jmp *dvmAsmInstructionStart+(259*4) 15868 15869/* ------------------------------ */ 15870.L_ALT_OP_NEW_ARRAY_JUMBO: /* 0x104 */ 15871/* File: x86/alt_stub.S */ 15872/* 15873 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15874 * any interesting requests and then jump to the real instruction 15875 * handler. Unlike the Arm handler, we can't do this as a tail call 15876 * because rIBASE is caller save and we need to reload it. 15877 */ 15878 movl rSELF, %eax 15879 movl rPC, OUT_ARG0(%esp) 15880 movl %eax, OUT_ARG1(%esp) 15881 call dvmCheckInst # (dPC, self) 15882 movl rSELF, %ecx 15883 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15884 jmp *dvmAsmInstructionStart+(260*4) 15885 15886/* ------------------------------ */ 15887.L_ALT_OP_FILLED_NEW_ARRAY_JUMBO: /* 0x105 */ 15888/* File: x86/alt_stub.S */ 15889/* 15890 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15891 * any interesting requests and then jump to the real instruction 15892 * handler. Unlike the Arm handler, we can't do this as a tail call 15893 * because rIBASE is caller save and we need to reload it. 15894 */ 15895 movl rSELF, %eax 15896 movl rPC, OUT_ARG0(%esp) 15897 movl %eax, OUT_ARG1(%esp) 15898 call dvmCheckInst # (dPC, self) 15899 movl rSELF, %ecx 15900 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15901 jmp *dvmAsmInstructionStart+(261*4) 15902 15903/* ------------------------------ */ 15904.L_ALT_OP_IGET_JUMBO: /* 0x106 */ 15905/* File: x86/alt_stub.S */ 15906/* 15907 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15908 * any interesting requests and then jump to the real instruction 15909 * handler. Unlike the Arm handler, we can't do this as a tail call 15910 * because rIBASE is caller save and we need to reload it. 15911 */ 15912 movl rSELF, %eax 15913 movl rPC, OUT_ARG0(%esp) 15914 movl %eax, OUT_ARG1(%esp) 15915 call dvmCheckInst # (dPC, self) 15916 movl rSELF, %ecx 15917 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15918 jmp *dvmAsmInstructionStart+(262*4) 15919 15920/* ------------------------------ */ 15921.L_ALT_OP_IGET_WIDE_JUMBO: /* 0x107 */ 15922/* File: x86/alt_stub.S */ 15923/* 15924 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15925 * any interesting requests and then jump to the real instruction 15926 * handler. Unlike the Arm handler, we can't do this as a tail call 15927 * because rIBASE is caller save and we need to reload it. 15928 */ 15929 movl rSELF, %eax 15930 movl rPC, OUT_ARG0(%esp) 15931 movl %eax, OUT_ARG1(%esp) 15932 call dvmCheckInst # (dPC, self) 15933 movl rSELF, %ecx 15934 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15935 jmp *dvmAsmInstructionStart+(263*4) 15936 15937/* ------------------------------ */ 15938.L_ALT_OP_IGET_OBJECT_JUMBO: /* 0x108 */ 15939/* File: x86/alt_stub.S */ 15940/* 15941 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15942 * any interesting requests and then jump to the real instruction 15943 * handler. Unlike the Arm handler, we can't do this as a tail call 15944 * because rIBASE is caller save and we need to reload it. 15945 */ 15946 movl rSELF, %eax 15947 movl rPC, OUT_ARG0(%esp) 15948 movl %eax, OUT_ARG1(%esp) 15949 call dvmCheckInst # (dPC, self) 15950 movl rSELF, %ecx 15951 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15952 jmp *dvmAsmInstructionStart+(264*4) 15953 15954/* ------------------------------ */ 15955.L_ALT_OP_IGET_BOOLEAN_JUMBO: /* 0x109 */ 15956/* File: x86/alt_stub.S */ 15957/* 15958 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15959 * any interesting requests and then jump to the real instruction 15960 * handler. Unlike the Arm handler, we can't do this as a tail call 15961 * because rIBASE is caller save and we need to reload it. 15962 */ 15963 movl rSELF, %eax 15964 movl rPC, OUT_ARG0(%esp) 15965 movl %eax, OUT_ARG1(%esp) 15966 call dvmCheckInst # (dPC, self) 15967 movl rSELF, %ecx 15968 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15969 jmp *dvmAsmInstructionStart+(265*4) 15970 15971/* ------------------------------ */ 15972.L_ALT_OP_IGET_BYTE_JUMBO: /* 0x10a */ 15973/* File: x86/alt_stub.S */ 15974/* 15975 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15976 * any interesting requests and then jump to the real instruction 15977 * handler. Unlike the Arm handler, we can't do this as a tail call 15978 * because rIBASE is caller save and we need to reload it. 15979 */ 15980 movl rSELF, %eax 15981 movl rPC, OUT_ARG0(%esp) 15982 movl %eax, OUT_ARG1(%esp) 15983 call dvmCheckInst # (dPC, self) 15984 movl rSELF, %ecx 15985 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15986 jmp *dvmAsmInstructionStart+(266*4) 15987 15988/* ------------------------------ */ 15989.L_ALT_OP_IGET_CHAR_JUMBO: /* 0x10b */ 15990/* File: x86/alt_stub.S */ 15991/* 15992 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15993 * any interesting requests and then jump to the real instruction 15994 * handler. Unlike the Arm handler, we can't do this as a tail call 15995 * because rIBASE is caller save and we need to reload it. 15996 */ 15997 movl rSELF, %eax 15998 movl rPC, OUT_ARG0(%esp) 15999 movl %eax, OUT_ARG1(%esp) 16000 call dvmCheckInst # (dPC, self) 16001 movl rSELF, %ecx 16002 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16003 jmp *dvmAsmInstructionStart+(267*4) 16004 16005/* ------------------------------ */ 16006.L_ALT_OP_IGET_SHORT_JUMBO: /* 0x10c */ 16007/* File: x86/alt_stub.S */ 16008/* 16009 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16010 * any interesting requests and then jump to the real instruction 16011 * handler. Unlike the Arm handler, we can't do this as a tail call 16012 * because rIBASE is caller save and we need to reload it. 16013 */ 16014 movl rSELF, %eax 16015 movl rPC, OUT_ARG0(%esp) 16016 movl %eax, OUT_ARG1(%esp) 16017 call dvmCheckInst # (dPC, self) 16018 movl rSELF, %ecx 16019 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16020 jmp *dvmAsmInstructionStart+(268*4) 16021 16022/* ------------------------------ */ 16023.L_ALT_OP_IPUT_JUMBO: /* 0x10d */ 16024/* File: x86/alt_stub.S */ 16025/* 16026 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16027 * any interesting requests and then jump to the real instruction 16028 * handler. Unlike the Arm handler, we can't do this as a tail call 16029 * because rIBASE is caller save and we need to reload it. 16030 */ 16031 movl rSELF, %eax 16032 movl rPC, OUT_ARG0(%esp) 16033 movl %eax, OUT_ARG1(%esp) 16034 call dvmCheckInst # (dPC, self) 16035 movl rSELF, %ecx 16036 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16037 jmp *dvmAsmInstructionStart+(269*4) 16038 16039/* ------------------------------ */ 16040.L_ALT_OP_IPUT_WIDE_JUMBO: /* 0x10e */ 16041/* File: x86/alt_stub.S */ 16042/* 16043 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16044 * any interesting requests and then jump to the real instruction 16045 * handler. Unlike the Arm handler, we can't do this as a tail call 16046 * because rIBASE is caller save and we need to reload it. 16047 */ 16048 movl rSELF, %eax 16049 movl rPC, OUT_ARG0(%esp) 16050 movl %eax, OUT_ARG1(%esp) 16051 call dvmCheckInst # (dPC, self) 16052 movl rSELF, %ecx 16053 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16054 jmp *dvmAsmInstructionStart+(270*4) 16055 16056/* ------------------------------ */ 16057.L_ALT_OP_IPUT_OBJECT_JUMBO: /* 0x10f */ 16058/* File: x86/alt_stub.S */ 16059/* 16060 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16061 * any interesting requests and then jump to the real instruction 16062 * handler. Unlike the Arm handler, we can't do this as a tail call 16063 * because rIBASE is caller save and we need to reload it. 16064 */ 16065 movl rSELF, %eax 16066 movl rPC, OUT_ARG0(%esp) 16067 movl %eax, OUT_ARG1(%esp) 16068 call dvmCheckInst # (dPC, self) 16069 movl rSELF, %ecx 16070 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16071 jmp *dvmAsmInstructionStart+(271*4) 16072 16073/* ------------------------------ */ 16074.L_ALT_OP_IPUT_BOOLEAN_JUMBO: /* 0x110 */ 16075/* File: x86/alt_stub.S */ 16076/* 16077 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16078 * any interesting requests and then jump to the real instruction 16079 * handler. Unlike the Arm handler, we can't do this as a tail call 16080 * because rIBASE is caller save and we need to reload it. 16081 */ 16082 movl rSELF, %eax 16083 movl rPC, OUT_ARG0(%esp) 16084 movl %eax, OUT_ARG1(%esp) 16085 call dvmCheckInst # (dPC, self) 16086 movl rSELF, %ecx 16087 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16088 jmp *dvmAsmInstructionStart+(272*4) 16089 16090/* ------------------------------ */ 16091.L_ALT_OP_IPUT_BYTE_JUMBO: /* 0x111 */ 16092/* File: x86/alt_stub.S */ 16093/* 16094 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16095 * any interesting requests and then jump to the real instruction 16096 * handler. Unlike the Arm handler, we can't do this as a tail call 16097 * because rIBASE is caller save and we need to reload it. 16098 */ 16099 movl rSELF, %eax 16100 movl rPC, OUT_ARG0(%esp) 16101 movl %eax, OUT_ARG1(%esp) 16102 call dvmCheckInst # (dPC, self) 16103 movl rSELF, %ecx 16104 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16105 jmp *dvmAsmInstructionStart+(273*4) 16106 16107/* ------------------------------ */ 16108.L_ALT_OP_IPUT_CHAR_JUMBO: /* 0x112 */ 16109/* File: x86/alt_stub.S */ 16110/* 16111 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16112 * any interesting requests and then jump to the real instruction 16113 * handler. Unlike the Arm handler, we can't do this as a tail call 16114 * because rIBASE is caller save and we need to reload it. 16115 */ 16116 movl rSELF, %eax 16117 movl rPC, OUT_ARG0(%esp) 16118 movl %eax, OUT_ARG1(%esp) 16119 call dvmCheckInst # (dPC, self) 16120 movl rSELF, %ecx 16121 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16122 jmp *dvmAsmInstructionStart+(274*4) 16123 16124/* ------------------------------ */ 16125.L_ALT_OP_IPUT_SHORT_JUMBO: /* 0x113 */ 16126/* File: x86/alt_stub.S */ 16127/* 16128 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16129 * any interesting requests and then jump to the real instruction 16130 * handler. Unlike the Arm handler, we can't do this as a tail call 16131 * because rIBASE is caller save and we need to reload it. 16132 */ 16133 movl rSELF, %eax 16134 movl rPC, OUT_ARG0(%esp) 16135 movl %eax, OUT_ARG1(%esp) 16136 call dvmCheckInst # (dPC, self) 16137 movl rSELF, %ecx 16138 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16139 jmp *dvmAsmInstructionStart+(275*4) 16140 16141/* ------------------------------ */ 16142.L_ALT_OP_SGET_JUMBO: /* 0x114 */ 16143/* File: x86/alt_stub.S */ 16144/* 16145 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16146 * any interesting requests and then jump to the real instruction 16147 * handler. Unlike the Arm handler, we can't do this as a tail call 16148 * because rIBASE is caller save and we need to reload it. 16149 */ 16150 movl rSELF, %eax 16151 movl rPC, OUT_ARG0(%esp) 16152 movl %eax, OUT_ARG1(%esp) 16153 call dvmCheckInst # (dPC, self) 16154 movl rSELF, %ecx 16155 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16156 jmp *dvmAsmInstructionStart+(276*4) 16157 16158/* ------------------------------ */ 16159.L_ALT_OP_SGET_WIDE_JUMBO: /* 0x115 */ 16160/* File: x86/alt_stub.S */ 16161/* 16162 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16163 * any interesting requests and then jump to the real instruction 16164 * handler. Unlike the Arm handler, we can't do this as a tail call 16165 * because rIBASE is caller save and we need to reload it. 16166 */ 16167 movl rSELF, %eax 16168 movl rPC, OUT_ARG0(%esp) 16169 movl %eax, OUT_ARG1(%esp) 16170 call dvmCheckInst # (dPC, self) 16171 movl rSELF, %ecx 16172 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16173 jmp *dvmAsmInstructionStart+(277*4) 16174 16175/* ------------------------------ */ 16176.L_ALT_OP_SGET_OBJECT_JUMBO: /* 0x116 */ 16177/* File: x86/alt_stub.S */ 16178/* 16179 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16180 * any interesting requests and then jump to the real instruction 16181 * handler. Unlike the Arm handler, we can't do this as a tail call 16182 * because rIBASE is caller save and we need to reload it. 16183 */ 16184 movl rSELF, %eax 16185 movl rPC, OUT_ARG0(%esp) 16186 movl %eax, OUT_ARG1(%esp) 16187 call dvmCheckInst # (dPC, self) 16188 movl rSELF, %ecx 16189 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16190 jmp *dvmAsmInstructionStart+(278*4) 16191 16192/* ------------------------------ */ 16193.L_ALT_OP_SGET_BOOLEAN_JUMBO: /* 0x117 */ 16194/* File: x86/alt_stub.S */ 16195/* 16196 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16197 * any interesting requests and then jump to the real instruction 16198 * handler. Unlike the Arm handler, we can't do this as a tail call 16199 * because rIBASE is caller save and we need to reload it. 16200 */ 16201 movl rSELF, %eax 16202 movl rPC, OUT_ARG0(%esp) 16203 movl %eax, OUT_ARG1(%esp) 16204 call dvmCheckInst # (dPC, self) 16205 movl rSELF, %ecx 16206 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16207 jmp *dvmAsmInstructionStart+(279*4) 16208 16209/* ------------------------------ */ 16210.L_ALT_OP_SGET_BYTE_JUMBO: /* 0x118 */ 16211/* File: x86/alt_stub.S */ 16212/* 16213 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16214 * any interesting requests and then jump to the real instruction 16215 * handler. Unlike the Arm handler, we can't do this as a tail call 16216 * because rIBASE is caller save and we need to reload it. 16217 */ 16218 movl rSELF, %eax 16219 movl rPC, OUT_ARG0(%esp) 16220 movl %eax, OUT_ARG1(%esp) 16221 call dvmCheckInst # (dPC, self) 16222 movl rSELF, %ecx 16223 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16224 jmp *dvmAsmInstructionStart+(280*4) 16225 16226/* ------------------------------ */ 16227.L_ALT_OP_SGET_CHAR_JUMBO: /* 0x119 */ 16228/* File: x86/alt_stub.S */ 16229/* 16230 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16231 * any interesting requests and then jump to the real instruction 16232 * handler. Unlike the Arm handler, we can't do this as a tail call 16233 * because rIBASE is caller save and we need to reload it. 16234 */ 16235 movl rSELF, %eax 16236 movl rPC, OUT_ARG0(%esp) 16237 movl %eax, OUT_ARG1(%esp) 16238 call dvmCheckInst # (dPC, self) 16239 movl rSELF, %ecx 16240 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16241 jmp *dvmAsmInstructionStart+(281*4) 16242 16243/* ------------------------------ */ 16244.L_ALT_OP_SGET_SHORT_JUMBO: /* 0x11a */ 16245/* File: x86/alt_stub.S */ 16246/* 16247 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16248 * any interesting requests and then jump to the real instruction 16249 * handler. Unlike the Arm handler, we can't do this as a tail call 16250 * because rIBASE is caller save and we need to reload it. 16251 */ 16252 movl rSELF, %eax 16253 movl rPC, OUT_ARG0(%esp) 16254 movl %eax, OUT_ARG1(%esp) 16255 call dvmCheckInst # (dPC, self) 16256 movl rSELF, %ecx 16257 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16258 jmp *dvmAsmInstructionStart+(282*4) 16259 16260/* ------------------------------ */ 16261.L_ALT_OP_SPUT_JUMBO: /* 0x11b */ 16262/* File: x86/alt_stub.S */ 16263/* 16264 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16265 * any interesting requests and then jump to the real instruction 16266 * handler. Unlike the Arm handler, we can't do this as a tail call 16267 * because rIBASE is caller save and we need to reload it. 16268 */ 16269 movl rSELF, %eax 16270 movl rPC, OUT_ARG0(%esp) 16271 movl %eax, OUT_ARG1(%esp) 16272 call dvmCheckInst # (dPC, self) 16273 movl rSELF, %ecx 16274 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16275 jmp *dvmAsmInstructionStart+(283*4) 16276 16277/* ------------------------------ */ 16278.L_ALT_OP_SPUT_WIDE_JUMBO: /* 0x11c */ 16279/* File: x86/alt_stub.S */ 16280/* 16281 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16282 * any interesting requests and then jump to the real instruction 16283 * handler. Unlike the Arm handler, we can't do this as a tail call 16284 * because rIBASE is caller save and we need to reload it. 16285 */ 16286 movl rSELF, %eax 16287 movl rPC, OUT_ARG0(%esp) 16288 movl %eax, OUT_ARG1(%esp) 16289 call dvmCheckInst # (dPC, self) 16290 movl rSELF, %ecx 16291 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16292 jmp *dvmAsmInstructionStart+(284*4) 16293 16294/* ------------------------------ */ 16295.L_ALT_OP_SPUT_OBJECT_JUMBO: /* 0x11d */ 16296/* File: x86/alt_stub.S */ 16297/* 16298 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16299 * any interesting requests and then jump to the real instruction 16300 * handler. Unlike the Arm handler, we can't do this as a tail call 16301 * because rIBASE is caller save and we need to reload it. 16302 */ 16303 movl rSELF, %eax 16304 movl rPC, OUT_ARG0(%esp) 16305 movl %eax, OUT_ARG1(%esp) 16306 call dvmCheckInst # (dPC, self) 16307 movl rSELF, %ecx 16308 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16309 jmp *dvmAsmInstructionStart+(285*4) 16310 16311/* ------------------------------ */ 16312.L_ALT_OP_SPUT_BOOLEAN_JUMBO: /* 0x11e */ 16313/* File: x86/alt_stub.S */ 16314/* 16315 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16316 * any interesting requests and then jump to the real instruction 16317 * handler. Unlike the Arm handler, we can't do this as a tail call 16318 * because rIBASE is caller save and we need to reload it. 16319 */ 16320 movl rSELF, %eax 16321 movl rPC, OUT_ARG0(%esp) 16322 movl %eax, OUT_ARG1(%esp) 16323 call dvmCheckInst # (dPC, self) 16324 movl rSELF, %ecx 16325 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16326 jmp *dvmAsmInstructionStart+(286*4) 16327 16328/* ------------------------------ */ 16329.L_ALT_OP_SPUT_BYTE_JUMBO: /* 0x11f */ 16330/* File: x86/alt_stub.S */ 16331/* 16332 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16333 * any interesting requests and then jump to the real instruction 16334 * handler. Unlike the Arm handler, we can't do this as a tail call 16335 * because rIBASE is caller save and we need to reload it. 16336 */ 16337 movl rSELF, %eax 16338 movl rPC, OUT_ARG0(%esp) 16339 movl %eax, OUT_ARG1(%esp) 16340 call dvmCheckInst # (dPC, self) 16341 movl rSELF, %ecx 16342 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16343 jmp *dvmAsmInstructionStart+(287*4) 16344 16345/* ------------------------------ */ 16346.L_ALT_OP_SPUT_CHAR_JUMBO: /* 0x120 */ 16347/* File: x86/alt_stub.S */ 16348/* 16349 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16350 * any interesting requests and then jump to the real instruction 16351 * handler. Unlike the Arm handler, we can't do this as a tail call 16352 * because rIBASE is caller save and we need to reload it. 16353 */ 16354 movl rSELF, %eax 16355 movl rPC, OUT_ARG0(%esp) 16356 movl %eax, OUT_ARG1(%esp) 16357 call dvmCheckInst # (dPC, self) 16358 movl rSELF, %ecx 16359 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16360 jmp *dvmAsmInstructionStart+(288*4) 16361 16362/* ------------------------------ */ 16363.L_ALT_OP_SPUT_SHORT_JUMBO: /* 0x121 */ 16364/* File: x86/alt_stub.S */ 16365/* 16366 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16367 * any interesting requests and then jump to the real instruction 16368 * handler. Unlike the Arm handler, we can't do this as a tail call 16369 * because rIBASE is caller save and we need to reload it. 16370 */ 16371 movl rSELF, %eax 16372 movl rPC, OUT_ARG0(%esp) 16373 movl %eax, OUT_ARG1(%esp) 16374 call dvmCheckInst # (dPC, self) 16375 movl rSELF, %ecx 16376 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16377 jmp *dvmAsmInstructionStart+(289*4) 16378 16379/* ------------------------------ */ 16380.L_ALT_OP_INVOKE_VIRTUAL_JUMBO: /* 0x122 */ 16381/* File: x86/alt_stub.S */ 16382/* 16383 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16384 * any interesting requests and then jump to the real instruction 16385 * handler. Unlike the Arm handler, we can't do this as a tail call 16386 * because rIBASE is caller save and we need to reload it. 16387 */ 16388 movl rSELF, %eax 16389 movl rPC, OUT_ARG0(%esp) 16390 movl %eax, OUT_ARG1(%esp) 16391 call dvmCheckInst # (dPC, self) 16392 movl rSELF, %ecx 16393 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16394 jmp *dvmAsmInstructionStart+(290*4) 16395 16396/* ------------------------------ */ 16397.L_ALT_OP_INVOKE_SUPER_JUMBO: /* 0x123 */ 16398/* File: x86/alt_stub.S */ 16399/* 16400 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16401 * any interesting requests and then jump to the real instruction 16402 * handler. Unlike the Arm handler, we can't do this as a tail call 16403 * because rIBASE is caller save and we need to reload it. 16404 */ 16405 movl rSELF, %eax 16406 movl rPC, OUT_ARG0(%esp) 16407 movl %eax, OUT_ARG1(%esp) 16408 call dvmCheckInst # (dPC, self) 16409 movl rSELF, %ecx 16410 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16411 jmp *dvmAsmInstructionStart+(291*4) 16412 16413/* ------------------------------ */ 16414.L_ALT_OP_INVOKE_DIRECT_JUMBO: /* 0x124 */ 16415/* File: x86/alt_stub.S */ 16416/* 16417 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16418 * any interesting requests and then jump to the real instruction 16419 * handler. Unlike the Arm handler, we can't do this as a tail call 16420 * because rIBASE is caller save and we need to reload it. 16421 */ 16422 movl rSELF, %eax 16423 movl rPC, OUT_ARG0(%esp) 16424 movl %eax, OUT_ARG1(%esp) 16425 call dvmCheckInst # (dPC, self) 16426 movl rSELF, %ecx 16427 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16428 jmp *dvmAsmInstructionStart+(292*4) 16429 16430/* ------------------------------ */ 16431.L_ALT_OP_INVOKE_STATIC_JUMBO: /* 0x125 */ 16432/* File: x86/alt_stub.S */ 16433/* 16434 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16435 * any interesting requests and then jump to the real instruction 16436 * handler. Unlike the Arm handler, we can't do this as a tail call 16437 * because rIBASE is caller save and we need to reload it. 16438 */ 16439 movl rSELF, %eax 16440 movl rPC, OUT_ARG0(%esp) 16441 movl %eax, OUT_ARG1(%esp) 16442 call dvmCheckInst # (dPC, self) 16443 movl rSELF, %ecx 16444 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16445 jmp *dvmAsmInstructionStart+(293*4) 16446 16447/* ------------------------------ */ 16448.L_ALT_OP_INVOKE_INTERFACE_JUMBO: /* 0x126 */ 16449/* File: x86/alt_stub.S */ 16450/* 16451 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16452 * any interesting requests and then jump to the real instruction 16453 * handler. Unlike the Arm handler, we can't do this as a tail call 16454 * because rIBASE is caller save and we need to reload it. 16455 */ 16456 movl rSELF, %eax 16457 movl rPC, OUT_ARG0(%esp) 16458 movl %eax, OUT_ARG1(%esp) 16459 call dvmCheckInst # (dPC, self) 16460 movl rSELF, %ecx 16461 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16462 jmp *dvmAsmInstructionStart+(294*4) 16463 16464/* ------------------------------ */ 16465.L_ALT_OP_UNUSED_27FF: /* 0x127 */ 16466/* File: x86/alt_stub.S */ 16467/* 16468 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16469 * any interesting requests and then jump to the real instruction 16470 * handler. Unlike the Arm handler, we can't do this as a tail call 16471 * because rIBASE is caller save and we need to reload it. 16472 */ 16473 movl rSELF, %eax 16474 movl rPC, OUT_ARG0(%esp) 16475 movl %eax, OUT_ARG1(%esp) 16476 call dvmCheckInst # (dPC, self) 16477 movl rSELF, %ecx 16478 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16479 jmp *dvmAsmInstructionStart+(295*4) 16480 16481/* ------------------------------ */ 16482.L_ALT_OP_UNUSED_28FF: /* 0x128 */ 16483/* File: x86/alt_stub.S */ 16484/* 16485 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16486 * any interesting requests and then jump to the real instruction 16487 * handler. Unlike the Arm handler, we can't do this as a tail call 16488 * because rIBASE is caller save and we need to reload it. 16489 */ 16490 movl rSELF, %eax 16491 movl rPC, OUT_ARG0(%esp) 16492 movl %eax, OUT_ARG1(%esp) 16493 call dvmCheckInst # (dPC, self) 16494 movl rSELF, %ecx 16495 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16496 jmp *dvmAsmInstructionStart+(296*4) 16497 16498/* ------------------------------ */ 16499.L_ALT_OP_UNUSED_29FF: /* 0x129 */ 16500/* File: x86/alt_stub.S */ 16501/* 16502 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16503 * any interesting requests and then jump to the real instruction 16504 * handler. Unlike the Arm handler, we can't do this as a tail call 16505 * because rIBASE is caller save and we need to reload it. 16506 */ 16507 movl rSELF, %eax 16508 movl rPC, OUT_ARG0(%esp) 16509 movl %eax, OUT_ARG1(%esp) 16510 call dvmCheckInst # (dPC, self) 16511 movl rSELF, %ecx 16512 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16513 jmp *dvmAsmInstructionStart+(297*4) 16514 16515/* ------------------------------ */ 16516.L_ALT_OP_UNUSED_2AFF: /* 0x12a */ 16517/* File: x86/alt_stub.S */ 16518/* 16519 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16520 * any interesting requests and then jump to the real instruction 16521 * handler. Unlike the Arm handler, we can't do this as a tail call 16522 * because rIBASE is caller save and we need to reload it. 16523 */ 16524 movl rSELF, %eax 16525 movl rPC, OUT_ARG0(%esp) 16526 movl %eax, OUT_ARG1(%esp) 16527 call dvmCheckInst # (dPC, self) 16528 movl rSELF, %ecx 16529 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16530 jmp *dvmAsmInstructionStart+(298*4) 16531 16532/* ------------------------------ */ 16533.L_ALT_OP_UNUSED_2BFF: /* 0x12b */ 16534/* File: x86/alt_stub.S */ 16535/* 16536 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16537 * any interesting requests and then jump to the real instruction 16538 * handler. Unlike the Arm handler, we can't do this as a tail call 16539 * because rIBASE is caller save and we need to reload it. 16540 */ 16541 movl rSELF, %eax 16542 movl rPC, OUT_ARG0(%esp) 16543 movl %eax, OUT_ARG1(%esp) 16544 call dvmCheckInst # (dPC, self) 16545 movl rSELF, %ecx 16546 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16547 jmp *dvmAsmInstructionStart+(299*4) 16548 16549/* ------------------------------ */ 16550.L_ALT_OP_UNUSED_2CFF: /* 0x12c */ 16551/* File: x86/alt_stub.S */ 16552/* 16553 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16554 * any interesting requests and then jump to the real instruction 16555 * handler. Unlike the Arm handler, we can't do this as a tail call 16556 * because rIBASE is caller save and we need to reload it. 16557 */ 16558 movl rSELF, %eax 16559 movl rPC, OUT_ARG0(%esp) 16560 movl %eax, OUT_ARG1(%esp) 16561 call dvmCheckInst # (dPC, self) 16562 movl rSELF, %ecx 16563 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16564 jmp *dvmAsmInstructionStart+(300*4) 16565 16566/* ------------------------------ */ 16567.L_ALT_OP_UNUSED_2DFF: /* 0x12d */ 16568/* File: x86/alt_stub.S */ 16569/* 16570 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16571 * any interesting requests and then jump to the real instruction 16572 * handler. Unlike the Arm handler, we can't do this as a tail call 16573 * because rIBASE is caller save and we need to reload it. 16574 */ 16575 movl rSELF, %eax 16576 movl rPC, OUT_ARG0(%esp) 16577 movl %eax, OUT_ARG1(%esp) 16578 call dvmCheckInst # (dPC, self) 16579 movl rSELF, %ecx 16580 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16581 jmp *dvmAsmInstructionStart+(301*4) 16582 16583/* ------------------------------ */ 16584.L_ALT_OP_UNUSED_2EFF: /* 0x12e */ 16585/* File: x86/alt_stub.S */ 16586/* 16587 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16588 * any interesting requests and then jump to the real instruction 16589 * handler. Unlike the Arm handler, we can't do this as a tail call 16590 * because rIBASE is caller save and we need to reload it. 16591 */ 16592 movl rSELF, %eax 16593 movl rPC, OUT_ARG0(%esp) 16594 movl %eax, OUT_ARG1(%esp) 16595 call dvmCheckInst # (dPC, self) 16596 movl rSELF, %ecx 16597 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16598 jmp *dvmAsmInstructionStart+(302*4) 16599 16600/* ------------------------------ */ 16601.L_ALT_OP_UNUSED_2FFF: /* 0x12f */ 16602/* File: x86/alt_stub.S */ 16603/* 16604 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16605 * any interesting requests and then jump to the real instruction 16606 * handler. Unlike the Arm handler, we can't do this as a tail call 16607 * because rIBASE is caller save and we need to reload it. 16608 */ 16609 movl rSELF, %eax 16610 movl rPC, OUT_ARG0(%esp) 16611 movl %eax, OUT_ARG1(%esp) 16612 call dvmCheckInst # (dPC, self) 16613 movl rSELF, %ecx 16614 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16615 jmp *dvmAsmInstructionStart+(303*4) 16616 16617/* ------------------------------ */ 16618.L_ALT_OP_UNUSED_30FF: /* 0x130 */ 16619/* File: x86/alt_stub.S */ 16620/* 16621 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16622 * any interesting requests and then jump to the real instruction 16623 * handler. Unlike the Arm handler, we can't do this as a tail call 16624 * because rIBASE is caller save and we need to reload it. 16625 */ 16626 movl rSELF, %eax 16627 movl rPC, OUT_ARG0(%esp) 16628 movl %eax, OUT_ARG1(%esp) 16629 call dvmCheckInst # (dPC, self) 16630 movl rSELF, %ecx 16631 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16632 jmp *dvmAsmInstructionStart+(304*4) 16633 16634/* ------------------------------ */ 16635.L_ALT_OP_UNUSED_31FF: /* 0x131 */ 16636/* File: x86/alt_stub.S */ 16637/* 16638 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16639 * any interesting requests and then jump to the real instruction 16640 * handler. Unlike the Arm handler, we can't do this as a tail call 16641 * because rIBASE is caller save and we need to reload it. 16642 */ 16643 movl rSELF, %eax 16644 movl rPC, OUT_ARG0(%esp) 16645 movl %eax, OUT_ARG1(%esp) 16646 call dvmCheckInst # (dPC, self) 16647 movl rSELF, %ecx 16648 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16649 jmp *dvmAsmInstructionStart+(305*4) 16650 16651/* ------------------------------ */ 16652.L_ALT_OP_UNUSED_32FF: /* 0x132 */ 16653/* File: x86/alt_stub.S */ 16654/* 16655 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16656 * any interesting requests and then jump to the real instruction 16657 * handler. Unlike the Arm handler, we can't do this as a tail call 16658 * because rIBASE is caller save and we need to reload it. 16659 */ 16660 movl rSELF, %eax 16661 movl rPC, OUT_ARG0(%esp) 16662 movl %eax, OUT_ARG1(%esp) 16663 call dvmCheckInst # (dPC, self) 16664 movl rSELF, %ecx 16665 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16666 jmp *dvmAsmInstructionStart+(306*4) 16667 16668/* ------------------------------ */ 16669.L_ALT_OP_UNUSED_33FF: /* 0x133 */ 16670/* File: x86/alt_stub.S */ 16671/* 16672 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16673 * any interesting requests and then jump to the real instruction 16674 * handler. Unlike the Arm handler, we can't do this as a tail call 16675 * because rIBASE is caller save and we need to reload it. 16676 */ 16677 movl rSELF, %eax 16678 movl rPC, OUT_ARG0(%esp) 16679 movl %eax, OUT_ARG1(%esp) 16680 call dvmCheckInst # (dPC, self) 16681 movl rSELF, %ecx 16682 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16683 jmp *dvmAsmInstructionStart+(307*4) 16684 16685/* ------------------------------ */ 16686.L_ALT_OP_UNUSED_34FF: /* 0x134 */ 16687/* File: x86/alt_stub.S */ 16688/* 16689 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16690 * any interesting requests and then jump to the real instruction 16691 * handler. Unlike the Arm handler, we can't do this as a tail call 16692 * because rIBASE is caller save and we need to reload it. 16693 */ 16694 movl rSELF, %eax 16695 movl rPC, OUT_ARG0(%esp) 16696 movl %eax, OUT_ARG1(%esp) 16697 call dvmCheckInst # (dPC, self) 16698 movl rSELF, %ecx 16699 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16700 jmp *dvmAsmInstructionStart+(308*4) 16701 16702/* ------------------------------ */ 16703.L_ALT_OP_UNUSED_35FF: /* 0x135 */ 16704/* File: x86/alt_stub.S */ 16705/* 16706 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16707 * any interesting requests and then jump to the real instruction 16708 * handler. Unlike the Arm handler, we can't do this as a tail call 16709 * because rIBASE is caller save and we need to reload it. 16710 */ 16711 movl rSELF, %eax 16712 movl rPC, OUT_ARG0(%esp) 16713 movl %eax, OUT_ARG1(%esp) 16714 call dvmCheckInst # (dPC, self) 16715 movl rSELF, %ecx 16716 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16717 jmp *dvmAsmInstructionStart+(309*4) 16718 16719/* ------------------------------ */ 16720.L_ALT_OP_UNUSED_36FF: /* 0x136 */ 16721/* File: x86/alt_stub.S */ 16722/* 16723 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16724 * any interesting requests and then jump to the real instruction 16725 * handler. Unlike the Arm handler, we can't do this as a tail call 16726 * because rIBASE is caller save and we need to reload it. 16727 */ 16728 movl rSELF, %eax 16729 movl rPC, OUT_ARG0(%esp) 16730 movl %eax, OUT_ARG1(%esp) 16731 call dvmCheckInst # (dPC, self) 16732 movl rSELF, %ecx 16733 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16734 jmp *dvmAsmInstructionStart+(310*4) 16735 16736/* ------------------------------ */ 16737.L_ALT_OP_UNUSED_37FF: /* 0x137 */ 16738/* File: x86/alt_stub.S */ 16739/* 16740 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16741 * any interesting requests and then jump to the real instruction 16742 * handler. Unlike the Arm handler, we can't do this as a tail call 16743 * because rIBASE is caller save and we need to reload it. 16744 */ 16745 movl rSELF, %eax 16746 movl rPC, OUT_ARG0(%esp) 16747 movl %eax, OUT_ARG1(%esp) 16748 call dvmCheckInst # (dPC, self) 16749 movl rSELF, %ecx 16750 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16751 jmp *dvmAsmInstructionStart+(311*4) 16752 16753/* ------------------------------ */ 16754.L_ALT_OP_UNUSED_38FF: /* 0x138 */ 16755/* File: x86/alt_stub.S */ 16756/* 16757 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16758 * any interesting requests and then jump to the real instruction 16759 * handler. Unlike the Arm handler, we can't do this as a tail call 16760 * because rIBASE is caller save and we need to reload it. 16761 */ 16762 movl rSELF, %eax 16763 movl rPC, OUT_ARG0(%esp) 16764 movl %eax, OUT_ARG1(%esp) 16765 call dvmCheckInst # (dPC, self) 16766 movl rSELF, %ecx 16767 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16768 jmp *dvmAsmInstructionStart+(312*4) 16769 16770/* ------------------------------ */ 16771.L_ALT_OP_UNUSED_39FF: /* 0x139 */ 16772/* File: x86/alt_stub.S */ 16773/* 16774 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16775 * any interesting requests and then jump to the real instruction 16776 * handler. Unlike the Arm handler, we can't do this as a tail call 16777 * because rIBASE is caller save and we need to reload it. 16778 */ 16779 movl rSELF, %eax 16780 movl rPC, OUT_ARG0(%esp) 16781 movl %eax, OUT_ARG1(%esp) 16782 call dvmCheckInst # (dPC, self) 16783 movl rSELF, %ecx 16784 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16785 jmp *dvmAsmInstructionStart+(313*4) 16786 16787/* ------------------------------ */ 16788.L_ALT_OP_UNUSED_3AFF: /* 0x13a */ 16789/* File: x86/alt_stub.S */ 16790/* 16791 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16792 * any interesting requests and then jump to the real instruction 16793 * handler. Unlike the Arm handler, we can't do this as a tail call 16794 * because rIBASE is caller save and we need to reload it. 16795 */ 16796 movl rSELF, %eax 16797 movl rPC, OUT_ARG0(%esp) 16798 movl %eax, OUT_ARG1(%esp) 16799 call dvmCheckInst # (dPC, self) 16800 movl rSELF, %ecx 16801 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16802 jmp *dvmAsmInstructionStart+(314*4) 16803 16804/* ------------------------------ */ 16805.L_ALT_OP_UNUSED_3BFF: /* 0x13b */ 16806/* File: x86/alt_stub.S */ 16807/* 16808 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16809 * any interesting requests and then jump to the real instruction 16810 * handler. Unlike the Arm handler, we can't do this as a tail call 16811 * because rIBASE is caller save and we need to reload it. 16812 */ 16813 movl rSELF, %eax 16814 movl rPC, OUT_ARG0(%esp) 16815 movl %eax, OUT_ARG1(%esp) 16816 call dvmCheckInst # (dPC, self) 16817 movl rSELF, %ecx 16818 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16819 jmp *dvmAsmInstructionStart+(315*4) 16820 16821/* ------------------------------ */ 16822.L_ALT_OP_UNUSED_3CFF: /* 0x13c */ 16823/* File: x86/alt_stub.S */ 16824/* 16825 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16826 * any interesting requests and then jump to the real instruction 16827 * handler. Unlike the Arm handler, we can't do this as a tail call 16828 * because rIBASE is caller save and we need to reload it. 16829 */ 16830 movl rSELF, %eax 16831 movl rPC, OUT_ARG0(%esp) 16832 movl %eax, OUT_ARG1(%esp) 16833 call dvmCheckInst # (dPC, self) 16834 movl rSELF, %ecx 16835 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16836 jmp *dvmAsmInstructionStart+(316*4) 16837 16838/* ------------------------------ */ 16839.L_ALT_OP_UNUSED_3DFF: /* 0x13d */ 16840/* File: x86/alt_stub.S */ 16841/* 16842 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16843 * any interesting requests and then jump to the real instruction 16844 * handler. Unlike the Arm handler, we can't do this as a tail call 16845 * because rIBASE is caller save and we need to reload it. 16846 */ 16847 movl rSELF, %eax 16848 movl rPC, OUT_ARG0(%esp) 16849 movl %eax, OUT_ARG1(%esp) 16850 call dvmCheckInst # (dPC, self) 16851 movl rSELF, %ecx 16852 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16853 jmp *dvmAsmInstructionStart+(317*4) 16854 16855/* ------------------------------ */ 16856.L_ALT_OP_UNUSED_3EFF: /* 0x13e */ 16857/* File: x86/alt_stub.S */ 16858/* 16859 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16860 * any interesting requests and then jump to the real instruction 16861 * handler. Unlike the Arm handler, we can't do this as a tail call 16862 * because rIBASE is caller save and we need to reload it. 16863 */ 16864 movl rSELF, %eax 16865 movl rPC, OUT_ARG0(%esp) 16866 movl %eax, OUT_ARG1(%esp) 16867 call dvmCheckInst # (dPC, self) 16868 movl rSELF, %ecx 16869 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16870 jmp *dvmAsmInstructionStart+(318*4) 16871 16872/* ------------------------------ */ 16873.L_ALT_OP_UNUSED_3FFF: /* 0x13f */ 16874/* File: x86/alt_stub.S */ 16875/* 16876 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16877 * any interesting requests and then jump to the real instruction 16878 * handler. Unlike the Arm handler, we can't do this as a tail call 16879 * because rIBASE is caller save and we need to reload it. 16880 */ 16881 movl rSELF, %eax 16882 movl rPC, OUT_ARG0(%esp) 16883 movl %eax, OUT_ARG1(%esp) 16884 call dvmCheckInst # (dPC, self) 16885 movl rSELF, %ecx 16886 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16887 jmp *dvmAsmInstructionStart+(319*4) 16888 16889/* ------------------------------ */ 16890.L_ALT_OP_UNUSED_40FF: /* 0x140 */ 16891/* File: x86/alt_stub.S */ 16892/* 16893 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16894 * any interesting requests and then jump to the real instruction 16895 * handler. Unlike the Arm handler, we can't do this as a tail call 16896 * because rIBASE is caller save and we need to reload it. 16897 */ 16898 movl rSELF, %eax 16899 movl rPC, OUT_ARG0(%esp) 16900 movl %eax, OUT_ARG1(%esp) 16901 call dvmCheckInst # (dPC, self) 16902 movl rSELF, %ecx 16903 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16904 jmp *dvmAsmInstructionStart+(320*4) 16905 16906/* ------------------------------ */ 16907.L_ALT_OP_UNUSED_41FF: /* 0x141 */ 16908/* File: x86/alt_stub.S */ 16909/* 16910 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16911 * any interesting requests and then jump to the real instruction 16912 * handler. Unlike the Arm handler, we can't do this as a tail call 16913 * because rIBASE is caller save and we need to reload it. 16914 */ 16915 movl rSELF, %eax 16916 movl rPC, OUT_ARG0(%esp) 16917 movl %eax, OUT_ARG1(%esp) 16918 call dvmCheckInst # (dPC, self) 16919 movl rSELF, %ecx 16920 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16921 jmp *dvmAsmInstructionStart+(321*4) 16922 16923/* ------------------------------ */ 16924.L_ALT_OP_UNUSED_42FF: /* 0x142 */ 16925/* File: x86/alt_stub.S */ 16926/* 16927 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16928 * any interesting requests and then jump to the real instruction 16929 * handler. Unlike the Arm handler, we can't do this as a tail call 16930 * because rIBASE is caller save and we need to reload it. 16931 */ 16932 movl rSELF, %eax 16933 movl rPC, OUT_ARG0(%esp) 16934 movl %eax, OUT_ARG1(%esp) 16935 call dvmCheckInst # (dPC, self) 16936 movl rSELF, %ecx 16937 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16938 jmp *dvmAsmInstructionStart+(322*4) 16939 16940/* ------------------------------ */ 16941.L_ALT_OP_UNUSED_43FF: /* 0x143 */ 16942/* File: x86/alt_stub.S */ 16943/* 16944 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16945 * any interesting requests and then jump to the real instruction 16946 * handler. Unlike the Arm handler, we can't do this as a tail call 16947 * because rIBASE is caller save and we need to reload it. 16948 */ 16949 movl rSELF, %eax 16950 movl rPC, OUT_ARG0(%esp) 16951 movl %eax, OUT_ARG1(%esp) 16952 call dvmCheckInst # (dPC, self) 16953 movl rSELF, %ecx 16954 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16955 jmp *dvmAsmInstructionStart+(323*4) 16956 16957/* ------------------------------ */ 16958.L_ALT_OP_UNUSED_44FF: /* 0x144 */ 16959/* File: x86/alt_stub.S */ 16960/* 16961 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16962 * any interesting requests and then jump to the real instruction 16963 * handler. Unlike the Arm handler, we can't do this as a tail call 16964 * because rIBASE is caller save and we need to reload it. 16965 */ 16966 movl rSELF, %eax 16967 movl rPC, OUT_ARG0(%esp) 16968 movl %eax, OUT_ARG1(%esp) 16969 call dvmCheckInst # (dPC, self) 16970 movl rSELF, %ecx 16971 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16972 jmp *dvmAsmInstructionStart+(324*4) 16973 16974/* ------------------------------ */ 16975.L_ALT_OP_UNUSED_45FF: /* 0x145 */ 16976/* File: x86/alt_stub.S */ 16977/* 16978 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16979 * any interesting requests and then jump to the real instruction 16980 * handler. Unlike the Arm handler, we can't do this as a tail call 16981 * because rIBASE is caller save and we need to reload it. 16982 */ 16983 movl rSELF, %eax 16984 movl rPC, OUT_ARG0(%esp) 16985 movl %eax, OUT_ARG1(%esp) 16986 call dvmCheckInst # (dPC, self) 16987 movl rSELF, %ecx 16988 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16989 jmp *dvmAsmInstructionStart+(325*4) 16990 16991/* ------------------------------ */ 16992.L_ALT_OP_UNUSED_46FF: /* 0x146 */ 16993/* File: x86/alt_stub.S */ 16994/* 16995 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16996 * any interesting requests and then jump to the real instruction 16997 * handler. Unlike the Arm handler, we can't do this as a tail call 16998 * because rIBASE is caller save and we need to reload it. 16999 */ 17000 movl rSELF, %eax 17001 movl rPC, OUT_ARG0(%esp) 17002 movl %eax, OUT_ARG1(%esp) 17003 call dvmCheckInst # (dPC, self) 17004 movl rSELF, %ecx 17005 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17006 jmp *dvmAsmInstructionStart+(326*4) 17007 17008/* ------------------------------ */ 17009.L_ALT_OP_UNUSED_47FF: /* 0x147 */ 17010/* File: x86/alt_stub.S */ 17011/* 17012 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17013 * any interesting requests and then jump to the real instruction 17014 * handler. Unlike the Arm handler, we can't do this as a tail call 17015 * because rIBASE is caller save and we need to reload it. 17016 */ 17017 movl rSELF, %eax 17018 movl rPC, OUT_ARG0(%esp) 17019 movl %eax, OUT_ARG1(%esp) 17020 call dvmCheckInst # (dPC, self) 17021 movl rSELF, %ecx 17022 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17023 jmp *dvmAsmInstructionStart+(327*4) 17024 17025/* ------------------------------ */ 17026.L_ALT_OP_UNUSED_48FF: /* 0x148 */ 17027/* File: x86/alt_stub.S */ 17028/* 17029 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17030 * any interesting requests and then jump to the real instruction 17031 * handler. Unlike the Arm handler, we can't do this as a tail call 17032 * because rIBASE is caller save and we need to reload it. 17033 */ 17034 movl rSELF, %eax 17035 movl rPC, OUT_ARG0(%esp) 17036 movl %eax, OUT_ARG1(%esp) 17037 call dvmCheckInst # (dPC, self) 17038 movl rSELF, %ecx 17039 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17040 jmp *dvmAsmInstructionStart+(328*4) 17041 17042/* ------------------------------ */ 17043.L_ALT_OP_UNUSED_49FF: /* 0x149 */ 17044/* File: x86/alt_stub.S */ 17045/* 17046 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17047 * any interesting requests and then jump to the real instruction 17048 * handler. Unlike the Arm handler, we can't do this as a tail call 17049 * because rIBASE is caller save and we need to reload it. 17050 */ 17051 movl rSELF, %eax 17052 movl rPC, OUT_ARG0(%esp) 17053 movl %eax, OUT_ARG1(%esp) 17054 call dvmCheckInst # (dPC, self) 17055 movl rSELF, %ecx 17056 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17057 jmp *dvmAsmInstructionStart+(329*4) 17058 17059/* ------------------------------ */ 17060.L_ALT_OP_UNUSED_4AFF: /* 0x14a */ 17061/* File: x86/alt_stub.S */ 17062/* 17063 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17064 * any interesting requests and then jump to the real instruction 17065 * handler. Unlike the Arm handler, we can't do this as a tail call 17066 * because rIBASE is caller save and we need to reload it. 17067 */ 17068 movl rSELF, %eax 17069 movl rPC, OUT_ARG0(%esp) 17070 movl %eax, OUT_ARG1(%esp) 17071 call dvmCheckInst # (dPC, self) 17072 movl rSELF, %ecx 17073 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17074 jmp *dvmAsmInstructionStart+(330*4) 17075 17076/* ------------------------------ */ 17077.L_ALT_OP_UNUSED_4BFF: /* 0x14b */ 17078/* File: x86/alt_stub.S */ 17079/* 17080 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17081 * any interesting requests and then jump to the real instruction 17082 * handler. Unlike the Arm handler, we can't do this as a tail call 17083 * because rIBASE is caller save and we need to reload it. 17084 */ 17085 movl rSELF, %eax 17086 movl rPC, OUT_ARG0(%esp) 17087 movl %eax, OUT_ARG1(%esp) 17088 call dvmCheckInst # (dPC, self) 17089 movl rSELF, %ecx 17090 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17091 jmp *dvmAsmInstructionStart+(331*4) 17092 17093/* ------------------------------ */ 17094.L_ALT_OP_UNUSED_4CFF: /* 0x14c */ 17095/* File: x86/alt_stub.S */ 17096/* 17097 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17098 * any interesting requests and then jump to the real instruction 17099 * handler. Unlike the Arm handler, we can't do this as a tail call 17100 * because rIBASE is caller save and we need to reload it. 17101 */ 17102 movl rSELF, %eax 17103 movl rPC, OUT_ARG0(%esp) 17104 movl %eax, OUT_ARG1(%esp) 17105 call dvmCheckInst # (dPC, self) 17106 movl rSELF, %ecx 17107 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17108 jmp *dvmAsmInstructionStart+(332*4) 17109 17110/* ------------------------------ */ 17111.L_ALT_OP_UNUSED_4DFF: /* 0x14d */ 17112/* File: x86/alt_stub.S */ 17113/* 17114 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17115 * any interesting requests and then jump to the real instruction 17116 * handler. Unlike the Arm handler, we can't do this as a tail call 17117 * because rIBASE is caller save and we need to reload it. 17118 */ 17119 movl rSELF, %eax 17120 movl rPC, OUT_ARG0(%esp) 17121 movl %eax, OUT_ARG1(%esp) 17122 call dvmCheckInst # (dPC, self) 17123 movl rSELF, %ecx 17124 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17125 jmp *dvmAsmInstructionStart+(333*4) 17126 17127/* ------------------------------ */ 17128.L_ALT_OP_UNUSED_4EFF: /* 0x14e */ 17129/* File: x86/alt_stub.S */ 17130/* 17131 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17132 * any interesting requests and then jump to the real instruction 17133 * handler. Unlike the Arm handler, we can't do this as a tail call 17134 * because rIBASE is caller save and we need to reload it. 17135 */ 17136 movl rSELF, %eax 17137 movl rPC, OUT_ARG0(%esp) 17138 movl %eax, OUT_ARG1(%esp) 17139 call dvmCheckInst # (dPC, self) 17140 movl rSELF, %ecx 17141 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17142 jmp *dvmAsmInstructionStart+(334*4) 17143 17144/* ------------------------------ */ 17145.L_ALT_OP_UNUSED_4FFF: /* 0x14f */ 17146/* File: x86/alt_stub.S */ 17147/* 17148 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17149 * any interesting requests and then jump to the real instruction 17150 * handler. Unlike the Arm handler, we can't do this as a tail call 17151 * because rIBASE is caller save and we need to reload it. 17152 */ 17153 movl rSELF, %eax 17154 movl rPC, OUT_ARG0(%esp) 17155 movl %eax, OUT_ARG1(%esp) 17156 call dvmCheckInst # (dPC, self) 17157 movl rSELF, %ecx 17158 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17159 jmp *dvmAsmInstructionStart+(335*4) 17160 17161/* ------------------------------ */ 17162.L_ALT_OP_UNUSED_50FF: /* 0x150 */ 17163/* File: x86/alt_stub.S */ 17164/* 17165 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17166 * any interesting requests and then jump to the real instruction 17167 * handler. Unlike the Arm handler, we can't do this as a tail call 17168 * because rIBASE is caller save and we need to reload it. 17169 */ 17170 movl rSELF, %eax 17171 movl rPC, OUT_ARG0(%esp) 17172 movl %eax, OUT_ARG1(%esp) 17173 call dvmCheckInst # (dPC, self) 17174 movl rSELF, %ecx 17175 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17176 jmp *dvmAsmInstructionStart+(336*4) 17177 17178/* ------------------------------ */ 17179.L_ALT_OP_UNUSED_51FF: /* 0x151 */ 17180/* File: x86/alt_stub.S */ 17181/* 17182 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17183 * any interesting requests and then jump to the real instruction 17184 * handler. Unlike the Arm handler, we can't do this as a tail call 17185 * because rIBASE is caller save and we need to reload it. 17186 */ 17187 movl rSELF, %eax 17188 movl rPC, OUT_ARG0(%esp) 17189 movl %eax, OUT_ARG1(%esp) 17190 call dvmCheckInst # (dPC, self) 17191 movl rSELF, %ecx 17192 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17193 jmp *dvmAsmInstructionStart+(337*4) 17194 17195/* ------------------------------ */ 17196.L_ALT_OP_UNUSED_52FF: /* 0x152 */ 17197/* File: x86/alt_stub.S */ 17198/* 17199 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17200 * any interesting requests and then jump to the real instruction 17201 * handler. Unlike the Arm handler, we can't do this as a tail call 17202 * because rIBASE is caller save and we need to reload it. 17203 */ 17204 movl rSELF, %eax 17205 movl rPC, OUT_ARG0(%esp) 17206 movl %eax, OUT_ARG1(%esp) 17207 call dvmCheckInst # (dPC, self) 17208 movl rSELF, %ecx 17209 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17210 jmp *dvmAsmInstructionStart+(338*4) 17211 17212/* ------------------------------ */ 17213.L_ALT_OP_UNUSED_53FF: /* 0x153 */ 17214/* File: x86/alt_stub.S */ 17215/* 17216 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17217 * any interesting requests and then jump to the real instruction 17218 * handler. Unlike the Arm handler, we can't do this as a tail call 17219 * because rIBASE is caller save and we need to reload it. 17220 */ 17221 movl rSELF, %eax 17222 movl rPC, OUT_ARG0(%esp) 17223 movl %eax, OUT_ARG1(%esp) 17224 call dvmCheckInst # (dPC, self) 17225 movl rSELF, %ecx 17226 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17227 jmp *dvmAsmInstructionStart+(339*4) 17228 17229/* ------------------------------ */ 17230.L_ALT_OP_UNUSED_54FF: /* 0x154 */ 17231/* File: x86/alt_stub.S */ 17232/* 17233 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17234 * any interesting requests and then jump to the real instruction 17235 * handler. Unlike the Arm handler, we can't do this as a tail call 17236 * because rIBASE is caller save and we need to reload it. 17237 */ 17238 movl rSELF, %eax 17239 movl rPC, OUT_ARG0(%esp) 17240 movl %eax, OUT_ARG1(%esp) 17241 call dvmCheckInst # (dPC, self) 17242 movl rSELF, %ecx 17243 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17244 jmp *dvmAsmInstructionStart+(340*4) 17245 17246/* ------------------------------ */ 17247.L_ALT_OP_UNUSED_55FF: /* 0x155 */ 17248/* File: x86/alt_stub.S */ 17249/* 17250 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17251 * any interesting requests and then jump to the real instruction 17252 * handler. Unlike the Arm handler, we can't do this as a tail call 17253 * because rIBASE is caller save and we need to reload it. 17254 */ 17255 movl rSELF, %eax 17256 movl rPC, OUT_ARG0(%esp) 17257 movl %eax, OUT_ARG1(%esp) 17258 call dvmCheckInst # (dPC, self) 17259 movl rSELF, %ecx 17260 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17261 jmp *dvmAsmInstructionStart+(341*4) 17262 17263/* ------------------------------ */ 17264.L_ALT_OP_UNUSED_56FF: /* 0x156 */ 17265/* File: x86/alt_stub.S */ 17266/* 17267 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17268 * any interesting requests and then jump to the real instruction 17269 * handler. Unlike the Arm handler, we can't do this as a tail call 17270 * because rIBASE is caller save and we need to reload it. 17271 */ 17272 movl rSELF, %eax 17273 movl rPC, OUT_ARG0(%esp) 17274 movl %eax, OUT_ARG1(%esp) 17275 call dvmCheckInst # (dPC, self) 17276 movl rSELF, %ecx 17277 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17278 jmp *dvmAsmInstructionStart+(342*4) 17279 17280/* ------------------------------ */ 17281.L_ALT_OP_UNUSED_57FF: /* 0x157 */ 17282/* File: x86/alt_stub.S */ 17283/* 17284 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17285 * any interesting requests and then jump to the real instruction 17286 * handler. Unlike the Arm handler, we can't do this as a tail call 17287 * because rIBASE is caller save and we need to reload it. 17288 */ 17289 movl rSELF, %eax 17290 movl rPC, OUT_ARG0(%esp) 17291 movl %eax, OUT_ARG1(%esp) 17292 call dvmCheckInst # (dPC, self) 17293 movl rSELF, %ecx 17294 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17295 jmp *dvmAsmInstructionStart+(343*4) 17296 17297/* ------------------------------ */ 17298.L_ALT_OP_UNUSED_58FF: /* 0x158 */ 17299/* File: x86/alt_stub.S */ 17300/* 17301 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17302 * any interesting requests and then jump to the real instruction 17303 * handler. Unlike the Arm handler, we can't do this as a tail call 17304 * because rIBASE is caller save and we need to reload it. 17305 */ 17306 movl rSELF, %eax 17307 movl rPC, OUT_ARG0(%esp) 17308 movl %eax, OUT_ARG1(%esp) 17309 call dvmCheckInst # (dPC, self) 17310 movl rSELF, %ecx 17311 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17312 jmp *dvmAsmInstructionStart+(344*4) 17313 17314/* ------------------------------ */ 17315.L_ALT_OP_UNUSED_59FF: /* 0x159 */ 17316/* File: x86/alt_stub.S */ 17317/* 17318 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17319 * any interesting requests and then jump to the real instruction 17320 * handler. Unlike the Arm handler, we can't do this as a tail call 17321 * because rIBASE is caller save and we need to reload it. 17322 */ 17323 movl rSELF, %eax 17324 movl rPC, OUT_ARG0(%esp) 17325 movl %eax, OUT_ARG1(%esp) 17326 call dvmCheckInst # (dPC, self) 17327 movl rSELF, %ecx 17328 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17329 jmp *dvmAsmInstructionStart+(345*4) 17330 17331/* ------------------------------ */ 17332.L_ALT_OP_UNUSED_5AFF: /* 0x15a */ 17333/* File: x86/alt_stub.S */ 17334/* 17335 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17336 * any interesting requests and then jump to the real instruction 17337 * handler. Unlike the Arm handler, we can't do this as a tail call 17338 * because rIBASE is caller save and we need to reload it. 17339 */ 17340 movl rSELF, %eax 17341 movl rPC, OUT_ARG0(%esp) 17342 movl %eax, OUT_ARG1(%esp) 17343 call dvmCheckInst # (dPC, self) 17344 movl rSELF, %ecx 17345 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17346 jmp *dvmAsmInstructionStart+(346*4) 17347 17348/* ------------------------------ */ 17349.L_ALT_OP_UNUSED_5BFF: /* 0x15b */ 17350/* File: x86/alt_stub.S */ 17351/* 17352 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17353 * any interesting requests and then jump to the real instruction 17354 * handler. Unlike the Arm handler, we can't do this as a tail call 17355 * because rIBASE is caller save and we need to reload it. 17356 */ 17357 movl rSELF, %eax 17358 movl rPC, OUT_ARG0(%esp) 17359 movl %eax, OUT_ARG1(%esp) 17360 call dvmCheckInst # (dPC, self) 17361 movl rSELF, %ecx 17362 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17363 jmp *dvmAsmInstructionStart+(347*4) 17364 17365/* ------------------------------ */ 17366.L_ALT_OP_UNUSED_5CFF: /* 0x15c */ 17367/* File: x86/alt_stub.S */ 17368/* 17369 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17370 * any interesting requests and then jump to the real instruction 17371 * handler. Unlike the Arm handler, we can't do this as a tail call 17372 * because rIBASE is caller save and we need to reload it. 17373 */ 17374 movl rSELF, %eax 17375 movl rPC, OUT_ARG0(%esp) 17376 movl %eax, OUT_ARG1(%esp) 17377 call dvmCheckInst # (dPC, self) 17378 movl rSELF, %ecx 17379 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17380 jmp *dvmAsmInstructionStart+(348*4) 17381 17382/* ------------------------------ */ 17383.L_ALT_OP_UNUSED_5DFF: /* 0x15d */ 17384/* File: x86/alt_stub.S */ 17385/* 17386 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17387 * any interesting requests and then jump to the real instruction 17388 * handler. Unlike the Arm handler, we can't do this as a tail call 17389 * because rIBASE is caller save and we need to reload it. 17390 */ 17391 movl rSELF, %eax 17392 movl rPC, OUT_ARG0(%esp) 17393 movl %eax, OUT_ARG1(%esp) 17394 call dvmCheckInst # (dPC, self) 17395 movl rSELF, %ecx 17396 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17397 jmp *dvmAsmInstructionStart+(349*4) 17398 17399/* ------------------------------ */ 17400.L_ALT_OP_UNUSED_5EFF: /* 0x15e */ 17401/* File: x86/alt_stub.S */ 17402/* 17403 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17404 * any interesting requests and then jump to the real instruction 17405 * handler. Unlike the Arm handler, we can't do this as a tail call 17406 * because rIBASE is caller save and we need to reload it. 17407 */ 17408 movl rSELF, %eax 17409 movl rPC, OUT_ARG0(%esp) 17410 movl %eax, OUT_ARG1(%esp) 17411 call dvmCheckInst # (dPC, self) 17412 movl rSELF, %ecx 17413 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17414 jmp *dvmAsmInstructionStart+(350*4) 17415 17416/* ------------------------------ */ 17417.L_ALT_OP_UNUSED_5FFF: /* 0x15f */ 17418/* File: x86/alt_stub.S */ 17419/* 17420 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17421 * any interesting requests and then jump to the real instruction 17422 * handler. Unlike the Arm handler, we can't do this as a tail call 17423 * because rIBASE is caller save and we need to reload it. 17424 */ 17425 movl rSELF, %eax 17426 movl rPC, OUT_ARG0(%esp) 17427 movl %eax, OUT_ARG1(%esp) 17428 call dvmCheckInst # (dPC, self) 17429 movl rSELF, %ecx 17430 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17431 jmp *dvmAsmInstructionStart+(351*4) 17432 17433/* ------------------------------ */ 17434.L_ALT_OP_UNUSED_60FF: /* 0x160 */ 17435/* File: x86/alt_stub.S */ 17436/* 17437 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17438 * any interesting requests and then jump to the real instruction 17439 * handler. Unlike the Arm handler, we can't do this as a tail call 17440 * because rIBASE is caller save and we need to reload it. 17441 */ 17442 movl rSELF, %eax 17443 movl rPC, OUT_ARG0(%esp) 17444 movl %eax, OUT_ARG1(%esp) 17445 call dvmCheckInst # (dPC, self) 17446 movl rSELF, %ecx 17447 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17448 jmp *dvmAsmInstructionStart+(352*4) 17449 17450/* ------------------------------ */ 17451.L_ALT_OP_UNUSED_61FF: /* 0x161 */ 17452/* File: x86/alt_stub.S */ 17453/* 17454 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17455 * any interesting requests and then jump to the real instruction 17456 * handler. Unlike the Arm handler, we can't do this as a tail call 17457 * because rIBASE is caller save and we need to reload it. 17458 */ 17459 movl rSELF, %eax 17460 movl rPC, OUT_ARG0(%esp) 17461 movl %eax, OUT_ARG1(%esp) 17462 call dvmCheckInst # (dPC, self) 17463 movl rSELF, %ecx 17464 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17465 jmp *dvmAsmInstructionStart+(353*4) 17466 17467/* ------------------------------ */ 17468.L_ALT_OP_UNUSED_62FF: /* 0x162 */ 17469/* File: x86/alt_stub.S */ 17470/* 17471 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17472 * any interesting requests and then jump to the real instruction 17473 * handler. Unlike the Arm handler, we can't do this as a tail call 17474 * because rIBASE is caller save and we need to reload it. 17475 */ 17476 movl rSELF, %eax 17477 movl rPC, OUT_ARG0(%esp) 17478 movl %eax, OUT_ARG1(%esp) 17479 call dvmCheckInst # (dPC, self) 17480 movl rSELF, %ecx 17481 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17482 jmp *dvmAsmInstructionStart+(354*4) 17483 17484/* ------------------------------ */ 17485.L_ALT_OP_UNUSED_63FF: /* 0x163 */ 17486/* File: x86/alt_stub.S */ 17487/* 17488 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17489 * any interesting requests and then jump to the real instruction 17490 * handler. Unlike the Arm handler, we can't do this as a tail call 17491 * because rIBASE is caller save and we need to reload it. 17492 */ 17493 movl rSELF, %eax 17494 movl rPC, OUT_ARG0(%esp) 17495 movl %eax, OUT_ARG1(%esp) 17496 call dvmCheckInst # (dPC, self) 17497 movl rSELF, %ecx 17498 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17499 jmp *dvmAsmInstructionStart+(355*4) 17500 17501/* ------------------------------ */ 17502.L_ALT_OP_UNUSED_64FF: /* 0x164 */ 17503/* File: x86/alt_stub.S */ 17504/* 17505 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17506 * any interesting requests and then jump to the real instruction 17507 * handler. Unlike the Arm handler, we can't do this as a tail call 17508 * because rIBASE is caller save and we need to reload it. 17509 */ 17510 movl rSELF, %eax 17511 movl rPC, OUT_ARG0(%esp) 17512 movl %eax, OUT_ARG1(%esp) 17513 call dvmCheckInst # (dPC, self) 17514 movl rSELF, %ecx 17515 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17516 jmp *dvmAsmInstructionStart+(356*4) 17517 17518/* ------------------------------ */ 17519.L_ALT_OP_UNUSED_65FF: /* 0x165 */ 17520/* File: x86/alt_stub.S */ 17521/* 17522 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17523 * any interesting requests and then jump to the real instruction 17524 * handler. Unlike the Arm handler, we can't do this as a tail call 17525 * because rIBASE is caller save and we need to reload it. 17526 */ 17527 movl rSELF, %eax 17528 movl rPC, OUT_ARG0(%esp) 17529 movl %eax, OUT_ARG1(%esp) 17530 call dvmCheckInst # (dPC, self) 17531 movl rSELF, %ecx 17532 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17533 jmp *dvmAsmInstructionStart+(357*4) 17534 17535/* ------------------------------ */ 17536.L_ALT_OP_UNUSED_66FF: /* 0x166 */ 17537/* File: x86/alt_stub.S */ 17538/* 17539 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17540 * any interesting requests and then jump to the real instruction 17541 * handler. Unlike the Arm handler, we can't do this as a tail call 17542 * because rIBASE is caller save and we need to reload it. 17543 */ 17544 movl rSELF, %eax 17545 movl rPC, OUT_ARG0(%esp) 17546 movl %eax, OUT_ARG1(%esp) 17547 call dvmCheckInst # (dPC, self) 17548 movl rSELF, %ecx 17549 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17550 jmp *dvmAsmInstructionStart+(358*4) 17551 17552/* ------------------------------ */ 17553.L_ALT_OP_UNUSED_67FF: /* 0x167 */ 17554/* File: x86/alt_stub.S */ 17555/* 17556 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17557 * any interesting requests and then jump to the real instruction 17558 * handler. Unlike the Arm handler, we can't do this as a tail call 17559 * because rIBASE is caller save and we need to reload it. 17560 */ 17561 movl rSELF, %eax 17562 movl rPC, OUT_ARG0(%esp) 17563 movl %eax, OUT_ARG1(%esp) 17564 call dvmCheckInst # (dPC, self) 17565 movl rSELF, %ecx 17566 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17567 jmp *dvmAsmInstructionStart+(359*4) 17568 17569/* ------------------------------ */ 17570.L_ALT_OP_UNUSED_68FF: /* 0x168 */ 17571/* File: x86/alt_stub.S */ 17572/* 17573 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17574 * any interesting requests and then jump to the real instruction 17575 * handler. Unlike the Arm handler, we can't do this as a tail call 17576 * because rIBASE is caller save and we need to reload it. 17577 */ 17578 movl rSELF, %eax 17579 movl rPC, OUT_ARG0(%esp) 17580 movl %eax, OUT_ARG1(%esp) 17581 call dvmCheckInst # (dPC, self) 17582 movl rSELF, %ecx 17583 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17584 jmp *dvmAsmInstructionStart+(360*4) 17585 17586/* ------------------------------ */ 17587.L_ALT_OP_UNUSED_69FF: /* 0x169 */ 17588/* File: x86/alt_stub.S */ 17589/* 17590 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17591 * any interesting requests and then jump to the real instruction 17592 * handler. Unlike the Arm handler, we can't do this as a tail call 17593 * because rIBASE is caller save and we need to reload it. 17594 */ 17595 movl rSELF, %eax 17596 movl rPC, OUT_ARG0(%esp) 17597 movl %eax, OUT_ARG1(%esp) 17598 call dvmCheckInst # (dPC, self) 17599 movl rSELF, %ecx 17600 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17601 jmp *dvmAsmInstructionStart+(361*4) 17602 17603/* ------------------------------ */ 17604.L_ALT_OP_UNUSED_6AFF: /* 0x16a */ 17605/* File: x86/alt_stub.S */ 17606/* 17607 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17608 * any interesting requests and then jump to the real instruction 17609 * handler. Unlike the Arm handler, we can't do this as a tail call 17610 * because rIBASE is caller save and we need to reload it. 17611 */ 17612 movl rSELF, %eax 17613 movl rPC, OUT_ARG0(%esp) 17614 movl %eax, OUT_ARG1(%esp) 17615 call dvmCheckInst # (dPC, self) 17616 movl rSELF, %ecx 17617 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17618 jmp *dvmAsmInstructionStart+(362*4) 17619 17620/* ------------------------------ */ 17621.L_ALT_OP_UNUSED_6BFF: /* 0x16b */ 17622/* File: x86/alt_stub.S */ 17623/* 17624 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17625 * any interesting requests and then jump to the real instruction 17626 * handler. Unlike the Arm handler, we can't do this as a tail call 17627 * because rIBASE is caller save and we need to reload it. 17628 */ 17629 movl rSELF, %eax 17630 movl rPC, OUT_ARG0(%esp) 17631 movl %eax, OUT_ARG1(%esp) 17632 call dvmCheckInst # (dPC, self) 17633 movl rSELF, %ecx 17634 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17635 jmp *dvmAsmInstructionStart+(363*4) 17636 17637/* ------------------------------ */ 17638.L_ALT_OP_UNUSED_6CFF: /* 0x16c */ 17639/* File: x86/alt_stub.S */ 17640/* 17641 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17642 * any interesting requests and then jump to the real instruction 17643 * handler. Unlike the Arm handler, we can't do this as a tail call 17644 * because rIBASE is caller save and we need to reload it. 17645 */ 17646 movl rSELF, %eax 17647 movl rPC, OUT_ARG0(%esp) 17648 movl %eax, OUT_ARG1(%esp) 17649 call dvmCheckInst # (dPC, self) 17650 movl rSELF, %ecx 17651 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17652 jmp *dvmAsmInstructionStart+(364*4) 17653 17654/* ------------------------------ */ 17655.L_ALT_OP_UNUSED_6DFF: /* 0x16d */ 17656/* File: x86/alt_stub.S */ 17657/* 17658 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17659 * any interesting requests and then jump to the real instruction 17660 * handler. Unlike the Arm handler, we can't do this as a tail call 17661 * because rIBASE is caller save and we need to reload it. 17662 */ 17663 movl rSELF, %eax 17664 movl rPC, OUT_ARG0(%esp) 17665 movl %eax, OUT_ARG1(%esp) 17666 call dvmCheckInst # (dPC, self) 17667 movl rSELF, %ecx 17668 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17669 jmp *dvmAsmInstructionStart+(365*4) 17670 17671/* ------------------------------ */ 17672.L_ALT_OP_UNUSED_6EFF: /* 0x16e */ 17673/* File: x86/alt_stub.S */ 17674/* 17675 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17676 * any interesting requests and then jump to the real instruction 17677 * handler. Unlike the Arm handler, we can't do this as a tail call 17678 * because rIBASE is caller save and we need to reload it. 17679 */ 17680 movl rSELF, %eax 17681 movl rPC, OUT_ARG0(%esp) 17682 movl %eax, OUT_ARG1(%esp) 17683 call dvmCheckInst # (dPC, self) 17684 movl rSELF, %ecx 17685 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17686 jmp *dvmAsmInstructionStart+(366*4) 17687 17688/* ------------------------------ */ 17689.L_ALT_OP_UNUSED_6FFF: /* 0x16f */ 17690/* File: x86/alt_stub.S */ 17691/* 17692 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17693 * any interesting requests and then jump to the real instruction 17694 * handler. Unlike the Arm handler, we can't do this as a tail call 17695 * because rIBASE is caller save and we need to reload it. 17696 */ 17697 movl rSELF, %eax 17698 movl rPC, OUT_ARG0(%esp) 17699 movl %eax, OUT_ARG1(%esp) 17700 call dvmCheckInst # (dPC, self) 17701 movl rSELF, %ecx 17702 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17703 jmp *dvmAsmInstructionStart+(367*4) 17704 17705/* ------------------------------ */ 17706.L_ALT_OP_UNUSED_70FF: /* 0x170 */ 17707/* File: x86/alt_stub.S */ 17708/* 17709 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17710 * any interesting requests and then jump to the real instruction 17711 * handler. Unlike the Arm handler, we can't do this as a tail call 17712 * because rIBASE is caller save and we need to reload it. 17713 */ 17714 movl rSELF, %eax 17715 movl rPC, OUT_ARG0(%esp) 17716 movl %eax, OUT_ARG1(%esp) 17717 call dvmCheckInst # (dPC, self) 17718 movl rSELF, %ecx 17719 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17720 jmp *dvmAsmInstructionStart+(368*4) 17721 17722/* ------------------------------ */ 17723.L_ALT_OP_UNUSED_71FF: /* 0x171 */ 17724/* File: x86/alt_stub.S */ 17725/* 17726 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17727 * any interesting requests and then jump to the real instruction 17728 * handler. Unlike the Arm handler, we can't do this as a tail call 17729 * because rIBASE is caller save and we need to reload it. 17730 */ 17731 movl rSELF, %eax 17732 movl rPC, OUT_ARG0(%esp) 17733 movl %eax, OUT_ARG1(%esp) 17734 call dvmCheckInst # (dPC, self) 17735 movl rSELF, %ecx 17736 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17737 jmp *dvmAsmInstructionStart+(369*4) 17738 17739/* ------------------------------ */ 17740.L_ALT_OP_UNUSED_72FF: /* 0x172 */ 17741/* File: x86/alt_stub.S */ 17742/* 17743 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17744 * any interesting requests and then jump to the real instruction 17745 * handler. Unlike the Arm handler, we can't do this as a tail call 17746 * because rIBASE is caller save and we need to reload it. 17747 */ 17748 movl rSELF, %eax 17749 movl rPC, OUT_ARG0(%esp) 17750 movl %eax, OUT_ARG1(%esp) 17751 call dvmCheckInst # (dPC, self) 17752 movl rSELF, %ecx 17753 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17754 jmp *dvmAsmInstructionStart+(370*4) 17755 17756/* ------------------------------ */ 17757.L_ALT_OP_UNUSED_73FF: /* 0x173 */ 17758/* File: x86/alt_stub.S */ 17759/* 17760 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17761 * any interesting requests and then jump to the real instruction 17762 * handler. Unlike the Arm handler, we can't do this as a tail call 17763 * because rIBASE is caller save and we need to reload it. 17764 */ 17765 movl rSELF, %eax 17766 movl rPC, OUT_ARG0(%esp) 17767 movl %eax, OUT_ARG1(%esp) 17768 call dvmCheckInst # (dPC, self) 17769 movl rSELF, %ecx 17770 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17771 jmp *dvmAsmInstructionStart+(371*4) 17772 17773/* ------------------------------ */ 17774.L_ALT_OP_UNUSED_74FF: /* 0x174 */ 17775/* File: x86/alt_stub.S */ 17776/* 17777 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17778 * any interesting requests and then jump to the real instruction 17779 * handler. Unlike the Arm handler, we can't do this as a tail call 17780 * because rIBASE is caller save and we need to reload it. 17781 */ 17782 movl rSELF, %eax 17783 movl rPC, OUT_ARG0(%esp) 17784 movl %eax, OUT_ARG1(%esp) 17785 call dvmCheckInst # (dPC, self) 17786 movl rSELF, %ecx 17787 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17788 jmp *dvmAsmInstructionStart+(372*4) 17789 17790/* ------------------------------ */ 17791.L_ALT_OP_UNUSED_75FF: /* 0x175 */ 17792/* File: x86/alt_stub.S */ 17793/* 17794 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17795 * any interesting requests and then jump to the real instruction 17796 * handler. Unlike the Arm handler, we can't do this as a tail call 17797 * because rIBASE is caller save and we need to reload it. 17798 */ 17799 movl rSELF, %eax 17800 movl rPC, OUT_ARG0(%esp) 17801 movl %eax, OUT_ARG1(%esp) 17802 call dvmCheckInst # (dPC, self) 17803 movl rSELF, %ecx 17804 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17805 jmp *dvmAsmInstructionStart+(373*4) 17806 17807/* ------------------------------ */ 17808.L_ALT_OP_UNUSED_76FF: /* 0x176 */ 17809/* File: x86/alt_stub.S */ 17810/* 17811 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17812 * any interesting requests and then jump to the real instruction 17813 * handler. Unlike the Arm handler, we can't do this as a tail call 17814 * because rIBASE is caller save and we need to reload it. 17815 */ 17816 movl rSELF, %eax 17817 movl rPC, OUT_ARG0(%esp) 17818 movl %eax, OUT_ARG1(%esp) 17819 call dvmCheckInst # (dPC, self) 17820 movl rSELF, %ecx 17821 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17822 jmp *dvmAsmInstructionStart+(374*4) 17823 17824/* ------------------------------ */ 17825.L_ALT_OP_UNUSED_77FF: /* 0x177 */ 17826/* File: x86/alt_stub.S */ 17827/* 17828 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17829 * any interesting requests and then jump to the real instruction 17830 * handler. Unlike the Arm handler, we can't do this as a tail call 17831 * because rIBASE is caller save and we need to reload it. 17832 */ 17833 movl rSELF, %eax 17834 movl rPC, OUT_ARG0(%esp) 17835 movl %eax, OUT_ARG1(%esp) 17836 call dvmCheckInst # (dPC, self) 17837 movl rSELF, %ecx 17838 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17839 jmp *dvmAsmInstructionStart+(375*4) 17840 17841/* ------------------------------ */ 17842.L_ALT_OP_UNUSED_78FF: /* 0x178 */ 17843/* File: x86/alt_stub.S */ 17844/* 17845 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17846 * any interesting requests and then jump to the real instruction 17847 * handler. Unlike the Arm handler, we can't do this as a tail call 17848 * because rIBASE is caller save and we need to reload it. 17849 */ 17850 movl rSELF, %eax 17851 movl rPC, OUT_ARG0(%esp) 17852 movl %eax, OUT_ARG1(%esp) 17853 call dvmCheckInst # (dPC, self) 17854 movl rSELF, %ecx 17855 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17856 jmp *dvmAsmInstructionStart+(376*4) 17857 17858/* ------------------------------ */ 17859.L_ALT_OP_UNUSED_79FF: /* 0x179 */ 17860/* File: x86/alt_stub.S */ 17861/* 17862 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17863 * any interesting requests and then jump to the real instruction 17864 * handler. Unlike the Arm handler, we can't do this as a tail call 17865 * because rIBASE is caller save and we need to reload it. 17866 */ 17867 movl rSELF, %eax 17868 movl rPC, OUT_ARG0(%esp) 17869 movl %eax, OUT_ARG1(%esp) 17870 call dvmCheckInst # (dPC, self) 17871 movl rSELF, %ecx 17872 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17873 jmp *dvmAsmInstructionStart+(377*4) 17874 17875/* ------------------------------ */ 17876.L_ALT_OP_UNUSED_7AFF: /* 0x17a */ 17877/* File: x86/alt_stub.S */ 17878/* 17879 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17880 * any interesting requests and then jump to the real instruction 17881 * handler. Unlike the Arm handler, we can't do this as a tail call 17882 * because rIBASE is caller save and we need to reload it. 17883 */ 17884 movl rSELF, %eax 17885 movl rPC, OUT_ARG0(%esp) 17886 movl %eax, OUT_ARG1(%esp) 17887 call dvmCheckInst # (dPC, self) 17888 movl rSELF, %ecx 17889 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17890 jmp *dvmAsmInstructionStart+(378*4) 17891 17892/* ------------------------------ */ 17893.L_ALT_OP_UNUSED_7BFF: /* 0x17b */ 17894/* File: x86/alt_stub.S */ 17895/* 17896 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17897 * any interesting requests and then jump to the real instruction 17898 * handler. Unlike the Arm handler, we can't do this as a tail call 17899 * because rIBASE is caller save and we need to reload it. 17900 */ 17901 movl rSELF, %eax 17902 movl rPC, OUT_ARG0(%esp) 17903 movl %eax, OUT_ARG1(%esp) 17904 call dvmCheckInst # (dPC, self) 17905 movl rSELF, %ecx 17906 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17907 jmp *dvmAsmInstructionStart+(379*4) 17908 17909/* ------------------------------ */ 17910.L_ALT_OP_UNUSED_7CFF: /* 0x17c */ 17911/* File: x86/alt_stub.S */ 17912/* 17913 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17914 * any interesting requests and then jump to the real instruction 17915 * handler. Unlike the Arm handler, we can't do this as a tail call 17916 * because rIBASE is caller save and we need to reload it. 17917 */ 17918 movl rSELF, %eax 17919 movl rPC, OUT_ARG0(%esp) 17920 movl %eax, OUT_ARG1(%esp) 17921 call dvmCheckInst # (dPC, self) 17922 movl rSELF, %ecx 17923 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17924 jmp *dvmAsmInstructionStart+(380*4) 17925 17926/* ------------------------------ */ 17927.L_ALT_OP_UNUSED_7DFF: /* 0x17d */ 17928/* File: x86/alt_stub.S */ 17929/* 17930 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17931 * any interesting requests and then jump to the real instruction 17932 * handler. Unlike the Arm handler, we can't do this as a tail call 17933 * because rIBASE is caller save and we need to reload it. 17934 */ 17935 movl rSELF, %eax 17936 movl rPC, OUT_ARG0(%esp) 17937 movl %eax, OUT_ARG1(%esp) 17938 call dvmCheckInst # (dPC, self) 17939 movl rSELF, %ecx 17940 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17941 jmp *dvmAsmInstructionStart+(381*4) 17942 17943/* ------------------------------ */ 17944.L_ALT_OP_UNUSED_7EFF: /* 0x17e */ 17945/* File: x86/alt_stub.S */ 17946/* 17947 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17948 * any interesting requests and then jump to the real instruction 17949 * handler. Unlike the Arm handler, we can't do this as a tail call 17950 * because rIBASE is caller save and we need to reload it. 17951 */ 17952 movl rSELF, %eax 17953 movl rPC, OUT_ARG0(%esp) 17954 movl %eax, OUT_ARG1(%esp) 17955 call dvmCheckInst # (dPC, self) 17956 movl rSELF, %ecx 17957 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17958 jmp *dvmAsmInstructionStart+(382*4) 17959 17960/* ------------------------------ */ 17961.L_ALT_OP_UNUSED_7FFF: /* 0x17f */ 17962/* File: x86/alt_stub.S */ 17963/* 17964 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17965 * any interesting requests and then jump to the real instruction 17966 * handler. Unlike the Arm handler, we can't do this as a tail call 17967 * because rIBASE is caller save and we need to reload it. 17968 */ 17969 movl rSELF, %eax 17970 movl rPC, OUT_ARG0(%esp) 17971 movl %eax, OUT_ARG1(%esp) 17972 call dvmCheckInst # (dPC, self) 17973 movl rSELF, %ecx 17974 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17975 jmp *dvmAsmInstructionStart+(383*4) 17976 17977/* ------------------------------ */ 17978.L_ALT_OP_UNUSED_80FF: /* 0x180 */ 17979/* File: x86/alt_stub.S */ 17980/* 17981 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17982 * any interesting requests and then jump to the real instruction 17983 * handler. Unlike the Arm handler, we can't do this as a tail call 17984 * because rIBASE is caller save and we need to reload it. 17985 */ 17986 movl rSELF, %eax 17987 movl rPC, OUT_ARG0(%esp) 17988 movl %eax, OUT_ARG1(%esp) 17989 call dvmCheckInst # (dPC, self) 17990 movl rSELF, %ecx 17991 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17992 jmp *dvmAsmInstructionStart+(384*4) 17993 17994/* ------------------------------ */ 17995.L_ALT_OP_UNUSED_81FF: /* 0x181 */ 17996/* File: x86/alt_stub.S */ 17997/* 17998 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17999 * any interesting requests and then jump to the real instruction 18000 * handler. Unlike the Arm handler, we can't do this as a tail call 18001 * because rIBASE is caller save and we need to reload it. 18002 */ 18003 movl rSELF, %eax 18004 movl rPC, OUT_ARG0(%esp) 18005 movl %eax, OUT_ARG1(%esp) 18006 call dvmCheckInst # (dPC, self) 18007 movl rSELF, %ecx 18008 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18009 jmp *dvmAsmInstructionStart+(385*4) 18010 18011/* ------------------------------ */ 18012.L_ALT_OP_UNUSED_82FF: /* 0x182 */ 18013/* File: x86/alt_stub.S */ 18014/* 18015 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18016 * any interesting requests and then jump to the real instruction 18017 * handler. Unlike the Arm handler, we can't do this as a tail call 18018 * because rIBASE is caller save and we need to reload it. 18019 */ 18020 movl rSELF, %eax 18021 movl rPC, OUT_ARG0(%esp) 18022 movl %eax, OUT_ARG1(%esp) 18023 call dvmCheckInst # (dPC, self) 18024 movl rSELF, %ecx 18025 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18026 jmp *dvmAsmInstructionStart+(386*4) 18027 18028/* ------------------------------ */ 18029.L_ALT_OP_UNUSED_83FF: /* 0x183 */ 18030/* File: x86/alt_stub.S */ 18031/* 18032 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18033 * any interesting requests and then jump to the real instruction 18034 * handler. Unlike the Arm handler, we can't do this as a tail call 18035 * because rIBASE is caller save and we need to reload it. 18036 */ 18037 movl rSELF, %eax 18038 movl rPC, OUT_ARG0(%esp) 18039 movl %eax, OUT_ARG1(%esp) 18040 call dvmCheckInst # (dPC, self) 18041 movl rSELF, %ecx 18042 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18043 jmp *dvmAsmInstructionStart+(387*4) 18044 18045/* ------------------------------ */ 18046.L_ALT_OP_UNUSED_84FF: /* 0x184 */ 18047/* File: x86/alt_stub.S */ 18048/* 18049 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18050 * any interesting requests and then jump to the real instruction 18051 * handler. Unlike the Arm handler, we can't do this as a tail call 18052 * because rIBASE is caller save and we need to reload it. 18053 */ 18054 movl rSELF, %eax 18055 movl rPC, OUT_ARG0(%esp) 18056 movl %eax, OUT_ARG1(%esp) 18057 call dvmCheckInst # (dPC, self) 18058 movl rSELF, %ecx 18059 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18060 jmp *dvmAsmInstructionStart+(388*4) 18061 18062/* ------------------------------ */ 18063.L_ALT_OP_UNUSED_85FF: /* 0x185 */ 18064/* File: x86/alt_stub.S */ 18065/* 18066 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18067 * any interesting requests and then jump to the real instruction 18068 * handler. Unlike the Arm handler, we can't do this as a tail call 18069 * because rIBASE is caller save and we need to reload it. 18070 */ 18071 movl rSELF, %eax 18072 movl rPC, OUT_ARG0(%esp) 18073 movl %eax, OUT_ARG1(%esp) 18074 call dvmCheckInst # (dPC, self) 18075 movl rSELF, %ecx 18076 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18077 jmp *dvmAsmInstructionStart+(389*4) 18078 18079/* ------------------------------ */ 18080.L_ALT_OP_UNUSED_86FF: /* 0x186 */ 18081/* File: x86/alt_stub.S */ 18082/* 18083 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18084 * any interesting requests and then jump to the real instruction 18085 * handler. Unlike the Arm handler, we can't do this as a tail call 18086 * because rIBASE is caller save and we need to reload it. 18087 */ 18088 movl rSELF, %eax 18089 movl rPC, OUT_ARG0(%esp) 18090 movl %eax, OUT_ARG1(%esp) 18091 call dvmCheckInst # (dPC, self) 18092 movl rSELF, %ecx 18093 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18094 jmp *dvmAsmInstructionStart+(390*4) 18095 18096/* ------------------------------ */ 18097.L_ALT_OP_UNUSED_87FF: /* 0x187 */ 18098/* File: x86/alt_stub.S */ 18099/* 18100 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18101 * any interesting requests and then jump to the real instruction 18102 * handler. Unlike the Arm handler, we can't do this as a tail call 18103 * because rIBASE is caller save and we need to reload it. 18104 */ 18105 movl rSELF, %eax 18106 movl rPC, OUT_ARG0(%esp) 18107 movl %eax, OUT_ARG1(%esp) 18108 call dvmCheckInst # (dPC, self) 18109 movl rSELF, %ecx 18110 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18111 jmp *dvmAsmInstructionStart+(391*4) 18112 18113/* ------------------------------ */ 18114.L_ALT_OP_UNUSED_88FF: /* 0x188 */ 18115/* File: x86/alt_stub.S */ 18116/* 18117 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18118 * any interesting requests and then jump to the real instruction 18119 * handler. Unlike the Arm handler, we can't do this as a tail call 18120 * because rIBASE is caller save and we need to reload it. 18121 */ 18122 movl rSELF, %eax 18123 movl rPC, OUT_ARG0(%esp) 18124 movl %eax, OUT_ARG1(%esp) 18125 call dvmCheckInst # (dPC, self) 18126 movl rSELF, %ecx 18127 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18128 jmp *dvmAsmInstructionStart+(392*4) 18129 18130/* ------------------------------ */ 18131.L_ALT_OP_UNUSED_89FF: /* 0x189 */ 18132/* File: x86/alt_stub.S */ 18133/* 18134 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18135 * any interesting requests and then jump to the real instruction 18136 * handler. Unlike the Arm handler, we can't do this as a tail call 18137 * because rIBASE is caller save and we need to reload it. 18138 */ 18139 movl rSELF, %eax 18140 movl rPC, OUT_ARG0(%esp) 18141 movl %eax, OUT_ARG1(%esp) 18142 call dvmCheckInst # (dPC, self) 18143 movl rSELF, %ecx 18144 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18145 jmp *dvmAsmInstructionStart+(393*4) 18146 18147/* ------------------------------ */ 18148.L_ALT_OP_UNUSED_8AFF: /* 0x18a */ 18149/* File: x86/alt_stub.S */ 18150/* 18151 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18152 * any interesting requests and then jump to the real instruction 18153 * handler. Unlike the Arm handler, we can't do this as a tail call 18154 * because rIBASE is caller save and we need to reload it. 18155 */ 18156 movl rSELF, %eax 18157 movl rPC, OUT_ARG0(%esp) 18158 movl %eax, OUT_ARG1(%esp) 18159 call dvmCheckInst # (dPC, self) 18160 movl rSELF, %ecx 18161 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18162 jmp *dvmAsmInstructionStart+(394*4) 18163 18164/* ------------------------------ */ 18165.L_ALT_OP_UNUSED_8BFF: /* 0x18b */ 18166/* File: x86/alt_stub.S */ 18167/* 18168 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18169 * any interesting requests and then jump to the real instruction 18170 * handler. Unlike the Arm handler, we can't do this as a tail call 18171 * because rIBASE is caller save and we need to reload it. 18172 */ 18173 movl rSELF, %eax 18174 movl rPC, OUT_ARG0(%esp) 18175 movl %eax, OUT_ARG1(%esp) 18176 call dvmCheckInst # (dPC, self) 18177 movl rSELF, %ecx 18178 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18179 jmp *dvmAsmInstructionStart+(395*4) 18180 18181/* ------------------------------ */ 18182.L_ALT_OP_UNUSED_8CFF: /* 0x18c */ 18183/* File: x86/alt_stub.S */ 18184/* 18185 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18186 * any interesting requests and then jump to the real instruction 18187 * handler. Unlike the Arm handler, we can't do this as a tail call 18188 * because rIBASE is caller save and we need to reload it. 18189 */ 18190 movl rSELF, %eax 18191 movl rPC, OUT_ARG0(%esp) 18192 movl %eax, OUT_ARG1(%esp) 18193 call dvmCheckInst # (dPC, self) 18194 movl rSELF, %ecx 18195 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18196 jmp *dvmAsmInstructionStart+(396*4) 18197 18198/* ------------------------------ */ 18199.L_ALT_OP_UNUSED_8DFF: /* 0x18d */ 18200/* File: x86/alt_stub.S */ 18201/* 18202 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18203 * any interesting requests and then jump to the real instruction 18204 * handler. Unlike the Arm handler, we can't do this as a tail call 18205 * because rIBASE is caller save and we need to reload it. 18206 */ 18207 movl rSELF, %eax 18208 movl rPC, OUT_ARG0(%esp) 18209 movl %eax, OUT_ARG1(%esp) 18210 call dvmCheckInst # (dPC, self) 18211 movl rSELF, %ecx 18212 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18213 jmp *dvmAsmInstructionStart+(397*4) 18214 18215/* ------------------------------ */ 18216.L_ALT_OP_UNUSED_8EFF: /* 0x18e */ 18217/* File: x86/alt_stub.S */ 18218/* 18219 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18220 * any interesting requests and then jump to the real instruction 18221 * handler. Unlike the Arm handler, we can't do this as a tail call 18222 * because rIBASE is caller save and we need to reload it. 18223 */ 18224 movl rSELF, %eax 18225 movl rPC, OUT_ARG0(%esp) 18226 movl %eax, OUT_ARG1(%esp) 18227 call dvmCheckInst # (dPC, self) 18228 movl rSELF, %ecx 18229 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18230 jmp *dvmAsmInstructionStart+(398*4) 18231 18232/* ------------------------------ */ 18233.L_ALT_OP_UNUSED_8FFF: /* 0x18f */ 18234/* File: x86/alt_stub.S */ 18235/* 18236 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18237 * any interesting requests and then jump to the real instruction 18238 * handler. Unlike the Arm handler, we can't do this as a tail call 18239 * because rIBASE is caller save and we need to reload it. 18240 */ 18241 movl rSELF, %eax 18242 movl rPC, OUT_ARG0(%esp) 18243 movl %eax, OUT_ARG1(%esp) 18244 call dvmCheckInst # (dPC, self) 18245 movl rSELF, %ecx 18246 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18247 jmp *dvmAsmInstructionStart+(399*4) 18248 18249/* ------------------------------ */ 18250.L_ALT_OP_UNUSED_90FF: /* 0x190 */ 18251/* File: x86/alt_stub.S */ 18252/* 18253 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18254 * any interesting requests and then jump to the real instruction 18255 * handler. Unlike the Arm handler, we can't do this as a tail call 18256 * because rIBASE is caller save and we need to reload it. 18257 */ 18258 movl rSELF, %eax 18259 movl rPC, OUT_ARG0(%esp) 18260 movl %eax, OUT_ARG1(%esp) 18261 call dvmCheckInst # (dPC, self) 18262 movl rSELF, %ecx 18263 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18264 jmp *dvmAsmInstructionStart+(400*4) 18265 18266/* ------------------------------ */ 18267.L_ALT_OP_UNUSED_91FF: /* 0x191 */ 18268/* File: x86/alt_stub.S */ 18269/* 18270 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18271 * any interesting requests and then jump to the real instruction 18272 * handler. Unlike the Arm handler, we can't do this as a tail call 18273 * because rIBASE is caller save and we need to reload it. 18274 */ 18275 movl rSELF, %eax 18276 movl rPC, OUT_ARG0(%esp) 18277 movl %eax, OUT_ARG1(%esp) 18278 call dvmCheckInst # (dPC, self) 18279 movl rSELF, %ecx 18280 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18281 jmp *dvmAsmInstructionStart+(401*4) 18282 18283/* ------------------------------ */ 18284.L_ALT_OP_UNUSED_92FF: /* 0x192 */ 18285/* File: x86/alt_stub.S */ 18286/* 18287 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18288 * any interesting requests and then jump to the real instruction 18289 * handler. Unlike the Arm handler, we can't do this as a tail call 18290 * because rIBASE is caller save and we need to reload it. 18291 */ 18292 movl rSELF, %eax 18293 movl rPC, OUT_ARG0(%esp) 18294 movl %eax, OUT_ARG1(%esp) 18295 call dvmCheckInst # (dPC, self) 18296 movl rSELF, %ecx 18297 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18298 jmp *dvmAsmInstructionStart+(402*4) 18299 18300/* ------------------------------ */ 18301.L_ALT_OP_UNUSED_93FF: /* 0x193 */ 18302/* File: x86/alt_stub.S */ 18303/* 18304 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18305 * any interesting requests and then jump to the real instruction 18306 * handler. Unlike the Arm handler, we can't do this as a tail call 18307 * because rIBASE is caller save and we need to reload it. 18308 */ 18309 movl rSELF, %eax 18310 movl rPC, OUT_ARG0(%esp) 18311 movl %eax, OUT_ARG1(%esp) 18312 call dvmCheckInst # (dPC, self) 18313 movl rSELF, %ecx 18314 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18315 jmp *dvmAsmInstructionStart+(403*4) 18316 18317/* ------------------------------ */ 18318.L_ALT_OP_UNUSED_94FF: /* 0x194 */ 18319/* File: x86/alt_stub.S */ 18320/* 18321 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18322 * any interesting requests and then jump to the real instruction 18323 * handler. Unlike the Arm handler, we can't do this as a tail call 18324 * because rIBASE is caller save and we need to reload it. 18325 */ 18326 movl rSELF, %eax 18327 movl rPC, OUT_ARG0(%esp) 18328 movl %eax, OUT_ARG1(%esp) 18329 call dvmCheckInst # (dPC, self) 18330 movl rSELF, %ecx 18331 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18332 jmp *dvmAsmInstructionStart+(404*4) 18333 18334/* ------------------------------ */ 18335.L_ALT_OP_UNUSED_95FF: /* 0x195 */ 18336/* File: x86/alt_stub.S */ 18337/* 18338 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18339 * any interesting requests and then jump to the real instruction 18340 * handler. Unlike the Arm handler, we can't do this as a tail call 18341 * because rIBASE is caller save and we need to reload it. 18342 */ 18343 movl rSELF, %eax 18344 movl rPC, OUT_ARG0(%esp) 18345 movl %eax, OUT_ARG1(%esp) 18346 call dvmCheckInst # (dPC, self) 18347 movl rSELF, %ecx 18348 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18349 jmp *dvmAsmInstructionStart+(405*4) 18350 18351/* ------------------------------ */ 18352.L_ALT_OP_UNUSED_96FF: /* 0x196 */ 18353/* File: x86/alt_stub.S */ 18354/* 18355 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18356 * any interesting requests and then jump to the real instruction 18357 * handler. Unlike the Arm handler, we can't do this as a tail call 18358 * because rIBASE is caller save and we need to reload it. 18359 */ 18360 movl rSELF, %eax 18361 movl rPC, OUT_ARG0(%esp) 18362 movl %eax, OUT_ARG1(%esp) 18363 call dvmCheckInst # (dPC, self) 18364 movl rSELF, %ecx 18365 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18366 jmp *dvmAsmInstructionStart+(406*4) 18367 18368/* ------------------------------ */ 18369.L_ALT_OP_UNUSED_97FF: /* 0x197 */ 18370/* File: x86/alt_stub.S */ 18371/* 18372 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18373 * any interesting requests and then jump to the real instruction 18374 * handler. Unlike the Arm handler, we can't do this as a tail call 18375 * because rIBASE is caller save and we need to reload it. 18376 */ 18377 movl rSELF, %eax 18378 movl rPC, OUT_ARG0(%esp) 18379 movl %eax, OUT_ARG1(%esp) 18380 call dvmCheckInst # (dPC, self) 18381 movl rSELF, %ecx 18382 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18383 jmp *dvmAsmInstructionStart+(407*4) 18384 18385/* ------------------------------ */ 18386.L_ALT_OP_UNUSED_98FF: /* 0x198 */ 18387/* File: x86/alt_stub.S */ 18388/* 18389 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18390 * any interesting requests and then jump to the real instruction 18391 * handler. Unlike the Arm handler, we can't do this as a tail call 18392 * because rIBASE is caller save and we need to reload it. 18393 */ 18394 movl rSELF, %eax 18395 movl rPC, OUT_ARG0(%esp) 18396 movl %eax, OUT_ARG1(%esp) 18397 call dvmCheckInst # (dPC, self) 18398 movl rSELF, %ecx 18399 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18400 jmp *dvmAsmInstructionStart+(408*4) 18401 18402/* ------------------------------ */ 18403.L_ALT_OP_UNUSED_99FF: /* 0x199 */ 18404/* File: x86/alt_stub.S */ 18405/* 18406 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18407 * any interesting requests and then jump to the real instruction 18408 * handler. Unlike the Arm handler, we can't do this as a tail call 18409 * because rIBASE is caller save and we need to reload it. 18410 */ 18411 movl rSELF, %eax 18412 movl rPC, OUT_ARG0(%esp) 18413 movl %eax, OUT_ARG1(%esp) 18414 call dvmCheckInst # (dPC, self) 18415 movl rSELF, %ecx 18416 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18417 jmp *dvmAsmInstructionStart+(409*4) 18418 18419/* ------------------------------ */ 18420.L_ALT_OP_UNUSED_9AFF: /* 0x19a */ 18421/* File: x86/alt_stub.S */ 18422/* 18423 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18424 * any interesting requests and then jump to the real instruction 18425 * handler. Unlike the Arm handler, we can't do this as a tail call 18426 * because rIBASE is caller save and we need to reload it. 18427 */ 18428 movl rSELF, %eax 18429 movl rPC, OUT_ARG0(%esp) 18430 movl %eax, OUT_ARG1(%esp) 18431 call dvmCheckInst # (dPC, self) 18432 movl rSELF, %ecx 18433 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18434 jmp *dvmAsmInstructionStart+(410*4) 18435 18436/* ------------------------------ */ 18437.L_ALT_OP_UNUSED_9BFF: /* 0x19b */ 18438/* File: x86/alt_stub.S */ 18439/* 18440 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18441 * any interesting requests and then jump to the real instruction 18442 * handler. Unlike the Arm handler, we can't do this as a tail call 18443 * because rIBASE is caller save and we need to reload it. 18444 */ 18445 movl rSELF, %eax 18446 movl rPC, OUT_ARG0(%esp) 18447 movl %eax, OUT_ARG1(%esp) 18448 call dvmCheckInst # (dPC, self) 18449 movl rSELF, %ecx 18450 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18451 jmp *dvmAsmInstructionStart+(411*4) 18452 18453/* ------------------------------ */ 18454.L_ALT_OP_UNUSED_9CFF: /* 0x19c */ 18455/* File: x86/alt_stub.S */ 18456/* 18457 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18458 * any interesting requests and then jump to the real instruction 18459 * handler. Unlike the Arm handler, we can't do this as a tail call 18460 * because rIBASE is caller save and we need to reload it. 18461 */ 18462 movl rSELF, %eax 18463 movl rPC, OUT_ARG0(%esp) 18464 movl %eax, OUT_ARG1(%esp) 18465 call dvmCheckInst # (dPC, self) 18466 movl rSELF, %ecx 18467 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18468 jmp *dvmAsmInstructionStart+(412*4) 18469 18470/* ------------------------------ */ 18471.L_ALT_OP_UNUSED_9DFF: /* 0x19d */ 18472/* File: x86/alt_stub.S */ 18473/* 18474 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18475 * any interesting requests and then jump to the real instruction 18476 * handler. Unlike the Arm handler, we can't do this as a tail call 18477 * because rIBASE is caller save and we need to reload it. 18478 */ 18479 movl rSELF, %eax 18480 movl rPC, OUT_ARG0(%esp) 18481 movl %eax, OUT_ARG1(%esp) 18482 call dvmCheckInst # (dPC, self) 18483 movl rSELF, %ecx 18484 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18485 jmp *dvmAsmInstructionStart+(413*4) 18486 18487/* ------------------------------ */ 18488.L_ALT_OP_UNUSED_9EFF: /* 0x19e */ 18489/* File: x86/alt_stub.S */ 18490/* 18491 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18492 * any interesting requests and then jump to the real instruction 18493 * handler. Unlike the Arm handler, we can't do this as a tail call 18494 * because rIBASE is caller save and we need to reload it. 18495 */ 18496 movl rSELF, %eax 18497 movl rPC, OUT_ARG0(%esp) 18498 movl %eax, OUT_ARG1(%esp) 18499 call dvmCheckInst # (dPC, self) 18500 movl rSELF, %ecx 18501 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18502 jmp *dvmAsmInstructionStart+(414*4) 18503 18504/* ------------------------------ */ 18505.L_ALT_OP_UNUSED_9FFF: /* 0x19f */ 18506/* File: x86/alt_stub.S */ 18507/* 18508 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18509 * any interesting requests and then jump to the real instruction 18510 * handler. Unlike the Arm handler, we can't do this as a tail call 18511 * because rIBASE is caller save and we need to reload it. 18512 */ 18513 movl rSELF, %eax 18514 movl rPC, OUT_ARG0(%esp) 18515 movl %eax, OUT_ARG1(%esp) 18516 call dvmCheckInst # (dPC, self) 18517 movl rSELF, %ecx 18518 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18519 jmp *dvmAsmInstructionStart+(415*4) 18520 18521/* ------------------------------ */ 18522.L_ALT_OP_UNUSED_A0FF: /* 0x1a0 */ 18523/* File: x86/alt_stub.S */ 18524/* 18525 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18526 * any interesting requests and then jump to the real instruction 18527 * handler. Unlike the Arm handler, we can't do this as a tail call 18528 * because rIBASE is caller save and we need to reload it. 18529 */ 18530 movl rSELF, %eax 18531 movl rPC, OUT_ARG0(%esp) 18532 movl %eax, OUT_ARG1(%esp) 18533 call dvmCheckInst # (dPC, self) 18534 movl rSELF, %ecx 18535 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18536 jmp *dvmAsmInstructionStart+(416*4) 18537 18538/* ------------------------------ */ 18539.L_ALT_OP_UNUSED_A1FF: /* 0x1a1 */ 18540/* File: x86/alt_stub.S */ 18541/* 18542 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18543 * any interesting requests and then jump to the real instruction 18544 * handler. Unlike the Arm handler, we can't do this as a tail call 18545 * because rIBASE is caller save and we need to reload it. 18546 */ 18547 movl rSELF, %eax 18548 movl rPC, OUT_ARG0(%esp) 18549 movl %eax, OUT_ARG1(%esp) 18550 call dvmCheckInst # (dPC, self) 18551 movl rSELF, %ecx 18552 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18553 jmp *dvmAsmInstructionStart+(417*4) 18554 18555/* ------------------------------ */ 18556.L_ALT_OP_UNUSED_A2FF: /* 0x1a2 */ 18557/* File: x86/alt_stub.S */ 18558/* 18559 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18560 * any interesting requests and then jump to the real instruction 18561 * handler. Unlike the Arm handler, we can't do this as a tail call 18562 * because rIBASE is caller save and we need to reload it. 18563 */ 18564 movl rSELF, %eax 18565 movl rPC, OUT_ARG0(%esp) 18566 movl %eax, OUT_ARG1(%esp) 18567 call dvmCheckInst # (dPC, self) 18568 movl rSELF, %ecx 18569 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18570 jmp *dvmAsmInstructionStart+(418*4) 18571 18572/* ------------------------------ */ 18573.L_ALT_OP_UNUSED_A3FF: /* 0x1a3 */ 18574/* File: x86/alt_stub.S */ 18575/* 18576 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18577 * any interesting requests and then jump to the real instruction 18578 * handler. Unlike the Arm handler, we can't do this as a tail call 18579 * because rIBASE is caller save and we need to reload it. 18580 */ 18581 movl rSELF, %eax 18582 movl rPC, OUT_ARG0(%esp) 18583 movl %eax, OUT_ARG1(%esp) 18584 call dvmCheckInst # (dPC, self) 18585 movl rSELF, %ecx 18586 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18587 jmp *dvmAsmInstructionStart+(419*4) 18588 18589/* ------------------------------ */ 18590.L_ALT_OP_UNUSED_A4FF: /* 0x1a4 */ 18591/* File: x86/alt_stub.S */ 18592/* 18593 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18594 * any interesting requests and then jump to the real instruction 18595 * handler. Unlike the Arm handler, we can't do this as a tail call 18596 * because rIBASE is caller save and we need to reload it. 18597 */ 18598 movl rSELF, %eax 18599 movl rPC, OUT_ARG0(%esp) 18600 movl %eax, OUT_ARG1(%esp) 18601 call dvmCheckInst # (dPC, self) 18602 movl rSELF, %ecx 18603 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18604 jmp *dvmAsmInstructionStart+(420*4) 18605 18606/* ------------------------------ */ 18607.L_ALT_OP_UNUSED_A5FF: /* 0x1a5 */ 18608/* File: x86/alt_stub.S */ 18609/* 18610 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18611 * any interesting requests and then jump to the real instruction 18612 * handler. Unlike the Arm handler, we can't do this as a tail call 18613 * because rIBASE is caller save and we need to reload it. 18614 */ 18615 movl rSELF, %eax 18616 movl rPC, OUT_ARG0(%esp) 18617 movl %eax, OUT_ARG1(%esp) 18618 call dvmCheckInst # (dPC, self) 18619 movl rSELF, %ecx 18620 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18621 jmp *dvmAsmInstructionStart+(421*4) 18622 18623/* ------------------------------ */ 18624.L_ALT_OP_UNUSED_A6FF: /* 0x1a6 */ 18625/* File: x86/alt_stub.S */ 18626/* 18627 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18628 * any interesting requests and then jump to the real instruction 18629 * handler. Unlike the Arm handler, we can't do this as a tail call 18630 * because rIBASE is caller save and we need to reload it. 18631 */ 18632 movl rSELF, %eax 18633 movl rPC, OUT_ARG0(%esp) 18634 movl %eax, OUT_ARG1(%esp) 18635 call dvmCheckInst # (dPC, self) 18636 movl rSELF, %ecx 18637 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18638 jmp *dvmAsmInstructionStart+(422*4) 18639 18640/* ------------------------------ */ 18641.L_ALT_OP_UNUSED_A7FF: /* 0x1a7 */ 18642/* File: x86/alt_stub.S */ 18643/* 18644 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18645 * any interesting requests and then jump to the real instruction 18646 * handler. Unlike the Arm handler, we can't do this as a tail call 18647 * because rIBASE is caller save and we need to reload it. 18648 */ 18649 movl rSELF, %eax 18650 movl rPC, OUT_ARG0(%esp) 18651 movl %eax, OUT_ARG1(%esp) 18652 call dvmCheckInst # (dPC, self) 18653 movl rSELF, %ecx 18654 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18655 jmp *dvmAsmInstructionStart+(423*4) 18656 18657/* ------------------------------ */ 18658.L_ALT_OP_UNUSED_A8FF: /* 0x1a8 */ 18659/* File: x86/alt_stub.S */ 18660/* 18661 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18662 * any interesting requests and then jump to the real instruction 18663 * handler. Unlike the Arm handler, we can't do this as a tail call 18664 * because rIBASE is caller save and we need to reload it. 18665 */ 18666 movl rSELF, %eax 18667 movl rPC, OUT_ARG0(%esp) 18668 movl %eax, OUT_ARG1(%esp) 18669 call dvmCheckInst # (dPC, self) 18670 movl rSELF, %ecx 18671 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18672 jmp *dvmAsmInstructionStart+(424*4) 18673 18674/* ------------------------------ */ 18675.L_ALT_OP_UNUSED_A9FF: /* 0x1a9 */ 18676/* File: x86/alt_stub.S */ 18677/* 18678 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18679 * any interesting requests and then jump to the real instruction 18680 * handler. Unlike the Arm handler, we can't do this as a tail call 18681 * because rIBASE is caller save and we need to reload it. 18682 */ 18683 movl rSELF, %eax 18684 movl rPC, OUT_ARG0(%esp) 18685 movl %eax, OUT_ARG1(%esp) 18686 call dvmCheckInst # (dPC, self) 18687 movl rSELF, %ecx 18688 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18689 jmp *dvmAsmInstructionStart+(425*4) 18690 18691/* ------------------------------ */ 18692.L_ALT_OP_UNUSED_AAFF: /* 0x1aa */ 18693/* File: x86/alt_stub.S */ 18694/* 18695 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18696 * any interesting requests and then jump to the real instruction 18697 * handler. Unlike the Arm handler, we can't do this as a tail call 18698 * because rIBASE is caller save and we need to reload it. 18699 */ 18700 movl rSELF, %eax 18701 movl rPC, OUT_ARG0(%esp) 18702 movl %eax, OUT_ARG1(%esp) 18703 call dvmCheckInst # (dPC, self) 18704 movl rSELF, %ecx 18705 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18706 jmp *dvmAsmInstructionStart+(426*4) 18707 18708/* ------------------------------ */ 18709.L_ALT_OP_UNUSED_ABFF: /* 0x1ab */ 18710/* File: x86/alt_stub.S */ 18711/* 18712 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18713 * any interesting requests and then jump to the real instruction 18714 * handler. Unlike the Arm handler, we can't do this as a tail call 18715 * because rIBASE is caller save and we need to reload it. 18716 */ 18717 movl rSELF, %eax 18718 movl rPC, OUT_ARG0(%esp) 18719 movl %eax, OUT_ARG1(%esp) 18720 call dvmCheckInst # (dPC, self) 18721 movl rSELF, %ecx 18722 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18723 jmp *dvmAsmInstructionStart+(427*4) 18724 18725/* ------------------------------ */ 18726.L_ALT_OP_UNUSED_ACFF: /* 0x1ac */ 18727/* File: x86/alt_stub.S */ 18728/* 18729 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18730 * any interesting requests and then jump to the real instruction 18731 * handler. Unlike the Arm handler, we can't do this as a tail call 18732 * because rIBASE is caller save and we need to reload it. 18733 */ 18734 movl rSELF, %eax 18735 movl rPC, OUT_ARG0(%esp) 18736 movl %eax, OUT_ARG1(%esp) 18737 call dvmCheckInst # (dPC, self) 18738 movl rSELF, %ecx 18739 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18740 jmp *dvmAsmInstructionStart+(428*4) 18741 18742/* ------------------------------ */ 18743.L_ALT_OP_UNUSED_ADFF: /* 0x1ad */ 18744/* File: x86/alt_stub.S */ 18745/* 18746 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18747 * any interesting requests and then jump to the real instruction 18748 * handler. Unlike the Arm handler, we can't do this as a tail call 18749 * because rIBASE is caller save and we need to reload it. 18750 */ 18751 movl rSELF, %eax 18752 movl rPC, OUT_ARG0(%esp) 18753 movl %eax, OUT_ARG1(%esp) 18754 call dvmCheckInst # (dPC, self) 18755 movl rSELF, %ecx 18756 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18757 jmp *dvmAsmInstructionStart+(429*4) 18758 18759/* ------------------------------ */ 18760.L_ALT_OP_UNUSED_AEFF: /* 0x1ae */ 18761/* File: x86/alt_stub.S */ 18762/* 18763 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18764 * any interesting requests and then jump to the real instruction 18765 * handler. Unlike the Arm handler, we can't do this as a tail call 18766 * because rIBASE is caller save and we need to reload it. 18767 */ 18768 movl rSELF, %eax 18769 movl rPC, OUT_ARG0(%esp) 18770 movl %eax, OUT_ARG1(%esp) 18771 call dvmCheckInst # (dPC, self) 18772 movl rSELF, %ecx 18773 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18774 jmp *dvmAsmInstructionStart+(430*4) 18775 18776/* ------------------------------ */ 18777.L_ALT_OP_UNUSED_AFFF: /* 0x1af */ 18778/* File: x86/alt_stub.S */ 18779/* 18780 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18781 * any interesting requests and then jump to the real instruction 18782 * handler. Unlike the Arm handler, we can't do this as a tail call 18783 * because rIBASE is caller save and we need to reload it. 18784 */ 18785 movl rSELF, %eax 18786 movl rPC, OUT_ARG0(%esp) 18787 movl %eax, OUT_ARG1(%esp) 18788 call dvmCheckInst # (dPC, self) 18789 movl rSELF, %ecx 18790 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18791 jmp *dvmAsmInstructionStart+(431*4) 18792 18793/* ------------------------------ */ 18794.L_ALT_OP_UNUSED_B0FF: /* 0x1b0 */ 18795/* File: x86/alt_stub.S */ 18796/* 18797 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18798 * any interesting requests and then jump to the real instruction 18799 * handler. Unlike the Arm handler, we can't do this as a tail call 18800 * because rIBASE is caller save and we need to reload it. 18801 */ 18802 movl rSELF, %eax 18803 movl rPC, OUT_ARG0(%esp) 18804 movl %eax, OUT_ARG1(%esp) 18805 call dvmCheckInst # (dPC, self) 18806 movl rSELF, %ecx 18807 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18808 jmp *dvmAsmInstructionStart+(432*4) 18809 18810/* ------------------------------ */ 18811.L_ALT_OP_UNUSED_B1FF: /* 0x1b1 */ 18812/* File: x86/alt_stub.S */ 18813/* 18814 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18815 * any interesting requests and then jump to the real instruction 18816 * handler. Unlike the Arm handler, we can't do this as a tail call 18817 * because rIBASE is caller save and we need to reload it. 18818 */ 18819 movl rSELF, %eax 18820 movl rPC, OUT_ARG0(%esp) 18821 movl %eax, OUT_ARG1(%esp) 18822 call dvmCheckInst # (dPC, self) 18823 movl rSELF, %ecx 18824 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18825 jmp *dvmAsmInstructionStart+(433*4) 18826 18827/* ------------------------------ */ 18828.L_ALT_OP_UNUSED_B2FF: /* 0x1b2 */ 18829/* File: x86/alt_stub.S */ 18830/* 18831 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18832 * any interesting requests and then jump to the real instruction 18833 * handler. Unlike the Arm handler, we can't do this as a tail call 18834 * because rIBASE is caller save and we need to reload it. 18835 */ 18836 movl rSELF, %eax 18837 movl rPC, OUT_ARG0(%esp) 18838 movl %eax, OUT_ARG1(%esp) 18839 call dvmCheckInst # (dPC, self) 18840 movl rSELF, %ecx 18841 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18842 jmp *dvmAsmInstructionStart+(434*4) 18843 18844/* ------------------------------ */ 18845.L_ALT_OP_UNUSED_B3FF: /* 0x1b3 */ 18846/* File: x86/alt_stub.S */ 18847/* 18848 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18849 * any interesting requests and then jump to the real instruction 18850 * handler. Unlike the Arm handler, we can't do this as a tail call 18851 * because rIBASE is caller save and we need to reload it. 18852 */ 18853 movl rSELF, %eax 18854 movl rPC, OUT_ARG0(%esp) 18855 movl %eax, OUT_ARG1(%esp) 18856 call dvmCheckInst # (dPC, self) 18857 movl rSELF, %ecx 18858 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18859 jmp *dvmAsmInstructionStart+(435*4) 18860 18861/* ------------------------------ */ 18862.L_ALT_OP_UNUSED_B4FF: /* 0x1b4 */ 18863/* File: x86/alt_stub.S */ 18864/* 18865 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18866 * any interesting requests and then jump to the real instruction 18867 * handler. Unlike the Arm handler, we can't do this as a tail call 18868 * because rIBASE is caller save and we need to reload it. 18869 */ 18870 movl rSELF, %eax 18871 movl rPC, OUT_ARG0(%esp) 18872 movl %eax, OUT_ARG1(%esp) 18873 call dvmCheckInst # (dPC, self) 18874 movl rSELF, %ecx 18875 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18876 jmp *dvmAsmInstructionStart+(436*4) 18877 18878/* ------------------------------ */ 18879.L_ALT_OP_UNUSED_B5FF: /* 0x1b5 */ 18880/* File: x86/alt_stub.S */ 18881/* 18882 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18883 * any interesting requests and then jump to the real instruction 18884 * handler. Unlike the Arm handler, we can't do this as a tail call 18885 * because rIBASE is caller save and we need to reload it. 18886 */ 18887 movl rSELF, %eax 18888 movl rPC, OUT_ARG0(%esp) 18889 movl %eax, OUT_ARG1(%esp) 18890 call dvmCheckInst # (dPC, self) 18891 movl rSELF, %ecx 18892 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18893 jmp *dvmAsmInstructionStart+(437*4) 18894 18895/* ------------------------------ */ 18896.L_ALT_OP_UNUSED_B6FF: /* 0x1b6 */ 18897/* File: x86/alt_stub.S */ 18898/* 18899 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18900 * any interesting requests and then jump to the real instruction 18901 * handler. Unlike the Arm handler, we can't do this as a tail call 18902 * because rIBASE is caller save and we need to reload it. 18903 */ 18904 movl rSELF, %eax 18905 movl rPC, OUT_ARG0(%esp) 18906 movl %eax, OUT_ARG1(%esp) 18907 call dvmCheckInst # (dPC, self) 18908 movl rSELF, %ecx 18909 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18910 jmp *dvmAsmInstructionStart+(438*4) 18911 18912/* ------------------------------ */ 18913.L_ALT_OP_UNUSED_B7FF: /* 0x1b7 */ 18914/* File: x86/alt_stub.S */ 18915/* 18916 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18917 * any interesting requests and then jump to the real instruction 18918 * handler. Unlike the Arm handler, we can't do this as a tail call 18919 * because rIBASE is caller save and we need to reload it. 18920 */ 18921 movl rSELF, %eax 18922 movl rPC, OUT_ARG0(%esp) 18923 movl %eax, OUT_ARG1(%esp) 18924 call dvmCheckInst # (dPC, self) 18925 movl rSELF, %ecx 18926 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18927 jmp *dvmAsmInstructionStart+(439*4) 18928 18929/* ------------------------------ */ 18930.L_ALT_OP_UNUSED_B8FF: /* 0x1b8 */ 18931/* File: x86/alt_stub.S */ 18932/* 18933 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18934 * any interesting requests and then jump to the real instruction 18935 * handler. Unlike the Arm handler, we can't do this as a tail call 18936 * because rIBASE is caller save and we need to reload it. 18937 */ 18938 movl rSELF, %eax 18939 movl rPC, OUT_ARG0(%esp) 18940 movl %eax, OUT_ARG1(%esp) 18941 call dvmCheckInst # (dPC, self) 18942 movl rSELF, %ecx 18943 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18944 jmp *dvmAsmInstructionStart+(440*4) 18945 18946/* ------------------------------ */ 18947.L_ALT_OP_UNUSED_B9FF: /* 0x1b9 */ 18948/* File: x86/alt_stub.S */ 18949/* 18950 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18951 * any interesting requests and then jump to the real instruction 18952 * handler. Unlike the Arm handler, we can't do this as a tail call 18953 * because rIBASE is caller save and we need to reload it. 18954 */ 18955 movl rSELF, %eax 18956 movl rPC, OUT_ARG0(%esp) 18957 movl %eax, OUT_ARG1(%esp) 18958 call dvmCheckInst # (dPC, self) 18959 movl rSELF, %ecx 18960 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18961 jmp *dvmAsmInstructionStart+(441*4) 18962 18963/* ------------------------------ */ 18964.L_ALT_OP_UNUSED_BAFF: /* 0x1ba */ 18965/* File: x86/alt_stub.S */ 18966/* 18967 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18968 * any interesting requests and then jump to the real instruction 18969 * handler. Unlike the Arm handler, we can't do this as a tail call 18970 * because rIBASE is caller save and we need to reload it. 18971 */ 18972 movl rSELF, %eax 18973 movl rPC, OUT_ARG0(%esp) 18974 movl %eax, OUT_ARG1(%esp) 18975 call dvmCheckInst # (dPC, self) 18976 movl rSELF, %ecx 18977 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18978 jmp *dvmAsmInstructionStart+(442*4) 18979 18980/* ------------------------------ */ 18981.L_ALT_OP_UNUSED_BBFF: /* 0x1bb */ 18982/* File: x86/alt_stub.S */ 18983/* 18984 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18985 * any interesting requests and then jump to the real instruction 18986 * handler. Unlike the Arm handler, we can't do this as a tail call 18987 * because rIBASE is caller save and we need to reload it. 18988 */ 18989 movl rSELF, %eax 18990 movl rPC, OUT_ARG0(%esp) 18991 movl %eax, OUT_ARG1(%esp) 18992 call dvmCheckInst # (dPC, self) 18993 movl rSELF, %ecx 18994 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18995 jmp *dvmAsmInstructionStart+(443*4) 18996 18997/* ------------------------------ */ 18998.L_ALT_OP_UNUSED_BCFF: /* 0x1bc */ 18999/* File: x86/alt_stub.S */ 19000/* 19001 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19002 * any interesting requests and then jump to the real instruction 19003 * handler. Unlike the Arm handler, we can't do this as a tail call 19004 * because rIBASE is caller save and we need to reload it. 19005 */ 19006 movl rSELF, %eax 19007 movl rPC, OUT_ARG0(%esp) 19008 movl %eax, OUT_ARG1(%esp) 19009 call dvmCheckInst # (dPC, self) 19010 movl rSELF, %ecx 19011 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19012 jmp *dvmAsmInstructionStart+(444*4) 19013 19014/* ------------------------------ */ 19015.L_ALT_OP_UNUSED_BDFF: /* 0x1bd */ 19016/* File: x86/alt_stub.S */ 19017/* 19018 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19019 * any interesting requests and then jump to the real instruction 19020 * handler. Unlike the Arm handler, we can't do this as a tail call 19021 * because rIBASE is caller save and we need to reload it. 19022 */ 19023 movl rSELF, %eax 19024 movl rPC, OUT_ARG0(%esp) 19025 movl %eax, OUT_ARG1(%esp) 19026 call dvmCheckInst # (dPC, self) 19027 movl rSELF, %ecx 19028 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19029 jmp *dvmAsmInstructionStart+(445*4) 19030 19031/* ------------------------------ */ 19032.L_ALT_OP_UNUSED_BEFF: /* 0x1be */ 19033/* File: x86/alt_stub.S */ 19034/* 19035 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19036 * any interesting requests and then jump to the real instruction 19037 * handler. Unlike the Arm handler, we can't do this as a tail call 19038 * because rIBASE is caller save and we need to reload it. 19039 */ 19040 movl rSELF, %eax 19041 movl rPC, OUT_ARG0(%esp) 19042 movl %eax, OUT_ARG1(%esp) 19043 call dvmCheckInst # (dPC, self) 19044 movl rSELF, %ecx 19045 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19046 jmp *dvmAsmInstructionStart+(446*4) 19047 19048/* ------------------------------ */ 19049.L_ALT_OP_UNUSED_BFFF: /* 0x1bf */ 19050/* File: x86/alt_stub.S */ 19051/* 19052 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19053 * any interesting requests and then jump to the real instruction 19054 * handler. Unlike the Arm handler, we can't do this as a tail call 19055 * because rIBASE is caller save and we need to reload it. 19056 */ 19057 movl rSELF, %eax 19058 movl rPC, OUT_ARG0(%esp) 19059 movl %eax, OUT_ARG1(%esp) 19060 call dvmCheckInst # (dPC, self) 19061 movl rSELF, %ecx 19062 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19063 jmp *dvmAsmInstructionStart+(447*4) 19064 19065/* ------------------------------ */ 19066.L_ALT_OP_UNUSED_C0FF: /* 0x1c0 */ 19067/* File: x86/alt_stub.S */ 19068/* 19069 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19070 * any interesting requests and then jump to the real instruction 19071 * handler. Unlike the Arm handler, we can't do this as a tail call 19072 * because rIBASE is caller save and we need to reload it. 19073 */ 19074 movl rSELF, %eax 19075 movl rPC, OUT_ARG0(%esp) 19076 movl %eax, OUT_ARG1(%esp) 19077 call dvmCheckInst # (dPC, self) 19078 movl rSELF, %ecx 19079 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19080 jmp *dvmAsmInstructionStart+(448*4) 19081 19082/* ------------------------------ */ 19083.L_ALT_OP_UNUSED_C1FF: /* 0x1c1 */ 19084/* File: x86/alt_stub.S */ 19085/* 19086 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19087 * any interesting requests and then jump to the real instruction 19088 * handler. Unlike the Arm handler, we can't do this as a tail call 19089 * because rIBASE is caller save and we need to reload it. 19090 */ 19091 movl rSELF, %eax 19092 movl rPC, OUT_ARG0(%esp) 19093 movl %eax, OUT_ARG1(%esp) 19094 call dvmCheckInst # (dPC, self) 19095 movl rSELF, %ecx 19096 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19097 jmp *dvmAsmInstructionStart+(449*4) 19098 19099/* ------------------------------ */ 19100.L_ALT_OP_UNUSED_C2FF: /* 0x1c2 */ 19101/* File: x86/alt_stub.S */ 19102/* 19103 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19104 * any interesting requests and then jump to the real instruction 19105 * handler. Unlike the Arm handler, we can't do this as a tail call 19106 * because rIBASE is caller save and we need to reload it. 19107 */ 19108 movl rSELF, %eax 19109 movl rPC, OUT_ARG0(%esp) 19110 movl %eax, OUT_ARG1(%esp) 19111 call dvmCheckInst # (dPC, self) 19112 movl rSELF, %ecx 19113 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19114 jmp *dvmAsmInstructionStart+(450*4) 19115 19116/* ------------------------------ */ 19117.L_ALT_OP_UNUSED_C3FF: /* 0x1c3 */ 19118/* File: x86/alt_stub.S */ 19119/* 19120 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19121 * any interesting requests and then jump to the real instruction 19122 * handler. Unlike the Arm handler, we can't do this as a tail call 19123 * because rIBASE is caller save and we need to reload it. 19124 */ 19125 movl rSELF, %eax 19126 movl rPC, OUT_ARG0(%esp) 19127 movl %eax, OUT_ARG1(%esp) 19128 call dvmCheckInst # (dPC, self) 19129 movl rSELF, %ecx 19130 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19131 jmp *dvmAsmInstructionStart+(451*4) 19132 19133/* ------------------------------ */ 19134.L_ALT_OP_UNUSED_C4FF: /* 0x1c4 */ 19135/* File: x86/alt_stub.S */ 19136/* 19137 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19138 * any interesting requests and then jump to the real instruction 19139 * handler. Unlike the Arm handler, we can't do this as a tail call 19140 * because rIBASE is caller save and we need to reload it. 19141 */ 19142 movl rSELF, %eax 19143 movl rPC, OUT_ARG0(%esp) 19144 movl %eax, OUT_ARG1(%esp) 19145 call dvmCheckInst # (dPC, self) 19146 movl rSELF, %ecx 19147 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19148 jmp *dvmAsmInstructionStart+(452*4) 19149 19150/* ------------------------------ */ 19151.L_ALT_OP_UNUSED_C5FF: /* 0x1c5 */ 19152/* File: x86/alt_stub.S */ 19153/* 19154 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19155 * any interesting requests and then jump to the real instruction 19156 * handler. Unlike the Arm handler, we can't do this as a tail call 19157 * because rIBASE is caller save and we need to reload it. 19158 */ 19159 movl rSELF, %eax 19160 movl rPC, OUT_ARG0(%esp) 19161 movl %eax, OUT_ARG1(%esp) 19162 call dvmCheckInst # (dPC, self) 19163 movl rSELF, %ecx 19164 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19165 jmp *dvmAsmInstructionStart+(453*4) 19166 19167/* ------------------------------ */ 19168.L_ALT_OP_UNUSED_C6FF: /* 0x1c6 */ 19169/* File: x86/alt_stub.S */ 19170/* 19171 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19172 * any interesting requests and then jump to the real instruction 19173 * handler. Unlike the Arm handler, we can't do this as a tail call 19174 * because rIBASE is caller save and we need to reload it. 19175 */ 19176 movl rSELF, %eax 19177 movl rPC, OUT_ARG0(%esp) 19178 movl %eax, OUT_ARG1(%esp) 19179 call dvmCheckInst # (dPC, self) 19180 movl rSELF, %ecx 19181 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19182 jmp *dvmAsmInstructionStart+(454*4) 19183 19184/* ------------------------------ */ 19185.L_ALT_OP_UNUSED_C7FF: /* 0x1c7 */ 19186/* File: x86/alt_stub.S */ 19187/* 19188 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19189 * any interesting requests and then jump to the real instruction 19190 * handler. Unlike the Arm handler, we can't do this as a tail call 19191 * because rIBASE is caller save and we need to reload it. 19192 */ 19193 movl rSELF, %eax 19194 movl rPC, OUT_ARG0(%esp) 19195 movl %eax, OUT_ARG1(%esp) 19196 call dvmCheckInst # (dPC, self) 19197 movl rSELF, %ecx 19198 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19199 jmp *dvmAsmInstructionStart+(455*4) 19200 19201/* ------------------------------ */ 19202.L_ALT_OP_UNUSED_C8FF: /* 0x1c8 */ 19203/* File: x86/alt_stub.S */ 19204/* 19205 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19206 * any interesting requests and then jump to the real instruction 19207 * handler. Unlike the Arm handler, we can't do this as a tail call 19208 * because rIBASE is caller save and we need to reload it. 19209 */ 19210 movl rSELF, %eax 19211 movl rPC, OUT_ARG0(%esp) 19212 movl %eax, OUT_ARG1(%esp) 19213 call dvmCheckInst # (dPC, self) 19214 movl rSELF, %ecx 19215 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19216 jmp *dvmAsmInstructionStart+(456*4) 19217 19218/* ------------------------------ */ 19219.L_ALT_OP_UNUSED_C9FF: /* 0x1c9 */ 19220/* File: x86/alt_stub.S */ 19221/* 19222 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19223 * any interesting requests and then jump to the real instruction 19224 * handler. Unlike the Arm handler, we can't do this as a tail call 19225 * because rIBASE is caller save and we need to reload it. 19226 */ 19227 movl rSELF, %eax 19228 movl rPC, OUT_ARG0(%esp) 19229 movl %eax, OUT_ARG1(%esp) 19230 call dvmCheckInst # (dPC, self) 19231 movl rSELF, %ecx 19232 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19233 jmp *dvmAsmInstructionStart+(457*4) 19234 19235/* ------------------------------ */ 19236.L_ALT_OP_UNUSED_CAFF: /* 0x1ca */ 19237/* File: x86/alt_stub.S */ 19238/* 19239 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19240 * any interesting requests and then jump to the real instruction 19241 * handler. Unlike the Arm handler, we can't do this as a tail call 19242 * because rIBASE is caller save and we need to reload it. 19243 */ 19244 movl rSELF, %eax 19245 movl rPC, OUT_ARG0(%esp) 19246 movl %eax, OUT_ARG1(%esp) 19247 call dvmCheckInst # (dPC, self) 19248 movl rSELF, %ecx 19249 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19250 jmp *dvmAsmInstructionStart+(458*4) 19251 19252/* ------------------------------ */ 19253.L_ALT_OP_UNUSED_CBFF: /* 0x1cb */ 19254/* File: x86/alt_stub.S */ 19255/* 19256 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19257 * any interesting requests and then jump to the real instruction 19258 * handler. Unlike the Arm handler, we can't do this as a tail call 19259 * because rIBASE is caller save and we need to reload it. 19260 */ 19261 movl rSELF, %eax 19262 movl rPC, OUT_ARG0(%esp) 19263 movl %eax, OUT_ARG1(%esp) 19264 call dvmCheckInst # (dPC, self) 19265 movl rSELF, %ecx 19266 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19267 jmp *dvmAsmInstructionStart+(459*4) 19268 19269/* ------------------------------ */ 19270.L_ALT_OP_UNUSED_CCFF: /* 0x1cc */ 19271/* File: x86/alt_stub.S */ 19272/* 19273 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19274 * any interesting requests and then jump to the real instruction 19275 * handler. Unlike the Arm handler, we can't do this as a tail call 19276 * because rIBASE is caller save and we need to reload it. 19277 */ 19278 movl rSELF, %eax 19279 movl rPC, OUT_ARG0(%esp) 19280 movl %eax, OUT_ARG1(%esp) 19281 call dvmCheckInst # (dPC, self) 19282 movl rSELF, %ecx 19283 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19284 jmp *dvmAsmInstructionStart+(460*4) 19285 19286/* ------------------------------ */ 19287.L_ALT_OP_UNUSED_CDFF: /* 0x1cd */ 19288/* File: x86/alt_stub.S */ 19289/* 19290 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19291 * any interesting requests and then jump to the real instruction 19292 * handler. Unlike the Arm handler, we can't do this as a tail call 19293 * because rIBASE is caller save and we need to reload it. 19294 */ 19295 movl rSELF, %eax 19296 movl rPC, OUT_ARG0(%esp) 19297 movl %eax, OUT_ARG1(%esp) 19298 call dvmCheckInst # (dPC, self) 19299 movl rSELF, %ecx 19300 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19301 jmp *dvmAsmInstructionStart+(461*4) 19302 19303/* ------------------------------ */ 19304.L_ALT_OP_UNUSED_CEFF: /* 0x1ce */ 19305/* File: x86/alt_stub.S */ 19306/* 19307 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19308 * any interesting requests and then jump to the real instruction 19309 * handler. Unlike the Arm handler, we can't do this as a tail call 19310 * because rIBASE is caller save and we need to reload it. 19311 */ 19312 movl rSELF, %eax 19313 movl rPC, OUT_ARG0(%esp) 19314 movl %eax, OUT_ARG1(%esp) 19315 call dvmCheckInst # (dPC, self) 19316 movl rSELF, %ecx 19317 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19318 jmp *dvmAsmInstructionStart+(462*4) 19319 19320/* ------------------------------ */ 19321.L_ALT_OP_UNUSED_CFFF: /* 0x1cf */ 19322/* File: x86/alt_stub.S */ 19323/* 19324 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19325 * any interesting requests and then jump to the real instruction 19326 * handler. Unlike the Arm handler, we can't do this as a tail call 19327 * because rIBASE is caller save and we need to reload it. 19328 */ 19329 movl rSELF, %eax 19330 movl rPC, OUT_ARG0(%esp) 19331 movl %eax, OUT_ARG1(%esp) 19332 call dvmCheckInst # (dPC, self) 19333 movl rSELF, %ecx 19334 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19335 jmp *dvmAsmInstructionStart+(463*4) 19336 19337/* ------------------------------ */ 19338.L_ALT_OP_UNUSED_D0FF: /* 0x1d0 */ 19339/* File: x86/alt_stub.S */ 19340/* 19341 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19342 * any interesting requests and then jump to the real instruction 19343 * handler. Unlike the Arm handler, we can't do this as a tail call 19344 * because rIBASE is caller save and we need to reload it. 19345 */ 19346 movl rSELF, %eax 19347 movl rPC, OUT_ARG0(%esp) 19348 movl %eax, OUT_ARG1(%esp) 19349 call dvmCheckInst # (dPC, self) 19350 movl rSELF, %ecx 19351 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19352 jmp *dvmAsmInstructionStart+(464*4) 19353 19354/* ------------------------------ */ 19355.L_ALT_OP_UNUSED_D1FF: /* 0x1d1 */ 19356/* File: x86/alt_stub.S */ 19357/* 19358 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19359 * any interesting requests and then jump to the real instruction 19360 * handler. Unlike the Arm handler, we can't do this as a tail call 19361 * because rIBASE is caller save and we need to reload it. 19362 */ 19363 movl rSELF, %eax 19364 movl rPC, OUT_ARG0(%esp) 19365 movl %eax, OUT_ARG1(%esp) 19366 call dvmCheckInst # (dPC, self) 19367 movl rSELF, %ecx 19368 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19369 jmp *dvmAsmInstructionStart+(465*4) 19370 19371/* ------------------------------ */ 19372.L_ALT_OP_UNUSED_D2FF: /* 0x1d2 */ 19373/* File: x86/alt_stub.S */ 19374/* 19375 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19376 * any interesting requests and then jump to the real instruction 19377 * handler. Unlike the Arm handler, we can't do this as a tail call 19378 * because rIBASE is caller save and we need to reload it. 19379 */ 19380 movl rSELF, %eax 19381 movl rPC, OUT_ARG0(%esp) 19382 movl %eax, OUT_ARG1(%esp) 19383 call dvmCheckInst # (dPC, self) 19384 movl rSELF, %ecx 19385 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19386 jmp *dvmAsmInstructionStart+(466*4) 19387 19388/* ------------------------------ */ 19389.L_ALT_OP_UNUSED_D3FF: /* 0x1d3 */ 19390/* File: x86/alt_stub.S */ 19391/* 19392 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19393 * any interesting requests and then jump to the real instruction 19394 * handler. Unlike the Arm handler, we can't do this as a tail call 19395 * because rIBASE is caller save and we need to reload it. 19396 */ 19397 movl rSELF, %eax 19398 movl rPC, OUT_ARG0(%esp) 19399 movl %eax, OUT_ARG1(%esp) 19400 call dvmCheckInst # (dPC, self) 19401 movl rSELF, %ecx 19402 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19403 jmp *dvmAsmInstructionStart+(467*4) 19404 19405/* ------------------------------ */ 19406.L_ALT_OP_UNUSED_D4FF: /* 0x1d4 */ 19407/* File: x86/alt_stub.S */ 19408/* 19409 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19410 * any interesting requests and then jump to the real instruction 19411 * handler. Unlike the Arm handler, we can't do this as a tail call 19412 * because rIBASE is caller save and we need to reload it. 19413 */ 19414 movl rSELF, %eax 19415 movl rPC, OUT_ARG0(%esp) 19416 movl %eax, OUT_ARG1(%esp) 19417 call dvmCheckInst # (dPC, self) 19418 movl rSELF, %ecx 19419 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19420 jmp *dvmAsmInstructionStart+(468*4) 19421 19422/* ------------------------------ */ 19423.L_ALT_OP_UNUSED_D5FF: /* 0x1d5 */ 19424/* File: x86/alt_stub.S */ 19425/* 19426 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19427 * any interesting requests and then jump to the real instruction 19428 * handler. Unlike the Arm handler, we can't do this as a tail call 19429 * because rIBASE is caller save and we need to reload it. 19430 */ 19431 movl rSELF, %eax 19432 movl rPC, OUT_ARG0(%esp) 19433 movl %eax, OUT_ARG1(%esp) 19434 call dvmCheckInst # (dPC, self) 19435 movl rSELF, %ecx 19436 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19437 jmp *dvmAsmInstructionStart+(469*4) 19438 19439/* ------------------------------ */ 19440.L_ALT_OP_UNUSED_D6FF: /* 0x1d6 */ 19441/* File: x86/alt_stub.S */ 19442/* 19443 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19444 * any interesting requests and then jump to the real instruction 19445 * handler. Unlike the Arm handler, we can't do this as a tail call 19446 * because rIBASE is caller save and we need to reload it. 19447 */ 19448 movl rSELF, %eax 19449 movl rPC, OUT_ARG0(%esp) 19450 movl %eax, OUT_ARG1(%esp) 19451 call dvmCheckInst # (dPC, self) 19452 movl rSELF, %ecx 19453 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19454 jmp *dvmAsmInstructionStart+(470*4) 19455 19456/* ------------------------------ */ 19457.L_ALT_OP_UNUSED_D7FF: /* 0x1d7 */ 19458/* File: x86/alt_stub.S */ 19459/* 19460 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19461 * any interesting requests and then jump to the real instruction 19462 * handler. Unlike the Arm handler, we can't do this as a tail call 19463 * because rIBASE is caller save and we need to reload it. 19464 */ 19465 movl rSELF, %eax 19466 movl rPC, OUT_ARG0(%esp) 19467 movl %eax, OUT_ARG1(%esp) 19468 call dvmCheckInst # (dPC, self) 19469 movl rSELF, %ecx 19470 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19471 jmp *dvmAsmInstructionStart+(471*4) 19472 19473/* ------------------------------ */ 19474.L_ALT_OP_UNUSED_D8FF: /* 0x1d8 */ 19475/* File: x86/alt_stub.S */ 19476/* 19477 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19478 * any interesting requests and then jump to the real instruction 19479 * handler. Unlike the Arm handler, we can't do this as a tail call 19480 * because rIBASE is caller save and we need to reload it. 19481 */ 19482 movl rSELF, %eax 19483 movl rPC, OUT_ARG0(%esp) 19484 movl %eax, OUT_ARG1(%esp) 19485 call dvmCheckInst # (dPC, self) 19486 movl rSELF, %ecx 19487 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19488 jmp *dvmAsmInstructionStart+(472*4) 19489 19490/* ------------------------------ */ 19491.L_ALT_OP_UNUSED_D9FF: /* 0x1d9 */ 19492/* File: x86/alt_stub.S */ 19493/* 19494 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19495 * any interesting requests and then jump to the real instruction 19496 * handler. Unlike the Arm handler, we can't do this as a tail call 19497 * because rIBASE is caller save and we need to reload it. 19498 */ 19499 movl rSELF, %eax 19500 movl rPC, OUT_ARG0(%esp) 19501 movl %eax, OUT_ARG1(%esp) 19502 call dvmCheckInst # (dPC, self) 19503 movl rSELF, %ecx 19504 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19505 jmp *dvmAsmInstructionStart+(473*4) 19506 19507/* ------------------------------ */ 19508.L_ALT_OP_UNUSED_DAFF: /* 0x1da */ 19509/* File: x86/alt_stub.S */ 19510/* 19511 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19512 * any interesting requests and then jump to the real instruction 19513 * handler. Unlike the Arm handler, we can't do this as a tail call 19514 * because rIBASE is caller save and we need to reload it. 19515 */ 19516 movl rSELF, %eax 19517 movl rPC, OUT_ARG0(%esp) 19518 movl %eax, OUT_ARG1(%esp) 19519 call dvmCheckInst # (dPC, self) 19520 movl rSELF, %ecx 19521 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19522 jmp *dvmAsmInstructionStart+(474*4) 19523 19524/* ------------------------------ */ 19525.L_ALT_OP_UNUSED_DBFF: /* 0x1db */ 19526/* File: x86/alt_stub.S */ 19527/* 19528 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19529 * any interesting requests and then jump to the real instruction 19530 * handler. Unlike the Arm handler, we can't do this as a tail call 19531 * because rIBASE is caller save and we need to reload it. 19532 */ 19533 movl rSELF, %eax 19534 movl rPC, OUT_ARG0(%esp) 19535 movl %eax, OUT_ARG1(%esp) 19536 call dvmCheckInst # (dPC, self) 19537 movl rSELF, %ecx 19538 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19539 jmp *dvmAsmInstructionStart+(475*4) 19540 19541/* ------------------------------ */ 19542.L_ALT_OP_UNUSED_DCFF: /* 0x1dc */ 19543/* File: x86/alt_stub.S */ 19544/* 19545 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19546 * any interesting requests and then jump to the real instruction 19547 * handler. Unlike the Arm handler, we can't do this as a tail call 19548 * because rIBASE is caller save and we need to reload it. 19549 */ 19550 movl rSELF, %eax 19551 movl rPC, OUT_ARG0(%esp) 19552 movl %eax, OUT_ARG1(%esp) 19553 call dvmCheckInst # (dPC, self) 19554 movl rSELF, %ecx 19555 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19556 jmp *dvmAsmInstructionStart+(476*4) 19557 19558/* ------------------------------ */ 19559.L_ALT_OP_UNUSED_DDFF: /* 0x1dd */ 19560/* File: x86/alt_stub.S */ 19561/* 19562 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19563 * any interesting requests and then jump to the real instruction 19564 * handler. Unlike the Arm handler, we can't do this as a tail call 19565 * because rIBASE is caller save and we need to reload it. 19566 */ 19567 movl rSELF, %eax 19568 movl rPC, OUT_ARG0(%esp) 19569 movl %eax, OUT_ARG1(%esp) 19570 call dvmCheckInst # (dPC, self) 19571 movl rSELF, %ecx 19572 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19573 jmp *dvmAsmInstructionStart+(477*4) 19574 19575/* ------------------------------ */ 19576.L_ALT_OP_UNUSED_DEFF: /* 0x1de */ 19577/* File: x86/alt_stub.S */ 19578/* 19579 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19580 * any interesting requests and then jump to the real instruction 19581 * handler. Unlike the Arm handler, we can't do this as a tail call 19582 * because rIBASE is caller save and we need to reload it. 19583 */ 19584 movl rSELF, %eax 19585 movl rPC, OUT_ARG0(%esp) 19586 movl %eax, OUT_ARG1(%esp) 19587 call dvmCheckInst # (dPC, self) 19588 movl rSELF, %ecx 19589 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19590 jmp *dvmAsmInstructionStart+(478*4) 19591 19592/* ------------------------------ */ 19593.L_ALT_OP_UNUSED_DFFF: /* 0x1df */ 19594/* File: x86/alt_stub.S */ 19595/* 19596 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19597 * any interesting requests and then jump to the real instruction 19598 * handler. Unlike the Arm handler, we can't do this as a tail call 19599 * because rIBASE is caller save and we need to reload it. 19600 */ 19601 movl rSELF, %eax 19602 movl rPC, OUT_ARG0(%esp) 19603 movl %eax, OUT_ARG1(%esp) 19604 call dvmCheckInst # (dPC, self) 19605 movl rSELF, %ecx 19606 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19607 jmp *dvmAsmInstructionStart+(479*4) 19608 19609/* ------------------------------ */ 19610.L_ALT_OP_UNUSED_E0FF: /* 0x1e0 */ 19611/* File: x86/alt_stub.S */ 19612/* 19613 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19614 * any interesting requests and then jump to the real instruction 19615 * handler. Unlike the Arm handler, we can't do this as a tail call 19616 * because rIBASE is caller save and we need to reload it. 19617 */ 19618 movl rSELF, %eax 19619 movl rPC, OUT_ARG0(%esp) 19620 movl %eax, OUT_ARG1(%esp) 19621 call dvmCheckInst # (dPC, self) 19622 movl rSELF, %ecx 19623 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19624 jmp *dvmAsmInstructionStart+(480*4) 19625 19626/* ------------------------------ */ 19627.L_ALT_OP_UNUSED_E1FF: /* 0x1e1 */ 19628/* File: x86/alt_stub.S */ 19629/* 19630 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19631 * any interesting requests and then jump to the real instruction 19632 * handler. Unlike the Arm handler, we can't do this as a tail call 19633 * because rIBASE is caller save and we need to reload it. 19634 */ 19635 movl rSELF, %eax 19636 movl rPC, OUT_ARG0(%esp) 19637 movl %eax, OUT_ARG1(%esp) 19638 call dvmCheckInst # (dPC, self) 19639 movl rSELF, %ecx 19640 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19641 jmp *dvmAsmInstructionStart+(481*4) 19642 19643/* ------------------------------ */ 19644.L_ALT_OP_UNUSED_E2FF: /* 0x1e2 */ 19645/* File: x86/alt_stub.S */ 19646/* 19647 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19648 * any interesting requests and then jump to the real instruction 19649 * handler. Unlike the Arm handler, we can't do this as a tail call 19650 * because rIBASE is caller save and we need to reload it. 19651 */ 19652 movl rSELF, %eax 19653 movl rPC, OUT_ARG0(%esp) 19654 movl %eax, OUT_ARG1(%esp) 19655 call dvmCheckInst # (dPC, self) 19656 movl rSELF, %ecx 19657 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19658 jmp *dvmAsmInstructionStart+(482*4) 19659 19660/* ------------------------------ */ 19661.L_ALT_OP_UNUSED_E3FF: /* 0x1e3 */ 19662/* File: x86/alt_stub.S */ 19663/* 19664 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19665 * any interesting requests and then jump to the real instruction 19666 * handler. Unlike the Arm handler, we can't do this as a tail call 19667 * because rIBASE is caller save and we need to reload it. 19668 */ 19669 movl rSELF, %eax 19670 movl rPC, OUT_ARG0(%esp) 19671 movl %eax, OUT_ARG1(%esp) 19672 call dvmCheckInst # (dPC, self) 19673 movl rSELF, %ecx 19674 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19675 jmp *dvmAsmInstructionStart+(483*4) 19676 19677/* ------------------------------ */ 19678.L_ALT_OP_UNUSED_E4FF: /* 0x1e4 */ 19679/* File: x86/alt_stub.S */ 19680/* 19681 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19682 * any interesting requests and then jump to the real instruction 19683 * handler. Unlike the Arm handler, we can't do this as a tail call 19684 * because rIBASE is caller save and we need to reload it. 19685 */ 19686 movl rSELF, %eax 19687 movl rPC, OUT_ARG0(%esp) 19688 movl %eax, OUT_ARG1(%esp) 19689 call dvmCheckInst # (dPC, self) 19690 movl rSELF, %ecx 19691 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19692 jmp *dvmAsmInstructionStart+(484*4) 19693 19694/* ------------------------------ */ 19695.L_ALT_OP_UNUSED_E5FF: /* 0x1e5 */ 19696/* File: x86/alt_stub.S */ 19697/* 19698 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19699 * any interesting requests and then jump to the real instruction 19700 * handler. Unlike the Arm handler, we can't do this as a tail call 19701 * because rIBASE is caller save and we need to reload it. 19702 */ 19703 movl rSELF, %eax 19704 movl rPC, OUT_ARG0(%esp) 19705 movl %eax, OUT_ARG1(%esp) 19706 call dvmCheckInst # (dPC, self) 19707 movl rSELF, %ecx 19708 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19709 jmp *dvmAsmInstructionStart+(485*4) 19710 19711/* ------------------------------ */ 19712.L_ALT_OP_UNUSED_E6FF: /* 0x1e6 */ 19713/* File: x86/alt_stub.S */ 19714/* 19715 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19716 * any interesting requests and then jump to the real instruction 19717 * handler. Unlike the Arm handler, we can't do this as a tail call 19718 * because rIBASE is caller save and we need to reload it. 19719 */ 19720 movl rSELF, %eax 19721 movl rPC, OUT_ARG0(%esp) 19722 movl %eax, OUT_ARG1(%esp) 19723 call dvmCheckInst # (dPC, self) 19724 movl rSELF, %ecx 19725 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19726 jmp *dvmAsmInstructionStart+(486*4) 19727 19728/* ------------------------------ */ 19729.L_ALT_OP_UNUSED_E7FF: /* 0x1e7 */ 19730/* File: x86/alt_stub.S */ 19731/* 19732 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19733 * any interesting requests and then jump to the real instruction 19734 * handler. Unlike the Arm handler, we can't do this as a tail call 19735 * because rIBASE is caller save and we need to reload it. 19736 */ 19737 movl rSELF, %eax 19738 movl rPC, OUT_ARG0(%esp) 19739 movl %eax, OUT_ARG1(%esp) 19740 call dvmCheckInst # (dPC, self) 19741 movl rSELF, %ecx 19742 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19743 jmp *dvmAsmInstructionStart+(487*4) 19744 19745/* ------------------------------ */ 19746.L_ALT_OP_UNUSED_E8FF: /* 0x1e8 */ 19747/* File: x86/alt_stub.S */ 19748/* 19749 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19750 * any interesting requests and then jump to the real instruction 19751 * handler. Unlike the Arm handler, we can't do this as a tail call 19752 * because rIBASE is caller save and we need to reload it. 19753 */ 19754 movl rSELF, %eax 19755 movl rPC, OUT_ARG0(%esp) 19756 movl %eax, OUT_ARG1(%esp) 19757 call dvmCheckInst # (dPC, self) 19758 movl rSELF, %ecx 19759 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19760 jmp *dvmAsmInstructionStart+(488*4) 19761 19762/* ------------------------------ */ 19763.L_ALT_OP_UNUSED_E9FF: /* 0x1e9 */ 19764/* File: x86/alt_stub.S */ 19765/* 19766 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19767 * any interesting requests and then jump to the real instruction 19768 * handler. Unlike the Arm handler, we can't do this as a tail call 19769 * because rIBASE is caller save and we need to reload it. 19770 */ 19771 movl rSELF, %eax 19772 movl rPC, OUT_ARG0(%esp) 19773 movl %eax, OUT_ARG1(%esp) 19774 call dvmCheckInst # (dPC, self) 19775 movl rSELF, %ecx 19776 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19777 jmp *dvmAsmInstructionStart+(489*4) 19778 19779/* ------------------------------ */ 19780.L_ALT_OP_UNUSED_EAFF: /* 0x1ea */ 19781/* File: x86/alt_stub.S */ 19782/* 19783 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19784 * any interesting requests and then jump to the real instruction 19785 * handler. Unlike the Arm handler, we can't do this as a tail call 19786 * because rIBASE is caller save and we need to reload it. 19787 */ 19788 movl rSELF, %eax 19789 movl rPC, OUT_ARG0(%esp) 19790 movl %eax, OUT_ARG1(%esp) 19791 call dvmCheckInst # (dPC, self) 19792 movl rSELF, %ecx 19793 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19794 jmp *dvmAsmInstructionStart+(490*4) 19795 19796/* ------------------------------ */ 19797.L_ALT_OP_UNUSED_EBFF: /* 0x1eb */ 19798/* File: x86/alt_stub.S */ 19799/* 19800 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19801 * any interesting requests and then jump to the real instruction 19802 * handler. Unlike the Arm handler, we can't do this as a tail call 19803 * because rIBASE is caller save and we need to reload it. 19804 */ 19805 movl rSELF, %eax 19806 movl rPC, OUT_ARG0(%esp) 19807 movl %eax, OUT_ARG1(%esp) 19808 call dvmCheckInst # (dPC, self) 19809 movl rSELF, %ecx 19810 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19811 jmp *dvmAsmInstructionStart+(491*4) 19812 19813/* ------------------------------ */ 19814.L_ALT_OP_UNUSED_ECFF: /* 0x1ec */ 19815/* File: x86/alt_stub.S */ 19816/* 19817 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19818 * any interesting requests and then jump to the real instruction 19819 * handler. Unlike the Arm handler, we can't do this as a tail call 19820 * because rIBASE is caller save and we need to reload it. 19821 */ 19822 movl rSELF, %eax 19823 movl rPC, OUT_ARG0(%esp) 19824 movl %eax, OUT_ARG1(%esp) 19825 call dvmCheckInst # (dPC, self) 19826 movl rSELF, %ecx 19827 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19828 jmp *dvmAsmInstructionStart+(492*4) 19829 19830/* ------------------------------ */ 19831.L_ALT_OP_UNUSED_EDFF: /* 0x1ed */ 19832/* File: x86/alt_stub.S */ 19833/* 19834 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19835 * any interesting requests and then jump to the real instruction 19836 * handler. Unlike the Arm handler, we can't do this as a tail call 19837 * because rIBASE is caller save and we need to reload it. 19838 */ 19839 movl rSELF, %eax 19840 movl rPC, OUT_ARG0(%esp) 19841 movl %eax, OUT_ARG1(%esp) 19842 call dvmCheckInst # (dPC, self) 19843 movl rSELF, %ecx 19844 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19845 jmp *dvmAsmInstructionStart+(493*4) 19846 19847/* ------------------------------ */ 19848.L_ALT_OP_UNUSED_EEFF: /* 0x1ee */ 19849/* File: x86/alt_stub.S */ 19850/* 19851 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19852 * any interesting requests and then jump to the real instruction 19853 * handler. Unlike the Arm handler, we can't do this as a tail call 19854 * because rIBASE is caller save and we need to reload it. 19855 */ 19856 movl rSELF, %eax 19857 movl rPC, OUT_ARG0(%esp) 19858 movl %eax, OUT_ARG1(%esp) 19859 call dvmCheckInst # (dPC, self) 19860 movl rSELF, %ecx 19861 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19862 jmp *dvmAsmInstructionStart+(494*4) 19863 19864/* ------------------------------ */ 19865.L_ALT_OP_UNUSED_EFFF: /* 0x1ef */ 19866/* File: x86/alt_stub.S */ 19867/* 19868 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19869 * any interesting requests and then jump to the real instruction 19870 * handler. Unlike the Arm handler, we can't do this as a tail call 19871 * because rIBASE is caller save and we need to reload it. 19872 */ 19873 movl rSELF, %eax 19874 movl rPC, OUT_ARG0(%esp) 19875 movl %eax, OUT_ARG1(%esp) 19876 call dvmCheckInst # (dPC, self) 19877 movl rSELF, %ecx 19878 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19879 jmp *dvmAsmInstructionStart+(495*4) 19880 19881/* ------------------------------ */ 19882.L_ALT_OP_UNUSED_F0FF: /* 0x1f0 */ 19883/* File: x86/alt_stub.S */ 19884/* 19885 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19886 * any interesting requests and then jump to the real instruction 19887 * handler. Unlike the Arm handler, we can't do this as a tail call 19888 * because rIBASE is caller save and we need to reload it. 19889 */ 19890 movl rSELF, %eax 19891 movl rPC, OUT_ARG0(%esp) 19892 movl %eax, OUT_ARG1(%esp) 19893 call dvmCheckInst # (dPC, self) 19894 movl rSELF, %ecx 19895 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19896 jmp *dvmAsmInstructionStart+(496*4) 19897 19898/* ------------------------------ */ 19899.L_ALT_OP_UNUSED_F1FF: /* 0x1f1 */ 19900/* File: x86/alt_stub.S */ 19901/* 19902 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19903 * any interesting requests and then jump to the real instruction 19904 * handler. Unlike the Arm handler, we can't do this as a tail call 19905 * because rIBASE is caller save and we need to reload it. 19906 */ 19907 movl rSELF, %eax 19908 movl rPC, OUT_ARG0(%esp) 19909 movl %eax, OUT_ARG1(%esp) 19910 call dvmCheckInst # (dPC, self) 19911 movl rSELF, %ecx 19912 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19913 jmp *dvmAsmInstructionStart+(497*4) 19914 19915/* ------------------------------ */ 19916.L_ALT_OP_UNUSED_F2FF: /* 0x1f2 */ 19917/* File: x86/alt_stub.S */ 19918/* 19919 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19920 * any interesting requests and then jump to the real instruction 19921 * handler. Unlike the Arm handler, we can't do this as a tail call 19922 * because rIBASE is caller save and we need to reload it. 19923 */ 19924 movl rSELF, %eax 19925 movl rPC, OUT_ARG0(%esp) 19926 movl %eax, OUT_ARG1(%esp) 19927 call dvmCheckInst # (dPC, self) 19928 movl rSELF, %ecx 19929 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19930 jmp *dvmAsmInstructionStart+(498*4) 19931 19932/* ------------------------------ */ 19933.L_ALT_OP_UNUSED_F3FF: /* 0x1f3 */ 19934/* File: x86/alt_stub.S */ 19935/* 19936 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19937 * any interesting requests and then jump to the real instruction 19938 * handler. Unlike the Arm handler, we can't do this as a tail call 19939 * because rIBASE is caller save and we need to reload it. 19940 */ 19941 movl rSELF, %eax 19942 movl rPC, OUT_ARG0(%esp) 19943 movl %eax, OUT_ARG1(%esp) 19944 call dvmCheckInst # (dPC, self) 19945 movl rSELF, %ecx 19946 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19947 jmp *dvmAsmInstructionStart+(499*4) 19948 19949/* ------------------------------ */ 19950.L_ALT_OP_UNUSED_F4FF: /* 0x1f4 */ 19951/* File: x86/alt_stub.S */ 19952/* 19953 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19954 * any interesting requests and then jump to the real instruction 19955 * handler. Unlike the Arm handler, we can't do this as a tail call 19956 * because rIBASE is caller save and we need to reload it. 19957 */ 19958 movl rSELF, %eax 19959 movl rPC, OUT_ARG0(%esp) 19960 movl %eax, OUT_ARG1(%esp) 19961 call dvmCheckInst # (dPC, self) 19962 movl rSELF, %ecx 19963 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19964 jmp *dvmAsmInstructionStart+(500*4) 19965 19966/* ------------------------------ */ 19967.L_ALT_OP_UNUSED_F5FF: /* 0x1f5 */ 19968/* File: x86/alt_stub.S */ 19969/* 19970 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19971 * any interesting requests and then jump to the real instruction 19972 * handler. Unlike the Arm handler, we can't do this as a tail call 19973 * because rIBASE is caller save and we need to reload it. 19974 */ 19975 movl rSELF, %eax 19976 movl rPC, OUT_ARG0(%esp) 19977 movl %eax, OUT_ARG1(%esp) 19978 call dvmCheckInst # (dPC, self) 19979 movl rSELF, %ecx 19980 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19981 jmp *dvmAsmInstructionStart+(501*4) 19982 19983/* ------------------------------ */ 19984.L_ALT_OP_UNUSED_F6FF: /* 0x1f6 */ 19985/* File: x86/alt_stub.S */ 19986/* 19987 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19988 * any interesting requests and then jump to the real instruction 19989 * handler. Unlike the Arm handler, we can't do this as a tail call 19990 * because rIBASE is caller save and we need to reload it. 19991 */ 19992 movl rSELF, %eax 19993 movl rPC, OUT_ARG0(%esp) 19994 movl %eax, OUT_ARG1(%esp) 19995 call dvmCheckInst # (dPC, self) 19996 movl rSELF, %ecx 19997 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19998 jmp *dvmAsmInstructionStart+(502*4) 19999 20000/* ------------------------------ */ 20001.L_ALT_OP_UNUSED_F7FF: /* 0x1f7 */ 20002/* File: x86/alt_stub.S */ 20003/* 20004 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 20005 * any interesting requests and then jump to the real instruction 20006 * handler. Unlike the Arm handler, we can't do this as a tail call 20007 * because rIBASE is caller save and we need to reload it. 20008 */ 20009 movl rSELF, %eax 20010 movl rPC, OUT_ARG0(%esp) 20011 movl %eax, OUT_ARG1(%esp) 20012 call dvmCheckInst # (dPC, self) 20013 movl rSELF, %ecx 20014 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 20015 jmp *dvmAsmInstructionStart+(503*4) 20016 20017/* ------------------------------ */ 20018.L_ALT_OP_UNUSED_F8FF: /* 0x1f8 */ 20019/* File: x86/alt_stub.S */ 20020/* 20021 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 20022 * any interesting requests and then jump to the real instruction 20023 * handler. Unlike the Arm handler, we can't do this as a tail call 20024 * because rIBASE is caller save and we need to reload it. 20025 */ 20026 movl rSELF, %eax 20027 movl rPC, OUT_ARG0(%esp) 20028 movl %eax, OUT_ARG1(%esp) 20029 call dvmCheckInst # (dPC, self) 20030 movl rSELF, %ecx 20031 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 20032 jmp *dvmAsmInstructionStart+(504*4) 20033 20034/* ------------------------------ */ 20035.L_ALT_OP_UNUSED_F9FF: /* 0x1f9 */ 20036/* File: x86/alt_stub.S */ 20037/* 20038 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 20039 * any interesting requests and then jump to the real instruction 20040 * handler. Unlike the Arm handler, we can't do this as a tail call 20041 * because rIBASE is caller save and we need to reload it. 20042 */ 20043 movl rSELF, %eax 20044 movl rPC, OUT_ARG0(%esp) 20045 movl %eax, OUT_ARG1(%esp) 20046 call dvmCheckInst # (dPC, self) 20047 movl rSELF, %ecx 20048 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 20049 jmp *dvmAsmInstructionStart+(505*4) 20050 20051/* ------------------------------ */ 20052.L_ALT_OP_UNUSED_FAFF: /* 0x1fa */ 20053/* File: x86/alt_stub.S */ 20054/* 20055 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 20056 * any interesting requests and then jump to the real instruction 20057 * handler. Unlike the Arm handler, we can't do this as a tail call 20058 * because rIBASE is caller save and we need to reload it. 20059 */ 20060 movl rSELF, %eax 20061 movl rPC, OUT_ARG0(%esp) 20062 movl %eax, OUT_ARG1(%esp) 20063 call dvmCheckInst # (dPC, self) 20064 movl rSELF, %ecx 20065 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 20066 jmp *dvmAsmInstructionStart+(506*4) 20067 20068/* ------------------------------ */ 20069.L_ALT_OP_UNUSED_FBFF: /* 0x1fb */ 20070/* File: x86/alt_stub.S */ 20071/* 20072 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 20073 * any interesting requests and then jump to the real instruction 20074 * handler. Unlike the Arm handler, we can't do this as a tail call 20075 * because rIBASE is caller save and we need to reload it. 20076 */ 20077 movl rSELF, %eax 20078 movl rPC, OUT_ARG0(%esp) 20079 movl %eax, OUT_ARG1(%esp) 20080 call dvmCheckInst # (dPC, self) 20081 movl rSELF, %ecx 20082 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 20083 jmp *dvmAsmInstructionStart+(507*4) 20084 20085/* ------------------------------ */ 20086.L_ALT_OP_UNUSED_FCFF: /* 0x1fc */ 20087/* File: x86/alt_stub.S */ 20088/* 20089 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 20090 * any interesting requests and then jump to the real instruction 20091 * handler. Unlike the Arm handler, we can't do this as a tail call 20092 * because rIBASE is caller save and we need to reload it. 20093 */ 20094 movl rSELF, %eax 20095 movl rPC, OUT_ARG0(%esp) 20096 movl %eax, OUT_ARG1(%esp) 20097 call dvmCheckInst # (dPC, self) 20098 movl rSELF, %ecx 20099 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 20100 jmp *dvmAsmInstructionStart+(508*4) 20101 20102/* ------------------------------ */ 20103.L_ALT_OP_UNUSED_FDFF: /* 0x1fd */ 20104/* File: x86/alt_stub.S */ 20105/* 20106 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 20107 * any interesting requests and then jump to the real instruction 20108 * handler. Unlike the Arm handler, we can't do this as a tail call 20109 * because rIBASE is caller save and we need to reload it. 20110 */ 20111 movl rSELF, %eax 20112 movl rPC, OUT_ARG0(%esp) 20113 movl %eax, OUT_ARG1(%esp) 20114 call dvmCheckInst # (dPC, self) 20115 movl rSELF, %ecx 20116 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 20117 jmp *dvmAsmInstructionStart+(509*4) 20118 20119/* ------------------------------ */ 20120.L_ALT_OP_UNUSED_FEFF: /* 0x1fe */ 20121/* File: x86/alt_stub.S */ 20122/* 20123 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 20124 * any interesting requests and then jump to the real instruction 20125 * handler. Unlike the Arm handler, we can't do this as a tail call 20126 * because rIBASE is caller save and we need to reload it. 20127 */ 20128 movl rSELF, %eax 20129 movl rPC, OUT_ARG0(%esp) 20130 movl %eax, OUT_ARG1(%esp) 20131 call dvmCheckInst # (dPC, self) 20132 movl rSELF, %ecx 20133 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 20134 jmp *dvmAsmInstructionStart+(510*4) 20135 20136/* ------------------------------ */ 20137.L_ALT_OP_THROW_VERIFICATION_ERROR_JUMBO: /* 0x1ff */ 20138/* File: x86/alt_stub.S */ 20139/* 20140 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 20141 * any interesting requests and then jump to the real instruction 20142 * handler. Unlike the Arm handler, we can't do this as a tail call 20143 * because rIBASE is caller save and we need to reload it. 20144 */ 20145 movl rSELF, %eax 20146 movl rPC, OUT_ARG0(%esp) 20147 movl %eax, OUT_ARG1(%esp) 20148 call dvmCheckInst # (dPC, self) 20149 movl rSELF, %ecx 20150 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 20151 jmp *dvmAsmInstructionStart+(511*4) 20152 20153 .size dvmAsmAltInstructionStartCode, .-dvmAsmAltInstructionStartCode 20154 .global dvmAsmAltInstructionEndCode 20155dvmAsmAltInstructionEndCode: 20156 20157 .global dvmAsmInstructionStart 20158 .text 20159dvmAsmInstructionStart: 20160 .long .L_OP_NOP /* 0x00 */ 20161 .long .L_OP_MOVE /* 0x01 */ 20162 .long .L_OP_MOVE_FROM16 /* 0x02 */ 20163 .long .L_OP_MOVE_16 /* 0x03 */ 20164 .long .L_OP_MOVE_WIDE /* 0x04 */ 20165 .long .L_OP_MOVE_WIDE_FROM16 /* 0x05 */ 20166 .long .L_OP_MOVE_WIDE_16 /* 0x06 */ 20167 .long .L_OP_MOVE_OBJECT /* 0x07 */ 20168 .long .L_OP_MOVE_OBJECT_FROM16 /* 0x08 */ 20169 .long .L_OP_MOVE_OBJECT_16 /* 0x09 */ 20170 .long .L_OP_MOVE_RESULT /* 0x0a */ 20171 .long .L_OP_MOVE_RESULT_WIDE /* 0x0b */ 20172 .long .L_OP_MOVE_RESULT_OBJECT /* 0x0c */ 20173 .long .L_OP_MOVE_EXCEPTION /* 0x0d */ 20174 .long .L_OP_RETURN_VOID /* 0x0e */ 20175 .long .L_OP_RETURN /* 0x0f */ 20176 .long .L_OP_RETURN_WIDE /* 0x10 */ 20177 .long .L_OP_RETURN_OBJECT /* 0x11 */ 20178 .long .L_OP_CONST_4 /* 0x12 */ 20179 .long .L_OP_CONST_16 /* 0x13 */ 20180 .long .L_OP_CONST /* 0x14 */ 20181 .long .L_OP_CONST_HIGH16 /* 0x15 */ 20182 .long .L_OP_CONST_WIDE_16 /* 0x16 */ 20183 .long .L_OP_CONST_WIDE_32 /* 0x17 */ 20184 .long .L_OP_CONST_WIDE /* 0x18 */ 20185 .long .L_OP_CONST_WIDE_HIGH16 /* 0x19 */ 20186 .long .L_OP_CONST_STRING /* 0x1a */ 20187 .long .L_OP_CONST_STRING_JUMBO /* 0x1b */ 20188 .long .L_OP_CONST_CLASS /* 0x1c */ 20189 .long .L_OP_MONITOR_ENTER /* 0x1d */ 20190 .long .L_OP_MONITOR_EXIT /* 0x1e */ 20191 .long .L_OP_CHECK_CAST /* 0x1f */ 20192 .long .L_OP_INSTANCE_OF /* 0x20 */ 20193 .long .L_OP_ARRAY_LENGTH /* 0x21 */ 20194 .long .L_OP_NEW_INSTANCE /* 0x22 */ 20195 .long .L_OP_NEW_ARRAY /* 0x23 */ 20196 .long .L_OP_FILLED_NEW_ARRAY /* 0x24 */ 20197 .long .L_OP_FILLED_NEW_ARRAY_RANGE /* 0x25 */ 20198 .long .L_OP_FILL_ARRAY_DATA /* 0x26 */ 20199 .long .L_OP_THROW /* 0x27 */ 20200 .long .L_OP_GOTO /* 0x28 */ 20201 .long .L_OP_GOTO_16 /* 0x29 */ 20202 .long .L_OP_GOTO_32 /* 0x2a */ 20203 .long .L_OP_PACKED_SWITCH /* 0x2b */ 20204 .long .L_OP_SPARSE_SWITCH /* 0x2c */ 20205 .long .L_OP_CMPL_FLOAT /* 0x2d */ 20206 .long .L_OP_CMPG_FLOAT /* 0x2e */ 20207 .long .L_OP_CMPL_DOUBLE /* 0x2f */ 20208 .long .L_OP_CMPG_DOUBLE /* 0x30 */ 20209 .long .L_OP_CMP_LONG /* 0x31 */ 20210 .long .L_OP_IF_EQ /* 0x32 */ 20211 .long .L_OP_IF_NE /* 0x33 */ 20212 .long .L_OP_IF_LT /* 0x34 */ 20213 .long .L_OP_IF_GE /* 0x35 */ 20214 .long .L_OP_IF_GT /* 0x36 */ 20215 .long .L_OP_IF_LE /* 0x37 */ 20216 .long .L_OP_IF_EQZ /* 0x38 */ 20217 .long .L_OP_IF_NEZ /* 0x39 */ 20218 .long .L_OP_IF_LTZ /* 0x3a */ 20219 .long .L_OP_IF_GEZ /* 0x3b */ 20220 .long .L_OP_IF_GTZ /* 0x3c */ 20221 .long .L_OP_IF_LEZ /* 0x3d */ 20222 .long .L_OP_UNUSED_3E /* 0x3e */ 20223 .long .L_OP_UNUSED_3F /* 0x3f */ 20224 .long .L_OP_UNUSED_40 /* 0x40 */ 20225 .long .L_OP_UNUSED_41 /* 0x41 */ 20226 .long .L_OP_UNUSED_42 /* 0x42 */ 20227 .long .L_OP_UNUSED_43 /* 0x43 */ 20228 .long .L_OP_AGET /* 0x44 */ 20229 .long .L_OP_AGET_WIDE /* 0x45 */ 20230 .long .L_OP_AGET_OBJECT /* 0x46 */ 20231 .long .L_OP_AGET_BOOLEAN /* 0x47 */ 20232 .long .L_OP_AGET_BYTE /* 0x48 */ 20233 .long .L_OP_AGET_CHAR /* 0x49 */ 20234 .long .L_OP_AGET_SHORT /* 0x4a */ 20235 .long .L_OP_APUT /* 0x4b */ 20236 .long .L_OP_APUT_WIDE /* 0x4c */ 20237 .long .L_OP_APUT_OBJECT /* 0x4d */ 20238 .long .L_OP_APUT_BOOLEAN /* 0x4e */ 20239 .long .L_OP_APUT_BYTE /* 0x4f */ 20240 .long .L_OP_APUT_CHAR /* 0x50 */ 20241 .long .L_OP_APUT_SHORT /* 0x51 */ 20242 .long .L_OP_IGET /* 0x52 */ 20243 .long .L_OP_IGET_WIDE /* 0x53 */ 20244 .long .L_OP_IGET_OBJECT /* 0x54 */ 20245 .long .L_OP_IGET_BOOLEAN /* 0x55 */ 20246 .long .L_OP_IGET_BYTE /* 0x56 */ 20247 .long .L_OP_IGET_CHAR /* 0x57 */ 20248 .long .L_OP_IGET_SHORT /* 0x58 */ 20249 .long .L_OP_IPUT /* 0x59 */ 20250 .long .L_OP_IPUT_WIDE /* 0x5a */ 20251 .long .L_OP_IPUT_OBJECT /* 0x5b */ 20252 .long .L_OP_IPUT_BOOLEAN /* 0x5c */ 20253 .long .L_OP_IPUT_BYTE /* 0x5d */ 20254 .long .L_OP_IPUT_CHAR /* 0x5e */ 20255 .long .L_OP_IPUT_SHORT /* 0x5f */ 20256 .long .L_OP_SGET /* 0x60 */ 20257 .long .L_OP_SGET_WIDE /* 0x61 */ 20258 .long .L_OP_SGET_OBJECT /* 0x62 */ 20259 .long .L_OP_SGET_BOOLEAN /* 0x63 */ 20260 .long .L_OP_SGET_BYTE /* 0x64 */ 20261 .long .L_OP_SGET_CHAR /* 0x65 */ 20262 .long .L_OP_SGET_SHORT /* 0x66 */ 20263 .long .L_OP_SPUT /* 0x67 */ 20264 .long .L_OP_SPUT_WIDE /* 0x68 */ 20265 .long .L_OP_SPUT_OBJECT /* 0x69 */ 20266 .long .L_OP_SPUT_BOOLEAN /* 0x6a */ 20267 .long .L_OP_SPUT_BYTE /* 0x6b */ 20268 .long .L_OP_SPUT_CHAR /* 0x6c */ 20269 .long .L_OP_SPUT_SHORT /* 0x6d */ 20270 .long .L_OP_INVOKE_VIRTUAL /* 0x6e */ 20271 .long .L_OP_INVOKE_SUPER /* 0x6f */ 20272 .long .L_OP_INVOKE_DIRECT /* 0x70 */ 20273 .long .L_OP_INVOKE_STATIC /* 0x71 */ 20274 .long .L_OP_INVOKE_INTERFACE /* 0x72 */ 20275 .long .L_OP_UNUSED_73 /* 0x73 */ 20276 .long .L_OP_INVOKE_VIRTUAL_RANGE /* 0x74 */ 20277 .long .L_OP_INVOKE_SUPER_RANGE /* 0x75 */ 20278 .long .L_OP_INVOKE_DIRECT_RANGE /* 0x76 */ 20279 .long .L_OP_INVOKE_STATIC_RANGE /* 0x77 */ 20280 .long .L_OP_INVOKE_INTERFACE_RANGE /* 0x78 */ 20281 .long .L_OP_UNUSED_79 /* 0x79 */ 20282 .long .L_OP_UNUSED_7A /* 0x7a */ 20283 .long .L_OP_NEG_INT /* 0x7b */ 20284 .long .L_OP_NOT_INT /* 0x7c */ 20285 .long .L_OP_NEG_LONG /* 0x7d */ 20286 .long .L_OP_NOT_LONG /* 0x7e */ 20287 .long .L_OP_NEG_FLOAT /* 0x7f */ 20288 .long .L_OP_NEG_DOUBLE /* 0x80 */ 20289 .long .L_OP_INT_TO_LONG /* 0x81 */ 20290 .long .L_OP_INT_TO_FLOAT /* 0x82 */ 20291 .long .L_OP_INT_TO_DOUBLE /* 0x83 */ 20292 .long .L_OP_LONG_TO_INT /* 0x84 */ 20293 .long .L_OP_LONG_TO_FLOAT /* 0x85 */ 20294 .long .L_OP_LONG_TO_DOUBLE /* 0x86 */ 20295 .long .L_OP_FLOAT_TO_INT /* 0x87 */ 20296 .long .L_OP_FLOAT_TO_LONG /* 0x88 */ 20297 .long .L_OP_FLOAT_TO_DOUBLE /* 0x89 */ 20298 .long .L_OP_DOUBLE_TO_INT /* 0x8a */ 20299 .long .L_OP_DOUBLE_TO_LONG /* 0x8b */ 20300 .long .L_OP_DOUBLE_TO_FLOAT /* 0x8c */ 20301 .long .L_OP_INT_TO_BYTE /* 0x8d */ 20302 .long .L_OP_INT_TO_CHAR /* 0x8e */ 20303 .long .L_OP_INT_TO_SHORT /* 0x8f */ 20304 .long .L_OP_ADD_INT /* 0x90 */ 20305 .long .L_OP_SUB_INT /* 0x91 */ 20306 .long .L_OP_MUL_INT /* 0x92 */ 20307 .long .L_OP_DIV_INT /* 0x93 */ 20308 .long .L_OP_REM_INT /* 0x94 */ 20309 .long .L_OP_AND_INT /* 0x95 */ 20310 .long .L_OP_OR_INT /* 0x96 */ 20311 .long .L_OP_XOR_INT /* 0x97 */ 20312 .long .L_OP_SHL_INT /* 0x98 */ 20313 .long .L_OP_SHR_INT /* 0x99 */ 20314 .long .L_OP_USHR_INT /* 0x9a */ 20315 .long .L_OP_ADD_LONG /* 0x9b */ 20316 .long .L_OP_SUB_LONG /* 0x9c */ 20317 .long .L_OP_MUL_LONG /* 0x9d */ 20318 .long .L_OP_DIV_LONG /* 0x9e */ 20319 .long .L_OP_REM_LONG /* 0x9f */ 20320 .long .L_OP_AND_LONG /* 0xa0 */ 20321 .long .L_OP_OR_LONG /* 0xa1 */ 20322 .long .L_OP_XOR_LONG /* 0xa2 */ 20323 .long .L_OP_SHL_LONG /* 0xa3 */ 20324 .long .L_OP_SHR_LONG /* 0xa4 */ 20325 .long .L_OP_USHR_LONG /* 0xa5 */ 20326 .long .L_OP_ADD_FLOAT /* 0xa6 */ 20327 .long .L_OP_SUB_FLOAT /* 0xa7 */ 20328 .long .L_OP_MUL_FLOAT /* 0xa8 */ 20329 .long .L_OP_DIV_FLOAT /* 0xa9 */ 20330 .long .L_OP_REM_FLOAT /* 0xaa */ 20331 .long .L_OP_ADD_DOUBLE /* 0xab */ 20332 .long .L_OP_SUB_DOUBLE /* 0xac */ 20333 .long .L_OP_MUL_DOUBLE /* 0xad */ 20334 .long .L_OP_DIV_DOUBLE /* 0xae */ 20335 .long .L_OP_REM_DOUBLE /* 0xaf */ 20336 .long .L_OP_ADD_INT_2ADDR /* 0xb0 */ 20337 .long .L_OP_SUB_INT_2ADDR /* 0xb1 */ 20338 .long .L_OP_MUL_INT_2ADDR /* 0xb2 */ 20339 .long .L_OP_DIV_INT_2ADDR /* 0xb3 */ 20340 .long .L_OP_REM_INT_2ADDR /* 0xb4 */ 20341 .long .L_OP_AND_INT_2ADDR /* 0xb5 */ 20342 .long .L_OP_OR_INT_2ADDR /* 0xb6 */ 20343 .long .L_OP_XOR_INT_2ADDR /* 0xb7 */ 20344 .long .L_OP_SHL_INT_2ADDR /* 0xb8 */ 20345 .long .L_OP_SHR_INT_2ADDR /* 0xb9 */ 20346 .long .L_OP_USHR_INT_2ADDR /* 0xba */ 20347 .long .L_OP_ADD_LONG_2ADDR /* 0xbb */ 20348 .long .L_OP_SUB_LONG_2ADDR /* 0xbc */ 20349 .long .L_OP_MUL_LONG_2ADDR /* 0xbd */ 20350 .long .L_OP_DIV_LONG_2ADDR /* 0xbe */ 20351 .long .L_OP_REM_LONG_2ADDR /* 0xbf */ 20352 .long .L_OP_AND_LONG_2ADDR /* 0xc0 */ 20353 .long .L_OP_OR_LONG_2ADDR /* 0xc1 */ 20354 .long .L_OP_XOR_LONG_2ADDR /* 0xc2 */ 20355 .long .L_OP_SHL_LONG_2ADDR /* 0xc3 */ 20356 .long .L_OP_SHR_LONG_2ADDR /* 0xc4 */ 20357 .long .L_OP_USHR_LONG_2ADDR /* 0xc5 */ 20358 .long .L_OP_ADD_FLOAT_2ADDR /* 0xc6 */ 20359 .long .L_OP_SUB_FLOAT_2ADDR /* 0xc7 */ 20360 .long .L_OP_MUL_FLOAT_2ADDR /* 0xc8 */ 20361 .long .L_OP_DIV_FLOAT_2ADDR /* 0xc9 */ 20362 .long .L_OP_REM_FLOAT_2ADDR /* 0xca */ 20363 .long .L_OP_ADD_DOUBLE_2ADDR /* 0xcb */ 20364 .long .L_OP_SUB_DOUBLE_2ADDR /* 0xcc */ 20365 .long .L_OP_MUL_DOUBLE_2ADDR /* 0xcd */ 20366 .long .L_OP_DIV_DOUBLE_2ADDR /* 0xce */ 20367 .long .L_OP_REM_DOUBLE_2ADDR /* 0xcf */ 20368 .long .L_OP_ADD_INT_LIT16 /* 0xd0 */ 20369 .long .L_OP_RSUB_INT /* 0xd1 */ 20370 .long .L_OP_MUL_INT_LIT16 /* 0xd2 */ 20371 .long .L_OP_DIV_INT_LIT16 /* 0xd3 */ 20372 .long .L_OP_REM_INT_LIT16 /* 0xd4 */ 20373 .long .L_OP_AND_INT_LIT16 /* 0xd5 */ 20374 .long .L_OP_OR_INT_LIT16 /* 0xd6 */ 20375 .long .L_OP_XOR_INT_LIT16 /* 0xd7 */ 20376 .long .L_OP_ADD_INT_LIT8 /* 0xd8 */ 20377 .long .L_OP_RSUB_INT_LIT8 /* 0xd9 */ 20378 .long .L_OP_MUL_INT_LIT8 /* 0xda */ 20379 .long .L_OP_DIV_INT_LIT8 /* 0xdb */ 20380 .long .L_OP_REM_INT_LIT8 /* 0xdc */ 20381 .long .L_OP_AND_INT_LIT8 /* 0xdd */ 20382 .long .L_OP_OR_INT_LIT8 /* 0xde */ 20383 .long .L_OP_XOR_INT_LIT8 /* 0xdf */ 20384 .long .L_OP_SHL_INT_LIT8 /* 0xe0 */ 20385 .long .L_OP_SHR_INT_LIT8 /* 0xe1 */ 20386 .long .L_OP_USHR_INT_LIT8 /* 0xe2 */ 20387 .long .L_OP_IGET_VOLATILE /* 0xe3 */ 20388 .long .L_OP_IPUT_VOLATILE /* 0xe4 */ 20389 .long .L_OP_SGET_VOLATILE /* 0xe5 */ 20390 .long .L_OP_SPUT_VOLATILE /* 0xe6 */ 20391 .long .L_OP_IGET_OBJECT_VOLATILE /* 0xe7 */ 20392 .long .L_OP_IGET_WIDE_VOLATILE /* 0xe8 */ 20393 .long .L_OP_IPUT_WIDE_VOLATILE /* 0xe9 */ 20394 .long .L_OP_SGET_WIDE_VOLATILE /* 0xea */ 20395 .long .L_OP_SPUT_WIDE_VOLATILE /* 0xeb */ 20396 .long .L_OP_BREAKPOINT /* 0xec */ 20397 .long .L_OP_THROW_VERIFICATION_ERROR /* 0xed */ 20398 .long .L_OP_EXECUTE_INLINE /* 0xee */ 20399 .long .L_OP_EXECUTE_INLINE_RANGE /* 0xef */ 20400 .long .L_OP_INVOKE_OBJECT_INIT_RANGE /* 0xf0 */ 20401 .long .L_OP_RETURN_VOID_BARRIER /* 0xf1 */ 20402 .long .L_OP_IGET_QUICK /* 0xf2 */ 20403 .long .L_OP_IGET_WIDE_QUICK /* 0xf3 */ 20404 .long .L_OP_IGET_OBJECT_QUICK /* 0xf4 */ 20405 .long .L_OP_IPUT_QUICK /* 0xf5 */ 20406 .long .L_OP_IPUT_WIDE_QUICK /* 0xf6 */ 20407 .long .L_OP_IPUT_OBJECT_QUICK /* 0xf7 */ 20408 .long .L_OP_INVOKE_VIRTUAL_QUICK /* 0xf8 */ 20409 .long .L_OP_INVOKE_VIRTUAL_QUICK_RANGE /* 0xf9 */ 20410 .long .L_OP_INVOKE_SUPER_QUICK /* 0xfa */ 20411 .long .L_OP_INVOKE_SUPER_QUICK_RANGE /* 0xfb */ 20412 .long .L_OP_IPUT_OBJECT_VOLATILE /* 0xfc */ 20413 .long .L_OP_SGET_OBJECT_VOLATILE /* 0xfd */ 20414 .long .L_OP_SPUT_OBJECT_VOLATILE /* 0xfe */ 20415 .long .L_OP_DISPATCH_FF /* 0xff */ 20416 .long .L_OP_CONST_CLASS_JUMBO /* 0x100 */ 20417 .long .L_OP_CHECK_CAST_JUMBO /* 0x101 */ 20418 .long .L_OP_INSTANCE_OF_JUMBO /* 0x102 */ 20419 .long .L_OP_NEW_INSTANCE_JUMBO /* 0x103 */ 20420 .long .L_OP_NEW_ARRAY_JUMBO /* 0x104 */ 20421 .long .L_OP_FILLED_NEW_ARRAY_JUMBO /* 0x105 */ 20422 .long .L_OP_IGET_JUMBO /* 0x106 */ 20423 .long .L_OP_IGET_WIDE_JUMBO /* 0x107 */ 20424 .long .L_OP_IGET_OBJECT_JUMBO /* 0x108 */ 20425 .long .L_OP_IGET_BOOLEAN_JUMBO /* 0x109 */ 20426 .long .L_OP_IGET_BYTE_JUMBO /* 0x10a */ 20427 .long .L_OP_IGET_CHAR_JUMBO /* 0x10b */ 20428 .long .L_OP_IGET_SHORT_JUMBO /* 0x10c */ 20429 .long .L_OP_IPUT_JUMBO /* 0x10d */ 20430 .long .L_OP_IPUT_WIDE_JUMBO /* 0x10e */ 20431 .long .L_OP_IPUT_OBJECT_JUMBO /* 0x10f */ 20432 .long .L_OP_IPUT_BOOLEAN_JUMBO /* 0x110 */ 20433 .long .L_OP_IPUT_BYTE_JUMBO /* 0x111 */ 20434 .long .L_OP_IPUT_CHAR_JUMBO /* 0x112 */ 20435 .long .L_OP_IPUT_SHORT_JUMBO /* 0x113 */ 20436 .long .L_OP_SGET_JUMBO /* 0x114 */ 20437 .long .L_OP_SGET_WIDE_JUMBO /* 0x115 */ 20438 .long .L_OP_SGET_OBJECT_JUMBO /* 0x116 */ 20439 .long .L_OP_SGET_BOOLEAN_JUMBO /* 0x117 */ 20440 .long .L_OP_SGET_BYTE_JUMBO /* 0x118 */ 20441 .long .L_OP_SGET_CHAR_JUMBO /* 0x119 */ 20442 .long .L_OP_SGET_SHORT_JUMBO /* 0x11a */ 20443 .long .L_OP_SPUT_JUMBO /* 0x11b */ 20444 .long .L_OP_SPUT_WIDE_JUMBO /* 0x11c */ 20445 .long .L_OP_SPUT_OBJECT_JUMBO /* 0x11d */ 20446 .long .L_OP_SPUT_BOOLEAN_JUMBO /* 0x11e */ 20447 .long .L_OP_SPUT_BYTE_JUMBO /* 0x11f */ 20448 .long .L_OP_SPUT_CHAR_JUMBO /* 0x120 */ 20449 .long .L_OP_SPUT_SHORT_JUMBO /* 0x121 */ 20450 .long .L_OP_INVOKE_VIRTUAL_JUMBO /* 0x122 */ 20451 .long .L_OP_INVOKE_SUPER_JUMBO /* 0x123 */ 20452 .long .L_OP_INVOKE_DIRECT_JUMBO /* 0x124 */ 20453 .long .L_OP_INVOKE_STATIC_JUMBO /* 0x125 */ 20454 .long .L_OP_INVOKE_INTERFACE_JUMBO /* 0x126 */ 20455 .long .L_OP_UNUSED_27FF /* 0x127 */ 20456 .long .L_OP_UNUSED_28FF /* 0x128 */ 20457 .long .L_OP_UNUSED_29FF /* 0x129 */ 20458 .long .L_OP_UNUSED_2AFF /* 0x12a */ 20459 .long .L_OP_UNUSED_2BFF /* 0x12b */ 20460 .long .L_OP_UNUSED_2CFF /* 0x12c */ 20461 .long .L_OP_UNUSED_2DFF /* 0x12d */ 20462 .long .L_OP_UNUSED_2EFF /* 0x12e */ 20463 .long .L_OP_UNUSED_2FFF /* 0x12f */ 20464 .long .L_OP_UNUSED_30FF /* 0x130 */ 20465 .long .L_OP_UNUSED_31FF /* 0x131 */ 20466 .long .L_OP_UNUSED_32FF /* 0x132 */ 20467 .long .L_OP_UNUSED_33FF /* 0x133 */ 20468 .long .L_OP_UNUSED_34FF /* 0x134 */ 20469 .long .L_OP_UNUSED_35FF /* 0x135 */ 20470 .long .L_OP_UNUSED_36FF /* 0x136 */ 20471 .long .L_OP_UNUSED_37FF /* 0x137 */ 20472 .long .L_OP_UNUSED_38FF /* 0x138 */ 20473 .long .L_OP_UNUSED_39FF /* 0x139 */ 20474 .long .L_OP_UNUSED_3AFF /* 0x13a */ 20475 .long .L_OP_UNUSED_3BFF /* 0x13b */ 20476 .long .L_OP_UNUSED_3CFF /* 0x13c */ 20477 .long .L_OP_UNUSED_3DFF /* 0x13d */ 20478 .long .L_OP_UNUSED_3EFF /* 0x13e */ 20479 .long .L_OP_UNUSED_3FFF /* 0x13f */ 20480 .long .L_OP_UNUSED_40FF /* 0x140 */ 20481 .long .L_OP_UNUSED_41FF /* 0x141 */ 20482 .long .L_OP_UNUSED_42FF /* 0x142 */ 20483 .long .L_OP_UNUSED_43FF /* 0x143 */ 20484 .long .L_OP_UNUSED_44FF /* 0x144 */ 20485 .long .L_OP_UNUSED_45FF /* 0x145 */ 20486 .long .L_OP_UNUSED_46FF /* 0x146 */ 20487 .long .L_OP_UNUSED_47FF /* 0x147 */ 20488 .long .L_OP_UNUSED_48FF /* 0x148 */ 20489 .long .L_OP_UNUSED_49FF /* 0x149 */ 20490 .long .L_OP_UNUSED_4AFF /* 0x14a */ 20491 .long .L_OP_UNUSED_4BFF /* 0x14b */ 20492 .long .L_OP_UNUSED_4CFF /* 0x14c */ 20493 .long .L_OP_UNUSED_4DFF /* 0x14d */ 20494 .long .L_OP_UNUSED_4EFF /* 0x14e */ 20495 .long .L_OP_UNUSED_4FFF /* 0x14f */ 20496 .long .L_OP_UNUSED_50FF /* 0x150 */ 20497 .long .L_OP_UNUSED_51FF /* 0x151 */ 20498 .long .L_OP_UNUSED_52FF /* 0x152 */ 20499 .long .L_OP_UNUSED_53FF /* 0x153 */ 20500 .long .L_OP_UNUSED_54FF /* 0x154 */ 20501 .long .L_OP_UNUSED_55FF /* 0x155 */ 20502 .long .L_OP_UNUSED_56FF /* 0x156 */ 20503 .long .L_OP_UNUSED_57FF /* 0x157 */ 20504 .long .L_OP_UNUSED_58FF /* 0x158 */ 20505 .long .L_OP_UNUSED_59FF /* 0x159 */ 20506 .long .L_OP_UNUSED_5AFF /* 0x15a */ 20507 .long .L_OP_UNUSED_5BFF /* 0x15b */ 20508 .long .L_OP_UNUSED_5CFF /* 0x15c */ 20509 .long .L_OP_UNUSED_5DFF /* 0x15d */ 20510 .long .L_OP_UNUSED_5EFF /* 0x15e */ 20511 .long .L_OP_UNUSED_5FFF /* 0x15f */ 20512 .long .L_OP_UNUSED_60FF /* 0x160 */ 20513 .long .L_OP_UNUSED_61FF /* 0x161 */ 20514 .long .L_OP_UNUSED_62FF /* 0x162 */ 20515 .long .L_OP_UNUSED_63FF /* 0x163 */ 20516 .long .L_OP_UNUSED_64FF /* 0x164 */ 20517 .long .L_OP_UNUSED_65FF /* 0x165 */ 20518 .long .L_OP_UNUSED_66FF /* 0x166 */ 20519 .long .L_OP_UNUSED_67FF /* 0x167 */ 20520 .long .L_OP_UNUSED_68FF /* 0x168 */ 20521 .long .L_OP_UNUSED_69FF /* 0x169 */ 20522 .long .L_OP_UNUSED_6AFF /* 0x16a */ 20523 .long .L_OP_UNUSED_6BFF /* 0x16b */ 20524 .long .L_OP_UNUSED_6CFF /* 0x16c */ 20525 .long .L_OP_UNUSED_6DFF /* 0x16d */ 20526 .long .L_OP_UNUSED_6EFF /* 0x16e */ 20527 .long .L_OP_UNUSED_6FFF /* 0x16f */ 20528 .long .L_OP_UNUSED_70FF /* 0x170 */ 20529 .long .L_OP_UNUSED_71FF /* 0x171 */ 20530 .long .L_OP_UNUSED_72FF /* 0x172 */ 20531 .long .L_OP_UNUSED_73FF /* 0x173 */ 20532 .long .L_OP_UNUSED_74FF /* 0x174 */ 20533 .long .L_OP_UNUSED_75FF /* 0x175 */ 20534 .long .L_OP_UNUSED_76FF /* 0x176 */ 20535 .long .L_OP_UNUSED_77FF /* 0x177 */ 20536 .long .L_OP_UNUSED_78FF /* 0x178 */ 20537 .long .L_OP_UNUSED_79FF /* 0x179 */ 20538 .long .L_OP_UNUSED_7AFF /* 0x17a */ 20539 .long .L_OP_UNUSED_7BFF /* 0x17b */ 20540 .long .L_OP_UNUSED_7CFF /* 0x17c */ 20541 .long .L_OP_UNUSED_7DFF /* 0x17d */ 20542 .long .L_OP_UNUSED_7EFF /* 0x17e */ 20543 .long .L_OP_UNUSED_7FFF /* 0x17f */ 20544 .long .L_OP_UNUSED_80FF /* 0x180 */ 20545 .long .L_OP_UNUSED_81FF /* 0x181 */ 20546 .long .L_OP_UNUSED_82FF /* 0x182 */ 20547 .long .L_OP_UNUSED_83FF /* 0x183 */ 20548 .long .L_OP_UNUSED_84FF /* 0x184 */ 20549 .long .L_OP_UNUSED_85FF /* 0x185 */ 20550 .long .L_OP_UNUSED_86FF /* 0x186 */ 20551 .long .L_OP_UNUSED_87FF /* 0x187 */ 20552 .long .L_OP_UNUSED_88FF /* 0x188 */ 20553 .long .L_OP_UNUSED_89FF /* 0x189 */ 20554 .long .L_OP_UNUSED_8AFF /* 0x18a */ 20555 .long .L_OP_UNUSED_8BFF /* 0x18b */ 20556 .long .L_OP_UNUSED_8CFF /* 0x18c */ 20557 .long .L_OP_UNUSED_8DFF /* 0x18d */ 20558 .long .L_OP_UNUSED_8EFF /* 0x18e */ 20559 .long .L_OP_UNUSED_8FFF /* 0x18f */ 20560 .long .L_OP_UNUSED_90FF /* 0x190 */ 20561 .long .L_OP_UNUSED_91FF /* 0x191 */ 20562 .long .L_OP_UNUSED_92FF /* 0x192 */ 20563 .long .L_OP_UNUSED_93FF /* 0x193 */ 20564 .long .L_OP_UNUSED_94FF /* 0x194 */ 20565 .long .L_OP_UNUSED_95FF /* 0x195 */ 20566 .long .L_OP_UNUSED_96FF /* 0x196 */ 20567 .long .L_OP_UNUSED_97FF /* 0x197 */ 20568 .long .L_OP_UNUSED_98FF /* 0x198 */ 20569 .long .L_OP_UNUSED_99FF /* 0x199 */ 20570 .long .L_OP_UNUSED_9AFF /* 0x19a */ 20571 .long .L_OP_UNUSED_9BFF /* 0x19b */ 20572 .long .L_OP_UNUSED_9CFF /* 0x19c */ 20573 .long .L_OP_UNUSED_9DFF /* 0x19d */ 20574 .long .L_OP_UNUSED_9EFF /* 0x19e */ 20575 .long .L_OP_UNUSED_9FFF /* 0x19f */ 20576 .long .L_OP_UNUSED_A0FF /* 0x1a0 */ 20577 .long .L_OP_UNUSED_A1FF /* 0x1a1 */ 20578 .long .L_OP_UNUSED_A2FF /* 0x1a2 */ 20579 .long .L_OP_UNUSED_A3FF /* 0x1a3 */ 20580 .long .L_OP_UNUSED_A4FF /* 0x1a4 */ 20581 .long .L_OP_UNUSED_A5FF /* 0x1a5 */ 20582 .long .L_OP_UNUSED_A6FF /* 0x1a6 */ 20583 .long .L_OP_UNUSED_A7FF /* 0x1a7 */ 20584 .long .L_OP_UNUSED_A8FF /* 0x1a8 */ 20585 .long .L_OP_UNUSED_A9FF /* 0x1a9 */ 20586 .long .L_OP_UNUSED_AAFF /* 0x1aa */ 20587 .long .L_OP_UNUSED_ABFF /* 0x1ab */ 20588 .long .L_OP_UNUSED_ACFF /* 0x1ac */ 20589 .long .L_OP_UNUSED_ADFF /* 0x1ad */ 20590 .long .L_OP_UNUSED_AEFF /* 0x1ae */ 20591 .long .L_OP_UNUSED_AFFF /* 0x1af */ 20592 .long .L_OP_UNUSED_B0FF /* 0x1b0 */ 20593 .long .L_OP_UNUSED_B1FF /* 0x1b1 */ 20594 .long .L_OP_UNUSED_B2FF /* 0x1b2 */ 20595 .long .L_OP_UNUSED_B3FF /* 0x1b3 */ 20596 .long .L_OP_UNUSED_B4FF /* 0x1b4 */ 20597 .long .L_OP_UNUSED_B5FF /* 0x1b5 */ 20598 .long .L_OP_UNUSED_B6FF /* 0x1b6 */ 20599 .long .L_OP_UNUSED_B7FF /* 0x1b7 */ 20600 .long .L_OP_UNUSED_B8FF /* 0x1b8 */ 20601 .long .L_OP_UNUSED_B9FF /* 0x1b9 */ 20602 .long .L_OP_UNUSED_BAFF /* 0x1ba */ 20603 .long .L_OP_UNUSED_BBFF /* 0x1bb */ 20604 .long .L_OP_UNUSED_BCFF /* 0x1bc */ 20605 .long .L_OP_UNUSED_BDFF /* 0x1bd */ 20606 .long .L_OP_UNUSED_BEFF /* 0x1be */ 20607 .long .L_OP_UNUSED_BFFF /* 0x1bf */ 20608 .long .L_OP_UNUSED_C0FF /* 0x1c0 */ 20609 .long .L_OP_UNUSED_C1FF /* 0x1c1 */ 20610 .long .L_OP_UNUSED_C2FF /* 0x1c2 */ 20611 .long .L_OP_UNUSED_C3FF /* 0x1c3 */ 20612 .long .L_OP_UNUSED_C4FF /* 0x1c4 */ 20613 .long .L_OP_UNUSED_C5FF /* 0x1c5 */ 20614 .long .L_OP_UNUSED_C6FF /* 0x1c6 */ 20615 .long .L_OP_UNUSED_C7FF /* 0x1c7 */ 20616 .long .L_OP_UNUSED_C8FF /* 0x1c8 */ 20617 .long .L_OP_UNUSED_C9FF /* 0x1c9 */ 20618 .long .L_OP_UNUSED_CAFF /* 0x1ca */ 20619 .long .L_OP_UNUSED_CBFF /* 0x1cb */ 20620 .long .L_OP_UNUSED_CCFF /* 0x1cc */ 20621 .long .L_OP_UNUSED_CDFF /* 0x1cd */ 20622 .long .L_OP_UNUSED_CEFF /* 0x1ce */ 20623 .long .L_OP_UNUSED_CFFF /* 0x1cf */ 20624 .long .L_OP_UNUSED_D0FF /* 0x1d0 */ 20625 .long .L_OP_UNUSED_D1FF /* 0x1d1 */ 20626 .long .L_OP_UNUSED_D2FF /* 0x1d2 */ 20627 .long .L_OP_UNUSED_D3FF /* 0x1d3 */ 20628 .long .L_OP_UNUSED_D4FF /* 0x1d4 */ 20629 .long .L_OP_UNUSED_D5FF /* 0x1d5 */ 20630 .long .L_OP_UNUSED_D6FF /* 0x1d6 */ 20631 .long .L_OP_UNUSED_D7FF /* 0x1d7 */ 20632 .long .L_OP_UNUSED_D8FF /* 0x1d8 */ 20633 .long .L_OP_UNUSED_D9FF /* 0x1d9 */ 20634 .long .L_OP_UNUSED_DAFF /* 0x1da */ 20635 .long .L_OP_UNUSED_DBFF /* 0x1db */ 20636 .long .L_OP_UNUSED_DCFF /* 0x1dc */ 20637 .long .L_OP_UNUSED_DDFF /* 0x1dd */ 20638 .long .L_OP_UNUSED_DEFF /* 0x1de */ 20639 .long .L_OP_UNUSED_DFFF /* 0x1df */ 20640 .long .L_OP_UNUSED_E0FF /* 0x1e0 */ 20641 .long .L_OP_UNUSED_E1FF /* 0x1e1 */ 20642 .long .L_OP_UNUSED_E2FF /* 0x1e2 */ 20643 .long .L_OP_UNUSED_E3FF /* 0x1e3 */ 20644 .long .L_OP_UNUSED_E4FF /* 0x1e4 */ 20645 .long .L_OP_UNUSED_E5FF /* 0x1e5 */ 20646 .long .L_OP_UNUSED_E6FF /* 0x1e6 */ 20647 .long .L_OP_UNUSED_E7FF /* 0x1e7 */ 20648 .long .L_OP_UNUSED_E8FF /* 0x1e8 */ 20649 .long .L_OP_UNUSED_E9FF /* 0x1e9 */ 20650 .long .L_OP_UNUSED_EAFF /* 0x1ea */ 20651 .long .L_OP_UNUSED_EBFF /* 0x1eb */ 20652 .long .L_OP_UNUSED_ECFF /* 0x1ec */ 20653 .long .L_OP_UNUSED_EDFF /* 0x1ed */ 20654 .long .L_OP_UNUSED_EEFF /* 0x1ee */ 20655 .long .L_OP_UNUSED_EFFF /* 0x1ef */ 20656 .long .L_OP_UNUSED_F0FF /* 0x1f0 */ 20657 .long .L_OP_UNUSED_F1FF /* 0x1f1 */ 20658 .long .L_OP_UNUSED_F2FF /* 0x1f2 */ 20659 .long .L_OP_UNUSED_F3FF /* 0x1f3 */ 20660 .long .L_OP_UNUSED_F4FF /* 0x1f4 */ 20661 .long .L_OP_UNUSED_F5FF /* 0x1f5 */ 20662 .long .L_OP_UNUSED_F6FF /* 0x1f6 */ 20663 .long .L_OP_UNUSED_F7FF /* 0x1f7 */ 20664 .long .L_OP_UNUSED_F8FF /* 0x1f8 */ 20665 .long .L_OP_UNUSED_F9FF /* 0x1f9 */ 20666 .long .L_OP_UNUSED_FAFF /* 0x1fa */ 20667 .long .L_OP_UNUSED_FBFF /* 0x1fb */ 20668 .long .L_OP_UNUSED_FCFF /* 0x1fc */ 20669 .long .L_OP_UNUSED_FDFF /* 0x1fd */ 20670 .long .L_OP_UNUSED_FEFF /* 0x1fe */ 20671 .long .L_OP_THROW_VERIFICATION_ERROR_JUMBO /* 0x1ff */ 20672 20673 .global dvmAsmAltInstructionStart 20674 .text 20675dvmAsmAltInstructionStart: 20676 .long .L_ALT_OP_NOP /* 0x00 */ 20677 .long .L_ALT_OP_MOVE /* 0x01 */ 20678 .long .L_ALT_OP_MOVE_FROM16 /* 0x02 */ 20679 .long .L_ALT_OP_MOVE_16 /* 0x03 */ 20680 .long .L_ALT_OP_MOVE_WIDE /* 0x04 */ 20681 .long .L_ALT_OP_MOVE_WIDE_FROM16 /* 0x05 */ 20682 .long .L_ALT_OP_MOVE_WIDE_16 /* 0x06 */ 20683 .long .L_ALT_OP_MOVE_OBJECT /* 0x07 */ 20684 .long .L_ALT_OP_MOVE_OBJECT_FROM16 /* 0x08 */ 20685 .long .L_ALT_OP_MOVE_OBJECT_16 /* 0x09 */ 20686 .long .L_ALT_OP_MOVE_RESULT /* 0x0a */ 20687 .long .L_ALT_OP_MOVE_RESULT_WIDE /* 0x0b */ 20688 .long .L_ALT_OP_MOVE_RESULT_OBJECT /* 0x0c */ 20689 .long .L_ALT_OP_MOVE_EXCEPTION /* 0x0d */ 20690 .long .L_ALT_OP_RETURN_VOID /* 0x0e */ 20691 .long .L_ALT_OP_RETURN /* 0x0f */ 20692 .long .L_ALT_OP_RETURN_WIDE /* 0x10 */ 20693 .long .L_ALT_OP_RETURN_OBJECT /* 0x11 */ 20694 .long .L_ALT_OP_CONST_4 /* 0x12 */ 20695 .long .L_ALT_OP_CONST_16 /* 0x13 */ 20696 .long .L_ALT_OP_CONST /* 0x14 */ 20697 .long .L_ALT_OP_CONST_HIGH16 /* 0x15 */ 20698 .long .L_ALT_OP_CONST_WIDE_16 /* 0x16 */ 20699 .long .L_ALT_OP_CONST_WIDE_32 /* 0x17 */ 20700 .long .L_ALT_OP_CONST_WIDE /* 0x18 */ 20701 .long .L_ALT_OP_CONST_WIDE_HIGH16 /* 0x19 */ 20702 .long .L_ALT_OP_CONST_STRING /* 0x1a */ 20703 .long .L_ALT_OP_CONST_STRING_JUMBO /* 0x1b */ 20704 .long .L_ALT_OP_CONST_CLASS /* 0x1c */ 20705 .long .L_ALT_OP_MONITOR_ENTER /* 0x1d */ 20706 .long .L_ALT_OP_MONITOR_EXIT /* 0x1e */ 20707 .long .L_ALT_OP_CHECK_CAST /* 0x1f */ 20708 .long .L_ALT_OP_INSTANCE_OF /* 0x20 */ 20709 .long .L_ALT_OP_ARRAY_LENGTH /* 0x21 */ 20710 .long .L_ALT_OP_NEW_INSTANCE /* 0x22 */ 20711 .long .L_ALT_OP_NEW_ARRAY /* 0x23 */ 20712 .long .L_ALT_OP_FILLED_NEW_ARRAY /* 0x24 */ 20713 .long .L_ALT_OP_FILLED_NEW_ARRAY_RANGE /* 0x25 */ 20714 .long .L_ALT_OP_FILL_ARRAY_DATA /* 0x26 */ 20715 .long .L_ALT_OP_THROW /* 0x27 */ 20716 .long .L_ALT_OP_GOTO /* 0x28 */ 20717 .long .L_ALT_OP_GOTO_16 /* 0x29 */ 20718 .long .L_ALT_OP_GOTO_32 /* 0x2a */ 20719 .long .L_ALT_OP_PACKED_SWITCH /* 0x2b */ 20720 .long .L_ALT_OP_SPARSE_SWITCH /* 0x2c */ 20721 .long .L_ALT_OP_CMPL_FLOAT /* 0x2d */ 20722 .long .L_ALT_OP_CMPG_FLOAT /* 0x2e */ 20723 .long .L_ALT_OP_CMPL_DOUBLE /* 0x2f */ 20724 .long .L_ALT_OP_CMPG_DOUBLE /* 0x30 */ 20725 .long .L_ALT_OP_CMP_LONG /* 0x31 */ 20726 .long .L_ALT_OP_IF_EQ /* 0x32 */ 20727 .long .L_ALT_OP_IF_NE /* 0x33 */ 20728 .long .L_ALT_OP_IF_LT /* 0x34 */ 20729 .long .L_ALT_OP_IF_GE /* 0x35 */ 20730 .long .L_ALT_OP_IF_GT /* 0x36 */ 20731 .long .L_ALT_OP_IF_LE /* 0x37 */ 20732 .long .L_ALT_OP_IF_EQZ /* 0x38 */ 20733 .long .L_ALT_OP_IF_NEZ /* 0x39 */ 20734 .long .L_ALT_OP_IF_LTZ /* 0x3a */ 20735 .long .L_ALT_OP_IF_GEZ /* 0x3b */ 20736 .long .L_ALT_OP_IF_GTZ /* 0x3c */ 20737 .long .L_ALT_OP_IF_LEZ /* 0x3d */ 20738 .long .L_ALT_OP_UNUSED_3E /* 0x3e */ 20739 .long .L_ALT_OP_UNUSED_3F /* 0x3f */ 20740 .long .L_ALT_OP_UNUSED_40 /* 0x40 */ 20741 .long .L_ALT_OP_UNUSED_41 /* 0x41 */ 20742 .long .L_ALT_OP_UNUSED_42 /* 0x42 */ 20743 .long .L_ALT_OP_UNUSED_43 /* 0x43 */ 20744 .long .L_ALT_OP_AGET /* 0x44 */ 20745 .long .L_ALT_OP_AGET_WIDE /* 0x45 */ 20746 .long .L_ALT_OP_AGET_OBJECT /* 0x46 */ 20747 .long .L_ALT_OP_AGET_BOOLEAN /* 0x47 */ 20748 .long .L_ALT_OP_AGET_BYTE /* 0x48 */ 20749 .long .L_ALT_OP_AGET_CHAR /* 0x49 */ 20750 .long .L_ALT_OP_AGET_SHORT /* 0x4a */ 20751 .long .L_ALT_OP_APUT /* 0x4b */ 20752 .long .L_ALT_OP_APUT_WIDE /* 0x4c */ 20753 .long .L_ALT_OP_APUT_OBJECT /* 0x4d */ 20754 .long .L_ALT_OP_APUT_BOOLEAN /* 0x4e */ 20755 .long .L_ALT_OP_APUT_BYTE /* 0x4f */ 20756 .long .L_ALT_OP_APUT_CHAR /* 0x50 */ 20757 .long .L_ALT_OP_APUT_SHORT /* 0x51 */ 20758 .long .L_ALT_OP_IGET /* 0x52 */ 20759 .long .L_ALT_OP_IGET_WIDE /* 0x53 */ 20760 .long .L_ALT_OP_IGET_OBJECT /* 0x54 */ 20761 .long .L_ALT_OP_IGET_BOOLEAN /* 0x55 */ 20762 .long .L_ALT_OP_IGET_BYTE /* 0x56 */ 20763 .long .L_ALT_OP_IGET_CHAR /* 0x57 */ 20764 .long .L_ALT_OP_IGET_SHORT /* 0x58 */ 20765 .long .L_ALT_OP_IPUT /* 0x59 */ 20766 .long .L_ALT_OP_IPUT_WIDE /* 0x5a */ 20767 .long .L_ALT_OP_IPUT_OBJECT /* 0x5b */ 20768 .long .L_ALT_OP_IPUT_BOOLEAN /* 0x5c */ 20769 .long .L_ALT_OP_IPUT_BYTE /* 0x5d */ 20770 .long .L_ALT_OP_IPUT_CHAR /* 0x5e */ 20771 .long .L_ALT_OP_IPUT_SHORT /* 0x5f */ 20772 .long .L_ALT_OP_SGET /* 0x60 */ 20773 .long .L_ALT_OP_SGET_WIDE /* 0x61 */ 20774 .long .L_ALT_OP_SGET_OBJECT /* 0x62 */ 20775 .long .L_ALT_OP_SGET_BOOLEAN /* 0x63 */ 20776 .long .L_ALT_OP_SGET_BYTE /* 0x64 */ 20777 .long .L_ALT_OP_SGET_CHAR /* 0x65 */ 20778 .long .L_ALT_OP_SGET_SHORT /* 0x66 */ 20779 .long .L_ALT_OP_SPUT /* 0x67 */ 20780 .long .L_ALT_OP_SPUT_WIDE /* 0x68 */ 20781 .long .L_ALT_OP_SPUT_OBJECT /* 0x69 */ 20782 .long .L_ALT_OP_SPUT_BOOLEAN /* 0x6a */ 20783 .long .L_ALT_OP_SPUT_BYTE /* 0x6b */ 20784 .long .L_ALT_OP_SPUT_CHAR /* 0x6c */ 20785 .long .L_ALT_OP_SPUT_SHORT /* 0x6d */ 20786 .long .L_ALT_OP_INVOKE_VIRTUAL /* 0x6e */ 20787 .long .L_ALT_OP_INVOKE_SUPER /* 0x6f */ 20788 .long .L_ALT_OP_INVOKE_DIRECT /* 0x70 */ 20789 .long .L_ALT_OP_INVOKE_STATIC /* 0x71 */ 20790 .long .L_ALT_OP_INVOKE_INTERFACE /* 0x72 */ 20791 .long .L_ALT_OP_UNUSED_73 /* 0x73 */ 20792 .long .L_ALT_OP_INVOKE_VIRTUAL_RANGE /* 0x74 */ 20793 .long .L_ALT_OP_INVOKE_SUPER_RANGE /* 0x75 */ 20794 .long .L_ALT_OP_INVOKE_DIRECT_RANGE /* 0x76 */ 20795 .long .L_ALT_OP_INVOKE_STATIC_RANGE /* 0x77 */ 20796 .long .L_ALT_OP_INVOKE_INTERFACE_RANGE /* 0x78 */ 20797 .long .L_ALT_OP_UNUSED_79 /* 0x79 */ 20798 .long .L_ALT_OP_UNUSED_7A /* 0x7a */ 20799 .long .L_ALT_OP_NEG_INT /* 0x7b */ 20800 .long .L_ALT_OP_NOT_INT /* 0x7c */ 20801 .long .L_ALT_OP_NEG_LONG /* 0x7d */ 20802 .long .L_ALT_OP_NOT_LONG /* 0x7e */ 20803 .long .L_ALT_OP_NEG_FLOAT /* 0x7f */ 20804 .long .L_ALT_OP_NEG_DOUBLE /* 0x80 */ 20805 .long .L_ALT_OP_INT_TO_LONG /* 0x81 */ 20806 .long .L_ALT_OP_INT_TO_FLOAT /* 0x82 */ 20807 .long .L_ALT_OP_INT_TO_DOUBLE /* 0x83 */ 20808 .long .L_ALT_OP_LONG_TO_INT /* 0x84 */ 20809 .long .L_ALT_OP_LONG_TO_FLOAT /* 0x85 */ 20810 .long .L_ALT_OP_LONG_TO_DOUBLE /* 0x86 */ 20811 .long .L_ALT_OP_FLOAT_TO_INT /* 0x87 */ 20812 .long .L_ALT_OP_FLOAT_TO_LONG /* 0x88 */ 20813 .long .L_ALT_OP_FLOAT_TO_DOUBLE /* 0x89 */ 20814 .long .L_ALT_OP_DOUBLE_TO_INT /* 0x8a */ 20815 .long .L_ALT_OP_DOUBLE_TO_LONG /* 0x8b */ 20816 .long .L_ALT_OP_DOUBLE_TO_FLOAT /* 0x8c */ 20817 .long .L_ALT_OP_INT_TO_BYTE /* 0x8d */ 20818 .long .L_ALT_OP_INT_TO_CHAR /* 0x8e */ 20819 .long .L_ALT_OP_INT_TO_SHORT /* 0x8f */ 20820 .long .L_ALT_OP_ADD_INT /* 0x90 */ 20821 .long .L_ALT_OP_SUB_INT /* 0x91 */ 20822 .long .L_ALT_OP_MUL_INT /* 0x92 */ 20823 .long .L_ALT_OP_DIV_INT /* 0x93 */ 20824 .long .L_ALT_OP_REM_INT /* 0x94 */ 20825 .long .L_ALT_OP_AND_INT /* 0x95 */ 20826 .long .L_ALT_OP_OR_INT /* 0x96 */ 20827 .long .L_ALT_OP_XOR_INT /* 0x97 */ 20828 .long .L_ALT_OP_SHL_INT /* 0x98 */ 20829 .long .L_ALT_OP_SHR_INT /* 0x99 */ 20830 .long .L_ALT_OP_USHR_INT /* 0x9a */ 20831 .long .L_ALT_OP_ADD_LONG /* 0x9b */ 20832 .long .L_ALT_OP_SUB_LONG /* 0x9c */ 20833 .long .L_ALT_OP_MUL_LONG /* 0x9d */ 20834 .long .L_ALT_OP_DIV_LONG /* 0x9e */ 20835 .long .L_ALT_OP_REM_LONG /* 0x9f */ 20836 .long .L_ALT_OP_AND_LONG /* 0xa0 */ 20837 .long .L_ALT_OP_OR_LONG /* 0xa1 */ 20838 .long .L_ALT_OP_XOR_LONG /* 0xa2 */ 20839 .long .L_ALT_OP_SHL_LONG /* 0xa3 */ 20840 .long .L_ALT_OP_SHR_LONG /* 0xa4 */ 20841 .long .L_ALT_OP_USHR_LONG /* 0xa5 */ 20842 .long .L_ALT_OP_ADD_FLOAT /* 0xa6 */ 20843 .long .L_ALT_OP_SUB_FLOAT /* 0xa7 */ 20844 .long .L_ALT_OP_MUL_FLOAT /* 0xa8 */ 20845 .long .L_ALT_OP_DIV_FLOAT /* 0xa9 */ 20846 .long .L_ALT_OP_REM_FLOAT /* 0xaa */ 20847 .long .L_ALT_OP_ADD_DOUBLE /* 0xab */ 20848 .long .L_ALT_OP_SUB_DOUBLE /* 0xac */ 20849 .long .L_ALT_OP_MUL_DOUBLE /* 0xad */ 20850 .long .L_ALT_OP_DIV_DOUBLE /* 0xae */ 20851 .long .L_ALT_OP_REM_DOUBLE /* 0xaf */ 20852 .long .L_ALT_OP_ADD_INT_2ADDR /* 0xb0 */ 20853 .long .L_ALT_OP_SUB_INT_2ADDR /* 0xb1 */ 20854 .long .L_ALT_OP_MUL_INT_2ADDR /* 0xb2 */ 20855 .long .L_ALT_OP_DIV_INT_2ADDR /* 0xb3 */ 20856 .long .L_ALT_OP_REM_INT_2ADDR /* 0xb4 */ 20857 .long .L_ALT_OP_AND_INT_2ADDR /* 0xb5 */ 20858 .long .L_ALT_OP_OR_INT_2ADDR /* 0xb6 */ 20859 .long .L_ALT_OP_XOR_INT_2ADDR /* 0xb7 */ 20860 .long .L_ALT_OP_SHL_INT_2ADDR /* 0xb8 */ 20861 .long .L_ALT_OP_SHR_INT_2ADDR /* 0xb9 */ 20862 .long .L_ALT_OP_USHR_INT_2ADDR /* 0xba */ 20863 .long .L_ALT_OP_ADD_LONG_2ADDR /* 0xbb */ 20864 .long .L_ALT_OP_SUB_LONG_2ADDR /* 0xbc */ 20865 .long .L_ALT_OP_MUL_LONG_2ADDR /* 0xbd */ 20866 .long .L_ALT_OP_DIV_LONG_2ADDR /* 0xbe */ 20867 .long .L_ALT_OP_REM_LONG_2ADDR /* 0xbf */ 20868 .long .L_ALT_OP_AND_LONG_2ADDR /* 0xc0 */ 20869 .long .L_ALT_OP_OR_LONG_2ADDR /* 0xc1 */ 20870 .long .L_ALT_OP_XOR_LONG_2ADDR /* 0xc2 */ 20871 .long .L_ALT_OP_SHL_LONG_2ADDR /* 0xc3 */ 20872 .long .L_ALT_OP_SHR_LONG_2ADDR /* 0xc4 */ 20873 .long .L_ALT_OP_USHR_LONG_2ADDR /* 0xc5 */ 20874 .long .L_ALT_OP_ADD_FLOAT_2ADDR /* 0xc6 */ 20875 .long .L_ALT_OP_SUB_FLOAT_2ADDR /* 0xc7 */ 20876 .long .L_ALT_OP_MUL_FLOAT_2ADDR /* 0xc8 */ 20877 .long .L_ALT_OP_DIV_FLOAT_2ADDR /* 0xc9 */ 20878 .long .L_ALT_OP_REM_FLOAT_2ADDR /* 0xca */ 20879 .long .L_ALT_OP_ADD_DOUBLE_2ADDR /* 0xcb */ 20880 .long .L_ALT_OP_SUB_DOUBLE_2ADDR /* 0xcc */ 20881 .long .L_ALT_OP_MUL_DOUBLE_2ADDR /* 0xcd */ 20882 .long .L_ALT_OP_DIV_DOUBLE_2ADDR /* 0xce */ 20883 .long .L_ALT_OP_REM_DOUBLE_2ADDR /* 0xcf */ 20884 .long .L_ALT_OP_ADD_INT_LIT16 /* 0xd0 */ 20885 .long .L_ALT_OP_RSUB_INT /* 0xd1 */ 20886 .long .L_ALT_OP_MUL_INT_LIT16 /* 0xd2 */ 20887 .long .L_ALT_OP_DIV_INT_LIT16 /* 0xd3 */ 20888 .long .L_ALT_OP_REM_INT_LIT16 /* 0xd4 */ 20889 .long .L_ALT_OP_AND_INT_LIT16 /* 0xd5 */ 20890 .long .L_ALT_OP_OR_INT_LIT16 /* 0xd6 */ 20891 .long .L_ALT_OP_XOR_INT_LIT16 /* 0xd7 */ 20892 .long .L_ALT_OP_ADD_INT_LIT8 /* 0xd8 */ 20893 .long .L_ALT_OP_RSUB_INT_LIT8 /* 0xd9 */ 20894 .long .L_ALT_OP_MUL_INT_LIT8 /* 0xda */ 20895 .long .L_ALT_OP_DIV_INT_LIT8 /* 0xdb */ 20896 .long .L_ALT_OP_REM_INT_LIT8 /* 0xdc */ 20897 .long .L_ALT_OP_AND_INT_LIT8 /* 0xdd */ 20898 .long .L_ALT_OP_OR_INT_LIT8 /* 0xde */ 20899 .long .L_ALT_OP_XOR_INT_LIT8 /* 0xdf */ 20900 .long .L_ALT_OP_SHL_INT_LIT8 /* 0xe0 */ 20901 .long .L_ALT_OP_SHR_INT_LIT8 /* 0xe1 */ 20902 .long .L_ALT_OP_USHR_INT_LIT8 /* 0xe2 */ 20903 .long .L_ALT_OP_IGET_VOLATILE /* 0xe3 */ 20904 .long .L_ALT_OP_IPUT_VOLATILE /* 0xe4 */ 20905 .long .L_ALT_OP_SGET_VOLATILE /* 0xe5 */ 20906 .long .L_ALT_OP_SPUT_VOLATILE /* 0xe6 */ 20907 .long .L_ALT_OP_IGET_OBJECT_VOLATILE /* 0xe7 */ 20908 .long .L_ALT_OP_IGET_WIDE_VOLATILE /* 0xe8 */ 20909 .long .L_ALT_OP_IPUT_WIDE_VOLATILE /* 0xe9 */ 20910 .long .L_ALT_OP_SGET_WIDE_VOLATILE /* 0xea */ 20911 .long .L_ALT_OP_SPUT_WIDE_VOLATILE /* 0xeb */ 20912 .long .L_ALT_OP_BREAKPOINT /* 0xec */ 20913 .long .L_ALT_OP_THROW_VERIFICATION_ERROR /* 0xed */ 20914 .long .L_ALT_OP_EXECUTE_INLINE /* 0xee */ 20915 .long .L_ALT_OP_EXECUTE_INLINE_RANGE /* 0xef */ 20916 .long .L_ALT_OP_INVOKE_OBJECT_INIT_RANGE /* 0xf0 */ 20917 .long .L_ALT_OP_RETURN_VOID_BARRIER /* 0xf1 */ 20918 .long .L_ALT_OP_IGET_QUICK /* 0xf2 */ 20919 .long .L_ALT_OP_IGET_WIDE_QUICK /* 0xf3 */ 20920 .long .L_ALT_OP_IGET_OBJECT_QUICK /* 0xf4 */ 20921 .long .L_ALT_OP_IPUT_QUICK /* 0xf5 */ 20922 .long .L_ALT_OP_IPUT_WIDE_QUICK /* 0xf6 */ 20923 .long .L_ALT_OP_IPUT_OBJECT_QUICK /* 0xf7 */ 20924 .long .L_ALT_OP_INVOKE_VIRTUAL_QUICK /* 0xf8 */ 20925 .long .L_ALT_OP_INVOKE_VIRTUAL_QUICK_RANGE /* 0xf9 */ 20926 .long .L_ALT_OP_INVOKE_SUPER_QUICK /* 0xfa */ 20927 .long .L_ALT_OP_INVOKE_SUPER_QUICK_RANGE /* 0xfb */ 20928 .long .L_ALT_OP_IPUT_OBJECT_VOLATILE /* 0xfc */ 20929 .long .L_ALT_OP_SGET_OBJECT_VOLATILE /* 0xfd */ 20930 .long .L_ALT_OP_SPUT_OBJECT_VOLATILE /* 0xfe */ 20931 .long .L_ALT_OP_DISPATCH_FF /* 0xff */ 20932 .long .L_ALT_OP_CONST_CLASS_JUMBO /* 0x100 */ 20933 .long .L_ALT_OP_CHECK_CAST_JUMBO /* 0x101 */ 20934 .long .L_ALT_OP_INSTANCE_OF_JUMBO /* 0x102 */ 20935 .long .L_ALT_OP_NEW_INSTANCE_JUMBO /* 0x103 */ 20936 .long .L_ALT_OP_NEW_ARRAY_JUMBO /* 0x104 */ 20937 .long .L_ALT_OP_FILLED_NEW_ARRAY_JUMBO /* 0x105 */ 20938 .long .L_ALT_OP_IGET_JUMBO /* 0x106 */ 20939 .long .L_ALT_OP_IGET_WIDE_JUMBO /* 0x107 */ 20940 .long .L_ALT_OP_IGET_OBJECT_JUMBO /* 0x108 */ 20941 .long .L_ALT_OP_IGET_BOOLEAN_JUMBO /* 0x109 */ 20942 .long .L_ALT_OP_IGET_BYTE_JUMBO /* 0x10a */ 20943 .long .L_ALT_OP_IGET_CHAR_JUMBO /* 0x10b */ 20944 .long .L_ALT_OP_IGET_SHORT_JUMBO /* 0x10c */ 20945 .long .L_ALT_OP_IPUT_JUMBO /* 0x10d */ 20946 .long .L_ALT_OP_IPUT_WIDE_JUMBO /* 0x10e */ 20947 .long .L_ALT_OP_IPUT_OBJECT_JUMBO /* 0x10f */ 20948 .long .L_ALT_OP_IPUT_BOOLEAN_JUMBO /* 0x110 */ 20949 .long .L_ALT_OP_IPUT_BYTE_JUMBO /* 0x111 */ 20950 .long .L_ALT_OP_IPUT_CHAR_JUMBO /* 0x112 */ 20951 .long .L_ALT_OP_IPUT_SHORT_JUMBO /* 0x113 */ 20952 .long .L_ALT_OP_SGET_JUMBO /* 0x114 */ 20953 .long .L_ALT_OP_SGET_WIDE_JUMBO /* 0x115 */ 20954 .long .L_ALT_OP_SGET_OBJECT_JUMBO /* 0x116 */ 20955 .long .L_ALT_OP_SGET_BOOLEAN_JUMBO /* 0x117 */ 20956 .long .L_ALT_OP_SGET_BYTE_JUMBO /* 0x118 */ 20957 .long .L_ALT_OP_SGET_CHAR_JUMBO /* 0x119 */ 20958 .long .L_ALT_OP_SGET_SHORT_JUMBO /* 0x11a */ 20959 .long .L_ALT_OP_SPUT_JUMBO /* 0x11b */ 20960 .long .L_ALT_OP_SPUT_WIDE_JUMBO /* 0x11c */ 20961 .long .L_ALT_OP_SPUT_OBJECT_JUMBO /* 0x11d */ 20962 .long .L_ALT_OP_SPUT_BOOLEAN_JUMBO /* 0x11e */ 20963 .long .L_ALT_OP_SPUT_BYTE_JUMBO /* 0x11f */ 20964 .long .L_ALT_OP_SPUT_CHAR_JUMBO /* 0x120 */ 20965 .long .L_ALT_OP_SPUT_SHORT_JUMBO /* 0x121 */ 20966 .long .L_ALT_OP_INVOKE_VIRTUAL_JUMBO /* 0x122 */ 20967 .long .L_ALT_OP_INVOKE_SUPER_JUMBO /* 0x123 */ 20968 .long .L_ALT_OP_INVOKE_DIRECT_JUMBO /* 0x124 */ 20969 .long .L_ALT_OP_INVOKE_STATIC_JUMBO /* 0x125 */ 20970 .long .L_ALT_OP_INVOKE_INTERFACE_JUMBO /* 0x126 */ 20971 .long .L_ALT_OP_UNUSED_27FF /* 0x127 */ 20972 .long .L_ALT_OP_UNUSED_28FF /* 0x128 */ 20973 .long .L_ALT_OP_UNUSED_29FF /* 0x129 */ 20974 .long .L_ALT_OP_UNUSED_2AFF /* 0x12a */ 20975 .long .L_ALT_OP_UNUSED_2BFF /* 0x12b */ 20976 .long .L_ALT_OP_UNUSED_2CFF /* 0x12c */ 20977 .long .L_ALT_OP_UNUSED_2DFF /* 0x12d */ 20978 .long .L_ALT_OP_UNUSED_2EFF /* 0x12e */ 20979 .long .L_ALT_OP_UNUSED_2FFF /* 0x12f */ 20980 .long .L_ALT_OP_UNUSED_30FF /* 0x130 */ 20981 .long .L_ALT_OP_UNUSED_31FF /* 0x131 */ 20982 .long .L_ALT_OP_UNUSED_32FF /* 0x132 */ 20983 .long .L_ALT_OP_UNUSED_33FF /* 0x133 */ 20984 .long .L_ALT_OP_UNUSED_34FF /* 0x134 */ 20985 .long .L_ALT_OP_UNUSED_35FF /* 0x135 */ 20986 .long .L_ALT_OP_UNUSED_36FF /* 0x136 */ 20987 .long .L_ALT_OP_UNUSED_37FF /* 0x137 */ 20988 .long .L_ALT_OP_UNUSED_38FF /* 0x138 */ 20989 .long .L_ALT_OP_UNUSED_39FF /* 0x139 */ 20990 .long .L_ALT_OP_UNUSED_3AFF /* 0x13a */ 20991 .long .L_ALT_OP_UNUSED_3BFF /* 0x13b */ 20992 .long .L_ALT_OP_UNUSED_3CFF /* 0x13c */ 20993 .long .L_ALT_OP_UNUSED_3DFF /* 0x13d */ 20994 .long .L_ALT_OP_UNUSED_3EFF /* 0x13e */ 20995 .long .L_ALT_OP_UNUSED_3FFF /* 0x13f */ 20996 .long .L_ALT_OP_UNUSED_40FF /* 0x140 */ 20997 .long .L_ALT_OP_UNUSED_41FF /* 0x141 */ 20998 .long .L_ALT_OP_UNUSED_42FF /* 0x142 */ 20999 .long .L_ALT_OP_UNUSED_43FF /* 0x143 */ 21000 .long .L_ALT_OP_UNUSED_44FF /* 0x144 */ 21001 .long .L_ALT_OP_UNUSED_45FF /* 0x145 */ 21002 .long .L_ALT_OP_UNUSED_46FF /* 0x146 */ 21003 .long .L_ALT_OP_UNUSED_47FF /* 0x147 */ 21004 .long .L_ALT_OP_UNUSED_48FF /* 0x148 */ 21005 .long .L_ALT_OP_UNUSED_49FF /* 0x149 */ 21006 .long .L_ALT_OP_UNUSED_4AFF /* 0x14a */ 21007 .long .L_ALT_OP_UNUSED_4BFF /* 0x14b */ 21008 .long .L_ALT_OP_UNUSED_4CFF /* 0x14c */ 21009 .long .L_ALT_OP_UNUSED_4DFF /* 0x14d */ 21010 .long .L_ALT_OP_UNUSED_4EFF /* 0x14e */ 21011 .long .L_ALT_OP_UNUSED_4FFF /* 0x14f */ 21012 .long .L_ALT_OP_UNUSED_50FF /* 0x150 */ 21013 .long .L_ALT_OP_UNUSED_51FF /* 0x151 */ 21014 .long .L_ALT_OP_UNUSED_52FF /* 0x152 */ 21015 .long .L_ALT_OP_UNUSED_53FF /* 0x153 */ 21016 .long .L_ALT_OP_UNUSED_54FF /* 0x154 */ 21017 .long .L_ALT_OP_UNUSED_55FF /* 0x155 */ 21018 .long .L_ALT_OP_UNUSED_56FF /* 0x156 */ 21019 .long .L_ALT_OP_UNUSED_57FF /* 0x157 */ 21020 .long .L_ALT_OP_UNUSED_58FF /* 0x158 */ 21021 .long .L_ALT_OP_UNUSED_59FF /* 0x159 */ 21022 .long .L_ALT_OP_UNUSED_5AFF /* 0x15a */ 21023 .long .L_ALT_OP_UNUSED_5BFF /* 0x15b */ 21024 .long .L_ALT_OP_UNUSED_5CFF /* 0x15c */ 21025 .long .L_ALT_OP_UNUSED_5DFF /* 0x15d */ 21026 .long .L_ALT_OP_UNUSED_5EFF /* 0x15e */ 21027 .long .L_ALT_OP_UNUSED_5FFF /* 0x15f */ 21028 .long .L_ALT_OP_UNUSED_60FF /* 0x160 */ 21029 .long .L_ALT_OP_UNUSED_61FF /* 0x161 */ 21030 .long .L_ALT_OP_UNUSED_62FF /* 0x162 */ 21031 .long .L_ALT_OP_UNUSED_63FF /* 0x163 */ 21032 .long .L_ALT_OP_UNUSED_64FF /* 0x164 */ 21033 .long .L_ALT_OP_UNUSED_65FF /* 0x165 */ 21034 .long .L_ALT_OP_UNUSED_66FF /* 0x166 */ 21035 .long .L_ALT_OP_UNUSED_67FF /* 0x167 */ 21036 .long .L_ALT_OP_UNUSED_68FF /* 0x168 */ 21037 .long .L_ALT_OP_UNUSED_69FF /* 0x169 */ 21038 .long .L_ALT_OP_UNUSED_6AFF /* 0x16a */ 21039 .long .L_ALT_OP_UNUSED_6BFF /* 0x16b */ 21040 .long .L_ALT_OP_UNUSED_6CFF /* 0x16c */ 21041 .long .L_ALT_OP_UNUSED_6DFF /* 0x16d */ 21042 .long .L_ALT_OP_UNUSED_6EFF /* 0x16e */ 21043 .long .L_ALT_OP_UNUSED_6FFF /* 0x16f */ 21044 .long .L_ALT_OP_UNUSED_70FF /* 0x170 */ 21045 .long .L_ALT_OP_UNUSED_71FF /* 0x171 */ 21046 .long .L_ALT_OP_UNUSED_72FF /* 0x172 */ 21047 .long .L_ALT_OP_UNUSED_73FF /* 0x173 */ 21048 .long .L_ALT_OP_UNUSED_74FF /* 0x174 */ 21049 .long .L_ALT_OP_UNUSED_75FF /* 0x175 */ 21050 .long .L_ALT_OP_UNUSED_76FF /* 0x176 */ 21051 .long .L_ALT_OP_UNUSED_77FF /* 0x177 */ 21052 .long .L_ALT_OP_UNUSED_78FF /* 0x178 */ 21053 .long .L_ALT_OP_UNUSED_79FF /* 0x179 */ 21054 .long .L_ALT_OP_UNUSED_7AFF /* 0x17a */ 21055 .long .L_ALT_OP_UNUSED_7BFF /* 0x17b */ 21056 .long .L_ALT_OP_UNUSED_7CFF /* 0x17c */ 21057 .long .L_ALT_OP_UNUSED_7DFF /* 0x17d */ 21058 .long .L_ALT_OP_UNUSED_7EFF /* 0x17e */ 21059 .long .L_ALT_OP_UNUSED_7FFF /* 0x17f */ 21060 .long .L_ALT_OP_UNUSED_80FF /* 0x180 */ 21061 .long .L_ALT_OP_UNUSED_81FF /* 0x181 */ 21062 .long .L_ALT_OP_UNUSED_82FF /* 0x182 */ 21063 .long .L_ALT_OP_UNUSED_83FF /* 0x183 */ 21064 .long .L_ALT_OP_UNUSED_84FF /* 0x184 */ 21065 .long .L_ALT_OP_UNUSED_85FF /* 0x185 */ 21066 .long .L_ALT_OP_UNUSED_86FF /* 0x186 */ 21067 .long .L_ALT_OP_UNUSED_87FF /* 0x187 */ 21068 .long .L_ALT_OP_UNUSED_88FF /* 0x188 */ 21069 .long .L_ALT_OP_UNUSED_89FF /* 0x189 */ 21070 .long .L_ALT_OP_UNUSED_8AFF /* 0x18a */ 21071 .long .L_ALT_OP_UNUSED_8BFF /* 0x18b */ 21072 .long .L_ALT_OP_UNUSED_8CFF /* 0x18c */ 21073 .long .L_ALT_OP_UNUSED_8DFF /* 0x18d */ 21074 .long .L_ALT_OP_UNUSED_8EFF /* 0x18e */ 21075 .long .L_ALT_OP_UNUSED_8FFF /* 0x18f */ 21076 .long .L_ALT_OP_UNUSED_90FF /* 0x190 */ 21077 .long .L_ALT_OP_UNUSED_91FF /* 0x191 */ 21078 .long .L_ALT_OP_UNUSED_92FF /* 0x192 */ 21079 .long .L_ALT_OP_UNUSED_93FF /* 0x193 */ 21080 .long .L_ALT_OP_UNUSED_94FF /* 0x194 */ 21081 .long .L_ALT_OP_UNUSED_95FF /* 0x195 */ 21082 .long .L_ALT_OP_UNUSED_96FF /* 0x196 */ 21083 .long .L_ALT_OP_UNUSED_97FF /* 0x197 */ 21084 .long .L_ALT_OP_UNUSED_98FF /* 0x198 */ 21085 .long .L_ALT_OP_UNUSED_99FF /* 0x199 */ 21086 .long .L_ALT_OP_UNUSED_9AFF /* 0x19a */ 21087 .long .L_ALT_OP_UNUSED_9BFF /* 0x19b */ 21088 .long .L_ALT_OP_UNUSED_9CFF /* 0x19c */ 21089 .long .L_ALT_OP_UNUSED_9DFF /* 0x19d */ 21090 .long .L_ALT_OP_UNUSED_9EFF /* 0x19e */ 21091 .long .L_ALT_OP_UNUSED_9FFF /* 0x19f */ 21092 .long .L_ALT_OP_UNUSED_A0FF /* 0x1a0 */ 21093 .long .L_ALT_OP_UNUSED_A1FF /* 0x1a1 */ 21094 .long .L_ALT_OP_UNUSED_A2FF /* 0x1a2 */ 21095 .long .L_ALT_OP_UNUSED_A3FF /* 0x1a3 */ 21096 .long .L_ALT_OP_UNUSED_A4FF /* 0x1a4 */ 21097 .long .L_ALT_OP_UNUSED_A5FF /* 0x1a5 */ 21098 .long .L_ALT_OP_UNUSED_A6FF /* 0x1a6 */ 21099 .long .L_ALT_OP_UNUSED_A7FF /* 0x1a7 */ 21100 .long .L_ALT_OP_UNUSED_A8FF /* 0x1a8 */ 21101 .long .L_ALT_OP_UNUSED_A9FF /* 0x1a9 */ 21102 .long .L_ALT_OP_UNUSED_AAFF /* 0x1aa */ 21103 .long .L_ALT_OP_UNUSED_ABFF /* 0x1ab */ 21104 .long .L_ALT_OP_UNUSED_ACFF /* 0x1ac */ 21105 .long .L_ALT_OP_UNUSED_ADFF /* 0x1ad */ 21106 .long .L_ALT_OP_UNUSED_AEFF /* 0x1ae */ 21107 .long .L_ALT_OP_UNUSED_AFFF /* 0x1af */ 21108 .long .L_ALT_OP_UNUSED_B0FF /* 0x1b0 */ 21109 .long .L_ALT_OP_UNUSED_B1FF /* 0x1b1 */ 21110 .long .L_ALT_OP_UNUSED_B2FF /* 0x1b2 */ 21111 .long .L_ALT_OP_UNUSED_B3FF /* 0x1b3 */ 21112 .long .L_ALT_OP_UNUSED_B4FF /* 0x1b4 */ 21113 .long .L_ALT_OP_UNUSED_B5FF /* 0x1b5 */ 21114 .long .L_ALT_OP_UNUSED_B6FF /* 0x1b6 */ 21115 .long .L_ALT_OP_UNUSED_B7FF /* 0x1b7 */ 21116 .long .L_ALT_OP_UNUSED_B8FF /* 0x1b8 */ 21117 .long .L_ALT_OP_UNUSED_B9FF /* 0x1b9 */ 21118 .long .L_ALT_OP_UNUSED_BAFF /* 0x1ba */ 21119 .long .L_ALT_OP_UNUSED_BBFF /* 0x1bb */ 21120 .long .L_ALT_OP_UNUSED_BCFF /* 0x1bc */ 21121 .long .L_ALT_OP_UNUSED_BDFF /* 0x1bd */ 21122 .long .L_ALT_OP_UNUSED_BEFF /* 0x1be */ 21123 .long .L_ALT_OP_UNUSED_BFFF /* 0x1bf */ 21124 .long .L_ALT_OP_UNUSED_C0FF /* 0x1c0 */ 21125 .long .L_ALT_OP_UNUSED_C1FF /* 0x1c1 */ 21126 .long .L_ALT_OP_UNUSED_C2FF /* 0x1c2 */ 21127 .long .L_ALT_OP_UNUSED_C3FF /* 0x1c3 */ 21128 .long .L_ALT_OP_UNUSED_C4FF /* 0x1c4 */ 21129 .long .L_ALT_OP_UNUSED_C5FF /* 0x1c5 */ 21130 .long .L_ALT_OP_UNUSED_C6FF /* 0x1c6 */ 21131 .long .L_ALT_OP_UNUSED_C7FF /* 0x1c7 */ 21132 .long .L_ALT_OP_UNUSED_C8FF /* 0x1c8 */ 21133 .long .L_ALT_OP_UNUSED_C9FF /* 0x1c9 */ 21134 .long .L_ALT_OP_UNUSED_CAFF /* 0x1ca */ 21135 .long .L_ALT_OP_UNUSED_CBFF /* 0x1cb */ 21136 .long .L_ALT_OP_UNUSED_CCFF /* 0x1cc */ 21137 .long .L_ALT_OP_UNUSED_CDFF /* 0x1cd */ 21138 .long .L_ALT_OP_UNUSED_CEFF /* 0x1ce */ 21139 .long .L_ALT_OP_UNUSED_CFFF /* 0x1cf */ 21140 .long .L_ALT_OP_UNUSED_D0FF /* 0x1d0 */ 21141 .long .L_ALT_OP_UNUSED_D1FF /* 0x1d1 */ 21142 .long .L_ALT_OP_UNUSED_D2FF /* 0x1d2 */ 21143 .long .L_ALT_OP_UNUSED_D3FF /* 0x1d3 */ 21144 .long .L_ALT_OP_UNUSED_D4FF /* 0x1d4 */ 21145 .long .L_ALT_OP_UNUSED_D5FF /* 0x1d5 */ 21146 .long .L_ALT_OP_UNUSED_D6FF /* 0x1d6 */ 21147 .long .L_ALT_OP_UNUSED_D7FF /* 0x1d7 */ 21148 .long .L_ALT_OP_UNUSED_D8FF /* 0x1d8 */ 21149 .long .L_ALT_OP_UNUSED_D9FF /* 0x1d9 */ 21150 .long .L_ALT_OP_UNUSED_DAFF /* 0x1da */ 21151 .long .L_ALT_OP_UNUSED_DBFF /* 0x1db */ 21152 .long .L_ALT_OP_UNUSED_DCFF /* 0x1dc */ 21153 .long .L_ALT_OP_UNUSED_DDFF /* 0x1dd */ 21154 .long .L_ALT_OP_UNUSED_DEFF /* 0x1de */ 21155 .long .L_ALT_OP_UNUSED_DFFF /* 0x1df */ 21156 .long .L_ALT_OP_UNUSED_E0FF /* 0x1e0 */ 21157 .long .L_ALT_OP_UNUSED_E1FF /* 0x1e1 */ 21158 .long .L_ALT_OP_UNUSED_E2FF /* 0x1e2 */ 21159 .long .L_ALT_OP_UNUSED_E3FF /* 0x1e3 */ 21160 .long .L_ALT_OP_UNUSED_E4FF /* 0x1e4 */ 21161 .long .L_ALT_OP_UNUSED_E5FF /* 0x1e5 */ 21162 .long .L_ALT_OP_UNUSED_E6FF /* 0x1e6 */ 21163 .long .L_ALT_OP_UNUSED_E7FF /* 0x1e7 */ 21164 .long .L_ALT_OP_UNUSED_E8FF /* 0x1e8 */ 21165 .long .L_ALT_OP_UNUSED_E9FF /* 0x1e9 */ 21166 .long .L_ALT_OP_UNUSED_EAFF /* 0x1ea */ 21167 .long .L_ALT_OP_UNUSED_EBFF /* 0x1eb */ 21168 .long .L_ALT_OP_UNUSED_ECFF /* 0x1ec */ 21169 .long .L_ALT_OP_UNUSED_EDFF /* 0x1ed */ 21170 .long .L_ALT_OP_UNUSED_EEFF /* 0x1ee */ 21171 .long .L_ALT_OP_UNUSED_EFFF /* 0x1ef */ 21172 .long .L_ALT_OP_UNUSED_F0FF /* 0x1f0 */ 21173 .long .L_ALT_OP_UNUSED_F1FF /* 0x1f1 */ 21174 .long .L_ALT_OP_UNUSED_F2FF /* 0x1f2 */ 21175 .long .L_ALT_OP_UNUSED_F3FF /* 0x1f3 */ 21176 .long .L_ALT_OP_UNUSED_F4FF /* 0x1f4 */ 21177 .long .L_ALT_OP_UNUSED_F5FF /* 0x1f5 */ 21178 .long .L_ALT_OP_UNUSED_F6FF /* 0x1f6 */ 21179 .long .L_ALT_OP_UNUSED_F7FF /* 0x1f7 */ 21180 .long .L_ALT_OP_UNUSED_F8FF /* 0x1f8 */ 21181 .long .L_ALT_OP_UNUSED_F9FF /* 0x1f9 */ 21182 .long .L_ALT_OP_UNUSED_FAFF /* 0x1fa */ 21183 .long .L_ALT_OP_UNUSED_FBFF /* 0x1fb */ 21184 .long .L_ALT_OP_UNUSED_FCFF /* 0x1fc */ 21185 .long .L_ALT_OP_UNUSED_FDFF /* 0x1fd */ 21186 .long .L_ALT_OP_UNUSED_FEFF /* 0x1fe */ 21187 .long .L_ALT_OP_THROW_VERIFICATION_ERROR_JUMBO /* 0x1ff */ 21188/* File: x86/entry.S */ 21189/* 21190 * Copyright (C) 2008 The Android Open Source Project 21191 * 21192 * Licensed under the Apache License, Version 2.0 (the "License"); 21193 * you may not use this file except in compliance with the License. 21194 * You may obtain a copy of the License at 21195 * 21196 * http://www.apache.org/licenses/LICENSE-2.0 21197 * 21198 * Unless required by applicable law or agreed to in writing, software 21199 * distributed under the License is distributed on an "AS IS" BASIS, 21200 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 21201 * See the License for the specific language governing permissions and 21202 * limitations under the License. 21203 */ 21204 21205 21206 .text 21207 .global dvmMterpStdRun 21208 .type dvmMterpStdRun, %function 21209/* 21210 * bool dvmMterpStdRun(Thread* self) 21211 * 21212 * Interpreter entry point. Returns changeInterp. 21213 * 21214 */ 21215dvmMterpStdRun: 21216 movl 4(%esp), %ecx # get incoming rSELF 21217 push %ebp # save caller base pointer 21218 push %ecx # save rSELF at (%ebp) 21219 movl %esp, %ebp # set our %ebp 21220/* 21221 * At this point we've allocated two slots on the stack 21222 * via push and stack is 8-byte aligned. Allocate space 21223 * for 8 spill slots, 3 local slots, 5 arg slots + 2 slots for 21224 * padding to bring us to 16-byte alignment 21225 */ 21226 subl $(FRAME_SIZE-8), %esp 21227 21228/* Spill callee save regs */ 21229 movl %edi,EDI_SPILL(%ebp) 21230 movl %esi,ESI_SPILL(%ebp) 21231 movl %ebx,EBX_SPILL(%ebp) 21232 21233/* Set up "named" registers */ 21234 movl offThread_pc(%ecx),rPC 21235 movl offThread_fp(%ecx),rFP 21236 movl offThread_curHandlerTable(%ecx),rIBASE 21237 21238/* Remember %esp for future "longjmp" */ 21239 movl %esp,offThread_bailPtr(%ecx) 21240 21241/* How to start? */ 21242 movb offThread_entryPoint(%ecx),%al 21243 21244/* Normal start? */ 21245 cmpb $kInterpEntryInstr,%al 21246 jne .Lnot_instr 21247 21248 /* Normal case: start executing the instruction at rPC */ 21249 FETCH_INST 21250 GOTO_NEXT 21251 21252.Lnot_instr: 21253 /* Reset to normal case */ 21254 movb $kInterpEntryInstr,offThread_entryPoint(%ecx) 21255 cmpb $kInterpEntryReturn,%al 21256 je common_returnFromMethod 21257 cmpb $kInterpEntryThrow,%al 21258 je common_exceptionThrown 21259 movzx %al,%eax 21260 movl %eax,OUT_ARG1(%esp) 21261 movl $.LstrBadEntryPoint,OUT_ARG0(%esp) 21262 call printf 21263 call dvmAbort 21264 /* Not reached */ 21265 21266 21267 .global dvmMterpStdBail 21268 .type dvmMterpStdBail, %function 21269/* 21270 * void dvmMterpStdBail(Thread* self, bool changeInterp) 21271 * 21272 * Restore the stack pointer and PC from the save point established on entry. 21273 * This is essentially the same as a longjmp, but should be cheaper. The 21274 * last instruction causes us to return to whoever called dvmMterpStdRun. 21275 * 21276 * We're not going to build a standard frame here, so the arg accesses will 21277 * look a little strange. 21278 * 21279 * On entry: 21280 * esp+4 (arg0) Thread* self 21281 * esp+8 (arg1) bool changeInterp 21282 */ 21283dvmMterpStdBail: 21284 movl 4(%esp),%ecx # grab self 21285 movl 8(%esp),%eax # changeInterp to return reg 21286 movl offThread_bailPtr(%ecx),%esp # Restore "setjmp" esp 21287 movl %esp,%ebp 21288 addl $(FRAME_SIZE-8), %ebp # Restore %ebp at point of setjmp 21289 movl EDI_SPILL(%ebp),%edi 21290 movl ESI_SPILL(%ebp),%esi 21291 movl EBX_SPILL(%ebp),%ebx 21292 movl PREV_FP(%ebp),%ebp # restore caller's ebp 21293 addl $FRAME_SIZE,%esp # strip frame 21294 ret # return to dvmMterpStdRun's caller 21295 21296 21297/* 21298 * Strings 21299 */ 21300 .section .rodata 21301.LstrBadEntryPoint: 21302 .asciz "Bad entry point %d\n" 21303 21304 21305/* File: x86/footer.S */ 21306/* 21307 * Copyright (C) 2008 The Android Open Source Project 21308 * 21309 * Licensed under the Apache License, Version 2.0 (the "License"); 21310 * you may not use this file except in compliance with the License. 21311 * You may obtain a copy of the License at 21312 * 21313 * http://www.apache.org/licenses/LICENSE-2.0 21314 * 21315 * Unless required by applicable law or agreed to in writing, software 21316 * distributed under the License is distributed on an "AS IS" BASIS, 21317 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 21318 * See the License for the specific language governing permissions and 21319 * limitations under the License. 21320 */ 21321/* 21322 * Common subroutines and data. 21323 */ 21324 21325#if defined(WITH_JIT) 21326/* 21327 * JIT-related re-entries into the interpreter. In general, if the 21328 * exit from a translation can at some point be chained, the entry 21329 * here requires that control arrived via a call, and that the "rp" 21330 * on TOS is actually a pointer to a 32-bit cell containing the Dalvik PC 21331 * of the next insn to handle. If no chaining will happen, the entry 21332 * should be reached via a direct jump and rPC set beforehand. 21333 */ 21334 21335 .global dvmJitToInterpPunt 21336/* 21337 * The compiler will generate a jump to this entry point when it is 21338 * having difficulty translating a Dalvik instruction. We must skip 21339 * the code cache lookup & prevent chaining to avoid bouncing between 21340 * the interpreter and code cache. rPC must be set on entry. 21341 */ 21342dvmJitToInterpPunt: 21343#if defined(WITH_JIT_TUNING) 21344 movl rPC, OUT_ARG0(%esp) 21345 call dvmBumpPunt 21346#endif 21347 movl rSELF, %ecx 21348 movl offThread_curHandlerTable(%ecx),rIBASE 21349 FETCH_INST_R %ecx 21350 GOTO_NEXT_R %ecx 21351 21352 .global dvmJitToInterpSingleStep 21353/* 21354 * Return to the interpreter to handle a single instruction. 21355 * Should be reached via a call. 21356 * On entry: 21357 * 0(%esp) <= native return address within trace 21358 * rPC <= Dalvik PC of this instruction 21359 * OUT_ARG0+4(%esp) <= Dalvik PC of next instruction 21360 */ 21361dvmJitToInterpSingleStep: 21362 pop %eax 21363 movl rSELF, %ecx 21364 movl OUT_ARG0(%esp), %edx 21365 movl %eax,offThread_jitResumeNPC(%ecx) 21366 movl %edx,offThread_jitResumeDPC(%ecx) 21367 movl $kInterpEntryInstr,offThread_entryPoint(%ecx) 21368 movl $1,rINST # changeInterp <= true 21369 jmp common_gotoBail 21370 21371 .global dvmJitToInterpNoChainNoProfile 21372/* 21373 * Return from the translation cache to the interpreter to do method 21374 * invocation. Check if the translation exists for the callee, but don't 21375 * chain to it. rPC must be set on entry. 21376 */ 21377dvmJitToInterpNoChainNoProfile: 21378#if defined(WITH_JIT_TUNING) 21379 call dvmBumpNoChain 21380#endif 21381 movl rPC,OUT_ARG0(%esp) 21382 call dvmJitGetTraceAddr # is there a translation? 21383 movl rSELF,%ecx # ecx <- self 21384 movl %eax,offThread_inJitCodeCache(%ecx) # set inJitCodeCache flag 21385 cmpl $0, %eax 21386 jz 1f 21387 call *%eax # exec translation if we've got one 21388 # won't return 213891: 21390 movl rSELF, %ecx 21391 movl offThread_curHandlerTable(%ecx),rIBASE 21392 FETCH_INST_R %ecx 21393 GOTO_NEXT_R %ecx 21394 21395/* 21396 * Return from the translation cache and immediately request a 21397 * translation fro the exit target, but don't attempt to chain. 21398 * rPC set on entry. 21399 */ 21400 .global dvmJitToInterpTraceSelectNoChain 21401dvmJitToInterpTraceSelectNoChain: 21402#if defined(WITH_JIT_TUNING) 21403 call dvmBumpNoChain 21404#endif 21405 movl rPC,OUT_ARG0(%esp) 21406 call dvmJitGetTraceAddr # is there a translation? 21407 movl rSELF,%ecx 21408 cmpl $0,%eax 21409 movl %eax,offThread_inJitCodeCache(%ecx) # set inJitCodeCache flag 21410 jz 1f 21411 call *%eax # jump to tranlation 21412 # won't return 21413 21414/* No Translation - request one */ 214151: 21416 GET_JIT_PROF_TABLE %ecx %eax 21417 cmpl $0, %eax # JIT enabled? 21418 jnz 2f # Request one if so 21419 movl rSELF, %ecx 21420 movl offThread_curHandlerTable(%ecx),rIBASE 21421 FETCH_INST_R %ecx # Continue interpreting if not 21422 GOTO_NEXT_R %ecx 214232: 21424 movl $kJitTSelectRequestHot,rINST # ask for trace select 21425 jmp common_selectTrace 21426 21427/* 21428 * Return from the translation cache and immediately request a 21429 * translation for the exit target. Reached via a call, and 21430 * (TOS)->rPC. 21431 */ 21432 .global dvmJitToInterpTraceSelect 21433dvmJitToInterpTraceSelect: 21434 pop rINST # save chain cell address in callee save reg 21435 movl (rINST),rPC 21436 movl rPC,OUT_ARG0(%esp) 21437 call dvmJitGetTraceAddr # is there a translation? 21438 cmpl $0,%eax 21439 jz 1b # no - ask for one 21440 movl %eax,OUT_ARG0(%esp) 21441# FIXME - need to adjust rINST to beginning of sequence 21442 movl rINST,OUT_ARG1(%esp) 21443 call dvmJitChain # Attempt dvmJitChain(codeAddr,chainAddr) 21444 cmpl $0,%eax # Success? 21445 jz toInterpreter # didn't chain - interpret 21446 call *%eax 21447 # won't return 21448 21449/* 21450 * Placeholder entries for x86 JIT 21451 */ 21452 .global dvmJitToInterpBackwardBranch 21453dvmJitToInterpBackwardBranch: 21454 .global dvmJitToInterpNormal 21455dvmJitToInterpNormal: 21456 .global dvmJitToInterpNoChain 21457dvmJitToInterpNoChain: 21458toInterpreter: 21459 jmp common_abort 21460#endif 21461 21462/* 21463 * Common code when a backwards branch is taken 21464 * 21465 * On entry: 21466 * ebx (a.k.a. rINST) -> PC adjustment in 16-bit words 21467 */ 21468common_backwardBranch: 21469 movl rSELF,%ecx 21470 call common_periodicChecks # rPC and ecx/rSELF preserved 21471#if defined(WITH_JIT) 21472 GET_JIT_PROF_TABLE %ecx rIBASE 21473 ADVANCE_PC_INDEXED rINST 21474 cmpl $0,rIBASE 21475 movl offThread_curHandlerTable(%ecx),rIBASE 21476 FETCH_INST 21477 jz 1f # Profiling off - continue 21478 .global updateProfile 21479updateProfile: 21480common_updateProfile: 21481 # quick & dirty hash 21482 movl rPC, %eax 21483 shrl $12, %eax 21484 xorl rPC, %eax 21485 andl $((1<<JIT_PROF_SIZE_LOG_2)-1),%eax 21486 decb (%edx,%eax) 21487 jz 2f 214881: 21489 GOTO_NEXT 214902: 21491/* 21492 * Here, we switch to the debug interpreter to request 21493 * trace selection. First, though, check to see if there 21494 * is already a native translation in place (and, if so, 21495 * jump to it now. 21496 */ 21497 GET_JIT_THRESHOLD %ecx rINST # leaves rSELF in %ecx 21498 EXPORT_PC 21499 movb rINSTbl,(%edx,%eax) # reset counter 21500 movl %ecx,rINST # preserve rSELF 21501 movl rPC,OUT_ARG0(%esp) 21502 call dvmJitGetTraceAddr # already have one? 21503 movl %eax,offThread_inJitCodeCache(rINST) # set the inJitCodeCache flag 21504 cmpl $0,%eax 21505 jz 1f 21506 call *%eax # FIXME: decide call vs/ jmp!. No return either way 215071: 21508 movl $kJitTSelectRequest,%eax 21509 # On entry, eax<- jitState, rPC valid 21510common_selectTrace: 21511 21512 movl rSELF,%ecx 21513 movl %eax,offThread_jitState(%ecx) 21514 movl $kInterpEntryInstr,offThread_entryPoint(%ecx) 21515 movl $1,rINST 21516 jmp common_gotoBail 21517#else 21518 movl offThread_curHandlerTable(%ecx),rIBASE 21519 ADVANCE_PC_INDEXED rINST 21520 FETCH_INST 21521 GOTO_NEXT 21522#endif 21523 21524 21525 21526/* 21527 * Common code for jumbo method invocation. 21528 * 21529 * On entry: 21530 * eax = Method* methodToCall 21531 * rINSTw trashed, must reload 21532 * rIBASE trashed, must reload before resuming interpreter 21533 */ 21534 21535common_invokeMethodJumbo: 21536.LinvokeNewJumbo: 21537 21538 /* 21539 * prepare to copy args to "outs" area of current frame 21540 */ 21541 movzwl 6(rPC),rINST # rINST<- BBBB 21542 movzwl 8(rPC), %ecx # %ecx<- CCCC 21543 ADVANCE_PC 2 # adjust pc to make return similar 21544 SAVEAREA_FROM_FP %edx # %edx<- &StackSaveArea 21545 test rINST, rINST 21546 movl rINST, LOCAL0_OFFSET(%ebp) # LOCAL0_OFFSET(%ebp)<- BBBB 21547 jz .LinvokeArgsDone # no args; jump to args done 21548 jmp .LinvokeRangeArgs # handle args like invoke range 21549 21550/* 21551 * Common code for method invocation with range. 21552 * 21553 * On entry: 21554 * eax = Method* methodToCall 21555 * rINSTw trashed, must reload 21556 * rIBASE trashed, must reload before resuming interpreter 21557 */ 21558 21559common_invokeMethodRange: 21560.LinvokeNewRange: 21561 21562 /* 21563 * prepare to copy args to "outs" area of current frame 21564 */ 21565 21566 movzbl 1(rPC),rINST # rINST<- AA 21567 movzwl 4(rPC), %ecx # %ecx<- CCCC 21568 SAVEAREA_FROM_FP %edx # %edx<- &StackSaveArea 21569 test rINST, rINST 21570 movl rINST, LOCAL0_OFFSET(%ebp) # LOCAL0_OFFSET(%ebp)<- AA 21571 jz .LinvokeArgsDone # no args; jump to args done 21572 21573 21574 /* 21575 * %eax=methodToCall, %ecx=CCCC, LOCAL0_OFFSET(%ebp)=count, %edx=&outs (&stackSaveArea) 21576 * (very few methods have > 10 args; could unroll for common cases) 21577 */ 21578 21579.LinvokeRangeArgs: 21580 movl %ebx, LOCAL1_OFFSET(%ebp) # LOCAL1_OFFSET(%ebp)<- save %ebx 21581 lea (rFP, %ecx, 4), %ecx # %ecx<- &vCCCC 21582 shll $2, LOCAL0_OFFSET(%ebp) # LOCAL0_OFFSET(%ebp)<- offset 21583 subl LOCAL0_OFFSET(%ebp), %edx # %edx<- update &outs 21584 shrl $2, LOCAL0_OFFSET(%ebp) # LOCAL0_OFFSET(%ebp)<- offset 215851: 21586 movl (%ecx), %ebx # %ebx<- vCCCC 21587 lea 4(%ecx), %ecx # %ecx<- &vCCCC++ 21588 subl $1, LOCAL0_OFFSET(%ebp) # LOCAL0_OFFSET<- LOCAL0_OFFSET-- 21589 movl %ebx, (%edx) # *outs<- vCCCC 21590 lea 4(%edx), %edx # outs++ 21591 jne 1b # loop if count (LOCAL0_OFFSET(%ebp)) not zero 21592 movl LOCAL1_OFFSET(%ebp), %ebx # %ebx<- restore %ebx 21593 jmp .LinvokeArgsDone # continue 21594 21595 /* 21596 * %eax is "Method* methodToCall", the method we're trying to call 21597 * prepare to copy args to "outs" area of current frame 21598 * rIBASE trashed, must reload before resuming interpreter 21599 */ 21600 21601common_invokeMethodNoRange: 21602.LinvokeNewNoRange: 21603 movzbl 1(rPC),rINST # rINST<- BA 21604 movl rINST, LOCAL0_OFFSET(%ebp) # LOCAL0_OFFSET(%ebp)<- BA 21605 shrl $4, LOCAL0_OFFSET(%ebp) # LOCAL0_OFFSET(%ebp)<- B 21606 je .LinvokeArgsDone # no args; jump to args done 21607 movzwl 4(rPC), %ecx # %ecx<- GFED 21608 SAVEAREA_FROM_FP %edx # %edx<- &StackSaveArea 21609 21610 /* 21611 * %eax=methodToCall, %ecx=GFED, LOCAL0_OFFSET(%ebp)=count, %edx=outs 21612 */ 21613 21614.LinvokeNonRange: 21615 cmp $2, LOCAL0_OFFSET(%ebp) # compare LOCAL0_OFFSET(%ebp) to 2 21616 movl %ecx, LOCAL1_OFFSET(%ebp) # LOCAL1_OFFSET(%ebp)<- GFED 21617 jl 1f # handle 1 arg 21618 je 2f # handle 2 args 21619 cmp $4, LOCAL0_OFFSET(%ebp) # compare LOCAL0_OFFSET(%ebp) to 4 21620 jl 3f # handle 3 args 21621 je 4f # handle 4 args 216225: 21623 andl $15, rINST # rINSTw<- A 21624 lea -4(%edx), %edx # %edx<- update &outs; &outs-- 21625 movl (rFP, rINST, 4), %ecx # %ecx<- vA 21626 movl %ecx, (%edx) # *outs<- vA 21627 movl LOCAL1_OFFSET(%ebp), %ecx # %ecx<- GFED 216284: 21629 shr $12, %ecx # %ecx<- G 21630 lea -4(%edx), %edx # %edx<- update &outs; &outs-- 21631 movl (rFP, %ecx, 4), %ecx # %ecx<- vG 21632 movl %ecx, (%edx) # *outs<- vG 21633 movl LOCAL1_OFFSET(%ebp), %ecx # %ecx<- GFED 216343: 21635 and $0x0f00, %ecx # %ecx<- 0F00 21636 shr $8, %ecx # %ecx<- F 21637 lea -4(%edx), %edx # %edx<- update &outs; &outs-- 21638 movl (rFP, %ecx, 4), %ecx # %ecx<- vF 21639 movl %ecx, (%edx) # *outs<- vF 21640 movl LOCAL1_OFFSET(%ebp), %ecx # %ecx<- GFED 216412: 21642 and $0x00f0, %ecx # %ecx<- 00E0 21643 shr $4, %ecx # %ecx<- E 21644 lea -4(%edx), %edx # %edx<- update &outs; &outs-- 21645 movl (rFP, %ecx, 4), %ecx # %ecx<- vE 21646 movl %ecx, (%edx) # *outs<- vE 21647 movl LOCAL1_OFFSET(%ebp), %ecx # %ecx<- GFED 216481: 21649 and $0x000f, %ecx # %ecx<- 000D 21650 movl (rFP, %ecx, 4), %ecx # %ecx<- vD 21651 movl %ecx, -4(%edx) # *--outs<- vD 216520: 21653 21654 /* 21655 * %eax is "Method* methodToCall", the method we're trying to call 21656 * find space for the new stack frame, check for overflow 21657 */ 21658 21659.LinvokeArgsDone: 21660 movzwl offMethod_registersSize(%eax), %edx # %edx<- methodToCall->regsSize 21661 movzwl offMethod_outsSize(%eax), %ecx # %ecx<- methodToCall->outsSize 21662 movl %eax, LOCAL0_OFFSET(%ebp) # LOCAL0_OFFSET<- methodToCall 21663 shl $2, %edx # %edx<- update offset 21664 SAVEAREA_FROM_FP %eax # %eax<- &StackSaveArea 21665 subl %edx, %eax # %eax<- newFP; (old savearea - regsSize) 21666 movl rSELF,%edx # %edx<- pthread 21667 movl %eax, LOCAL1_OFFSET(%ebp) # LOCAL1_OFFSET(%ebp)<- &outs 21668 subl $sizeofStackSaveArea, %eax # %eax<- newSaveArea (stack save area using newFP) 21669 movl offThread_interpStackEnd(%edx), %edx # %edx<- self->interpStackEnd 21670 movl %edx, LOCAL2_OFFSET(%ebp) # LOCAL2_OFFSET<- self->interpStackEnd 21671 shl $2, %ecx # %ecx<- update offset for outsSize 21672 movl %eax, %edx # %edx<- newSaveArea 21673 sub %ecx, %eax # %eax<- bottom; (newSaveArea - outsSize) 21674 cmp LOCAL2_OFFSET(%ebp), %eax # compare interpStackEnd and bottom 21675 movl LOCAL0_OFFSET(%ebp), %eax # %eax<- restore methodToCall 21676 jl .LstackOverflow # handle frame overflow 21677 21678 /* 21679 * set up newSaveArea 21680 */ 21681 21682#ifdef EASY_GDB 21683 SAVEAREA_FROM_FP %ecx # %ecx<- &StackSaveArea 21684 movl %ecx, offStackSaveArea_prevSave(%edx) # newSaveArea->prevSave<- &outs 21685#endif 21686 movl rFP, offStackSaveArea_prevFrame(%edx) # newSaveArea->prevFrame<- rFP 21687 movl rPC, offStackSaveArea_savedPc(%edx) # newSaveArea->savedPc<- rPC 21688 testl $ACC_NATIVE, offMethod_accessFlags(%eax) # check for native call 21689 movl %eax, offStackSaveArea_method(%edx) # newSaveArea->method<- method to call 21690 jne .LinvokeNative # handle native call 21691 21692 /* 21693 * Update "self" values for the new method 21694 * %eax=methodToCall, LOCAL1_OFFSET(%ebp)=newFp 21695 */ 21696 21697 movl offMethod_clazz(%eax), %edx # %edx<- method->clazz 21698 movl rSELF,%ecx # %ecx<- pthread 21699 movl offClassObject_pDvmDex(%edx), %edx # %edx<- method->clazz->pDvmDex 21700 movl %eax, offThread_method(%ecx) # self->method<- methodToCall 21701 movl %edx, offThread_methodClassDex(%ecx) # self->methodClassDex<- method->clazz->pDvmDex 21702 movl offMethod_insns(%eax), rPC # rPC<- methodToCall->insns 21703 movl LOCAL1_OFFSET(%ebp), rFP # rFP<- newFP 21704 movl rFP, offThread_curFrame(%ecx) # self->curFrame<- newFP 21705 movl offThread_curHandlerTable(%ecx),rIBASE 21706 FETCH_INST 21707 GOTO_NEXT # jump to methodToCall->insns 21708 21709 /* 21710 * Prep for the native call 21711 * %eax=methodToCall, LOCAL1_OFFSET(%ebp)=newFP, %edx=newSaveArea 21712 */ 21713 21714.LinvokeNative: 21715 movl rSELF,%ecx # %ecx<- pthread 21716 movl %eax, OUT_ARG1(%esp) # push parameter methodToCall 21717 movl offThread_jniLocal_topCookie(%ecx), %eax # %eax<- self->localRef->... 21718 movl %eax, offStackSaveArea_localRefCookie(%edx) # newSaveArea->localRefCookie<- top 21719 movl %edx, OUT_ARG4(%esp) # save newSaveArea 21720 movl LOCAL1_OFFSET(%ebp), %edx # %edx<- newFP 21721 movl %edx, offThread_curFrame(%ecx) # self->curFrame<- newFP 21722 movl %ecx, OUT_ARG3(%esp) # save self 21723 movl %ecx, OUT_ARG2(%esp) # push parameter self 21724 movl rSELF,%ecx # %ecx<- pthread 21725 movl OUT_ARG1(%esp), %eax # %eax<- methodToCall 21726 lea offThread_retval(%ecx), %ecx # %ecx<- &retval 21727 movl %ecx, OUT_ARG0(%esp) # push parameter pthread 21728 push %edx # push parameter newFP 21729 21730 call *offMethod_nativeFunc(%eax) # call methodToCall->nativeFunc 21731 lea 4(%esp), %esp 21732 movl OUT_ARG4(%esp), %ecx # %ecx<- newSaveArea 21733 movl OUT_ARG3(%esp), %eax # %eax<- self 21734 movl offStackSaveArea_localRefCookie(%ecx), %edx # %edx<- old top 21735 cmp $0, offThread_exception(%eax) # check for exception 21736 movl rFP, offThread_curFrame(%eax) # self->curFrame<- rFP 21737 movl %edx, offThread_jniLocal_topCookie(%eax) # new top <- old top 21738 jne common_exceptionThrown # handle exception 21739 movl offThread_curHandlerTable(%eax),rIBASE 21740 FETCH_INST_OPCODE 3 %ecx 21741 ADVANCE_PC 3 21742 GOTO_NEXT_R %ecx # jump to next instruction 21743 21744.LstackOverflow: # eax=methodToCall 21745 movl %eax, OUT_ARG1(%esp) # push parameter methodToCall 21746 movl rSELF,%eax # %eax<- self 21747 movl %eax, OUT_ARG0(%esp) # push parameter self 21748 call dvmHandleStackOverflow # call: (Thread* self, Method* meth) 21749 jmp common_exceptionThrown # handle exception 21750 21751 21752/* 21753 * Do we need the thread to be suspended or have debugger/profiling activity? 21754 * 21755 * On entry: 21756 * ebx -> PC adjustment in 16-bit words (must be preserved) 21757 * ecx -> SELF pointer 21758 * reentry type, e.g. kInterpEntryInstr stored in rSELF->entryPoint 21759 * 21760 * Note: A call will normally kill %eax and %ecx. To 21761 * streamline the normal case, this routine will preserve 21762 * %ecx in addition to the normal caller save regs. The save/restore 21763 * is a bit ugly, but will happen in the relatively uncommon path. 21764 * TODO: Basic-block style Jit will need a hook here as well. Fold it into 21765 * the suspendCount check so we can get both in 1 shot. 21766 * TUNING: Improve scheduling here & do initial single test for all. 21767 */ 21768common_periodicChecks: 21769 cmpl $0,offThread_suspendCount(%ecx) # non-zero suspendCount? 21770 jne 1f 21771 217726: 21773 movl offThread_pInterpBreak(%ecx),%eax # eax <- &interpBreak 21774 cmpl $0,(%eax) # something interesting happening? 21775 jne 3f # yes - switch interpreters 21776 ret 21777 21778 /* Check for suspend */ 217791: 21780 /* At this point, the return pointer to the caller of 21781 * common_periodicChecks is on the top of stack. We need to preserve 21782 * SELF(ecx). 21783 * The outgoing profile is: 21784 * bool dvmCheckSuspendPending(Thread* self) 21785 * Because we reached here via a call, go ahead and build a new frame. 21786 */ 21787 EXPORT_PC # need for precise GC 21788 movl %ecx,%eax # eax<- self 21789 push %ebp 21790 movl %esp,%ebp 21791 subl $24,%esp 21792 movl %eax,OUT_ARG0(%esp) 21793 call dvmCheckSuspendPending 21794 addl $24,%esp 21795 pop %ebp 21796 movl rSELF,%ecx 21797 21798 /* 21799 * Need to check to see if debugger or profiler flags got set 21800 * while we were suspended. 21801 */ 21802 jmp 6b 21803 21804 /* Switch interpreters */ 21805 /* Note: %ebx contains the 16-bit word offset to be applied to rPC to 21806 * "complete" the interpretation of backwards branches. In effect, we 21807 * are completing the interpretation of the branch instruction here, 21808 * and the new interpreter will resume interpretation at the branch 21809 * target. However, a switch request recognized during the handling 21810 * of a return from method instruction results in an immediate abort, 21811 * and the new interpreter will resume by re-interpreting the return 21812 * instruction. 21813 */ 218143: 21815 leal (rPC,%ebx,2),rPC # adjust pc to show target 21816 movl rSELF,%ecx # bail expect SELF already loaded 21817 movl $1,rINST # set changeInterp to true 21818 jmp common_gotoBail 21819 21820 21821/* 21822 * Common code for handling a return instruction 21823 */ 21824common_returnFromMethod: 21825 movl rSELF,%ecx 21826 /* Set entry mode in case we bail */ 21827 movb $kInterpEntryReturn,offThread_entryPoint(%ecx) 21828 xorl rINST,rINST # zero offset in case we switch interps 21829 call common_periodicChecks # Note: expects %ecx to be preserved 21830 21831 SAVEAREA_FROM_FP %eax # eax<- saveArea (old) 21832 movl offStackSaveArea_prevFrame(%eax),rFP # rFP<- prevFrame 21833 movl (offStackSaveArea_method-sizeofStackSaveArea)(rFP),rINST 21834 cmpl $0,rINST # break? 21835 je common_gotoBail # break frame, bail out completely 21836 21837 movl offStackSaveArea_savedPc(%eax),rPC # pc<- saveArea->savedPC 21838 movl rINST,offThread_method(%ecx) # self->method = newSave->meethod 21839 movl rFP,offThread_curFrame(%ecx) # self->curFrame = fp 21840 movl offMethod_clazz(rINST),%eax # eax<- method->clazz 21841 movl offThread_curHandlerTable(%ecx),rIBASE 21842 movl offClassObject_pDvmDex(%eax),rINST # rINST<- method->clazz->pDvmDex 21843 FETCH_INST_OPCODE 3 %eax 21844 movl rINST,offThread_methodClassDex(%ecx) 21845 ADVANCE_PC 3 21846 /* not bailing - restore entry mode to default */ 21847 movb $kInterpEntryInstr,offThread_entryPoint(%ecx) 21848 GOTO_NEXT_R %eax 21849 21850/* 21851 * Prepare to strip the current frame and "longjump" back to caller of 21852 * dvmMterpStdRun. 21853 * 21854 * on entry: 21855 * rINST holds changeInterp 21856 * ecx holds self pointer 21857 * 21858 * expected profile: dvmMterpStdBail(Thread *self, bool changeInterp) 21859 */ 21860common_gotoBail: 21861 movl rPC,offThread_pc(%ecx) # export state to self 21862 movl rFP,offThread_fp(%ecx) 21863 movl %ecx,OUT_ARG0(%esp) # self in arg0 21864 movl rINST,OUT_ARG1(%esp) # changeInterp in arg1 21865 call dvmMterpStdBail # bail out.... 21866 21867 21868/* 21869 * After returning from a "selfd" function, pull out the updated values 21870 * and start executing at the next instruction. 21871 */ 21872 common_resumeAfterGlueCall: 21873 movl rSELF, %eax 21874 movl offThread_pc(%eax),rPC 21875 movl offThread_fp(%eax),rFP 21876 movl offThread_curHandlerTable(%eax),rIBASE 21877 FETCH_INST 21878 GOTO_NEXT 21879 21880/* 21881 * Integer divide or mod by zero 21882 */ 21883common_errDivideByZero: 21884 EXPORT_PC 21885 movl $.LstrDivideByZero,%eax 21886 movl %eax,OUT_ARG0(%esp) 21887 call dvmThrowArithmeticException 21888 jmp common_exceptionThrown 21889 21890/* 21891 * Attempt to allocate an array with a negative size. 21892 * On entry, len in eax 21893 */ 21894common_errNegativeArraySize: 21895 EXPORT_PC 21896 movl %eax,OUT_ARG0(%esp) # arg0<- len 21897 call dvmThrowNegativeArraySizeException # (len) 21898 jmp common_exceptionThrown 21899 21900/* 21901 * Attempt to allocate an array with a negative size. 21902 * On entry, method name in eax 21903 */ 21904common_errNoSuchMethod: 21905 21906 EXPORT_PC 21907 movl %eax,OUT_ARG0(%esp) 21908 call dvmThrowNoSuchMethodError 21909 jmp common_exceptionThrown 21910 21911/* 21912 * Hit a null object when we weren't expecting one. Export the PC, throw a 21913 * NullPointerException and goto the exception processing code. 21914 */ 21915common_errNullObject: 21916 EXPORT_PC 21917 xorl %eax,%eax 21918 movl %eax,OUT_ARG0(%esp) 21919 call dvmThrowNullPointerException 21920 jmp common_exceptionThrown 21921 21922/* 21923 * Array index exceeds max. 21924 * On entry: 21925 * eax <- array object 21926 * ecx <- index 21927 */ 21928common_errArrayIndex: 21929 EXPORT_PC 21930 movl offArrayObject_length(%eax), %eax 21931 movl %ecx,OUT_ARG0(%esp) 21932 movl %eax,OUT_ARG1(%esp) 21933 call dvmThrowArrayIndexOutOfBoundsException # args (index, length) 21934 jmp common_exceptionThrown 21935 21936/* 21937 * Somebody has thrown an exception. Handle it. 21938 * 21939 * If the exception processing code returns to us (instead of falling 21940 * out of the interpreter), continue with whatever the next instruction 21941 * now happens to be. 21942 * 21943 * This does not return. 21944 */ 21945common_exceptionThrown: 21946 movl rSELF,%ecx 21947 movl rPC,offThread_pc(%ecx) 21948 movl rFP,offThread_fp(%ecx) 21949 movl %ecx,OUT_ARG0(%esp) 21950 call dvmMterp_exceptionThrown 21951 jmp common_resumeAfterGlueCall 21952 21953common_abort: 21954 movl $0xdeadf00d,%eax 21955 call *%eax 21956 21957 21958/* 21959 * Strings 21960 */ 21961 21962 .section .rodata 21963.LstrDivideByZero: 21964 .asciz "divide by zero" 21965.LstrFilledNewArrayNotImplA: 21966 .asciz "filled-new-array only implemented for 'int'" 21967 21968