InterpAsm-x86.S revision 30bc0d46ae730d78c42c39cfa56a59ba3025380b
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 49Stack must be 16-byte aligned to support SSE in native code. 50 51If we're not doing variable stack allocation (alloca), the frame pointer can be 52eliminated and all arg references adjusted to be esp relative. 53 54Mterp notes: 55 56Some key interpreter variables will be assigned to registers. Note that each 57will also have an associated spill location (mostly useful for those assigned 58to callee save registers). 59 60 nick reg purpose 61 rPC edi interpreted program counter, used for fetching instructions 62 rFP esi interpreted frame pointer, used for accessing locals and args 63 rINSTw bx first 16-bit code of current instruction 64 rINSTbl bl opcode portion of instruction word 65 rINSTbh bh high byte of inst word, usually contains src/tgt reg names 66 rIBASE edx base of instruction handler table 67 68Notes: 69 o High order 16 bits of ebx must be zero on entry to handler 70 o rPC, rFP, rINSTw/rINSTbl valid on handler entry and exit 71 o eax and ecx are scratch, rINSTw/ebx sometimes scratch 72 73*/ 74 75#define rSELF 8(%ebp) 76#define rPC %esi 77#define rFP %edi 78#define rINST %ebx 79#define rINSTw %bx 80#define rINSTbh %bh 81#define rINSTbl %bl 82#define rIBASE %edx 83 84 85/* Frame diagram while executing dvmMterpStdRun, high to low addresses */ 86#define IN_ARG0 ( 8) 87#define CALLER_RP ( 4) 88#define PREV_FP ( 0) 89/* Spill offsets relative to %ebp */ 90#define EDI_SPILL ( -4) 91#define ESI_SPILL ( -8) 92#define EBX_SPILL (-12) 93#define rPC_SPILL (-16) 94#define rFP_SPILL (-20) 95#define rINST_SPILL (-24) 96#define rIBASE_SPILL (-28) 97#define TMP_SPILL1 (-32) 98#define TMP_SPILL2 (-36) 99#define TMP_SPILL3 (-20) 100#define LOCAL0_OFFSET (-44) 101#define LOCAL1_OFFSET (-48) 102#define LOCAL2_OFFSET (-52) 103/* Out Arg offsets, relative to %esp */ 104#define OUT_ARG4 ( 16) 105#define OUT_ARG3 ( 12) 106#define OUT_ARG2 ( 8) 107#define OUT_ARG1 ( 4) 108#define OUT_ARG0 ( 0) /* <- dvmMterpStdRun esp */ 109#define FRAME_SIZE 76 110 111#define SPILL(reg) movl reg##,reg##_SPILL(%ebp) 112#define UNSPILL(reg) movl reg##_SPILL(%ebp),reg 113#define SPILL_TMP1(reg) movl reg,TMP_SPILL1(%ebp) 114#define UNSPILL_TMP1(reg) movl TMP_SPILL1(%ebp),reg 115#define SPILL_TMP2(reg) movl reg,TMP_SPILL2(%ebp) 116#define UNSPILL_TMP2(reg) movl TMP_SPILL2(%ebp),reg 117#define SPILL_TMP3(reg) movl reg,TMP_SPILL3(%ebp) 118#define UNSPILL_TMP3(reg) movl TMP_SPILL3(%ebp),reg 119 120#if defined(WITH_JIT) 121.macro GET_JIT_PROF_TABLE _self _reg 122 movl offThread_pJitProfTable(\_self),\_reg 123.endm 124.macro GET_JIT_THRESHOLD _self _reg 125 movl offThread_jitThreshold(\_self),\_reg 126.endm 127#endif 128 129/* save/restore the PC and/or FP from the self struct */ 130.macro SAVE_PC_FP_TO_SELF _reg 131 movl rSELF,\_reg 132 movl rPC,offThread_pc(\_reg) 133 movl rFP,offThread_curFrame(\_reg) 134.endm 135 136.macro LOAD_PC_FP_FROM_SELF 137 movl rSELF,rFP 138 movl offThread_pc(rFP),rPC 139 movl offThread_curFrame(rFP),rFP 140.endm 141 142/* The interpreter assumes a properly aligned stack on entry, and 143 * will preserve 16-byte alignment. 144 */ 145 146/* 147 * "export" the PC to the interpreted stack frame, f/b/o future exception 148 * objects. Must be done *before* something throws. 149 * 150 * In C this is "SAVEAREA_FROM_FP(fp)->xtra.currentPc = pc", i.e. 151 * fp - sizeof(StackSaveArea) + offsetof(SaveArea, xtra.currentPc) 152 * 153 * It's okay to do this more than once. 154 */ 155.macro EXPORT_PC 156 movl rPC, (-sizeofStackSaveArea + offStackSaveArea_currentPc)(rFP) 157.endm 158 159/* 160 * Given a frame pointer, find the stack save area. 161 * 162 * In C this is "((StackSaveArea*)(_fp) -1)". 163 */ 164.macro SAVEAREA_FROM_FP _reg 165 leal -sizeofStackSaveArea(rFP), \_reg 166.endm 167 168/* 169 * Fetch the next instruction from rPC into rINSTw. Does not advance rPC. 170 */ 171.macro FETCH_INST 172 movzwl (rPC),rINST 173.endm 174 175/* 176 * Fetch the opcode byte and zero-extend it into _reg. Must be used 177 * in conjunction with GOTO_NEXT_R 178 */ 179.macro FETCH_INST_R _reg 180 movzbl (rPC),\_reg 181.endm 182 183/* 184 * Fetch the opcode byte at _count words offset from rPC and zero-extend 185 * it into _reg. Must be used in conjunction with GOTO_NEXT_R 186 */ 187.macro FETCH_INST_OPCODE _count _reg 188 movzbl \_count*2(rPC),\_reg 189.endm 190 191/* 192 * Fetch the nth instruction word from rPC into rINSTw. Does not advance 193 * rPC, and _count is in words 194 */ 195.macro FETCH_INST_WORD _count 196 movzwl \_count*2(rPC),rINST 197.endm 198 199/* 200 * Fetch instruction word indexed (used for branching). 201 * Index is in instruction word units. 202 */ 203.macro FETCH_INST_INDEXED _reg 204 movzwl (rPC,\_reg,2),rINST 205.endm 206 207/* 208 * Advance rPC by instruction count 209 */ 210.macro ADVANCE_PC _count 211 leal 2*\_count(rPC),rPC 212.endm 213 214/* 215 * Advance rPC by branch offset in register 216 */ 217.macro ADVANCE_PC_INDEXED _reg 218 leal (rPC,\_reg,2),rPC 219.endm 220 221.macro GOTO_NEXT 222 movzx rINSTbl,%eax 223 movzbl rINSTbh,rINST 224 jmp *(rIBASE,%eax,4) 225.endm 226 227 /* 228 * Version of GOTO_NEXT that assumes _reg preloaded with opcode. 229 * Should be paired with FETCH_INST_R 230 */ 231.macro GOTO_NEXT_R _reg 232 movzbl 1(rPC),rINST 233 jmp *(rIBASE,\_reg,4) 234.endm 235 236 /* 237 * Jumbo version of GOTO_NEXT that assumes _reg preloaded with table 238 * offset of the jumbo instruction, which is the top half of the extended 239 * opcode + 0x100. Loads rINST with BBBB field, similar to GOTO_NEXT_R 240 */ 241.macro GOTO_NEXT_JUMBO_R _reg 242 movzwl 6(rPC),rINST 243 jmp *(rIBASE,\_reg,4) 244.endm 245 246/* 247 * Get/set the 32-bit value from a Dalvik register. 248 */ 249.macro GET_VREG_R _reg _vreg 250 movl (rFP,\_vreg,4),\_reg 251.endm 252 253.macro SET_VREG _reg _vreg 254 movl \_reg,(rFP,\_vreg,4) 255.endm 256 257.macro GET_VREG_WORD _reg _vreg _offset 258 movl 4*(\_offset)(rFP,\_vreg,4),\_reg 259.endm 260 261.macro SET_VREG_WORD _reg _vreg _offset 262 movl \_reg,4*(\_offset)(rFP,\_vreg,4) 263.endm 264 265#define sReg0 LOCAL0_OFFSET(%ebp) 266#define sReg1 LOCAL1_OFFSET(%ebp) 267#define sReg2 LOCAL2_OFFSET(%ebp) 268 269 /* 270 * Hard coded helper values. 271 */ 272 273.balign 16 274 275.LdoubNeg: 276 .quad 0x8000000000000000 277 278.L64bits: 279 .quad 0xFFFFFFFFFFFFFFFF 280 281.LshiftMask2: 282 .quad 0x0000000000000000 283.LshiftMask: 284 .quad 0x000000000000003F 285 286.Lvalue64: 287 .quad 0x0000000000000040 288 289.LvaluePosInfLong: 290 .quad 0x7FFFFFFFFFFFFFFF 291 292.LvalueNegInfLong: 293 .quad 0x8000000000000000 294 295.LvalueNanLong: 296 .quad 0x0000000000000000 297 298.LintMin: 299.long 0x80000000 300 301.LintMax: 302.long 0x7FFFFFFF 303 304 305/* 306 * This is a #include, not a %include, because we want the C pre-processor 307 * to expand the macros into assembler assignment statements. 308 */ 309#include "../common/asm-constants.h" 310 311#if defined(WITH_JIT) 312#include "../common/jit-config.h" 313#endif 314 315 316 .global dvmAsmInstructionStartCode 317 .type dvmAsmInstructionStartCode, %function 318dvmAsmInstructionStartCode = .L_OP_NOP 319 .text 320 321/* ------------------------------ */ 322.L_OP_NOP: /* 0x00 */ 323/* File: x86/OP_NOP.S */ 324 FETCH_INST_OPCODE 1 %ecx 325 ADVANCE_PC 1 326 GOTO_NEXT_R %ecx 327 328/* ------------------------------ */ 329.L_OP_MOVE: /* 0x01 */ 330/* File: x86/OP_MOVE.S */ 331 /* for move, move-object, long-to-int */ 332 /* op vA, vB */ 333 movzbl rINSTbl,%eax # eax<- BA 334 andb $0xf,%al # eax<- A 335 shrl $4,rINST # rINST<- B 336 GET_VREG_R rINST rINST 337 FETCH_INST_OPCODE 1 %ecx 338 ADVANCE_PC 1 339 SET_VREG rINST %eax # fp[A]<-fp[B] 340 GOTO_NEXT_R %ecx 341 342/* ------------------------------ */ 343.L_OP_MOVE_FROM16: /* 0x02 */ 344/* File: x86/OP_MOVE_FROM16.S */ 345 /* for: move/from16, move-object/from16 */ 346 /* op vAA, vBBBB */ 347 movzx rINSTbl,%eax # eax <= AA 348 movw 2(rPC),rINSTw # rINSTw <= BBBB 349 GET_VREG_R rINST rINST # rINST- fp[BBBB] 350 FETCH_INST_OPCODE 2 %ecx 351 ADVANCE_PC 2 352 SET_VREG rINST %eax # fp[AA]<- ecx] 353 GOTO_NEXT_R %ecx 354 355/* ------------------------------ */ 356.L_OP_MOVE_16: /* 0x03 */ 357/* File: x86/OP_MOVE_16.S */ 358 /* for: move/16, move-object/16 */ 359 /* op vAAAA, vBBBB */ 360 movzwl 4(rPC),%ecx # ecx<- BBBB 361 movzwl 2(rPC),%eax # eax<- AAAA 362 GET_VREG_R rINST %ecx 363 FETCH_INST_OPCODE 3 %ecx 364 ADVANCE_PC 3 365 SET_VREG rINST %eax 366 GOTO_NEXT_R %ecx 367 368/* ------------------------------ */ 369.L_OP_MOVE_WIDE: /* 0x04 */ 370/* File: x86/OP_MOVE_WIDE.S */ 371 /* move-wide vA, vB */ 372 /* NOTE: regs can overlap, e.g. "move v6,v7" or "move v7,v6" */ 373 movzbl rINSTbl,%ecx # ecx <- BA 374 sarl $4,rINST # rINST<- B 375 GET_VREG_WORD %eax rINST 0 # eax<- v[B+0] 376 GET_VREG_WORD rINST rINST 1 # rINST<- v[B+1] 377 andb $0xf,%cl # ecx <- A 378 SET_VREG_WORD rINST %ecx 1 # v[A+1]<- rINST 379 SET_VREG_WORD %eax %ecx 0 # v[A+0]<- eax 380 FETCH_INST_OPCODE 1 %ecx 381 ADVANCE_PC 1 382 GOTO_NEXT_R %ecx 383 384/* ------------------------------ */ 385.L_OP_MOVE_WIDE_FROM16: /* 0x05 */ 386/* File: x86/OP_MOVE_WIDE_FROM16.S */ 387 /* move-wide/from16 vAA, vBBBB */ 388 /* NOTE: regs can overlap, e.g. "move v6,v7" or "move v7,v6" */ 389 movzwl 2(rPC),%ecx # ecx<- BBBB 390 movzbl rINSTbl,%eax # eax<- AAAA 391 GET_VREG_WORD rINST %ecx 0 # rINST<- v[BBBB+0] 392 GET_VREG_WORD %ecx %ecx 1 # ecx<- v[BBBB+1] 393 SET_VREG_WORD rINST %eax 0 # v[AAAA+0]<- rINST 394 SET_VREG_WORD %ecx %eax 1 # v[AAAA+1]<- eax 395 FETCH_INST_OPCODE 2 %ecx 396 ADVANCE_PC 2 397 GOTO_NEXT_R %ecx 398 399/* ------------------------------ */ 400.L_OP_MOVE_WIDE_16: /* 0x06 */ 401/* File: x86/OP_MOVE_WIDE_16.S */ 402 /* move-wide/16 vAAAA, vBBBB */ 403 /* NOTE: regs can overlap, e.g. "move v6,v7" or "move v7,v6" */ 404 movzwl 4(rPC),%ecx # ecx<- BBBB 405 movzwl 2(rPC),%eax # eax<- AAAA 406 GET_VREG_WORD rINST %ecx 0 # rINSTw_WORD<- v[BBBB+0] 407 GET_VREG_WORD %ecx %ecx 1 # ecx<- v[BBBB+1] 408 SET_VREG_WORD rINST %eax 0 # v[AAAA+0]<- rINST 409 SET_VREG_WORD %ecx %eax 1 # v[AAAA+1]<- ecx 410 FETCH_INST_OPCODE 3 %ecx 411 ADVANCE_PC 3 412 GOTO_NEXT_R %ecx 413 414/* ------------------------------ */ 415.L_OP_MOVE_OBJECT: /* 0x07 */ 416/* File: x86/OP_MOVE_OBJECT.S */ 417/* File: x86/OP_MOVE.S */ 418 /* for move, move-object, long-to-int */ 419 /* op vA, vB */ 420 movzbl rINSTbl,%eax # eax<- BA 421 andb $0xf,%al # eax<- A 422 shrl $4,rINST # rINST<- B 423 GET_VREG_R rINST rINST 424 FETCH_INST_OPCODE 1 %ecx 425 ADVANCE_PC 1 426 SET_VREG rINST %eax # fp[A]<-fp[B] 427 GOTO_NEXT_R %ecx 428 429 430/* ------------------------------ */ 431.L_OP_MOVE_OBJECT_FROM16: /* 0x08 */ 432/* File: x86/OP_MOVE_OBJECT_FROM16.S */ 433/* File: x86/OP_MOVE_FROM16.S */ 434 /* for: move/from16, move-object/from16 */ 435 /* op vAA, vBBBB */ 436 movzx rINSTbl,%eax # eax <= AA 437 movw 2(rPC),rINSTw # rINSTw <= BBBB 438 GET_VREG_R rINST rINST # rINST- fp[BBBB] 439 FETCH_INST_OPCODE 2 %ecx 440 ADVANCE_PC 2 441 SET_VREG rINST %eax # fp[AA]<- ecx] 442 GOTO_NEXT_R %ecx 443 444 445/* ------------------------------ */ 446.L_OP_MOVE_OBJECT_16: /* 0x09 */ 447/* File: x86/OP_MOVE_OBJECT_16.S */ 448/* File: x86/OP_MOVE_16.S */ 449 /* for: move/16, move-object/16 */ 450 /* op vAAAA, vBBBB */ 451 movzwl 4(rPC),%ecx # ecx<- BBBB 452 movzwl 2(rPC),%eax # eax<- AAAA 453 GET_VREG_R rINST %ecx 454 FETCH_INST_OPCODE 3 %ecx 455 ADVANCE_PC 3 456 SET_VREG rINST %eax 457 GOTO_NEXT_R %ecx 458 459 460/* ------------------------------ */ 461.L_OP_MOVE_RESULT: /* 0x0a */ 462/* File: x86/OP_MOVE_RESULT.S */ 463 /* for: move-result, move-result-object */ 464 /* op vAA */ 465 movl rSELF,%eax # eax<- rSELF 466 movl offThread_retval(%eax),%eax # eax<- self->retval.l 467 FETCH_INST_OPCODE 1 %ecx 468 ADVANCE_PC 1 469 SET_VREG %eax rINST # fp[AA]<- retval.l 470 GOTO_NEXT_R %ecx 471 472/* ------------------------------ */ 473.L_OP_MOVE_RESULT_WIDE: /* 0x0b */ 474/* File: x86/OP_MOVE_RESULT_WIDE.S */ 475 /* move-result-wide vAA */ 476 movl rSELF,%ecx 477 movl offThread_retval(%ecx),%eax 478 movl 4+offThread_retval(%ecx),%ecx 479 SET_VREG_WORD %eax rINST 0 # v[AA+0] <- eax 480 SET_VREG_WORD %ecx rINST 1 # v[AA+1] <- ecx 481 FETCH_INST_OPCODE 1 %ecx 482 ADVANCE_PC 1 483 GOTO_NEXT_R %ecx 484 485/* ------------------------------ */ 486.L_OP_MOVE_RESULT_OBJECT: /* 0x0c */ 487/* File: x86/OP_MOVE_RESULT_OBJECT.S */ 488/* File: x86/OP_MOVE_RESULT.S */ 489 /* for: move-result, move-result-object */ 490 /* op vAA */ 491 movl rSELF,%eax # eax<- rSELF 492 movl offThread_retval(%eax),%eax # eax<- self->retval.l 493 FETCH_INST_OPCODE 1 %ecx 494 ADVANCE_PC 1 495 SET_VREG %eax rINST # fp[AA]<- retval.l 496 GOTO_NEXT_R %ecx 497 498 499/* ------------------------------ */ 500.L_OP_MOVE_EXCEPTION: /* 0x0d */ 501/* File: x86/OP_MOVE_EXCEPTION.S */ 502 /* move-exception vAA */ 503 movl rSELF,%ecx 504 movl offThread_exception(%ecx),%eax # eax<- dvmGetException bypass 505 SET_VREG %eax rINST # fp[AA]<- exception object 506 FETCH_INST_OPCODE 1 %eax 507 ADVANCE_PC 1 508 movl $0,offThread_exception(%ecx) # dvmClearException bypass 509 GOTO_NEXT_R %eax 510 511/* ------------------------------ */ 512.L_OP_RETURN_VOID: /* 0x0e */ 513/* File: x86/OP_RETURN_VOID.S */ 514 jmp common_returnFromMethod 515 516/* ------------------------------ */ 517.L_OP_RETURN: /* 0x0f */ 518/* File: x86/OP_RETURN.S */ 519 /* 520 * Return a 32-bit value. Copies the return value into the "self" 521 * structure, then jumps to the return handler. 522 * 523 * for: return, return-object 524 */ 525 /* op vAA */ 526 movl rSELF,%ecx 527 GET_VREG_R %eax rINST # eax<- vAA 528 movl %eax,offThread_retval(%ecx) # retval.i <- AA 529 jmp common_returnFromMethod 530 531/* ------------------------------ */ 532.L_OP_RETURN_WIDE: /* 0x10 */ 533/* File: x86/OP_RETURN_WIDE.S */ 534 /* 535 * Return a 64-bit value. Copies the return value into the "self" 536 * structure, then jumps to the return handler. 537 */ 538 /* return-wide vAA */ 539 movl rSELF,%ecx 540 GET_VREG_WORD %eax rINST 0 # eax<- v[AA+0] 541 GET_VREG_WORD rINST rINST 1 # rINST<- v[AA+1] 542 movl %eax,offThread_retval(%ecx) 543 movl rINST,4+offThread_retval(%ecx) 544 jmp common_returnFromMethod 545 546/* ------------------------------ */ 547.L_OP_RETURN_OBJECT: /* 0x11 */ 548/* File: x86/OP_RETURN_OBJECT.S */ 549/* File: x86/OP_RETURN.S */ 550 /* 551 * Return a 32-bit value. Copies the return value into the "self" 552 * structure, then jumps to the return handler. 553 * 554 * for: return, return-object 555 */ 556 /* op vAA */ 557 movl rSELF,%ecx 558 GET_VREG_R %eax rINST # eax<- vAA 559 movl %eax,offThread_retval(%ecx) # retval.i <- AA 560 jmp common_returnFromMethod 561 562 563/* ------------------------------ */ 564.L_OP_CONST_4: /* 0x12 */ 565/* File: x86/OP_CONST_4.S */ 566 /* const/4 vA, #+B */ 567 movsx rINSTbl,%eax # eax<-ssssssBx 568 movl $0xf,rINST 569 andl %eax,rINST # rINST<- A 570 FETCH_INST_OPCODE 1 %ecx 571 ADVANCE_PC 1 572 sarl $4,%eax 573 SET_VREG %eax rINST 574 GOTO_NEXT_R %ecx 575 576/* ------------------------------ */ 577.L_OP_CONST_16: /* 0x13 */ 578/* File: x86/OP_CONST_16.S */ 579 /* const/16 vAA, #+BBBB */ 580 movswl 2(rPC),%ecx # ecx<- ssssBBBB 581 FETCH_INST_OPCODE 2 %eax 582 ADVANCE_PC 2 583 SET_VREG %ecx rINST # vAA<- ssssBBBB 584 GOTO_NEXT_R %eax 585 586/* ------------------------------ */ 587.L_OP_CONST: /* 0x14 */ 588/* File: x86/OP_CONST.S */ 589 /* const vAA, #+BBBBbbbb */ 590 movl 2(rPC),%eax # grab all 32 bits at once 591 movl rINST,rINST # rINST<- AA 592 FETCH_INST_OPCODE 3 %ecx 593 ADVANCE_PC 3 594 SET_VREG %eax rINST # vAA<- eax 595 GOTO_NEXT_R %ecx 596 597/* ------------------------------ */ 598.L_OP_CONST_HIGH16: /* 0x15 */ 599/* File: x86/OP_CONST_HIGH16.S */ 600 /* const/high16 vAA, #+BBBB0000 */ 601 movzwl 2(rPC),%eax # eax<- 0000BBBB 602 FETCH_INST_OPCODE 2 %ecx 603 ADVANCE_PC 2 604 sall $16,%eax # eax<- BBBB0000 605 SET_VREG %eax rINST # vAA<- eax 606 GOTO_NEXT_R %ecx 607 608/* ------------------------------ */ 609.L_OP_CONST_WIDE_16: /* 0x16 */ 610/* File: x86/OP_CONST_WIDE_16.S */ 611 /* const-wide/16 vAA, #+BBBB */ 612 movswl 2(rPC),%eax # eax<- ssssBBBB 613 SPILL(rIBASE) # preserve rIBASE (cltd trashes it) 614 cltd # rIBASE:eax<- ssssssssssssBBBB 615 SET_VREG_WORD rIBASE rINST 1 # store msw 616 FETCH_INST_OPCODE 2 %ecx 617 UNSPILL(rIBASE) # restore rIBASE 618 SET_VREG_WORD %eax rINST 0 # store lsw 619 ADVANCE_PC 2 620 GOTO_NEXT_R %ecx 621 622/* ------------------------------ */ 623.L_OP_CONST_WIDE_32: /* 0x17 */ 624/* File: x86/OP_CONST_WIDE_32.S */ 625 /* const-wide/32 vAA, #+BBBBbbbb */ 626 movl 2(rPC),%eax # eax<- BBBBbbbb 627 SPILL(rIBASE) # save rIBASE (cltd trashes it) 628 cltd # rIBASE:eax<- ssssssssssssBBBB 629 SET_VREG_WORD rIBASE rINST,1 # store msw 630 FETCH_INST_OPCODE 3 %ecx 631 UNSPILL(rIBASE) # restore rIBASE 632 SET_VREG_WORD %eax rINST 0 # store lsw 633 ADVANCE_PC 3 634 GOTO_NEXT_R %ecx 635 636/* ------------------------------ */ 637.L_OP_CONST_WIDE: /* 0x18 */ 638/* File: x86/OP_CONST_WIDE.S */ 639 /* const-wide vAA, #+HHHHhhhhBBBBbbbb */ 640 movl 2(rPC),%eax # eax<- lsw 641 movzbl rINSTbl,%ecx # ecx<- AA 642 movl 6(rPC),rINST # rINST<- msw 643 leal (rFP,%ecx,4),%ecx # dst addr 644 movl rINST,4(%ecx) 645 movl %eax,(%ecx) 646 FETCH_INST_OPCODE 5 %ecx 647 ADVANCE_PC 5 648 GOTO_NEXT_R %ecx 649 650/* ------------------------------ */ 651.L_OP_CONST_WIDE_HIGH16: /* 0x19 */ 652/* File: x86/OP_CONST_WIDE_HIGH16.S */ 653 /* const-wide/high16 vAA, #+BBBB000000000000 */ 654 movzwl 2(rPC),%eax # eax<- 0000BBBB 655 FETCH_INST_OPCODE 2 %ecx 656 ADVANCE_PC 2 657 sall $16,%eax # eax<- BBBB0000 658 SET_VREG_WORD %eax rINST 1 # v[AA+1]<- eax 659 xorl %eax,%eax 660 SET_VREG_WORD %eax rINST 0 # v[AA+0]<- eax 661 GOTO_NEXT_R %ecx 662 663/* ------------------------------ */ 664.L_OP_CONST_STRING: /* 0x1a */ 665/* File: x86/OP_CONST_STRING.S */ 666 667 /* const/string vAA, String@BBBB */ 668 movl rSELF,%ecx 669 movzwl 2(rPC),%eax # eax<- BBBB 670 movl offThread_methodClassDex(%ecx),%ecx# ecx<- self->methodClassDex 671 movl offDvmDex_pResStrings(%ecx),%ecx # ecx<- dvmDex->pResStrings 672 movl (%ecx,%eax,4),%eax # eax<- rResString[BBBB] 673 FETCH_INST_OPCODE 2 %ecx 674 testl %eax,%eax # resolved yet? 675 je .LOP_CONST_STRING_resolve 676 SET_VREG %eax rINST # vAA<- rResString[BBBB] 677 ADVANCE_PC 2 678 GOTO_NEXT_R %ecx 679 680/* This is the less common path, so we'll redo some work 681 here rather than force spills on the common path */ 682.LOP_CONST_STRING_resolve: 683 movl rSELF,%eax 684 EXPORT_PC 685 movl offThread_method(%eax),%eax # eax<- self->method 686 movzwl 2(rPC),%ecx # ecx<- BBBB 687 movl offMethod_clazz(%eax),%eax 688 movl %ecx,OUT_ARG1(%esp) 689 movl %eax,OUT_ARG0(%esp) 690 SPILL(rIBASE) 691 call dvmResolveString # go resolve 692 UNSPILL(rIBASE) 693 testl %eax,%eax # failed? 694 je common_exceptionThrown 695 FETCH_INST_OPCODE 2 %ecx 696 SET_VREG %eax rINST 697 ADVANCE_PC 2 698 GOTO_NEXT_R %ecx 699 700/* ------------------------------ */ 701.L_OP_CONST_STRING_JUMBO: /* 0x1b */ 702/* File: x86/OP_CONST_STRING_JUMBO.S */ 703 704 /* const/string vAA, String@BBBBBBBB */ 705 movl rSELF,%ecx 706 movl 2(rPC),%eax # eax<- BBBBBBBB 707 movl offThread_methodClassDex(%ecx),%ecx# ecx<- self->methodClassDex 708 movl offDvmDex_pResStrings(%ecx),%ecx # ecx<- dvmDex->pResStrings 709 movl (%ecx,%eax,4),%eax # eax<- rResString[BBBB] 710 FETCH_INST_OPCODE 3 %ecx 711 testl %eax,%eax # resolved yet? 712 je .LOP_CONST_STRING_JUMBO_resolve 713 SET_VREG %eax rINST # vAA<- rResString[BBBB] 714 ADVANCE_PC 3 715 GOTO_NEXT_R %ecx 716 717/* This is the less common path, so we'll redo some work 718 here rather than force spills on the common path */ 719.LOP_CONST_STRING_JUMBO_resolve: 720 movl rSELF,%eax 721 EXPORT_PC 722 movl offThread_method(%eax),%eax # eax<- self->method 723 movl 2(rPC),%ecx # ecx<- BBBBBBBB 724 movl offMethod_clazz(%eax),%eax 725 movl %ecx,OUT_ARG1(%esp) 726 movl %eax,OUT_ARG0(%esp) 727 SPILL(rIBASE) 728 call dvmResolveString # go resolve 729 UNSPILL(rIBASE) 730 testl %eax,%eax # failed? 731 je common_exceptionThrown 732 FETCH_INST_OPCODE 3 %ecx 733 SET_VREG %eax rINST 734 ADVANCE_PC 3 735 GOTO_NEXT_R %ecx 736 737/* ------------------------------ */ 738.L_OP_CONST_CLASS: /* 0x1c */ 739/* File: x86/OP_CONST_CLASS.S */ 740 741 /* const/class vAA, Class@BBBB */ 742 movl rSELF,%ecx 743 movzwl 2(rPC),%eax # eax<- BBBB 744 movl offThread_methodClassDex(%ecx),%ecx# ecx<- self->methodClassDex 745 movl offDvmDex_pResClasses(%ecx),%ecx # ecx<- dvmDex->pResClasses 746 movl (%ecx,%eax,4),%eax # eax<- rResClasses[BBBB] 747 testl %eax,%eax # resolved yet? 748 je .LOP_CONST_CLASS_resolve 749 FETCH_INST_OPCODE 2 %ecx 750 SET_VREG %eax rINST # vAA<- rResClasses[BBBB] 751 ADVANCE_PC 2 752 GOTO_NEXT_R %ecx 753 754/* This is the less common path, so we'll redo some work 755 here rather than force spills on the common path */ 756.LOP_CONST_CLASS_resolve: 757 movl rSELF,%eax 758 EXPORT_PC 759 movl offThread_method(%eax),%eax # eax<- self->method 760 movl $1,OUT_ARG2(%esp) # true 761 movzwl 2(rPC),%ecx # ecx<- BBBB 762 movl offMethod_clazz(%eax),%eax 763 movl %ecx,OUT_ARG1(%esp) 764 movl %eax,OUT_ARG0(%esp) 765 SPILL(rIBASE) 766 call dvmResolveClass # go resolve 767 UNSPILL(rIBASE) 768 testl %eax,%eax # failed? 769 je common_exceptionThrown 770 FETCH_INST_OPCODE 2 %ecx 771 SET_VREG %eax rINST 772 ADVANCE_PC 2 773 GOTO_NEXT_R %ecx 774 775/* ------------------------------ */ 776.L_OP_MONITOR_ENTER: /* 0x1d */ 777/* File: x86/OP_MONITOR_ENTER.S */ 778 /* 779 * Synchronize on an object. 780 */ 781 /* monitor-enter vAA */ 782 movl rSELF,%ecx 783 GET_VREG_R %eax rINST # eax<- vAA 784 FETCH_INST_WORD 1 785 testl %eax,%eax # null object? 786 EXPORT_PC # need for precise GC 787 je common_errNullObject 788 movl %ecx,OUT_ARG0(%esp) 789 movl %eax,OUT_ARG1(%esp) 790 SPILL(rIBASE) 791 call dvmLockObject # dvmLockObject(self,object) 792 UNSPILL(rIBASE) 793 FETCH_INST_OPCODE 1 %ecx 794 ADVANCE_PC 1 795 GOTO_NEXT_R %ecx 796 797/* ------------------------------ */ 798.L_OP_MONITOR_EXIT: /* 0x1e */ 799/* File: x86/OP_MONITOR_EXIT.S */ 800 /* 801 * Unlock an object. 802 * 803 * Exceptions that occur when unlocking a monitor need to appear as 804 * if they happened at the following instruction. See the Dalvik 805 * instruction spec. 806 */ 807 /* monitor-exit vAA */ 808 GET_VREG_R %eax rINST 809 movl rSELF,%ecx 810 EXPORT_PC 811 testl %eax,%eax # null object? 812 je .LOP_MONITOR_EXIT_errNullObject # go if so 813 movl %eax,OUT_ARG1(%esp) 814 movl %ecx,OUT_ARG0(%esp) 815 SPILL(rIBASE) 816 call dvmUnlockObject # unlock(self,obj) 817 UNSPILL(rIBASE) 818 FETCH_INST_OPCODE 1 %ecx 819 testl %eax,%eax # success? 820 ADVANCE_PC 1 821 je common_exceptionThrown # no, exception pending 822 GOTO_NEXT_R %ecx 823.LOP_MONITOR_EXIT_errNullObject: 824 ADVANCE_PC 1 # advance before throw 825 jmp common_errNullObject 826 827/* ------------------------------ */ 828.L_OP_CHECK_CAST: /* 0x1f */ 829/* File: x86/OP_CHECK_CAST.S */ 830 /* 831 * Check to see if a cast from one class to another is allowed. 832 */ 833 /* check-cast vAA, class@BBBB */ 834 movl rSELF,%ecx 835 GET_VREG_R rINST,rINST # rINST<- vAA (object) 836 movzwl 2(rPC),%eax # eax<- BBBB 837 movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex 838 testl rINST,rINST # is oject null? 839 movl offDvmDex_pResClasses(%ecx),%ecx # ecx<- pDvmDex->pResClasses 840 je .LOP_CHECK_CAST_okay # null obj, cast always succeeds 841 movl (%ecx,%eax,4),%eax # eax<- resolved class 842 movl offObject_clazz(rINST),%ecx # ecx<- obj->clazz 843 testl %eax,%eax # have we resolved this before? 844 je .LOP_CHECK_CAST_resolve # no, go do it now 845.LOP_CHECK_CAST_resolved: 846 cmpl %eax,%ecx # same class (trivial success)? 847 jne .LOP_CHECK_CAST_fullcheck # no, do full check 848.LOP_CHECK_CAST_okay: 849 FETCH_INST_OPCODE 2 %ecx 850 ADVANCE_PC 2 851 GOTO_NEXT_R %ecx 852 853 /* 854 * Trivial test failed, need to perform full check. This is common. 855 * ecx holds obj->clazz 856 * eax holds class resolved from BBBB 857 * rINST holds object 858 */ 859.LOP_CHECK_CAST_fullcheck: 860 movl %eax,sReg0 # we'll need the desired class on failure 861 movl %eax,OUT_ARG1(%esp) 862 movl %ecx,OUT_ARG0(%esp) 863 SPILL(rIBASE) 864 call dvmInstanceofNonTrivial # eax<- boolean result 865 UNSPILL(rIBASE) 866 testl %eax,%eax # failed? 867 jne .LOP_CHECK_CAST_okay # no, success 868 869 # A cast has failed. We need to throw a ClassCastException. 870 EXPORT_PC 871 movl offObject_clazz(rINST),%eax 872 movl %eax,OUT_ARG0(%esp) # arg0<- obj->clazz 873 movl sReg0,%ecx 874 movl %ecx,OUT_ARG1(%esp) # arg1<- desired class 875 call dvmThrowClassCastException 876 jmp common_exceptionThrown 877 878 /* 879 * Resolution required. This is the least-likely path, and we're 880 * going to have to recreate some data. 881 * 882 * rINST holds object 883 */ 884.LOP_CHECK_CAST_resolve: 885 movl rSELF,%ecx 886 EXPORT_PC 887 movzwl 2(rPC),%eax # eax<- BBBB 888 movl offThread_method(%ecx),%ecx # ecx<- self->method 889 movl %eax,OUT_ARG1(%esp) # arg1<- BBBB 890 movl offMethod_clazz(%ecx),%ecx # ecx<- metho->clazz 891 movl $0,OUT_ARG2(%esp) # arg2<- false 892 movl %ecx,OUT_ARG0(%esp) # arg0<- method->clazz 893 SPILL(rIBASE) 894 call dvmResolveClass # eax<- resolved ClassObject ptr 895 UNSPILL(rIBASE) 896 testl %eax,%eax # got null? 897 je common_exceptionThrown # yes, handle exception 898 movl offObject_clazz(rINST),%ecx # ecx<- obj->clazz 899 jmp .LOP_CHECK_CAST_resolved # pick up where we left off 900 901/* ------------------------------ */ 902.L_OP_INSTANCE_OF: /* 0x20 */ 903/* File: x86/OP_INSTANCE_OF.S */ 904 /* 905 * Check to see if an object reference is an instance of a class. 906 * 907 * Most common situation is a non-null object, being compared against 908 * an already-resolved class. 909 */ 910 /* instance-of vA, vB, class@CCCC */ 911 movl rINST,%eax # eax<- BA 912 sarl $4,%eax # eax<- B 913 GET_VREG_R %eax %eax # eax<- vB (obj) 914 movl rSELF,%ecx 915 testl %eax,%eax # object null? 916 movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex 917 SPILL(rIBASE) # preserve rIBASE 918 je .LOP_INSTANCE_OF_store # null obj, not instance, store it 919 movzwl 2(rPC),rIBASE # rIBASE<- CCCC 920 movl offDvmDex_pResClasses(%ecx),%ecx # ecx<- pDvmDex->pResClasses 921 movl (%ecx,rIBASE,4),%ecx # ecx<- resolved class 922 movl offObject_clazz(%eax),%eax # eax<- obj->clazz 923 testl %ecx,%ecx # have we resolved this before? 924 je .LOP_INSTANCE_OF_resolve # not resolved, do it now 925.LOP_INSTANCE_OF_resolved: # eax<- obj->clazz, ecx<- resolved class 926 cmpl %eax,%ecx # same class (trivial success)? 927 je .LOP_INSTANCE_OF_trivial # yes, trivial finish 928 /* 929 * Trivial test failed, need to perform full check. This is common. 930 * eax holds obj->clazz 931 * ecx holds class resolved from BBBB 932 * rINST has BA 933 */ 934 movl %eax,OUT_ARG0(%esp) 935 movl %ecx,OUT_ARG1(%esp) 936 call dvmInstanceofNonTrivial # eax<- boolean result 937 # fall through to OP_INSTANCE_OF_store 938 939 /* 940 * eax holds boolean result 941 * rINST holds BA 942 */ 943.LOP_INSTANCE_OF_store: 944 FETCH_INST_OPCODE 2 %ecx 945 UNSPILL(rIBASE) 946 andb $0xf,rINSTbl # <- A 947 ADVANCE_PC 2 948 SET_VREG %eax rINST # vA<- eax 949 GOTO_NEXT_R %ecx 950 951 /* 952 * Trivial test succeeded, save and bail. 953 * r9 holds A 954 */ 955.LOP_INSTANCE_OF_trivial: 956 FETCH_INST_OPCODE 2 %ecx 957 UNSPILL(rIBASE) 958 andb $0xf,rINSTbl # <- A 959 ADVANCE_PC 2 960 movl $1,%eax 961 SET_VREG %eax rINST # vA<- true 962 GOTO_NEXT_R %ecx 963 964 /* 965 * Resolution required. This is the least-likely path. 966 * 967 * rIBASE holds BBBB 968 * rINST holds BA 969 */ 970.LOP_INSTANCE_OF_resolve: 971 movl rIBASE,OUT_ARG1(%esp) # arg1<- BBBB 972 movl rSELF,%ecx 973 movl offThread_method(%ecx),%ecx 974 movl $1,OUT_ARG2(%esp) # arg2<- true 975 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 976 EXPORT_PC 977 movl %ecx,OUT_ARG0(%esp) # arg0<- method->clazz 978 call dvmResolveClass # eax<- resolved ClassObject ptr 979 testl %eax,%eax # success? 980 je common_exceptionThrown # no, handle exception 981/* Now, we need to sync up with fast path. We need eax to 982 * hold the obj->clazz, and ecx to hold the resolved class 983 */ 984 movl %eax,%ecx # ecx<- resolved class 985 movl rINST,%eax # eax<- BA 986 sarl $4,%eax # eax<- B 987 GET_VREG_R %eax %eax # eax<- vB (obj) 988 movl offObject_clazz(%eax),%eax # eax<- obj->clazz 989 jmp .LOP_INSTANCE_OF_resolved 990 991/* ------------------------------ */ 992.L_OP_ARRAY_LENGTH: /* 0x21 */ 993/* File: x86/OP_ARRAY_LENGTH.S */ 994 /* 995 * Return the length of an array. 996 */ 997 mov rINST,%eax # eax<- BA 998 sarl $4,rINST # rINST<- B 999 GET_VREG_R %ecx rINST # ecx<- vB (object ref) 1000 andb $0xf,%al # eax<- A 1001 testl %ecx,%ecx # is null? 1002 je common_errNullObject 1003 movl offArrayObject_length(%ecx),rINST 1004 FETCH_INST_OPCODE 1 %ecx 1005 ADVANCE_PC 1 1006 SET_VREG rINST %eax 1007 GOTO_NEXT_R %ecx 1008 1009/* ------------------------------ */ 1010.L_OP_NEW_INSTANCE: /* 0x22 */ 1011/* File: x86/OP_NEW_INSTANCE.S */ 1012 /* 1013 * Create a new instance of a class. 1014 */ 1015 /* new-instance vAA, class@BBBB */ 1016 movl rSELF,%ecx 1017 movzwl 2(rPC),%eax # eax<- BBBB 1018 movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex 1019 SPILL(rIBASE) 1020 movl offDvmDex_pResClasses(%ecx),%ecx # ecx<- pDvmDex->pResClasses 1021 EXPORT_PC 1022 movl (%ecx,%eax,4),%ecx # ecx<- resolved class 1023 testl %ecx,%ecx # resolved? 1024 je .LOP_NEW_INSTANCE_resolve # no, go do it 1025.LOP_NEW_INSTANCE_resolved: # on entry, ecx<- class 1026 cmpb $CLASS_INITIALIZED,offClassObject_status(%ecx) 1027 jne .LOP_NEW_INSTANCE_needinit 1028.LOP_NEW_INSTANCE_initialized: # on entry, ecx<- class 1029 movl $ALLOC_DONT_TRACK,OUT_ARG1(%esp) 1030 movl %ecx,OUT_ARG0(%esp) 1031 call dvmAllocObject # eax<- new object 1032 FETCH_INST_OPCODE 2 %ecx 1033 UNSPILL(rIBASE) 1034 testl %eax,%eax # success? 1035 je common_exceptionThrown # no, bail out 1036 SET_VREG %eax rINST 1037 ADVANCE_PC 2 1038 GOTO_NEXT_R %ecx 1039 1040 /* 1041 * Class initialization required. 1042 * 1043 * ecx holds class object 1044 */ 1045.LOP_NEW_INSTANCE_needinit: 1046 SPILL_TMP1(%ecx) # save object 1047 movl %ecx,OUT_ARG0(%esp) 1048 call dvmInitClass # initialize class 1049 UNSPILL_TMP1(%ecx) # restore object 1050 testl %eax,%eax # success? 1051 jne .LOP_NEW_INSTANCE_initialized # success, continue 1052 jmp common_exceptionThrown # go deal with init exception 1053 1054 /* 1055 * Resolution required. This is the least-likely path. 1056 * 1057 */ 1058.LOP_NEW_INSTANCE_resolve: 1059 movl rSELF,%ecx 1060 movzwl 2(rPC),%eax 1061 movl offThread_method(%ecx),%ecx # ecx<- self->method 1062 movl %eax,OUT_ARG1(%esp) 1063 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 1064 movl $0,OUT_ARG2(%esp) 1065 movl %ecx,OUT_ARG0(%esp) 1066 call dvmResolveClass # call(clazz,off,flags) 1067 movl %eax,%ecx # ecx<- resolved ClassObject ptr 1068 testl %ecx,%ecx # success? 1069 jne .LOP_NEW_INSTANCE_resolved # good to go 1070 jmp common_exceptionThrown # no, handle exception 1071 1072/* ------------------------------ */ 1073.L_OP_NEW_ARRAY: /* 0x23 */ 1074/* File: x86/OP_NEW_ARRAY.S */ 1075 /* 1076 * Allocate an array of objects, specified with the array class 1077 * and a count. 1078 * 1079 * The verifier guarantees that this is an array class, so we don't 1080 * check for it here. 1081 */ 1082 /* new-array vA, vB, class@CCCC */ 1083 movl rSELF,%ecx 1084 EXPORT_PC 1085 movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex 1086 movzwl 2(rPC),%eax # eax<- CCCC 1087 movl offDvmDex_pResClasses(%ecx),%ecx # ecx<- pDvmDex->pResClasses 1088 SPILL(rIBASE) 1089 movl (%ecx,%eax,4),%ecx # ecx<- resolved class 1090 movzbl rINSTbl,%eax 1091 sarl $4,%eax # eax<- B 1092 GET_VREG_R %eax %eax # eax<- vB (array length) 1093 andb $0xf,rINSTbl # rINST<- A 1094 testl %eax,%eax 1095 js common_errNegativeArraySize # bail, passing len in eax 1096 testl %ecx,%ecx # already resolved? 1097 jne .LOP_NEW_ARRAY_finish # yes, fast path 1098 /* 1099 * Resolve class. (This is an uncommon case.) 1100 * ecx holds class (null here) 1101 * eax holds array length (vB) 1102 */ 1103 movl rSELF,%ecx 1104 SPILL_TMP1(%eax) # save array length 1105 movl offThread_method(%ecx),%ecx # ecx<- self->method 1106 movzwl 2(rPC),%eax # eax<- CCCC 1107 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 1108 movl %eax,OUT_ARG1(%esp) 1109 movl $0,OUT_ARG2(%esp) 1110 movl %ecx,OUT_ARG0(%esp) 1111 call dvmResolveClass # eax<- call(clazz,ref,flag) 1112 movl %eax,%ecx 1113 UNSPILL_TMP1(%eax) 1114 testl %ecx,%ecx # successful resolution? 1115 je common_exceptionThrown # no, bail. 1116# fall through to OP_NEW_ARRAY_finish 1117 1118 /* 1119 * Finish allocation 1120 * 1121 * ecx holds class 1122 * eax holds array length (vB) 1123 */ 1124.LOP_NEW_ARRAY_finish: 1125 movl %ecx,OUT_ARG0(%esp) 1126 movl %eax,OUT_ARG1(%esp) 1127 movl $ALLOC_DONT_TRACK,OUT_ARG2(%esp) 1128 call dvmAllocArrayByClass # eax<- call(clazz,length,flags) 1129 FETCH_INST_OPCODE 2 %ecx 1130 UNSPILL(rIBASE) 1131 testl %eax,%eax # failed? 1132 je common_exceptionThrown # yup - go handle 1133 SET_VREG %eax rINST 1134 ADVANCE_PC 2 1135 GOTO_NEXT_R %ecx 1136 1137/* ------------------------------ */ 1138.L_OP_FILLED_NEW_ARRAY: /* 0x24 */ 1139/* File: x86/OP_FILLED_NEW_ARRAY.S */ 1140 /* 1141 * Create a new array with elements filled from registers. 1142 * 1143 * for: filled-new-array, filled-new-array/range 1144 */ 1145 /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ 1146 /* op {vCCCC..v(CCCC+AA-1)}, type@BBBB */ 1147 movl rSELF,%eax 1148 movl offThread_methodClassDex(%eax),%eax # eax<- pDvmDex 1149 movzwl 2(rPC),%ecx # ecx<- BBBB 1150 movl offDvmDex_pResClasses(%eax),%eax # eax<- pDvmDex->pResClasses 1151 SPILL(rIBASE) # preserve rIBASE 1152 movl (%eax,%ecx,4),%eax # eax<- resolved class 1153 EXPORT_PC 1154 testl %eax,%eax # already resolved? 1155 jne .LOP_FILLED_NEW_ARRAY_continue # yes, continue 1156 # less frequent path, so we'll redo some work 1157 movl rSELF,%eax 1158 movl $0,OUT_ARG2(%esp) # arg2<- false 1159 movl %ecx,OUT_ARG1(%esp) # arg1<- BBBB 1160 movl offThread_method(%eax),%eax # eax<- self->method 1161 movl offMethod_clazz(%eax),%eax # eax<- method->clazz 1162 movl %eax,OUT_ARG0(%esp) # arg0<- clazz 1163 call dvmResolveClass # eax<- call(clazz,ref,flag) 1164 testl %eax,%eax # null? 1165 je common_exceptionThrown # yes, handle it 1166 1167 # note: fall through to .LOP_FILLED_NEW_ARRAY_continue 1168 1169 /* 1170 * On entry: 1171 * eax holds array class [r0] 1172 * rINST holds AA or BB [r10] 1173 * ecx is scratch 1174 */ 1175.LOP_FILLED_NEW_ARRAY_continue: 1176 movl offClassObject_descriptor(%eax),%ecx # ecx<- arrayClass->descriptor 1177 movl $ALLOC_DONT_TRACK,OUT_ARG2(%esp) # arg2<- flags 1178 movzbl 1(%ecx),%ecx # ecx<- descriptor[1] 1179 movl %eax,OUT_ARG0(%esp) # arg0<- arrayClass 1180 movl rSELF,%eax 1181 cmpb $'I',%cl # supported? 1182 je 1f 1183 cmpb $'L',%cl 1184 je 1f 1185 cmpb $'[',%cl 1186 jne .LOP_FILLED_NEW_ARRAY_notimpl # no, not handled yet 11871: 1188 movl %ecx,offThread_retval+4(%eax) # save type 1189 .if (!0) 1190 SPILL_TMP1(rINST) # save copy, need "B" later 1191 sarl $4,rINST 1192 .endif 1193 movl rINST,OUT_ARG1(%esp) # arg1<- A or AA (length) 1194 call dvmAllocArrayByClass # eax<- call(arrayClass, length, flags) 1195 movl rSELF,%ecx 1196 testl %eax,%eax # alloc successful? 1197 je common_exceptionThrown # no, handle exception 1198 movl %eax,offThread_retval(%ecx) # retval.l<- new array 1199 movzwl 4(rPC),%ecx # ecx<- FEDC or CCCC 1200 leal offArrayObject_contents(%eax),%eax # eax<- newArray->contents 1201 1202/* at this point: 1203 * eax is pointer to tgt 1204 * rINST is length 1205 * ecx is FEDC or CCCC 1206 * TMP_SPILL1 is BA 1207 * We now need to copy values from registers into the array 1208 */ 1209 1210 .if 0 1211 # set up src pointer 1212 SPILL_TMP2(%esi) 1213 SPILL_TMP3(%edi) 1214 leal (rFP,%ecx,4),%esi # set up src ptr 1215 movl %eax,%edi # set up dst ptr 1216 movl rINST,%ecx # load count register 1217 rep 1218 movsd 1219 UNSPILL_TMP2(%esi) 1220 UNSPILL_TMP3(%edi) 1221 movl rSELF,%ecx 1222 movl offThread_retval+4(%ecx),%eax # eax<- type 1223 .else 1224 testl rINST,rINST 1225 je 4f 1226 UNSPILL_TMP1(rIBASE) # restore "BA" 1227 andl $0x0f,rIBASE # rIBASE<- 0000000A 1228 sall $16,rIBASE # rIBASE<- 000A0000 1229 orl %ecx,rIBASE # rIBASE<- 000AFEDC 12303: 1231 movl $0xf,%ecx 1232 andl rIBASE,%ecx # ecx<- next reg to load 1233 GET_VREG_R %ecx %ecx 1234 shrl $4,rIBASE 1235 leal 4(%eax),%eax 1236 movl %ecx,-4(%eax) 1237 sub $1,rINST 1238 jne 3b 12394: 1240 movl rSELF,%ecx 1241 movl offThread_retval+4(%ecx),%eax # eax<- type 1242 .endif 1243 1244 cmpb $'I',%al # Int array? 1245 je 5f # skip card mark if so 1246 movl offThread_retval(%ecx),%eax # eax<- object head 1247 movl offThread_cardTable(%ecx),%ecx # card table base 1248 shrl $GC_CARD_SHIFT,%eax # convert to card num 1249 movb %cl,(%ecx,%eax) # mark card based on object head 12505: 1251 UNSPILL(rIBASE) # restore rIBASE 1252 FETCH_INST_OPCODE 3 %ecx 1253 ADVANCE_PC 3 1254 GOTO_NEXT_R %ecx 1255 1256 1257 /* 1258 * Throw an exception indicating that we have not implemented this 1259 * mode of filled-new-array. 1260 */ 1261.LOP_FILLED_NEW_ARRAY_notimpl: 1262 movl $.LstrFilledNewArrayNotImplA,%eax 1263 movl %eax,OUT_ARG0(%esp) 1264 call dvmThrowInternalError 1265 jmp common_exceptionThrown 1266 1267/* ------------------------------ */ 1268.L_OP_FILLED_NEW_ARRAY_RANGE: /* 0x25 */ 1269/* File: x86/OP_FILLED_NEW_ARRAY_RANGE.S */ 1270/* File: x86/OP_FILLED_NEW_ARRAY.S */ 1271 /* 1272 * Create a new array with elements filled from registers. 1273 * 1274 * for: filled-new-array, filled-new-array/range 1275 */ 1276 /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ 1277 /* op {vCCCC..v(CCCC+AA-1)}, type@BBBB */ 1278 movl rSELF,%eax 1279 movl offThread_methodClassDex(%eax),%eax # eax<- pDvmDex 1280 movzwl 2(rPC),%ecx # ecx<- BBBB 1281 movl offDvmDex_pResClasses(%eax),%eax # eax<- pDvmDex->pResClasses 1282 SPILL(rIBASE) # preserve rIBASE 1283 movl (%eax,%ecx,4),%eax # eax<- resolved class 1284 EXPORT_PC 1285 testl %eax,%eax # already resolved? 1286 jne .LOP_FILLED_NEW_ARRAY_RANGE_continue # yes, continue 1287 # less frequent path, so we'll redo some work 1288 movl rSELF,%eax 1289 movl $0,OUT_ARG2(%esp) # arg2<- false 1290 movl %ecx,OUT_ARG1(%esp) # arg1<- BBBB 1291 movl offThread_method(%eax),%eax # eax<- self->method 1292 movl offMethod_clazz(%eax),%eax # eax<- method->clazz 1293 movl %eax,OUT_ARG0(%esp) # arg0<- clazz 1294 call dvmResolveClass # eax<- call(clazz,ref,flag) 1295 testl %eax,%eax # null? 1296 je common_exceptionThrown # yes, handle it 1297 1298 # note: fall through to .LOP_FILLED_NEW_ARRAY_RANGE_continue 1299 1300 /* 1301 * On entry: 1302 * eax holds array class [r0] 1303 * rINST holds AA or BB [r10] 1304 * ecx is scratch 1305 */ 1306.LOP_FILLED_NEW_ARRAY_RANGE_continue: 1307 movl offClassObject_descriptor(%eax),%ecx # ecx<- arrayClass->descriptor 1308 movl $ALLOC_DONT_TRACK,OUT_ARG2(%esp) # arg2<- flags 1309 movzbl 1(%ecx),%ecx # ecx<- descriptor[1] 1310 movl %eax,OUT_ARG0(%esp) # arg0<- arrayClass 1311 movl rSELF,%eax 1312 cmpb $'I',%cl # supported? 1313 je 1f 1314 cmpb $'L',%cl 1315 je 1f 1316 cmpb $'[',%cl 1317 jne .LOP_FILLED_NEW_ARRAY_RANGE_notimpl # no, not handled yet 13181: 1319 movl %ecx,offThread_retval+4(%eax) # save type 1320 .if (!1) 1321 SPILL_TMP1(rINST) # save copy, need "B" later 1322 sarl $4,rINST 1323 .endif 1324 movl rINST,OUT_ARG1(%esp) # arg1<- A or AA (length) 1325 call dvmAllocArrayByClass # eax<- call(arrayClass, length, flags) 1326 movl rSELF,%ecx 1327 testl %eax,%eax # alloc successful? 1328 je common_exceptionThrown # no, handle exception 1329 movl %eax,offThread_retval(%ecx) # retval.l<- new array 1330 movzwl 4(rPC),%ecx # ecx<- FEDC or CCCC 1331 leal offArrayObject_contents(%eax),%eax # eax<- newArray->contents 1332 1333/* at this point: 1334 * eax is pointer to tgt 1335 * rINST is length 1336 * ecx is FEDC or CCCC 1337 * TMP_SPILL1 is BA 1338 * We now need to copy values from registers into the array 1339 */ 1340 1341 .if 1 1342 # set up src pointer 1343 SPILL_TMP2(%esi) 1344 SPILL_TMP3(%edi) 1345 leal (rFP,%ecx,4),%esi # set up src ptr 1346 movl %eax,%edi # set up dst ptr 1347 movl rINST,%ecx # load count register 1348 rep 1349 movsd 1350 UNSPILL_TMP2(%esi) 1351 UNSPILL_TMP3(%edi) 1352 movl rSELF,%ecx 1353 movl offThread_retval+4(%ecx),%eax # eax<- type 1354 .else 1355 testl rINST,rINST 1356 je 4f 1357 UNSPILL_TMP1(rIBASE) # restore "BA" 1358 andl $0x0f,rIBASE # rIBASE<- 0000000A 1359 sall $16,rIBASE # rIBASE<- 000A0000 1360 orl %ecx,rIBASE # rIBASE<- 000AFEDC 13613: 1362 movl $0xf,%ecx 1363 andl rIBASE,%ecx # ecx<- next reg to load 1364 GET_VREG_R %ecx %ecx 1365 shrl $4,rIBASE 1366 leal 4(%eax),%eax 1367 movl %ecx,-4(%eax) 1368 sub $1,rINST 1369 jne 3b 13704: 1371 movl rSELF,%ecx 1372 movl offThread_retval+4(%ecx),%eax # eax<- type 1373 .endif 1374 1375 cmpb $'I',%al # Int array? 1376 je 5f # skip card mark if so 1377 movl offThread_retval(%ecx),%eax # eax<- object head 1378 movl offThread_cardTable(%ecx),%ecx # card table base 1379 shrl $GC_CARD_SHIFT,%eax # convert to card num 1380 movb %cl,(%ecx,%eax) # mark card based on object head 13815: 1382 UNSPILL(rIBASE) # restore rIBASE 1383 FETCH_INST_OPCODE 3 %ecx 1384 ADVANCE_PC 3 1385 GOTO_NEXT_R %ecx 1386 1387 1388 /* 1389 * Throw an exception indicating that we have not implemented this 1390 * mode of filled-new-array. 1391 */ 1392.LOP_FILLED_NEW_ARRAY_RANGE_notimpl: 1393 movl $.LstrFilledNewArrayNotImplA,%eax 1394 movl %eax,OUT_ARG0(%esp) 1395 call dvmThrowInternalError 1396 jmp common_exceptionThrown 1397 1398 1399/* ------------------------------ */ 1400.L_OP_FILL_ARRAY_DATA: /* 0x26 */ 1401/* File: x86/OP_FILL_ARRAY_DATA.S */ 1402 /* fill-array-data vAA, +BBBBBBBB */ 1403 movl 2(rPC),%ecx # ecx<- BBBBbbbb 1404 leal (rPC,%ecx,2),%ecx # ecx<- PC + BBBBbbbb*2 1405 GET_VREG_R %eax rINST 1406 EXPORT_PC 1407 movl %eax,OUT_ARG0(%esp) 1408 movl %ecx,OUT_ARG1(%esp) 1409 SPILL(rIBASE) 1410 call dvmInterpHandleFillArrayData 1411 UNSPILL(rIBASE) 1412 FETCH_INST_OPCODE 3 %ecx 1413 testl %eax,%eax # exception thrown? 1414 je common_exceptionThrown 1415 ADVANCE_PC 3 1416 GOTO_NEXT_R %ecx 1417 1418/* ------------------------------ */ 1419.L_OP_THROW: /* 0x27 */ 1420/* File: x86/OP_THROW.S */ 1421 /* 1422 * Throw an exception object in the current thread. 1423 */ 1424 /* throw vAA */ 1425 EXPORT_PC 1426 GET_VREG_R %eax rINST # eax<- exception object 1427 movl rSELF,%ecx # ecx<- self 1428 testl %eax,%eax # null object? 1429 je common_errNullObject 1430 movl %eax,offThread_exception(%ecx) # thread->exception<- obj 1431 jmp common_exceptionThrown 1432 1433/* ------------------------------ */ 1434.L_OP_GOTO: /* 0x28 */ 1435/* File: x86/OP_GOTO.S */ 1436 /* 1437 * Unconditional branch, 8-bit offset. 1438 * 1439 * The branch distance is a signed code-unit offset, which we need to 1440 * double to get a byte offset. 1441 */ 1442 /* goto +AA */ 1443 movl rSELF,%ecx 1444 movsbl rINSTbl,%eax # eax<- ssssssAA 1445 movl offThread_curHandlerTable(%ecx),rIBASE 1446 FETCH_INST_INDEXED %eax 1447 ADVANCE_PC_INDEXED %eax 1448 GOTO_NEXT 1449 1450/* ------------------------------ */ 1451.L_OP_GOTO_16: /* 0x29 */ 1452/* File: x86/OP_GOTO_16.S */ 1453 /* 1454 * Unconditional branch, 16-bit offset. 1455 * 1456 * The branch distance is a signed code-unit offset 1457 */ 1458 /* goto/16 +AAAA */ 1459 movl rSELF,%ecx 1460 movswl 2(rPC),%eax # eax<- ssssAAAA 1461 movl offThread_curHandlerTable(%ecx),rIBASE 1462 FETCH_INST_INDEXED %eax 1463 ADVANCE_PC_INDEXED %eax 1464 GOTO_NEXT 1465 1466/* ------------------------------ */ 1467.L_OP_GOTO_32: /* 0x2a */ 1468/* File: x86/OP_GOTO_32.S */ 1469 /* 1470 * Unconditional branch, 32-bit offset. 1471 * 1472 * The branch distance is a signed code-unit offset. 1473 */ 1474 /* goto/32 AAAAAAAA */ 1475 movl rSELF,%ecx 1476 movl 2(rPC),%eax # eax<- AAAAAAAA 1477 movl offThread_curHandlerTable(%ecx),rIBASE 1478 FETCH_INST_INDEXED %eax 1479 ADVANCE_PC_INDEXED %eax 1480 GOTO_NEXT 1481 1482/* ------------------------------ */ 1483.L_OP_PACKED_SWITCH: /* 0x2b */ 1484/* File: x86/OP_PACKED_SWITCH.S */ 1485 /* 1486 * Handle a packed-switch or sparse-switch instruction. In both cases 1487 * we decode it and hand it off to a helper function. 1488 * 1489 * We don't really expect backward branches in a switch statement, but 1490 * they're perfectly legal, so we check for them here. 1491 * 1492 * for: packed-switch, sparse-switch 1493 */ 1494 /* op vAA, +BBBB */ 1495 movl 2(rPC),%ecx # ecx<- BBBBbbbb 1496 GET_VREG_R %eax rINST # eax<- vAA 1497 leal (rPC,%ecx,2),%ecx # ecx<- PC + BBBBbbbb*2 1498 movl %eax,OUT_ARG1(%esp) # ARG1<- vAA 1499 movl %ecx,OUT_ARG0(%esp) # ARG0<- switchData 1500 call dvmInterpHandlePackedSwitch 1501 movl rSELF,%ecx 1502 ADVANCE_PC_INDEXED %eax 1503 movl offThread_curHandlerTable(%ecx),rIBASE 1504 FETCH_INST 1505 GOTO_NEXT 1506 1507/* ------------------------------ */ 1508.L_OP_SPARSE_SWITCH: /* 0x2c */ 1509/* File: x86/OP_SPARSE_SWITCH.S */ 1510/* File: x86/OP_PACKED_SWITCH.S */ 1511 /* 1512 * Handle a packed-switch or sparse-switch instruction. In both cases 1513 * we decode it and hand it off to a helper function. 1514 * 1515 * We don't really expect backward branches in a switch statement, but 1516 * they're perfectly legal, so we check for them here. 1517 * 1518 * for: packed-switch, sparse-switch 1519 */ 1520 /* op vAA, +BBBB */ 1521 movl 2(rPC),%ecx # ecx<- BBBBbbbb 1522 GET_VREG_R %eax rINST # eax<- vAA 1523 leal (rPC,%ecx,2),%ecx # ecx<- PC + BBBBbbbb*2 1524 movl %eax,OUT_ARG1(%esp) # ARG1<- vAA 1525 movl %ecx,OUT_ARG0(%esp) # ARG0<- switchData 1526 call dvmInterpHandleSparseSwitch 1527 movl rSELF,%ecx 1528 ADVANCE_PC_INDEXED %eax 1529 movl offThread_curHandlerTable(%ecx),rIBASE 1530 FETCH_INST 1531 GOTO_NEXT 1532 1533 1534/* ------------------------------ */ 1535.L_OP_CMPL_FLOAT: /* 0x2d */ 1536/* File: x86/OP_CMPL_FLOAT.S */ 1537/* File: x86/OP_CMPG_DOUBLE.S */ 1538 /* float/double_cmp[gl] vAA, vBB, vCC */ 1539 movzbl 3(rPC),%eax # eax<- CC 1540 movzbl 2(rPC),%ecx # ecx<- BB 1541 .if 0 1542 fldl (rFP,%eax,4) 1543 fldl (rFP,%ecx,4) 1544 .else 1545 flds (rFP,%eax,4) 1546 flds (rFP,%ecx,4) 1547 .endif 1548 xorl %ecx,%ecx 1549 fucompp # z if equal, p set if NaN, c set if st0 < st1 1550 fnstsw %ax 1551 sahf 1552 FETCH_INST_OPCODE 2 %eax 1553 jp .LOP_CMPL_FLOAT_isNaN 1554 je .LOP_CMPL_FLOAT_finish 1555 sbbl %ecx,%ecx 1556 jb .LOP_CMPL_FLOAT_finish 1557 incl %ecx 1558.LOP_CMPL_FLOAT_finish: 1559 SET_VREG %ecx rINST 1560 ADVANCE_PC 2 1561 GOTO_NEXT_R %eax 1562 1563.LOP_CMPL_FLOAT_isNaN: 1564 movl $-1,%ecx 1565 jmp .LOP_CMPL_FLOAT_finish 1566 1567 1568/* ------------------------------ */ 1569.L_OP_CMPG_FLOAT: /* 0x2e */ 1570/* File: x86/OP_CMPG_FLOAT.S */ 1571/* File: x86/OP_CMPG_DOUBLE.S */ 1572 /* float/double_cmp[gl] vAA, vBB, vCC */ 1573 movzbl 3(rPC),%eax # eax<- CC 1574 movzbl 2(rPC),%ecx # ecx<- BB 1575 .if 0 1576 fldl (rFP,%eax,4) 1577 fldl (rFP,%ecx,4) 1578 .else 1579 flds (rFP,%eax,4) 1580 flds (rFP,%ecx,4) 1581 .endif 1582 xorl %ecx,%ecx 1583 fucompp # z if equal, p set if NaN, c set if st0 < st1 1584 fnstsw %ax 1585 sahf 1586 FETCH_INST_OPCODE 2 %eax 1587 jp .LOP_CMPG_FLOAT_isNaN 1588 je .LOP_CMPG_FLOAT_finish 1589 sbbl %ecx,%ecx 1590 jb .LOP_CMPG_FLOAT_finish 1591 incl %ecx 1592.LOP_CMPG_FLOAT_finish: 1593 SET_VREG %ecx rINST 1594 ADVANCE_PC 2 1595 GOTO_NEXT_R %eax 1596 1597.LOP_CMPG_FLOAT_isNaN: 1598 movl $1,%ecx 1599 jmp .LOP_CMPG_FLOAT_finish 1600 1601 1602/* ------------------------------ */ 1603.L_OP_CMPL_DOUBLE: /* 0x2f */ 1604/* File: x86/OP_CMPL_DOUBLE.S */ 1605/* File: x86/OP_CMPG_DOUBLE.S */ 1606 /* float/double_cmp[gl] vAA, vBB, vCC */ 1607 movzbl 3(rPC),%eax # eax<- CC 1608 movzbl 2(rPC),%ecx # ecx<- BB 1609 .if 1 1610 fldl (rFP,%eax,4) 1611 fldl (rFP,%ecx,4) 1612 .else 1613 flds (rFP,%eax,4) 1614 flds (rFP,%ecx,4) 1615 .endif 1616 xorl %ecx,%ecx 1617 fucompp # z if equal, p set if NaN, c set if st0 < st1 1618 fnstsw %ax 1619 sahf 1620 FETCH_INST_OPCODE 2 %eax 1621 jp .LOP_CMPL_DOUBLE_isNaN 1622 je .LOP_CMPL_DOUBLE_finish 1623 sbbl %ecx,%ecx 1624 jb .LOP_CMPL_DOUBLE_finish 1625 incl %ecx 1626.LOP_CMPL_DOUBLE_finish: 1627 SET_VREG %ecx rINST 1628 ADVANCE_PC 2 1629 GOTO_NEXT_R %eax 1630 1631.LOP_CMPL_DOUBLE_isNaN: 1632 movl $-1,%ecx 1633 jmp .LOP_CMPL_DOUBLE_finish 1634 1635 1636/* ------------------------------ */ 1637.L_OP_CMPG_DOUBLE: /* 0x30 */ 1638/* File: x86/OP_CMPG_DOUBLE.S */ 1639 /* float/double_cmp[gl] vAA, vBB, vCC */ 1640 movzbl 3(rPC),%eax # eax<- CC 1641 movzbl 2(rPC),%ecx # ecx<- BB 1642 .if 1 1643 fldl (rFP,%eax,4) 1644 fldl (rFP,%ecx,4) 1645 .else 1646 flds (rFP,%eax,4) 1647 flds (rFP,%ecx,4) 1648 .endif 1649 xorl %ecx,%ecx 1650 fucompp # z if equal, p set if NaN, c set if st0 < st1 1651 fnstsw %ax 1652 sahf 1653 FETCH_INST_OPCODE 2 %eax 1654 jp .LOP_CMPG_DOUBLE_isNaN 1655 je .LOP_CMPG_DOUBLE_finish 1656 sbbl %ecx,%ecx 1657 jb .LOP_CMPG_DOUBLE_finish 1658 incl %ecx 1659.LOP_CMPG_DOUBLE_finish: 1660 SET_VREG %ecx rINST 1661 ADVANCE_PC 2 1662 GOTO_NEXT_R %eax 1663 1664.LOP_CMPG_DOUBLE_isNaN: 1665 movl $1,%ecx 1666 jmp .LOP_CMPG_DOUBLE_finish 1667 1668/* ------------------------------ */ 1669.L_OP_CMP_LONG: /* 0x31 */ 1670/* File: x86/OP_CMP_LONG.S */ 1671 /* 1672 * Compare two 64-bit values. Puts 0, 1, or -1 into the destination 1673 * register based on the results of the comparison. 1674 */ 1675 // TUNING: rework to avoid rIBASE spill 1676 /* cmp-long vAA, vBB, vCC */ 1677 movzbl 2(rPC),%ecx # ecx<- BB 1678 SPILL(rIBASE) 1679 movzbl 3(rPC),rIBASE # rIBASE- CC 1680 GET_VREG_WORD %eax %ecx,1 # eax<- v[BB+1] 1681 GET_VREG_WORD %ecx %ecx 0 # ecx<- v[BB+0] 1682 cmpl 4(rFP,rIBASE,4),%eax 1683 jl .LOP_CMP_LONG_smaller 1684 jg .LOP_CMP_LONG_bigger 1685 sub (rFP,rIBASE,4),%ecx 1686 ja .LOP_CMP_LONG_bigger 1687 jb .LOP_CMP_LONG_smaller 1688 SET_VREG %ecx rINST 1689 FETCH_INST_OPCODE 2 %ecx 1690 UNSPILL(rIBASE) 1691 ADVANCE_PC 2 1692 GOTO_NEXT_R %ecx 1693 1694.LOP_CMP_LONG_bigger: 1695 movl $1,%ecx 1696 SET_VREG %ecx rINST 1697 FETCH_INST_OPCODE 2 %ecx 1698 UNSPILL(rIBASE) 1699 ADVANCE_PC 2 1700 GOTO_NEXT_R %ecx 1701 1702.LOP_CMP_LONG_smaller: 1703 movl $-1,%ecx 1704 SET_VREG %ecx rINST 1705 FETCH_INST_OPCODE 2 %ecx 1706 UNSPILL(rIBASE) 1707 ADVANCE_PC 2 1708 GOTO_NEXT_R %ecx 1709 1710/* ------------------------------ */ 1711.L_OP_IF_EQ: /* 0x32 */ 1712/* File: x86/OP_IF_EQ.S */ 1713/* File: x86/bincmp.S */ 1714 /* 1715 * Generic two-operand compare-and-branch operation. Provide a "revcmp" 1716 * fragment that specifies the *reverse* comparison to perform, e.g. 1717 * for "if-le" you would use "gt". 1718 * 1719 * For: if-eq, if-ne, if-lt, if-ge, if-gt, if-le 1720 */ 1721 /* if-cmp vA, vB, +CCCC */ 1722 movzx rINSTbl,%ecx # ecx <- A+ 1723 andb $0xf,%cl # ecx <- A 1724 GET_VREG_R %eax %ecx # eax <- vA 1725 sarl $4,rINST # rINST<- B 1726 movl rSELF,%ecx 1727 cmpl (rFP,rINST,4),%eax # compare (vA, vB) 1728 movl $2,%eax # assume not taken 1729 jne 1f 1730 movswl 2(rPC),%eax # Get signed branch offset 17311: 1732 movl offThread_curHandlerTable(%ecx),rIBASE 1733 FETCH_INST_INDEXED %eax 1734 ADVANCE_PC_INDEXED %eax 1735 GOTO_NEXT 1736 1737 1738/* ------------------------------ */ 1739.L_OP_IF_NE: /* 0x33 */ 1740/* File: x86/OP_IF_NE.S */ 1741/* File: x86/bincmp.S */ 1742 /* 1743 * Generic two-operand compare-and-branch operation. Provide a "revcmp" 1744 * fragment that specifies the *reverse* comparison to perform, e.g. 1745 * for "if-le" you would use "gt". 1746 * 1747 * For: if-eq, if-ne, if-lt, if-ge, if-gt, if-le 1748 */ 1749 /* if-cmp vA, vB, +CCCC */ 1750 movzx rINSTbl,%ecx # ecx <- A+ 1751 andb $0xf,%cl # ecx <- A 1752 GET_VREG_R %eax %ecx # eax <- vA 1753 sarl $4,rINST # rINST<- B 1754 movl rSELF,%ecx 1755 cmpl (rFP,rINST,4),%eax # compare (vA, vB) 1756 movl $2,%eax # assume not taken 1757 je 1f 1758 movswl 2(rPC),%eax # Get signed branch offset 17591: 1760 movl offThread_curHandlerTable(%ecx),rIBASE 1761 FETCH_INST_INDEXED %eax 1762 ADVANCE_PC_INDEXED %eax 1763 GOTO_NEXT 1764 1765 1766/* ------------------------------ */ 1767.L_OP_IF_LT: /* 0x34 */ 1768/* File: x86/OP_IF_LT.S */ 1769/* File: x86/bincmp.S */ 1770 /* 1771 * Generic two-operand compare-and-branch operation. Provide a "revcmp" 1772 * fragment that specifies the *reverse* comparison to perform, e.g. 1773 * for "if-le" you would use "gt". 1774 * 1775 * For: if-eq, if-ne, if-lt, if-ge, if-gt, if-le 1776 */ 1777 /* if-cmp vA, vB, +CCCC */ 1778 movzx rINSTbl,%ecx # ecx <- A+ 1779 andb $0xf,%cl # ecx <- A 1780 GET_VREG_R %eax %ecx # eax <- vA 1781 sarl $4,rINST # rINST<- B 1782 movl rSELF,%ecx 1783 cmpl (rFP,rINST,4),%eax # compare (vA, vB) 1784 movl $2,%eax # assume not taken 1785 jge 1f 1786 movswl 2(rPC),%eax # Get signed branch offset 17871: 1788 movl offThread_curHandlerTable(%ecx),rIBASE 1789 FETCH_INST_INDEXED %eax 1790 ADVANCE_PC_INDEXED %eax 1791 GOTO_NEXT 1792 1793 1794/* ------------------------------ */ 1795.L_OP_IF_GE: /* 0x35 */ 1796/* File: x86/OP_IF_GE.S */ 1797/* File: x86/bincmp.S */ 1798 /* 1799 * Generic two-operand compare-and-branch operation. Provide a "revcmp" 1800 * fragment that specifies the *reverse* comparison to perform, e.g. 1801 * for "if-le" you would use "gt". 1802 * 1803 * For: if-eq, if-ne, if-lt, if-ge, if-gt, if-le 1804 */ 1805 /* if-cmp vA, vB, +CCCC */ 1806 movzx rINSTbl,%ecx # ecx <- A+ 1807 andb $0xf,%cl # ecx <- A 1808 GET_VREG_R %eax %ecx # eax <- vA 1809 sarl $4,rINST # rINST<- B 1810 movl rSELF,%ecx 1811 cmpl (rFP,rINST,4),%eax # compare (vA, vB) 1812 movl $2,%eax # assume not taken 1813 jl 1f 1814 movswl 2(rPC),%eax # Get signed branch offset 18151: 1816 movl offThread_curHandlerTable(%ecx),rIBASE 1817 FETCH_INST_INDEXED %eax 1818 ADVANCE_PC_INDEXED %eax 1819 GOTO_NEXT 1820 1821 1822/* ------------------------------ */ 1823.L_OP_IF_GT: /* 0x36 */ 1824/* File: x86/OP_IF_GT.S */ 1825/* File: x86/bincmp.S */ 1826 /* 1827 * Generic two-operand compare-and-branch operation. Provide a "revcmp" 1828 * fragment that specifies the *reverse* comparison to perform, e.g. 1829 * for "if-le" you would use "gt". 1830 * 1831 * For: if-eq, if-ne, if-lt, if-ge, if-gt, if-le 1832 */ 1833 /* if-cmp vA, vB, +CCCC */ 1834 movzx rINSTbl,%ecx # ecx <- A+ 1835 andb $0xf,%cl # ecx <- A 1836 GET_VREG_R %eax %ecx # eax <- vA 1837 sarl $4,rINST # rINST<- B 1838 movl rSELF,%ecx 1839 cmpl (rFP,rINST,4),%eax # compare (vA, vB) 1840 movl $2,%eax # assume not taken 1841 jle 1f 1842 movswl 2(rPC),%eax # Get signed branch offset 18431: 1844 movl offThread_curHandlerTable(%ecx),rIBASE 1845 FETCH_INST_INDEXED %eax 1846 ADVANCE_PC_INDEXED %eax 1847 GOTO_NEXT 1848 1849 1850/* ------------------------------ */ 1851.L_OP_IF_LE: /* 0x37 */ 1852/* File: x86/OP_IF_LE.S */ 1853/* File: x86/bincmp.S */ 1854 /* 1855 * Generic two-operand compare-and-branch operation. Provide a "revcmp" 1856 * fragment that specifies the *reverse* comparison to perform, e.g. 1857 * for "if-le" you would use "gt". 1858 * 1859 * For: if-eq, if-ne, if-lt, if-ge, if-gt, if-le 1860 */ 1861 /* if-cmp vA, vB, +CCCC */ 1862 movzx rINSTbl,%ecx # ecx <- A+ 1863 andb $0xf,%cl # ecx <- A 1864 GET_VREG_R %eax %ecx # eax <- vA 1865 sarl $4,rINST # rINST<- B 1866 movl rSELF,%ecx 1867 cmpl (rFP,rINST,4),%eax # compare (vA, vB) 1868 movl $2,%eax # assume not taken 1869 jg 1f 1870 movswl 2(rPC),%eax # Get signed branch offset 18711: 1872 movl offThread_curHandlerTable(%ecx),rIBASE 1873 FETCH_INST_INDEXED %eax 1874 ADVANCE_PC_INDEXED %eax 1875 GOTO_NEXT 1876 1877 1878/* ------------------------------ */ 1879.L_OP_IF_EQZ: /* 0x38 */ 1880/* File: x86/OP_IF_EQZ.S */ 1881/* File: x86/zcmp.S */ 1882 /* 1883 * Generic one-operand compare-and-branch operation. Provide a "revcmp" 1884 * fragment that specifies the *reverse* comparison to perform, e.g. 1885 * for "if-le" you would use "gt". 1886 * 1887 * for: if-eqz, if-nez, if-ltz, if-gez, if-gtz, if-lez 1888 */ 1889 /* if-cmp vAA, +BBBB */ 1890 cmpl $0,(rFP,rINST,4) # compare (vA, 0) 1891 movl $2,%eax # assume branch not taken 1892 jne 1f 1893 movl rSELF,%ecx 1894 movswl 2(rPC),%eax # fetch signed displacement 1895 movl offThread_curHandlerTable(%ecx),rIBASE 18961: 1897 FETCH_INST_INDEXED %eax 1898 ADVANCE_PC_INDEXED %eax 1899 GOTO_NEXT 1900 1901 1902/* ------------------------------ */ 1903.L_OP_IF_NEZ: /* 0x39 */ 1904/* File: x86/OP_IF_NEZ.S */ 1905/* File: x86/zcmp.S */ 1906 /* 1907 * Generic one-operand compare-and-branch operation. Provide a "revcmp" 1908 * fragment that specifies the *reverse* comparison to perform, e.g. 1909 * for "if-le" you would use "gt". 1910 * 1911 * for: if-eqz, if-nez, if-ltz, if-gez, if-gtz, if-lez 1912 */ 1913 /* if-cmp vAA, +BBBB */ 1914 cmpl $0,(rFP,rINST,4) # compare (vA, 0) 1915 movl $2,%eax # assume branch not taken 1916 je 1f 1917 movl rSELF,%ecx 1918 movswl 2(rPC),%eax # fetch signed displacement 1919 movl offThread_curHandlerTable(%ecx),rIBASE 19201: 1921 FETCH_INST_INDEXED %eax 1922 ADVANCE_PC_INDEXED %eax 1923 GOTO_NEXT 1924 1925 1926/* ------------------------------ */ 1927.L_OP_IF_LTZ: /* 0x3a */ 1928/* File: x86/OP_IF_LTZ.S */ 1929/* File: x86/zcmp.S */ 1930 /* 1931 * Generic one-operand compare-and-branch operation. Provide a "revcmp" 1932 * fragment that specifies the *reverse* comparison to perform, e.g. 1933 * for "if-le" you would use "gt". 1934 * 1935 * for: if-eqz, if-nez, if-ltz, if-gez, if-gtz, if-lez 1936 */ 1937 /* if-cmp vAA, +BBBB */ 1938 cmpl $0,(rFP,rINST,4) # compare (vA, 0) 1939 movl $2,%eax # assume branch not taken 1940 jge 1f 1941 movl rSELF,%ecx 1942 movswl 2(rPC),%eax # fetch signed displacement 1943 movl offThread_curHandlerTable(%ecx),rIBASE 19441: 1945 FETCH_INST_INDEXED %eax 1946 ADVANCE_PC_INDEXED %eax 1947 GOTO_NEXT 1948 1949 1950/* ------------------------------ */ 1951.L_OP_IF_GEZ: /* 0x3b */ 1952/* File: x86/OP_IF_GEZ.S */ 1953/* File: x86/zcmp.S */ 1954 /* 1955 * Generic one-operand compare-and-branch operation. Provide a "revcmp" 1956 * fragment that specifies the *reverse* comparison to perform, e.g. 1957 * for "if-le" you would use "gt". 1958 * 1959 * for: if-eqz, if-nez, if-ltz, if-gez, if-gtz, if-lez 1960 */ 1961 /* if-cmp vAA, +BBBB */ 1962 cmpl $0,(rFP,rINST,4) # compare (vA, 0) 1963 movl $2,%eax # assume branch not taken 1964 jl 1f 1965 movl rSELF,%ecx 1966 movswl 2(rPC),%eax # fetch signed displacement 1967 movl offThread_curHandlerTable(%ecx),rIBASE 19681: 1969 FETCH_INST_INDEXED %eax 1970 ADVANCE_PC_INDEXED %eax 1971 GOTO_NEXT 1972 1973 1974/* ------------------------------ */ 1975.L_OP_IF_GTZ: /* 0x3c */ 1976/* File: x86/OP_IF_GTZ.S */ 1977/* File: x86/zcmp.S */ 1978 /* 1979 * Generic one-operand compare-and-branch operation. Provide a "revcmp" 1980 * fragment that specifies the *reverse* comparison to perform, e.g. 1981 * for "if-le" you would use "gt". 1982 * 1983 * for: if-eqz, if-nez, if-ltz, if-gez, if-gtz, if-lez 1984 */ 1985 /* if-cmp vAA, +BBBB */ 1986 cmpl $0,(rFP,rINST,4) # compare (vA, 0) 1987 movl $2,%eax # assume branch not taken 1988 jle 1f 1989 movl rSELF,%ecx 1990 movswl 2(rPC),%eax # fetch signed displacement 1991 movl offThread_curHandlerTable(%ecx),rIBASE 19921: 1993 FETCH_INST_INDEXED %eax 1994 ADVANCE_PC_INDEXED %eax 1995 GOTO_NEXT 1996 1997 1998/* ------------------------------ */ 1999.L_OP_IF_LEZ: /* 0x3d */ 2000/* File: x86/OP_IF_LEZ.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 movl $2,%eax # assume branch not taken 2012 jg 1f 2013 movl rSELF,%ecx 2014 movswl 2(rPC),%eax # fetch signed displacement 2015 movl offThread_curHandlerTable(%ecx),rIBASE 20161: 2017 FETCH_INST_INDEXED %eax 2018 ADVANCE_PC_INDEXED %eax 2019 GOTO_NEXT 2020 2021 2022/* ------------------------------ */ 2023.L_OP_UNUSED_3E: /* 0x3e */ 2024/* File: x86/OP_UNUSED_3E.S */ 2025/* File: x86/unused.S */ 2026 jmp common_abort 2027 2028 2029/* ------------------------------ */ 2030.L_OP_UNUSED_3F: /* 0x3f */ 2031/* File: x86/OP_UNUSED_3F.S */ 2032/* File: x86/unused.S */ 2033 jmp common_abort 2034 2035 2036/* ------------------------------ */ 2037.L_OP_UNUSED_40: /* 0x40 */ 2038/* File: x86/OP_UNUSED_40.S */ 2039/* File: x86/unused.S */ 2040 jmp common_abort 2041 2042 2043/* ------------------------------ */ 2044.L_OP_UNUSED_41: /* 0x41 */ 2045/* File: x86/OP_UNUSED_41.S */ 2046/* File: x86/unused.S */ 2047 jmp common_abort 2048 2049 2050/* ------------------------------ */ 2051.L_OP_UNUSED_42: /* 0x42 */ 2052/* File: x86/OP_UNUSED_42.S */ 2053/* File: x86/unused.S */ 2054 jmp common_abort 2055 2056 2057/* ------------------------------ */ 2058.L_OP_UNUSED_43: /* 0x43 */ 2059/* File: x86/OP_UNUSED_43.S */ 2060/* File: x86/unused.S */ 2061 jmp common_abort 2062 2063 2064/* ------------------------------ */ 2065.L_OP_AGET: /* 0x44 */ 2066/* File: x86/OP_AGET.S */ 2067 /* 2068 * Array get, 32 bits or less. vAA <- vBB[vCC]. 2069 * 2070 * for: aget, aget-object, aget-boolean, aget-byte, aget-char, aget-short 2071 */ 2072 /* op vAA, vBB, vCC */ 2073 movzbl 2(rPC),%eax # eax<- BB 2074 movzbl 3(rPC),%ecx # ecx<- CC 2075 GET_VREG_R %eax %eax # eax<- vBB (array object) 2076 GET_VREG_R %ecx %ecx # ecs<- vCC (requested index) 2077 testl %eax,%eax # null array object? 2078 je common_errNullObject # bail if so 2079 cmpl offArrayObject_length(%eax),%ecx 2080 jae common_errArrayIndex # index >= length, bail. Expects 2081 # arrayObj in eax 2082 # index in ecx 2083 movl offArrayObject_contents(%eax,%ecx,4),%eax 2084.LOP_AGET_finish: 2085 FETCH_INST_OPCODE 2 %ecx 2086 SET_VREG %eax rINST 2087 ADVANCE_PC 2 2088 GOTO_NEXT_R %ecx 2089 2090/* ------------------------------ */ 2091.L_OP_AGET_WIDE: /* 0x45 */ 2092/* File: x86/OP_AGET_WIDE.S */ 2093 /* 2094 * Array get, 64 bits. vAA <- vBB[vCC]. 2095 * 2096 */ 2097 /* op vAA, vBB, vCC */ 2098 movzbl 2(rPC),%eax # eax<- BB 2099 movzbl 3(rPC),%ecx # ecx<- CC 2100 GET_VREG_R %eax %eax # eax<- vBB (array object) 2101 GET_VREG_R %ecx %ecx # ecs<- vCC (requested index) 2102 testl %eax,%eax # null array object? 2103 je common_errNullObject # bail if so 2104 cmpl offArrayObject_length(%eax),%ecx 2105 jae common_errArrayIndex # index >= length, bail. Expects 2106 # arrayObj in eax 2107 # index in ecx 2108 leal offArrayObject_contents(%eax,%ecx,8),%eax 2109 movl (%eax),%ecx 2110 movl 4(%eax),%eax 2111 SET_VREG_WORD %ecx rINST 0 2112 SET_VREG_WORD %eax rINST 1 2113 FETCH_INST_OPCODE 2 %ecx 2114 ADVANCE_PC 2 2115 GOTO_NEXT_R %ecx 2116 2117/* ------------------------------ */ 2118.L_OP_AGET_OBJECT: /* 0x46 */ 2119/* File: x86/OP_AGET_OBJECT.S */ 2120/* File: x86/OP_AGET.S */ 2121 /* 2122 * Array get, 32 bits or less. vAA <- vBB[vCC]. 2123 * 2124 * for: aget, aget-object, aget-boolean, aget-byte, aget-char, aget-short 2125 */ 2126 /* op vAA, vBB, vCC */ 2127 movzbl 2(rPC),%eax # eax<- BB 2128 movzbl 3(rPC),%ecx # ecx<- CC 2129 GET_VREG_R %eax %eax # eax<- vBB (array object) 2130 GET_VREG_R %ecx %ecx # ecs<- vCC (requested index) 2131 testl %eax,%eax # null array object? 2132 je common_errNullObject # bail if so 2133 cmpl offArrayObject_length(%eax),%ecx 2134 jae common_errArrayIndex # index >= length, bail. Expects 2135 # arrayObj in eax 2136 # index in ecx 2137 movl offArrayObject_contents(%eax,%ecx,4),%eax 2138.LOP_AGET_OBJECT_finish: 2139 FETCH_INST_OPCODE 2 %ecx 2140 SET_VREG %eax rINST 2141 ADVANCE_PC 2 2142 GOTO_NEXT_R %ecx 2143 2144 2145/* ------------------------------ */ 2146.L_OP_AGET_BOOLEAN: /* 0x47 */ 2147/* File: x86/OP_AGET_BOOLEAN.S */ 2148/* File: x86/OP_AGET.S */ 2149 /* 2150 * Array get, 32 bits or less. vAA <- vBB[vCC]. 2151 * 2152 * for: aget, aget-object, aget-boolean, aget-byte, aget-char, aget-short 2153 */ 2154 /* op vAA, vBB, vCC */ 2155 movzbl 2(rPC),%eax # eax<- BB 2156 movzbl 3(rPC),%ecx # ecx<- CC 2157 GET_VREG_R %eax %eax # eax<- vBB (array object) 2158 GET_VREG_R %ecx %ecx # ecs<- vCC (requested index) 2159 testl %eax,%eax # null array object? 2160 je common_errNullObject # bail if so 2161 cmpl offArrayObject_length(%eax),%ecx 2162 jae common_errArrayIndex # index >= length, bail. Expects 2163 # arrayObj in eax 2164 # index in ecx 2165 movzbl offArrayObject_contents(%eax,%ecx,1),%eax 2166.LOP_AGET_BOOLEAN_finish: 2167 FETCH_INST_OPCODE 2 %ecx 2168 SET_VREG %eax rINST 2169 ADVANCE_PC 2 2170 GOTO_NEXT_R %ecx 2171 2172 2173/* ------------------------------ */ 2174.L_OP_AGET_BYTE: /* 0x48 */ 2175/* File: x86/OP_AGET_BYTE.S */ 2176/* File: x86/OP_AGET.S */ 2177 /* 2178 * Array get, 32 bits or less. vAA <- vBB[vCC]. 2179 * 2180 * for: aget, aget-object, aget-boolean, aget-byte, aget-char, aget-short 2181 */ 2182 /* op vAA, vBB, vCC */ 2183 movzbl 2(rPC),%eax # eax<- BB 2184 movzbl 3(rPC),%ecx # ecx<- CC 2185 GET_VREG_R %eax %eax # eax<- vBB (array object) 2186 GET_VREG_R %ecx %ecx # ecs<- vCC (requested index) 2187 testl %eax,%eax # null array object? 2188 je common_errNullObject # bail if so 2189 cmpl offArrayObject_length(%eax),%ecx 2190 jae common_errArrayIndex # index >= length, bail. Expects 2191 # arrayObj in eax 2192 # index in ecx 2193 movsbl offArrayObject_contents(%eax,%ecx,1),%eax 2194.LOP_AGET_BYTE_finish: 2195 FETCH_INST_OPCODE 2 %ecx 2196 SET_VREG %eax rINST 2197 ADVANCE_PC 2 2198 GOTO_NEXT_R %ecx 2199 2200 2201/* ------------------------------ */ 2202.L_OP_AGET_CHAR: /* 0x49 */ 2203/* File: x86/OP_AGET_CHAR.S */ 2204/* File: x86/OP_AGET.S */ 2205 /* 2206 * Array get, 32 bits or less. vAA <- vBB[vCC]. 2207 * 2208 * for: aget, aget-object, aget-boolean, aget-byte, aget-char, aget-short 2209 */ 2210 /* op vAA, vBB, vCC */ 2211 movzbl 2(rPC),%eax # eax<- BB 2212 movzbl 3(rPC),%ecx # ecx<- CC 2213 GET_VREG_R %eax %eax # eax<- vBB (array object) 2214 GET_VREG_R %ecx %ecx # ecs<- vCC (requested index) 2215 testl %eax,%eax # null array object? 2216 je common_errNullObject # bail if so 2217 cmpl offArrayObject_length(%eax),%ecx 2218 jae common_errArrayIndex # index >= length, bail. Expects 2219 # arrayObj in eax 2220 # index in ecx 2221 movzwl offArrayObject_contents(%eax,%ecx,2),%eax 2222.LOP_AGET_CHAR_finish: 2223 FETCH_INST_OPCODE 2 %ecx 2224 SET_VREG %eax rINST 2225 ADVANCE_PC 2 2226 GOTO_NEXT_R %ecx 2227 2228 2229/* ------------------------------ */ 2230.L_OP_AGET_SHORT: /* 0x4a */ 2231/* File: x86/OP_AGET_SHORT.S */ 2232/* File: x86/OP_AGET.S */ 2233 /* 2234 * Array get, 32 bits or less. vAA <- vBB[vCC]. 2235 * 2236 * for: aget, aget-object, aget-boolean, aget-byte, aget-char, aget-short 2237 */ 2238 /* op vAA, vBB, vCC */ 2239 movzbl 2(rPC),%eax # eax<- BB 2240 movzbl 3(rPC),%ecx # ecx<- CC 2241 GET_VREG_R %eax %eax # eax<- vBB (array object) 2242 GET_VREG_R %ecx %ecx # ecs<- vCC (requested index) 2243 testl %eax,%eax # null array object? 2244 je common_errNullObject # bail if so 2245 cmpl offArrayObject_length(%eax),%ecx 2246 jae common_errArrayIndex # index >= length, bail. Expects 2247 # arrayObj in eax 2248 # index in ecx 2249 movswl offArrayObject_contents(%eax,%ecx,2),%eax 2250.LOP_AGET_SHORT_finish: 2251 FETCH_INST_OPCODE 2 %ecx 2252 SET_VREG %eax rINST 2253 ADVANCE_PC 2 2254 GOTO_NEXT_R %ecx 2255 2256 2257/* ------------------------------ */ 2258.L_OP_APUT: /* 0x4b */ 2259/* File: x86/OP_APUT.S */ 2260 /* 2261 * Array put, 32 bits or less. vBB[vCC] <- vAA 2262 * 2263 * for: aput, aput-object, aput-boolean, aput-byte, aput-char, aput-short 2264 */ 2265 /* op vAA, vBB, vCC */ 2266 movzbl 2(rPC),%eax # eax<- BB 2267 movzbl 3(rPC),%ecx # ecx<- CC 2268 GET_VREG_R %eax %eax # eax<- vBB (array object) 2269 GET_VREG_R %ecx %ecx # ecs<- vCC (requested index) 2270 testl %eax,%eax # null array object? 2271 je common_errNullObject # bail if so 2272 cmpl offArrayObject_length(%eax),%ecx 2273 jae common_errArrayIndex # index >= length, bail. Expects: 2274 # arrayObj in eax 2275 # index in ecx 2276 leal offArrayObject_contents(%eax,%ecx,4),%eax 2277.LOP_APUT_finish: 2278 GET_VREG_R rINST rINST 2279 FETCH_INST_OPCODE 2 %ecx 2280 movl rINST,(%eax) 2281 ADVANCE_PC 2 2282 GOTO_NEXT_R %ecx 2283 2284/* ------------------------------ */ 2285.L_OP_APUT_WIDE: /* 0x4c */ 2286/* File: x86/OP_APUT_WIDE.S */ 2287 /* 2288 * Array put, 64 bits. vBB[vCC]<-vAA. 2289 * 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,8),%eax 2303 GET_VREG_WORD %ecx rINST 0 2304 GET_VREG_WORD rINST rINST 1 2305 movl %ecx,(%eax) 2306 FETCH_INST_OPCODE 2 %ecx 2307 movl rINST,4(%eax) 2308 ADVANCE_PC 2 2309 GOTO_NEXT_R %ecx 2310 2311/* ------------------------------ */ 2312.L_OP_APUT_OBJECT: /* 0x4d */ 2313/* File: x86/OP_APUT_OBJECT.S */ 2314 /* 2315 * Array put, 32 bits or less. vBB[vCC] <- vAA 2316 * 2317 * for: aput, aput-object, aput-boolean, aput-byte, aput-char, aput-short 2318 */ 2319 /* op vAA, vBB, vCC */ 2320 movzbl 2(rPC),%eax # eax<- BB 2321 movzbl 3(rPC),%ecx # ecx<- CC 2322 GET_VREG_R %eax %eax # eax<- vBB (array object) 2323 GET_VREG_R %ecx %ecx # ecs<- vCC (requested index) 2324 GET_VREG_R rINST rINST # rINST<- vAA 2325 testl %eax,%eax # null array object? 2326 je common_errNullObject # bail if so 2327 cmpl offArrayObject_length(%eax),%ecx 2328 jae common_errArrayIndex # index >= length, bail. Expects 2329 # arrayObj in eax 2330 # index in ecx 2331 /* On entry: 2332 * eax<- array object 2333 * ecx<- index 2334 * rINST<- vAA 2335 */ 2336 leal offArrayObject_contents(%eax,%ecx,4),%ecx 2337 testl rINST,rINST # storing null reference? 2338 je .LOP_APUT_OBJECT_skip_check 2339 SPILL_TMP1(%ecx) # save target address 2340 SPILL_TMP2(%eax) # save object head 2341 movl offObject_clazz(%eax),%eax # eax<- arrayObj->clazz 2342 movl offObject_clazz(rINST),%ecx # ecx<- obj->clazz 2343 movl %eax,OUT_ARG1(%esp) 2344 movl %ecx,OUT_ARG0(%esp) 2345 movl %ecx,sReg0 # store the two classes for later 2346 movl %eax,sReg1 2347 SPILL(rIBASE) 2348 call dvmCanPutArrayElement # test object type vs. array type 2349 UNSPILL(rIBASE) 2350 UNSPILL_TMP1(%ecx) # recover target address 2351 testl %eax,%eax 2352 movl rSELF,%eax 2353 jne .LOP_APUT_OBJECT_types_okay 2354 2355 # The types don't match. We need to throw an ArrayStoreException. 2356 EXPORT_PC 2357 movl sReg0,%eax # restore the two classes... 2358 movl %eax,OUT_ARG0(%esp) 2359 movl sReg1,%ecx 2360 movl %ecx,OUT_ARG1(%esp) 2361 call dvmThrowArrayStoreExceptionIncompatibleElement # ...and throw 2362 jmp common_exceptionThrown 2363 2364.LOP_APUT_OBJECT_types_okay: 2365 movl offThread_cardTable(%eax),%eax # get card table base 2366 movl rINST,(%ecx) # store into array 2367 UNSPILL_TMP2(rINST) # recover object head 2368 FETCH_INST_OPCODE 2 %ecx 2369 shrl $GC_CARD_SHIFT,rINST # object head to card number 2370 movb %al,(%eax,rINST) # mark card using object head 2371 ADVANCE_PC 2 2372 GOTO_NEXT_R %ecx 2373 2374.LOP_APUT_OBJECT_skip_check: 2375 movl rINST,(%ecx) 2376 FETCH_INST_OPCODE 2 %ecx 2377 ADVANCE_PC 2 2378 GOTO_NEXT_R %ecx 2379 2380/* ------------------------------ */ 2381.L_OP_APUT_BOOLEAN: /* 0x4e */ 2382/* File: x86/OP_APUT_BOOLEAN.S */ 2383/* File: x86/OP_APUT.S */ 2384 /* 2385 * Array put, 32 bits or less. vBB[vCC] <- vAA 2386 * 2387 * for: aput, aput-object, aput-boolean, aput-byte, aput-char, aput-short 2388 */ 2389 /* op vAA, vBB, vCC */ 2390 movzbl 2(rPC),%eax # eax<- BB 2391 movzbl 3(rPC),%ecx # ecx<- CC 2392 GET_VREG_R %eax %eax # eax<- vBB (array object) 2393 GET_VREG_R %ecx %ecx # ecs<- vCC (requested index) 2394 testl %eax,%eax # null array object? 2395 je common_errNullObject # bail if so 2396 cmpl offArrayObject_length(%eax),%ecx 2397 jae common_errArrayIndex # index >= length, bail. Expects: 2398 # arrayObj in eax 2399 # index in ecx 2400 leal offArrayObject_contents(%eax,%ecx,1),%eax 2401.LOP_APUT_BOOLEAN_finish: 2402 GET_VREG_R rINST rINST 2403 FETCH_INST_OPCODE 2 %ecx 2404 movb rINSTbl,(%eax) 2405 ADVANCE_PC 2 2406 GOTO_NEXT_R %ecx 2407 2408 2409/* ------------------------------ */ 2410.L_OP_APUT_BYTE: /* 0x4f */ 2411/* File: x86/OP_APUT_BYTE.S */ 2412/* File: x86/OP_APUT.S */ 2413 /* 2414 * Array put, 32 bits or less. vBB[vCC] <- vAA 2415 * 2416 * for: aput, aput-object, aput-boolean, aput-byte, aput-char, aput-short 2417 */ 2418 /* op vAA, vBB, vCC */ 2419 movzbl 2(rPC),%eax # eax<- BB 2420 movzbl 3(rPC),%ecx # ecx<- CC 2421 GET_VREG_R %eax %eax # eax<- vBB (array object) 2422 GET_VREG_R %ecx %ecx # ecs<- vCC (requested index) 2423 testl %eax,%eax # null array object? 2424 je common_errNullObject # bail if so 2425 cmpl offArrayObject_length(%eax),%ecx 2426 jae common_errArrayIndex # index >= length, bail. Expects: 2427 # arrayObj in eax 2428 # index in ecx 2429 leal offArrayObject_contents(%eax,%ecx,1),%eax 2430.LOP_APUT_BYTE_finish: 2431 GET_VREG_R rINST rINST 2432 FETCH_INST_OPCODE 2 %ecx 2433 movb rINSTbl,(%eax) 2434 ADVANCE_PC 2 2435 GOTO_NEXT_R %ecx 2436 2437 2438/* ------------------------------ */ 2439.L_OP_APUT_CHAR: /* 0x50 */ 2440/* File: x86/OP_APUT_CHAR.S */ 2441/* File: x86/OP_APUT.S */ 2442 /* 2443 * Array put, 32 bits or less. vBB[vCC] <- vAA 2444 * 2445 * for: aput, aput-object, aput-boolean, aput-byte, aput-char, aput-short 2446 */ 2447 /* op vAA, vBB, vCC */ 2448 movzbl 2(rPC),%eax # eax<- BB 2449 movzbl 3(rPC),%ecx # ecx<- CC 2450 GET_VREG_R %eax %eax # eax<- vBB (array object) 2451 GET_VREG_R %ecx %ecx # ecs<- vCC (requested index) 2452 testl %eax,%eax # null array object? 2453 je common_errNullObject # bail if so 2454 cmpl offArrayObject_length(%eax),%ecx 2455 jae common_errArrayIndex # index >= length, bail. Expects: 2456 # arrayObj in eax 2457 # index in ecx 2458 leal offArrayObject_contents(%eax,%ecx,2),%eax 2459.LOP_APUT_CHAR_finish: 2460 GET_VREG_R rINST rINST 2461 FETCH_INST_OPCODE 2 %ecx 2462 movw rINSTw,(%eax) 2463 ADVANCE_PC 2 2464 GOTO_NEXT_R %ecx 2465 2466 2467/* ------------------------------ */ 2468.L_OP_APUT_SHORT: /* 0x51 */ 2469/* File: x86/OP_APUT_SHORT.S */ 2470/* File: x86/OP_APUT.S */ 2471 /* 2472 * Array put, 32 bits or less. vBB[vCC] <- vAA 2473 * 2474 * for: aput, aput-object, aput-boolean, aput-byte, aput-char, aput-short 2475 */ 2476 /* op vAA, vBB, vCC */ 2477 movzbl 2(rPC),%eax # eax<- BB 2478 movzbl 3(rPC),%ecx # ecx<- CC 2479 GET_VREG_R %eax %eax # eax<- vBB (array object) 2480 GET_VREG_R %ecx %ecx # ecs<- vCC (requested index) 2481 testl %eax,%eax # null array object? 2482 je common_errNullObject # bail if so 2483 cmpl offArrayObject_length(%eax),%ecx 2484 jae common_errArrayIndex # index >= length, bail. Expects: 2485 # arrayObj in eax 2486 # index in ecx 2487 leal offArrayObject_contents(%eax,%ecx,2),%eax 2488.LOP_APUT_SHORT_finish: 2489 GET_VREG_R rINST rINST 2490 FETCH_INST_OPCODE 2 %ecx 2491 movw rINSTw,(%eax) 2492 ADVANCE_PC 2 2493 GOTO_NEXT_R %ecx 2494 2495 2496/* ------------------------------ */ 2497.L_OP_IGET: /* 0x52 */ 2498/* File: x86/OP_IGET.S */ 2499 /* 2500 * General 32-bit instance field get. 2501 * 2502 * for: iget, iget-object, iget-boolean, iget-byte, iget-char, iget-short 2503 */ 2504 /* op vA, vB, field@CCCC */ 2505 movl rSELF,%ecx 2506 SPILL(rIBASE) # preserve rIBASE 2507 movzwl 2(rPC),rIBASE # rIBASE<- 0000CCCC 2508 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex 2509 movzbl rINSTbl,%ecx # ecx<- BA 2510 sarl $4,%ecx # ecx<- B 2511 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields 2512 andb $0xf,rINSTbl # rINST<- A 2513 GET_VREG_R %ecx %ecx # ecx<- fp[B], the object ptr 2514 movl (%eax,rIBASE,4),%eax # resolved entry 2515 testl %eax,%eax # is resolved entry null? 2516 jne .LOP_IGET_finish # no, already resolved 2517 movl rIBASE,OUT_ARG1(%esp) # needed by dvmResolveInstField 2518 movl rSELF,rIBASE 2519 EXPORT_PC 2520 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method 2521 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz 2522 SPILL_TMP1(%ecx) # save obj pointer across call 2523 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz 2524 call dvmResolveInstField # ... to dvmResolveInstField 2525 UNSPILL_TMP1(%ecx) 2526 testl %eax,%eax # returns InstrField ptr 2527 jne .LOP_IGET_finish 2528 jmp common_exceptionThrown 2529 2530.LOP_IGET_finish: 2531 /* 2532 * Currently: 2533 * eax holds resolved field 2534 * ecx holds object 2535 * rINST holds A 2536 */ 2537 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field 2538 testl %ecx,%ecx # object null? 2539 je common_errNullObject # object was null 2540 movl (%ecx,%eax,1),%ecx # ecx<- obj.field (8/16/32 bits) 2541 FETCH_INST_OPCODE 2 %eax 2542 UNSPILL(rIBASE) 2543 SET_VREG %ecx rINST 2544 ADVANCE_PC 2 2545 GOTO_NEXT_R %eax 2546 2547/* ------------------------------ */ 2548.L_OP_IGET_WIDE: /* 0x53 */ 2549/* File: x86/OP_IGET_WIDE.S */ 2550 /* 2551 * 64-bit instance field get. 2552 * 2553 */ 2554 /* op vA, vB, field@CCCC */ 2555 movl rSELF,%ecx 2556 SPILL(rIBASE) # preserve rIBASE 2557 movzwl 2(rPC),rIBASE # rIBASE<- 0000CCCC 2558 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex 2559 movzbl rINSTbl,%ecx # ecx<- BA 2560 sarl $4,%ecx # ecx<- B 2561 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields 2562 andb $0xf,rINSTbl # rINST<- A 2563 GET_VREG_R %ecx %ecx # ecx<- fp[B], the object ptr 2564 movl (%eax,rIBASE,4),%eax # resolved entry 2565 testl %eax,%eax # is resolved entry null? 2566 jne .LOP_IGET_WIDE_finish # no, already resolved 2567 movl rIBASE,OUT_ARG1(%esp) # for dvmResolveInstField 2568 movl rSELF,rIBASE 2569 EXPORT_PC 2570 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method 2571 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz 2572 SPILL_TMP1(%ecx) # save objpointer across call 2573 movl rPC,OUT_ARG0(%esp) # pass in method->clazz 2574 call dvmResolveInstField # ... to dvmResolveInstField 2575 UNSPILL_TMP1(%ecx) 2576 testl %eax,%eax # returns InstrField ptr 2577 jne .LOP_IGET_WIDE_finish 2578 jmp common_exceptionThrown 2579 2580.LOP_IGET_WIDE_finish: 2581 /* 2582 * Currently: 2583 * eax holds resolved field 2584 * ecx holds object 2585 * rINST holds A 2586 */ 2587 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field 2588 testl %ecx,%ecx # object null? 2589 je common_errNullObject # object was null 2590 leal (%ecx,%eax,1),%eax # eax<- address of field 2591 movl (%eax),%ecx # ecx<- lsw 2592 movl 4(%eax),%eax # eax<- msw 2593 SET_VREG_WORD %ecx rINST 0 2594 FETCH_INST_OPCODE 2 %ecx 2595 UNSPILL(rIBASE) # restore rIBASE 2596 SET_VREG_WORD %eax rINST 1 2597 ADVANCE_PC 2 2598 GOTO_NEXT_R %ecx 2599 2600/* ------------------------------ */ 2601.L_OP_IGET_OBJECT: /* 0x54 */ 2602/* File: x86/OP_IGET_OBJECT.S */ 2603/* File: x86/OP_IGET.S */ 2604 /* 2605 * General 32-bit instance field get. 2606 * 2607 * for: iget, iget-object, iget-boolean, iget-byte, iget-char, iget-short 2608 */ 2609 /* op vA, vB, field@CCCC */ 2610 movl rSELF,%ecx 2611 SPILL(rIBASE) # preserve rIBASE 2612 movzwl 2(rPC),rIBASE # rIBASE<- 0000CCCC 2613 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex 2614 movzbl rINSTbl,%ecx # ecx<- BA 2615 sarl $4,%ecx # ecx<- B 2616 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields 2617 andb $0xf,rINSTbl # rINST<- A 2618 GET_VREG_R %ecx %ecx # ecx<- fp[B], the object ptr 2619 movl (%eax,rIBASE,4),%eax # resolved entry 2620 testl %eax,%eax # is resolved entry null? 2621 jne .LOP_IGET_OBJECT_finish # no, already resolved 2622 movl rIBASE,OUT_ARG1(%esp) # needed by dvmResolveInstField 2623 movl rSELF,rIBASE 2624 EXPORT_PC 2625 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method 2626 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz 2627 SPILL_TMP1(%ecx) # save obj pointer across call 2628 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz 2629 call dvmResolveInstField # ... to dvmResolveInstField 2630 UNSPILL_TMP1(%ecx) 2631 testl %eax,%eax # returns InstrField ptr 2632 jne .LOP_IGET_OBJECT_finish 2633 jmp common_exceptionThrown 2634 2635.LOP_IGET_OBJECT_finish: 2636 /* 2637 * Currently: 2638 * eax holds resolved field 2639 * ecx holds object 2640 * rINST holds A 2641 */ 2642 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field 2643 testl %ecx,%ecx # object null? 2644 je common_errNullObject # object was null 2645 movl (%ecx,%eax,1),%ecx # ecx<- obj.field (8/16/32 bits) 2646 FETCH_INST_OPCODE 2 %eax 2647 UNSPILL(rIBASE) 2648 SET_VREG %ecx rINST 2649 ADVANCE_PC 2 2650 GOTO_NEXT_R %eax 2651 2652 2653/* ------------------------------ */ 2654.L_OP_IGET_BOOLEAN: /* 0x55 */ 2655/* File: x86/OP_IGET_BOOLEAN.S */ 2656/* File: x86/OP_IGET.S */ 2657 /* 2658 * General 32-bit instance field get. 2659 * 2660 * for: iget, iget-object, iget-boolean, iget-byte, iget-char, iget-short 2661 */ 2662 /* op vA, vB, field@CCCC */ 2663 movl rSELF,%ecx 2664 SPILL(rIBASE) # preserve rIBASE 2665 movzwl 2(rPC),rIBASE # rIBASE<- 0000CCCC 2666 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex 2667 movzbl rINSTbl,%ecx # ecx<- BA 2668 sarl $4,%ecx # ecx<- B 2669 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields 2670 andb $0xf,rINSTbl # rINST<- A 2671 GET_VREG_R %ecx %ecx # ecx<- fp[B], the object ptr 2672 movl (%eax,rIBASE,4),%eax # resolved entry 2673 testl %eax,%eax # is resolved entry null? 2674 jne .LOP_IGET_BOOLEAN_finish # no, already resolved 2675 movl rIBASE,OUT_ARG1(%esp) # needed by dvmResolveInstField 2676 movl rSELF,rIBASE 2677 EXPORT_PC 2678 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method 2679 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz 2680 SPILL_TMP1(%ecx) # save obj pointer across call 2681 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz 2682 call dvmResolveInstField # ... to dvmResolveInstField 2683 UNSPILL_TMP1(%ecx) 2684 testl %eax,%eax # returns InstrField ptr 2685 jne .LOP_IGET_BOOLEAN_finish 2686 jmp common_exceptionThrown 2687 2688.LOP_IGET_BOOLEAN_finish: 2689 /* 2690 * Currently: 2691 * eax holds resolved field 2692 * ecx holds object 2693 * rINST holds A 2694 */ 2695 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field 2696 testl %ecx,%ecx # object null? 2697 je common_errNullObject # object was null 2698 movzbl (%ecx,%eax,1),%ecx # ecx<- obj.field (8/16/32 bits) 2699 FETCH_INST_OPCODE 2 %eax 2700 UNSPILL(rIBASE) 2701 SET_VREG %ecx rINST 2702 ADVANCE_PC 2 2703 GOTO_NEXT_R %eax 2704 2705 2706/* ------------------------------ */ 2707.L_OP_IGET_BYTE: /* 0x56 */ 2708/* File: x86/OP_IGET_BYTE.S */ 2709/* File: x86/OP_IGET.S */ 2710 /* 2711 * General 32-bit instance field get. 2712 * 2713 * for: iget, iget-object, iget-boolean, iget-byte, iget-char, iget-short 2714 */ 2715 /* op vA, vB, field@CCCC */ 2716 movl rSELF,%ecx 2717 SPILL(rIBASE) # preserve rIBASE 2718 movzwl 2(rPC),rIBASE # rIBASE<- 0000CCCC 2719 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex 2720 movzbl rINSTbl,%ecx # ecx<- BA 2721 sarl $4,%ecx # ecx<- B 2722 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields 2723 andb $0xf,rINSTbl # rINST<- A 2724 GET_VREG_R %ecx %ecx # ecx<- fp[B], the object ptr 2725 movl (%eax,rIBASE,4),%eax # resolved entry 2726 testl %eax,%eax # is resolved entry null? 2727 jne .LOP_IGET_BYTE_finish # no, already resolved 2728 movl rIBASE,OUT_ARG1(%esp) # needed by dvmResolveInstField 2729 movl rSELF,rIBASE 2730 EXPORT_PC 2731 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method 2732 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz 2733 SPILL_TMP1(%ecx) # save obj pointer across call 2734 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz 2735 call dvmResolveInstField # ... to dvmResolveInstField 2736 UNSPILL_TMP1(%ecx) 2737 testl %eax,%eax # returns InstrField ptr 2738 jne .LOP_IGET_BYTE_finish 2739 jmp common_exceptionThrown 2740 2741.LOP_IGET_BYTE_finish: 2742 /* 2743 * Currently: 2744 * eax holds resolved field 2745 * ecx holds object 2746 * rINST holds A 2747 */ 2748 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field 2749 testl %ecx,%ecx # object null? 2750 je common_errNullObject # object was null 2751 movsbl (%ecx,%eax,1),%ecx # ecx<- obj.field (8/16/32 bits) 2752 FETCH_INST_OPCODE 2 %eax 2753 UNSPILL(rIBASE) 2754 SET_VREG %ecx rINST 2755 ADVANCE_PC 2 2756 GOTO_NEXT_R %eax 2757 2758 2759/* ------------------------------ */ 2760.L_OP_IGET_CHAR: /* 0x57 */ 2761/* File: x86/OP_IGET_CHAR.S */ 2762/* File: x86/OP_IGET.S */ 2763 /* 2764 * General 32-bit instance field get. 2765 * 2766 * for: iget, iget-object, iget-boolean, iget-byte, iget-char, iget-short 2767 */ 2768 /* op vA, vB, field@CCCC */ 2769 movl rSELF,%ecx 2770 SPILL(rIBASE) # preserve rIBASE 2771 movzwl 2(rPC),rIBASE # rIBASE<- 0000CCCC 2772 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex 2773 movzbl rINSTbl,%ecx # ecx<- BA 2774 sarl $4,%ecx # ecx<- B 2775 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields 2776 andb $0xf,rINSTbl # rINST<- A 2777 GET_VREG_R %ecx %ecx # ecx<- fp[B], the object ptr 2778 movl (%eax,rIBASE,4),%eax # resolved entry 2779 testl %eax,%eax # is resolved entry null? 2780 jne .LOP_IGET_CHAR_finish # no, already resolved 2781 movl rIBASE,OUT_ARG1(%esp) # needed by dvmResolveInstField 2782 movl rSELF,rIBASE 2783 EXPORT_PC 2784 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method 2785 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz 2786 SPILL_TMP1(%ecx) # save obj pointer across call 2787 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz 2788 call dvmResolveInstField # ... to dvmResolveInstField 2789 UNSPILL_TMP1(%ecx) 2790 testl %eax,%eax # returns InstrField ptr 2791 jne .LOP_IGET_CHAR_finish 2792 jmp common_exceptionThrown 2793 2794.LOP_IGET_CHAR_finish: 2795 /* 2796 * Currently: 2797 * eax holds resolved field 2798 * ecx holds object 2799 * rINST holds A 2800 */ 2801 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field 2802 testl %ecx,%ecx # object null? 2803 je common_errNullObject # object was null 2804 movzwl (%ecx,%eax,1),%ecx # ecx<- obj.field (8/16/32 bits) 2805 FETCH_INST_OPCODE 2 %eax 2806 UNSPILL(rIBASE) 2807 SET_VREG %ecx rINST 2808 ADVANCE_PC 2 2809 GOTO_NEXT_R %eax 2810 2811 2812/* ------------------------------ */ 2813.L_OP_IGET_SHORT: /* 0x58 */ 2814/* File: x86/OP_IGET_SHORT.S */ 2815/* File: x86/OP_IGET.S */ 2816 /* 2817 * General 32-bit instance field get. 2818 * 2819 * for: iget, iget-object, iget-boolean, iget-byte, iget-char, iget-short 2820 */ 2821 /* op vA, vB, field@CCCC */ 2822 movl rSELF,%ecx 2823 SPILL(rIBASE) # preserve rIBASE 2824 movzwl 2(rPC),rIBASE # rIBASE<- 0000CCCC 2825 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex 2826 movzbl rINSTbl,%ecx # ecx<- BA 2827 sarl $4,%ecx # ecx<- B 2828 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields 2829 andb $0xf,rINSTbl # rINST<- A 2830 GET_VREG_R %ecx %ecx # ecx<- fp[B], the object ptr 2831 movl (%eax,rIBASE,4),%eax # resolved entry 2832 testl %eax,%eax # is resolved entry null? 2833 jne .LOP_IGET_SHORT_finish # no, already resolved 2834 movl rIBASE,OUT_ARG1(%esp) # needed by dvmResolveInstField 2835 movl rSELF,rIBASE 2836 EXPORT_PC 2837 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method 2838 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz 2839 SPILL_TMP1(%ecx) # save obj pointer across call 2840 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz 2841 call dvmResolveInstField # ... to dvmResolveInstField 2842 UNSPILL_TMP1(%ecx) 2843 testl %eax,%eax # returns InstrField ptr 2844 jne .LOP_IGET_SHORT_finish 2845 jmp common_exceptionThrown 2846 2847.LOP_IGET_SHORT_finish: 2848 /* 2849 * Currently: 2850 * eax holds resolved field 2851 * ecx holds object 2852 * rINST holds A 2853 */ 2854 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field 2855 testl %ecx,%ecx # object null? 2856 je common_errNullObject # object was null 2857 movswl (%ecx,%eax,1),%ecx # ecx<- obj.field (8/16/32 bits) 2858 FETCH_INST_OPCODE 2 %eax 2859 UNSPILL(rIBASE) 2860 SET_VREG %ecx rINST 2861 ADVANCE_PC 2 2862 GOTO_NEXT_R %eax 2863 2864 2865/* ------------------------------ */ 2866.L_OP_IPUT: /* 0x59 */ 2867/* File: x86/OP_IPUT.S */ 2868 2869 /* 2870 * General 32-bit instance field put. 2871 * 2872 * for: iput, iput-object, iput-boolean, iput-byte, iput-char, iput-short 2873 */ 2874 /* op vA, vB, field@CCCC */ 2875 movl rSELF,%ecx 2876 SPILL (rIBASE) 2877 movzwl 2(rPC),rIBASE # rIBASE<- 0000CCCC 2878 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex 2879 movzbl rINSTbl,%ecx # ecx<- BA 2880 sarl $4,%ecx # ecx<- B 2881 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields 2882 andb $0xf,rINSTbl # rINST<- A 2883 GET_VREG_R %ecx %ecx # ecx<- fp[B], the object ptr 2884 movl (%eax,rIBASE,4),%eax # resolved entry 2885 testl %eax,%eax # is resolved entry null? 2886 jne .LOP_IPUT_finish # no, already resolved 2887 movl rIBASE,OUT_ARG1(%esp) 2888 movl rSELF,rIBASE 2889 EXPORT_PC 2890 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method 2891 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz 2892 SPILL_TMP1(%ecx) # save obj pointer across call 2893 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz 2894 call dvmResolveInstField # ... to dvmResolveInstField 2895 UNSPILL_TMP1(%ecx) 2896 testl %eax,%eax # returns InstrField ptr 2897 jne .LOP_IPUT_finish 2898 jmp common_exceptionThrown 2899 2900.LOP_IPUT_finish: 2901 /* 2902 * Currently: 2903 * eax holds resolved field 2904 * ecx holds object 2905 * rINST holds A 2906 */ 2907 GET_VREG_R rINST rINST # rINST<- v[A] 2908 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field 2909 testl %ecx,%ecx # object null? 2910 je common_errNullObject # object was null 2911 movl rINST,(%ecx,%eax,1) # obj.field <- v[A](8/16/32 bits) 2912 FETCH_INST_OPCODE 2 %ecx 2913 UNSPILL(rIBASE) 2914 ADVANCE_PC 2 2915 GOTO_NEXT_R %ecx 2916 2917/* ------------------------------ */ 2918.L_OP_IPUT_WIDE: /* 0x5a */ 2919/* File: x86/OP_IPUT_WIDE.S */ 2920 /* 2921 * 64-bit instance field put. 2922 * 2923 */ 2924 /* op vA, vB, field@CCCC */ 2925 movl rSELF,%ecx 2926 SPILL(rIBASE) 2927 movzwl 2(rPC),rIBASE # rIBASE<- 0000CCCC 2928 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex 2929 movzbl rINSTbl,%ecx # ecx<- BA 2930 sarl $4,%ecx # ecx<- B 2931 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields 2932 andb $0xf,rINSTbl # rINST<- A 2933 GET_VREG_R %ecx %ecx # ecx<- fp[B], the object ptr 2934 movl (%eax,rIBASE,4),%eax # resolved entry 2935 testl %eax,%eax # is resolved entry null? 2936 jne .LOP_IPUT_WIDE_finish # no, already resolved 2937 movl rIBASE,OUT_ARG1(%esp) 2938 movl rSELF,rIBASE 2939 EXPORT_PC 2940 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method 2941 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz 2942 SPILL_TMP1(%ecx) # save obj pointer across call 2943 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz 2944 call dvmResolveInstField # ... to dvmResolveInstField 2945 UNSPILL_TMP1(%ecx) 2946 testl %eax,%eax # ... which returns InstrField ptr 2947 jne .LOP_IPUT_WIDE_finish 2948 jmp common_exceptionThrown 2949 2950.LOP_IPUT_WIDE_finish: 2951 /* 2952 * Currently: 2953 * eax holds resolved field 2954 * ecx holds object 2955 * rIBASE is scratch, but needs to be unspilled 2956 * rINST holds A 2957 */ 2958 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field 2959 testl %ecx,%ecx # object null? 2960 je common_errNullObject # object was null 2961 leal (%ecx,%eax,1),%eax # eax<- address of field 2962 GET_VREG_WORD %ecx rINST 0 # ecx<- lsw 2963 GET_VREG_WORD rINST rINST 1 # rINST<- msw 2964 movl rINST,4(%eax) 2965 movl %ecx,(%eax) 2966 FETCH_INST_OPCODE 2 %ecx 2967 UNSPILL(rIBASE) 2968 ADVANCE_PC 2 2969 GOTO_NEXT_R %ecx 2970 2971/* ------------------------------ */ 2972.L_OP_IPUT_OBJECT: /* 0x5b */ 2973/* File: x86/OP_IPUT_OBJECT.S */ 2974 /* 2975 * Object field put. 2976 * 2977 * for: iput-object 2978 */ 2979 /* op vA, vB, field@CCCC */ 2980 movl rSELF,%ecx 2981 SPILL(rIBASE) 2982 movzwl 2(rPC),rIBASE # rIBASE<- 0000CCCC 2983 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex 2984 movzbl rINSTbl,%ecx # ecx<- BA 2985 sarl $4,%ecx # ecx<- B 2986 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields 2987 andb $0xf,rINSTbl # rINST<- A 2988 GET_VREG_R %ecx %ecx # ecx<- fp[B], the object ptr 2989 movl (%eax,rIBASE,4),%eax # resolved entry 2990 testl %eax,%eax # is resolved entry null? 2991 jne .LOP_IPUT_OBJECT_finish # no, already resolved 2992 movl rIBASE,OUT_ARG1(%esp) 2993 movl rSELF,rIBASE 2994 EXPORT_PC 2995 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method 2996 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz 2997 SPILL_TMP1(%ecx) # save obj pointer across call 2998 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz 2999 call dvmResolveInstField # ... to dvmResolveInstField 3000 UNSPILL_TMP1(%ecx) 3001 testl %eax,%eax # returns InstrField ptr 3002 jne .LOP_IPUT_OBJECT_finish 3003 jmp common_exceptionThrown 3004 3005.LOP_IPUT_OBJECT_finish: 3006 /* 3007 * Currently: 3008 * eax holds resolved field 3009 * ecx holds object 3010 * rIBASE is scratch, but needs to be unspilled 3011 * rINST holds A 3012 */ 3013 GET_VREG_R rINST rINST # rINST<- v[A] 3014 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field 3015 testl %ecx,%ecx # object null? 3016 je common_errNullObject # object was null 3017 movl rINST,(%ecx,%eax) # obj.field <- v[A](8/16/32 bits) 3018 movl rSELF,%eax 3019 testl rINST,rINST # stored a NULL? 3020 movl offThread_cardTable(%eax),%eax # get card table base 3021 je 1f # skip card mark if null store 3022 shrl $GC_CARD_SHIFT,%ecx # object head to card number 3023 movb %al,(%eax,%ecx) # mark card using object head 30241: 3025 UNSPILL(rIBASE) 3026 FETCH_INST_OPCODE 2 %ecx 3027 ADVANCE_PC 2 3028 GOTO_NEXT_R %ecx 3029 3030/* ------------------------------ */ 3031.L_OP_IPUT_BOOLEAN: /* 0x5c */ 3032/* File: x86/OP_IPUT_BOOLEAN.S */ 3033/* File: x86/OP_IPUT.S */ 3034 3035 /* 3036 * General 32-bit instance field put. 3037 * 3038 * for: iput, iput-object, iput-boolean, iput-byte, iput-char, iput-short 3039 */ 3040 /* op vA, vB, field@CCCC */ 3041 movl rSELF,%ecx 3042 SPILL (rIBASE) 3043 movzwl 2(rPC),rIBASE # rIBASE<- 0000CCCC 3044 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex 3045 movzbl rINSTbl,%ecx # ecx<- BA 3046 sarl $4,%ecx # ecx<- B 3047 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields 3048 andb $0xf,rINSTbl # rINST<- A 3049 GET_VREG_R %ecx %ecx # ecx<- fp[B], the object ptr 3050 movl (%eax,rIBASE,4),%eax # resolved entry 3051 testl %eax,%eax # is resolved entry null? 3052 jne .LOP_IPUT_BOOLEAN_finish # no, already resolved 3053 movl rIBASE,OUT_ARG1(%esp) 3054 movl rSELF,rIBASE 3055 EXPORT_PC 3056 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method 3057 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz 3058 SPILL_TMP1(%ecx) # save obj pointer across call 3059 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz 3060 call dvmResolveInstField # ... to dvmResolveInstField 3061 UNSPILL_TMP1(%ecx) 3062 testl %eax,%eax # returns InstrField ptr 3063 jne .LOP_IPUT_BOOLEAN_finish 3064 jmp common_exceptionThrown 3065 3066.LOP_IPUT_BOOLEAN_finish: 3067 /* 3068 * Currently: 3069 * eax holds resolved field 3070 * ecx holds object 3071 * rINST holds A 3072 */ 3073 GET_VREG_R rINST rINST # rINST<- v[A] 3074 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field 3075 testl %ecx,%ecx # object null? 3076 je common_errNullObject # object was null 3077 movb rINSTbl,(%ecx,%eax,1) # obj.field <- v[A](8/16/32 bits) 3078 FETCH_INST_OPCODE 2 %ecx 3079 UNSPILL(rIBASE) 3080 ADVANCE_PC 2 3081 GOTO_NEXT_R %ecx 3082 3083 3084/* ------------------------------ */ 3085.L_OP_IPUT_BYTE: /* 0x5d */ 3086/* File: x86/OP_IPUT_BYTE.S */ 3087/* File: x86/OP_IPUT.S */ 3088 3089 /* 3090 * General 32-bit instance field put. 3091 * 3092 * for: iput, iput-object, iput-boolean, iput-byte, iput-char, iput-short 3093 */ 3094 /* op vA, vB, field@CCCC */ 3095 movl rSELF,%ecx 3096 SPILL (rIBASE) 3097 movzwl 2(rPC),rIBASE # rIBASE<- 0000CCCC 3098 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex 3099 movzbl rINSTbl,%ecx # ecx<- BA 3100 sarl $4,%ecx # ecx<- B 3101 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields 3102 andb $0xf,rINSTbl # rINST<- A 3103 GET_VREG_R %ecx %ecx # ecx<- fp[B], the object ptr 3104 movl (%eax,rIBASE,4),%eax # resolved entry 3105 testl %eax,%eax # is resolved entry null? 3106 jne .LOP_IPUT_BYTE_finish # no, already resolved 3107 movl rIBASE,OUT_ARG1(%esp) 3108 movl rSELF,rIBASE 3109 EXPORT_PC 3110 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method 3111 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz 3112 SPILL_TMP1(%ecx) # save obj pointer across call 3113 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz 3114 call dvmResolveInstField # ... to dvmResolveInstField 3115 UNSPILL_TMP1(%ecx) 3116 testl %eax,%eax # returns InstrField ptr 3117 jne .LOP_IPUT_BYTE_finish 3118 jmp common_exceptionThrown 3119 3120.LOP_IPUT_BYTE_finish: 3121 /* 3122 * Currently: 3123 * eax holds resolved field 3124 * ecx holds object 3125 * rINST holds A 3126 */ 3127 GET_VREG_R rINST rINST # rINST<- v[A] 3128 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field 3129 testl %ecx,%ecx # object null? 3130 je common_errNullObject # object was null 3131 movb rINSTbl,(%ecx,%eax,1) # obj.field <- v[A](8/16/32 bits) 3132 FETCH_INST_OPCODE 2 %ecx 3133 UNSPILL(rIBASE) 3134 ADVANCE_PC 2 3135 GOTO_NEXT_R %ecx 3136 3137 3138/* ------------------------------ */ 3139.L_OP_IPUT_CHAR: /* 0x5e */ 3140/* File: x86/OP_IPUT_CHAR.S */ 3141/* File: x86/OP_IPUT.S */ 3142 3143 /* 3144 * General 32-bit instance field put. 3145 * 3146 * for: iput, iput-object, iput-boolean, iput-byte, iput-char, iput-short 3147 */ 3148 /* op vA, vB, field@CCCC */ 3149 movl rSELF,%ecx 3150 SPILL (rIBASE) 3151 movzwl 2(rPC),rIBASE # rIBASE<- 0000CCCC 3152 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex 3153 movzbl rINSTbl,%ecx # ecx<- BA 3154 sarl $4,%ecx # ecx<- B 3155 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields 3156 andb $0xf,rINSTbl # rINST<- A 3157 GET_VREG_R %ecx %ecx # ecx<- fp[B], the object ptr 3158 movl (%eax,rIBASE,4),%eax # resolved entry 3159 testl %eax,%eax # is resolved entry null? 3160 jne .LOP_IPUT_CHAR_finish # no, already resolved 3161 movl rIBASE,OUT_ARG1(%esp) 3162 movl rSELF,rIBASE 3163 EXPORT_PC 3164 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method 3165 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz 3166 SPILL_TMP1(%ecx) # save obj pointer across call 3167 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz 3168 call dvmResolveInstField # ... to dvmResolveInstField 3169 UNSPILL_TMP1(%ecx) 3170 testl %eax,%eax # returns InstrField ptr 3171 jne .LOP_IPUT_CHAR_finish 3172 jmp common_exceptionThrown 3173 3174.LOP_IPUT_CHAR_finish: 3175 /* 3176 * Currently: 3177 * eax holds resolved field 3178 * ecx holds object 3179 * rINST holds A 3180 */ 3181 GET_VREG_R rINST rINST # rINST<- v[A] 3182 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field 3183 testl %ecx,%ecx # object null? 3184 je common_errNullObject # object was null 3185 movw rINSTw,(%ecx,%eax,1) # obj.field <- v[A](8/16/32 bits) 3186 FETCH_INST_OPCODE 2 %ecx 3187 UNSPILL(rIBASE) 3188 ADVANCE_PC 2 3189 GOTO_NEXT_R %ecx 3190 3191 3192/* ------------------------------ */ 3193.L_OP_IPUT_SHORT: /* 0x5f */ 3194/* File: x86/OP_IPUT_SHORT.S */ 3195/* File: x86/OP_IPUT.S */ 3196 3197 /* 3198 * General 32-bit instance field put. 3199 * 3200 * for: iput, iput-object, iput-boolean, iput-byte, iput-char, iput-short 3201 */ 3202 /* op vA, vB, field@CCCC */ 3203 movl rSELF,%ecx 3204 SPILL (rIBASE) 3205 movzwl 2(rPC),rIBASE # rIBASE<- 0000CCCC 3206 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex 3207 movzbl rINSTbl,%ecx # ecx<- BA 3208 sarl $4,%ecx # ecx<- B 3209 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields 3210 andb $0xf,rINSTbl # rINST<- A 3211 GET_VREG_R %ecx %ecx # ecx<- fp[B], the object ptr 3212 movl (%eax,rIBASE,4),%eax # resolved entry 3213 testl %eax,%eax # is resolved entry null? 3214 jne .LOP_IPUT_SHORT_finish # no, already resolved 3215 movl rIBASE,OUT_ARG1(%esp) 3216 movl rSELF,rIBASE 3217 EXPORT_PC 3218 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method 3219 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz 3220 SPILL_TMP1(%ecx) # save obj pointer across call 3221 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz 3222 call dvmResolveInstField # ... to dvmResolveInstField 3223 UNSPILL_TMP1(%ecx) 3224 testl %eax,%eax # returns InstrField ptr 3225 jne .LOP_IPUT_SHORT_finish 3226 jmp common_exceptionThrown 3227 3228.LOP_IPUT_SHORT_finish: 3229 /* 3230 * Currently: 3231 * eax holds resolved field 3232 * ecx holds object 3233 * rINST holds A 3234 */ 3235 GET_VREG_R rINST rINST # rINST<- v[A] 3236 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field 3237 testl %ecx,%ecx # object null? 3238 je common_errNullObject # object was null 3239 movw rINSTw,(%ecx,%eax,1) # obj.field <- v[A](8/16/32 bits) 3240 FETCH_INST_OPCODE 2 %ecx 3241 UNSPILL(rIBASE) 3242 ADVANCE_PC 2 3243 GOTO_NEXT_R %ecx 3244 3245 3246/* ------------------------------ */ 3247.L_OP_SGET: /* 0x60 */ 3248/* File: x86/OP_SGET.S */ 3249 /* 3250 * General 32-bit SGET handler. 3251 * 3252 * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short 3253 */ 3254 /* op vAA, field@BBBB */ 3255 movl rSELF,%ecx 3256 movzwl 2(rPC),%eax # eax<- field ref BBBB 3257 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex 3258 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields 3259 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr 3260 testl %eax,%eax # resolved entry null? 3261 je .LOP_SGET_resolve # if not, make it so 3262.LOP_SGET_finish: # field ptr in eax 3263 movl offStaticField_value(%eax),%eax 3264 FETCH_INST_OPCODE 2 %ecx 3265 ADVANCE_PC 2 3266 SET_VREG %eax rINST 3267 GOTO_NEXT_R %ecx 3268 3269 /* 3270 * Go resolve the field 3271 */ 3272.LOP_SGET_resolve: 3273 movl rSELF,%ecx 3274 movzwl 2(rPC),%eax # eax<- field ref BBBB 3275 movl offThread_method(%ecx),%ecx # ecx<- current method 3276 EXPORT_PC # could throw, need to export 3277 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 3278 movl %eax,OUT_ARG1(%esp) 3279 movl %ecx,OUT_ARG0(%esp) 3280 SPILL(rIBASE) 3281 call dvmResolveStaticField # eax<- resolved StaticField ptr 3282 UNSPILL(rIBASE) 3283 testl %eax,%eax 3284 jne .LOP_SGET_finish # success, continue 3285 jmp common_exceptionThrown # no, handle exception 3286 3287/* ------------------------------ */ 3288.L_OP_SGET_WIDE: /* 0x61 */ 3289/* File: x86/OP_SGET_WIDE.S */ 3290 /* 3291 * 64-bit SGET handler. 3292 * 3293 */ 3294 /* sget-wide vAA, field@BBBB */ 3295 movl rSELF,%ecx 3296 movzwl 2(rPC),%eax # eax<- field ref BBBB 3297 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex 3298 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields 3299 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr 3300 testl %eax,%eax # resolved entry null? 3301 je .LOP_SGET_WIDE_resolve # if not, make it so 3302.LOP_SGET_WIDE_finish: # field ptr in eax 3303 movl offStaticField_value(%eax),%ecx # ecx<- lsw 3304 movl 4+offStaticField_value(%eax),%eax # eax<- msw 3305 SET_VREG_WORD %ecx rINST 0 3306 FETCH_INST_OPCODE 2 %ecx 3307 SET_VREG_WORD %eax rINST 1 3308 ADVANCE_PC 2 3309 GOTO_NEXT_R %ecx 3310 3311 /* 3312 * Go resolve the field 3313 */ 3314.LOP_SGET_WIDE_resolve: 3315 movl rSELF,%ecx 3316 movzwl 2(rPC),%eax # eax<- field ref BBBB 3317 movl offThread_method(%ecx),%ecx # ecx<- current method 3318 EXPORT_PC # could throw, need to export 3319 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 3320 movl %eax,OUT_ARG1(%esp) 3321 movl %ecx,OUT_ARG0(%esp) 3322 SPILL(rIBASE) 3323 call dvmResolveStaticField # eax<- resolved StaticField ptr 3324 UNSPILL(rIBASE) 3325 testl %eax,%eax 3326 jne .LOP_SGET_WIDE_finish # success, continue 3327 jmp common_exceptionThrown # no, handle exception 3328 3329/* ------------------------------ */ 3330.L_OP_SGET_OBJECT: /* 0x62 */ 3331/* File: x86/OP_SGET_OBJECT.S */ 3332/* File: x86/OP_SGET.S */ 3333 /* 3334 * General 32-bit SGET handler. 3335 * 3336 * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short 3337 */ 3338 /* op vAA, field@BBBB */ 3339 movl rSELF,%ecx 3340 movzwl 2(rPC),%eax # eax<- field ref BBBB 3341 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex 3342 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields 3343 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr 3344 testl %eax,%eax # resolved entry null? 3345 je .LOP_SGET_OBJECT_resolve # if not, make it so 3346.LOP_SGET_OBJECT_finish: # field ptr in eax 3347 movl offStaticField_value(%eax),%eax 3348 FETCH_INST_OPCODE 2 %ecx 3349 ADVANCE_PC 2 3350 SET_VREG %eax rINST 3351 GOTO_NEXT_R %ecx 3352 3353 /* 3354 * Go resolve the field 3355 */ 3356.LOP_SGET_OBJECT_resolve: 3357 movl rSELF,%ecx 3358 movzwl 2(rPC),%eax # eax<- field ref BBBB 3359 movl offThread_method(%ecx),%ecx # ecx<- current method 3360 EXPORT_PC # could throw, need to export 3361 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 3362 movl %eax,OUT_ARG1(%esp) 3363 movl %ecx,OUT_ARG0(%esp) 3364 SPILL(rIBASE) 3365 call dvmResolveStaticField # eax<- resolved StaticField ptr 3366 UNSPILL(rIBASE) 3367 testl %eax,%eax 3368 jne .LOP_SGET_OBJECT_finish # success, continue 3369 jmp common_exceptionThrown # no, handle exception 3370 3371 3372/* ------------------------------ */ 3373.L_OP_SGET_BOOLEAN: /* 0x63 */ 3374/* File: x86/OP_SGET_BOOLEAN.S */ 3375/* File: x86/OP_SGET.S */ 3376 /* 3377 * General 32-bit SGET handler. 3378 * 3379 * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short 3380 */ 3381 /* op vAA, field@BBBB */ 3382 movl rSELF,%ecx 3383 movzwl 2(rPC),%eax # eax<- field ref BBBB 3384 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex 3385 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields 3386 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr 3387 testl %eax,%eax # resolved entry null? 3388 je .LOP_SGET_BOOLEAN_resolve # if not, make it so 3389.LOP_SGET_BOOLEAN_finish: # field ptr in eax 3390 movl offStaticField_value(%eax),%eax 3391 FETCH_INST_OPCODE 2 %ecx 3392 ADVANCE_PC 2 3393 SET_VREG %eax rINST 3394 GOTO_NEXT_R %ecx 3395 3396 /* 3397 * Go resolve the field 3398 */ 3399.LOP_SGET_BOOLEAN_resolve: 3400 movl rSELF,%ecx 3401 movzwl 2(rPC),%eax # eax<- field ref BBBB 3402 movl offThread_method(%ecx),%ecx # ecx<- current method 3403 EXPORT_PC # could throw, need to export 3404 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 3405 movl %eax,OUT_ARG1(%esp) 3406 movl %ecx,OUT_ARG0(%esp) 3407 SPILL(rIBASE) 3408 call dvmResolveStaticField # eax<- resolved StaticField ptr 3409 UNSPILL(rIBASE) 3410 testl %eax,%eax 3411 jne .LOP_SGET_BOOLEAN_finish # success, continue 3412 jmp common_exceptionThrown # no, handle exception 3413 3414 3415/* ------------------------------ */ 3416.L_OP_SGET_BYTE: /* 0x64 */ 3417/* File: x86/OP_SGET_BYTE.S */ 3418/* File: x86/OP_SGET.S */ 3419 /* 3420 * General 32-bit SGET handler. 3421 * 3422 * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short 3423 */ 3424 /* op vAA, field@BBBB */ 3425 movl rSELF,%ecx 3426 movzwl 2(rPC),%eax # eax<- field ref BBBB 3427 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex 3428 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields 3429 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr 3430 testl %eax,%eax # resolved entry null? 3431 je .LOP_SGET_BYTE_resolve # if not, make it so 3432.LOP_SGET_BYTE_finish: # field ptr in eax 3433 movl offStaticField_value(%eax),%eax 3434 FETCH_INST_OPCODE 2 %ecx 3435 ADVANCE_PC 2 3436 SET_VREG %eax rINST 3437 GOTO_NEXT_R %ecx 3438 3439 /* 3440 * Go resolve the field 3441 */ 3442.LOP_SGET_BYTE_resolve: 3443 movl rSELF,%ecx 3444 movzwl 2(rPC),%eax # eax<- field ref BBBB 3445 movl offThread_method(%ecx),%ecx # ecx<- current method 3446 EXPORT_PC # could throw, need to export 3447 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 3448 movl %eax,OUT_ARG1(%esp) 3449 movl %ecx,OUT_ARG0(%esp) 3450 SPILL(rIBASE) 3451 call dvmResolveStaticField # eax<- resolved StaticField ptr 3452 UNSPILL(rIBASE) 3453 testl %eax,%eax 3454 jne .LOP_SGET_BYTE_finish # success, continue 3455 jmp common_exceptionThrown # no, handle exception 3456 3457 3458/* ------------------------------ */ 3459.L_OP_SGET_CHAR: /* 0x65 */ 3460/* File: x86/OP_SGET_CHAR.S */ 3461/* File: x86/OP_SGET.S */ 3462 /* 3463 * General 32-bit SGET handler. 3464 * 3465 * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short 3466 */ 3467 /* op vAA, field@BBBB */ 3468 movl rSELF,%ecx 3469 movzwl 2(rPC),%eax # eax<- field ref BBBB 3470 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex 3471 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields 3472 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr 3473 testl %eax,%eax # resolved entry null? 3474 je .LOP_SGET_CHAR_resolve # if not, make it so 3475.LOP_SGET_CHAR_finish: # field ptr in eax 3476 movl offStaticField_value(%eax),%eax 3477 FETCH_INST_OPCODE 2 %ecx 3478 ADVANCE_PC 2 3479 SET_VREG %eax rINST 3480 GOTO_NEXT_R %ecx 3481 3482 /* 3483 * Go resolve the field 3484 */ 3485.LOP_SGET_CHAR_resolve: 3486 movl rSELF,%ecx 3487 movzwl 2(rPC),%eax # eax<- field ref BBBB 3488 movl offThread_method(%ecx),%ecx # ecx<- current method 3489 EXPORT_PC # could throw, need to export 3490 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 3491 movl %eax,OUT_ARG1(%esp) 3492 movl %ecx,OUT_ARG0(%esp) 3493 SPILL(rIBASE) 3494 call dvmResolveStaticField # eax<- resolved StaticField ptr 3495 UNSPILL(rIBASE) 3496 testl %eax,%eax 3497 jne .LOP_SGET_CHAR_finish # success, continue 3498 jmp common_exceptionThrown # no, handle exception 3499 3500 3501/* ------------------------------ */ 3502.L_OP_SGET_SHORT: /* 0x66 */ 3503/* File: x86/OP_SGET_SHORT.S */ 3504/* File: x86/OP_SGET.S */ 3505 /* 3506 * General 32-bit SGET handler. 3507 * 3508 * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short 3509 */ 3510 /* op vAA, field@BBBB */ 3511 movl rSELF,%ecx 3512 movzwl 2(rPC),%eax # eax<- field ref BBBB 3513 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex 3514 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields 3515 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr 3516 testl %eax,%eax # resolved entry null? 3517 je .LOP_SGET_SHORT_resolve # if not, make it so 3518.LOP_SGET_SHORT_finish: # field ptr in eax 3519 movl offStaticField_value(%eax),%eax 3520 FETCH_INST_OPCODE 2 %ecx 3521 ADVANCE_PC 2 3522 SET_VREG %eax rINST 3523 GOTO_NEXT_R %ecx 3524 3525 /* 3526 * Go resolve the field 3527 */ 3528.LOP_SGET_SHORT_resolve: 3529 movl rSELF,%ecx 3530 movzwl 2(rPC),%eax # eax<- field ref BBBB 3531 movl offThread_method(%ecx),%ecx # ecx<- current method 3532 EXPORT_PC # could throw, need to export 3533 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 3534 movl %eax,OUT_ARG1(%esp) 3535 movl %ecx,OUT_ARG0(%esp) 3536 SPILL(rIBASE) 3537 call dvmResolveStaticField # eax<- resolved StaticField ptr 3538 UNSPILL(rIBASE) 3539 testl %eax,%eax 3540 jne .LOP_SGET_SHORT_finish # success, continue 3541 jmp common_exceptionThrown # no, handle exception 3542 3543 3544/* ------------------------------ */ 3545.L_OP_SPUT: /* 0x67 */ 3546/* File: x86/OP_SPUT.S */ 3547 /* 3548 * General 32-bit SPUT handler. 3549 * 3550 * for: sput, sput-boolean, sput-byte, sput-char, sput-short 3551 */ 3552 /* op vAA, field@BBBB */ 3553 movl rSELF,%ecx 3554 movzwl 2(rPC),%eax # eax<- field ref BBBB 3555 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex 3556 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields 3557 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr 3558 testl %eax,%eax # resolved entry null? 3559 je .LOP_SPUT_resolve # if not, make it so 3560.LOP_SPUT_finish: # field ptr in eax 3561 GET_VREG_R rINST rINST 3562 FETCH_INST_OPCODE 2 %ecx 3563 ADVANCE_PC 2 3564 movl rINST,offStaticField_value(%eax) 3565 GOTO_NEXT_R %ecx 3566 3567 /* 3568 * Go resolve the field 3569 */ 3570.LOP_SPUT_resolve: 3571 movl rSELF,%ecx 3572 movzwl 2(rPC),%eax # eax<- field ref BBBB 3573 movl offThread_method(%ecx),%ecx # ecx<- current method 3574 EXPORT_PC # could throw, need to export 3575 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 3576 movl %eax,OUT_ARG1(%esp) 3577 movl %ecx,OUT_ARG0(%esp) 3578 SPILL(rIBASE) 3579 call dvmResolveStaticField # eax<- resolved StaticField ptr 3580 UNSPILL(rIBASE) 3581 testl %eax,%eax 3582 jne .LOP_SPUT_finish # success, continue 3583 jmp common_exceptionThrown # no, handle exception 3584 3585/* ------------------------------ */ 3586.L_OP_SPUT_WIDE: /* 0x68 */ 3587/* File: x86/OP_SPUT_WIDE.S */ 3588 /* 3589 * General 32-bit SPUT handler. 3590 * 3591 * for: sput, sput-object, sput-boolean, sput-byte, sput-char, sput-short 3592 */ 3593 /* op vAA, field@BBBB */ 3594 movl rSELF,%ecx 3595 movzwl 2(rPC),%eax # eax<- field ref BBBB 3596 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex 3597 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields 3598 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr 3599 testl %eax,%eax # resolved entry null? 3600 je .LOP_SPUT_WIDE_resolve # if not, make it so 3601.LOP_SPUT_WIDE_finish: # field ptr in eax 3602 GET_VREG_WORD %ecx rINST 0 # rINST<- lsw 3603 GET_VREG_WORD rINST rINST 1 # ecx<- msw 3604 movl %ecx,offStaticField_value(%eax) 3605 FETCH_INST_OPCODE 2 %ecx 3606 movl rINST,4+offStaticField_value(%eax) 3607 ADVANCE_PC 2 3608 GOTO_NEXT_R %ecx 3609 3610 /* 3611 * Go resolve the field 3612 */ 3613.LOP_SPUT_WIDE_resolve: 3614 movl rSELF,%ecx 3615 movzwl 2(rPC),%eax # eax<- field ref BBBB 3616 movl offThread_method(%ecx),%ecx # ecx<- current method 3617 EXPORT_PC # could throw, need to export 3618 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 3619 movl %eax,OUT_ARG1(%esp) 3620 movl %ecx,OUT_ARG0(%esp) 3621 SPILL(rIBASE) 3622 call dvmResolveStaticField # eax<- resolved StaticField ptr 3623 UNSPILL(rIBASE) 3624 testl %eax,%eax 3625 jne .LOP_SPUT_WIDE_finish # success, continue 3626 jmp common_exceptionThrown # no, handle exception 3627 3628/* ------------------------------ */ 3629.L_OP_SPUT_OBJECT: /* 0x69 */ 3630/* File: x86/OP_SPUT_OBJECT.S */ 3631 /* 3632 * SPUT object handler. 3633 */ 3634 /* op vAA, field@BBBB */ 3635 movl rSELF,%ecx 3636 movzwl 2(rPC),%eax # eax<- field ref BBBB 3637 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex 3638 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields 3639 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField 3640 testl %eax,%eax # resolved entry null? 3641 je .LOP_SPUT_OBJECT_resolve # if not, make it so 3642.LOP_SPUT_OBJECT_finish: # field ptr in eax 3643 movzbl rINSTbl,%ecx # ecx<- AA 3644 GET_VREG_R %ecx %ecx 3645 movl %ecx,offStaticField_value(%eax) # do the store 3646 testl %ecx,%ecx # stored null object ptr? 3647 je 1f # skip card mark if null 3648 movl rSELF,%ecx 3649 movl offField_clazz(%eax),%eax # eax<- method->clazz 3650 movl offThread_cardTable(%ecx),%ecx # get card table base 3651 shrl $GC_CARD_SHIFT,%eax # head to card number 3652 movb %cl,(%ecx,%eax) # mark card 36531: 3654 FETCH_INST_OPCODE 2 %ecx 3655 ADVANCE_PC 2 3656 GOTO_NEXT_R %ecx 3657 3658.LOP_SPUT_OBJECT_resolve: 3659 movl rSELF,%ecx 3660 movzwl 2(rPC),%eax # eax<- field ref BBBB 3661 movl offThread_method(%ecx),%ecx # ecx<- current method 3662 EXPORT_PC # could throw, need to export 3663 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 3664 movl %eax,OUT_ARG1(%esp) 3665 movl %ecx,OUT_ARG0(%esp) 3666 SPILL(rIBASE) 3667 call dvmResolveStaticField # eax<- resolved StaticField ptr 3668 UNSPILL(rIBASE) 3669 testl %eax,%eax 3670 jne .LOP_SPUT_OBJECT_finish # success, continue 3671 jmp common_exceptionThrown # no, handle exception 3672 3673/* ------------------------------ */ 3674.L_OP_SPUT_BOOLEAN: /* 0x6a */ 3675/* File: x86/OP_SPUT_BOOLEAN.S */ 3676/* File: x86/OP_SPUT.S */ 3677 /* 3678 * General 32-bit SPUT handler. 3679 * 3680 * for: sput, sput-boolean, sput-byte, sput-char, sput-short 3681 */ 3682 /* op vAA, field@BBBB */ 3683 movl rSELF,%ecx 3684 movzwl 2(rPC),%eax # eax<- field ref BBBB 3685 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex 3686 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields 3687 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr 3688 testl %eax,%eax # resolved entry null? 3689 je .LOP_SPUT_BOOLEAN_resolve # if not, make it so 3690.LOP_SPUT_BOOLEAN_finish: # field ptr in eax 3691 GET_VREG_R rINST rINST 3692 FETCH_INST_OPCODE 2 %ecx 3693 ADVANCE_PC 2 3694 movl rINST,offStaticField_value(%eax) 3695 GOTO_NEXT_R %ecx 3696 3697 /* 3698 * Go resolve the field 3699 */ 3700.LOP_SPUT_BOOLEAN_resolve: 3701 movl rSELF,%ecx 3702 movzwl 2(rPC),%eax # eax<- field ref BBBB 3703 movl offThread_method(%ecx),%ecx # ecx<- current method 3704 EXPORT_PC # could throw, need to export 3705 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 3706 movl %eax,OUT_ARG1(%esp) 3707 movl %ecx,OUT_ARG0(%esp) 3708 SPILL(rIBASE) 3709 call dvmResolveStaticField # eax<- resolved StaticField ptr 3710 UNSPILL(rIBASE) 3711 testl %eax,%eax 3712 jne .LOP_SPUT_BOOLEAN_finish # success, continue 3713 jmp common_exceptionThrown # no, handle exception 3714 3715 3716/* ------------------------------ */ 3717.L_OP_SPUT_BYTE: /* 0x6b */ 3718/* File: x86/OP_SPUT_BYTE.S */ 3719/* File: x86/OP_SPUT.S */ 3720 /* 3721 * General 32-bit SPUT handler. 3722 * 3723 * for: sput, sput-boolean, sput-byte, sput-char, sput-short 3724 */ 3725 /* op vAA, field@BBBB */ 3726 movl rSELF,%ecx 3727 movzwl 2(rPC),%eax # eax<- field ref BBBB 3728 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex 3729 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields 3730 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr 3731 testl %eax,%eax # resolved entry null? 3732 je .LOP_SPUT_BYTE_resolve # if not, make it so 3733.LOP_SPUT_BYTE_finish: # field ptr in eax 3734 GET_VREG_R rINST rINST 3735 FETCH_INST_OPCODE 2 %ecx 3736 ADVANCE_PC 2 3737 movl rINST,offStaticField_value(%eax) 3738 GOTO_NEXT_R %ecx 3739 3740 /* 3741 * Go resolve the field 3742 */ 3743.LOP_SPUT_BYTE_resolve: 3744 movl rSELF,%ecx 3745 movzwl 2(rPC),%eax # eax<- field ref BBBB 3746 movl offThread_method(%ecx),%ecx # ecx<- current method 3747 EXPORT_PC # could throw, need to export 3748 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 3749 movl %eax,OUT_ARG1(%esp) 3750 movl %ecx,OUT_ARG0(%esp) 3751 SPILL(rIBASE) 3752 call dvmResolveStaticField # eax<- resolved StaticField ptr 3753 UNSPILL(rIBASE) 3754 testl %eax,%eax 3755 jne .LOP_SPUT_BYTE_finish # success, continue 3756 jmp common_exceptionThrown # no, handle exception 3757 3758 3759/* ------------------------------ */ 3760.L_OP_SPUT_CHAR: /* 0x6c */ 3761/* File: x86/OP_SPUT_CHAR.S */ 3762/* File: x86/OP_SPUT.S */ 3763 /* 3764 * General 32-bit SPUT handler. 3765 * 3766 * for: sput, sput-boolean, sput-byte, sput-char, sput-short 3767 */ 3768 /* op vAA, field@BBBB */ 3769 movl rSELF,%ecx 3770 movzwl 2(rPC),%eax # eax<- field ref BBBB 3771 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex 3772 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields 3773 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr 3774 testl %eax,%eax # resolved entry null? 3775 je .LOP_SPUT_CHAR_resolve # if not, make it so 3776.LOP_SPUT_CHAR_finish: # field ptr in eax 3777 GET_VREG_R rINST rINST 3778 FETCH_INST_OPCODE 2 %ecx 3779 ADVANCE_PC 2 3780 movl rINST,offStaticField_value(%eax) 3781 GOTO_NEXT_R %ecx 3782 3783 /* 3784 * Go resolve the field 3785 */ 3786.LOP_SPUT_CHAR_resolve: 3787 movl rSELF,%ecx 3788 movzwl 2(rPC),%eax # eax<- field ref BBBB 3789 movl offThread_method(%ecx),%ecx # ecx<- current method 3790 EXPORT_PC # could throw, need to export 3791 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 3792 movl %eax,OUT_ARG1(%esp) 3793 movl %ecx,OUT_ARG0(%esp) 3794 SPILL(rIBASE) 3795 call dvmResolveStaticField # eax<- resolved StaticField ptr 3796 UNSPILL(rIBASE) 3797 testl %eax,%eax 3798 jne .LOP_SPUT_CHAR_finish # success, continue 3799 jmp common_exceptionThrown # no, handle exception 3800 3801 3802/* ------------------------------ */ 3803.L_OP_SPUT_SHORT: /* 0x6d */ 3804/* File: x86/OP_SPUT_SHORT.S */ 3805/* File: x86/OP_SPUT.S */ 3806 /* 3807 * General 32-bit SPUT handler. 3808 * 3809 * for: sput, sput-boolean, sput-byte, sput-char, sput-short 3810 */ 3811 /* op vAA, field@BBBB */ 3812 movl rSELF,%ecx 3813 movzwl 2(rPC),%eax # eax<- field ref BBBB 3814 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex 3815 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields 3816 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr 3817 testl %eax,%eax # resolved entry null? 3818 je .LOP_SPUT_SHORT_resolve # if not, make it so 3819.LOP_SPUT_SHORT_finish: # field ptr in eax 3820 GET_VREG_R rINST rINST 3821 FETCH_INST_OPCODE 2 %ecx 3822 ADVANCE_PC 2 3823 movl rINST,offStaticField_value(%eax) 3824 GOTO_NEXT_R %ecx 3825 3826 /* 3827 * Go resolve the field 3828 */ 3829.LOP_SPUT_SHORT_resolve: 3830 movl rSELF,%ecx 3831 movzwl 2(rPC),%eax # eax<- field ref BBBB 3832 movl offThread_method(%ecx),%ecx # ecx<- current method 3833 EXPORT_PC # could throw, need to export 3834 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 3835 movl %eax,OUT_ARG1(%esp) 3836 movl %ecx,OUT_ARG0(%esp) 3837 SPILL(rIBASE) 3838 call dvmResolveStaticField # eax<- resolved StaticField ptr 3839 UNSPILL(rIBASE) 3840 testl %eax,%eax 3841 jne .LOP_SPUT_SHORT_finish # success, continue 3842 jmp common_exceptionThrown # no, handle exception 3843 3844 3845/* ------------------------------ */ 3846.L_OP_INVOKE_VIRTUAL: /* 0x6e */ 3847/* File: x86/OP_INVOKE_VIRTUAL.S */ 3848 3849 /* 3850 * Handle a virtual method call. 3851 * 3852 * for: invoke-virtual, invoke-virtual/range 3853 */ 3854 /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ 3855 /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ 3856 movl rSELF,%eax 3857 movzwl 2(rPC),%ecx # ecx<- BBBB 3858 movl offThread_methodClassDex(%eax),%eax # eax<- pDvmDex 3859 EXPORT_PC 3860 movl offDvmDex_pResMethods(%eax),%eax # eax<- pDvmDex->pResMethods 3861 movl (%eax,%ecx,4),%eax # eax<- resolved baseMethod 3862 testl %eax,%eax # already resolved? 3863 jne .LOP_INVOKE_VIRTUAL_continue # yes, continue 3864 movl rSELF,%eax 3865 movl %ecx,OUT_ARG1(%esp) # arg1<- ref 3866 movl offThread_method(%eax),%eax # eax<- self->method 3867 movl offMethod_clazz(%eax),%eax # ecx<- method->clazz 3868 movl %eax,OUT_ARG0(%esp) # arg0<- clazz 3869 movl $METHOD_VIRTUAL,OUT_ARG2(%esp) # arg2<- flags 3870 call dvmResolveMethod # eax<- call(clazz, ref, flags) 3871 testl %eax,%eax # got null? 3872 jne .LOP_INVOKE_VIRTUAL_continue # no, continue 3873 jmp common_exceptionThrown # yes, handle exception 3874 3875 /* At this point: 3876 * eax = resolved base method 3877 * ecx = scratch 3878 */ 3879.LOP_INVOKE_VIRTUAL_continue: 3880 movzwl 4(rPC),%ecx # ecx<- GFED or CCCC 3881 .if (!0) 3882 andl $0xf,%ecx # ecx<- D (or stays CCCC) 3883 .endif 3884 GET_VREG_R %ecx %ecx # ecx<- "this" 3885 movzwl offMethod_methodIndex(%eax),%eax # eax<- baseMethod->methodIndex 3886 testl %ecx,%ecx # null this? 3887 je common_errNullObject # go if so 3888 movl offObject_clazz(%ecx),%ecx # ecx<- thisPtr->clazz 3889 movl offClassObject_vtable(%ecx),%ecx # ecx<- thisPtr->clazz->vtable 3890 movl (%ecx,%eax,4),%eax # eax<- vtable[methodIndex] 3891 jmp common_invokeMethodNoRange 3892 3893/* ------------------------------ */ 3894.L_OP_INVOKE_SUPER: /* 0x6f */ 3895/* File: x86/OP_INVOKE_SUPER.S */ 3896 /* 3897 * Handle a "super" method call. 3898 * 3899 * for: invoke-super, invoke-super/range 3900 */ 3901 /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ 3902 /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ 3903 movl rSELF,rINST 3904 movzwl 2(rPC),%eax # eax<- BBBB 3905 movl offThread_methodClassDex(rINST),%ecx # ecx<- pDvmDex 3906 EXPORT_PC 3907 movl offDvmDex_pResMethods(%ecx),%ecx # ecx<- pDvmDex->pResMethods 3908 movl (%ecx,%eax,4),%ecx # ecx<- resolved baseMethod 3909 movl offThread_method(rINST),%eax # eax<- method 3910 movzwl 4(rPC),rINST # rINST<- GFED or CCCC 3911 .if (!0) 3912 andl $0xf,rINST # rINST<- D (or stays CCCC) 3913 .endif 3914 GET_VREG_R rINST rINST # rINST<- "this" ptr 3915 testl rINST,rINST # null "this"? 3916 je common_errNullObject # yes, throw 3917 movl offMethod_clazz(%eax),%eax # eax<- method->clazz 3918 testl %ecx,%ecx # already resolved? 3919 je .LOP_INVOKE_SUPER_resolve 3920 /* 3921 * At this point: 3922 * ecx = resolved base method [r0] 3923 * eax = method->clazz [r9] 3924 */ 3925.LOP_INVOKE_SUPER_continue: 3926 movl offClassObject_super(%eax),%eax # eax<- method->clazz->super 3927 movzwl offMethod_methodIndex(%ecx),%ecx # ecx<- baseMthod->methodIndex 3928 cmpl offClassObject_vtableCount(%eax),%ecx # compare(methodIndex,vtableCount) 3929 jae .LOP_INVOKE_SUPER_nsm # method not present in superclass 3930 movl offClassObject_vtable(%eax),%eax # eax<- ...clazz->super->vtable 3931 movl (%eax,%ecx,4),%eax # eax<- vtable[methodIndex] 3932 jmp common_invokeMethodNoRange 3933 3934 3935 /* At this point: 3936 * ecx = null (needs to be resolved base method) 3937 * eax = method->clazz 3938 */ 3939.LOP_INVOKE_SUPER_resolve: 3940 SPILL_TMP1(%eax) # method->clazz 3941 movl %eax,OUT_ARG0(%esp) # arg0<- method->clazz 3942 movzwl 2(rPC),%ecx # ecx<- BBBB 3943 movl $METHOD_VIRTUAL,OUT_ARG2(%esp) # arg2<- resolver method type 3944 movl %ecx,OUT_ARG1(%esp) # arg1<- ref 3945 call dvmResolveMethod # eax<- call(clazz, ref, flags) 3946 testl %eax,%eax # got null? 3947 movl %eax,%ecx # ecx<- resolved base method 3948 UNSPILL_TMP1(%eax) # restore method->clazz 3949 jne .LOP_INVOKE_SUPER_continue # good to go - continue 3950 jmp common_exceptionThrown # handle exception 3951 3952 /* 3953 * Throw a NoSuchMethodError with the method name as the message. 3954 * ecx = resolved base method 3955 */ 3956.LOP_INVOKE_SUPER_nsm: 3957 movl offMethod_name(%ecx),%eax 3958 jmp common_errNoSuchMethod 3959 3960/* ------------------------------ */ 3961.L_OP_INVOKE_DIRECT: /* 0x70 */ 3962/* File: x86/OP_INVOKE_DIRECT.S */ 3963 /* 3964 * Handle a direct method call. 3965 * 3966 * (We could defer the "is 'this' pointer null" test to the common 3967 * method invocation code, and use a flag to indicate that static 3968 * calls don't count. If we do this as part of copying the arguments 3969 * out we could avoiding loading the first arg twice.) 3970 * 3971 * for: invoke-direct, invoke-direct/range 3972 */ 3973 /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ 3974 /* op {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ 3975 movl rSELF,%ecx 3976 movzwl 2(rPC),%eax # eax<- BBBB 3977 movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex 3978 EXPORT_PC 3979 movl offDvmDex_pResMethods(%ecx),%ecx # ecx<- pDvmDex->pResMethods 3980 movzwl 4(rPC),rIBASE # rIBASE<- GFED or CCCC 3981 movl (%ecx,%eax,4),%eax # eax<- resolved methodToCall 3982 .if (!0) 3983 andl $0xf,rIBASE # rIBASE<- D (or stays CCCC) 3984 .endif 3985 testl %eax,%eax # already resolved? 3986 GET_VREG_R %ecx rIBASE # ecx<- "this" ptr 3987 je .LOP_INVOKE_DIRECT_resolve # not resolved, do it now 3988.LOP_INVOKE_DIRECT_finish: 3989 testl %ecx,%ecx # null "this"? 3990 jne common_invokeMethodNoRange # no, continue on 3991 jmp common_errNullObject 3992 3993 /* 3994 * On entry: 3995 * TMP_SPILL <- "this" register 3996 * Things a bit ugly on this path, but it's the less 3997 * frequent one. We'll have to do some reloading. 3998 */ 3999.LOP_INVOKE_DIRECT_resolve: 4000 SPILL_TMP1(%ecx) 4001 movl rSELF,%ecx 4002 movl offThread_method(%ecx),%ecx # ecx<- self->method 4003 movzwl 2(rPC),%eax # reference (BBBB or CCCC) 4004 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 4005 movl $METHOD_DIRECT,OUT_ARG2(%esp) 4006 movl %eax,OUT_ARG1(%esp) 4007 movl %ecx,OUT_ARG0(%esp) 4008 call dvmResolveMethod # eax<- call(clazz, ref, flags) 4009 UNSPILL_TMP1(%ecx) 4010 testl %eax,%eax 4011 jne .LOP_INVOKE_DIRECT_finish 4012 jmp common_exceptionThrown 4013 4014/* ------------------------------ */ 4015.L_OP_INVOKE_STATIC: /* 0x71 */ 4016/* File: x86/OP_INVOKE_STATIC.S */ 4017 /* 4018 * Handle a static method call. 4019 * 4020 * for: invoke-static, invoke-static/range 4021 */ 4022 /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ 4023 /* op {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ 4024 movl rSELF,%ecx 4025 movzwl 2(rPC),%eax # eax<- BBBB 4026 movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex 4027 EXPORT_PC 4028 movl offDvmDex_pResMethods(%ecx),%ecx # ecx<- pDvmDex->pResMethods 4029 movl (%ecx,%eax,4),%eax # eax<- resolved methodToCall 4030 testl %eax,%eax 4031 jne common_invokeMethodNoRange 4032 movl rSELF,%ecx 4033 movl offThread_method(%ecx),%ecx # ecx<- self->method 4034 movzwl 2(rPC),%eax 4035 movl offMethod_clazz(%ecx),%ecx# ecx<- method->clazz 4036 movl %eax,OUT_ARG1(%esp) # arg1<- BBBB 4037 movl %ecx,OUT_ARG0(%esp) # arg0<- clazz 4038 movl $METHOD_STATIC,%eax 4039 movl %eax,OUT_ARG2(%esp) # arg2<- flags 4040 call dvmResolveMethod # call(clazz,ref,flags) 4041 testl %eax,%eax # got null? 4042 jne common_invokeMethodNoRange 4043 jmp common_exceptionThrown 4044 4045/* ------------------------------ */ 4046.L_OP_INVOKE_INTERFACE: /* 0x72 */ 4047/* File: x86/OP_INVOKE_INTERFACE.S */ 4048 /* 4049 * Handle an interface method call. 4050 * 4051 * for: invoke-interface, invoke-interface/range 4052 */ 4053 /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ 4054 /* op {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ 4055 movzwl 4(rPC),%eax # eax<- FEDC or CCCC 4056 movl rSELF,%ecx 4057 .if (!0) 4058 andl $0xf,%eax # eax<- C (or stays CCCC) 4059 .endif 4060 GET_VREG_R %eax %eax # eax<- "this" 4061 EXPORT_PC 4062 testl %eax,%eax # null this? 4063 je common_errNullObject # yes, fail 4064 movl offObject_clazz(%eax),%eax# eax<- thisPtr->clazz 4065 movl %eax,OUT_ARG0(%esp) # arg0<- class 4066 movl offThread_methodClassDex(%ecx),%eax # eax<- methodClassDex 4067 movl offThread_method(%ecx),%ecx # ecx<- method 4068 movl %eax,OUT_ARG3(%esp) # arg3<- dex 4069 movzwl 2(rPC),%eax # eax<- BBBB 4070 movl %ecx,OUT_ARG2(%esp) # arg2<- method 4071 movl %eax,OUT_ARG1(%esp) # arg1<- BBBB 4072 call dvmFindInterfaceMethodInCache # eax<- call(class, ref, method, dex) 4073 testl %eax,%eax 4074 je common_exceptionThrown 4075 jmp common_invokeMethodNoRange 4076 4077/* ------------------------------ */ 4078.L_OP_UNUSED_73: /* 0x73 */ 4079/* File: x86/OP_UNUSED_73.S */ 4080/* File: x86/unused.S */ 4081 jmp common_abort 4082 4083 4084/* ------------------------------ */ 4085.L_OP_INVOKE_VIRTUAL_RANGE: /* 0x74 */ 4086/* File: x86/OP_INVOKE_VIRTUAL_RANGE.S */ 4087/* File: x86/OP_INVOKE_VIRTUAL.S */ 4088 4089 /* 4090 * Handle a virtual method call. 4091 * 4092 * for: invoke-virtual, invoke-virtual/range 4093 */ 4094 /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ 4095 /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ 4096 movl rSELF,%eax 4097 movzwl 2(rPC),%ecx # ecx<- BBBB 4098 movl offThread_methodClassDex(%eax),%eax # eax<- pDvmDex 4099 EXPORT_PC 4100 movl offDvmDex_pResMethods(%eax),%eax # eax<- pDvmDex->pResMethods 4101 movl (%eax,%ecx,4),%eax # eax<- resolved baseMethod 4102 testl %eax,%eax # already resolved? 4103 jne .LOP_INVOKE_VIRTUAL_RANGE_continue # yes, continue 4104 movl rSELF,%eax 4105 movl %ecx,OUT_ARG1(%esp) # arg1<- ref 4106 movl offThread_method(%eax),%eax # eax<- self->method 4107 movl offMethod_clazz(%eax),%eax # ecx<- method->clazz 4108 movl %eax,OUT_ARG0(%esp) # arg0<- clazz 4109 movl $METHOD_VIRTUAL,OUT_ARG2(%esp) # arg2<- flags 4110 call dvmResolveMethod # eax<- call(clazz, ref, flags) 4111 testl %eax,%eax # got null? 4112 jne .LOP_INVOKE_VIRTUAL_RANGE_continue # no, continue 4113 jmp common_exceptionThrown # yes, handle exception 4114 4115 /* At this point: 4116 * eax = resolved base method 4117 * ecx = scratch 4118 */ 4119.LOP_INVOKE_VIRTUAL_RANGE_continue: 4120 movzwl 4(rPC),%ecx # ecx<- GFED or CCCC 4121 .if (!1) 4122 andl $0xf,%ecx # ecx<- D (or stays CCCC) 4123 .endif 4124 GET_VREG_R %ecx %ecx # ecx<- "this" 4125 movzwl offMethod_methodIndex(%eax),%eax # eax<- baseMethod->methodIndex 4126 testl %ecx,%ecx # null this? 4127 je common_errNullObject # go if so 4128 movl offObject_clazz(%ecx),%ecx # ecx<- thisPtr->clazz 4129 movl offClassObject_vtable(%ecx),%ecx # ecx<- thisPtr->clazz->vtable 4130 movl (%ecx,%eax,4),%eax # eax<- vtable[methodIndex] 4131 jmp common_invokeMethodRange 4132 4133 4134/* ------------------------------ */ 4135.L_OP_INVOKE_SUPER_RANGE: /* 0x75 */ 4136/* File: x86/OP_INVOKE_SUPER_RANGE.S */ 4137/* File: x86/OP_INVOKE_SUPER.S */ 4138 /* 4139 * Handle a "super" method call. 4140 * 4141 * for: invoke-super, invoke-super/range 4142 */ 4143 /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ 4144 /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ 4145 movl rSELF,rINST 4146 movzwl 2(rPC),%eax # eax<- BBBB 4147 movl offThread_methodClassDex(rINST),%ecx # ecx<- pDvmDex 4148 EXPORT_PC 4149 movl offDvmDex_pResMethods(%ecx),%ecx # ecx<- pDvmDex->pResMethods 4150 movl (%ecx,%eax,4),%ecx # ecx<- resolved baseMethod 4151 movl offThread_method(rINST),%eax # eax<- method 4152 movzwl 4(rPC),rINST # rINST<- GFED or CCCC 4153 .if (!1) 4154 andl $0xf,rINST # rINST<- D (or stays CCCC) 4155 .endif 4156 GET_VREG_R rINST rINST # rINST<- "this" ptr 4157 testl rINST,rINST # null "this"? 4158 je common_errNullObject # yes, throw 4159 movl offMethod_clazz(%eax),%eax # eax<- method->clazz 4160 testl %ecx,%ecx # already resolved? 4161 je .LOP_INVOKE_SUPER_RANGE_resolve 4162 /* 4163 * At this point: 4164 * ecx = resolved base method [r0] 4165 * eax = method->clazz [r9] 4166 */ 4167.LOP_INVOKE_SUPER_RANGE_continue: 4168 movl offClassObject_super(%eax),%eax # eax<- method->clazz->super 4169 movzwl offMethod_methodIndex(%ecx),%ecx # ecx<- baseMthod->methodIndex 4170 cmpl offClassObject_vtableCount(%eax),%ecx # compare(methodIndex,vtableCount) 4171 jae .LOP_INVOKE_SUPER_RANGE_nsm # method not present in superclass 4172 movl offClassObject_vtable(%eax),%eax # eax<- ...clazz->super->vtable 4173 movl (%eax,%ecx,4),%eax # eax<- vtable[methodIndex] 4174 jmp common_invokeMethodRange 4175 4176 4177 /* At this point: 4178 * ecx = null (needs to be resolved base method) 4179 * eax = method->clazz 4180 */ 4181.LOP_INVOKE_SUPER_RANGE_resolve: 4182 SPILL_TMP1(%eax) # method->clazz 4183 movl %eax,OUT_ARG0(%esp) # arg0<- method->clazz 4184 movzwl 2(rPC),%ecx # ecx<- BBBB 4185 movl $METHOD_VIRTUAL,OUT_ARG2(%esp) # arg2<- resolver method type 4186 movl %ecx,OUT_ARG1(%esp) # arg1<- ref 4187 call dvmResolveMethod # eax<- call(clazz, ref, flags) 4188 testl %eax,%eax # got null? 4189 movl %eax,%ecx # ecx<- resolved base method 4190 UNSPILL_TMP1(%eax) # restore method->clazz 4191 jne .LOP_INVOKE_SUPER_RANGE_continue # good to go - continue 4192 jmp common_exceptionThrown # handle exception 4193 4194 /* 4195 * Throw a NoSuchMethodError with the method name as the message. 4196 * ecx = resolved base method 4197 */ 4198.LOP_INVOKE_SUPER_RANGE_nsm: 4199 movl offMethod_name(%ecx),%eax 4200 jmp common_errNoSuchMethod 4201 4202 4203/* ------------------------------ */ 4204.L_OP_INVOKE_DIRECT_RANGE: /* 0x76 */ 4205/* File: x86/OP_INVOKE_DIRECT_RANGE.S */ 4206/* File: x86/OP_INVOKE_DIRECT.S */ 4207 /* 4208 * Handle a direct method call. 4209 * 4210 * (We could defer the "is 'this' pointer null" test to the common 4211 * method invocation code, and use a flag to indicate that static 4212 * calls don't count. If we do this as part of copying the arguments 4213 * out we could avoiding loading the first arg twice.) 4214 * 4215 * for: invoke-direct, invoke-direct/range 4216 */ 4217 /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ 4218 /* op {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ 4219 movl rSELF,%ecx 4220 movzwl 2(rPC),%eax # eax<- BBBB 4221 movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex 4222 EXPORT_PC 4223 movl offDvmDex_pResMethods(%ecx),%ecx # ecx<- pDvmDex->pResMethods 4224 movzwl 4(rPC),rIBASE # rIBASE<- GFED or CCCC 4225 movl (%ecx,%eax,4),%eax # eax<- resolved methodToCall 4226 .if (!1) 4227 andl $0xf,rIBASE # rIBASE<- D (or stays CCCC) 4228 .endif 4229 testl %eax,%eax # already resolved? 4230 GET_VREG_R %ecx rIBASE # ecx<- "this" ptr 4231 je .LOP_INVOKE_DIRECT_RANGE_resolve # not resolved, do it now 4232.LOP_INVOKE_DIRECT_RANGE_finish: 4233 testl %ecx,%ecx # null "this"? 4234 jne common_invokeMethodRange # no, continue on 4235 jmp common_errNullObject 4236 4237 /* 4238 * On entry: 4239 * TMP_SPILL <- "this" register 4240 * Things a bit ugly on this path, but it's the less 4241 * frequent one. We'll have to do some reloading. 4242 */ 4243.LOP_INVOKE_DIRECT_RANGE_resolve: 4244 SPILL_TMP1(%ecx) 4245 movl rSELF,%ecx 4246 movl offThread_method(%ecx),%ecx # ecx<- self->method 4247 movzwl 2(rPC),%eax # reference (BBBB or CCCC) 4248 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 4249 movl $METHOD_DIRECT,OUT_ARG2(%esp) 4250 movl %eax,OUT_ARG1(%esp) 4251 movl %ecx,OUT_ARG0(%esp) 4252 call dvmResolveMethod # eax<- call(clazz, ref, flags) 4253 UNSPILL_TMP1(%ecx) 4254 testl %eax,%eax 4255 jne .LOP_INVOKE_DIRECT_RANGE_finish 4256 jmp common_exceptionThrown 4257 4258 4259/* ------------------------------ */ 4260.L_OP_INVOKE_STATIC_RANGE: /* 0x77 */ 4261/* File: x86/OP_INVOKE_STATIC_RANGE.S */ 4262/* File: x86/OP_INVOKE_STATIC.S */ 4263 /* 4264 * Handle a static method call. 4265 * 4266 * for: invoke-static, invoke-static/range 4267 */ 4268 /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ 4269 /* op {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ 4270 movl rSELF,%ecx 4271 movzwl 2(rPC),%eax # eax<- BBBB 4272 movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex 4273 EXPORT_PC 4274 movl offDvmDex_pResMethods(%ecx),%ecx # ecx<- pDvmDex->pResMethods 4275 movl (%ecx,%eax,4),%eax # eax<- resolved methodToCall 4276 testl %eax,%eax 4277 jne common_invokeMethodRange 4278 movl rSELF,%ecx 4279 movl offThread_method(%ecx),%ecx # ecx<- self->method 4280 movzwl 2(rPC),%eax 4281 movl offMethod_clazz(%ecx),%ecx# ecx<- method->clazz 4282 movl %eax,OUT_ARG1(%esp) # arg1<- BBBB 4283 movl %ecx,OUT_ARG0(%esp) # arg0<- clazz 4284 movl $METHOD_STATIC,%eax 4285 movl %eax,OUT_ARG2(%esp) # arg2<- flags 4286 call dvmResolveMethod # call(clazz,ref,flags) 4287 testl %eax,%eax # got null? 4288 jne common_invokeMethodRange 4289 jmp common_exceptionThrown 4290 4291 4292/* ------------------------------ */ 4293.L_OP_INVOKE_INTERFACE_RANGE: /* 0x78 */ 4294/* File: x86/OP_INVOKE_INTERFACE_RANGE.S */ 4295/* File: x86/OP_INVOKE_INTERFACE.S */ 4296 /* 4297 * Handle an interface method call. 4298 * 4299 * for: invoke-interface, invoke-interface/range 4300 */ 4301 /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ 4302 /* op {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ 4303 movzwl 4(rPC),%eax # eax<- FEDC or CCCC 4304 movl rSELF,%ecx 4305 .if (!1) 4306 andl $0xf,%eax # eax<- C (or stays CCCC) 4307 .endif 4308 GET_VREG_R %eax %eax # eax<- "this" 4309 EXPORT_PC 4310 testl %eax,%eax # null this? 4311 je common_errNullObject # yes, fail 4312 movl offObject_clazz(%eax),%eax# eax<- thisPtr->clazz 4313 movl %eax,OUT_ARG0(%esp) # arg0<- class 4314 movl offThread_methodClassDex(%ecx),%eax # eax<- methodClassDex 4315 movl offThread_method(%ecx),%ecx # ecx<- method 4316 movl %eax,OUT_ARG3(%esp) # arg3<- dex 4317 movzwl 2(rPC),%eax # eax<- BBBB 4318 movl %ecx,OUT_ARG2(%esp) # arg2<- method 4319 movl %eax,OUT_ARG1(%esp) # arg1<- BBBB 4320 call dvmFindInterfaceMethodInCache # eax<- call(class, ref, method, dex) 4321 testl %eax,%eax 4322 je common_exceptionThrown 4323 jmp common_invokeMethodRange 4324 4325 4326/* ------------------------------ */ 4327.L_OP_UNUSED_79: /* 0x79 */ 4328/* File: x86/OP_UNUSED_79.S */ 4329/* File: x86/unused.S */ 4330 jmp common_abort 4331 4332 4333/* ------------------------------ */ 4334.L_OP_UNUSED_7A: /* 0x7a */ 4335/* File: x86/OP_UNUSED_7A.S */ 4336/* File: x86/unused.S */ 4337 jmp common_abort 4338 4339 4340/* ------------------------------ */ 4341.L_OP_NEG_INT: /* 0x7b */ 4342/* File: x86/OP_NEG_INT.S */ 4343/* File: x86/unop.S */ 4344 /* 4345 * Generic 32-bit unary operation. Provide an "instr" line that 4346 * specifies an instruction that performs "result = op eax". 4347 */ 4348 /* unop vA, vB */ 4349 movzbl rINSTbl,%ecx # ecx<- A+ 4350 sarl $4,rINST # rINST<- B 4351 GET_VREG_R %eax rINST # eax<- vB 4352 andb $0xf,%cl # ecx<- A 4353 4354 4355 negl %eax 4356 SET_VREG %eax %ecx 4357 FETCH_INST_OPCODE 1 %ecx 4358 ADVANCE_PC 1 4359 GOTO_NEXT_R %ecx 4360 4361 4362/* ------------------------------ */ 4363.L_OP_NOT_INT: /* 0x7c */ 4364/* File: x86/OP_NOT_INT.S */ 4365/* File: x86/unop.S */ 4366 /* 4367 * Generic 32-bit unary operation. Provide an "instr" line that 4368 * specifies an instruction that performs "result = op eax". 4369 */ 4370 /* unop vA, vB */ 4371 movzbl rINSTbl,%ecx # ecx<- A+ 4372 sarl $4,rINST # rINST<- B 4373 GET_VREG_R %eax rINST # eax<- vB 4374 andb $0xf,%cl # ecx<- A 4375 4376 4377 notl %eax 4378 SET_VREG %eax %ecx 4379 FETCH_INST_OPCODE 1 %ecx 4380 ADVANCE_PC 1 4381 GOTO_NEXT_R %ecx 4382 4383 4384/* ------------------------------ */ 4385.L_OP_NEG_LONG: /* 0x7d */ 4386/* File: x86/OP_NEG_LONG.S */ 4387 /* unop vA, vB */ 4388 movzbl rINSTbl,%ecx # ecx<- BA 4389 sarl $4,%ecx # ecx<- B 4390 andb $0xf,rINSTbl # rINST<- A 4391 GET_VREG_WORD %eax %ecx 0 # eax<- v[B+0] 4392 GET_VREG_WORD %ecx %ecx 1 # ecx<- v[B+1] 4393 negl %eax 4394 adcl $0,%ecx 4395 negl %ecx 4396 SET_VREG_WORD %eax rINST 0 # v[A+0]<- eax 4397 FETCH_INST_OPCODE 1 %eax 4398 SET_VREG_WORD %ecx rINST 1 # v[A+1]<- ecx 4399 ADVANCE_PC 1 4400 GOTO_NEXT_R %eax 4401 4402/* ------------------------------ */ 4403.L_OP_NOT_LONG: /* 0x7e */ 4404/* File: x86/OP_NOT_LONG.S */ 4405 /* unop vA, vB */ 4406 movzbl rINSTbl,%ecx # ecx<- BA 4407 sarl $4,%ecx # ecx<- B 4408 andb $0xf,rINSTbl # rINST<- A 4409 GET_VREG_WORD %eax %ecx 0 # eax<- v[B+0] 4410 GET_VREG_WORD %ecx %ecx 1 # ecx<- v[B+1] 4411 notl %eax 4412 notl %ecx 4413 SET_VREG_WORD %eax rINST 0 # v[A+0]<- eax 4414 FETCH_INST_OPCODE 1 %eax 4415 SET_VREG_WORD %ecx rINST 1 # v[A+1]<- ecx 4416 ADVANCE_PC 1 4417 GOTO_NEXT_R %eax 4418 4419/* ------------------------------ */ 4420.L_OP_NEG_FLOAT: /* 0x7f */ 4421/* File: x86/OP_NEG_FLOAT.S */ 4422/* File: x86/fpcvt.S */ 4423 /* 4424 * Generic 32-bit FP conversion operation. 4425 */ 4426 /* unop vA, vB */ 4427 movzbl rINSTbl,%ecx # ecx<- A+ 4428 sarl $4,rINST # rINST<- B 4429 flds (rFP,rINST,4) # %st0<- vB 4430 andb $0xf,%cl # ecx<- A 4431 fchs 4432 fstps (rFP,%ecx,4) # vA<- %st0 4433 FETCH_INST_OPCODE 1 %ecx 4434 ADVANCE_PC 1 4435 GOTO_NEXT_R %ecx 4436 4437 4438/* ------------------------------ */ 4439.L_OP_NEG_DOUBLE: /* 0x80 */ 4440/* File: x86/OP_NEG_DOUBLE.S */ 4441/* File: x86/fpcvt.S */ 4442 /* 4443 * Generic 32-bit FP conversion operation. 4444 */ 4445 /* unop vA, vB */ 4446 movzbl rINSTbl,%ecx # ecx<- A+ 4447 sarl $4,rINST # rINST<- B 4448 fldl (rFP,rINST,4) # %st0<- vB 4449 andb $0xf,%cl # ecx<- A 4450 fchs 4451 fstpl (rFP,%ecx,4) # vA<- %st0 4452 FETCH_INST_OPCODE 1 %ecx 4453 ADVANCE_PC 1 4454 GOTO_NEXT_R %ecx 4455 4456 4457/* ------------------------------ */ 4458.L_OP_INT_TO_LONG: /* 0x81 */ 4459/* File: x86/OP_INT_TO_LONG.S */ 4460 /* int to long vA, vB */ 4461 movzbl rINSTbl,%eax # eax<- +A 4462 sarl $4,%eax # eax<- B 4463 GET_VREG_R %eax %eax # eax<- vB 4464 andb $0xf,rINSTbl # rINST<- A 4465 SPILL(rIBASE) # cltd trashes rIBASE/edx 4466 cltd # rINST:eax<- sssssssBBBBBBBB 4467 SET_VREG_WORD rIBASE rINST 1 # v[A+1]<- rIBASE/rPC 4468 FETCH_INST_OPCODE 1 %ecx 4469 UNSPILL(rIBASE) 4470 SET_VREG_WORD %eax rINST 0 # v[A+0]<- %eax 4471 ADVANCE_PC 1 4472 GOTO_NEXT_R %ecx 4473 4474/* ------------------------------ */ 4475.L_OP_INT_TO_FLOAT: /* 0x82 */ 4476/* File: x86/OP_INT_TO_FLOAT.S */ 4477/* File: x86/fpcvt.S */ 4478 /* 4479 * Generic 32-bit FP conversion operation. 4480 */ 4481 /* unop vA, vB */ 4482 movzbl rINSTbl,%ecx # ecx<- A+ 4483 sarl $4,rINST # rINST<- B 4484 fildl (rFP,rINST,4) # %st0<- vB 4485 andb $0xf,%cl # ecx<- A 4486 4487 fstps (rFP,%ecx,4) # vA<- %st0 4488 FETCH_INST_OPCODE 1 %ecx 4489 ADVANCE_PC 1 4490 GOTO_NEXT_R %ecx 4491 4492 4493/* ------------------------------ */ 4494.L_OP_INT_TO_DOUBLE: /* 0x83 */ 4495/* File: x86/OP_INT_TO_DOUBLE.S */ 4496/* File: x86/fpcvt.S */ 4497 /* 4498 * Generic 32-bit FP conversion operation. 4499 */ 4500 /* unop vA, vB */ 4501 movzbl rINSTbl,%ecx # ecx<- A+ 4502 sarl $4,rINST # rINST<- B 4503 fildl (rFP,rINST,4) # %st0<- vB 4504 andb $0xf,%cl # ecx<- A 4505 4506 fstpl (rFP,%ecx,4) # vA<- %st0 4507 FETCH_INST_OPCODE 1 %ecx 4508 ADVANCE_PC 1 4509 GOTO_NEXT_R %ecx 4510 4511 4512/* ------------------------------ */ 4513.L_OP_LONG_TO_INT: /* 0x84 */ 4514/* File: x86/OP_LONG_TO_INT.S */ 4515/* we ignore the high word, making this equivalent to a 32-bit reg move */ 4516/* File: x86/OP_MOVE.S */ 4517 /* for move, move-object, long-to-int */ 4518 /* op vA, vB */ 4519 movzbl rINSTbl,%eax # eax<- BA 4520 andb $0xf,%al # eax<- A 4521 shrl $4,rINST # rINST<- B 4522 GET_VREG_R rINST rINST 4523 FETCH_INST_OPCODE 1 %ecx 4524 ADVANCE_PC 1 4525 SET_VREG rINST %eax # fp[A]<-fp[B] 4526 GOTO_NEXT_R %ecx 4527 4528 4529/* ------------------------------ */ 4530.L_OP_LONG_TO_FLOAT: /* 0x85 */ 4531/* File: x86/OP_LONG_TO_FLOAT.S */ 4532/* File: x86/fpcvt.S */ 4533 /* 4534 * Generic 32-bit FP conversion operation. 4535 */ 4536 /* unop vA, vB */ 4537 movzbl rINSTbl,%ecx # ecx<- A+ 4538 sarl $4,rINST # rINST<- B 4539 fildll (rFP,rINST,4) # %st0<- vB 4540 andb $0xf,%cl # ecx<- A 4541 4542 fstps (rFP,%ecx,4) # vA<- %st0 4543 FETCH_INST_OPCODE 1 %ecx 4544 ADVANCE_PC 1 4545 GOTO_NEXT_R %ecx 4546 4547 4548/* ------------------------------ */ 4549.L_OP_LONG_TO_DOUBLE: /* 0x86 */ 4550/* File: x86/OP_LONG_TO_DOUBLE.S */ 4551/* File: x86/fpcvt.S */ 4552 /* 4553 * Generic 32-bit FP conversion operation. 4554 */ 4555 /* unop vA, vB */ 4556 movzbl rINSTbl,%ecx # ecx<- A+ 4557 sarl $4,rINST # rINST<- B 4558 fildll (rFP,rINST,4) # %st0<- vB 4559 andb $0xf,%cl # ecx<- A 4560 4561 fstpl (rFP,%ecx,4) # vA<- %st0 4562 FETCH_INST_OPCODE 1 %ecx 4563 ADVANCE_PC 1 4564 GOTO_NEXT_R %ecx 4565 4566 4567/* ------------------------------ */ 4568.L_OP_FLOAT_TO_INT: /* 0x87 */ 4569/* File: x86/OP_FLOAT_TO_INT.S */ 4570/* File: x86/cvtfp_int.S */ 4571/* On fp to int conversions, Java requires that 4572 * if the result > maxint, it should be clamped to maxint. If it is less 4573 * than minint, it should be clamped to minint. If it is a nan, the result 4574 * should be zero. Further, the rounding mode is to truncate. This model 4575 * differs from what is delivered normally via the x86 fpu, so we have 4576 * to play some games. 4577 */ 4578 /* float/double to int/long vA, vB */ 4579 movzbl rINSTbl,%ecx # ecx<- A+ 4580 sarl $4,rINST # rINST<- B 4581 .if 0 4582 fldl (rFP,rINST,4) # %st0<- vB 4583 .else 4584 flds (rFP,rINST,4) # %st0<- vB 4585 .endif 4586 ftst 4587 fnstcw LOCAL0_OFFSET(%ebp) # remember original rounding mode 4588 movzwl LOCAL0_OFFSET(%ebp),%eax 4589 movb $0xc,%ah 4590 movw %ax,LOCAL0_OFFSET+2(%ebp) 4591 fldcw LOCAL0_OFFSET+2(%ebp) # set "to zero" rounding mode 4592 andb $0xf,%cl # ecx<- A 4593 .if 0 4594 fistpll (rFP,%ecx,4) # convert and store 4595 .else 4596 fistpl (rFP,%ecx,4) # convert and store 4597 .endif 4598 fldcw LOCAL0_OFFSET(%ebp) # restore previous rounding mode 4599 .if 0 4600 movl $0x80000000,%eax 4601 xorl 4(rFP,%ecx,4),%eax 4602 orl (rFP,%ecx,4),%eax 4603 .else 4604 cmpl $0x80000000,(rFP,%ecx,4) 4605 .endif 4606 je .LOP_FLOAT_TO_INT_special_case # fix up result 4607 4608.LOP_FLOAT_TO_INT_finish: 4609 FETCH_INST_OPCODE 1 %ecx 4610 ADVANCE_PC 1 4611 GOTO_NEXT_R %ecx 4612 4613.LOP_FLOAT_TO_INT_special_case: 4614 fnstsw %ax 4615 sahf 4616 jp .LOP_FLOAT_TO_INT_isNaN 4617 adcl $-1,(rFP,%ecx,4) 4618 .if 0 4619 adcl $-1,4(rFP,%ecx,4) 4620 .endif 4621 jmp .LOP_FLOAT_TO_INT_finish 4622.LOP_FLOAT_TO_INT_isNaN: 4623 movl $0,(rFP,%ecx,4) 4624 .if 0 4625 movl $0,4(rFP,%ecx,4) 4626 .endif 4627 jmp .LOP_FLOAT_TO_INT_finish 4628 4629 4630/* ------------------------------ */ 4631.L_OP_FLOAT_TO_LONG: /* 0x88 */ 4632/* File: x86/OP_FLOAT_TO_LONG.S */ 4633/* File: x86/cvtfp_int.S */ 4634/* On fp to int conversions, Java requires that 4635 * if the result > maxint, it should be clamped to maxint. If it is less 4636 * than minint, it should be clamped to minint. If it is a nan, the result 4637 * should be zero. Further, the rounding mode is to truncate. This model 4638 * differs from what is delivered normally via the x86 fpu, so we have 4639 * to play some games. 4640 */ 4641 /* float/double to int/long vA, vB */ 4642 movzbl rINSTbl,%ecx # ecx<- A+ 4643 sarl $4,rINST # rINST<- B 4644 .if 0 4645 fldl (rFP,rINST,4) # %st0<- vB 4646 .else 4647 flds (rFP,rINST,4) # %st0<- vB 4648 .endif 4649 ftst 4650 fnstcw LOCAL0_OFFSET(%ebp) # remember original rounding mode 4651 movzwl LOCAL0_OFFSET(%ebp),%eax 4652 movb $0xc,%ah 4653 movw %ax,LOCAL0_OFFSET+2(%ebp) 4654 fldcw LOCAL0_OFFSET+2(%ebp) # set "to zero" rounding mode 4655 andb $0xf,%cl # ecx<- A 4656 .if 1 4657 fistpll (rFP,%ecx,4) # convert and store 4658 .else 4659 fistpl (rFP,%ecx,4) # convert and store 4660 .endif 4661 fldcw LOCAL0_OFFSET(%ebp) # restore previous rounding mode 4662 .if 1 4663 movl $0x80000000,%eax 4664 xorl 4(rFP,%ecx,4),%eax 4665 orl (rFP,%ecx,4),%eax 4666 .else 4667 cmpl $0x80000000,(rFP,%ecx,4) 4668 .endif 4669 je .LOP_FLOAT_TO_LONG_special_case # fix up result 4670 4671.LOP_FLOAT_TO_LONG_finish: 4672 FETCH_INST_OPCODE 1 %ecx 4673 ADVANCE_PC 1 4674 GOTO_NEXT_R %ecx 4675 4676.LOP_FLOAT_TO_LONG_special_case: 4677 fnstsw %ax 4678 sahf 4679 jp .LOP_FLOAT_TO_LONG_isNaN 4680 adcl $-1,(rFP,%ecx,4) 4681 .if 1 4682 adcl $-1,4(rFP,%ecx,4) 4683 .endif 4684 jmp .LOP_FLOAT_TO_LONG_finish 4685.LOP_FLOAT_TO_LONG_isNaN: 4686 movl $0,(rFP,%ecx,4) 4687 .if 1 4688 movl $0,4(rFP,%ecx,4) 4689 .endif 4690 jmp .LOP_FLOAT_TO_LONG_finish 4691 4692 4693/* ------------------------------ */ 4694.L_OP_FLOAT_TO_DOUBLE: /* 0x89 */ 4695/* File: x86/OP_FLOAT_TO_DOUBLE.S */ 4696/* File: x86/fpcvt.S */ 4697 /* 4698 * Generic 32-bit FP conversion operation. 4699 */ 4700 /* unop vA, vB */ 4701 movzbl rINSTbl,%ecx # ecx<- A+ 4702 sarl $4,rINST # rINST<- B 4703 flds (rFP,rINST,4) # %st0<- vB 4704 andb $0xf,%cl # ecx<- A 4705 4706 fstpl (rFP,%ecx,4) # vA<- %st0 4707 FETCH_INST_OPCODE 1 %ecx 4708 ADVANCE_PC 1 4709 GOTO_NEXT_R %ecx 4710 4711 4712/* ------------------------------ */ 4713.L_OP_DOUBLE_TO_INT: /* 0x8a */ 4714/* File: x86/OP_DOUBLE_TO_INT.S */ 4715/* File: x86/cvtfp_int.S */ 4716/* On fp to int conversions, Java requires that 4717 * if the result > maxint, it should be clamped to maxint. If it is less 4718 * than minint, it should be clamped to minint. If it is a nan, the result 4719 * should be zero. Further, the rounding mode is to truncate. This model 4720 * differs from what is delivered normally via the x86 fpu, so we have 4721 * to play some games. 4722 */ 4723 /* float/double to int/long vA, vB */ 4724 movzbl rINSTbl,%ecx # ecx<- A+ 4725 sarl $4,rINST # rINST<- B 4726 .if 1 4727 fldl (rFP,rINST,4) # %st0<- vB 4728 .else 4729 flds (rFP,rINST,4) # %st0<- vB 4730 .endif 4731 ftst 4732 fnstcw LOCAL0_OFFSET(%ebp) # remember original rounding mode 4733 movzwl LOCAL0_OFFSET(%ebp),%eax 4734 movb $0xc,%ah 4735 movw %ax,LOCAL0_OFFSET+2(%ebp) 4736 fldcw LOCAL0_OFFSET+2(%ebp) # set "to zero" rounding mode 4737 andb $0xf,%cl # ecx<- A 4738 .if 0 4739 fistpll (rFP,%ecx,4) # convert and store 4740 .else 4741 fistpl (rFP,%ecx,4) # convert and store 4742 .endif 4743 fldcw LOCAL0_OFFSET(%ebp) # restore previous rounding mode 4744 .if 0 4745 movl $0x80000000,%eax 4746 xorl 4(rFP,%ecx,4),%eax 4747 orl (rFP,%ecx,4),%eax 4748 .else 4749 cmpl $0x80000000,(rFP,%ecx,4) 4750 .endif 4751 je .LOP_DOUBLE_TO_INT_special_case # fix up result 4752 4753.LOP_DOUBLE_TO_INT_finish: 4754 FETCH_INST_OPCODE 1 %ecx 4755 ADVANCE_PC 1 4756 GOTO_NEXT_R %ecx 4757 4758.LOP_DOUBLE_TO_INT_special_case: 4759 fnstsw %ax 4760 sahf 4761 jp .LOP_DOUBLE_TO_INT_isNaN 4762 adcl $-1,(rFP,%ecx,4) 4763 .if 0 4764 adcl $-1,4(rFP,%ecx,4) 4765 .endif 4766 jmp .LOP_DOUBLE_TO_INT_finish 4767.LOP_DOUBLE_TO_INT_isNaN: 4768 movl $0,(rFP,%ecx,4) 4769 .if 0 4770 movl $0,4(rFP,%ecx,4) 4771 .endif 4772 jmp .LOP_DOUBLE_TO_INT_finish 4773 4774 4775/* ------------------------------ */ 4776.L_OP_DOUBLE_TO_LONG: /* 0x8b */ 4777/* File: x86/OP_DOUBLE_TO_LONG.S */ 4778/* File: x86/cvtfp_int.S */ 4779/* On fp to int conversions, Java requires that 4780 * if the result > maxint, it should be clamped to maxint. If it is less 4781 * than minint, it should be clamped to minint. If it is a nan, the result 4782 * should be zero. Further, the rounding mode is to truncate. This model 4783 * differs from what is delivered normally via the x86 fpu, so we have 4784 * to play some games. 4785 */ 4786 /* float/double to int/long vA, vB */ 4787 movzbl rINSTbl,%ecx # ecx<- A+ 4788 sarl $4,rINST # rINST<- B 4789 .if 1 4790 fldl (rFP,rINST,4) # %st0<- vB 4791 .else 4792 flds (rFP,rINST,4) # %st0<- vB 4793 .endif 4794 ftst 4795 fnstcw LOCAL0_OFFSET(%ebp) # remember original rounding mode 4796 movzwl LOCAL0_OFFSET(%ebp),%eax 4797 movb $0xc,%ah 4798 movw %ax,LOCAL0_OFFSET+2(%ebp) 4799 fldcw LOCAL0_OFFSET+2(%ebp) # set "to zero" rounding mode 4800 andb $0xf,%cl # ecx<- A 4801 .if 1 4802 fistpll (rFP,%ecx,4) # convert and store 4803 .else 4804 fistpl (rFP,%ecx,4) # convert and store 4805 .endif 4806 fldcw LOCAL0_OFFSET(%ebp) # restore previous rounding mode 4807 .if 1 4808 movl $0x80000000,%eax 4809 xorl 4(rFP,%ecx,4),%eax 4810 orl (rFP,%ecx,4),%eax 4811 .else 4812 cmpl $0x80000000,(rFP,%ecx,4) 4813 .endif 4814 je .LOP_DOUBLE_TO_LONG_special_case # fix up result 4815 4816.LOP_DOUBLE_TO_LONG_finish: 4817 FETCH_INST_OPCODE 1 %ecx 4818 ADVANCE_PC 1 4819 GOTO_NEXT_R %ecx 4820 4821.LOP_DOUBLE_TO_LONG_special_case: 4822 fnstsw %ax 4823 sahf 4824 jp .LOP_DOUBLE_TO_LONG_isNaN 4825 adcl $-1,(rFP,%ecx,4) 4826 .if 1 4827 adcl $-1,4(rFP,%ecx,4) 4828 .endif 4829 jmp .LOP_DOUBLE_TO_LONG_finish 4830.LOP_DOUBLE_TO_LONG_isNaN: 4831 movl $0,(rFP,%ecx,4) 4832 .if 1 4833 movl $0,4(rFP,%ecx,4) 4834 .endif 4835 jmp .LOP_DOUBLE_TO_LONG_finish 4836 4837 4838/* ------------------------------ */ 4839.L_OP_DOUBLE_TO_FLOAT: /* 0x8c */ 4840/* File: x86/OP_DOUBLE_TO_FLOAT.S */ 4841/* File: x86/fpcvt.S */ 4842 /* 4843 * Generic 32-bit FP conversion operation. 4844 */ 4845 /* unop vA, vB */ 4846 movzbl rINSTbl,%ecx # ecx<- A+ 4847 sarl $4,rINST # rINST<- B 4848 fldl (rFP,rINST,4) # %st0<- vB 4849 andb $0xf,%cl # ecx<- A 4850 4851 fstps (rFP,%ecx,4) # vA<- %st0 4852 FETCH_INST_OPCODE 1 %ecx 4853 ADVANCE_PC 1 4854 GOTO_NEXT_R %ecx 4855 4856 4857/* ------------------------------ */ 4858.L_OP_INT_TO_BYTE: /* 0x8d */ 4859/* File: x86/OP_INT_TO_BYTE.S */ 4860/* File: x86/unop.S */ 4861 /* 4862 * Generic 32-bit unary operation. Provide an "instr" line that 4863 * specifies an instruction that performs "result = op eax". 4864 */ 4865 /* unop vA, vB */ 4866 movzbl rINSTbl,%ecx # ecx<- A+ 4867 sarl $4,rINST # rINST<- B 4868 GET_VREG_R %eax rINST # eax<- vB 4869 andb $0xf,%cl # ecx<- A 4870 4871 4872 movsbl %al,%eax 4873 SET_VREG %eax %ecx 4874 FETCH_INST_OPCODE 1 %ecx 4875 ADVANCE_PC 1 4876 GOTO_NEXT_R %ecx 4877 4878 4879/* ------------------------------ */ 4880.L_OP_INT_TO_CHAR: /* 0x8e */ 4881/* File: x86/OP_INT_TO_CHAR.S */ 4882/* File: x86/unop.S */ 4883 /* 4884 * Generic 32-bit unary operation. Provide an "instr" line that 4885 * specifies an instruction that performs "result = op eax". 4886 */ 4887 /* unop vA, vB */ 4888 movzbl rINSTbl,%ecx # ecx<- A+ 4889 sarl $4,rINST # rINST<- B 4890 GET_VREG_R %eax rINST # eax<- vB 4891 andb $0xf,%cl # ecx<- A 4892 4893 4894 movzwl %ax,%eax 4895 SET_VREG %eax %ecx 4896 FETCH_INST_OPCODE 1 %ecx 4897 ADVANCE_PC 1 4898 GOTO_NEXT_R %ecx 4899 4900 4901/* ------------------------------ */ 4902.L_OP_INT_TO_SHORT: /* 0x8f */ 4903/* File: x86/OP_INT_TO_SHORT.S */ 4904/* File: x86/unop.S */ 4905 /* 4906 * Generic 32-bit unary operation. Provide an "instr" line that 4907 * specifies an instruction that performs "result = op eax". 4908 */ 4909 /* unop vA, vB */ 4910 movzbl rINSTbl,%ecx # ecx<- A+ 4911 sarl $4,rINST # rINST<- B 4912 GET_VREG_R %eax rINST # eax<- vB 4913 andb $0xf,%cl # ecx<- A 4914 4915 4916 movswl %ax,%eax 4917 SET_VREG %eax %ecx 4918 FETCH_INST_OPCODE 1 %ecx 4919 ADVANCE_PC 1 4920 GOTO_NEXT_R %ecx 4921 4922 4923/* ------------------------------ */ 4924.L_OP_ADD_INT: /* 0x90 */ 4925/* File: x86/OP_ADD_INT.S */ 4926/* File: x86/binop.S */ 4927 /* 4928 * Generic 32-bit binary operation. Provide an "instr" line that 4929 * specifies an instruction that performs "result = eax op (rFP,%ecx,4)". 4930 * This could be an x86 instruction or a function call. (If the result 4931 * comes back in a register other than eax, you can override "result".) 4932 * 4933 * For: add-int, sub-int, and-int, or-int, 4934 * xor-int, shl-int, shr-int, ushr-int 4935 */ 4936 /* binop vAA, vBB, vCC */ 4937 movzbl 2(rPC),%eax # eax<- BB 4938 movzbl 3(rPC),%ecx # ecx<- CC 4939 GET_VREG_R %eax %eax # eax<- vBB 4940 addl (rFP,%ecx,4),%eax # ex: addl (rFP,%ecx,4),%eax 4941 SET_VREG %eax rINST 4942 FETCH_INST_OPCODE 2 %ecx 4943 ADVANCE_PC 2 4944 GOTO_NEXT_R %ecx 4945 4946 4947/* ------------------------------ */ 4948.L_OP_SUB_INT: /* 0x91 */ 4949/* File: x86/OP_SUB_INT.S */ 4950/* File: x86/binop.S */ 4951 /* 4952 * Generic 32-bit binary operation. Provide an "instr" line that 4953 * specifies an instruction that performs "result = eax op (rFP,%ecx,4)". 4954 * This could be an x86 instruction or a function call. (If the result 4955 * comes back in a register other than eax, you can override "result".) 4956 * 4957 * For: add-int, sub-int, and-int, or-int, 4958 * xor-int, shl-int, shr-int, ushr-int 4959 */ 4960 /* binop vAA, vBB, vCC */ 4961 movzbl 2(rPC),%eax # eax<- BB 4962 movzbl 3(rPC),%ecx # ecx<- CC 4963 GET_VREG_R %eax %eax # eax<- vBB 4964 subl (rFP,%ecx,4),%eax # ex: addl (rFP,%ecx,4),%eax 4965 SET_VREG %eax rINST 4966 FETCH_INST_OPCODE 2 %ecx 4967 ADVANCE_PC 2 4968 GOTO_NEXT_R %ecx 4969 4970 4971/* ------------------------------ */ 4972.L_OP_MUL_INT: /* 0x92 */ 4973/* File: x86/OP_MUL_INT.S */ 4974 /* 4975 * 32-bit binary multiplication. 4976 */ 4977 /* mul vAA, vBB, vCC */ 4978 movzbl 2(rPC),%eax # eax<- BB 4979 movzbl 3(rPC),%ecx # ecx<- CC 4980 GET_VREG_R %eax %eax # eax<- vBB 4981 SPILL(rIBASE) 4982 imull (rFP,%ecx,4),%eax # trashes rIBASE/edx 4983 UNSPILL(rIBASE) 4984 FETCH_INST_OPCODE 2 %ecx 4985 ADVANCE_PC 2 4986 SET_VREG %eax rINST 4987 GOTO_NEXT_R %ecx 4988 4989/* ------------------------------ */ 4990.L_OP_DIV_INT: /* 0x93 */ 4991/* File: x86/OP_DIV_INT.S */ 4992/* File: x86/bindiv.S */ 4993 4994 /* 4995 * 32-bit binary div/rem operation. Handles special case of op0=minint and 4996 * op1=-1. 4997 */ 4998 /* binop vAA, vBB, vCC */ 4999 movzbl 2(rPC),%eax # eax<- BB 5000 movzbl 3(rPC),%ecx # ecx<- CC 5001 GET_VREG_R %eax %eax # eax<- vBB 5002 GET_VREG_R %ecx %ecx # eax<- vBB 5003 SPILL(rIBASE) 5004 cmpl $0,%ecx 5005 je common_errDivideByZero 5006 cmpl $-1,%ecx 5007 jne .LOP_DIV_INT_continue_div 5008 cmpl $0x80000000,%eax 5009 jne .LOP_DIV_INT_continue_div 5010 movl $0x80000000,%eax 5011 SET_VREG %eax rINST 5012 UNSPILL(rIBASE) 5013 FETCH_INST_OPCODE 2 %ecx 5014 ADVANCE_PC 2 5015 GOTO_NEXT_R %ecx 5016 5017.LOP_DIV_INT_continue_div: 5018 cltd 5019 idivl %ecx 5020 SET_VREG %eax rINST 5021 UNSPILL(rIBASE) 5022 FETCH_INST_OPCODE 2 %ecx 5023 ADVANCE_PC 2 5024 GOTO_NEXT_R %ecx 5025 5026 5027/* ------------------------------ */ 5028.L_OP_REM_INT: /* 0x94 */ 5029/* File: x86/OP_REM_INT.S */ 5030/* File: x86/bindiv.S */ 5031 5032 /* 5033 * 32-bit binary div/rem operation. Handles special case of op0=minint and 5034 * op1=-1. 5035 */ 5036 /* binop vAA, vBB, vCC */ 5037 movzbl 2(rPC),%eax # eax<- BB 5038 movzbl 3(rPC),%ecx # ecx<- CC 5039 GET_VREG_R %eax %eax # eax<- vBB 5040 GET_VREG_R %ecx %ecx # eax<- vBB 5041 SPILL(rIBASE) 5042 cmpl $0,%ecx 5043 je common_errDivideByZero 5044 cmpl $-1,%ecx 5045 jne .LOP_REM_INT_continue_div 5046 cmpl $0x80000000,%eax 5047 jne .LOP_REM_INT_continue_div 5048 movl $0,rIBASE 5049 SET_VREG rIBASE rINST 5050 UNSPILL(rIBASE) 5051 FETCH_INST_OPCODE 2 %ecx 5052 ADVANCE_PC 2 5053 GOTO_NEXT_R %ecx 5054 5055.LOP_REM_INT_continue_div: 5056 cltd 5057 idivl %ecx 5058 SET_VREG rIBASE rINST 5059 UNSPILL(rIBASE) 5060 FETCH_INST_OPCODE 2 %ecx 5061 ADVANCE_PC 2 5062 GOTO_NEXT_R %ecx 5063 5064 5065/* ------------------------------ */ 5066.L_OP_AND_INT: /* 0x95 */ 5067/* File: x86/OP_AND_INT.S */ 5068/* File: x86/binop.S */ 5069 /* 5070 * Generic 32-bit binary operation. Provide an "instr" line that 5071 * specifies an instruction that performs "result = eax op (rFP,%ecx,4)". 5072 * This could be an x86 instruction or a function call. (If the result 5073 * comes back in a register other than eax, you can override "result".) 5074 * 5075 * For: add-int, sub-int, and-int, or-int, 5076 * xor-int, shl-int, shr-int, ushr-int 5077 */ 5078 /* binop vAA, vBB, vCC */ 5079 movzbl 2(rPC),%eax # eax<- BB 5080 movzbl 3(rPC),%ecx # ecx<- CC 5081 GET_VREG_R %eax %eax # eax<- vBB 5082 andl (rFP,%ecx,4),%eax # ex: addl (rFP,%ecx,4),%eax 5083 SET_VREG %eax rINST 5084 FETCH_INST_OPCODE 2 %ecx 5085 ADVANCE_PC 2 5086 GOTO_NEXT_R %ecx 5087 5088 5089/* ------------------------------ */ 5090.L_OP_OR_INT: /* 0x96 */ 5091/* File: x86/OP_OR_INT.S */ 5092/* File: x86/binop.S */ 5093 /* 5094 * Generic 32-bit binary operation. Provide an "instr" line that 5095 * specifies an instruction that performs "result = eax op (rFP,%ecx,4)". 5096 * This could be an x86 instruction or a function call. (If the result 5097 * comes back in a register other than eax, you can override "result".) 5098 * 5099 * For: add-int, sub-int, and-int, or-int, 5100 * xor-int, shl-int, shr-int, ushr-int 5101 */ 5102 /* binop vAA, vBB, vCC */ 5103 movzbl 2(rPC),%eax # eax<- BB 5104 movzbl 3(rPC),%ecx # ecx<- CC 5105 GET_VREG_R %eax %eax # eax<- vBB 5106 orl (rFP,%ecx,4),%eax # ex: addl (rFP,%ecx,4),%eax 5107 SET_VREG %eax rINST 5108 FETCH_INST_OPCODE 2 %ecx 5109 ADVANCE_PC 2 5110 GOTO_NEXT_R %ecx 5111 5112 5113/* ------------------------------ */ 5114.L_OP_XOR_INT: /* 0x97 */ 5115/* File: x86/OP_XOR_INT.S */ 5116/* File: x86/binop.S */ 5117 /* 5118 * Generic 32-bit binary operation. Provide an "instr" line that 5119 * specifies an instruction that performs "result = eax op (rFP,%ecx,4)". 5120 * This could be an x86 instruction or a function call. (If the result 5121 * comes back in a register other than eax, you can override "result".) 5122 * 5123 * For: add-int, sub-int, and-int, or-int, 5124 * xor-int, shl-int, shr-int, ushr-int 5125 */ 5126 /* binop vAA, vBB, vCC */ 5127 movzbl 2(rPC),%eax # eax<- BB 5128 movzbl 3(rPC),%ecx # ecx<- CC 5129 GET_VREG_R %eax %eax # eax<- vBB 5130 xorl (rFP,%ecx,4),%eax # ex: addl (rFP,%ecx,4),%eax 5131 SET_VREG %eax rINST 5132 FETCH_INST_OPCODE 2 %ecx 5133 ADVANCE_PC 2 5134 GOTO_NEXT_R %ecx 5135 5136 5137/* ------------------------------ */ 5138.L_OP_SHL_INT: /* 0x98 */ 5139/* File: x86/OP_SHL_INT.S */ 5140/* File: x86/binop1.S */ 5141 /* 5142 * Generic 32-bit binary operation in which both operands loaded to 5143 * registers (op0 in eax, op1 in ecx). 5144 */ 5145 /* binop vAA, vBB, vCC */ 5146 movzbl 2(rPC),%eax # eax<- BB 5147 movzbl 3(rPC),%ecx # ecx<- CC 5148 GET_VREG_R %eax %eax # eax<- vBB 5149 GET_VREG_R %ecx %ecx # eax<- vBB 5150 sall %cl,%eax # ex: addl %ecx,%eax 5151 SET_VREG %eax rINST 5152 FETCH_INST_OPCODE 2 %ecx 5153 ADVANCE_PC 2 5154 GOTO_NEXT_R %ecx 5155 5156 5157/* ------------------------------ */ 5158.L_OP_SHR_INT: /* 0x99 */ 5159/* File: x86/OP_SHR_INT.S */ 5160/* File: x86/binop1.S */ 5161 /* 5162 * Generic 32-bit binary operation in which both operands loaded to 5163 * registers (op0 in eax, op1 in ecx). 5164 */ 5165 /* binop vAA, vBB, vCC */ 5166 movzbl 2(rPC),%eax # eax<- BB 5167 movzbl 3(rPC),%ecx # ecx<- CC 5168 GET_VREG_R %eax %eax # eax<- vBB 5169 GET_VREG_R %ecx %ecx # eax<- vBB 5170 sarl %cl,%eax # ex: addl %ecx,%eax 5171 SET_VREG %eax rINST 5172 FETCH_INST_OPCODE 2 %ecx 5173 ADVANCE_PC 2 5174 GOTO_NEXT_R %ecx 5175 5176 5177/* ------------------------------ */ 5178.L_OP_USHR_INT: /* 0x9a */ 5179/* File: x86/OP_USHR_INT.S */ 5180/* File: x86/binop1.S */ 5181 /* 5182 * Generic 32-bit binary operation in which both operands loaded to 5183 * registers (op0 in eax, op1 in ecx). 5184 */ 5185 /* binop vAA, vBB, vCC */ 5186 movzbl 2(rPC),%eax # eax<- BB 5187 movzbl 3(rPC),%ecx # ecx<- CC 5188 GET_VREG_R %eax %eax # eax<- vBB 5189 GET_VREG_R %ecx %ecx # eax<- vBB 5190 shrl %cl,%eax # ex: addl %ecx,%eax 5191 SET_VREG %eax rINST 5192 FETCH_INST_OPCODE 2 %ecx 5193 ADVANCE_PC 2 5194 GOTO_NEXT_R %ecx 5195 5196 5197/* ------------------------------ */ 5198.L_OP_ADD_LONG: /* 0x9b */ 5199/* File: x86/OP_ADD_LONG.S */ 5200/* File: x86/binopWide.S */ 5201 /* 5202 * Generic 64-bit binary operation. 5203 */ 5204 /* binop vAA, vBB, vCC */ 5205 5206 movzbl 2(rPC),%eax # eax<- BB 5207 movzbl 3(rPC),%ecx # ecx<- CC 5208 SPILL(rIBASE) # save rIBASE 5209 GET_VREG_WORD rIBASE %eax 0 # rIBASE<- v[BB+0] 5210 GET_VREG_WORD %eax %eax 1 # eax<- v[BB+1] 5211 addl (rFP,%ecx,4),rIBASE # ex: addl (rFP,%ecx,4),rIBASE 5212 adcl 4(rFP,%ecx,4),%eax # ex: adcl 4(rFP,%ecx,4),%eax 5213 SET_VREG_WORD rIBASE rINST 0 # v[AA+0] <- rIBASE 5214 FETCH_INST_OPCODE 2 %ecx 5215 UNSPILL(rIBASE) # restore rIBASE 5216 SET_VREG_WORD %eax rINST 1 # v[AA+1] <- eax 5217 ADVANCE_PC 2 5218 GOTO_NEXT_R %ecx 5219 5220 5221/* ------------------------------ */ 5222.L_OP_SUB_LONG: /* 0x9c */ 5223/* File: x86/OP_SUB_LONG.S */ 5224/* File: x86/binopWide.S */ 5225 /* 5226 * Generic 64-bit binary operation. 5227 */ 5228 /* binop vAA, vBB, vCC */ 5229 5230 movzbl 2(rPC),%eax # eax<- BB 5231 movzbl 3(rPC),%ecx # ecx<- CC 5232 SPILL(rIBASE) # save rIBASE 5233 GET_VREG_WORD rIBASE %eax 0 # rIBASE<- v[BB+0] 5234 GET_VREG_WORD %eax %eax 1 # eax<- v[BB+1] 5235 subl (rFP,%ecx,4),rIBASE # ex: addl (rFP,%ecx,4),rIBASE 5236 sbbl 4(rFP,%ecx,4),%eax # ex: adcl 4(rFP,%ecx,4),%eax 5237 SET_VREG_WORD rIBASE rINST 0 # v[AA+0] <- rIBASE 5238 FETCH_INST_OPCODE 2 %ecx 5239 UNSPILL(rIBASE) # restore rIBASE 5240 SET_VREG_WORD %eax rINST 1 # v[AA+1] <- eax 5241 ADVANCE_PC 2 5242 GOTO_NEXT_R %ecx 5243 5244 5245/* ------------------------------ */ 5246.L_OP_MUL_LONG: /* 0x9d */ 5247/* File: x86/OP_MUL_LONG.S */ 5248 /* 5249 * Signed 64-bit integer multiply. 5250 * 5251 * We could definately use more free registers for 5252 * this code. We spill rINSTw (ebx), 5253 * giving us eax, ebc, ecx and edx as computational 5254 * temps. On top of that, we'll spill edi (rFP) 5255 * for use as the vB pointer and esi (rPC) for use 5256 * as the vC pointer. Yuck. 5257 */ 5258 /* mul-long vAA, vBB, vCC */ 5259 movzbl 2(rPC),%eax # eax<- B 5260 movzbl 3(rPC),%ecx # ecx<- C 5261 SPILL_TMP2(%esi) # save Dalvik PC 5262 SPILL(rFP) 5263 SPILL(rINST) 5264 SPILL(rIBASE) 5265 leal (rFP,%eax,4),%esi # esi<- &v[B] 5266 leal (rFP,%ecx,4),rFP # rFP<- &v[C] 5267 movl 4(%esi),%ecx # ecx<- Bmsw 5268 imull (rFP),%ecx # ecx<- (Bmsw*Clsw) 5269 movl 4(rFP),%eax # eax<- Cmsw 5270 imull (%esi),%eax # eax<- (Cmsw*Blsw) 5271 addl %eax,%ecx # ecx<- (Bmsw*Clsw)+(Cmsw*Blsw) 5272 movl (rFP),%eax # eax<- Clsw 5273 mull (%esi) # eax<- (Clsw*Alsw) 5274 UNSPILL(rINST) 5275 UNSPILL(rFP) 5276 leal (%ecx,rIBASE),rIBASE # full result now in rIBASE:%eax 5277 UNSPILL_TMP2(%esi) # Restore Dalvik PC 5278 FETCH_INST_OPCODE 2 %ecx # Fetch next instruction 5279 movl rIBASE,4(rFP,rINST,4)# v[B+1]<- rIBASE 5280 UNSPILL(rIBASE) 5281 movl %eax,(rFP,rINST,4) # v[B]<- %eax 5282 ADVANCE_PC 2 5283 GOTO_NEXT_R %ecx 5284 5285/* ------------------------------ */ 5286.L_OP_DIV_LONG: /* 0x9e */ 5287/* File: x86/OP_DIV_LONG.S */ 5288 /* div vAA, vBB, vCC */ 5289 movzbl 3(rPC),%eax # eax<- CC 5290 movzbl 2(rPC),%ecx # ecx<- BB 5291 SPILL(rIBASE) # save rIBASE/%edx 5292 GET_VREG_WORD rIBASE %eax 0 5293 GET_VREG_WORD %eax %eax 1 5294 movl rIBASE,OUT_ARG2(%esp) 5295 testl %eax,%eax 5296 je .LOP_DIV_LONG_check_zero 5297 cmpl $-1,%eax 5298 je .LOP_DIV_LONG_check_neg1 5299.LOP_DIV_LONG_notSpecial: 5300 GET_VREG_WORD rIBASE %ecx 0 5301 GET_VREG_WORD %ecx %ecx 1 5302.LOP_DIV_LONG_notSpecial1: 5303 movl %eax,OUT_ARG3(%esp) 5304 movl rIBASE,OUT_ARG0(%esp) 5305 movl %ecx,OUT_ARG1(%esp) 5306 call __divdi3 5307.LOP_DIV_LONG_finish: 5308 SET_VREG_WORD rIBASE rINST 1 5309 UNSPILL(rIBASE) # restore rIBASE/%edx 5310 SET_VREG_WORD %eax rINST 0 5311 FETCH_INST_OPCODE 2 %ecx 5312 ADVANCE_PC 2 5313 GOTO_NEXT_R %ecx 5314 5315.LOP_DIV_LONG_check_zero: 5316 testl rIBASE,rIBASE 5317 jne .LOP_DIV_LONG_notSpecial 5318 jmp common_errDivideByZero 5319.LOP_DIV_LONG_check_neg1: 5320 testl rIBASE,%eax 5321 jne .LOP_DIV_LONG_notSpecial 5322 GET_VREG_WORD rIBASE %ecx 0 5323 GET_VREG_WORD %ecx %ecx 1 5324 testl rIBASE,rIBASE 5325 jne .LOP_DIV_LONG_notSpecial1 5326 cmpl $0x80000000,%ecx 5327 jne .LOP_DIV_LONG_notSpecial1 5328 /* minint / -1, return minint on div, 0 on rem */ 5329 xorl %eax,%eax 5330 movl $0x80000000,rIBASE 5331 jmp .LOP_DIV_LONG_finish 5332 5333/* ------------------------------ */ 5334.L_OP_REM_LONG: /* 0x9f */ 5335/* File: x86/OP_REM_LONG.S */ 5336/* File: x86/OP_DIV_LONG.S */ 5337 /* div vAA, vBB, vCC */ 5338 movzbl 3(rPC),%eax # eax<- CC 5339 movzbl 2(rPC),%ecx # ecx<- BB 5340 SPILL(rIBASE) # save rIBASE/%edx 5341 GET_VREG_WORD rIBASE %eax 0 5342 GET_VREG_WORD %eax %eax 1 5343 movl rIBASE,OUT_ARG2(%esp) 5344 testl %eax,%eax 5345 je .LOP_REM_LONG_check_zero 5346 cmpl $-1,%eax 5347 je .LOP_REM_LONG_check_neg1 5348.LOP_REM_LONG_notSpecial: 5349 GET_VREG_WORD rIBASE %ecx 0 5350 GET_VREG_WORD %ecx %ecx 1 5351.LOP_REM_LONG_notSpecial1: 5352 movl %eax,OUT_ARG3(%esp) 5353 movl rIBASE,OUT_ARG0(%esp) 5354 movl %ecx,OUT_ARG1(%esp) 5355 call __moddi3 5356.LOP_REM_LONG_finish: 5357 SET_VREG_WORD rIBASE rINST 1 5358 UNSPILL(rIBASE) # restore rIBASE/%edx 5359 SET_VREG_WORD %eax rINST 0 5360 FETCH_INST_OPCODE 2 %ecx 5361 ADVANCE_PC 2 5362 GOTO_NEXT_R %ecx 5363 5364.LOP_REM_LONG_check_zero: 5365 testl rIBASE,rIBASE 5366 jne .LOP_REM_LONG_notSpecial 5367 jmp common_errDivideByZero 5368.LOP_REM_LONG_check_neg1: 5369 testl rIBASE,%eax 5370 jne .LOP_REM_LONG_notSpecial 5371 GET_VREG_WORD rIBASE %ecx 0 5372 GET_VREG_WORD %ecx %ecx 1 5373 testl rIBASE,rIBASE 5374 jne .LOP_REM_LONG_notSpecial1 5375 cmpl $0x80000000,%ecx 5376 jne .LOP_REM_LONG_notSpecial1 5377 /* minint / -1, return minint on div, 0 on rem */ 5378 xorl %eax,%eax 5379 movl $0,rIBASE 5380 jmp .LOP_REM_LONG_finish 5381 5382 5383/* ------------------------------ */ 5384.L_OP_AND_LONG: /* 0xa0 */ 5385/* File: x86/OP_AND_LONG.S */ 5386/* File: x86/binopWide.S */ 5387 /* 5388 * Generic 64-bit binary operation. 5389 */ 5390 /* binop vAA, vBB, vCC */ 5391 5392 movzbl 2(rPC),%eax # eax<- BB 5393 movzbl 3(rPC),%ecx # ecx<- CC 5394 SPILL(rIBASE) # save rIBASE 5395 GET_VREG_WORD rIBASE %eax 0 # rIBASE<- v[BB+0] 5396 GET_VREG_WORD %eax %eax 1 # eax<- v[BB+1] 5397 andl (rFP,%ecx,4),rIBASE # ex: addl (rFP,%ecx,4),rIBASE 5398 andl 4(rFP,%ecx,4),%eax # ex: adcl 4(rFP,%ecx,4),%eax 5399 SET_VREG_WORD rIBASE rINST 0 # v[AA+0] <- rIBASE 5400 FETCH_INST_OPCODE 2 %ecx 5401 UNSPILL(rIBASE) # restore rIBASE 5402 SET_VREG_WORD %eax rINST 1 # v[AA+1] <- eax 5403 ADVANCE_PC 2 5404 GOTO_NEXT_R %ecx 5405 5406 5407/* ------------------------------ */ 5408.L_OP_OR_LONG: /* 0xa1 */ 5409/* File: x86/OP_OR_LONG.S */ 5410/* File: x86/binopWide.S */ 5411 /* 5412 * Generic 64-bit binary operation. 5413 */ 5414 /* binop vAA, vBB, vCC */ 5415 5416 movzbl 2(rPC),%eax # eax<- BB 5417 movzbl 3(rPC),%ecx # ecx<- CC 5418 SPILL(rIBASE) # save rIBASE 5419 GET_VREG_WORD rIBASE %eax 0 # rIBASE<- v[BB+0] 5420 GET_VREG_WORD %eax %eax 1 # eax<- v[BB+1] 5421 orl (rFP,%ecx,4),rIBASE # ex: addl (rFP,%ecx,4),rIBASE 5422 orl 4(rFP,%ecx,4),%eax # ex: adcl 4(rFP,%ecx,4),%eax 5423 SET_VREG_WORD rIBASE rINST 0 # v[AA+0] <- rIBASE 5424 FETCH_INST_OPCODE 2 %ecx 5425 UNSPILL(rIBASE) # restore rIBASE 5426 SET_VREG_WORD %eax rINST 1 # v[AA+1] <- eax 5427 ADVANCE_PC 2 5428 GOTO_NEXT_R %ecx 5429 5430 5431/* ------------------------------ */ 5432.L_OP_XOR_LONG: /* 0xa2 */ 5433/* File: x86/OP_XOR_LONG.S */ 5434/* File: x86/binopWide.S */ 5435 /* 5436 * Generic 64-bit binary operation. 5437 */ 5438 /* binop vAA, vBB, vCC */ 5439 5440 movzbl 2(rPC),%eax # eax<- BB 5441 movzbl 3(rPC),%ecx # ecx<- CC 5442 SPILL(rIBASE) # save rIBASE 5443 GET_VREG_WORD rIBASE %eax 0 # rIBASE<- v[BB+0] 5444 GET_VREG_WORD %eax %eax 1 # eax<- v[BB+1] 5445 xorl (rFP,%ecx,4),rIBASE # ex: addl (rFP,%ecx,4),rIBASE 5446 xorl 4(rFP,%ecx,4),%eax # ex: adcl 4(rFP,%ecx,4),%eax 5447 SET_VREG_WORD rIBASE rINST 0 # v[AA+0] <- rIBASE 5448 FETCH_INST_OPCODE 2 %ecx 5449 UNSPILL(rIBASE) # restore rIBASE 5450 SET_VREG_WORD %eax rINST 1 # v[AA+1] <- eax 5451 ADVANCE_PC 2 5452 GOTO_NEXT_R %ecx 5453 5454 5455/* ------------------------------ */ 5456.L_OP_SHL_LONG: /* 0xa3 */ 5457/* File: x86/OP_SHL_LONG.S */ 5458 /* 5459 * Long integer shift. This is different from the generic 32/64-bit 5460 * binary operations because vAA/vBB are 64-bit but vCC (the shift 5461 * distance) is 32-bit. Also, Dalvik requires us to mask off the low 5462 * 6 bits of the shift distance. x86 shifts automatically mask off 5463 * the low 5 bits of %cl, so have to handle the 64 > shiftcount > 31 5464 * case specially. 5465 */ 5466 /* shl-long vAA, vBB, vCC */ 5467 /* ecx gets shift count */ 5468 /* Need to spill rINST */ 5469 /* rINSTw gets AA */ 5470 movzbl 2(rPC),%eax # eax<- BB 5471 movzbl 3(rPC),%ecx # ecx<- CC 5472 SPILL(rIBASE) 5473 GET_VREG_WORD rIBASE %eax 1 # ecx<- v[BB+1] 5474 GET_VREG_R %ecx %ecx # ecx<- vCC 5475 GET_VREG_WORD %eax %eax 0 # eax<- v[BB+0] 5476 shldl %eax,rIBASE 5477 sall %cl,%eax 5478 testb $32,%cl 5479 je 2f 5480 movl %eax,rIBASE 5481 xorl %eax,%eax 54822: 5483 SET_VREG_WORD rIBASE rINST 1 # v[AA+1]<- rIBASE 5484 FETCH_INST_OPCODE 2 %ecx 5485 UNSPILL(rIBASE) 5486 SET_VREG_WORD %eax rINST 0 # v[AA+0]<- %eax 5487 ADVANCE_PC 2 5488 GOTO_NEXT_R %ecx 5489 5490/* ------------------------------ */ 5491.L_OP_SHR_LONG: /* 0xa4 */ 5492/* File: x86/OP_SHR_LONG.S */ 5493 /* 5494 * Long integer shift. This is different from the generic 32/64-bit 5495 * binary operations because vAA/vBB are 64-bit but vCC (the shift 5496 * distance) is 32-bit. Also, Dalvik requires us to mask off the low 5497 * 6 bits of the shift distance. x86 shifts automatically mask off 5498 * the low 5 bits of %cl, so have to handle the 64 > shiftcount > 31 5499 * case specially. 5500 */ 5501 /* shr-long vAA, vBB, vCC */ 5502 /* ecx gets shift count */ 5503 /* Need to spill rIBASE */ 5504 /* rINSTw gets AA */ 5505 movzbl 2(rPC),%eax # eax<- BB 5506 movzbl 3(rPC),%ecx # ecx<- CC 5507 SPILL(rIBASE) 5508 GET_VREG_WORD rIBASE %eax 1 # rIBASE<- v[BB+1] 5509 GET_VREG_R %ecx %ecx # ecx<- vCC 5510 GET_VREG_WORD %eax %eax 0 # eax<- v[BB+0] 5511 shrdl rIBASE,%eax 5512 sarl %cl,rIBASE 5513 testb $32,%cl 5514 je 2f 5515 movl rIBASE,%eax 5516 sarl $31,rIBASE 55172: 5518 SET_VREG_WORD rIBASE rINST 1 # v[AA+1]<- rIBASE 5519 FETCH_INST_OPCODE 2 %ecx 5520 UNSPILL(rIBASE) 5521 SET_VREG_WORD %eax rINST 0 # v[AA+0]<- eax 5522 ADVANCE_PC 2 5523 GOTO_NEXT_R %ecx 5524 5525/* ------------------------------ */ 5526.L_OP_USHR_LONG: /* 0xa5 */ 5527/* File: x86/OP_USHR_LONG.S */ 5528 /* 5529 * Long integer shift. This is different from the generic 32/64-bit 5530 * binary operations because vAA/vBB are 64-bit but vCC (the shift 5531 * distance) is 32-bit. Also, Dalvik requires us to mask off the low 5532 * 6 bits of the shift distance. x86 shifts automatically mask off 5533 * the low 5 bits of %cl, so have to handle the 64 > shiftcount > 31 5534 * case specially. 5535 */ 5536 /* shr-long vAA, vBB, vCC */ 5537 /* ecx gets shift count */ 5538 /* Need to spill rIBASE */ 5539 /* rINSTw gets AA */ 5540 movzbl 2(rPC),%eax # eax<- BB 5541 movzbl 3(rPC),%ecx # ecx<- CC 5542 SPILL(rIBASE) 5543 GET_VREG_WORD rIBASE %eax 1 # rIBASE<- v[BB+1] 5544 GET_VREG_R %ecx %ecx # ecx<- vCC 5545 GET_VREG_WORD %eax %eax 0 # eax<- v[BB+0] 5546 shrdl rIBASE,%eax 5547 shrl %cl,rIBASE 5548 testb $32,%cl 5549 je 2f 5550 movl rIBASE,%eax 5551 xorl rIBASE,rIBASE 55522: 5553 SET_VREG_WORD rIBASE rINST 1 # v[AA+1]<- rIBASE 5554 FETCH_INST_OPCODE 2 %ecx 5555 UNSPILL(rIBASE) 5556 SET_VREG_WORD %eax rINST 0 # v[BB+0]<- eax 5557 ADVANCE_PC 2 5558 GOTO_NEXT_R %ecx 5559 5560/* ------------------------------ */ 5561.L_OP_ADD_FLOAT: /* 0xa6 */ 5562/* File: x86/OP_ADD_FLOAT.S */ 5563/* File: x86/binflop.S */ 5564 /* 5565 * Generic 32-bit binary float operation. 5566 * 5567 * For: add-fp, sub-fp, mul-fp, div-fp 5568 */ 5569 /* binop vAA, vBB, vCC */ 5570 movzbl 2(rPC),%eax # eax<- CC 5571 movzbl 3(rPC),%ecx # ecx<- BB 5572 flds (rFP,%eax,4) # vCC to fp stack 5573 fadds (rFP,%ecx,4) # ex: faddp 5574 FETCH_INST_OPCODE 2 %ecx 5575 ADVANCE_PC 2 5576 fstps (rFP,rINST,4) # %st to vAA 5577 GOTO_NEXT_R %ecx 5578 5579 5580/* ------------------------------ */ 5581.L_OP_SUB_FLOAT: /* 0xa7 */ 5582/* File: x86/OP_SUB_FLOAT.S */ 5583/* File: x86/binflop.S */ 5584 /* 5585 * Generic 32-bit binary float operation. 5586 * 5587 * For: add-fp, sub-fp, mul-fp, div-fp 5588 */ 5589 /* binop vAA, vBB, vCC */ 5590 movzbl 2(rPC),%eax # eax<- CC 5591 movzbl 3(rPC),%ecx # ecx<- BB 5592 flds (rFP,%eax,4) # vCC to fp stack 5593 fsubs (rFP,%ecx,4) # ex: faddp 5594 FETCH_INST_OPCODE 2 %ecx 5595 ADVANCE_PC 2 5596 fstps (rFP,rINST,4) # %st to vAA 5597 GOTO_NEXT_R %ecx 5598 5599 5600/* ------------------------------ */ 5601.L_OP_MUL_FLOAT: /* 0xa8 */ 5602/* File: x86/OP_MUL_FLOAT.S */ 5603/* File: x86/binflop.S */ 5604 /* 5605 * Generic 32-bit binary float operation. 5606 * 5607 * For: add-fp, sub-fp, mul-fp, div-fp 5608 */ 5609 /* binop vAA, vBB, vCC */ 5610 movzbl 2(rPC),%eax # eax<- CC 5611 movzbl 3(rPC),%ecx # ecx<- BB 5612 flds (rFP,%eax,4) # vCC to fp stack 5613 fmuls (rFP,%ecx,4) # ex: faddp 5614 FETCH_INST_OPCODE 2 %ecx 5615 ADVANCE_PC 2 5616 fstps (rFP,rINST,4) # %st to vAA 5617 GOTO_NEXT_R %ecx 5618 5619 5620/* ------------------------------ */ 5621.L_OP_DIV_FLOAT: /* 0xa9 */ 5622/* File: x86/OP_DIV_FLOAT.S */ 5623/* File: x86/binflop.S */ 5624 /* 5625 * Generic 32-bit binary float operation. 5626 * 5627 * For: add-fp, sub-fp, mul-fp, div-fp 5628 */ 5629 /* binop vAA, vBB, vCC */ 5630 movzbl 2(rPC),%eax # eax<- CC 5631 movzbl 3(rPC),%ecx # ecx<- BB 5632 flds (rFP,%eax,4) # vCC to fp stack 5633 fdivs (rFP,%ecx,4) # ex: faddp 5634 FETCH_INST_OPCODE 2 %ecx 5635 ADVANCE_PC 2 5636 fstps (rFP,rINST,4) # %st to vAA 5637 GOTO_NEXT_R %ecx 5638 5639 5640/* ------------------------------ */ 5641.L_OP_REM_FLOAT: /* 0xaa */ 5642/* File: x86/OP_REM_FLOAT.S */ 5643 /* rem_float vAA, vBB, vCC */ 5644 movzbl 3(rPC),%ecx # ecx<- BB 5645 movzbl 2(rPC),%eax # eax<- CC 5646 flds (rFP,%ecx,4) # vCC to fp stack 5647 flds (rFP,%eax,4) # vCC to fp stack 5648 movzbl rINSTbl,%ecx # ecx<- AA 56491: 5650 fprem 5651 fstsw %ax 5652 sahf 5653 jp 1b 5654 fstp %st(1) 5655 FETCH_INST_OPCODE 2 %eax 5656 ADVANCE_PC 2 5657 fstps (rFP,%ecx,4) # %st to vAA 5658 GOTO_NEXT_R %eax 5659 5660/* ------------------------------ */ 5661.L_OP_ADD_DOUBLE: /* 0xab */ 5662/* File: x86/OP_ADD_DOUBLE.S */ 5663/* File: x86/binflop.S */ 5664 /* 5665 * Generic 32-bit binary float operation. 5666 * 5667 * For: add-fp, sub-fp, mul-fp, div-fp 5668 */ 5669 /* binop vAA, vBB, vCC */ 5670 movzbl 2(rPC),%eax # eax<- CC 5671 movzbl 3(rPC),%ecx # ecx<- BB 5672 fldl (rFP,%eax,4) # vCC to fp stack 5673 faddl (rFP,%ecx,4) # ex: faddp 5674 FETCH_INST_OPCODE 2 %ecx 5675 ADVANCE_PC 2 5676 fstpl (rFP,rINST,4) # %st to vAA 5677 GOTO_NEXT_R %ecx 5678 5679 5680/* ------------------------------ */ 5681.L_OP_SUB_DOUBLE: /* 0xac */ 5682/* File: x86/OP_SUB_DOUBLE.S */ 5683/* File: x86/binflop.S */ 5684 /* 5685 * Generic 32-bit binary float operation. 5686 * 5687 * For: add-fp, sub-fp, mul-fp, div-fp 5688 */ 5689 /* binop vAA, vBB, vCC */ 5690 movzbl 2(rPC),%eax # eax<- CC 5691 movzbl 3(rPC),%ecx # ecx<- BB 5692 fldl (rFP,%eax,4) # vCC to fp stack 5693 fsubl (rFP,%ecx,4) # ex: faddp 5694 FETCH_INST_OPCODE 2 %ecx 5695 ADVANCE_PC 2 5696 fstpl (rFP,rINST,4) # %st to vAA 5697 GOTO_NEXT_R %ecx 5698 5699 5700/* ------------------------------ */ 5701.L_OP_MUL_DOUBLE: /* 0xad */ 5702/* File: x86/OP_MUL_DOUBLE.S */ 5703/* File: x86/binflop.S */ 5704 /* 5705 * Generic 32-bit binary float operation. 5706 * 5707 * For: add-fp, sub-fp, mul-fp, div-fp 5708 */ 5709 /* binop vAA, vBB, vCC */ 5710 movzbl 2(rPC),%eax # eax<- CC 5711 movzbl 3(rPC),%ecx # ecx<- BB 5712 fldl (rFP,%eax,4) # vCC to fp stack 5713 fmull (rFP,%ecx,4) # ex: faddp 5714 FETCH_INST_OPCODE 2 %ecx 5715 ADVANCE_PC 2 5716 fstpl (rFP,rINST,4) # %st to vAA 5717 GOTO_NEXT_R %ecx 5718 5719 5720/* ------------------------------ */ 5721.L_OP_DIV_DOUBLE: /* 0xae */ 5722/* File: x86/OP_DIV_DOUBLE.S */ 5723/* File: x86/binflop.S */ 5724 /* 5725 * Generic 32-bit binary float operation. 5726 * 5727 * For: add-fp, sub-fp, mul-fp, div-fp 5728 */ 5729 /* binop vAA, vBB, vCC */ 5730 movzbl 2(rPC),%eax # eax<- CC 5731 movzbl 3(rPC),%ecx # ecx<- BB 5732 fldl (rFP,%eax,4) # vCC to fp stack 5733 fdivl (rFP,%ecx,4) # ex: faddp 5734 FETCH_INST_OPCODE 2 %ecx 5735 ADVANCE_PC 2 5736 fstpl (rFP,rINST,4) # %st to vAA 5737 GOTO_NEXT_R %ecx 5738 5739 5740/* ------------------------------ */ 5741.L_OP_REM_DOUBLE: /* 0xaf */ 5742/* File: x86/OP_REM_DOUBLE.S */ 5743 /* rem_float vAA, vBB, vCC */ 5744 movzbl 3(rPC),%ecx # ecx<- BB 5745 movzbl 2(rPC),%eax # eax<- CC 5746 fldl (rFP,%ecx,4) # vCC to fp stack 5747 fldl (rFP,%eax,4) # vCC to fp stack 5748 FETCH_INST_OPCODE 2 %ecx 57491: 5750 fprem 5751 fstsw %ax 5752 sahf 5753 jp 1b 5754 fstp %st(1) 5755 ADVANCE_PC 2 5756 fstpl (rFP,rINST,4) # %st to vAA 5757 GOTO_NEXT_R %ecx 5758 5759/* ------------------------------ */ 5760.L_OP_ADD_INT_2ADDR: /* 0xb0 */ 5761/* File: x86/OP_ADD_INT_2ADDR.S */ 5762/* File: x86/binop2addr.S */ 5763 /* 5764 * Generic 32-bit "/2addr" binary operation. Provide an "instr" line 5765 * that specifies an instruction that performs "result = r0 op r1". 5766 * This could be an ARM instruction or a function call. (If the result 5767 * comes back in a register other than r0, you can override "result".) 5768 * 5769 * If "chkzero" is set to 1, we perform a divide-by-zero check on 5770 * vCC (r1). Useful for integer division and modulus. 5771 * 5772 * For: add-int/2addr, sub-int/2addr, mul-int/2addr, div-int/2addr, 5773 * rem-int/2addr, and-int/2addr, or-int/2addr, xor-int/2addr, 5774 * shl-int/2addr, shr-int/2addr, ushr-int/2addr, add-float/2addr, 5775 * sub-float/2addr, mul-float/2addr, div-float/2addr, rem-float/2addr 5776 */ 5777 /* binop/2addr vA, vB */ 5778 movzx rINSTbl,%ecx # ecx<- A+ 5779 sarl $4,rINST # rINST<- B 5780 GET_VREG_R %eax rINST # eax<- vB 5781 andb $0xf,%cl # ecx<- A 5782 addl %eax,(rFP,%ecx,4) # for ex: addl %eax,(rFP,%ecx,4) 5783 FETCH_INST_OPCODE 1 %ecx 5784 ADVANCE_PC 1 5785 GOTO_NEXT_R %ecx 5786 5787 5788/* ------------------------------ */ 5789.L_OP_SUB_INT_2ADDR: /* 0xb1 */ 5790/* File: x86/OP_SUB_INT_2ADDR.S */ 5791/* File: x86/binop2addr.S */ 5792 /* 5793 * Generic 32-bit "/2addr" binary operation. Provide an "instr" line 5794 * that specifies an instruction that performs "result = r0 op r1". 5795 * This could be an ARM instruction or a function call. (If the result 5796 * comes back in a register other than r0, you can override "result".) 5797 * 5798 * If "chkzero" is set to 1, we perform a divide-by-zero check on 5799 * vCC (r1). Useful for integer division and modulus. 5800 * 5801 * For: add-int/2addr, sub-int/2addr, mul-int/2addr, div-int/2addr, 5802 * rem-int/2addr, and-int/2addr, or-int/2addr, xor-int/2addr, 5803 * shl-int/2addr, shr-int/2addr, ushr-int/2addr, add-float/2addr, 5804 * sub-float/2addr, mul-float/2addr, div-float/2addr, rem-float/2addr 5805 */ 5806 /* binop/2addr vA, vB */ 5807 movzx rINSTbl,%ecx # ecx<- A+ 5808 sarl $4,rINST # rINST<- B 5809 GET_VREG_R %eax rINST # eax<- vB 5810 andb $0xf,%cl # ecx<- A 5811 subl %eax,(rFP,%ecx,4) # for ex: addl %eax,(rFP,%ecx,4) 5812 FETCH_INST_OPCODE 1 %ecx 5813 ADVANCE_PC 1 5814 GOTO_NEXT_R %ecx 5815 5816 5817/* ------------------------------ */ 5818.L_OP_MUL_INT_2ADDR: /* 0xb2 */ 5819/* File: x86/OP_MUL_INT_2ADDR.S */ 5820 /* mul vA, vB */ 5821 movzx rINSTbl,%ecx # ecx<- A+ 5822 sarl $4,rINST # rINST<- B 5823 GET_VREG_R %eax rINST # eax<- vB 5824 andb $0xf,%cl # ecx<- A 5825 SPILL(rIBASE) 5826 imull (rFP,%ecx,4),%eax # trashes rIBASE/edx 5827 UNSPILL(rIBASE) 5828 SET_VREG %eax %ecx 5829 FETCH_INST_OPCODE 1 %ecx 5830 ADVANCE_PC 1 5831 GOTO_NEXT_R %ecx 5832 5833/* ------------------------------ */ 5834.L_OP_DIV_INT_2ADDR: /* 0xb3 */ 5835/* File: x86/OP_DIV_INT_2ADDR.S */ 5836/* File: x86/bindiv2addr.S */ 5837 /* 5838 * 32-bit binary div/rem operation. Handles special case of op0=minint and 5839 * op1=-1. 5840 */ 5841 /* div/rem/2addr vA, vB */ 5842 movzx rINSTbl,%ecx # eax<- BA 5843 SPILL(rIBASE) 5844 sarl $4,%ecx # ecx<- B 5845 GET_VREG_R %ecx %ecx # eax<- vBB 5846 andb $0xf,rINSTbl # rINST<- A 5847 GET_VREG_R %eax rINST # eax<- vBB 5848 cmpl $0,%ecx 5849 je common_errDivideByZero 5850 cmpl $-1,%ecx 5851 jne .LOP_DIV_INT_2ADDR_continue_div2addr 5852 cmpl $0x80000000,%eax 5853 jne .LOP_DIV_INT_2ADDR_continue_div2addr 5854 movl $0x80000000,%eax 5855 SET_VREG %eax rINST 5856 UNSPILL(rIBASE) 5857 FETCH_INST_OPCODE 1 %ecx 5858 ADVANCE_PC 1 5859 GOTO_NEXT_R %ecx 5860 5861.LOP_DIV_INT_2ADDR_continue_div2addr: 5862 cltd 5863 idivl %ecx 5864 SET_VREG %eax rINST 5865 UNSPILL(rIBASE) 5866 FETCH_INST_OPCODE 1 %ecx 5867 ADVANCE_PC 1 5868 GOTO_NEXT_R %ecx 5869 5870 5871/* ------------------------------ */ 5872.L_OP_REM_INT_2ADDR: /* 0xb4 */ 5873/* File: x86/OP_REM_INT_2ADDR.S */ 5874/* File: x86/bindiv2addr.S */ 5875 /* 5876 * 32-bit binary div/rem operation. Handles special case of op0=minint and 5877 * op1=-1. 5878 */ 5879 /* div/rem/2addr vA, vB */ 5880 movzx rINSTbl,%ecx # eax<- BA 5881 SPILL(rIBASE) 5882 sarl $4,%ecx # ecx<- B 5883 GET_VREG_R %ecx %ecx # eax<- vBB 5884 andb $0xf,rINSTbl # rINST<- A 5885 GET_VREG_R %eax rINST # eax<- vBB 5886 cmpl $0,%ecx 5887 je common_errDivideByZero 5888 cmpl $-1,%ecx 5889 jne .LOP_REM_INT_2ADDR_continue_div2addr 5890 cmpl $0x80000000,%eax 5891 jne .LOP_REM_INT_2ADDR_continue_div2addr 5892 movl $0,rIBASE 5893 SET_VREG rIBASE rINST 5894 UNSPILL(rIBASE) 5895 FETCH_INST_OPCODE 1 %ecx 5896 ADVANCE_PC 1 5897 GOTO_NEXT_R %ecx 5898 5899.LOP_REM_INT_2ADDR_continue_div2addr: 5900 cltd 5901 idivl %ecx 5902 SET_VREG rIBASE rINST 5903 UNSPILL(rIBASE) 5904 FETCH_INST_OPCODE 1 %ecx 5905 ADVANCE_PC 1 5906 GOTO_NEXT_R %ecx 5907 5908 5909/* ------------------------------ */ 5910.L_OP_AND_INT_2ADDR: /* 0xb5 */ 5911/* File: x86/OP_AND_INT_2ADDR.S */ 5912/* File: x86/binop2addr.S */ 5913 /* 5914 * Generic 32-bit "/2addr" binary operation. Provide an "instr" line 5915 * that specifies an instruction that performs "result = r0 op r1". 5916 * This could be an ARM instruction or a function call. (If the result 5917 * comes back in a register other than r0, you can override "result".) 5918 * 5919 * If "chkzero" is set to 1, we perform a divide-by-zero check on 5920 * vCC (r1). Useful for integer division and modulus. 5921 * 5922 * For: add-int/2addr, sub-int/2addr, mul-int/2addr, div-int/2addr, 5923 * rem-int/2addr, and-int/2addr, or-int/2addr, xor-int/2addr, 5924 * shl-int/2addr, shr-int/2addr, ushr-int/2addr, add-float/2addr, 5925 * sub-float/2addr, mul-float/2addr, div-float/2addr, rem-float/2addr 5926 */ 5927 /* binop/2addr vA, vB */ 5928 movzx rINSTbl,%ecx # ecx<- A+ 5929 sarl $4,rINST # rINST<- B 5930 GET_VREG_R %eax rINST # eax<- vB 5931 andb $0xf,%cl # ecx<- A 5932 andl %eax,(rFP,%ecx,4) # for ex: addl %eax,(rFP,%ecx,4) 5933 FETCH_INST_OPCODE 1 %ecx 5934 ADVANCE_PC 1 5935 GOTO_NEXT_R %ecx 5936 5937 5938/* ------------------------------ */ 5939.L_OP_OR_INT_2ADDR: /* 0xb6 */ 5940/* File: x86/OP_OR_INT_2ADDR.S */ 5941/* File: x86/binop2addr.S */ 5942 /* 5943 * Generic 32-bit "/2addr" binary operation. Provide an "instr" line 5944 * that specifies an instruction that performs "result = r0 op r1". 5945 * This could be an ARM instruction or a function call. (If the result 5946 * comes back in a register other than r0, you can override "result".) 5947 * 5948 * If "chkzero" is set to 1, we perform a divide-by-zero check on 5949 * vCC (r1). Useful for integer division and modulus. 5950 * 5951 * For: add-int/2addr, sub-int/2addr, mul-int/2addr, div-int/2addr, 5952 * rem-int/2addr, and-int/2addr, or-int/2addr, xor-int/2addr, 5953 * shl-int/2addr, shr-int/2addr, ushr-int/2addr, add-float/2addr, 5954 * sub-float/2addr, mul-float/2addr, div-float/2addr, rem-float/2addr 5955 */ 5956 /* binop/2addr vA, vB */ 5957 movzx rINSTbl,%ecx # ecx<- A+ 5958 sarl $4,rINST # rINST<- B 5959 GET_VREG_R %eax rINST # eax<- vB 5960 andb $0xf,%cl # ecx<- A 5961 orl %eax,(rFP,%ecx,4) # for ex: addl %eax,(rFP,%ecx,4) 5962 FETCH_INST_OPCODE 1 %ecx 5963 ADVANCE_PC 1 5964 GOTO_NEXT_R %ecx 5965 5966 5967/* ------------------------------ */ 5968.L_OP_XOR_INT_2ADDR: /* 0xb7 */ 5969/* File: x86/OP_XOR_INT_2ADDR.S */ 5970/* File: x86/binop2addr.S */ 5971 /* 5972 * Generic 32-bit "/2addr" binary operation. Provide an "instr" line 5973 * that specifies an instruction that performs "result = r0 op r1". 5974 * This could be an ARM instruction or a function call. (If the result 5975 * comes back in a register other than r0, you can override "result".) 5976 * 5977 * If "chkzero" is set to 1, we perform a divide-by-zero check on 5978 * vCC (r1). Useful for integer division and modulus. 5979 * 5980 * For: add-int/2addr, sub-int/2addr, mul-int/2addr, div-int/2addr, 5981 * rem-int/2addr, and-int/2addr, or-int/2addr, xor-int/2addr, 5982 * shl-int/2addr, shr-int/2addr, ushr-int/2addr, add-float/2addr, 5983 * sub-float/2addr, mul-float/2addr, div-float/2addr, rem-float/2addr 5984 */ 5985 /* binop/2addr vA, vB */ 5986 movzx rINSTbl,%ecx # ecx<- A+ 5987 sarl $4,rINST # rINST<- B 5988 GET_VREG_R %eax rINST # eax<- vB 5989 andb $0xf,%cl # ecx<- A 5990 xorl %eax,(rFP,%ecx,4) # for ex: addl %eax,(rFP,%ecx,4) 5991 FETCH_INST_OPCODE 1 %ecx 5992 ADVANCE_PC 1 5993 GOTO_NEXT_R %ecx 5994 5995 5996/* ------------------------------ */ 5997.L_OP_SHL_INT_2ADDR: /* 0xb8 */ 5998/* File: x86/OP_SHL_INT_2ADDR.S */ 5999/* File: x86/shop2addr.S */ 6000 /* 6001 * Generic 32-bit "shift/2addr" operation. 6002 */ 6003 /* shift/2addr vA, vB */ 6004 movzx rINSTbl,%ecx # eax<- BA 6005 sarl $4,%ecx # ecx<- B 6006 GET_VREG_R %ecx %ecx # eax<- vBB 6007 andb $0xf,rINSTbl # rINST<- A 6008 GET_VREG_R %eax rINST # eax<- vAA 6009 sall %cl,%eax # ex: sarl %cl,%eax 6010 FETCH_INST_OPCODE 1 %ecx 6011 SET_VREG %eax rINST 6012 ADVANCE_PC 1 6013 GOTO_NEXT_R %ecx 6014 6015 6016/* ------------------------------ */ 6017.L_OP_SHR_INT_2ADDR: /* 0xb9 */ 6018/* File: x86/OP_SHR_INT_2ADDR.S */ 6019/* File: x86/shop2addr.S */ 6020 /* 6021 * Generic 32-bit "shift/2addr" operation. 6022 */ 6023 /* shift/2addr vA, vB */ 6024 movzx rINSTbl,%ecx # eax<- BA 6025 sarl $4,%ecx # ecx<- B 6026 GET_VREG_R %ecx %ecx # eax<- vBB 6027 andb $0xf,rINSTbl # rINST<- A 6028 GET_VREG_R %eax rINST # eax<- vAA 6029 sarl %cl,%eax # ex: sarl %cl,%eax 6030 FETCH_INST_OPCODE 1 %ecx 6031 SET_VREG %eax rINST 6032 ADVANCE_PC 1 6033 GOTO_NEXT_R %ecx 6034 6035 6036/* ------------------------------ */ 6037.L_OP_USHR_INT_2ADDR: /* 0xba */ 6038/* File: x86/OP_USHR_INT_2ADDR.S */ 6039/* File: x86/shop2addr.S */ 6040 /* 6041 * Generic 32-bit "shift/2addr" operation. 6042 */ 6043 /* shift/2addr vA, vB */ 6044 movzx rINSTbl,%ecx # eax<- BA 6045 sarl $4,%ecx # ecx<- B 6046 GET_VREG_R %ecx %ecx # eax<- vBB 6047 andb $0xf,rINSTbl # rINST<- A 6048 GET_VREG_R %eax rINST # eax<- vAA 6049 shrl %cl,%eax # ex: sarl %cl,%eax 6050 FETCH_INST_OPCODE 1 %ecx 6051 SET_VREG %eax rINST 6052 ADVANCE_PC 1 6053 GOTO_NEXT_R %ecx 6054 6055 6056/* ------------------------------ */ 6057.L_OP_ADD_LONG_2ADDR: /* 0xbb */ 6058/* File: x86/OP_ADD_LONG_2ADDR.S */ 6059/* File: x86/binopWide2addr.S */ 6060 /* 6061 * Generic 64-bit binary operation. 6062 */ 6063 /* binop/2addr vA, vB */ 6064 movzbl rINSTbl,%ecx # ecx<- BA 6065 sarl $4,%ecx # ecx<- B 6066 GET_VREG_WORD %eax %ecx 0 # eax<- v[B+0] 6067 GET_VREG_WORD %ecx %ecx 1 # eax<- v[B+1] 6068 andb $0xF,rINSTbl # rINST<- A 6069 addl %eax,(rFP,rINST,4) # example: addl %eax,(rFP,rINST,4) 6070 adcl %ecx,4(rFP,rINST,4) # example: adcl %ecx,4(rFP,rINST,4) 6071 FETCH_INST_OPCODE 1 %ecx 6072 ADVANCE_PC 1 6073 GOTO_NEXT_R %ecx 6074 6075 6076/* ------------------------------ */ 6077.L_OP_SUB_LONG_2ADDR: /* 0xbc */ 6078/* File: x86/OP_SUB_LONG_2ADDR.S */ 6079/* File: x86/binopWide2addr.S */ 6080 /* 6081 * Generic 64-bit binary operation. 6082 */ 6083 /* binop/2addr vA, vB */ 6084 movzbl rINSTbl,%ecx # ecx<- BA 6085 sarl $4,%ecx # ecx<- B 6086 GET_VREG_WORD %eax %ecx 0 # eax<- v[B+0] 6087 GET_VREG_WORD %ecx %ecx 1 # eax<- v[B+1] 6088 andb $0xF,rINSTbl # rINST<- A 6089 subl %eax,(rFP,rINST,4) # example: addl %eax,(rFP,rINST,4) 6090 sbbl %ecx,4(rFP,rINST,4) # example: adcl %ecx,4(rFP,rINST,4) 6091 FETCH_INST_OPCODE 1 %ecx 6092 ADVANCE_PC 1 6093 GOTO_NEXT_R %ecx 6094 6095 6096/* ------------------------------ */ 6097.L_OP_MUL_LONG_2ADDR: /* 0xbd */ 6098/* File: x86/OP_MUL_LONG_2ADDR.S */ 6099 /* 6100 * Signed 64-bit integer multiply, 2-addr version 6101 * 6102 * We could definately use more free registers for 6103 * this code. We must spill %edx (rIBASE) because it 6104 * is used by imul. We'll also spill rINST (ebx), 6105 * giving us eax, ebc, ecx and rIBASE as computational 6106 * temps. On top of that, we'll spill %esi (edi) 6107 * for use as the vA pointer and rFP (esi) for use 6108 * as the vB pointer. Yuck. 6109 */ 6110 /* mul-long/2addr vA, vB */ 6111 movzbl rINSTbl,%eax # eax<- BA 6112 andb $0xf,%al # eax<- A 6113 sarl $4,rINST # rINST<- B 6114 SPILL_TMP2(%esi) 6115 SPILL(rFP) 6116 SPILL(rIBASE) 6117 leal (rFP,%eax,4),%esi # %esi<- &v[A] 6118 leal (rFP,rINST,4),rFP # rFP<- &v[B] 6119 movl 4(%esi),%ecx # ecx<- Amsw 6120 imull (rFP),%ecx # ecx<- (Amsw*Blsw) 6121 movl 4(rFP),%eax # eax<- Bmsw 6122 imull (%esi),%eax # eax<- (Bmsw*Alsw) 6123 addl %eax,%ecx # ecx<- (Amsw*Blsw)+(Bmsw*Alsw) 6124 movl (rFP),%eax # eax<- Blsw 6125 mull (%esi) # eax<- (Blsw*Alsw) 6126 leal (%ecx,rIBASE),rIBASE # full result now in %edx:%eax 6127 movl rIBASE,4(%esi) # v[A+1]<- rIBASE 6128 movl %eax,(%esi) # v[A]<- %eax 6129 UNSPILL_TMP2(%esi) 6130 FETCH_INST_OPCODE 1 %ecx 6131 UNSPILL(rIBASE) 6132 UNSPILL(rFP) 6133 ADVANCE_PC 1 6134 GOTO_NEXT_R %ecx 6135 6136/* ------------------------------ */ 6137.L_OP_DIV_LONG_2ADDR: /* 0xbe */ 6138/* File: x86/OP_DIV_LONG_2ADDR.S */ 6139 /* div/2addr vA, vB */ 6140 movzbl rINSTbl,%eax 6141 shrl $4,%eax # eax<- B 6142 andb $0xf,rINSTbl # rINST<- A 6143 SPILL(rIBASE) # save rIBASE/%edx 6144 GET_VREG_WORD rIBASE %eax 0 6145 GET_VREG_WORD %eax %eax 1 6146 movl rIBASE,OUT_ARG2(%esp) 6147 testl %eax,%eax 6148 je .LOP_DIV_LONG_2ADDR_check_zero 6149 cmpl $-1,%eax 6150 je .LOP_DIV_LONG_2ADDR_check_neg1 6151.LOP_DIV_LONG_2ADDR_notSpecial: 6152 GET_VREG_WORD rIBASE rINST 0 6153 GET_VREG_WORD %ecx rINST 1 6154.LOP_DIV_LONG_2ADDR_notSpecial1: 6155 movl %eax,OUT_ARG3(%esp) 6156 movl rIBASE,OUT_ARG0(%esp) 6157 movl %ecx,OUT_ARG1(%esp) 6158 call __divdi3 6159.LOP_DIV_LONG_2ADDR_finish: 6160 SET_VREG_WORD rIBASE rINST 1 6161 UNSPILL(rIBASE) # restore rIBASE/%edx 6162 SET_VREG_WORD %eax rINST 0 6163 FETCH_INST_OPCODE 1 %ecx 6164 ADVANCE_PC 1 6165 GOTO_NEXT_R %ecx 6166 6167.LOP_DIV_LONG_2ADDR_check_zero: 6168 testl rIBASE,rIBASE 6169 jne .LOP_DIV_LONG_2ADDR_notSpecial 6170 jmp common_errDivideByZero 6171.LOP_DIV_LONG_2ADDR_check_neg1: 6172 testl rIBASE,%eax 6173 jne .LOP_DIV_LONG_2ADDR_notSpecial 6174 GET_VREG_WORD rIBASE rINST 0 6175 GET_VREG_WORD %ecx rINST 1 6176 testl rIBASE,rIBASE 6177 jne .LOP_DIV_LONG_2ADDR_notSpecial1 6178 cmpl $0x80000000,%ecx 6179 jne .LOP_DIV_LONG_2ADDR_notSpecial1 6180 /* minint / -1, return minint on div, 0 on rem */ 6181 xorl %eax,%eax 6182 movl $0x80000000,rIBASE 6183 jmp .LOP_DIV_LONG_2ADDR_finish 6184 6185/* ------------------------------ */ 6186.L_OP_REM_LONG_2ADDR: /* 0xbf */ 6187/* File: x86/OP_REM_LONG_2ADDR.S */ 6188/* File: x86/OP_DIV_LONG_2ADDR.S */ 6189 /* div/2addr vA, vB */ 6190 movzbl rINSTbl,%eax 6191 shrl $4,%eax # eax<- B 6192 andb $0xf,rINSTbl # rINST<- A 6193 SPILL(rIBASE) # save rIBASE/%edx 6194 GET_VREG_WORD rIBASE %eax 0 6195 GET_VREG_WORD %eax %eax 1 6196 movl rIBASE,OUT_ARG2(%esp) 6197 testl %eax,%eax 6198 je .LOP_REM_LONG_2ADDR_check_zero 6199 cmpl $-1,%eax 6200 je .LOP_REM_LONG_2ADDR_check_neg1 6201.LOP_REM_LONG_2ADDR_notSpecial: 6202 GET_VREG_WORD rIBASE rINST 0 6203 GET_VREG_WORD %ecx rINST 1 6204.LOP_REM_LONG_2ADDR_notSpecial1: 6205 movl %eax,OUT_ARG3(%esp) 6206 movl rIBASE,OUT_ARG0(%esp) 6207 movl %ecx,OUT_ARG1(%esp) 6208 call __moddi3 6209.LOP_REM_LONG_2ADDR_finish: 6210 SET_VREG_WORD rIBASE rINST 1 6211 UNSPILL(rIBASE) # restore rIBASE/%edx 6212 SET_VREG_WORD %eax rINST 0 6213 FETCH_INST_OPCODE 1 %ecx 6214 ADVANCE_PC 1 6215 GOTO_NEXT_R %ecx 6216 6217.LOP_REM_LONG_2ADDR_check_zero: 6218 testl rIBASE,rIBASE 6219 jne .LOP_REM_LONG_2ADDR_notSpecial 6220 jmp common_errDivideByZero 6221.LOP_REM_LONG_2ADDR_check_neg1: 6222 testl rIBASE,%eax 6223 jne .LOP_REM_LONG_2ADDR_notSpecial 6224 GET_VREG_WORD rIBASE rINST 0 6225 GET_VREG_WORD %ecx rINST 1 6226 testl rIBASE,rIBASE 6227 jne .LOP_REM_LONG_2ADDR_notSpecial1 6228 cmpl $0x80000000,%ecx 6229 jne .LOP_REM_LONG_2ADDR_notSpecial1 6230 /* minint / -1, return minint on div, 0 on rem */ 6231 xorl %eax,%eax 6232 movl $0,rIBASE 6233 jmp .LOP_REM_LONG_2ADDR_finish 6234 6235 6236/* ------------------------------ */ 6237.L_OP_AND_LONG_2ADDR: /* 0xc0 */ 6238/* File: x86/OP_AND_LONG_2ADDR.S */ 6239/* File: x86/binopWide2addr.S */ 6240 /* 6241 * Generic 64-bit binary operation. 6242 */ 6243 /* binop/2addr vA, vB */ 6244 movzbl rINSTbl,%ecx # ecx<- BA 6245 sarl $4,%ecx # ecx<- B 6246 GET_VREG_WORD %eax %ecx 0 # eax<- v[B+0] 6247 GET_VREG_WORD %ecx %ecx 1 # eax<- v[B+1] 6248 andb $0xF,rINSTbl # rINST<- A 6249 andl %eax,(rFP,rINST,4) # example: addl %eax,(rFP,rINST,4) 6250 andl %ecx,4(rFP,rINST,4) # example: adcl %ecx,4(rFP,rINST,4) 6251 FETCH_INST_OPCODE 1 %ecx 6252 ADVANCE_PC 1 6253 GOTO_NEXT_R %ecx 6254 6255 6256/* ------------------------------ */ 6257.L_OP_OR_LONG_2ADDR: /* 0xc1 */ 6258/* File: x86/OP_OR_LONG_2ADDR.S */ 6259/* File: x86/binopWide2addr.S */ 6260 /* 6261 * Generic 64-bit binary operation. 6262 */ 6263 /* binop/2addr vA, vB */ 6264 movzbl rINSTbl,%ecx # ecx<- BA 6265 sarl $4,%ecx # ecx<- B 6266 GET_VREG_WORD %eax %ecx 0 # eax<- v[B+0] 6267 GET_VREG_WORD %ecx %ecx 1 # eax<- v[B+1] 6268 andb $0xF,rINSTbl # rINST<- A 6269 orl %eax,(rFP,rINST,4) # example: addl %eax,(rFP,rINST,4) 6270 orl %ecx,4(rFP,rINST,4) # example: adcl %ecx,4(rFP,rINST,4) 6271 FETCH_INST_OPCODE 1 %ecx 6272 ADVANCE_PC 1 6273 GOTO_NEXT_R %ecx 6274 6275 6276/* ------------------------------ */ 6277.L_OP_XOR_LONG_2ADDR: /* 0xc2 */ 6278/* File: x86/OP_XOR_LONG_2ADDR.S */ 6279/* File: x86/binopWide2addr.S */ 6280 /* 6281 * Generic 64-bit binary operation. 6282 */ 6283 /* binop/2addr vA, vB */ 6284 movzbl rINSTbl,%ecx # ecx<- BA 6285 sarl $4,%ecx # ecx<- B 6286 GET_VREG_WORD %eax %ecx 0 # eax<- v[B+0] 6287 GET_VREG_WORD %ecx %ecx 1 # eax<- v[B+1] 6288 andb $0xF,rINSTbl # rINST<- A 6289 xorl %eax,(rFP,rINST,4) # example: addl %eax,(rFP,rINST,4) 6290 xorl %ecx,4(rFP,rINST,4) # example: adcl %ecx,4(rFP,rINST,4) 6291 FETCH_INST_OPCODE 1 %ecx 6292 ADVANCE_PC 1 6293 GOTO_NEXT_R %ecx 6294 6295 6296/* ------------------------------ */ 6297.L_OP_SHL_LONG_2ADDR: /* 0xc3 */ 6298/* File: x86/OP_SHL_LONG_2ADDR.S */ 6299 /* 6300 * Long integer shift, 2addr version. vA is 64-bit value/result, vB is 6301 * 32-bit shift distance. 6302 */ 6303 /* shl-long/2addr vA, vB */ 6304 /* ecx gets shift count */ 6305 /* Need to spill rIBASE */ 6306 /* rINSTw gets AA */ 6307 movzbl rINSTbl,%ecx # ecx<- BA 6308 andb $0xf,rINSTbl # rINST<- A 6309 GET_VREG_WORD %eax rINST 0 # eax<- v[AA+0] 6310 sarl $4,%ecx # ecx<- B 6311 SPILL(rIBASE) 6312 GET_VREG_WORD rIBASE rINST 1 # rIBASE<- v[AA+1] 6313 GET_VREG_R %ecx %ecx # ecx<- vBB 6314 shldl %eax,rIBASE 6315 sall %cl,%eax 6316 testb $32,%cl 6317 je 2f 6318 movl %eax,rIBASE 6319 xorl %eax,%eax 63202: 6321 SET_VREG_WORD rIBASE rINST 1 # v[AA+1]<- rIBASE 6322 UNSPILL(rIBASE) 6323 FETCH_INST_OPCODE 1 %ecx 6324 SET_VREG_WORD %eax rINST 0 # v[AA+0]<- eax 6325 ADVANCE_PC 1 6326 GOTO_NEXT_R %ecx 6327 6328/* ------------------------------ */ 6329.L_OP_SHR_LONG_2ADDR: /* 0xc4 */ 6330/* File: x86/OP_SHR_LONG_2ADDR.S */ 6331 /* 6332 * Long integer shift, 2addr version. vA is 64-bit value/result, vB is 6333 * 32-bit shift distance. 6334 */ 6335 /* shl-long/2addr vA, vB */ 6336 /* ecx gets shift count */ 6337 /* Need to spill rIBASE */ 6338 /* rINSTw gets AA */ 6339 movzbl rINSTbl,%ecx # ecx<- BA 6340 andb $0xf,rINSTbl # rINST<- A 6341 GET_VREG_WORD %eax rINST 0 # eax<- v[AA+0] 6342 sarl $4,%ecx # ecx<- B 6343 SPILL(rIBASE) 6344 GET_VREG_WORD rIBASE rINST 1 # rIBASE<- v[AA+1] 6345 GET_VREG_R %ecx %ecx # ecx<- vBB 6346 shrdl rIBASE,%eax 6347 sarl %cl,rIBASE 6348 testb $32,%cl 6349 je 2f 6350 movl rIBASE,%eax 6351 sarl $31,rIBASE 63522: 6353 SET_VREG_WORD rIBASE rINST 1 # v[AA+1]<- rIBASE 6354 UNSPILL(rIBASE) 6355 FETCH_INST_OPCODE 1 %ecx 6356 SET_VREG_WORD %eax rINST 0 # v[AA+0]<- eax 6357 ADVANCE_PC 1 6358 GOTO_NEXT_R %ecx 6359 6360/* ------------------------------ */ 6361.L_OP_USHR_LONG_2ADDR: /* 0xc5 */ 6362/* File: x86/OP_USHR_LONG_2ADDR.S */ 6363 /* 6364 * Long integer shift, 2addr version. vA is 64-bit value/result, vB is 6365 * 32-bit shift distance. 6366 */ 6367 /* shl-long/2addr vA, vB */ 6368 /* ecx gets shift count */ 6369 /* Need to spill rIBASE */ 6370 /* rINSTw gets AA */ 6371 movzbl rINSTbl,%ecx # ecx<- BA 6372 andb $0xf,rINSTbl # rINST<- A 6373 GET_VREG_WORD %eax rINST 0 # eax<- v[AA+0] 6374 sarl $4,%ecx # ecx<- B 6375 SPILL(rIBASE) 6376 GET_VREG_WORD rIBASE rINST 1 # rIBASE<- v[AA+1] 6377 GET_VREG_R %ecx %ecx # ecx<- vBB 6378 shrdl rIBASE,%eax 6379 shrl %cl,rIBASE 6380 testb $32,%cl 6381 je 2f 6382 movl rIBASE,%eax 6383 xorl rIBASE,rIBASE 63842: 6385 SET_VREG_WORD rIBASE rINST 1 # v[AA+1]<- rIBASE 6386 FETCH_INST_OPCODE 1 %ecx 6387 UNSPILL(rIBASE) 6388 SET_VREG_WORD %eax rINST 0 # v[AA+0]<- eax 6389 ADVANCE_PC 1 6390 GOTO_NEXT_R %ecx 6391 6392/* ------------------------------ */ 6393.L_OP_ADD_FLOAT_2ADDR: /* 0xc6 */ 6394/* File: x86/OP_ADD_FLOAT_2ADDR.S */ 6395/* File: x86/binflop2addr.S */ 6396 /* 6397 * Generic 32-bit binary float operation. 6398 * 6399 * For: add-fp, sub-fp, mul-fp, div-fp 6400 */ 6401 6402 /* binop/2addr vA, vB */ 6403 movzx rINSTbl,%ecx # ecx<- A+ 6404 andb $0xf,%cl # ecx<- A 6405 flds (rFP,%ecx,4) # vAA to fp stack 6406 sarl $4,rINST # rINST<- B 6407 fadds (rFP,rINST,4) # ex: faddp 6408 FETCH_INST_OPCODE 1 %eax 6409 ADVANCE_PC 1 6410 fstps (rFP,%ecx,4) # %st to vA 6411 GOTO_NEXT_R %eax 6412 6413 6414/* ------------------------------ */ 6415.L_OP_SUB_FLOAT_2ADDR: /* 0xc7 */ 6416/* File: x86/OP_SUB_FLOAT_2ADDR.S */ 6417/* File: x86/binflop2addr.S */ 6418 /* 6419 * Generic 32-bit binary float operation. 6420 * 6421 * For: add-fp, sub-fp, mul-fp, div-fp 6422 */ 6423 6424 /* binop/2addr vA, vB */ 6425 movzx rINSTbl,%ecx # ecx<- A+ 6426 andb $0xf,%cl # ecx<- A 6427 flds (rFP,%ecx,4) # vAA to fp stack 6428 sarl $4,rINST # rINST<- B 6429 fsubs (rFP,rINST,4) # ex: faddp 6430 FETCH_INST_OPCODE 1 %eax 6431 ADVANCE_PC 1 6432 fstps (rFP,%ecx,4) # %st to vA 6433 GOTO_NEXT_R %eax 6434 6435 6436/* ------------------------------ */ 6437.L_OP_MUL_FLOAT_2ADDR: /* 0xc8 */ 6438/* File: x86/OP_MUL_FLOAT_2ADDR.S */ 6439/* File: x86/binflop2addr.S */ 6440 /* 6441 * Generic 32-bit binary float operation. 6442 * 6443 * For: add-fp, sub-fp, mul-fp, div-fp 6444 */ 6445 6446 /* binop/2addr vA, vB */ 6447 movzx rINSTbl,%ecx # ecx<- A+ 6448 andb $0xf,%cl # ecx<- A 6449 flds (rFP,%ecx,4) # vAA to fp stack 6450 sarl $4,rINST # rINST<- B 6451 fmuls (rFP,rINST,4) # ex: faddp 6452 FETCH_INST_OPCODE 1 %eax 6453 ADVANCE_PC 1 6454 fstps (rFP,%ecx,4) # %st to vA 6455 GOTO_NEXT_R %eax 6456 6457 6458/* ------------------------------ */ 6459.L_OP_DIV_FLOAT_2ADDR: /* 0xc9 */ 6460/* File: x86/OP_DIV_FLOAT_2ADDR.S */ 6461/* File: x86/binflop2addr.S */ 6462 /* 6463 * Generic 32-bit binary float operation. 6464 * 6465 * For: add-fp, sub-fp, mul-fp, div-fp 6466 */ 6467 6468 /* binop/2addr vA, vB */ 6469 movzx rINSTbl,%ecx # ecx<- A+ 6470 andb $0xf,%cl # ecx<- A 6471 flds (rFP,%ecx,4) # vAA to fp stack 6472 sarl $4,rINST # rINST<- B 6473 fdivs (rFP,rINST,4) # ex: faddp 6474 FETCH_INST_OPCODE 1 %eax 6475 ADVANCE_PC 1 6476 fstps (rFP,%ecx,4) # %st to vA 6477 GOTO_NEXT_R %eax 6478 6479 6480/* ------------------------------ */ 6481.L_OP_REM_FLOAT_2ADDR: /* 0xca */ 6482/* File: x86/OP_REM_FLOAT_2ADDR.S */ 6483 /* rem_float/2addr vA, vB */ 6484 movzx rINSTbl,%ecx # ecx<- A+ 6485 sarl $4,rINST # rINST<- B 6486 flds (rFP,rINST,4) # vBB to fp stack 6487 andb $0xf,%cl # ecx<- A 6488 flds (rFP,%ecx,4) # vAA to fp stack 64891: 6490 fprem 6491 fstsw %ax 6492 sahf 6493 jp 1b 6494 fstp %st(1) 6495 FETCH_INST_OPCODE 1 %eax 6496 ADVANCE_PC 1 6497 fstps (rFP,%ecx,4) # %st to vA 6498 GOTO_NEXT_R %eax 6499 6500/* ------------------------------ */ 6501.L_OP_ADD_DOUBLE_2ADDR: /* 0xcb */ 6502/* File: x86/OP_ADD_DOUBLE_2ADDR.S */ 6503/* File: x86/binflop2addr.S */ 6504 /* 6505 * Generic 32-bit binary float operation. 6506 * 6507 * For: add-fp, sub-fp, mul-fp, div-fp 6508 */ 6509 6510 /* binop/2addr vA, vB */ 6511 movzx rINSTbl,%ecx # ecx<- A+ 6512 andb $0xf,%cl # ecx<- A 6513 fldl (rFP,%ecx,4) # vAA to fp stack 6514 sarl $4,rINST # rINST<- B 6515 faddl (rFP,rINST,4) # ex: faddp 6516 FETCH_INST_OPCODE 1 %eax 6517 ADVANCE_PC 1 6518 fstpl (rFP,%ecx,4) # %st to vA 6519 GOTO_NEXT_R %eax 6520 6521 6522/* ------------------------------ */ 6523.L_OP_SUB_DOUBLE_2ADDR: /* 0xcc */ 6524/* File: x86/OP_SUB_DOUBLE_2ADDR.S */ 6525/* File: x86/binflop2addr.S */ 6526 /* 6527 * Generic 32-bit binary float operation. 6528 * 6529 * For: add-fp, sub-fp, mul-fp, div-fp 6530 */ 6531 6532 /* binop/2addr vA, vB */ 6533 movzx rINSTbl,%ecx # ecx<- A+ 6534 andb $0xf,%cl # ecx<- A 6535 fldl (rFP,%ecx,4) # vAA to fp stack 6536 sarl $4,rINST # rINST<- B 6537 fsubl (rFP,rINST,4) # ex: faddp 6538 FETCH_INST_OPCODE 1 %eax 6539 ADVANCE_PC 1 6540 fstpl (rFP,%ecx,4) # %st to vA 6541 GOTO_NEXT_R %eax 6542 6543 6544/* ------------------------------ */ 6545.L_OP_MUL_DOUBLE_2ADDR: /* 0xcd */ 6546/* File: x86/OP_MUL_DOUBLE_2ADDR.S */ 6547/* File: x86/binflop2addr.S */ 6548 /* 6549 * Generic 32-bit binary float operation. 6550 * 6551 * For: add-fp, sub-fp, mul-fp, div-fp 6552 */ 6553 6554 /* binop/2addr vA, vB */ 6555 movzx rINSTbl,%ecx # ecx<- A+ 6556 andb $0xf,%cl # ecx<- A 6557 fldl (rFP,%ecx,4) # vAA to fp stack 6558 sarl $4,rINST # rINST<- B 6559 fmull (rFP,rINST,4) # ex: faddp 6560 FETCH_INST_OPCODE 1 %eax 6561 ADVANCE_PC 1 6562 fstpl (rFP,%ecx,4) # %st to vA 6563 GOTO_NEXT_R %eax 6564 6565 6566/* ------------------------------ */ 6567.L_OP_DIV_DOUBLE_2ADDR: /* 0xce */ 6568/* File: x86/OP_DIV_DOUBLE_2ADDR.S */ 6569/* File: x86/binflop2addr.S */ 6570 /* 6571 * Generic 32-bit binary float operation. 6572 * 6573 * For: add-fp, sub-fp, mul-fp, div-fp 6574 */ 6575 6576 /* binop/2addr vA, vB */ 6577 movzx rINSTbl,%ecx # ecx<- A+ 6578 andb $0xf,%cl # ecx<- A 6579 fldl (rFP,%ecx,4) # vAA to fp stack 6580 sarl $4,rINST # rINST<- B 6581 fdivl (rFP,rINST,4) # ex: faddp 6582 FETCH_INST_OPCODE 1 %eax 6583 ADVANCE_PC 1 6584 fstpl (rFP,%ecx,4) # %st to vA 6585 GOTO_NEXT_R %eax 6586 6587 6588/* ------------------------------ */ 6589.L_OP_REM_DOUBLE_2ADDR: /* 0xcf */ 6590/* File: x86/OP_REM_DOUBLE_2ADDR.S */ 6591 /* rem_float/2addr vA, vB */ 6592 movzx rINSTbl,%ecx # ecx<- A+ 6593 sarl $4,rINST # rINST<- B 6594 fldl (rFP,rINST,4) # vBB to fp stack 6595 andb $0xf,%cl # ecx<- A 6596 fldl (rFP,%ecx,4) # vAA to fp stack 65971: 6598 fprem 6599 fstsw %ax 6600 sahf 6601 jp 1b 6602 fstp %st(1) 6603 FETCH_INST_OPCODE 1 %eax 6604 ADVANCE_PC 1 6605 fstpl (rFP,%ecx,4) # %st to vA 6606 GOTO_NEXT_R %eax 6607 6608/* ------------------------------ */ 6609.L_OP_ADD_INT_LIT16: /* 0xd0 */ 6610/* File: x86/OP_ADD_INT_LIT16.S */ 6611/* File: x86/binopLit16.S */ 6612 /* 6613 * Generic 32-bit "lit16" binary operation. Provide an "instr" line 6614 * that specifies an instruction that performs "result = eax op ecx". 6615 * This could be an x86 instruction or a function call. (If the result 6616 * comes back in a register other than eax, you can override "result".) 6617 * 6618 * For: add-int/lit16, rsub-int, 6619 * and-int/lit16, or-int/lit16, xor-int/lit16 6620 */ 6621 /* binop/lit16 vA, vB, #+CCCC */ 6622 movzbl rINSTbl,%eax # eax<- 000000BA 6623 sarl $4,%eax # eax<- B 6624 GET_VREG_R %eax %eax # eax<- vB 6625 movswl 2(rPC),%ecx # ecx<- ssssCCCC 6626 andb $0xf,rINSTbl # rINST<- A 6627 addl %ecx,%eax # for example: addl %ecx, %eax 6628 SET_VREG %eax rINST 6629 FETCH_INST_OPCODE 2 %ecx 6630 ADVANCE_PC 2 6631 GOTO_NEXT_R %ecx 6632 6633 6634/* ------------------------------ */ 6635.L_OP_RSUB_INT: /* 0xd1 */ 6636/* File: x86/OP_RSUB_INT.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 subl %eax,%ecx # for example: addl %ecx, %eax 6654 SET_VREG %ecx rINST 6655 FETCH_INST_OPCODE 2 %ecx 6656 ADVANCE_PC 2 6657 GOTO_NEXT_R %ecx 6658 6659 6660/* ------------------------------ */ 6661.L_OP_MUL_INT_LIT16: /* 0xd2 */ 6662/* File: x86/OP_MUL_INT_LIT16.S */ 6663 /* mul/lit16 vA, vB, #+CCCC */ 6664 /* Need A in rINST, ssssCCCC in ecx, vB in eax */ 6665 movzbl rINSTbl,%eax # eax<- 000000BA 6666 sarl $4,%eax # eax<- B 6667 GET_VREG_R %eax %eax # eax<- vB 6668 movswl 2(rPC),%ecx # ecx<- ssssCCCC 6669 andb $0xf,rINSTbl # rINST<- A 6670 SPILL(rIBASE) 6671 imull %ecx,%eax # trashes rIBASE/edx 6672 UNSPILL(rIBASE) 6673 FETCH_INST_OPCODE 2 %ecx 6674 ADVANCE_PC 2 6675 SET_VREG %eax rINST 6676 GOTO_NEXT_R %ecx 6677 6678/* ------------------------------ */ 6679.L_OP_DIV_INT_LIT16: /* 0xd3 */ 6680/* File: x86/OP_DIV_INT_LIT16.S */ 6681/* File: x86/bindivLit16.S */ 6682 /* 6683 * 32-bit binary div/rem operation. Handles special case of op0=minint and 6684 * op1=-1. 6685 */ 6686 /* div/rem/lit16 vA, vB, #+CCCC */ 6687 /* Need A in rINST, ssssCCCC in ecx, vB in eax */ 6688 movzbl rINSTbl,%eax # eax<- 000000BA 6689 SPILL(rIBASE) 6690 sarl $4,%eax # eax<- B 6691 GET_VREG_R %eax %eax # eax<- vB 6692 movswl 2(rPC),%ecx # ecx<- ssssCCCC 6693 andb $0xf,rINSTbl # rINST<- A 6694 cmpl $0,%ecx 6695 je common_errDivideByZero 6696 cmpl $-1,%ecx 6697 jne .LOP_DIV_INT_LIT16_continue_div 6698 cmpl $0x80000000,%eax 6699 jne .LOP_DIV_INT_LIT16_continue_div 6700 movl $0x80000000,%eax 6701 SET_VREG %eax rINST 6702 UNSPILL(rIBASE) 6703 FETCH_INST_OPCODE 2 %ecx 6704 ADVANCE_PC 2 6705 GOTO_NEXT_R %ecx 6706 6707.LOP_DIV_INT_LIT16_continue_div: 6708 cltd 6709 idivl %ecx 6710 SET_VREG %eax rINST 6711 UNSPILL(rIBASE) 6712 FETCH_INST_OPCODE 2 %ecx 6713 ADVANCE_PC 2 6714 GOTO_NEXT_R %ecx 6715 6716 6717/* ------------------------------ */ 6718.L_OP_REM_INT_LIT16: /* 0xd4 */ 6719/* File: x86/OP_REM_INT_LIT16.S */ 6720/* File: x86/bindivLit16.S */ 6721 /* 6722 * 32-bit binary div/rem operation. Handles special case of op0=minint and 6723 * op1=-1. 6724 */ 6725 /* div/rem/lit16 vA, vB, #+CCCC */ 6726 /* Need A in rINST, ssssCCCC in ecx, vB in eax */ 6727 movzbl rINSTbl,%eax # eax<- 000000BA 6728 SPILL(rIBASE) 6729 sarl $4,%eax # eax<- B 6730 GET_VREG_R %eax %eax # eax<- vB 6731 movswl 2(rPC),%ecx # ecx<- ssssCCCC 6732 andb $0xf,rINSTbl # rINST<- A 6733 cmpl $0,%ecx 6734 je common_errDivideByZero 6735 cmpl $-1,%ecx 6736 jne .LOP_REM_INT_LIT16_continue_div 6737 cmpl $0x80000000,%eax 6738 jne .LOP_REM_INT_LIT16_continue_div 6739 movl $0,rIBASE 6740 SET_VREG rIBASE rINST 6741 UNSPILL(rIBASE) 6742 FETCH_INST_OPCODE 2 %ecx 6743 ADVANCE_PC 2 6744 GOTO_NEXT_R %ecx 6745 6746.LOP_REM_INT_LIT16_continue_div: 6747 cltd 6748 idivl %ecx 6749 SET_VREG rIBASE rINST 6750 UNSPILL(rIBASE) 6751 FETCH_INST_OPCODE 2 %ecx 6752 ADVANCE_PC 2 6753 GOTO_NEXT_R %ecx 6754 6755 6756/* ------------------------------ */ 6757.L_OP_AND_INT_LIT16: /* 0xd5 */ 6758/* File: x86/OP_AND_INT_LIT16.S */ 6759/* File: x86/binopLit16.S */ 6760 /* 6761 * Generic 32-bit "lit16" binary operation. Provide an "instr" line 6762 * that specifies an instruction that performs "result = eax op ecx". 6763 * This could be an x86 instruction or a function call. (If the result 6764 * comes back in a register other than eax, you can override "result".) 6765 * 6766 * For: add-int/lit16, rsub-int, 6767 * and-int/lit16, or-int/lit16, xor-int/lit16 6768 */ 6769 /* binop/lit16 vA, vB, #+CCCC */ 6770 movzbl rINSTbl,%eax # eax<- 000000BA 6771 sarl $4,%eax # eax<- B 6772 GET_VREG_R %eax %eax # eax<- vB 6773 movswl 2(rPC),%ecx # ecx<- ssssCCCC 6774 andb $0xf,rINSTbl # rINST<- A 6775 andl %ecx,%eax # for example: addl %ecx, %eax 6776 SET_VREG %eax rINST 6777 FETCH_INST_OPCODE 2 %ecx 6778 ADVANCE_PC 2 6779 GOTO_NEXT_R %ecx 6780 6781 6782/* ------------------------------ */ 6783.L_OP_OR_INT_LIT16: /* 0xd6 */ 6784/* File: x86/OP_OR_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 orl %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_XOR_INT_LIT16: /* 0xd7 */ 6810/* File: x86/OP_XOR_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 xor %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_ADD_INT_LIT8: /* 0xd8 */ 6836/* File: x86/OP_ADD_INT_LIT8.S */ 6837/* File: x86/binopLit8.S */ 6838 /* 6839 * Generic 32-bit "lit8" 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 r0, you can override "result".) 6843 * 6844 * For: add-int/lit8, rsub-int/lit8 6845 * and-int/lit8, or-int/lit8, xor-int/lit8, 6846 * shl-int/lit8, shr-int/lit8, ushr-int/lit8 6847 */ 6848 /* binop/lit8 vAA, vBB, #+CC */ 6849 movzbl 2(rPC),%eax # eax<- BB 6850 movsbl 3(rPC),%ecx # ecx<- ssssssCC 6851 GET_VREG_R %eax %eax # eax<- rBB 6852 addl %ecx,%eax # ex: addl %ecx,%eax 6853 SET_VREG %eax rINST 6854 FETCH_INST_OPCODE 2 %ecx 6855 ADVANCE_PC 2 6856 GOTO_NEXT_R %ecx 6857 6858 6859/* ------------------------------ */ 6860.L_OP_RSUB_INT_LIT8: /* 0xd9 */ 6861/* File: x86/OP_RSUB_INT_LIT8.S */ 6862/* File: x86/binopLit8.S */ 6863 /* 6864 * Generic 32-bit "lit8" binary operation. Provide an "instr" line 6865 * that specifies an instruction that performs "result = eax op ecx". 6866 * This could be an x86 instruction or a function call. (If the result 6867 * comes back in a register other than r0, you can override "result".) 6868 * 6869 * For: add-int/lit8, rsub-int/lit8 6870 * and-int/lit8, or-int/lit8, xor-int/lit8, 6871 * shl-int/lit8, shr-int/lit8, ushr-int/lit8 6872 */ 6873 /* binop/lit8 vAA, vBB, #+CC */ 6874 movzbl 2(rPC),%eax # eax<- BB 6875 movsbl 3(rPC),%ecx # ecx<- ssssssCC 6876 GET_VREG_R %eax %eax # eax<- rBB 6877 subl %eax,%ecx # ex: addl %ecx,%eax 6878 SET_VREG %ecx rINST 6879 FETCH_INST_OPCODE 2 %ecx 6880 ADVANCE_PC 2 6881 GOTO_NEXT_R %ecx 6882 6883 6884/* ------------------------------ */ 6885.L_OP_MUL_INT_LIT8: /* 0xda */ 6886/* File: x86/OP_MUL_INT_LIT8.S */ 6887 /* mul/lit8 vAA, vBB, #+CC */ 6888 movzbl 2(rPC),%eax # eax<- BB 6889 movsbl 3(rPC),%ecx # ecx<- ssssssCC 6890 GET_VREG_R %eax %eax # eax<- rBB 6891 SPILL(rIBASE) 6892 imull %ecx,%eax # trashes rIBASE/edx 6893 UNSPILL(rIBASE) 6894 FETCH_INST_OPCODE 2 %ecx 6895 ADVANCE_PC 2 6896 SET_VREG %eax rINST 6897 GOTO_NEXT_R %ecx 6898 6899/* ------------------------------ */ 6900.L_OP_DIV_INT_LIT8: /* 0xdb */ 6901/* File: x86/OP_DIV_INT_LIT8.S */ 6902/* File: x86/bindivLit8.S */ 6903 /* 6904 * 32-bit div/rem "lit8" binary operation. Handles special case of 6905 * op0=minint & op1=-1 6906 */ 6907 /* div/rem/lit8 vAA, vBB, #+CC */ 6908 movzbl 2(rPC),%eax # eax<- BB 6909 movsbl 3(rPC),%ecx # ecx<- ssssssCC 6910 SPILL(rIBASE) 6911 GET_VREG_R %eax %eax # eax<- rBB 6912 cmpl $0,%ecx 6913 je common_errDivideByZero 6914 cmpl $0x80000000,%eax 6915 jne .LOP_DIV_INT_LIT8_continue_div 6916 cmpl $-1,%ecx 6917 jne .LOP_DIV_INT_LIT8_continue_div 6918 movl $0x80000000,%eax 6919 SET_VREG %eax rINST 6920 UNSPILL(rIBASE) 6921 FETCH_INST_OPCODE 2 %ecx 6922 ADVANCE_PC 2 6923 GOTO_NEXT_R %ecx 6924 6925.LOP_DIV_INT_LIT8_continue_div: 6926 cltd 6927 idivl %ecx 6928 SET_VREG %eax rINST 6929 UNSPILL(rIBASE) 6930 FETCH_INST_OPCODE 2 %ecx 6931 ADVANCE_PC 2 6932 GOTO_NEXT_R %ecx 6933 6934 6935/* ------------------------------ */ 6936.L_OP_REM_INT_LIT8: /* 0xdc */ 6937/* File: x86/OP_REM_INT_LIT8.S */ 6938/* File: x86/bindivLit8.S */ 6939 /* 6940 * 32-bit div/rem "lit8" binary operation. Handles special case of 6941 * op0=minint & op1=-1 6942 */ 6943 /* div/rem/lit8 vAA, vBB, #+CC */ 6944 movzbl 2(rPC),%eax # eax<- BB 6945 movsbl 3(rPC),%ecx # ecx<- ssssssCC 6946 SPILL(rIBASE) 6947 GET_VREG_R %eax %eax # eax<- rBB 6948 cmpl $0,%ecx 6949 je common_errDivideByZero 6950 cmpl $0x80000000,%eax 6951 jne .LOP_REM_INT_LIT8_continue_div 6952 cmpl $-1,%ecx 6953 jne .LOP_REM_INT_LIT8_continue_div 6954 movl $0,rIBASE 6955 SET_VREG rIBASE rINST 6956 UNSPILL(rIBASE) 6957 FETCH_INST_OPCODE 2 %ecx 6958 ADVANCE_PC 2 6959 GOTO_NEXT_R %ecx 6960 6961.LOP_REM_INT_LIT8_continue_div: 6962 cltd 6963 idivl %ecx 6964 SET_VREG rIBASE rINST 6965 UNSPILL(rIBASE) 6966 FETCH_INST_OPCODE 2 %ecx 6967 ADVANCE_PC 2 6968 GOTO_NEXT_R %ecx 6969 6970 6971/* ------------------------------ */ 6972.L_OP_AND_INT_LIT8: /* 0xdd */ 6973/* File: x86/OP_AND_INT_LIT8.S */ 6974/* File: x86/binopLit8.S */ 6975 /* 6976 * Generic 32-bit "lit8" binary operation. Provide an "instr" line 6977 * that specifies an instruction that performs "result = eax op ecx". 6978 * This could be an x86 instruction or a function call. (If the result 6979 * comes back in a register other than r0, you can override "result".) 6980 * 6981 * For: add-int/lit8, rsub-int/lit8 6982 * and-int/lit8, or-int/lit8, xor-int/lit8, 6983 * shl-int/lit8, shr-int/lit8, ushr-int/lit8 6984 */ 6985 /* binop/lit8 vAA, vBB, #+CC */ 6986 movzbl 2(rPC),%eax # eax<- BB 6987 movsbl 3(rPC),%ecx # ecx<- ssssssCC 6988 GET_VREG_R %eax %eax # eax<- rBB 6989 andl %ecx,%eax # ex: addl %ecx,%eax 6990 SET_VREG %eax rINST 6991 FETCH_INST_OPCODE 2 %ecx 6992 ADVANCE_PC 2 6993 GOTO_NEXT_R %ecx 6994 6995 6996/* ------------------------------ */ 6997.L_OP_OR_INT_LIT8: /* 0xde */ 6998/* File: x86/OP_OR_INT_LIT8.S */ 6999/* File: x86/binopLit8.S */ 7000 /* 7001 * Generic 32-bit "lit8" binary operation. Provide an "instr" line 7002 * that specifies an instruction that performs "result = eax op ecx". 7003 * This could be an x86 instruction or a function call. (If the result 7004 * comes back in a register other than r0, you can override "result".) 7005 * 7006 * For: add-int/lit8, rsub-int/lit8 7007 * and-int/lit8, or-int/lit8, xor-int/lit8, 7008 * shl-int/lit8, shr-int/lit8, ushr-int/lit8 7009 */ 7010 /* binop/lit8 vAA, vBB, #+CC */ 7011 movzbl 2(rPC),%eax # eax<- BB 7012 movsbl 3(rPC),%ecx # ecx<- ssssssCC 7013 GET_VREG_R %eax %eax # eax<- rBB 7014 orl %ecx,%eax # ex: addl %ecx,%eax 7015 SET_VREG %eax rINST 7016 FETCH_INST_OPCODE 2 %ecx 7017 ADVANCE_PC 2 7018 GOTO_NEXT_R %ecx 7019 7020 7021/* ------------------------------ */ 7022.L_OP_XOR_INT_LIT8: /* 0xdf */ 7023/* File: x86/OP_XOR_INT_LIT8.S */ 7024/* File: x86/binopLit8.S */ 7025 /* 7026 * Generic 32-bit "lit8" binary operation. Provide an "instr" line 7027 * that specifies an instruction that performs "result = eax op ecx". 7028 * This could be an x86 instruction or a function call. (If the result 7029 * comes back in a register other than r0, you can override "result".) 7030 * 7031 * For: add-int/lit8, rsub-int/lit8 7032 * and-int/lit8, or-int/lit8, xor-int/lit8, 7033 * shl-int/lit8, shr-int/lit8, ushr-int/lit8 7034 */ 7035 /* binop/lit8 vAA, vBB, #+CC */ 7036 movzbl 2(rPC),%eax # eax<- BB 7037 movsbl 3(rPC),%ecx # ecx<- ssssssCC 7038 GET_VREG_R %eax %eax # eax<- rBB 7039 xor %ecx,%eax # ex: addl %ecx,%eax 7040 SET_VREG %eax rINST 7041 FETCH_INST_OPCODE 2 %ecx 7042 ADVANCE_PC 2 7043 GOTO_NEXT_R %ecx 7044 7045 7046/* ------------------------------ */ 7047.L_OP_SHL_INT_LIT8: /* 0xe0 */ 7048/* File: x86/OP_SHL_INT_LIT8.S */ 7049/* File: x86/binopLit8.S */ 7050 /* 7051 * Generic 32-bit "lit8" binary operation. Provide an "instr" line 7052 * that specifies an instruction that performs "result = eax op ecx". 7053 * This could be an x86 instruction or a function call. (If the result 7054 * comes back in a register other than r0, you can override "result".) 7055 * 7056 * For: add-int/lit8, rsub-int/lit8 7057 * and-int/lit8, or-int/lit8, xor-int/lit8, 7058 * shl-int/lit8, shr-int/lit8, ushr-int/lit8 7059 */ 7060 /* binop/lit8 vAA, vBB, #+CC */ 7061 movzbl 2(rPC),%eax # eax<- BB 7062 movsbl 3(rPC),%ecx # ecx<- ssssssCC 7063 GET_VREG_R %eax %eax # eax<- rBB 7064 sall %cl,%eax # ex: addl %ecx,%eax 7065 SET_VREG %eax rINST 7066 FETCH_INST_OPCODE 2 %ecx 7067 ADVANCE_PC 2 7068 GOTO_NEXT_R %ecx 7069 7070 7071/* ------------------------------ */ 7072.L_OP_SHR_INT_LIT8: /* 0xe1 */ 7073/* File: x86/OP_SHR_INT_LIT8.S */ 7074/* File: x86/binopLit8.S */ 7075 /* 7076 * Generic 32-bit "lit8" binary operation. Provide an "instr" line 7077 * that specifies an instruction that performs "result = eax op ecx". 7078 * This could be an x86 instruction or a function call. (If the result 7079 * comes back in a register other than r0, you can override "result".) 7080 * 7081 * For: add-int/lit8, rsub-int/lit8 7082 * and-int/lit8, or-int/lit8, xor-int/lit8, 7083 * shl-int/lit8, shr-int/lit8, ushr-int/lit8 7084 */ 7085 /* binop/lit8 vAA, vBB, #+CC */ 7086 movzbl 2(rPC),%eax # eax<- BB 7087 movsbl 3(rPC),%ecx # ecx<- ssssssCC 7088 GET_VREG_R %eax %eax # eax<- rBB 7089 sarl %cl,%eax # ex: addl %ecx,%eax 7090 SET_VREG %eax rINST 7091 FETCH_INST_OPCODE 2 %ecx 7092 ADVANCE_PC 2 7093 GOTO_NEXT_R %ecx 7094 7095 7096/* ------------------------------ */ 7097.L_OP_USHR_INT_LIT8: /* 0xe2 */ 7098/* File: x86/OP_USHR_INT_LIT8.S */ 7099/* File: x86/binopLit8.S */ 7100 /* 7101 * Generic 32-bit "lit8" binary operation. Provide an "instr" line 7102 * that specifies an instruction that performs "result = eax op ecx". 7103 * This could be an x86 instruction or a function call. (If the result 7104 * comes back in a register other than r0, you can override "result".) 7105 * 7106 * For: add-int/lit8, rsub-int/lit8 7107 * and-int/lit8, or-int/lit8, xor-int/lit8, 7108 * shl-int/lit8, shr-int/lit8, ushr-int/lit8 7109 */ 7110 /* binop/lit8 vAA, vBB, #+CC */ 7111 movzbl 2(rPC),%eax # eax<- BB 7112 movsbl 3(rPC),%ecx # ecx<- ssssssCC 7113 GET_VREG_R %eax %eax # eax<- rBB 7114 shrl %cl,%eax # ex: addl %ecx,%eax 7115 SET_VREG %eax rINST 7116 FETCH_INST_OPCODE 2 %ecx 7117 ADVANCE_PC 2 7118 GOTO_NEXT_R %ecx 7119 7120 7121/* ------------------------------ */ 7122.L_OP_IGET_VOLATILE: /* 0xe3 */ 7123/* File: x86/OP_IGET_VOLATILE.S */ 7124/* File: x86/OP_IGET.S */ 7125 /* 7126 * General 32-bit instance field get. 7127 * 7128 * for: iget, iget-object, iget-boolean, iget-byte, iget-char, iget-short 7129 */ 7130 /* op vA, vB, field@CCCC */ 7131 movl rSELF,%ecx 7132 SPILL(rIBASE) # preserve rIBASE 7133 movzwl 2(rPC),rIBASE # rIBASE<- 0000CCCC 7134 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex 7135 movzbl rINSTbl,%ecx # ecx<- BA 7136 sarl $4,%ecx # ecx<- B 7137 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields 7138 andb $0xf,rINSTbl # rINST<- A 7139 GET_VREG_R %ecx %ecx # ecx<- fp[B], the object ptr 7140 movl (%eax,rIBASE,4),%eax # resolved entry 7141 testl %eax,%eax # is resolved entry null? 7142 jne .LOP_IGET_VOLATILE_finish # no, already resolved 7143 movl rIBASE,OUT_ARG1(%esp) # needed by dvmResolveInstField 7144 movl rSELF,rIBASE 7145 EXPORT_PC 7146 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method 7147 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz 7148 SPILL_TMP1(%ecx) # save obj pointer across call 7149 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz 7150 call dvmResolveInstField # ... to dvmResolveInstField 7151 UNSPILL_TMP1(%ecx) 7152 testl %eax,%eax # returns InstrField ptr 7153 jne .LOP_IGET_VOLATILE_finish 7154 jmp common_exceptionThrown 7155 7156.LOP_IGET_VOLATILE_finish: 7157 /* 7158 * Currently: 7159 * eax holds resolved field 7160 * ecx holds object 7161 * rINST holds A 7162 */ 7163 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field 7164 testl %ecx,%ecx # object null? 7165 je common_errNullObject # object was null 7166 movl (%ecx,%eax,1),%ecx # ecx<- obj.field (8/16/32 bits) 7167 FETCH_INST_OPCODE 2 %eax 7168 UNSPILL(rIBASE) 7169 SET_VREG %ecx rINST 7170 ADVANCE_PC 2 7171 GOTO_NEXT_R %eax 7172 7173 7174/* ------------------------------ */ 7175.L_OP_IPUT_VOLATILE: /* 0xe4 */ 7176/* File: x86/OP_IPUT_VOLATILE.S */ 7177/* File: x86/OP_IPUT.S */ 7178 7179 /* 7180 * General 32-bit instance field put. 7181 * 7182 * for: iput, iput-object, iput-boolean, iput-byte, iput-char, iput-short 7183 */ 7184 /* op vA, vB, field@CCCC */ 7185 movl rSELF,%ecx 7186 SPILL (rIBASE) 7187 movzwl 2(rPC),rIBASE # rIBASE<- 0000CCCC 7188 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex 7189 movzbl rINSTbl,%ecx # ecx<- BA 7190 sarl $4,%ecx # ecx<- B 7191 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields 7192 andb $0xf,rINSTbl # rINST<- A 7193 GET_VREG_R %ecx %ecx # ecx<- fp[B], the object ptr 7194 movl (%eax,rIBASE,4),%eax # resolved entry 7195 testl %eax,%eax # is resolved entry null? 7196 jne .LOP_IPUT_VOLATILE_finish # no, already resolved 7197 movl rIBASE,OUT_ARG1(%esp) 7198 movl rSELF,rIBASE 7199 EXPORT_PC 7200 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method 7201 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz 7202 SPILL_TMP1(%ecx) # save obj pointer across call 7203 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz 7204 call dvmResolveInstField # ... to dvmResolveInstField 7205 UNSPILL_TMP1(%ecx) 7206 testl %eax,%eax # returns InstrField ptr 7207 jne .LOP_IPUT_VOLATILE_finish 7208 jmp common_exceptionThrown 7209 7210.LOP_IPUT_VOLATILE_finish: 7211 /* 7212 * Currently: 7213 * eax holds resolved field 7214 * ecx holds object 7215 * rINST holds A 7216 */ 7217 GET_VREG_R rINST rINST # rINST<- v[A] 7218 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field 7219 testl %ecx,%ecx # object null? 7220 je common_errNullObject # object was null 7221 movl rINST,(%ecx,%eax,1) # obj.field <- v[A](8/16/32 bits) 7222 FETCH_INST_OPCODE 2 %ecx 7223 UNSPILL(rIBASE) 7224 ADVANCE_PC 2 7225 GOTO_NEXT_R %ecx 7226 7227 7228/* ------------------------------ */ 7229.L_OP_SGET_VOLATILE: /* 0xe5 */ 7230/* File: x86/OP_SGET_VOLATILE.S */ 7231/* File: x86/OP_SGET.S */ 7232 /* 7233 * General 32-bit SGET handler. 7234 * 7235 * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short 7236 */ 7237 /* op vAA, field@BBBB */ 7238 movl rSELF,%ecx 7239 movzwl 2(rPC),%eax # eax<- field ref BBBB 7240 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex 7241 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields 7242 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr 7243 testl %eax,%eax # resolved entry null? 7244 je .LOP_SGET_VOLATILE_resolve # if not, make it so 7245.LOP_SGET_VOLATILE_finish: # field ptr in eax 7246 movl offStaticField_value(%eax),%eax 7247 FETCH_INST_OPCODE 2 %ecx 7248 ADVANCE_PC 2 7249 SET_VREG %eax rINST 7250 GOTO_NEXT_R %ecx 7251 7252 /* 7253 * Go resolve the field 7254 */ 7255.LOP_SGET_VOLATILE_resolve: 7256 movl rSELF,%ecx 7257 movzwl 2(rPC),%eax # eax<- field ref BBBB 7258 movl offThread_method(%ecx),%ecx # ecx<- current method 7259 EXPORT_PC # could throw, need to export 7260 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 7261 movl %eax,OUT_ARG1(%esp) 7262 movl %ecx,OUT_ARG0(%esp) 7263 SPILL(rIBASE) 7264 call dvmResolveStaticField # eax<- resolved StaticField ptr 7265 UNSPILL(rIBASE) 7266 testl %eax,%eax 7267 jne .LOP_SGET_VOLATILE_finish # success, continue 7268 jmp common_exceptionThrown # no, handle exception 7269 7270 7271/* ------------------------------ */ 7272.L_OP_SPUT_VOLATILE: /* 0xe6 */ 7273/* File: x86/OP_SPUT_VOLATILE.S */ 7274/* File: x86/OP_SPUT.S */ 7275 /* 7276 * General 32-bit SPUT handler. 7277 * 7278 * for: sput, sput-boolean, sput-byte, sput-char, sput-short 7279 */ 7280 /* op vAA, field@BBBB */ 7281 movl rSELF,%ecx 7282 movzwl 2(rPC),%eax # eax<- field ref BBBB 7283 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex 7284 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields 7285 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr 7286 testl %eax,%eax # resolved entry null? 7287 je .LOP_SPUT_VOLATILE_resolve # if not, make it so 7288.LOP_SPUT_VOLATILE_finish: # field ptr in eax 7289 GET_VREG_R rINST rINST 7290 FETCH_INST_OPCODE 2 %ecx 7291 ADVANCE_PC 2 7292 movl rINST,offStaticField_value(%eax) 7293 GOTO_NEXT_R %ecx 7294 7295 /* 7296 * Go resolve the field 7297 */ 7298.LOP_SPUT_VOLATILE_resolve: 7299 movl rSELF,%ecx 7300 movzwl 2(rPC),%eax # eax<- field ref BBBB 7301 movl offThread_method(%ecx),%ecx # ecx<- current method 7302 EXPORT_PC # could throw, need to export 7303 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 7304 movl %eax,OUT_ARG1(%esp) 7305 movl %ecx,OUT_ARG0(%esp) 7306 SPILL(rIBASE) 7307 call dvmResolveStaticField # eax<- resolved StaticField ptr 7308 UNSPILL(rIBASE) 7309 testl %eax,%eax 7310 jne .LOP_SPUT_VOLATILE_finish # success, continue 7311 jmp common_exceptionThrown # no, handle exception 7312 7313 7314/* ------------------------------ */ 7315.L_OP_IGET_OBJECT_VOLATILE: /* 0xe7 */ 7316/* File: x86/OP_IGET_OBJECT_VOLATILE.S */ 7317/* File: x86/OP_IGET.S */ 7318 /* 7319 * General 32-bit instance field get. 7320 * 7321 * for: iget, iget-object, iget-boolean, iget-byte, iget-char, iget-short 7322 */ 7323 /* op vA, vB, field@CCCC */ 7324 movl rSELF,%ecx 7325 SPILL(rIBASE) # preserve rIBASE 7326 movzwl 2(rPC),rIBASE # rIBASE<- 0000CCCC 7327 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex 7328 movzbl rINSTbl,%ecx # ecx<- BA 7329 sarl $4,%ecx # ecx<- B 7330 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields 7331 andb $0xf,rINSTbl # rINST<- A 7332 GET_VREG_R %ecx %ecx # ecx<- fp[B], the object ptr 7333 movl (%eax,rIBASE,4),%eax # resolved entry 7334 testl %eax,%eax # is resolved entry null? 7335 jne .LOP_IGET_OBJECT_VOLATILE_finish # no, already resolved 7336 movl rIBASE,OUT_ARG1(%esp) # needed by dvmResolveInstField 7337 movl rSELF,rIBASE 7338 EXPORT_PC 7339 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method 7340 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz 7341 SPILL_TMP1(%ecx) # save obj pointer across call 7342 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz 7343 call dvmResolveInstField # ... to dvmResolveInstField 7344 UNSPILL_TMP1(%ecx) 7345 testl %eax,%eax # returns InstrField ptr 7346 jne .LOP_IGET_OBJECT_VOLATILE_finish 7347 jmp common_exceptionThrown 7348 7349.LOP_IGET_OBJECT_VOLATILE_finish: 7350 /* 7351 * Currently: 7352 * eax holds resolved field 7353 * ecx holds object 7354 * rINST holds A 7355 */ 7356 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field 7357 testl %ecx,%ecx # object null? 7358 je common_errNullObject # object was null 7359 movl (%ecx,%eax,1),%ecx # ecx<- obj.field (8/16/32 bits) 7360 FETCH_INST_OPCODE 2 %eax 7361 UNSPILL(rIBASE) 7362 SET_VREG %ecx rINST 7363 ADVANCE_PC 2 7364 GOTO_NEXT_R %eax 7365 7366 7367/* ------------------------------ */ 7368.L_OP_IGET_WIDE_VOLATILE: /* 0xe8 */ 7369 /* (stub) */ 7370 SAVE_PC_FP_TO_SELF %ecx # leaves rSELF in %ecx 7371 movl %ecx,OUT_ARG0(%esp) # self is first arg to function 7372 call dvmMterp_OP_IGET_WIDE_VOLATILE # do the real work 7373 movl rSELF,%ecx 7374 LOAD_PC_FP_FROM_SELF # retrieve updated values 7375 movl offThread_curHandlerTable(%ecx),rIBASE # set up rIBASE 7376 FETCH_INST 7377 GOTO_NEXT 7378/* ------------------------------ */ 7379.L_OP_IPUT_WIDE_VOLATILE: /* 0xe9 */ 7380 /* (stub) */ 7381 SAVE_PC_FP_TO_SELF %ecx # leaves rSELF in %ecx 7382 movl %ecx,OUT_ARG0(%esp) # self is first arg to function 7383 call dvmMterp_OP_IPUT_WIDE_VOLATILE # do the real work 7384 movl rSELF,%ecx 7385 LOAD_PC_FP_FROM_SELF # retrieve updated values 7386 movl offThread_curHandlerTable(%ecx),rIBASE # set up rIBASE 7387 FETCH_INST 7388 GOTO_NEXT 7389/* ------------------------------ */ 7390.L_OP_SGET_WIDE_VOLATILE: /* 0xea */ 7391 /* (stub) */ 7392 SAVE_PC_FP_TO_SELF %ecx # leaves rSELF in %ecx 7393 movl %ecx,OUT_ARG0(%esp) # self is first arg to function 7394 call dvmMterp_OP_SGET_WIDE_VOLATILE # do the real work 7395 movl rSELF,%ecx 7396 LOAD_PC_FP_FROM_SELF # retrieve updated values 7397 movl offThread_curHandlerTable(%ecx),rIBASE # set up rIBASE 7398 FETCH_INST 7399 GOTO_NEXT 7400/* ------------------------------ */ 7401.L_OP_SPUT_WIDE_VOLATILE: /* 0xeb */ 7402 /* (stub) */ 7403 SAVE_PC_FP_TO_SELF %ecx # leaves rSELF in %ecx 7404 movl %ecx,OUT_ARG0(%esp) # self is first arg to function 7405 call dvmMterp_OP_SPUT_WIDE_VOLATILE # do the real work 7406 movl rSELF,%ecx 7407 LOAD_PC_FP_FROM_SELF # retrieve updated values 7408 movl offThread_curHandlerTable(%ecx),rIBASE # set up rIBASE 7409 FETCH_INST 7410 GOTO_NEXT 7411/* ------------------------------ */ 7412.L_OP_BREAKPOINT: /* 0xec */ 7413/* File: x86/OP_BREAKPOINT.S */ 7414 /* 7415 * Breakpoint handler. 7416 * 7417 * Restart this instruction with the original opcode. By 7418 * the time we get here, the breakpoint will have already been 7419 * handled. We also assume that all other special "checkBefore" 7420 * actions have been handled, so we'll transition directly 7421 * to the real handler 7422 */ 7423 SPILL(rIBASE) 7424 movl rPC,OUT_ARG0(%esp) 7425 call dvmGetOriginalOpcode 7426 UNSPILL(rIBASE) 7427 movl rSELF,%ecx 7428 movzbl 1(rPC),rINST 7429 movl offThread_mainHandlerTable(%ecx),%ecx 7430 jmp *(%ecx,%eax,4) 7431 7432 7433/* ------------------------------ */ 7434.L_OP_THROW_VERIFICATION_ERROR: /* 0xed */ 7435/* File: x86/OP_THROW_VERIFICATION_ERROR.S */ 7436 /* 7437 * Handle a throw-verification-error instruction. This throws an 7438 * exception for an error discovered during verification. The 7439 * exception is indicated by AA, with some detail provided by BBBB. 7440 */ 7441 /* op AA, ref@BBBB */ 7442 movl rSELF,%ecx 7443 movzwl 2(rPC),%eax # eax<- BBBB 7444 movl offThread_method(%ecx),%ecx # ecx<- self->method 7445 EXPORT_PC 7446 movl %eax,OUT_ARG2(%esp) # arg2<- BBBB 7447 movl rINST,OUT_ARG1(%esp) # arg1<- AA 7448 movl %ecx,OUT_ARG0(%esp) # arg0<- method 7449 call dvmThrowVerificationError # call(method, kind, ref) 7450 jmp common_exceptionThrown # handle exception 7451 7452/* ------------------------------ */ 7453.L_OP_EXECUTE_INLINE: /* 0xee */ 7454/* File: x86/OP_EXECUTE_INLINE.S */ 7455 /* 7456 * Execute a "native inline" instruction. 7457 * 7458 * We will be calling through a function table: 7459 * 7460 * (*gDvmInlineOpsTable[opIndex].func)(arg0, arg1, arg2, arg3, pResult) 7461 * 7462 * Ignores argument count - always loads 4. 7463 * 7464 */ 7465 /* [opt] execute-inline vAA, {vC, vD, vE, vF}, inline@BBBB */ 7466 movl rSELF,%ecx 7467 EXPORT_PC 7468 movzwl 2(rPC),%eax # eax<- BBBB 7469 leal offThread_retval(%ecx),%ecx # ecx<- & self->retval 7470 SPILL(rIBASE) # preserve rIBASE 7471 movl %ecx,OUT_ARG4(%esp) 7472 call .LOP_EXECUTE_INLINE_continue # make call; will return after 7473 UNSPILL(rIBASE) # restore rIBASE 7474 testl %eax,%eax # successful? 7475 FETCH_INST_OPCODE 3 %ecx 7476 je common_exceptionThrown # no, handle exception 7477 ADVANCE_PC 3 7478 GOTO_NEXT_R %ecx 7479 7480.LOP_EXECUTE_INLINE_continue: 7481 /* 7482 * Extract args, call function. 7483 * ecx = #of args (0-4) 7484 * eax = call index 7485 * @esp = return addr 7486 * esp is -4 from normal 7487 * 7488 * Go ahead and load all 4 args, even if not used. 7489 */ 7490 movzwl 4(rPC),rIBASE 7491 7492 movl $0xf,%ecx 7493 andl rIBASE,%ecx 7494 GET_VREG_R %ecx %ecx 7495 sarl $4,rIBASE 7496 movl %ecx,4+OUT_ARG0(%esp) 7497 7498 movl $0xf,%ecx 7499 andl rIBASE,%ecx 7500 GET_VREG_R %ecx %ecx 7501 sarl $4,rIBASE 7502 movl %ecx,4+OUT_ARG1(%esp) 7503 7504 movl $0xf,%ecx 7505 andl rIBASE,%ecx 7506 GET_VREG_R %ecx %ecx 7507 sarl $4,rIBASE 7508 movl %ecx,4+OUT_ARG2(%esp) 7509 7510 movl $0xf,%ecx 7511 andl rIBASE,%ecx 7512 GET_VREG_R %ecx %ecx 7513 sarl $4,rIBASE 7514 movl %ecx,4+OUT_ARG3(%esp) 7515 7516 sall $4,%eax # index *= sizeof(table entry) 7517 jmp *gDvmInlineOpsTable(%eax) 7518 # will return to caller of .LOP_EXECUTE_INLINE_continue 7519 7520/* ------------------------------ */ 7521.L_OP_EXECUTE_INLINE_RANGE: /* 0xef */ 7522 /* (stub) */ 7523 SAVE_PC_FP_TO_SELF %ecx # leaves rSELF in %ecx 7524 movl %ecx,OUT_ARG0(%esp) # self is first arg to function 7525 call dvmMterp_OP_EXECUTE_INLINE_RANGE # do the real work 7526 movl rSELF,%ecx 7527 LOAD_PC_FP_FROM_SELF # retrieve updated values 7528 movl offThread_curHandlerTable(%ecx),rIBASE # set up rIBASE 7529 FETCH_INST 7530 GOTO_NEXT 7531/* ------------------------------ */ 7532.L_OP_INVOKE_OBJECT_INIT_RANGE: /* 0xf0 */ 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_INVOKE_OBJECT_INIT_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_RETURN_VOID_BARRIER: /* 0xf1 */ 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_RETURN_VOID_BARRIER # 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_IGET_QUICK: /* 0xf2 */ 7555/* File: x86/OP_IGET_QUICK.S */ 7556 /* For: iget-quick, iget-object-quick */ 7557 /* op vA, vB, offset@CCCC */ 7558 movzbl rINSTbl,%ecx # ecx<- BA 7559 sarl $4,%ecx # ecx<- B 7560 GET_VREG_R %ecx %ecx # vB (object we're operating on) 7561 movzwl 2(rPC),%eax # eax<- field byte offset 7562 cmpl $0,%ecx # is object null? 7563 je common_errNullObject 7564 movl (%ecx,%eax,1),%eax 7565 FETCH_INST_OPCODE 2 %ecx 7566 ADVANCE_PC 2 7567 andb $0xf,rINSTbl # rINST<- A 7568 SET_VREG %eax rINST # fp[A]<- result 7569 GOTO_NEXT_R %ecx 7570 7571/* ------------------------------ */ 7572.L_OP_IGET_WIDE_QUICK: /* 0xf3 */ 7573/* File: x86/OP_IGET_WIDE_QUICK.S */ 7574 /* For: iget-wide-quick */ 7575 /* op vA, vB, offset@CCCC */ 7576 movzbl rINSTbl,%ecx # ecx<- BA 7577 sarl $4,%ecx # ecx<- B 7578 GET_VREG_R %ecx %ecx # vB (object we're operating on) 7579 movzwl 2(rPC),%eax # eax<- field byte offset 7580 cmpl $0,%ecx # is object null? 7581 je common_errNullObject 7582 leal (%ecx,%eax,1),%eax # eax<- address of 64-bit source 7583 movl (%eax),%ecx # ecx<- lsw 7584 movl 4(%eax),%eax # eax<- msw 7585 andb $0xf,rINSTbl # rINST<- A 7586 SET_VREG_WORD %ecx rINST 0 # v[A+0]<- lsw 7587 FETCH_INST_OPCODE 2 %ecx 7588 SET_VREG_WORD %eax rINST 1 # v[A+1]<- msw 7589 ADVANCE_PC 2 7590 GOTO_NEXT_R %ecx 7591 7592/* ------------------------------ */ 7593.L_OP_IGET_OBJECT_QUICK: /* 0xf4 */ 7594/* File: x86/OP_IGET_OBJECT_QUICK.S */ 7595/* File: x86/OP_IGET_QUICK.S */ 7596 /* For: iget-quick, iget-object-quick */ 7597 /* op vA, vB, offset@CCCC */ 7598 movzbl rINSTbl,%ecx # ecx<- BA 7599 sarl $4,%ecx # ecx<- B 7600 GET_VREG_R %ecx %ecx # vB (object we're operating on) 7601 movzwl 2(rPC),%eax # eax<- field byte offset 7602 cmpl $0,%ecx # is object null? 7603 je common_errNullObject 7604 movl (%ecx,%eax,1),%eax 7605 FETCH_INST_OPCODE 2 %ecx 7606 ADVANCE_PC 2 7607 andb $0xf,rINSTbl # rINST<- A 7608 SET_VREG %eax rINST # fp[A]<- result 7609 GOTO_NEXT_R %ecx 7610 7611 7612/* ------------------------------ */ 7613.L_OP_IPUT_QUICK: /* 0xf5 */ 7614/* File: x86/OP_IPUT_QUICK.S */ 7615 /* For: iput-quick */ 7616 /* op vA, vB, offset@CCCC */ 7617 movzbl rINSTbl,%ecx # ecx<- BA 7618 sarl $4,%ecx # ecx<- B 7619 GET_VREG_R %ecx %ecx # vB (object we're operating on) 7620 andb $0xf,rINSTbl # rINST<- A 7621 GET_VREG_R rINST,rINST # rINST<- v[A] 7622 movzwl 2(rPC),%eax # eax<- field byte offset 7623 testl %ecx,%ecx # is object null? 7624 je common_errNullObject 7625 movl rINST,(%ecx,%eax,1) 7626 FETCH_INST_OPCODE 2 %ecx 7627 ADVANCE_PC 2 7628 GOTO_NEXT_R %ecx 7629 7630/* ------------------------------ */ 7631.L_OP_IPUT_WIDE_QUICK: /* 0xf6 */ 7632/* File: x86/OP_IPUT_WIDE_QUICK.S */ 7633 /* For: iput-wide-quick */ 7634 /* op vA, vB, offset@CCCC */ 7635 movzbl rINSTbl,%ecx # ecx<- BA 7636 sarl $4,%ecx # ecx<- B 7637 GET_VREG_R %ecx %ecx # vB (object we're operating on) 7638 movzwl 2(rPC),%eax # eax<- field byte offset 7639 testl %ecx,%ecx # is object null? 7640 je common_errNullObject 7641 leal (%ecx,%eax,1),%ecx # ecx<- Address of 64-bit target 7642 andb $0xf,rINSTbl # rINST<- A 7643 GET_VREG_WORD %eax rINST 0 # eax<- lsw 7644 GET_VREG_WORD rINST rINST 1 # rINST<- msw 7645 movl %eax,(%ecx) 7646 movl rINST,4(%ecx) 7647 FETCH_INST_OPCODE 2 %ecx 7648 ADVANCE_PC 2 7649 GOTO_NEXT_R %ecx 7650 7651/* ------------------------------ */ 7652.L_OP_IPUT_OBJECT_QUICK: /* 0xf7 */ 7653/* File: x86/OP_IPUT_OBJECT_QUICK.S */ 7654 /* For: iput-object-quick */ 7655 /* op vA, vB, offset@CCCC */ 7656 movzbl rINSTbl,%ecx # ecx<- BA 7657 sarl $4,%ecx # ecx<- B 7658 GET_VREG_R %ecx %ecx # vB (object we're operating on) 7659 andb $0xf,rINSTbl # rINST<- A 7660 GET_VREG_R rINST rINST # rINST<- v[A] 7661 movzwl 2(rPC),%eax # eax<- field byte offset 7662 testl %ecx,%ecx # is object null? 7663 je common_errNullObject 7664 movl rINST,(%ecx,%eax,1) 7665 movl rSELF,%eax 7666 testl rINST,rINST # did we store null? 7667 movl offThread_cardTable(%eax),%eax # get card table base 7668 je 1f # skip card mark if null store 7669 shrl $GC_CARD_SHIFT,%ecx # object head to card number 7670 movb %al,(%eax,%ecx) # mark card based on object head 76711: 7672 FETCH_INST_OPCODE 2 %ecx 7673 ADVANCE_PC 2 7674 GOTO_NEXT_R %ecx 7675 7676/* ------------------------------ */ 7677.L_OP_INVOKE_VIRTUAL_QUICK: /* 0xf8 */ 7678/* File: x86/OP_INVOKE_VIRTUAL_QUICK.S */ 7679 /* 7680 * Handle an optimized virtual method call. 7681 * 7682 * for: [opt] invoke-virtual-quick, invoke-virtual-quick/range 7683 */ 7684 /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ 7685 /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ 7686 movzwl 4(rPC),%eax # eax<- FEDC or CCCC 7687 movzwl 2(rPC),%ecx # ecx<- BBBB 7688 .if (!0) 7689 andl $0xf,%eax # eax<- C (or stays CCCC) 7690 .endif 7691 GET_VREG_R %eax %eax # eax<- vC ("this" ptr) 7692 testl %eax,%eax # null? 7693 je common_errNullObject # yep, throw exception 7694 movl offObject_clazz(%eax),%eax # eax<- thisPtr->clazz 7695 movl offClassObject_vtable(%eax),%eax # eax<- thisPtr->clazz->vtable 7696 EXPORT_PC # might throw later - get ready 7697 movl (%eax,%ecx,4),%eax # eax<- vtable[BBBB] 7698 jmp common_invokeMethodNoRange 7699 7700/* ------------------------------ */ 7701.L_OP_INVOKE_VIRTUAL_QUICK_RANGE: /* 0xf9 */ 7702/* File: x86/OP_INVOKE_VIRTUAL_QUICK_RANGE.S */ 7703/* File: x86/OP_INVOKE_VIRTUAL_QUICK.S */ 7704 /* 7705 * Handle an optimized virtual method call. 7706 * 7707 * for: [opt] invoke-virtual-quick, invoke-virtual-quick/range 7708 */ 7709 /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ 7710 /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ 7711 movzwl 4(rPC),%eax # eax<- FEDC or CCCC 7712 movzwl 2(rPC),%ecx # ecx<- BBBB 7713 .if (!1) 7714 andl $0xf,%eax # eax<- C (or stays CCCC) 7715 .endif 7716 GET_VREG_R %eax %eax # eax<- vC ("this" ptr) 7717 testl %eax,%eax # null? 7718 je common_errNullObject # yep, throw exception 7719 movl offObject_clazz(%eax),%eax # eax<- thisPtr->clazz 7720 movl offClassObject_vtable(%eax),%eax # eax<- thisPtr->clazz->vtable 7721 EXPORT_PC # might throw later - get ready 7722 movl (%eax,%ecx,4),%eax # eax<- vtable[BBBB] 7723 jmp common_invokeMethodRange 7724 7725 7726/* ------------------------------ */ 7727.L_OP_INVOKE_SUPER_QUICK: /* 0xfa */ 7728/* File: x86/OP_INVOKE_SUPER_QUICK.S */ 7729 /* 7730 * Handle an optimized "super" method call. 7731 * 7732 * for: [opt] invoke-super-quick, invoke-super-quick/range 7733 */ 7734 /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ 7735 /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ 7736 movl rSELF,%ecx 7737 movzwl 4(rPC),%eax # eax<- GFED or CCCC 7738 movl offThread_method(%ecx),%ecx # ecx<- current method 7739 .if (!0) 7740 andl $0xf,%eax # eax<- D (or stays CCCC) 7741 .endif 7742 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 7743 GET_VREG_R %eax %eax # eax<- "this" 7744 movl offClassObject_super(%ecx),%ecx # ecx<- method->clazz->super 7745 testl %eax,%eax # null "this"? 7746 je common_errNullObject # "this" is null, throw exception 7747 movzwl 2(rPC),%eax # eax<- BBBB 7748 movl offClassObject_vtable(%ecx),%ecx # ecx<- vtable 7749 EXPORT_PC 7750 movl (%ecx,%eax,4),%eax # eax<- super->vtable[BBBB] 7751 jmp common_invokeMethodNoRange 7752 7753/* ------------------------------ */ 7754.L_OP_INVOKE_SUPER_QUICK_RANGE: /* 0xfb */ 7755/* File: x86/OP_INVOKE_SUPER_QUICK_RANGE.S */ 7756/* File: x86/OP_INVOKE_SUPER_QUICK.S */ 7757 /* 7758 * Handle an optimized "super" method call. 7759 * 7760 * for: [opt] invoke-super-quick, invoke-super-quick/range 7761 */ 7762 /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ 7763 /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ 7764 movl rSELF,%ecx 7765 movzwl 4(rPC),%eax # eax<- GFED or CCCC 7766 movl offThread_method(%ecx),%ecx # ecx<- current method 7767 .if (!1) 7768 andl $0xf,%eax # eax<- D (or stays CCCC) 7769 .endif 7770 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 7771 GET_VREG_R %eax %eax # eax<- "this" 7772 movl offClassObject_super(%ecx),%ecx # ecx<- method->clazz->super 7773 testl %eax,%eax # null "this"? 7774 je common_errNullObject # "this" is null, throw exception 7775 movzwl 2(rPC),%eax # eax<- BBBB 7776 movl offClassObject_vtable(%ecx),%ecx # ecx<- vtable 7777 EXPORT_PC 7778 movl (%ecx,%eax,4),%eax # eax<- super->vtable[BBBB] 7779 jmp common_invokeMethodRange 7780 7781 7782/* ------------------------------ */ 7783.L_OP_IPUT_OBJECT_VOLATILE: /* 0xfc */ 7784/* File: x86/OP_IPUT_OBJECT_VOLATILE.S */ 7785/* File: x86/OP_IPUT_OBJECT.S */ 7786 /* 7787 * Object field put. 7788 * 7789 * for: iput-object 7790 */ 7791 /* op vA, vB, field@CCCC */ 7792 movl rSELF,%ecx 7793 SPILL(rIBASE) 7794 movzwl 2(rPC),rIBASE # rIBASE<- 0000CCCC 7795 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex 7796 movzbl rINSTbl,%ecx # ecx<- BA 7797 sarl $4,%ecx # ecx<- B 7798 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields 7799 andb $0xf,rINSTbl # rINST<- A 7800 GET_VREG_R %ecx %ecx # ecx<- fp[B], the object ptr 7801 movl (%eax,rIBASE,4),%eax # resolved entry 7802 testl %eax,%eax # is resolved entry null? 7803 jne .LOP_IPUT_OBJECT_VOLATILE_finish # no, already resolved 7804 movl rIBASE,OUT_ARG1(%esp) 7805 movl rSELF,rIBASE 7806 EXPORT_PC 7807 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method 7808 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz 7809 SPILL_TMP1(%ecx) # save obj pointer across call 7810 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz 7811 call dvmResolveInstField # ... to dvmResolveInstField 7812 UNSPILL_TMP1(%ecx) 7813 testl %eax,%eax # returns InstrField ptr 7814 jne .LOP_IPUT_OBJECT_VOLATILE_finish 7815 jmp common_exceptionThrown 7816 7817.LOP_IPUT_OBJECT_VOLATILE_finish: 7818 /* 7819 * Currently: 7820 * eax holds resolved field 7821 * ecx holds object 7822 * rIBASE is scratch, but needs to be unspilled 7823 * rINST holds A 7824 */ 7825 GET_VREG_R rINST rINST # rINST<- v[A] 7826 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field 7827 testl %ecx,%ecx # object null? 7828 je common_errNullObject # object was null 7829 movl rINST,(%ecx,%eax) # obj.field <- v[A](8/16/32 bits) 7830 movl rSELF,%eax 7831 testl rINST,rINST # stored a NULL? 7832 movl offThread_cardTable(%eax),%eax # get card table base 7833 je 1f # skip card mark if null store 7834 shrl $GC_CARD_SHIFT,%ecx # object head to card number 7835 movb %al,(%eax,%ecx) # mark card using object head 78361: 7837 UNSPILL(rIBASE) 7838 FETCH_INST_OPCODE 2 %ecx 7839 ADVANCE_PC 2 7840 GOTO_NEXT_R %ecx 7841 7842 7843/* ------------------------------ */ 7844.L_OP_SGET_OBJECT_VOLATILE: /* 0xfd */ 7845/* File: x86/OP_SGET_OBJECT_VOLATILE.S */ 7846/* File: x86/OP_SGET.S */ 7847 /* 7848 * General 32-bit SGET handler. 7849 * 7850 * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short 7851 */ 7852 /* op vAA, field@BBBB */ 7853 movl rSELF,%ecx 7854 movzwl 2(rPC),%eax # eax<- field ref BBBB 7855 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex 7856 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields 7857 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr 7858 testl %eax,%eax # resolved entry null? 7859 je .LOP_SGET_OBJECT_VOLATILE_resolve # if not, make it so 7860.LOP_SGET_OBJECT_VOLATILE_finish: # field ptr in eax 7861 movl offStaticField_value(%eax),%eax 7862 FETCH_INST_OPCODE 2 %ecx 7863 ADVANCE_PC 2 7864 SET_VREG %eax rINST 7865 GOTO_NEXT_R %ecx 7866 7867 /* 7868 * Go resolve the field 7869 */ 7870.LOP_SGET_OBJECT_VOLATILE_resolve: 7871 movl rSELF,%ecx 7872 movzwl 2(rPC),%eax # eax<- field ref BBBB 7873 movl offThread_method(%ecx),%ecx # ecx<- current method 7874 EXPORT_PC # could throw, need to export 7875 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 7876 movl %eax,OUT_ARG1(%esp) 7877 movl %ecx,OUT_ARG0(%esp) 7878 SPILL(rIBASE) 7879 call dvmResolveStaticField # eax<- resolved StaticField ptr 7880 UNSPILL(rIBASE) 7881 testl %eax,%eax 7882 jne .LOP_SGET_OBJECT_VOLATILE_finish # success, continue 7883 jmp common_exceptionThrown # no, handle exception 7884 7885 7886/* ------------------------------ */ 7887.L_OP_SPUT_OBJECT_VOLATILE: /* 0xfe */ 7888/* File: x86/OP_SPUT_OBJECT_VOLATILE.S */ 7889/* File: x86/OP_SPUT_OBJECT.S */ 7890 /* 7891 * SPUT object handler. 7892 */ 7893 /* op vAA, field@BBBB */ 7894 movl rSELF,%ecx 7895 movzwl 2(rPC),%eax # eax<- field ref BBBB 7896 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex 7897 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields 7898 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField 7899 testl %eax,%eax # resolved entry null? 7900 je .LOP_SPUT_OBJECT_VOLATILE_resolve # if not, make it so 7901.LOP_SPUT_OBJECT_VOLATILE_finish: # field ptr in eax 7902 movzbl rINSTbl,%ecx # ecx<- AA 7903 GET_VREG_R %ecx %ecx 7904 movl %ecx,offStaticField_value(%eax) # do the store 7905 testl %ecx,%ecx # stored null object ptr? 7906 je 1f # skip card mark if null 7907 movl rSELF,%ecx 7908 movl offField_clazz(%eax),%eax # eax<- method->clazz 7909 movl offThread_cardTable(%ecx),%ecx # get card table base 7910 shrl $GC_CARD_SHIFT,%eax # head to card number 7911 movb %cl,(%ecx,%eax) # mark card 79121: 7913 FETCH_INST_OPCODE 2 %ecx 7914 ADVANCE_PC 2 7915 GOTO_NEXT_R %ecx 7916 7917.LOP_SPUT_OBJECT_VOLATILE_resolve: 7918 movl rSELF,%ecx 7919 movzwl 2(rPC),%eax # eax<- field ref BBBB 7920 movl offThread_method(%ecx),%ecx # ecx<- current method 7921 EXPORT_PC # could throw, need to export 7922 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 7923 movl %eax,OUT_ARG1(%esp) 7924 movl %ecx,OUT_ARG0(%esp) 7925 SPILL(rIBASE) 7926 call dvmResolveStaticField # eax<- resolved StaticField ptr 7927 UNSPILL(rIBASE) 7928 testl %eax,%eax 7929 jne .LOP_SPUT_OBJECT_VOLATILE_finish # success, continue 7930 jmp common_exceptionThrown # no, handle exception 7931 7932 7933/* ------------------------------ */ 7934.L_OP_DISPATCH_FF: /* 0xff */ 7935/* File: x86/OP_DISPATCH_FF.S */ 7936 leal 256(rINST),%ecx 7937 GOTO_NEXT_JUMBO_R %ecx 7938 7939/* ------------------------------ */ 7940.L_OP_CONST_CLASS_JUMBO: /* 0x100 */ 7941/* File: x86/OP_CONST_CLASS_JUMBO.S */ 7942 /* const-class/jumbo vBBBB, Class@AAAAAAAA */ 7943 movl rSELF,%ecx 7944 movl 2(rPC),%eax # eax<- AAAAAAAA 7945 movl offThread_methodClassDex(%ecx),%ecx# ecx<- self->methodClassDex 7946 movl offDvmDex_pResClasses(%ecx),%ecx # ecx<- dvmDex->pResClasses 7947 movl (%ecx,%eax,4),%eax # eax<- rResClasses[AAAAAAAA] 7948 FETCH_INST_OPCODE 4 %ecx 7949 testl %eax,%eax # resolved yet? 7950 je .LOP_CONST_CLASS_JUMBO_resolve 7951 SET_VREG %eax rINST # vBBBB<- rResClasses[AAAAAAAA] 7952 ADVANCE_PC 4 7953 GOTO_NEXT_R %ecx 7954 7955/* This is the less common path, so we'll redo some work 7956 here rather than force spills on the common path */ 7957.LOP_CONST_CLASS_JUMBO_resolve: 7958 movl rSELF,%eax 7959 EXPORT_PC 7960 movl offThread_method(%eax),%eax # eax<- self->method 7961 movl $1,OUT_ARG2(%esp) # true 7962 movl 2(rPC),%ecx # ecx<- AAAAAAAA 7963 movl offMethod_clazz(%eax),%eax 7964 movl %ecx,OUT_ARG1(%esp) 7965 movl %eax,OUT_ARG0(%esp) 7966 SPILL(rIBASE) 7967 call dvmResolveClass # go resolve 7968 UNSPILL(rIBASE) 7969 testl %eax,%eax # failed? 7970 je common_exceptionThrown 7971 FETCH_INST_OPCODE 4 %ecx 7972 SET_VREG %eax rINST 7973 ADVANCE_PC 4 7974 GOTO_NEXT_R %ecx 7975 7976/* ------------------------------ */ 7977.L_OP_CHECK_CAST_JUMBO: /* 0x101 */ 7978/* File: x86/OP_CHECK_CAST_JUMBO.S */ 7979 /* 7980 * Check to see if a cast from one class to another is allowed. 7981 */ 7982 /* check-cast/jumbo vBBBB, class@AAAAAAAA */ 7983 movl rSELF,%ecx 7984 GET_VREG_R rINST,rINST # rINST<- vBBBB (object) 7985 movl 2(rPC),%eax # eax<- AAAAAAAA 7986 movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex 7987 testl rINST,rINST # is oject null? 7988 movl offDvmDex_pResClasses(%ecx),%ecx # ecx<- pDvmDex->pResClasses 7989 je .LOP_CHECK_CAST_JUMBO_okay # null obj, cast always succeeds 7990 movl (%ecx,%eax,4),%eax # eax<- resolved class 7991 movl offObject_clazz(rINST),%ecx # ecx<- obj->clazz 7992 testl %eax,%eax # have we resolved this before? 7993 je .LOP_CHECK_CAST_JUMBO_resolve # no, go do it now 7994.LOP_CHECK_CAST_JUMBO_resolved: 7995 cmpl %eax,%ecx # same class (trivial success)? 7996 jne .LOP_CHECK_CAST_JUMBO_fullcheck # no, do full check 7997.LOP_CHECK_CAST_JUMBO_okay: 7998 FETCH_INST_OPCODE 4 %ecx 7999 ADVANCE_PC 4 8000 GOTO_NEXT_R %ecx 8001 8002 /* 8003 * Trivial test failed, need to perform full check. This is common. 8004 * ecx holds obj->clazz 8005 * eax holds class resolved from AAAAAAAA 8006 * rINST holds object 8007 */ 8008.LOP_CHECK_CAST_JUMBO_fullcheck: 8009 movl %eax,sReg0 # we'll need the desired class on failure 8010 movl %eax,OUT_ARG1(%esp) 8011 movl %ecx,OUT_ARG0(%esp) 8012 SPILL(rIBASE) 8013 call dvmInstanceofNonTrivial # eax<- boolean result 8014 UNSPILL(rIBASE) 8015 testl %eax,%eax # failed? 8016 jne .LOP_CHECK_CAST_JUMBO_okay # no, success 8017 8018 # A cast has failed. We need to throw a ClassCastException. 8019 EXPORT_PC 8020 movl offObject_clazz(rINST),%eax 8021 movl %eax,OUT_ARG0(%esp) # arg0<- obj->clazz 8022 movl sReg0,%ecx 8023 movl %ecx,OUT_ARG1(%esp) # arg1<- desired class 8024 call dvmThrowClassCastException 8025 jmp common_exceptionThrown 8026 8027 /* 8028 * Resolution required. This is the least-likely path, and we're 8029 * going to have to recreate some data. 8030 * 8031 * rINST holds object 8032 */ 8033.LOP_CHECK_CAST_JUMBO_resolve: 8034 movl rSELF,%ecx 8035 EXPORT_PC 8036 movl 2(rPC),%eax # eax<- AAAAAAAA 8037 movl offThread_method(%ecx),%ecx # ecx<- self->method 8038 movl %eax,OUT_ARG1(%esp) # arg1<- AAAAAAAA 8039 movl offMethod_clazz(%ecx),%ecx # ecx<- metho->clazz 8040 movl $0,OUT_ARG2(%esp) # arg2<- false 8041 movl %ecx,OUT_ARG0(%esp) # arg0<- method->clazz 8042 SPILL(rIBASE) 8043 call dvmResolveClass # eax<- resolved ClassObject ptr 8044 UNSPILL(rIBASE) 8045 testl %eax,%eax # got null? 8046 je common_exceptionThrown # yes, handle exception 8047 movl offObject_clazz(rINST),%ecx # ecx<- obj->clazz 8048 jmp .LOP_CHECK_CAST_JUMBO_resolved # pick up where we left off 8049 8050/* ------------------------------ */ 8051.L_OP_INSTANCE_OF_JUMBO: /* 0x102 */ 8052/* File: x86/OP_INSTANCE_OF_JUMBO.S */ 8053 /* 8054 * Check to see if an object reference is an instance of a class. 8055 * 8056 * Most common situation is a non-null object, being compared against 8057 * an already-resolved class. 8058 */ 8059 /* instance-of/jumbo vBBBB, vCCCC, class@AAAAAAAA */ 8060 movzwl 8(rPC),%eax # eax<- CCCC 8061 GET_VREG_R %eax %eax # eax<- vCCCC (obj) 8062 movl rSELF,%ecx 8063 testl %eax,%eax # object null? 8064 movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex 8065 SPILL(rIBASE) # preserve rIBASE 8066 je .LOP_INSTANCE_OF_JUMBO_store # null obj, not instance, store it 8067 movl 2(rPC),rIBASE # edx<- AAAAAAAA 8068 movl offDvmDex_pResClasses(%ecx),%ecx # ecx<- pDvmDex->pResClasses 8069 movl (%ecx,rIBASE,4),%ecx # ecx<- resolved class 8070 movl offObject_clazz(%eax),%eax # eax<- obj->clazz 8071 testl %ecx,%ecx # have we resolved this before? 8072 je .LOP_INSTANCE_OF_JUMBO_resolve # not resolved, do it now 8073.LOP_INSTANCE_OF_JUMBO_resolved: # eax<- obj->clazz, ecx<- resolved class 8074 cmpl %eax,%ecx # same class (trivial success)? 8075 je .LOP_INSTANCE_OF_JUMBO_trivial # yes, trivial finish 8076 /* 8077 * Trivial test failed, need to perform full check. This is common. 8078 * eax holds obj->clazz 8079 * ecx holds class resolved from BBBB 8080 * rINST has BA 8081 */ 8082 movl %eax,OUT_ARG0(%esp) 8083 movl %ecx,OUT_ARG1(%esp) 8084 call dvmInstanceofNonTrivial # eax<- boolean result 8085 # fall through to OP_INSTANCE_OF_JUMBO_store 8086 8087 /* 8088 * eax holds boolean result 8089 * rINST holds BBBB 8090 */ 8091.LOP_INSTANCE_OF_JUMBO_store: 8092 FETCH_INST_OPCODE 5 %ecx 8093 UNSPILL(rIBASE) 8094 ADVANCE_PC 5 8095 SET_VREG %eax rINST # vBBBB<- eax 8096 GOTO_NEXT_R %ecx 8097 8098 /* 8099 * Trivial test succeeded, save and bail. 8100 * r9 holds BBBB 8101 */ 8102.LOP_INSTANCE_OF_JUMBO_trivial: 8103 FETCH_INST_OPCODE 5 %ecx 8104 UNSPILL(rIBASE) 8105 ADVANCE_PC 5 8106 movl $1,%eax 8107 SET_VREG %eax rINST # vBBBB<- true 8108 GOTO_NEXT_R %ecx 8109 8110 /* 8111 * Resolution required. This is the least-likely path. 8112 * 8113 * edx holds AAAAAAAA 8114 */ 8115.LOP_INSTANCE_OF_JUMBO_resolve: 8116 movl rIBASE,OUT_ARG1(%esp) # arg1<- AAAAAAAA 8117 movl rSELF,%ecx 8118 movl offThread_method(%ecx),%ecx 8119 movl $1,OUT_ARG2(%esp) # arg2<- true 8120 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 8121 EXPORT_PC 8122 movl %ecx,OUT_ARG0(%esp) # arg0<- method->clazz 8123 call dvmResolveClass # eax<- resolved ClassObject ptr 8124 testl %eax,%eax # success? 8125 je common_exceptionThrown # no, handle exception 8126/* Now, we need to sync up with fast path. We need eax to 8127 * hold the obj->clazz, and ecx to hold the resolved class 8128 */ 8129 movl %eax,%ecx # ecx<- resolved class 8130 movzwl 8(rPC),%eax # eax<- CCCC 8131 GET_VREG_R %eax %eax # eax<- vCCCC (obj) 8132 movl offObject_clazz(%eax),%eax # eax<- obj->clazz 8133 jmp .LOP_INSTANCE_OF_JUMBO_resolved 8134 8135/* ------------------------------ */ 8136.L_OP_NEW_INSTANCE_JUMBO: /* 0x103 */ 8137/* File: x86/OP_NEW_INSTANCE_JUMBO.S */ 8138 /* 8139 * Create a new instance of a class. 8140 */ 8141 /* new-instance/jumbo vBBBB, class@AAAAAAAA */ 8142 movl rSELF,%ecx 8143 movl 2(rPC),%eax # eax<- AAAAAAAA 8144 movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex 8145 movl offDvmDex_pResClasses(%ecx),%ecx # ecx<- pDvmDex->pResClasses 8146 EXPORT_PC 8147 movl (%ecx,%eax,4),%ecx # ecx<- resolved class 8148 SPILL(rIBASE) 8149 testl %ecx,%ecx # resolved? 8150 je .LOP_NEW_INSTANCE_JUMBO_resolve # no, go do it 8151.LOP_NEW_INSTANCE_JUMBO_resolved: # on entry, ecx<- class 8152 cmpb $CLASS_INITIALIZED,offClassObject_status(%ecx) 8153 jne .LOP_NEW_INSTANCE_JUMBO_needinit 8154.LOP_NEW_INSTANCE_JUMBO_initialized: # on entry, ecx<- class 8155 movl $ALLOC_DONT_TRACK,OUT_ARG1(%esp) 8156 movl %ecx,OUT_ARG0(%esp) 8157 call dvmAllocObject # eax<- new object 8158 UNSPILL(rIBASE) 8159 FETCH_INST_OPCODE 4 %ecx 8160 testl %eax,%eax # success? 8161 je common_exceptionThrown # no, bail out 8162 SET_VREG %eax rINST 8163 ADVANCE_PC 4 8164 GOTO_NEXT_R %ecx 8165 8166 /* 8167 * Class initialization required. 8168 * 8169 * ecx holds class object 8170 */ 8171.LOP_NEW_INSTANCE_JUMBO_needinit: 8172 SPILL_TMP1(%ecx) # save object 8173 movl %ecx,OUT_ARG0(%esp) 8174 call dvmInitClass # initialize class 8175 UNSPILL_TMP1(%ecx) # restore object 8176 testl %eax,%eax # success? 8177 jne .LOP_NEW_INSTANCE_JUMBO_initialized # success, continue 8178 jmp common_exceptionThrown # go deal with init exception 8179 8180 /* 8181 * Resolution required. This is the least-likely path. 8182 * 8183 */ 8184.LOP_NEW_INSTANCE_JUMBO_resolve: 8185 movl rSELF,%ecx 8186 movl 2(rPC),%eax # eax<- AAAAAAAA 8187 movl offThread_method(%ecx),%ecx # ecx<- self->method 8188 movl %eax,OUT_ARG1(%esp) 8189 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 8190 movl $0,OUT_ARG2(%esp) 8191 movl %ecx,OUT_ARG0(%esp) 8192 call dvmResolveClass # call(clazz,off,flags) 8193 movl %eax,%ecx # ecx<- resolved ClassObject ptr 8194 testl %ecx,%ecx # success? 8195 jne .LOP_NEW_INSTANCE_JUMBO_resolved # good to go 8196 jmp common_exceptionThrown # no, handle exception 8197 8198/* ------------------------------ */ 8199.L_OP_NEW_ARRAY_JUMBO: /* 0x104 */ 8200/* File: x86/OP_NEW_ARRAY_JUMBO.S */ 8201 /* 8202 * Allocate an array of objects, specified with the array class 8203 * and a count. 8204 * 8205 * The verifier guarantees that this is an array class, so we don't 8206 * check for it here. 8207 */ 8208 /* new-array/jumbo vBBBB, vCCCC, class@AAAAAAAA */ 8209 movl rSELF,%ecx 8210 EXPORT_PC 8211 movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex 8212 movl 2(rPC),%eax # eax<- AAAAAAAA 8213 movl offDvmDex_pResClasses(%ecx),%ecx # ecx<- pDvmDex->pResClasses 8214 SPILL(rIBASE) 8215 movl (%ecx,%eax,4),%ecx # ecx<- resolved class 8216 movzwl 8(rPC),%eax # eax<- CCCC 8217 GET_VREG_R %eax %eax # eax<- vCCCC (array length) 8218 testl %eax,%eax 8219 js common_errNegativeArraySize # bail, passing len in eax 8220 testl %ecx,%ecx # already resolved? 8221 jne .LOP_NEW_ARRAY_JUMBO_finish # yes, fast path 8222 /* 8223 * Resolve class. (This is an uncommon case.) 8224 * ecx holds class (null here) 8225 * eax holds array length (vCCCC) 8226 */ 8227 movl rSELF,%ecx 8228 SPILL_TMP1(%eax) # save array length 8229 movl offThread_method(%ecx),%ecx # ecx<- self->method 8230 movl 2(rPC),%eax # eax<- AAAAAAAA 8231 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 8232 movl %eax,OUT_ARG1(%esp) 8233 movl $0,OUT_ARG2(%esp) 8234 movl %ecx,OUT_ARG0(%esp) 8235 call dvmResolveClass # eax<- call(clazz,ref,flag) 8236 movl %eax,%ecx 8237 UNSPILL_TMP1(%eax) 8238 testl %ecx,%ecx # successful resolution? 8239 je common_exceptionThrown # no, bail. 8240# fall through to OP_NEW_ARRAY_JUMBO_finish 8241 8242 /* 8243 * Finish allocation 8244 * 8245 * ecx holds class 8246 * eax holds array length (vCCCC) 8247 */ 8248.LOP_NEW_ARRAY_JUMBO_finish: 8249 movl %ecx,OUT_ARG0(%esp) 8250 movl %eax,OUT_ARG1(%esp) 8251 movl $ALLOC_DONT_TRACK,OUT_ARG2(%esp) 8252 call dvmAllocArrayByClass # eax<- call(clazz,length,flags) 8253 UNSPILL(rIBASE) 8254 FETCH_INST_OPCODE 5 %ecx 8255 testl %eax,%eax # failed? 8256 je common_exceptionThrown # yup - go handle 8257 SET_VREG %eax rINST 8258 ADVANCE_PC 5 8259 GOTO_NEXT_R %ecx 8260 8261/* ------------------------------ */ 8262.L_OP_FILLED_NEW_ARRAY_JUMBO: /* 0x105 */ 8263/* File: x86/OP_FILLED_NEW_ARRAY_JUMBO.S */ 8264 /* 8265 * Create a new array with elements filled from registers. 8266 */ 8267 /* filled-new-array/jumbo {vCCCC..v(CCCC+BBBB-1)}, type@AAAAAAAA */ 8268 movl rSELF,%eax 8269 movl offThread_methodClassDex(%eax),%eax # eax<- pDvmDex 8270 movl 2(rPC),%ecx # ecx<- AAAAAAAA 8271 movl offDvmDex_pResClasses(%eax),%eax # eax<- pDvmDex->pResClasses 8272 movl (%eax,%ecx,4),%eax # eax<- resolved class 8273 EXPORT_PC 8274 testl %eax,%eax # already resolved? 8275 jne .LOP_FILLED_NEW_ARRAY_JUMBO_continue # yes, continue 8276 # less frequent path, so we'll redo some work 8277 movl rSELF,%eax 8278 movl $0,OUT_ARG2(%esp) # arg2<- false 8279 movl %ecx,OUT_ARG1(%esp) # arg1<- AAAAAAAA 8280 movl offThread_method(%eax),%eax # eax<- self->method 8281 movl offMethod_clazz(%eax),%eax # eax<- method->clazz 8282 movl %eax,OUT_ARG0(%esp) # arg0<- clazz 8283 SPILL(rIBASE) 8284 call dvmResolveClass # eax<- call(clazz,ref,flag) 8285 UNSPILL(rIBASE) 8286 testl %eax,%eax # null? 8287 je common_exceptionThrown # yes, handle it 8288 8289 # note: fall through to .LOP_FILLED_NEW_ARRAY_JUMBO_continue 8290 8291 /* 8292 * On entry: 8293 * eax holds array class [r0] 8294 * ecx is scratch 8295 */ 8296.LOP_FILLED_NEW_ARRAY_JUMBO_continue: 8297 movl offClassObject_descriptor(%eax),%ecx # ecx<- arrayClass->descriptor 8298 movl $ALLOC_DONT_TRACK,OUT_ARG2(%esp) # arg2<- flags 8299 movzbl 1(%ecx),%ecx # ecx<- descriptor[1] 8300 movl %eax,OUT_ARG0(%esp) # arg0<- arrayClass 8301 movl rSELF,%eax 8302 cmpb $'I',%cl # supported? 8303 je 1f 8304 cmpb $'L',%cl 8305 je 1f 8306 cmpb $'[',%cl 8307 jne .LOP_FILLED_NEW_ARRAY_JUMBO_notimpl # no, not handled yet 83081: 8309 movl %ecx,offThread_retval+4(%eax) # save type 8310 movl rINST,OUT_ARG1(%esp) # arg1<- BBBB (length) 8311 SPILL(rIBASE) 8312 call dvmAllocArrayByClass # eax<- call(arrayClass, length, flags) 8313 UNSPILL(rIBASE) 8314 movl rSELF,%ecx 8315 testl %eax,%eax # alloc successful? 8316 je common_exceptionThrown # no, handle exception 8317 movl %eax,offThread_retval(%ecx) # retval.l<- new array 8318 movzwl 8(rPC),%ecx # ecx<- CCCC 8319 leal offArrayObject_contents(%eax),%eax # eax<- newArray->contents 8320 8321/* at this point: 8322 * eax is pointer to tgt 8323 * rINST is length 8324 * ecx is CCCC 8325 * We now need to copy values from registers into the array 8326 */ 8327 8328 # set up src pointer 8329 SPILL_TMP2(%esi) 8330 SPILL_TMP3(%edi) 8331 leal (rFP,%ecx,4),%esi # set up src ptr 8332 movl %eax,%edi # set up dst ptr 8333 movl rINST,%ecx # load count register 8334 rep 8335 movsd 8336 UNSPILL_TMP2(%esi) 8337 UNSPILL_TMP3(%edi) 8338 movl rSELF,%ecx 8339 movl offThread_retval+4(%ecx),%eax # eax<- type 8340 8341 cmpb $'I',%al # Int array? 8342 je 5f # skip card mark if so 8343 movl offThread_retval(%ecx),%eax # eax<- object head 8344 movl offThread_cardTable(%ecx),%ecx # card table base 8345 shrl $GC_CARD_SHIFT,%eax # convert to card num 8346 movb %cl,(%ecx,%eax) # mark card based on object head 83475: 8348 FETCH_INST_OPCODE 5 %ecx 8349 ADVANCE_PC 5 8350 GOTO_NEXT_R %ecx 8351 8352 8353 /* 8354 * Throw an exception indicating that we have not implemented this 8355 * mode of filled-new-array. 8356 */ 8357.LOP_FILLED_NEW_ARRAY_JUMBO_notimpl: 8358 movl $.LstrFilledNewArrayNotImplA,%eax 8359 movl %eax,OUT_ARG0(%esp) 8360 call dvmThrowInternalError 8361 jmp common_exceptionThrown 8362 8363/* ------------------------------ */ 8364.L_OP_IGET_JUMBO: /* 0x106 */ 8365/* File: x86/OP_IGET_JUMBO.S */ 8366 /* 8367 * Jumbo 32-bit instance field get. 8368 * 8369 * for: iget/jumbo, iget-object/jumbo, iget-boolean/jumbo, iget-byte/jumbo, 8370 * iget-char/jumbo, iget-short/jumbo 8371 */ 8372 /* exop vBBBB, vCCCC, field@AAAAAAAA */ 8373 movl rSELF,%ecx 8374 SPILL(rIBASE) # preserve rIBASE 8375 movl 2(rPC),rIBASE # rIBASE<- AAAAAAAA 8376 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex 8377 movzwl 8(rPC),%ecx # ecx<- CCCC 8378 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields 8379 GET_VREG_R %ecx %ecx # ecx<- fp[CCCC], the object ptr 8380 movl (%eax,rIBASE,4),%eax # resolved entry 8381 testl %eax,%eax # is resolved entry null? 8382 jne .LOP_IGET_JUMBO_finish # no, already resolved 8383 movl rIBASE,OUT_ARG1(%esp) # needed by dvmResolveInstField 8384 movl rSELF,rIBASE 8385 EXPORT_PC 8386 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method 8387 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz 8388 SPILL_TMP1(%ecx) # save obj pointer across call 8389 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz 8390 call dvmResolveInstField # ... to dvmResolveInstField 8391 UNSPILL_TMP1(%ecx) 8392 testl %eax,%eax # returns InstrField ptr 8393 jne .LOP_IGET_JUMBO_finish 8394 jmp common_exceptionThrown 8395 8396.LOP_IGET_JUMBO_finish: 8397 /* 8398 * Currently: 8399 * eax holds resolved field 8400 * ecx holds object 8401 * rINST holds BBBB 8402 */ 8403 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field 8404 testl %ecx,%ecx # object null? 8405 je common_errNullObject # object was null 8406 movl (%ecx,%eax,1),%ecx # ecx<- obj.field (8/16/32 bits) 8407 FETCH_INST_OPCODE 5 %eax 8408 UNSPILL(rIBASE) # restore rIBASE 8409 SET_VREG %ecx rINST 8410 ADVANCE_PC 5 8411 GOTO_NEXT_R %eax 8412 8413/* ------------------------------ */ 8414.L_OP_IGET_WIDE_JUMBO: /* 0x107 */ 8415/* File: x86/OP_IGET_WIDE_JUMBO.S */ 8416 /* 8417 * Jumbo 64-bit instance field get. 8418 */ 8419 /* iget-wide/jumbo vBBBB, vCCCC, field@AAAA */ 8420 movl rSELF,%ecx 8421 SPILL(rIBASE) # preserve rIBASE 8422 movl 2(rPC),rIBASE # rIBASE<- AAAAAAAA 8423 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex 8424 movzwl 8(rPC),%ecx # ecx<- CCCC 8425 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields 8426 GET_VREG_R %ecx %ecx # ecx<- fp[CCCC], the object ptr 8427 movl (%eax,rIBASE,4),%eax # resolved entry 8428 testl %eax,%eax # is resolved entry null? 8429 jne .LOP_IGET_WIDE_JUMBO_finish # no, already resolved 8430 movl rIBASE,OUT_ARG1(%esp) # for dvmResolveInstField 8431 movl rSELF,rIBASE 8432 EXPORT_PC 8433 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method 8434 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz 8435 SPILL_TMP1(%ecx) # save objpointer across call 8436 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz 8437 call dvmResolveInstField # ... to dvmResolveInstField 8438 UNSPILL_TMP1(%ecx) 8439 testl %eax,%eax # returns InstrField ptr 8440 jne .LOP_IGET_WIDE_JUMBO_finish 8441 jmp common_exceptionThrown 8442 8443.LOP_IGET_WIDE_JUMBO_finish: 8444 /* 8445 * Currently: 8446 * eax holds resolved field 8447 * ecx holds object 8448 * rINST holds BBBB 8449 */ 8450 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field 8451 testl %ecx,%ecx # object null? 8452 je common_errNullObject # object was null 8453 leal (%ecx,%eax,1),%eax # eax<- address of field 8454 movl (%eax),%ecx # ecx<- lsw 8455 movl 4(%eax),%eax # eax<- msw 8456 SET_VREG_WORD %ecx rINST 0 8457 FETCH_INST_OPCODE 5 %ecx 8458 UNSPILL(rIBASE) # restore rIBASE 8459 SET_VREG_WORD %eax rINST 1 8460 ADVANCE_PC 5 8461 GOTO_NEXT_R %ecx 8462 8463/* ------------------------------ */ 8464.L_OP_IGET_OBJECT_JUMBO: /* 0x108 */ 8465/* File: x86/OP_IGET_OBJECT_JUMBO.S */ 8466/* File: x86/OP_IGET_JUMBO.S */ 8467 /* 8468 * Jumbo 32-bit instance field get. 8469 * 8470 * for: iget/jumbo, iget-object/jumbo, iget-boolean/jumbo, iget-byte/jumbo, 8471 * iget-char/jumbo, iget-short/jumbo 8472 */ 8473 /* exop vBBBB, vCCCC, field@AAAAAAAA */ 8474 movl rSELF,%ecx 8475 SPILL(rIBASE) # preserve rIBASE 8476 movl 2(rPC),rIBASE # rIBASE<- AAAAAAAA 8477 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex 8478 movzwl 8(rPC),%ecx # ecx<- CCCC 8479 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields 8480 GET_VREG_R %ecx %ecx # ecx<- fp[CCCC], the object ptr 8481 movl (%eax,rIBASE,4),%eax # resolved entry 8482 testl %eax,%eax # is resolved entry null? 8483 jne .LOP_IGET_OBJECT_JUMBO_finish # no, already resolved 8484 movl rIBASE,OUT_ARG1(%esp) # needed by dvmResolveInstField 8485 movl rSELF,rIBASE 8486 EXPORT_PC 8487 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method 8488 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz 8489 SPILL_TMP1(%ecx) # save obj pointer across call 8490 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz 8491 call dvmResolveInstField # ... to dvmResolveInstField 8492 UNSPILL_TMP1(%ecx) 8493 testl %eax,%eax # returns InstrField ptr 8494 jne .LOP_IGET_OBJECT_JUMBO_finish 8495 jmp common_exceptionThrown 8496 8497.LOP_IGET_OBJECT_JUMBO_finish: 8498 /* 8499 * Currently: 8500 * eax holds resolved field 8501 * ecx holds object 8502 * rINST holds BBBB 8503 */ 8504 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field 8505 testl %ecx,%ecx # object null? 8506 je common_errNullObject # object was null 8507 movl (%ecx,%eax,1),%ecx # ecx<- obj.field (8/16/32 bits) 8508 FETCH_INST_OPCODE 5 %eax 8509 UNSPILL(rIBASE) # restore rIBASE 8510 SET_VREG %ecx rINST 8511 ADVANCE_PC 5 8512 GOTO_NEXT_R %eax 8513 8514 8515/* ------------------------------ */ 8516.L_OP_IGET_BOOLEAN_JUMBO: /* 0x109 */ 8517/* File: x86/OP_IGET_BOOLEAN_JUMBO.S */ 8518/* File: x86/OP_IGET_JUMBO.S */ 8519 /* 8520 * Jumbo 32-bit instance field get. 8521 * 8522 * for: iget/jumbo, iget-object/jumbo, iget-boolean/jumbo, iget-byte/jumbo, 8523 * iget-char/jumbo, iget-short/jumbo 8524 */ 8525 /* exop vBBBB, vCCCC, field@AAAAAAAA */ 8526 movl rSELF,%ecx 8527 SPILL(rIBASE) # preserve rIBASE 8528 movl 2(rPC),rIBASE # rIBASE<- AAAAAAAA 8529 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex 8530 movzwl 8(rPC),%ecx # ecx<- CCCC 8531 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields 8532 GET_VREG_R %ecx %ecx # ecx<- fp[CCCC], the object ptr 8533 movl (%eax,rIBASE,4),%eax # resolved entry 8534 testl %eax,%eax # is resolved entry null? 8535 jne .LOP_IGET_BOOLEAN_JUMBO_finish # no, already resolved 8536 movl rIBASE,OUT_ARG1(%esp) # needed by dvmResolveInstField 8537 movl rSELF,rIBASE 8538 EXPORT_PC 8539 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method 8540 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz 8541 SPILL_TMP1(%ecx) # save obj pointer across call 8542 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz 8543 call dvmResolveInstField # ... to dvmResolveInstField 8544 UNSPILL_TMP1(%ecx) 8545 testl %eax,%eax # returns InstrField ptr 8546 jne .LOP_IGET_BOOLEAN_JUMBO_finish 8547 jmp common_exceptionThrown 8548 8549.LOP_IGET_BOOLEAN_JUMBO_finish: 8550 /* 8551 * Currently: 8552 * eax holds resolved field 8553 * ecx holds object 8554 * rINST holds BBBB 8555 */ 8556 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field 8557 testl %ecx,%ecx # object null? 8558 je common_errNullObject # object was null 8559 movzbl (%ecx,%eax,1),%ecx # ecx<- obj.field (8/16/32 bits) 8560 FETCH_INST_OPCODE 5 %eax 8561 UNSPILL(rIBASE) # restore rIBASE 8562 SET_VREG %ecx rINST 8563 ADVANCE_PC 5 8564 GOTO_NEXT_R %eax 8565 8566 8567/* ------------------------------ */ 8568.L_OP_IGET_BYTE_JUMBO: /* 0x10a */ 8569/* File: x86/OP_IGET_BYTE_JUMBO.S */ 8570/* File: x86/OP_IGET_JUMBO.S */ 8571 /* 8572 * Jumbo 32-bit instance field get. 8573 * 8574 * for: iget/jumbo, iget-object/jumbo, iget-boolean/jumbo, iget-byte/jumbo, 8575 * iget-char/jumbo, iget-short/jumbo 8576 */ 8577 /* exop vBBBB, vCCCC, field@AAAAAAAA */ 8578 movl rSELF,%ecx 8579 SPILL(rIBASE) # preserve rIBASE 8580 movl 2(rPC),rIBASE # rIBASE<- AAAAAAAA 8581 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex 8582 movzwl 8(rPC),%ecx # ecx<- CCCC 8583 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields 8584 GET_VREG_R %ecx %ecx # ecx<- fp[CCCC], the object ptr 8585 movl (%eax,rIBASE,4),%eax # resolved entry 8586 testl %eax,%eax # is resolved entry null? 8587 jne .LOP_IGET_BYTE_JUMBO_finish # no, already resolved 8588 movl rIBASE,OUT_ARG1(%esp) # needed by dvmResolveInstField 8589 movl rSELF,rIBASE 8590 EXPORT_PC 8591 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method 8592 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz 8593 SPILL_TMP1(%ecx) # save obj pointer across call 8594 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz 8595 call dvmResolveInstField # ... to dvmResolveInstField 8596 UNSPILL_TMP1(%ecx) 8597 testl %eax,%eax # returns InstrField ptr 8598 jne .LOP_IGET_BYTE_JUMBO_finish 8599 jmp common_exceptionThrown 8600 8601.LOP_IGET_BYTE_JUMBO_finish: 8602 /* 8603 * Currently: 8604 * eax holds resolved field 8605 * ecx holds object 8606 * rINST holds BBBB 8607 */ 8608 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field 8609 testl %ecx,%ecx # object null? 8610 je common_errNullObject # object was null 8611 movsbl (%ecx,%eax,1),%ecx # ecx<- obj.field (8/16/32 bits) 8612 FETCH_INST_OPCODE 5 %eax 8613 UNSPILL(rIBASE) # restore rIBASE 8614 SET_VREG %ecx rINST 8615 ADVANCE_PC 5 8616 GOTO_NEXT_R %eax 8617 8618 8619/* ------------------------------ */ 8620.L_OP_IGET_CHAR_JUMBO: /* 0x10b */ 8621/* File: x86/OP_IGET_CHAR_JUMBO.S */ 8622/* File: x86/OP_IGET_JUMBO.S */ 8623 /* 8624 * Jumbo 32-bit instance field get. 8625 * 8626 * for: iget/jumbo, iget-object/jumbo, iget-boolean/jumbo, iget-byte/jumbo, 8627 * iget-char/jumbo, iget-short/jumbo 8628 */ 8629 /* exop vBBBB, vCCCC, field@AAAAAAAA */ 8630 movl rSELF,%ecx 8631 SPILL(rIBASE) # preserve rIBASE 8632 movl 2(rPC),rIBASE # rIBASE<- AAAAAAAA 8633 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex 8634 movzwl 8(rPC),%ecx # ecx<- CCCC 8635 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields 8636 GET_VREG_R %ecx %ecx # ecx<- fp[CCCC], the object ptr 8637 movl (%eax,rIBASE,4),%eax # resolved entry 8638 testl %eax,%eax # is resolved entry null? 8639 jne .LOP_IGET_CHAR_JUMBO_finish # no, already resolved 8640 movl rIBASE,OUT_ARG1(%esp) # needed by dvmResolveInstField 8641 movl rSELF,rIBASE 8642 EXPORT_PC 8643 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method 8644 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz 8645 SPILL_TMP1(%ecx) # save obj pointer across call 8646 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz 8647 call dvmResolveInstField # ... to dvmResolveInstField 8648 UNSPILL_TMP1(%ecx) 8649 testl %eax,%eax # returns InstrField ptr 8650 jne .LOP_IGET_CHAR_JUMBO_finish 8651 jmp common_exceptionThrown 8652 8653.LOP_IGET_CHAR_JUMBO_finish: 8654 /* 8655 * Currently: 8656 * eax holds resolved field 8657 * ecx holds object 8658 * rINST holds BBBB 8659 */ 8660 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field 8661 testl %ecx,%ecx # object null? 8662 je common_errNullObject # object was null 8663 movzwl (%ecx,%eax,1),%ecx # ecx<- obj.field (8/16/32 bits) 8664 FETCH_INST_OPCODE 5 %eax 8665 UNSPILL(rIBASE) # restore rIBASE 8666 SET_VREG %ecx rINST 8667 ADVANCE_PC 5 8668 GOTO_NEXT_R %eax 8669 8670 8671/* ------------------------------ */ 8672.L_OP_IGET_SHORT_JUMBO: /* 0x10c */ 8673/* File: x86/OP_IGET_SHORT_JUMBO.S */ 8674/* File: x86/OP_IGET_JUMBO.S */ 8675 /* 8676 * Jumbo 32-bit instance field get. 8677 * 8678 * for: iget/jumbo, iget-object/jumbo, iget-boolean/jumbo, iget-byte/jumbo, 8679 * iget-char/jumbo, iget-short/jumbo 8680 */ 8681 /* exop vBBBB, vCCCC, field@AAAAAAAA */ 8682 movl rSELF,%ecx 8683 SPILL(rIBASE) # preserve rIBASE 8684 movl 2(rPC),rIBASE # rIBASE<- AAAAAAAA 8685 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex 8686 movzwl 8(rPC),%ecx # ecx<- CCCC 8687 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields 8688 GET_VREG_R %ecx %ecx # ecx<- fp[CCCC], the object ptr 8689 movl (%eax,rIBASE,4),%eax # resolved entry 8690 testl %eax,%eax # is resolved entry null? 8691 jne .LOP_IGET_SHORT_JUMBO_finish # no, already resolved 8692 movl rIBASE,OUT_ARG1(%esp) # needed by dvmResolveInstField 8693 movl rSELF,rIBASE 8694 EXPORT_PC 8695 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method 8696 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz 8697 SPILL_TMP1(%ecx) # save obj pointer across call 8698 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz 8699 call dvmResolveInstField # ... to dvmResolveInstField 8700 UNSPILL_TMP1(%ecx) 8701 testl %eax,%eax # returns InstrField ptr 8702 jne .LOP_IGET_SHORT_JUMBO_finish 8703 jmp common_exceptionThrown 8704 8705.LOP_IGET_SHORT_JUMBO_finish: 8706 /* 8707 * Currently: 8708 * eax holds resolved field 8709 * ecx holds object 8710 * rINST holds BBBB 8711 */ 8712 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field 8713 testl %ecx,%ecx # object null? 8714 je common_errNullObject # object was null 8715 movswl (%ecx,%eax,1),%ecx # ecx<- obj.field (8/16/32 bits) 8716 FETCH_INST_OPCODE 5 %eax 8717 UNSPILL(rIBASE) # restore rIBASE 8718 SET_VREG %ecx rINST 8719 ADVANCE_PC 5 8720 GOTO_NEXT_R %eax 8721 8722 8723/* ------------------------------ */ 8724.L_OP_IPUT_JUMBO: /* 0x10d */ 8725/* File: x86/OP_IPUT_JUMBO.S */ 8726 /* 8727 * Jumbo 32-bit instance field put. 8728 * 8729 * for: iput/jumbo, iput-object/jumbo, iput-boolean/jumbo, iput-byte/jumbo, 8730 iput-char/jumbo, iput-short/jumbo 8731 */ 8732 /* exop vBBBB, vCCCC, field@AAAAAAAA */ 8733 movl rSELF,%ecx 8734 SPILL(rIBASE) 8735 movl 2(rPC),rIBASE # rIBASE<- AAAAAAAA 8736 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex 8737 movzwl 8(rPC),%ecx # ecx<- CCCC 8738 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields 8739 GET_VREG_R %ecx %ecx # ecx<- fp[CCCC], the object ptr 8740 movl (%eax,rIBASE,4),%eax # resolved entry 8741 testl %eax,%eax # is resolved entry null? 8742 jne .LOP_IPUT_JUMBO_finish # no, already resolved 8743 movl rIBASE,OUT_ARG1(%esp) 8744 movl rSELF,rIBASE 8745 EXPORT_PC 8746 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method 8747 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz 8748 SPILL_TMP1(%ecx) # save obj pointer across call 8749 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz 8750 call dvmResolveInstField # ... to dvmResolveInstField 8751 UNSPILL_TMP1(%ecx) 8752 testl %eax,%eax # returns InstrField ptr 8753 jne .LOP_IPUT_JUMBO_finish 8754 jmp common_exceptionThrown 8755 8756.LOP_IPUT_JUMBO_finish: 8757 /* 8758 * Currently: 8759 * eax holds resolved field 8760 * ecx holds object 8761 * rINST holds BBBB 8762 */ 8763 GET_VREG_R rINST rINST # rINST<- v[BBBB] 8764 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field 8765 testl %ecx,%ecx # object null? 8766 je common_errNullObject # object was null 8767 movl rINST,(%ecx,%eax,1) # obj.field <- v[BBBB](8/16/32 bits) 8768 FETCH_INST_OPCODE 5 %ecx 8769 UNSPILL(rIBASE) 8770 ADVANCE_PC 5 8771 GOTO_NEXT_R %ecx 8772 8773/* ------------------------------ */ 8774.L_OP_IPUT_WIDE_JUMBO: /* 0x10e */ 8775/* File: x86/OP_IPUT_WIDE_JUMBO.S */ 8776 /* 8777 * Jumbo 64-bit instance field put. 8778 */ 8779 /* iput-wide/jumbo vBBBB, vCCCC, field@AAAAAAAA */ 8780 movl rSELF,%ecx 8781 SPILL(rIBASE) 8782 movl 2(rPC),rIBASE # rIBASE<- AAAAAAAA 8783 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex 8784 movzwl 8(rPC),%ecx # ecx<- CCCC 8785 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields 8786 GET_VREG_R %ecx %ecx # ecx<- fp[CCCC], the object ptr 8787 movl (%eax,rIBASE,4),%eax # resolved entry 8788 testl %eax,%eax # is resolved entry null? 8789 jne .LOP_IPUT_WIDE_JUMBO_finish # no, already resolved 8790 movl rIBASE,OUT_ARG1(%esp) 8791 movl rSELF,rIBASE 8792 EXPORT_PC 8793 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method 8794 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz 8795 SPILL_TMP1(%ecx) # save obj pointer across call 8796 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz 8797 call dvmResolveInstField # ... to dvmResolveInstField 8798 UNSPILL_TMP1(%ecx) 8799 testl %eax,%eax # ... which returns InstrField ptr 8800 jne .LOP_IPUT_WIDE_JUMBO_finish 8801 jmp common_exceptionThrown 8802 8803.LOP_IPUT_WIDE_JUMBO_finish: 8804 /* 8805 * Currently: 8806 * eax holds resolved field 8807 * ecx holds object 8808 * rIBASE is scratch, but needs to be unspilled 8809 * rINST holds BBBB 8810 */ 8811 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field 8812 testl %ecx,%ecx # object null? 8813 je common_errNullObject # object was null 8814 leal (%ecx,%eax,1),%eax # eax<- address of field 8815 GET_VREG_WORD %ecx rINST 0 # ecx<- lsw 8816 GET_VREG_WORD rINST rINST 1 # rINST<- msw 8817 movl rINST,4(%eax) 8818 movl %ecx,(%eax) 8819 FETCH_INST_OPCODE 5 %ecx 8820 UNSPILL(rIBASE) 8821 ADVANCE_PC 5 8822 GOTO_NEXT_R %ecx 8823 8824/* ------------------------------ */ 8825.L_OP_IPUT_OBJECT_JUMBO: /* 0x10f */ 8826/* File: x86/OP_IPUT_OBJECT_JUMBO.S */ 8827 /* 8828 * Jumbo object field put. 8829 */ 8830 /* iput-object/jumbo vBBBB, vCCCC, field@AAAAAAAA */ 8831 movl rSELF,%ecx 8832 SPILL(rIBASE) 8833 movl 2(rPC),rIBASE # rIBASE<- AAAAAAAA 8834 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex 8835 movzwl 8(rPC),%ecx # ecx<- CCCC 8836 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields 8837 GET_VREG_R %ecx %ecx # ecx<- fp[CCCC], the object ptr 8838 movl (%eax,rIBASE,4),%eax # resolved entry 8839 testl %eax,%eax # is resolved entry null? 8840 jne .LOP_IPUT_OBJECT_JUMBO_finish # no, already resolved 8841 movl rIBASE,OUT_ARG1(%esp) 8842 movl rSELF,rIBASE 8843 EXPORT_PC 8844 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method 8845 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz 8846 SPILL_TMP1(%ecx) # save obj pointer across call 8847 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz 8848 call dvmResolveInstField # ... to dvmResolveInstField 8849 UNSPILL_TMP1(%ecx) 8850 testl %eax,%eax # returns InstrField ptr 8851 jne .LOP_IPUT_OBJECT_JUMBO_finish 8852 jmp common_exceptionThrown 8853 8854.LOP_IPUT_OBJECT_JUMBO_finish: 8855 /* 8856 * Currently: 8857 * eax holds resolved field 8858 * ecx holds object 8859 * rIBASE is scratch, but needs to be unspilled 8860 * rINST holds BBBB 8861 */ 8862 GET_VREG_R rINST rINST # rINST<- v[BBBB] 8863 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field 8864 testl %ecx,%ecx # object null? 8865 je common_errNullObject # object was null 8866 movl rINST,(%ecx,%eax) # obj.field <- v[BBBB](8/16/32 bits) 8867 movl rSELF,%eax 8868 testl rINST,rINST # stored a NULL? 8869 movl offThread_cardTable(%eax),%eax # get card table base 8870 je 1f # skip card mark if null store 8871 shrl $GC_CARD_SHIFT,%ecx # object head to card number 8872 movb %al,(%eax,%ecx) # mark card using object head 88731: 8874 FETCH_INST_OPCODE 5 %ecx 8875 UNSPILL(rIBASE) 8876 ADVANCE_PC 5 8877 GOTO_NEXT_R %ecx 8878 8879/* ------------------------------ */ 8880.L_OP_IPUT_BOOLEAN_JUMBO: /* 0x110 */ 8881/* File: x86/OP_IPUT_BOOLEAN_JUMBO.S */ 8882/* File: x86/OP_IPUT_JUMBO.S */ 8883 /* 8884 * Jumbo 32-bit instance field put. 8885 * 8886 * for: iput/jumbo, iput-object/jumbo, iput-boolean/jumbo, iput-byte/jumbo, 8887 iput-char/jumbo, iput-short/jumbo 8888 */ 8889 /* exop vBBBB, vCCCC, field@AAAAAAAA */ 8890 movl rSELF,%ecx 8891 SPILL(rIBASE) 8892 movl 2(rPC),rIBASE # rIBASE<- AAAAAAAA 8893 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex 8894 movzwl 8(rPC),%ecx # ecx<- CCCC 8895 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields 8896 GET_VREG_R %ecx %ecx # ecx<- fp[CCCC], the object ptr 8897 movl (%eax,rIBASE,4),%eax # resolved entry 8898 testl %eax,%eax # is resolved entry null? 8899 jne .LOP_IPUT_BOOLEAN_JUMBO_finish # no, already resolved 8900 movl rIBASE,OUT_ARG1(%esp) 8901 movl rSELF,rIBASE 8902 EXPORT_PC 8903 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method 8904 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz 8905 SPILL_TMP1(%ecx) # save obj pointer across call 8906 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz 8907 call dvmResolveInstField # ... to dvmResolveInstField 8908 UNSPILL_TMP1(%ecx) 8909 testl %eax,%eax # returns InstrField ptr 8910 jne .LOP_IPUT_BOOLEAN_JUMBO_finish 8911 jmp common_exceptionThrown 8912 8913.LOP_IPUT_BOOLEAN_JUMBO_finish: 8914 /* 8915 * Currently: 8916 * eax holds resolved field 8917 * ecx holds object 8918 * rINST holds BBBB 8919 */ 8920 GET_VREG_R rINST rINST # rINST<- v[BBBB] 8921 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field 8922 testl %ecx,%ecx # object null? 8923 je common_errNullObject # object was null 8924 movb rINSTbl,(%ecx,%eax,1) # obj.field <- v[BBBB](8/16/32 bits) 8925 FETCH_INST_OPCODE 5 %ecx 8926 UNSPILL(rIBASE) 8927 ADVANCE_PC 5 8928 GOTO_NEXT_R %ecx 8929 8930 8931/* ------------------------------ */ 8932.L_OP_IPUT_BYTE_JUMBO: /* 0x111 */ 8933/* File: x86/OP_IPUT_BYTE_JUMBO.S */ 8934/* File: x86/OP_IPUT_JUMBO.S */ 8935 /* 8936 * Jumbo 32-bit instance field put. 8937 * 8938 * for: iput/jumbo, iput-object/jumbo, iput-boolean/jumbo, iput-byte/jumbo, 8939 iput-char/jumbo, iput-short/jumbo 8940 */ 8941 /* exop vBBBB, vCCCC, field@AAAAAAAA */ 8942 movl rSELF,%ecx 8943 SPILL(rIBASE) 8944 movl 2(rPC),rIBASE # rIBASE<- AAAAAAAA 8945 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex 8946 movzwl 8(rPC),%ecx # ecx<- CCCC 8947 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields 8948 GET_VREG_R %ecx %ecx # ecx<- fp[CCCC], the object ptr 8949 movl (%eax,rIBASE,4),%eax # resolved entry 8950 testl %eax,%eax # is resolved entry null? 8951 jne .LOP_IPUT_BYTE_JUMBO_finish # no, already resolved 8952 movl rIBASE,OUT_ARG1(%esp) 8953 movl rSELF,rIBASE 8954 EXPORT_PC 8955 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method 8956 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz 8957 SPILL_TMP1(%ecx) # save obj pointer across call 8958 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz 8959 call dvmResolveInstField # ... to dvmResolveInstField 8960 UNSPILL_TMP1(%ecx) 8961 testl %eax,%eax # returns InstrField ptr 8962 jne .LOP_IPUT_BYTE_JUMBO_finish 8963 jmp common_exceptionThrown 8964 8965.LOP_IPUT_BYTE_JUMBO_finish: 8966 /* 8967 * Currently: 8968 * eax holds resolved field 8969 * ecx holds object 8970 * rINST holds BBBB 8971 */ 8972 GET_VREG_R rINST rINST # rINST<- v[BBBB] 8973 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field 8974 testl %ecx,%ecx # object null? 8975 je common_errNullObject # object was null 8976 movb rINSTbl,(%ecx,%eax,1) # obj.field <- v[BBBB](8/16/32 bits) 8977 FETCH_INST_OPCODE 5 %ecx 8978 UNSPILL(rIBASE) 8979 ADVANCE_PC 5 8980 GOTO_NEXT_R %ecx 8981 8982 8983/* ------------------------------ */ 8984.L_OP_IPUT_CHAR_JUMBO: /* 0x112 */ 8985/* File: x86/OP_IPUT_CHAR_JUMBO.S */ 8986/* File: x86/OP_IPUT_JUMBO.S */ 8987 /* 8988 * Jumbo 32-bit instance field put. 8989 * 8990 * for: iput/jumbo, iput-object/jumbo, iput-boolean/jumbo, iput-byte/jumbo, 8991 iput-char/jumbo, iput-short/jumbo 8992 */ 8993 /* exop vBBBB, vCCCC, field@AAAAAAAA */ 8994 movl rSELF,%ecx 8995 SPILL(rIBASE) 8996 movl 2(rPC),rIBASE # rIBASE<- AAAAAAAA 8997 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex 8998 movzwl 8(rPC),%ecx # ecx<- CCCC 8999 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields 9000 GET_VREG_R %ecx %ecx # ecx<- fp[CCCC], the object ptr 9001 movl (%eax,rIBASE,4),%eax # resolved entry 9002 testl %eax,%eax # is resolved entry null? 9003 jne .LOP_IPUT_CHAR_JUMBO_finish # no, already resolved 9004 movl rIBASE,OUT_ARG1(%esp) 9005 movl rSELF,rIBASE 9006 EXPORT_PC 9007 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method 9008 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz 9009 SPILL_TMP1(%ecx) # save obj pointer across call 9010 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz 9011 call dvmResolveInstField # ... to dvmResolveInstField 9012 UNSPILL_TMP1(%ecx) 9013 testl %eax,%eax # returns InstrField ptr 9014 jne .LOP_IPUT_CHAR_JUMBO_finish 9015 jmp common_exceptionThrown 9016 9017.LOP_IPUT_CHAR_JUMBO_finish: 9018 /* 9019 * Currently: 9020 * eax holds resolved field 9021 * ecx holds object 9022 * rINST holds BBBB 9023 */ 9024 GET_VREG_R rINST rINST # rINST<- v[BBBB] 9025 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field 9026 testl %ecx,%ecx # object null? 9027 je common_errNullObject # object was null 9028 movw rINSTw,(%ecx,%eax,1) # obj.field <- v[BBBB](8/16/32 bits) 9029 FETCH_INST_OPCODE 5 %ecx 9030 UNSPILL(rIBASE) 9031 ADVANCE_PC 5 9032 GOTO_NEXT_R %ecx 9033 9034 9035/* ------------------------------ */ 9036.L_OP_IPUT_SHORT_JUMBO: /* 0x113 */ 9037/* File: x86/OP_IPUT_SHORT_JUMBO.S */ 9038/* File: x86/OP_IPUT_JUMBO.S */ 9039 /* 9040 * Jumbo 32-bit instance field put. 9041 * 9042 * for: iput/jumbo, iput-object/jumbo, iput-boolean/jumbo, iput-byte/jumbo, 9043 iput-char/jumbo, iput-short/jumbo 9044 */ 9045 /* exop vBBBB, vCCCC, field@AAAAAAAA */ 9046 movl rSELF,%ecx 9047 SPILL(rIBASE) 9048 movl 2(rPC),rIBASE # rIBASE<- AAAAAAAA 9049 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex 9050 movzwl 8(rPC),%ecx # ecx<- CCCC 9051 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields 9052 GET_VREG_R %ecx %ecx # ecx<- fp[CCCC], the object ptr 9053 movl (%eax,rIBASE,4),%eax # resolved entry 9054 testl %eax,%eax # is resolved entry null? 9055 jne .LOP_IPUT_SHORT_JUMBO_finish # no, already resolved 9056 movl rIBASE,OUT_ARG1(%esp) 9057 movl rSELF,rIBASE 9058 EXPORT_PC 9059 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method 9060 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz 9061 SPILL_TMP1(%ecx) # save obj pointer across call 9062 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz 9063 call dvmResolveInstField # ... to dvmResolveInstField 9064 UNSPILL_TMP1(%ecx) 9065 testl %eax,%eax # returns InstrField ptr 9066 jne .LOP_IPUT_SHORT_JUMBO_finish 9067 jmp common_exceptionThrown 9068 9069.LOP_IPUT_SHORT_JUMBO_finish: 9070 /* 9071 * Currently: 9072 * eax holds resolved field 9073 * ecx holds object 9074 * rINST holds BBBB 9075 */ 9076 GET_VREG_R rINST rINST # rINST<- v[BBBB] 9077 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field 9078 testl %ecx,%ecx # object null? 9079 je common_errNullObject # object was null 9080 movw rINSTw,(%ecx,%eax,1) # obj.field <- v[BBBB](8/16/32 bits) 9081 FETCH_INST_OPCODE 5 %ecx 9082 UNSPILL(rIBASE) 9083 ADVANCE_PC 5 9084 GOTO_NEXT_R %ecx 9085 9086 9087/* ------------------------------ */ 9088.L_OP_SGET_JUMBO: /* 0x114 */ 9089/* File: x86/OP_SGET_JUMBO.S */ 9090 /* 9091 * Jumbo 32-bit SGET handler. 9092 * 9093 * for: sget/jumbo, sget-object/jumbo, sget-boolean/jumbo, sget-byte/jumbo, 9094 * sget-char/jumbo, sget-short/jumbo 9095 */ 9096 /* exop vBBBB, field@AAAAAAAA */ 9097 movl rSELF,%ecx 9098 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex 9099 movl 2(rPC),%eax # eax<- field ref AAAAAAAA 9100 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields 9101 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr 9102 testl %eax,%eax # resolved entry null? 9103 je .LOP_SGET_JUMBO_resolve # if not, make it so 9104.LOP_SGET_JUMBO_finish: # field ptr in eax 9105 movl offStaticField_value(%eax),%eax 9106 FETCH_INST_OPCODE 4 %ecx 9107 ADVANCE_PC 4 9108 SET_VREG %eax rINST 9109 GOTO_NEXT_R %ecx 9110 9111 /* 9112 * Go resolve the field 9113 */ 9114.LOP_SGET_JUMBO_resolve: 9115 movl rSELF,%ecx 9116 movl 2(rPC),%eax # eax<- field ref AAAAAAAA 9117 movl offThread_method(%ecx),%ecx # ecx<- current method 9118 EXPORT_PC # could throw, need to export 9119 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 9120 movl %eax,OUT_ARG1(%esp) 9121 movl %ecx,OUT_ARG0(%esp) 9122 SPILL(rIBASE) 9123 call dvmResolveStaticField # eax<- resolved StaticField ptr 9124 UNSPILL(rIBASE) 9125 testl %eax,%eax 9126 jne .LOP_SGET_JUMBO_finish # success, continue 9127 jmp common_exceptionThrown # no, handle exception 9128 9129/* ------------------------------ */ 9130.L_OP_SGET_WIDE_JUMBO: /* 0x115 */ 9131/* File: x86/OP_SGET_WIDE_JUMBO.S */ 9132 /* 9133 * Jumbo 64-bit SGET handler. 9134 * 9135 */ 9136 /* sget-wide/jumbo vBBBB, field@AAAAAAAA */ 9137 movl rSELF,%ecx 9138 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex 9139 movl 2(rPC),%eax # eax<- field ref AAAAAAAA 9140 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields 9141 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr 9142 testl %eax,%eax # resolved entry null? 9143 je .LOP_SGET_WIDE_JUMBO_resolve # if not, make it so 9144.LOP_SGET_WIDE_JUMBO_finish: # field ptr in eax 9145 movl offStaticField_value(%eax),%ecx # ecx<- lsw 9146 movl 4+offStaticField_value(%eax),%eax # eax<- msw 9147 SET_VREG_WORD %ecx rINST 0 9148 FETCH_INST_OPCODE 2 %ecx 9149 SET_VREG_WORD %eax rINST 1 9150 ADVANCE_PC 2 9151 GOTO_NEXT_R %ecx 9152 9153 /* 9154 * Go resolve the field 9155 */ 9156.LOP_SGET_WIDE_JUMBO_resolve: 9157 movl rSELF,%ecx 9158 movl 2(rPC),%eax # eax<- field ref AAAAAAAA 9159 movl offThread_method(%ecx),%ecx # ecx<- current method 9160 EXPORT_PC # could throw, need to export 9161 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 9162 movl %eax,OUT_ARG1(%esp) 9163 movl %ecx,OUT_ARG0(%esp) 9164 SPILL(rIBASE) 9165 call dvmResolveStaticField # eax<- resolved StaticField ptr 9166 UNSPILL(rIBASE) 9167 testl %eax,%eax 9168 jne .LOP_SGET_WIDE_JUMBO_finish # success, continue 9169 jmp common_exceptionThrown # no, handle exception 9170 9171/* ------------------------------ */ 9172.L_OP_SGET_OBJECT_JUMBO: /* 0x116 */ 9173/* File: x86/OP_SGET_OBJECT_JUMBO.S */ 9174/* File: x86/OP_SGET_JUMBO.S */ 9175 /* 9176 * Jumbo 32-bit SGET handler. 9177 * 9178 * for: sget/jumbo, sget-object/jumbo, sget-boolean/jumbo, sget-byte/jumbo, 9179 * sget-char/jumbo, sget-short/jumbo 9180 */ 9181 /* exop vBBBB, field@AAAAAAAA */ 9182 movl rSELF,%ecx 9183 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex 9184 movl 2(rPC),%eax # eax<- field ref AAAAAAAA 9185 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields 9186 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr 9187 testl %eax,%eax # resolved entry null? 9188 je .LOP_SGET_OBJECT_JUMBO_resolve # if not, make it so 9189.LOP_SGET_OBJECT_JUMBO_finish: # field ptr in eax 9190 movl offStaticField_value(%eax),%eax 9191 FETCH_INST_OPCODE 4 %ecx 9192 ADVANCE_PC 4 9193 SET_VREG %eax rINST 9194 GOTO_NEXT_R %ecx 9195 9196 /* 9197 * Go resolve the field 9198 */ 9199.LOP_SGET_OBJECT_JUMBO_resolve: 9200 movl rSELF,%ecx 9201 movl 2(rPC),%eax # eax<- field ref AAAAAAAA 9202 movl offThread_method(%ecx),%ecx # ecx<- current method 9203 EXPORT_PC # could throw, need to export 9204 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 9205 movl %eax,OUT_ARG1(%esp) 9206 movl %ecx,OUT_ARG0(%esp) 9207 SPILL(rIBASE) 9208 call dvmResolveStaticField # eax<- resolved StaticField ptr 9209 UNSPILL(rIBASE) 9210 testl %eax,%eax 9211 jne .LOP_SGET_OBJECT_JUMBO_finish # success, continue 9212 jmp common_exceptionThrown # no, handle exception 9213 9214 9215/* ------------------------------ */ 9216.L_OP_SGET_BOOLEAN_JUMBO: /* 0x117 */ 9217/* File: x86/OP_SGET_BOOLEAN_JUMBO.S */ 9218/* File: x86/OP_SGET_JUMBO.S */ 9219 /* 9220 * Jumbo 32-bit SGET handler. 9221 * 9222 * for: sget/jumbo, sget-object/jumbo, sget-boolean/jumbo, sget-byte/jumbo, 9223 * sget-char/jumbo, sget-short/jumbo 9224 */ 9225 /* exop vBBBB, field@AAAAAAAA */ 9226 movl rSELF,%ecx 9227 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex 9228 movl 2(rPC),%eax # eax<- field ref AAAAAAAA 9229 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields 9230 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr 9231 testl %eax,%eax # resolved entry null? 9232 je .LOP_SGET_BOOLEAN_JUMBO_resolve # if not, make it so 9233.LOP_SGET_BOOLEAN_JUMBO_finish: # field ptr in eax 9234 movl offStaticField_value(%eax),%eax 9235 FETCH_INST_OPCODE 4 %ecx 9236 ADVANCE_PC 4 9237 SET_VREG %eax rINST 9238 GOTO_NEXT_R %ecx 9239 9240 /* 9241 * Go resolve the field 9242 */ 9243.LOP_SGET_BOOLEAN_JUMBO_resolve: 9244 movl rSELF,%ecx 9245 movl 2(rPC),%eax # eax<- field ref AAAAAAAA 9246 movl offThread_method(%ecx),%ecx # ecx<- current method 9247 EXPORT_PC # could throw, need to export 9248 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 9249 movl %eax,OUT_ARG1(%esp) 9250 movl %ecx,OUT_ARG0(%esp) 9251 SPILL(rIBASE) 9252 call dvmResolveStaticField # eax<- resolved StaticField ptr 9253 UNSPILL(rIBASE) 9254 testl %eax,%eax 9255 jne .LOP_SGET_BOOLEAN_JUMBO_finish # success, continue 9256 jmp common_exceptionThrown # no, handle exception 9257 9258 9259/* ------------------------------ */ 9260.L_OP_SGET_BYTE_JUMBO: /* 0x118 */ 9261/* File: x86/OP_SGET_BYTE_JUMBO.S */ 9262/* File: x86/OP_SGET_JUMBO.S */ 9263 /* 9264 * Jumbo 32-bit SGET handler. 9265 * 9266 * for: sget/jumbo, sget-object/jumbo, sget-boolean/jumbo, sget-byte/jumbo, 9267 * sget-char/jumbo, sget-short/jumbo 9268 */ 9269 /* exop vBBBB, field@AAAAAAAA */ 9270 movl rSELF,%ecx 9271 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex 9272 movl 2(rPC),%eax # eax<- field ref AAAAAAAA 9273 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields 9274 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr 9275 testl %eax,%eax # resolved entry null? 9276 je .LOP_SGET_BYTE_JUMBO_resolve # if not, make it so 9277.LOP_SGET_BYTE_JUMBO_finish: # field ptr in eax 9278 movl offStaticField_value(%eax),%eax 9279 FETCH_INST_OPCODE 4 %ecx 9280 ADVANCE_PC 4 9281 SET_VREG %eax rINST 9282 GOTO_NEXT_R %ecx 9283 9284 /* 9285 * Go resolve the field 9286 */ 9287.LOP_SGET_BYTE_JUMBO_resolve: 9288 movl rSELF,%ecx 9289 movl 2(rPC),%eax # eax<- field ref AAAAAAAA 9290 movl offThread_method(%ecx),%ecx # ecx<- current method 9291 EXPORT_PC # could throw, need to export 9292 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 9293 movl %eax,OUT_ARG1(%esp) 9294 movl %ecx,OUT_ARG0(%esp) 9295 SPILL(rIBASE) 9296 call dvmResolveStaticField # eax<- resolved StaticField ptr 9297 UNSPILL(rIBASE) 9298 testl %eax,%eax 9299 jne .LOP_SGET_BYTE_JUMBO_finish # success, continue 9300 jmp common_exceptionThrown # no, handle exception 9301 9302 9303/* ------------------------------ */ 9304.L_OP_SGET_CHAR_JUMBO: /* 0x119 */ 9305/* File: x86/OP_SGET_CHAR_JUMBO.S */ 9306/* File: x86/OP_SGET_JUMBO.S */ 9307 /* 9308 * Jumbo 32-bit SGET handler. 9309 * 9310 * for: sget/jumbo, sget-object/jumbo, sget-boolean/jumbo, sget-byte/jumbo, 9311 * sget-char/jumbo, sget-short/jumbo 9312 */ 9313 /* exop vBBBB, field@AAAAAAAA */ 9314 movl rSELF,%ecx 9315 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex 9316 movl 2(rPC),%eax # eax<- field ref AAAAAAAA 9317 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields 9318 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr 9319 testl %eax,%eax # resolved entry null? 9320 je .LOP_SGET_CHAR_JUMBO_resolve # if not, make it so 9321.LOP_SGET_CHAR_JUMBO_finish: # field ptr in eax 9322 movl offStaticField_value(%eax),%eax 9323 FETCH_INST_OPCODE 4 %ecx 9324 ADVANCE_PC 4 9325 SET_VREG %eax rINST 9326 GOTO_NEXT_R %ecx 9327 9328 /* 9329 * Go resolve the field 9330 */ 9331.LOP_SGET_CHAR_JUMBO_resolve: 9332 movl rSELF,%ecx 9333 movl 2(rPC),%eax # eax<- field ref AAAAAAAA 9334 movl offThread_method(%ecx),%ecx # ecx<- current method 9335 EXPORT_PC # could throw, need to export 9336 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 9337 movl %eax,OUT_ARG1(%esp) 9338 movl %ecx,OUT_ARG0(%esp) 9339 SPILL(rIBASE) 9340 call dvmResolveStaticField # eax<- resolved StaticField ptr 9341 UNSPILL(rIBASE) 9342 testl %eax,%eax 9343 jne .LOP_SGET_CHAR_JUMBO_finish # success, continue 9344 jmp common_exceptionThrown # no, handle exception 9345 9346 9347/* ------------------------------ */ 9348.L_OP_SGET_SHORT_JUMBO: /* 0x11a */ 9349/* File: x86/OP_SGET_SHORT_JUMBO.S */ 9350/* File: x86/OP_SGET_JUMBO.S */ 9351 /* 9352 * Jumbo 32-bit SGET handler. 9353 * 9354 * for: sget/jumbo, sget-object/jumbo, sget-boolean/jumbo, sget-byte/jumbo, 9355 * sget-char/jumbo, sget-short/jumbo 9356 */ 9357 /* exop vBBBB, field@AAAAAAAA */ 9358 movl rSELF,%ecx 9359 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex 9360 movl 2(rPC),%eax # eax<- field ref AAAAAAAA 9361 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields 9362 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr 9363 testl %eax,%eax # resolved entry null? 9364 je .LOP_SGET_SHORT_JUMBO_resolve # if not, make it so 9365.LOP_SGET_SHORT_JUMBO_finish: # field ptr in eax 9366 movl offStaticField_value(%eax),%eax 9367 FETCH_INST_OPCODE 4 %ecx 9368 ADVANCE_PC 4 9369 SET_VREG %eax rINST 9370 GOTO_NEXT_R %ecx 9371 9372 /* 9373 * Go resolve the field 9374 */ 9375.LOP_SGET_SHORT_JUMBO_resolve: 9376 movl rSELF,%ecx 9377 movl 2(rPC),%eax # eax<- field ref AAAAAAAA 9378 movl offThread_method(%ecx),%ecx # ecx<- current method 9379 EXPORT_PC # could throw, need to export 9380 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 9381 movl %eax,OUT_ARG1(%esp) 9382 movl %ecx,OUT_ARG0(%esp) 9383 SPILL(rIBASE) 9384 call dvmResolveStaticField # eax<- resolved StaticField ptr 9385 UNSPILL(rIBASE) 9386 testl %eax,%eax 9387 jne .LOP_SGET_SHORT_JUMBO_finish # success, continue 9388 jmp common_exceptionThrown # no, handle exception 9389 9390 9391/* ------------------------------ */ 9392.L_OP_SPUT_JUMBO: /* 0x11b */ 9393/* File: x86/OP_SPUT_JUMBO.S */ 9394 /* 9395 * Jumbo 32-bit SPUT handler. 9396 * 9397 * for: sput/jumbo, sput-boolean/jumbo, sput-byte/jumbo, sput-char/jumbo, 9398 * sput-short/jumbo 9399 */ 9400 /* exop vBBBB, field@AAAAAAAA */ 9401 movl rSELF,%ecx 9402 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex 9403 movl 2(rPC),%eax # eax<- field ref AAAAAAAA 9404 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields 9405 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr 9406 testl %eax,%eax # resolved entry null? 9407 je .LOP_SPUT_JUMBO_resolve # if not, make it so 9408.LOP_SPUT_JUMBO_finish: # field ptr in eax 9409 GET_VREG_R rINST rINST 9410 FETCH_INST_OPCODE 4 %ecx 9411 ADVANCE_PC 4 9412 movl rINST,offStaticField_value(%eax) 9413 GOTO_NEXT_R %ecx 9414 9415 /* 9416 * Go resolve the field 9417 */ 9418.LOP_SPUT_JUMBO_resolve: 9419 movl rSELF,%ecx 9420 movl 2(rPC),%eax # eax<- field ref AAAAAAAA 9421 movl offThread_method(%ecx),%ecx # ecx<- current method 9422 EXPORT_PC # could throw, need to export 9423 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 9424 movl %eax,OUT_ARG1(%esp) 9425 movl %ecx,OUT_ARG0(%esp) 9426 SPILL(rIBASE) 9427 call dvmResolveStaticField # eax<- resolved StaticField ptr 9428 UNSPILL(rIBASE) 9429 testl %eax,%eax 9430 jne .LOP_SPUT_JUMBO_finish # success, continue 9431 jmp common_exceptionThrown # no, handle exception 9432 9433/* ------------------------------ */ 9434.L_OP_SPUT_WIDE_JUMBO: /* 0x11c */ 9435/* File: x86/OP_SPUT_WIDE_JUMBO.S */ 9436 /* 9437 * Jumbo 64-bit SPUT handler. 9438 */ 9439 /* sput-wide/jumbo vBBBB, field@AAAAAAAA */ 9440 movl rSELF,%ecx 9441 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex 9442 movl 2(rPC),%eax # eax<- field ref AAAAAAAA 9443 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields 9444 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr 9445 testl %eax,%eax # resolved entry null? 9446 je .LOP_SPUT_WIDE_JUMBO_resolve # if not, make it so 9447.LOP_SPUT_WIDE_JUMBO_finish: # field ptr in eax 9448 GET_VREG_WORD %ecx rINST 0 # ecx<- lsw 9449 GET_VREG_WORD rINST rINST 1 # rINST<- msw 9450 movl %ecx,offStaticField_value(%eax) 9451 FETCH_INST_OPCODE 4 %ecx 9452 movl rINST,4+offStaticField_value(%eax) 9453 ADVANCE_PC 4 9454 GOTO_NEXT_R %ecx 9455 9456 /* 9457 * Go resolve the field 9458 */ 9459.LOP_SPUT_WIDE_JUMBO_resolve: 9460 movl rSELF,%ecx 9461 movl 2(rPC),%eax # eax<- field ref AAAAAAAA 9462 movl offThread_method(%ecx),%ecx # ecx<- current method 9463 EXPORT_PC # could throw, need to export 9464 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 9465 movl %eax,OUT_ARG1(%esp) 9466 movl %ecx,OUT_ARG0(%esp) 9467 SPILL(rIBASE) 9468 call dvmResolveStaticField # eax<- resolved StaticField ptr 9469 UNSPILL(rIBASE) 9470 testl %eax,%eax 9471 jne .LOP_SPUT_WIDE_JUMBO_finish # success, continue 9472 jmp common_exceptionThrown # no, handle exception 9473 9474/* ------------------------------ */ 9475.L_OP_SPUT_OBJECT_JUMBO: /* 0x11d */ 9476/* File: x86/OP_SPUT_OBJECT_JUMBO.S */ 9477 /* 9478 * Jumbo SPUT object handler. 9479 */ 9480 /* sput-object/jumbo vBBBB, field@AAAAAAAA */ 9481 movl rSELF,%ecx 9482 movl 2(rPC),%eax # eax<- field ref AAAAAAAA 9483 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex 9484 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields 9485 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField 9486 testl %eax,%eax # resolved entry null? 9487 je .LOP_SPUT_OBJECT_JUMBO_resolve # if not, make it so 9488.LOP_SPUT_OBJECT_JUMBO_finish: # field ptr in eax 9489 GET_VREG_R %ecx rINST 9490 movl %ecx,offStaticField_value(%eax) # do the store 9491 testl %ecx,%ecx # stored null object ptr? 9492 je 1f # skip card mark if null 9493 movl rSELF,%ecx 9494 movl offField_clazz(%eax),%eax # eax<- method->clazz 9495 movl offThread_cardTable(%ecx),%ecx # get card table base 9496 shrl $GC_CARD_SHIFT,%eax # head to card number 9497 movb %cl,(%ecx,%eax) # mark card 94981: 9499 FETCH_INST_OPCODE 4 %ecx 9500 ADVANCE_PC 4 9501 GOTO_NEXT_R %ecx 9502 9503.LOP_SPUT_OBJECT_JUMBO_resolve: 9504 movl rSELF,%ecx 9505 movl 2(rPC),%eax # eax<- field ref AAAAAAAA 9506 movl offThread_method(%ecx),%ecx # ecx<- current method 9507 EXPORT_PC # could throw, need to export 9508 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 9509 movl %eax,OUT_ARG1(%esp) 9510 movl %ecx,OUT_ARG0(%esp) 9511 SPILL(rIBASE) 9512 call dvmResolveStaticField # eax<- resolved StaticField ptr 9513 UNSPILL(rIBASE) 9514 testl %eax,%eax 9515 jne .LOP_SPUT_OBJECT_JUMBO_finish # success, continue 9516 jmp common_exceptionThrown # no, handle exception 9517 9518/* ------------------------------ */ 9519.L_OP_SPUT_BOOLEAN_JUMBO: /* 0x11e */ 9520/* File: x86/OP_SPUT_BOOLEAN_JUMBO.S */ 9521/* File: x86/OP_SPUT_JUMBO.S */ 9522 /* 9523 * Jumbo 32-bit SPUT handler. 9524 * 9525 * for: sput/jumbo, sput-boolean/jumbo, sput-byte/jumbo, sput-char/jumbo, 9526 * sput-short/jumbo 9527 */ 9528 /* exop vBBBB, field@AAAAAAAA */ 9529 movl rSELF,%ecx 9530 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex 9531 movl 2(rPC),%eax # eax<- field ref AAAAAAAA 9532 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields 9533 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr 9534 testl %eax,%eax # resolved entry null? 9535 je .LOP_SPUT_BOOLEAN_JUMBO_resolve # if not, make it so 9536.LOP_SPUT_BOOLEAN_JUMBO_finish: # field ptr in eax 9537 GET_VREG_R rINST rINST 9538 FETCH_INST_OPCODE 4 %ecx 9539 ADVANCE_PC 4 9540 movl rINST,offStaticField_value(%eax) 9541 GOTO_NEXT_R %ecx 9542 9543 /* 9544 * Go resolve the field 9545 */ 9546.LOP_SPUT_BOOLEAN_JUMBO_resolve: 9547 movl rSELF,%ecx 9548 movl 2(rPC),%eax # eax<- field ref AAAAAAAA 9549 movl offThread_method(%ecx),%ecx # ecx<- current method 9550 EXPORT_PC # could throw, need to export 9551 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 9552 movl %eax,OUT_ARG1(%esp) 9553 movl %ecx,OUT_ARG0(%esp) 9554 SPILL(rIBASE) 9555 call dvmResolveStaticField # eax<- resolved StaticField ptr 9556 UNSPILL(rIBASE) 9557 testl %eax,%eax 9558 jne .LOP_SPUT_BOOLEAN_JUMBO_finish # success, continue 9559 jmp common_exceptionThrown # no, handle exception 9560 9561 9562/* ------------------------------ */ 9563.L_OP_SPUT_BYTE_JUMBO: /* 0x11f */ 9564/* File: x86/OP_SPUT_BYTE_JUMBO.S */ 9565/* File: x86/OP_SPUT_JUMBO.S */ 9566 /* 9567 * Jumbo 32-bit SPUT handler. 9568 * 9569 * for: sput/jumbo, sput-boolean/jumbo, sput-byte/jumbo, sput-char/jumbo, 9570 * sput-short/jumbo 9571 */ 9572 /* exop vBBBB, field@AAAAAAAA */ 9573 movl rSELF,%ecx 9574 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex 9575 movl 2(rPC),%eax # eax<- field ref AAAAAAAA 9576 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields 9577 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr 9578 testl %eax,%eax # resolved entry null? 9579 je .LOP_SPUT_BYTE_JUMBO_resolve # if not, make it so 9580.LOP_SPUT_BYTE_JUMBO_finish: # field ptr in eax 9581 GET_VREG_R rINST rINST 9582 FETCH_INST_OPCODE 4 %ecx 9583 ADVANCE_PC 4 9584 movl rINST,offStaticField_value(%eax) 9585 GOTO_NEXT_R %ecx 9586 9587 /* 9588 * Go resolve the field 9589 */ 9590.LOP_SPUT_BYTE_JUMBO_resolve: 9591 movl rSELF,%ecx 9592 movl 2(rPC),%eax # eax<- field ref AAAAAAAA 9593 movl offThread_method(%ecx),%ecx # ecx<- current method 9594 EXPORT_PC # could throw, need to export 9595 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 9596 movl %eax,OUT_ARG1(%esp) 9597 movl %ecx,OUT_ARG0(%esp) 9598 SPILL(rIBASE) 9599 call dvmResolveStaticField # eax<- resolved StaticField ptr 9600 UNSPILL(rIBASE) 9601 testl %eax,%eax 9602 jne .LOP_SPUT_BYTE_JUMBO_finish # success, continue 9603 jmp common_exceptionThrown # no, handle exception 9604 9605 9606/* ------------------------------ */ 9607.L_OP_SPUT_CHAR_JUMBO: /* 0x120 */ 9608/* File: x86/OP_SPUT_CHAR_JUMBO.S */ 9609/* File: x86/OP_SPUT_JUMBO.S */ 9610 /* 9611 * Jumbo 32-bit SPUT handler. 9612 * 9613 * for: sput/jumbo, sput-boolean/jumbo, sput-byte/jumbo, sput-char/jumbo, 9614 * sput-short/jumbo 9615 */ 9616 /* exop vBBBB, field@AAAAAAAA */ 9617 movl rSELF,%ecx 9618 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex 9619 movl 2(rPC),%eax # eax<- field ref AAAAAAAA 9620 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields 9621 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr 9622 testl %eax,%eax # resolved entry null? 9623 je .LOP_SPUT_CHAR_JUMBO_resolve # if not, make it so 9624.LOP_SPUT_CHAR_JUMBO_finish: # field ptr in eax 9625 GET_VREG_R rINST rINST 9626 FETCH_INST_OPCODE 4 %ecx 9627 ADVANCE_PC 4 9628 movl rINST,offStaticField_value(%eax) 9629 GOTO_NEXT_R %ecx 9630 9631 /* 9632 * Go resolve the field 9633 */ 9634.LOP_SPUT_CHAR_JUMBO_resolve: 9635 movl rSELF,%ecx 9636 movl 2(rPC),%eax # eax<- field ref AAAAAAAA 9637 movl offThread_method(%ecx),%ecx # ecx<- current method 9638 EXPORT_PC # could throw, need to export 9639 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 9640 movl %eax,OUT_ARG1(%esp) 9641 movl %ecx,OUT_ARG0(%esp) 9642 SPILL(rIBASE) 9643 call dvmResolveStaticField # eax<- resolved StaticField ptr 9644 UNSPILL(rIBASE) 9645 testl %eax,%eax 9646 jne .LOP_SPUT_CHAR_JUMBO_finish # success, continue 9647 jmp common_exceptionThrown # no, handle exception 9648 9649 9650/* ------------------------------ */ 9651.L_OP_SPUT_SHORT_JUMBO: /* 0x121 */ 9652/* File: x86/OP_SPUT_SHORT_JUMBO.S */ 9653/* File: x86/OP_SPUT_JUMBO.S */ 9654 /* 9655 * Jumbo 32-bit SPUT handler. 9656 * 9657 * for: sput/jumbo, sput-boolean/jumbo, sput-byte/jumbo, sput-char/jumbo, 9658 * sput-short/jumbo 9659 */ 9660 /* exop vBBBB, field@AAAAAAAA */ 9661 movl rSELF,%ecx 9662 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex 9663 movl 2(rPC),%eax # eax<- field ref AAAAAAAA 9664 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields 9665 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr 9666 testl %eax,%eax # resolved entry null? 9667 je .LOP_SPUT_SHORT_JUMBO_resolve # if not, make it so 9668.LOP_SPUT_SHORT_JUMBO_finish: # field ptr in eax 9669 GET_VREG_R rINST rINST 9670 FETCH_INST_OPCODE 4 %ecx 9671 ADVANCE_PC 4 9672 movl rINST,offStaticField_value(%eax) 9673 GOTO_NEXT_R %ecx 9674 9675 /* 9676 * Go resolve the field 9677 */ 9678.LOP_SPUT_SHORT_JUMBO_resolve: 9679 movl rSELF,%ecx 9680 movl 2(rPC),%eax # eax<- field ref AAAAAAAA 9681 movl offThread_method(%ecx),%ecx # ecx<- current method 9682 EXPORT_PC # could throw, need to export 9683 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 9684 movl %eax,OUT_ARG1(%esp) 9685 movl %ecx,OUT_ARG0(%esp) 9686 SPILL(rIBASE) 9687 call dvmResolveStaticField # eax<- resolved StaticField ptr 9688 UNSPILL(rIBASE) 9689 testl %eax,%eax 9690 jne .LOP_SPUT_SHORT_JUMBO_finish # success, continue 9691 jmp common_exceptionThrown # no, handle exception 9692 9693 9694/* ------------------------------ */ 9695.L_OP_INVOKE_VIRTUAL_JUMBO: /* 0x122 */ 9696/* File: x86/OP_INVOKE_VIRTUAL_JUMBO.S */ 9697 /* 9698 * Handle a jumbo virtual method call. 9699 */ 9700 /* invoke-virtual/jumbo vBBBB, {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */ 9701 movl rSELF,%eax 9702 movl 2(rPC),%ecx # ecx<- AAAAAAAA 9703 movl offThread_methodClassDex(%eax),%eax # eax<- pDvmDex 9704 EXPORT_PC 9705 movl offDvmDex_pResMethods(%eax),%eax # eax<- pDvmDex->pResMethods 9706 movl (%eax,%ecx,4),%eax # eax<- resolved baseMethod 9707 testl %eax,%eax # already resolved? 9708 jne .LOP_INVOKE_VIRTUAL_JUMBO_continue # yes, continue 9709 movl rSELF,%eax 9710 movl %ecx,OUT_ARG1(%esp) # arg1<- ref 9711 movl offThread_method(%eax),%eax # eax<- self->method 9712 movl offMethod_clazz(%eax),%eax # ecx<- method->clazz 9713 movl %eax,OUT_ARG0(%esp) # arg0<- clazz 9714 movl $METHOD_VIRTUAL,OUT_ARG2(%esp) # arg2<- flags 9715 call dvmResolveMethod # eax<- call(clazz, ref, flags) 9716 testl %eax,%eax # got null? 9717 jne .LOP_INVOKE_VIRTUAL_JUMBO_continue # no, continue 9718 jmp common_exceptionThrown # yes, handle exception 9719 9720 /* At this point: 9721 * eax = resolved base method 9722 * ecx = scratch 9723 */ 9724.LOP_INVOKE_VIRTUAL_JUMBO_continue: 9725 movzwl 8(rPC),%ecx # ecx<- CCCC 9726 GET_VREG_R %ecx %ecx # ecx<- "this" 9727 movzwl offMethod_methodIndex(%eax),%eax # eax<- baseMethod->methodIndex 9728 testl %ecx,%ecx # null this? 9729 je common_errNullObject # go if so 9730 movl offObject_clazz(%ecx),%ecx # ecx<- thisPtr->clazz 9731 movl offClassObject_vtable(%ecx),%ecx # ecx<- thisPtr->clazz->vtable 9732 movl (%ecx,%eax,4),%eax # eax<- vtable[methodIndex] 9733 jmp common_invokeMethodJumbo 9734 9735/* ------------------------------ */ 9736.L_OP_INVOKE_SUPER_JUMBO: /* 0x123 */ 9737/* File: x86/OP_INVOKE_SUPER_JUMBO.S */ 9738 /* 9739 * Handle a jumbo "super" method call. 9740 */ 9741 /* invoke-super/jumbo {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */ 9742 movl rSELF,rINST 9743 movl 2(rPC),%eax # eax<- AAAAAAAA 9744 movl offThread_methodClassDex(rINST),%ecx # ecx<- pDvmDex 9745 EXPORT_PC 9746 movl offDvmDex_pResMethods(%ecx),%ecx # ecx<- pDvmDex->pResMethods 9747 movl (%ecx,%eax,4),%ecx # ecx<- resolved baseMethod 9748 movl offThread_method(rINST),%eax # eax<- method 9749 movzwl 8(rPC),rINST # rINST<- CCCC 9750 GET_VREG_R rINST rINST # rINST<- "this" ptr 9751 testl rINST,rINST # null "this"? 9752 je common_errNullObject # yes, throw 9753 movl offMethod_clazz(%eax),%eax # eax<- method->clazz 9754 testl %ecx,%ecx # already resolved? 9755 je .LOP_INVOKE_SUPER_JUMBO_resolve 9756 /* 9757 * At this point: 9758 * ecx = resolved base method [r0] 9759 * eax = method->clazz [r9] 9760 */ 9761.LOP_INVOKE_SUPER_JUMBO_continue: 9762 movl offClassObject_super(%eax),%eax # eax<- method->clazz->super 9763 movzwl offMethod_methodIndex(%ecx),%ecx # ecx<- baseMthod->methodIndex 9764 cmpl offClassObject_vtableCount(%eax),%ecx # compare(methodIndex,vtableCount) 9765 jae .LOP_INVOKE_SUPER_JUMBO_nsm # method not present in superclass 9766 movl offClassObject_vtable(%eax),%eax # eax<- ...clazz->super->vtable 9767 movl (%eax,%ecx,4),%eax # eax<- vtable[methodIndex] 9768 jmp common_invokeMethodJumbo 9769 9770 9771 /* At this point: 9772 * ecx = null (needs to be resolved base method) 9773 * eax = method->clazz 9774 */ 9775.LOP_INVOKE_SUPER_JUMBO_resolve: 9776 SPILL_TMP1(%eax) # method->clazz 9777 movl %eax,OUT_ARG0(%esp) # arg0<- method->clazz 9778 movl 2(rPC),%ecx # ecx<- AAAAAAAA 9779 movl $METHOD_VIRTUAL,OUT_ARG2(%esp) # arg2<- resolver method type 9780 movl %ecx,OUT_ARG1(%esp) # arg1<- ref 9781 call dvmResolveMethod # eax<- call(clazz, ref, flags) 9782 testl %eax,%eax # got null? 9783 movl %eax,%ecx # ecx<- resolved base method 9784 UNSPILL_TMP1(%eax) # restore method->clazz 9785 jne .LOP_INVOKE_SUPER_JUMBO_continue # good to go - continue 9786 jmp common_exceptionThrown # handle exception 9787 9788 /* 9789 * Throw a NoSuchMethodError with the method name as the message. 9790 * ecx = resolved base method 9791 */ 9792.LOP_INVOKE_SUPER_JUMBO_nsm: 9793 movl offMethod_name(%ecx),%eax 9794 jmp common_errNoSuchMethod 9795 9796/* ------------------------------ */ 9797.L_OP_INVOKE_DIRECT_JUMBO: /* 0x124 */ 9798/* File: x86/OP_INVOKE_DIRECT_JUMBO.S */ 9799 /* 9800 * Handle a jumbo direct method call. 9801 * 9802 * (We could defer the "is 'this' pointer null" test to the common 9803 * method invocation code, and use a flag to indicate that static 9804 * calls don't count. If we do this as part of copying the arguments 9805 * out we could avoiding loading the first arg twice.) 9806 */ 9807 /* invoke-direct/jumbo {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */ 9808 movl rSELF,%ecx 9809 movl 2(rPC),%eax # eax<- AAAAAAAA 9810 movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex 9811 EXPORT_PC 9812 movl offDvmDex_pResMethods(%ecx),%ecx # ecx<- pDvmDex->pResMethods 9813 movzwl 8(rPC),rIBASE # rIBASE<- CCCC 9814 movl (%ecx,%eax,4),%eax # eax<- resolved methodToCall 9815 testl %eax,%eax # already resolved? 9816 GET_VREG_R %ecx rIBASE # ecx<- "this" ptr 9817 je .LOP_INVOKE_DIRECT_JUMBO_resolve # not resolved, do it now 9818.LOP_INVOKE_DIRECT_JUMBO_finish: 9819 testl %ecx,%ecx # null "this"? 9820 jne common_invokeMethodJumbo # no, continue on 9821 jmp common_errNullObject 9822 9823 /* 9824 * On entry: 9825 * TMP_SPILL <- "this" register 9826 * Things a bit ugly on this path, but it's the less 9827 * frequent one. We'll have to do some reloading. 9828 */ 9829.LOP_INVOKE_DIRECT_JUMBO_resolve: 9830 SPILL_TMP1(%ecx) 9831 movl rSELF,%ecx 9832 movl offThread_method(%ecx),%ecx # ecx<- self->method 9833 movl 2(rPC),%eax # reference AAAAAAAA 9834 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 9835 movl $METHOD_DIRECT,OUT_ARG2(%esp) 9836 movl %eax,OUT_ARG1(%esp) 9837 movl %ecx,OUT_ARG0(%esp) 9838 call dvmResolveMethod # eax<- call(clazz, ref, flags) 9839 UNSPILL_TMP1(%ecx) 9840 testl %eax,%eax 9841 jne .LOP_INVOKE_DIRECT_JUMBO_finish 9842 jmp common_exceptionThrown 9843 9844/* ------------------------------ */ 9845.L_OP_INVOKE_STATIC_JUMBO: /* 0x125 */ 9846/* File: x86/OP_INVOKE_STATIC_JUMBO.S */ 9847 /* 9848 * Handle a jumbo static method call. 9849 */ 9850 /* invoke-static/jumbo {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */ 9851 movl rSELF,%ecx 9852 movl 2(rPC),%eax # eax<- AAAAAAAA 9853 movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex 9854 EXPORT_PC 9855 movl offDvmDex_pResMethods(%ecx),%ecx # ecx<- pDvmDex->pResMethods 9856 movl (%ecx,%eax,4),%eax # eax<- resolved methodToCall 9857 testl %eax,%eax 9858 jne common_invokeMethodJumbo 9859 movl rSELF,%ecx 9860 movl offThread_method(%ecx),%ecx # ecx<- self->method 9861 movl 2(rPC),%eax # eax<- AAAAAAAA 9862 movl offMethod_clazz(%ecx),%ecx# ecx<- method->clazz 9863 movl %eax,OUT_ARG1(%esp) # arg1<- AAAAAAAA 9864 movl %ecx,OUT_ARG0(%esp) # arg0<- clazz 9865 movl $METHOD_STATIC,%eax 9866 movl %eax,OUT_ARG2(%esp) # arg2<- flags 9867 call dvmResolveMethod # call(clazz,ref,flags) 9868 testl %eax,%eax # got null? 9869 jne common_invokeMethodJumbo 9870 jmp common_exceptionThrown 9871 9872/* ------------------------------ */ 9873.L_OP_INVOKE_INTERFACE_JUMBO: /* 0x126 */ 9874/* File: x86/OP_INVOKE_INTERFACE_JUMBO.S */ 9875 /* 9876 * Handle a jumbo interface method call. 9877 */ 9878 /* invoke-interface/jumbo {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */ 9879 movzwl 8(rPC),%eax # eax<- CCCC 9880 movl rSELF,%ecx 9881 GET_VREG_R %eax %eax # eax<- "this" 9882 EXPORT_PC 9883 testl %eax,%eax # null this? 9884 je common_errNullObject # yes, fail 9885 movl offObject_clazz(%eax),%eax# eax<- thisPtr->clazz 9886 movl %eax,OUT_ARG0(%esp) # arg0<- class 9887 movl offThread_methodClassDex(%ecx),%eax # eax<- methodClassDex 9888 movl offThread_method(%ecx),%ecx # ecx<- method 9889 movl %eax,OUT_ARG3(%esp) # arg3<- dex 9890 movl 2(rPC),%eax # eax<- AAAAAAAA 9891 movl %ecx,OUT_ARG2(%esp) # arg2<- method 9892 movl %eax,OUT_ARG1(%esp) # arg1<- AAAAAAAA 9893 call dvmFindInterfaceMethodInCache # eax<- call(class, ref, method, dex) 9894 testl %eax,%eax 9895 je common_exceptionThrown 9896 jmp common_invokeMethodJumbo 9897 9898/* ------------------------------ */ 9899.L_OP_UNUSED_27FF: /* 0x127 */ 9900/* File: x86/OP_UNUSED_27FF.S */ 9901/* File: x86/unused.S */ 9902 jmp common_abort 9903 9904 9905/* ------------------------------ */ 9906.L_OP_UNUSED_28FF: /* 0x128 */ 9907/* File: x86/OP_UNUSED_28FF.S */ 9908/* File: x86/unused.S */ 9909 jmp common_abort 9910 9911 9912/* ------------------------------ */ 9913.L_OP_UNUSED_29FF: /* 0x129 */ 9914/* File: x86/OP_UNUSED_29FF.S */ 9915/* File: x86/unused.S */ 9916 jmp common_abort 9917 9918 9919/* ------------------------------ */ 9920.L_OP_UNUSED_2AFF: /* 0x12a */ 9921/* File: x86/OP_UNUSED_2AFF.S */ 9922/* File: x86/unused.S */ 9923 jmp common_abort 9924 9925 9926/* ------------------------------ */ 9927.L_OP_UNUSED_2BFF: /* 0x12b */ 9928/* File: x86/OP_UNUSED_2BFF.S */ 9929/* File: x86/unused.S */ 9930 jmp common_abort 9931 9932 9933/* ------------------------------ */ 9934.L_OP_UNUSED_2CFF: /* 0x12c */ 9935/* File: x86/OP_UNUSED_2CFF.S */ 9936/* File: x86/unused.S */ 9937 jmp common_abort 9938 9939 9940/* ------------------------------ */ 9941.L_OP_UNUSED_2DFF: /* 0x12d */ 9942/* File: x86/OP_UNUSED_2DFF.S */ 9943/* File: x86/unused.S */ 9944 jmp common_abort 9945 9946 9947/* ------------------------------ */ 9948.L_OP_UNUSED_2EFF: /* 0x12e */ 9949/* File: x86/OP_UNUSED_2EFF.S */ 9950/* File: x86/unused.S */ 9951 jmp common_abort 9952 9953 9954/* ------------------------------ */ 9955.L_OP_UNUSED_2FFF: /* 0x12f */ 9956/* File: x86/OP_UNUSED_2FFF.S */ 9957/* File: x86/unused.S */ 9958 jmp common_abort 9959 9960 9961/* ------------------------------ */ 9962.L_OP_UNUSED_30FF: /* 0x130 */ 9963/* File: x86/OP_UNUSED_30FF.S */ 9964/* File: x86/unused.S */ 9965 jmp common_abort 9966 9967 9968/* ------------------------------ */ 9969.L_OP_UNUSED_31FF: /* 0x131 */ 9970/* File: x86/OP_UNUSED_31FF.S */ 9971/* File: x86/unused.S */ 9972 jmp common_abort 9973 9974 9975/* ------------------------------ */ 9976.L_OP_UNUSED_32FF: /* 0x132 */ 9977/* File: x86/OP_UNUSED_32FF.S */ 9978/* File: x86/unused.S */ 9979 jmp common_abort 9980 9981 9982/* ------------------------------ */ 9983.L_OP_UNUSED_33FF: /* 0x133 */ 9984/* File: x86/OP_UNUSED_33FF.S */ 9985/* File: x86/unused.S */ 9986 jmp common_abort 9987 9988 9989/* ------------------------------ */ 9990.L_OP_UNUSED_34FF: /* 0x134 */ 9991/* File: x86/OP_UNUSED_34FF.S */ 9992/* File: x86/unused.S */ 9993 jmp common_abort 9994 9995 9996/* ------------------------------ */ 9997.L_OP_UNUSED_35FF: /* 0x135 */ 9998/* File: x86/OP_UNUSED_35FF.S */ 9999/* File: x86/unused.S */ 10000 jmp common_abort 10001 10002 10003/* ------------------------------ */ 10004.L_OP_UNUSED_36FF: /* 0x136 */ 10005/* File: x86/OP_UNUSED_36FF.S */ 10006/* File: x86/unused.S */ 10007 jmp common_abort 10008 10009 10010/* ------------------------------ */ 10011.L_OP_UNUSED_37FF: /* 0x137 */ 10012/* File: x86/OP_UNUSED_37FF.S */ 10013/* File: x86/unused.S */ 10014 jmp common_abort 10015 10016 10017/* ------------------------------ */ 10018.L_OP_UNUSED_38FF: /* 0x138 */ 10019/* File: x86/OP_UNUSED_38FF.S */ 10020/* File: x86/unused.S */ 10021 jmp common_abort 10022 10023 10024/* ------------------------------ */ 10025.L_OP_UNUSED_39FF: /* 0x139 */ 10026/* File: x86/OP_UNUSED_39FF.S */ 10027/* File: x86/unused.S */ 10028 jmp common_abort 10029 10030 10031/* ------------------------------ */ 10032.L_OP_UNUSED_3AFF: /* 0x13a */ 10033/* File: x86/OP_UNUSED_3AFF.S */ 10034/* File: x86/unused.S */ 10035 jmp common_abort 10036 10037 10038/* ------------------------------ */ 10039.L_OP_UNUSED_3BFF: /* 0x13b */ 10040/* File: x86/OP_UNUSED_3BFF.S */ 10041/* File: x86/unused.S */ 10042 jmp common_abort 10043 10044 10045/* ------------------------------ */ 10046.L_OP_UNUSED_3CFF: /* 0x13c */ 10047/* File: x86/OP_UNUSED_3CFF.S */ 10048/* File: x86/unused.S */ 10049 jmp common_abort 10050 10051 10052/* ------------------------------ */ 10053.L_OP_UNUSED_3DFF: /* 0x13d */ 10054/* File: x86/OP_UNUSED_3DFF.S */ 10055/* File: x86/unused.S */ 10056 jmp common_abort 10057 10058 10059/* ------------------------------ */ 10060.L_OP_UNUSED_3EFF: /* 0x13e */ 10061/* File: x86/OP_UNUSED_3EFF.S */ 10062/* File: x86/unused.S */ 10063 jmp common_abort 10064 10065 10066/* ------------------------------ */ 10067.L_OP_UNUSED_3FFF: /* 0x13f */ 10068/* File: x86/OP_UNUSED_3FFF.S */ 10069/* File: x86/unused.S */ 10070 jmp common_abort 10071 10072 10073/* ------------------------------ */ 10074.L_OP_UNUSED_40FF: /* 0x140 */ 10075/* File: x86/OP_UNUSED_40FF.S */ 10076/* File: x86/unused.S */ 10077 jmp common_abort 10078 10079 10080/* ------------------------------ */ 10081.L_OP_UNUSED_41FF: /* 0x141 */ 10082/* File: x86/OP_UNUSED_41FF.S */ 10083/* File: x86/unused.S */ 10084 jmp common_abort 10085 10086 10087/* ------------------------------ */ 10088.L_OP_UNUSED_42FF: /* 0x142 */ 10089/* File: x86/OP_UNUSED_42FF.S */ 10090/* File: x86/unused.S */ 10091 jmp common_abort 10092 10093 10094/* ------------------------------ */ 10095.L_OP_UNUSED_43FF: /* 0x143 */ 10096/* File: x86/OP_UNUSED_43FF.S */ 10097/* File: x86/unused.S */ 10098 jmp common_abort 10099 10100 10101/* ------------------------------ */ 10102.L_OP_UNUSED_44FF: /* 0x144 */ 10103/* File: x86/OP_UNUSED_44FF.S */ 10104/* File: x86/unused.S */ 10105 jmp common_abort 10106 10107 10108/* ------------------------------ */ 10109.L_OP_UNUSED_45FF: /* 0x145 */ 10110/* File: x86/OP_UNUSED_45FF.S */ 10111/* File: x86/unused.S */ 10112 jmp common_abort 10113 10114 10115/* ------------------------------ */ 10116.L_OP_UNUSED_46FF: /* 0x146 */ 10117/* File: x86/OP_UNUSED_46FF.S */ 10118/* File: x86/unused.S */ 10119 jmp common_abort 10120 10121 10122/* ------------------------------ */ 10123.L_OP_UNUSED_47FF: /* 0x147 */ 10124/* File: x86/OP_UNUSED_47FF.S */ 10125/* File: x86/unused.S */ 10126 jmp common_abort 10127 10128 10129/* ------------------------------ */ 10130.L_OP_UNUSED_48FF: /* 0x148 */ 10131/* File: x86/OP_UNUSED_48FF.S */ 10132/* File: x86/unused.S */ 10133 jmp common_abort 10134 10135 10136/* ------------------------------ */ 10137.L_OP_UNUSED_49FF: /* 0x149 */ 10138/* File: x86/OP_UNUSED_49FF.S */ 10139/* File: x86/unused.S */ 10140 jmp common_abort 10141 10142 10143/* ------------------------------ */ 10144.L_OP_UNUSED_4AFF: /* 0x14a */ 10145/* File: x86/OP_UNUSED_4AFF.S */ 10146/* File: x86/unused.S */ 10147 jmp common_abort 10148 10149 10150/* ------------------------------ */ 10151.L_OP_UNUSED_4BFF: /* 0x14b */ 10152/* File: x86/OP_UNUSED_4BFF.S */ 10153/* File: x86/unused.S */ 10154 jmp common_abort 10155 10156 10157/* ------------------------------ */ 10158.L_OP_UNUSED_4CFF: /* 0x14c */ 10159/* File: x86/OP_UNUSED_4CFF.S */ 10160/* File: x86/unused.S */ 10161 jmp common_abort 10162 10163 10164/* ------------------------------ */ 10165.L_OP_UNUSED_4DFF: /* 0x14d */ 10166/* File: x86/OP_UNUSED_4DFF.S */ 10167/* File: x86/unused.S */ 10168 jmp common_abort 10169 10170 10171/* ------------------------------ */ 10172.L_OP_UNUSED_4EFF: /* 0x14e */ 10173/* File: x86/OP_UNUSED_4EFF.S */ 10174/* File: x86/unused.S */ 10175 jmp common_abort 10176 10177 10178/* ------------------------------ */ 10179.L_OP_UNUSED_4FFF: /* 0x14f */ 10180/* File: x86/OP_UNUSED_4FFF.S */ 10181/* File: x86/unused.S */ 10182 jmp common_abort 10183 10184 10185/* ------------------------------ */ 10186.L_OP_UNUSED_50FF: /* 0x150 */ 10187/* File: x86/OP_UNUSED_50FF.S */ 10188/* File: x86/unused.S */ 10189 jmp common_abort 10190 10191 10192/* ------------------------------ */ 10193.L_OP_UNUSED_51FF: /* 0x151 */ 10194/* File: x86/OP_UNUSED_51FF.S */ 10195/* File: x86/unused.S */ 10196 jmp common_abort 10197 10198 10199/* ------------------------------ */ 10200.L_OP_UNUSED_52FF: /* 0x152 */ 10201/* File: x86/OP_UNUSED_52FF.S */ 10202/* File: x86/unused.S */ 10203 jmp common_abort 10204 10205 10206/* ------------------------------ */ 10207.L_OP_UNUSED_53FF: /* 0x153 */ 10208/* File: x86/OP_UNUSED_53FF.S */ 10209/* File: x86/unused.S */ 10210 jmp common_abort 10211 10212 10213/* ------------------------------ */ 10214.L_OP_UNUSED_54FF: /* 0x154 */ 10215/* File: x86/OP_UNUSED_54FF.S */ 10216/* File: x86/unused.S */ 10217 jmp common_abort 10218 10219 10220/* ------------------------------ */ 10221.L_OP_UNUSED_55FF: /* 0x155 */ 10222/* File: x86/OP_UNUSED_55FF.S */ 10223/* File: x86/unused.S */ 10224 jmp common_abort 10225 10226 10227/* ------------------------------ */ 10228.L_OP_UNUSED_56FF: /* 0x156 */ 10229/* File: x86/OP_UNUSED_56FF.S */ 10230/* File: x86/unused.S */ 10231 jmp common_abort 10232 10233 10234/* ------------------------------ */ 10235.L_OP_UNUSED_57FF: /* 0x157 */ 10236/* File: x86/OP_UNUSED_57FF.S */ 10237/* File: x86/unused.S */ 10238 jmp common_abort 10239 10240 10241/* ------------------------------ */ 10242.L_OP_UNUSED_58FF: /* 0x158 */ 10243/* File: x86/OP_UNUSED_58FF.S */ 10244/* File: x86/unused.S */ 10245 jmp common_abort 10246 10247 10248/* ------------------------------ */ 10249.L_OP_UNUSED_59FF: /* 0x159 */ 10250/* File: x86/OP_UNUSED_59FF.S */ 10251/* File: x86/unused.S */ 10252 jmp common_abort 10253 10254 10255/* ------------------------------ */ 10256.L_OP_UNUSED_5AFF: /* 0x15a */ 10257/* File: x86/OP_UNUSED_5AFF.S */ 10258/* File: x86/unused.S */ 10259 jmp common_abort 10260 10261 10262/* ------------------------------ */ 10263.L_OP_UNUSED_5BFF: /* 0x15b */ 10264/* File: x86/OP_UNUSED_5BFF.S */ 10265/* File: x86/unused.S */ 10266 jmp common_abort 10267 10268 10269/* ------------------------------ */ 10270.L_OP_UNUSED_5CFF: /* 0x15c */ 10271/* File: x86/OP_UNUSED_5CFF.S */ 10272/* File: x86/unused.S */ 10273 jmp common_abort 10274 10275 10276/* ------------------------------ */ 10277.L_OP_UNUSED_5DFF: /* 0x15d */ 10278/* File: x86/OP_UNUSED_5DFF.S */ 10279/* File: x86/unused.S */ 10280 jmp common_abort 10281 10282 10283/* ------------------------------ */ 10284.L_OP_UNUSED_5EFF: /* 0x15e */ 10285/* File: x86/OP_UNUSED_5EFF.S */ 10286/* File: x86/unused.S */ 10287 jmp common_abort 10288 10289 10290/* ------------------------------ */ 10291.L_OP_UNUSED_5FFF: /* 0x15f */ 10292/* File: x86/OP_UNUSED_5FFF.S */ 10293/* File: x86/unused.S */ 10294 jmp common_abort 10295 10296 10297/* ------------------------------ */ 10298.L_OP_UNUSED_60FF: /* 0x160 */ 10299/* File: x86/OP_UNUSED_60FF.S */ 10300/* File: x86/unused.S */ 10301 jmp common_abort 10302 10303 10304/* ------------------------------ */ 10305.L_OP_UNUSED_61FF: /* 0x161 */ 10306/* File: x86/OP_UNUSED_61FF.S */ 10307/* File: x86/unused.S */ 10308 jmp common_abort 10309 10310 10311/* ------------------------------ */ 10312.L_OP_UNUSED_62FF: /* 0x162 */ 10313/* File: x86/OP_UNUSED_62FF.S */ 10314/* File: x86/unused.S */ 10315 jmp common_abort 10316 10317 10318/* ------------------------------ */ 10319.L_OP_UNUSED_63FF: /* 0x163 */ 10320/* File: x86/OP_UNUSED_63FF.S */ 10321/* File: x86/unused.S */ 10322 jmp common_abort 10323 10324 10325/* ------------------------------ */ 10326.L_OP_UNUSED_64FF: /* 0x164 */ 10327/* File: x86/OP_UNUSED_64FF.S */ 10328/* File: x86/unused.S */ 10329 jmp common_abort 10330 10331 10332/* ------------------------------ */ 10333.L_OP_UNUSED_65FF: /* 0x165 */ 10334/* File: x86/OP_UNUSED_65FF.S */ 10335/* File: x86/unused.S */ 10336 jmp common_abort 10337 10338 10339/* ------------------------------ */ 10340.L_OP_UNUSED_66FF: /* 0x166 */ 10341/* File: x86/OP_UNUSED_66FF.S */ 10342/* File: x86/unused.S */ 10343 jmp common_abort 10344 10345 10346/* ------------------------------ */ 10347.L_OP_UNUSED_67FF: /* 0x167 */ 10348/* File: x86/OP_UNUSED_67FF.S */ 10349/* File: x86/unused.S */ 10350 jmp common_abort 10351 10352 10353/* ------------------------------ */ 10354.L_OP_UNUSED_68FF: /* 0x168 */ 10355/* File: x86/OP_UNUSED_68FF.S */ 10356/* File: x86/unused.S */ 10357 jmp common_abort 10358 10359 10360/* ------------------------------ */ 10361.L_OP_UNUSED_69FF: /* 0x169 */ 10362/* File: x86/OP_UNUSED_69FF.S */ 10363/* File: x86/unused.S */ 10364 jmp common_abort 10365 10366 10367/* ------------------------------ */ 10368.L_OP_UNUSED_6AFF: /* 0x16a */ 10369/* File: x86/OP_UNUSED_6AFF.S */ 10370/* File: x86/unused.S */ 10371 jmp common_abort 10372 10373 10374/* ------------------------------ */ 10375.L_OP_UNUSED_6BFF: /* 0x16b */ 10376/* File: x86/OP_UNUSED_6BFF.S */ 10377/* File: x86/unused.S */ 10378 jmp common_abort 10379 10380 10381/* ------------------------------ */ 10382.L_OP_UNUSED_6CFF: /* 0x16c */ 10383/* File: x86/OP_UNUSED_6CFF.S */ 10384/* File: x86/unused.S */ 10385 jmp common_abort 10386 10387 10388/* ------------------------------ */ 10389.L_OP_UNUSED_6DFF: /* 0x16d */ 10390/* File: x86/OP_UNUSED_6DFF.S */ 10391/* File: x86/unused.S */ 10392 jmp common_abort 10393 10394 10395/* ------------------------------ */ 10396.L_OP_UNUSED_6EFF: /* 0x16e */ 10397/* File: x86/OP_UNUSED_6EFF.S */ 10398/* File: x86/unused.S */ 10399 jmp common_abort 10400 10401 10402/* ------------------------------ */ 10403.L_OP_UNUSED_6FFF: /* 0x16f */ 10404/* File: x86/OP_UNUSED_6FFF.S */ 10405/* File: x86/unused.S */ 10406 jmp common_abort 10407 10408 10409/* ------------------------------ */ 10410.L_OP_UNUSED_70FF: /* 0x170 */ 10411/* File: x86/OP_UNUSED_70FF.S */ 10412/* File: x86/unused.S */ 10413 jmp common_abort 10414 10415 10416/* ------------------------------ */ 10417.L_OP_UNUSED_71FF: /* 0x171 */ 10418/* File: x86/OP_UNUSED_71FF.S */ 10419/* File: x86/unused.S */ 10420 jmp common_abort 10421 10422 10423/* ------------------------------ */ 10424.L_OP_UNUSED_72FF: /* 0x172 */ 10425/* File: x86/OP_UNUSED_72FF.S */ 10426/* File: x86/unused.S */ 10427 jmp common_abort 10428 10429 10430/* ------------------------------ */ 10431.L_OP_UNUSED_73FF: /* 0x173 */ 10432/* File: x86/OP_UNUSED_73FF.S */ 10433/* File: x86/unused.S */ 10434 jmp common_abort 10435 10436 10437/* ------------------------------ */ 10438.L_OP_UNUSED_74FF: /* 0x174 */ 10439/* File: x86/OP_UNUSED_74FF.S */ 10440/* File: x86/unused.S */ 10441 jmp common_abort 10442 10443 10444/* ------------------------------ */ 10445.L_OP_UNUSED_75FF: /* 0x175 */ 10446/* File: x86/OP_UNUSED_75FF.S */ 10447/* File: x86/unused.S */ 10448 jmp common_abort 10449 10450 10451/* ------------------------------ */ 10452.L_OP_UNUSED_76FF: /* 0x176 */ 10453/* File: x86/OP_UNUSED_76FF.S */ 10454/* File: x86/unused.S */ 10455 jmp common_abort 10456 10457 10458/* ------------------------------ */ 10459.L_OP_UNUSED_77FF: /* 0x177 */ 10460/* File: x86/OP_UNUSED_77FF.S */ 10461/* File: x86/unused.S */ 10462 jmp common_abort 10463 10464 10465/* ------------------------------ */ 10466.L_OP_UNUSED_78FF: /* 0x178 */ 10467/* File: x86/OP_UNUSED_78FF.S */ 10468/* File: x86/unused.S */ 10469 jmp common_abort 10470 10471 10472/* ------------------------------ */ 10473.L_OP_UNUSED_79FF: /* 0x179 */ 10474/* File: x86/OP_UNUSED_79FF.S */ 10475/* File: x86/unused.S */ 10476 jmp common_abort 10477 10478 10479/* ------------------------------ */ 10480.L_OP_UNUSED_7AFF: /* 0x17a */ 10481/* File: x86/OP_UNUSED_7AFF.S */ 10482/* File: x86/unused.S */ 10483 jmp common_abort 10484 10485 10486/* ------------------------------ */ 10487.L_OP_UNUSED_7BFF: /* 0x17b */ 10488/* File: x86/OP_UNUSED_7BFF.S */ 10489/* File: x86/unused.S */ 10490 jmp common_abort 10491 10492 10493/* ------------------------------ */ 10494.L_OP_UNUSED_7CFF: /* 0x17c */ 10495/* File: x86/OP_UNUSED_7CFF.S */ 10496/* File: x86/unused.S */ 10497 jmp common_abort 10498 10499 10500/* ------------------------------ */ 10501.L_OP_UNUSED_7DFF: /* 0x17d */ 10502/* File: x86/OP_UNUSED_7DFF.S */ 10503/* File: x86/unused.S */ 10504 jmp common_abort 10505 10506 10507/* ------------------------------ */ 10508.L_OP_UNUSED_7EFF: /* 0x17e */ 10509/* File: x86/OP_UNUSED_7EFF.S */ 10510/* File: x86/unused.S */ 10511 jmp common_abort 10512 10513 10514/* ------------------------------ */ 10515.L_OP_UNUSED_7FFF: /* 0x17f */ 10516/* File: x86/OP_UNUSED_7FFF.S */ 10517/* File: x86/unused.S */ 10518 jmp common_abort 10519 10520 10521/* ------------------------------ */ 10522.L_OP_UNUSED_80FF: /* 0x180 */ 10523/* File: x86/OP_UNUSED_80FF.S */ 10524/* File: x86/unused.S */ 10525 jmp common_abort 10526 10527 10528/* ------------------------------ */ 10529.L_OP_UNUSED_81FF: /* 0x181 */ 10530/* File: x86/OP_UNUSED_81FF.S */ 10531/* File: x86/unused.S */ 10532 jmp common_abort 10533 10534 10535/* ------------------------------ */ 10536.L_OP_UNUSED_82FF: /* 0x182 */ 10537/* File: x86/OP_UNUSED_82FF.S */ 10538/* File: x86/unused.S */ 10539 jmp common_abort 10540 10541 10542/* ------------------------------ */ 10543.L_OP_UNUSED_83FF: /* 0x183 */ 10544/* File: x86/OP_UNUSED_83FF.S */ 10545/* File: x86/unused.S */ 10546 jmp common_abort 10547 10548 10549/* ------------------------------ */ 10550.L_OP_UNUSED_84FF: /* 0x184 */ 10551/* File: x86/OP_UNUSED_84FF.S */ 10552/* File: x86/unused.S */ 10553 jmp common_abort 10554 10555 10556/* ------------------------------ */ 10557.L_OP_UNUSED_85FF: /* 0x185 */ 10558/* File: x86/OP_UNUSED_85FF.S */ 10559/* File: x86/unused.S */ 10560 jmp common_abort 10561 10562 10563/* ------------------------------ */ 10564.L_OP_UNUSED_86FF: /* 0x186 */ 10565/* File: x86/OP_UNUSED_86FF.S */ 10566/* File: x86/unused.S */ 10567 jmp common_abort 10568 10569 10570/* ------------------------------ */ 10571.L_OP_UNUSED_87FF: /* 0x187 */ 10572/* File: x86/OP_UNUSED_87FF.S */ 10573/* File: x86/unused.S */ 10574 jmp common_abort 10575 10576 10577/* ------------------------------ */ 10578.L_OP_UNUSED_88FF: /* 0x188 */ 10579/* File: x86/OP_UNUSED_88FF.S */ 10580/* File: x86/unused.S */ 10581 jmp common_abort 10582 10583 10584/* ------------------------------ */ 10585.L_OP_UNUSED_89FF: /* 0x189 */ 10586/* File: x86/OP_UNUSED_89FF.S */ 10587/* File: x86/unused.S */ 10588 jmp common_abort 10589 10590 10591/* ------------------------------ */ 10592.L_OP_UNUSED_8AFF: /* 0x18a */ 10593/* File: x86/OP_UNUSED_8AFF.S */ 10594/* File: x86/unused.S */ 10595 jmp common_abort 10596 10597 10598/* ------------------------------ */ 10599.L_OP_UNUSED_8BFF: /* 0x18b */ 10600/* File: x86/OP_UNUSED_8BFF.S */ 10601/* File: x86/unused.S */ 10602 jmp common_abort 10603 10604 10605/* ------------------------------ */ 10606.L_OP_UNUSED_8CFF: /* 0x18c */ 10607/* File: x86/OP_UNUSED_8CFF.S */ 10608/* File: x86/unused.S */ 10609 jmp common_abort 10610 10611 10612/* ------------------------------ */ 10613.L_OP_UNUSED_8DFF: /* 0x18d */ 10614/* File: x86/OP_UNUSED_8DFF.S */ 10615/* File: x86/unused.S */ 10616 jmp common_abort 10617 10618 10619/* ------------------------------ */ 10620.L_OP_UNUSED_8EFF: /* 0x18e */ 10621/* File: x86/OP_UNUSED_8EFF.S */ 10622/* File: x86/unused.S */ 10623 jmp common_abort 10624 10625 10626/* ------------------------------ */ 10627.L_OP_UNUSED_8FFF: /* 0x18f */ 10628/* File: x86/OP_UNUSED_8FFF.S */ 10629/* File: x86/unused.S */ 10630 jmp common_abort 10631 10632 10633/* ------------------------------ */ 10634.L_OP_UNUSED_90FF: /* 0x190 */ 10635/* File: x86/OP_UNUSED_90FF.S */ 10636/* File: x86/unused.S */ 10637 jmp common_abort 10638 10639 10640/* ------------------------------ */ 10641.L_OP_UNUSED_91FF: /* 0x191 */ 10642/* File: x86/OP_UNUSED_91FF.S */ 10643/* File: x86/unused.S */ 10644 jmp common_abort 10645 10646 10647/* ------------------------------ */ 10648.L_OP_UNUSED_92FF: /* 0x192 */ 10649/* File: x86/OP_UNUSED_92FF.S */ 10650/* File: x86/unused.S */ 10651 jmp common_abort 10652 10653 10654/* ------------------------------ */ 10655.L_OP_UNUSED_93FF: /* 0x193 */ 10656/* File: x86/OP_UNUSED_93FF.S */ 10657/* File: x86/unused.S */ 10658 jmp common_abort 10659 10660 10661/* ------------------------------ */ 10662.L_OP_UNUSED_94FF: /* 0x194 */ 10663/* File: x86/OP_UNUSED_94FF.S */ 10664/* File: x86/unused.S */ 10665 jmp common_abort 10666 10667 10668/* ------------------------------ */ 10669.L_OP_UNUSED_95FF: /* 0x195 */ 10670/* File: x86/OP_UNUSED_95FF.S */ 10671/* File: x86/unused.S */ 10672 jmp common_abort 10673 10674 10675/* ------------------------------ */ 10676.L_OP_UNUSED_96FF: /* 0x196 */ 10677/* File: x86/OP_UNUSED_96FF.S */ 10678/* File: x86/unused.S */ 10679 jmp common_abort 10680 10681 10682/* ------------------------------ */ 10683.L_OP_UNUSED_97FF: /* 0x197 */ 10684/* File: x86/OP_UNUSED_97FF.S */ 10685/* File: x86/unused.S */ 10686 jmp common_abort 10687 10688 10689/* ------------------------------ */ 10690.L_OP_UNUSED_98FF: /* 0x198 */ 10691/* File: x86/OP_UNUSED_98FF.S */ 10692/* File: x86/unused.S */ 10693 jmp common_abort 10694 10695 10696/* ------------------------------ */ 10697.L_OP_UNUSED_99FF: /* 0x199 */ 10698/* File: x86/OP_UNUSED_99FF.S */ 10699/* File: x86/unused.S */ 10700 jmp common_abort 10701 10702 10703/* ------------------------------ */ 10704.L_OP_UNUSED_9AFF: /* 0x19a */ 10705/* File: x86/OP_UNUSED_9AFF.S */ 10706/* File: x86/unused.S */ 10707 jmp common_abort 10708 10709 10710/* ------------------------------ */ 10711.L_OP_UNUSED_9BFF: /* 0x19b */ 10712/* File: x86/OP_UNUSED_9BFF.S */ 10713/* File: x86/unused.S */ 10714 jmp common_abort 10715 10716 10717/* ------------------------------ */ 10718.L_OP_UNUSED_9CFF: /* 0x19c */ 10719/* File: x86/OP_UNUSED_9CFF.S */ 10720/* File: x86/unused.S */ 10721 jmp common_abort 10722 10723 10724/* ------------------------------ */ 10725.L_OP_UNUSED_9DFF: /* 0x19d */ 10726/* File: x86/OP_UNUSED_9DFF.S */ 10727/* File: x86/unused.S */ 10728 jmp common_abort 10729 10730 10731/* ------------------------------ */ 10732.L_OP_UNUSED_9EFF: /* 0x19e */ 10733/* File: x86/OP_UNUSED_9EFF.S */ 10734/* File: x86/unused.S */ 10735 jmp common_abort 10736 10737 10738/* ------------------------------ */ 10739.L_OP_UNUSED_9FFF: /* 0x19f */ 10740/* File: x86/OP_UNUSED_9FFF.S */ 10741/* File: x86/unused.S */ 10742 jmp common_abort 10743 10744 10745/* ------------------------------ */ 10746.L_OP_UNUSED_A0FF: /* 0x1a0 */ 10747/* File: x86/OP_UNUSED_A0FF.S */ 10748/* File: x86/unused.S */ 10749 jmp common_abort 10750 10751 10752/* ------------------------------ */ 10753.L_OP_UNUSED_A1FF: /* 0x1a1 */ 10754/* File: x86/OP_UNUSED_A1FF.S */ 10755/* File: x86/unused.S */ 10756 jmp common_abort 10757 10758 10759/* ------------------------------ */ 10760.L_OP_UNUSED_A2FF: /* 0x1a2 */ 10761/* File: x86/OP_UNUSED_A2FF.S */ 10762/* File: x86/unused.S */ 10763 jmp common_abort 10764 10765 10766/* ------------------------------ */ 10767.L_OP_UNUSED_A3FF: /* 0x1a3 */ 10768/* File: x86/OP_UNUSED_A3FF.S */ 10769/* File: x86/unused.S */ 10770 jmp common_abort 10771 10772 10773/* ------------------------------ */ 10774.L_OP_UNUSED_A4FF: /* 0x1a4 */ 10775/* File: x86/OP_UNUSED_A4FF.S */ 10776/* File: x86/unused.S */ 10777 jmp common_abort 10778 10779 10780/* ------------------------------ */ 10781.L_OP_UNUSED_A5FF: /* 0x1a5 */ 10782/* File: x86/OP_UNUSED_A5FF.S */ 10783/* File: x86/unused.S */ 10784 jmp common_abort 10785 10786 10787/* ------------------------------ */ 10788.L_OP_UNUSED_A6FF: /* 0x1a6 */ 10789/* File: x86/OP_UNUSED_A6FF.S */ 10790/* File: x86/unused.S */ 10791 jmp common_abort 10792 10793 10794/* ------------------------------ */ 10795.L_OP_UNUSED_A7FF: /* 0x1a7 */ 10796/* File: x86/OP_UNUSED_A7FF.S */ 10797/* File: x86/unused.S */ 10798 jmp common_abort 10799 10800 10801/* ------------------------------ */ 10802.L_OP_UNUSED_A8FF: /* 0x1a8 */ 10803/* File: x86/OP_UNUSED_A8FF.S */ 10804/* File: x86/unused.S */ 10805 jmp common_abort 10806 10807 10808/* ------------------------------ */ 10809.L_OP_UNUSED_A9FF: /* 0x1a9 */ 10810/* File: x86/OP_UNUSED_A9FF.S */ 10811/* File: x86/unused.S */ 10812 jmp common_abort 10813 10814 10815/* ------------------------------ */ 10816.L_OP_UNUSED_AAFF: /* 0x1aa */ 10817/* File: x86/OP_UNUSED_AAFF.S */ 10818/* File: x86/unused.S */ 10819 jmp common_abort 10820 10821 10822/* ------------------------------ */ 10823.L_OP_UNUSED_ABFF: /* 0x1ab */ 10824/* File: x86/OP_UNUSED_ABFF.S */ 10825/* File: x86/unused.S */ 10826 jmp common_abort 10827 10828 10829/* ------------------------------ */ 10830.L_OP_UNUSED_ACFF: /* 0x1ac */ 10831/* File: x86/OP_UNUSED_ACFF.S */ 10832/* File: x86/unused.S */ 10833 jmp common_abort 10834 10835 10836/* ------------------------------ */ 10837.L_OP_UNUSED_ADFF: /* 0x1ad */ 10838/* File: x86/OP_UNUSED_ADFF.S */ 10839/* File: x86/unused.S */ 10840 jmp common_abort 10841 10842 10843/* ------------------------------ */ 10844.L_OP_UNUSED_AEFF: /* 0x1ae */ 10845/* File: x86/OP_UNUSED_AEFF.S */ 10846/* File: x86/unused.S */ 10847 jmp common_abort 10848 10849 10850/* ------------------------------ */ 10851.L_OP_UNUSED_AFFF: /* 0x1af */ 10852/* File: x86/OP_UNUSED_AFFF.S */ 10853/* File: x86/unused.S */ 10854 jmp common_abort 10855 10856 10857/* ------------------------------ */ 10858.L_OP_UNUSED_B0FF: /* 0x1b0 */ 10859/* File: x86/OP_UNUSED_B0FF.S */ 10860/* File: x86/unused.S */ 10861 jmp common_abort 10862 10863 10864/* ------------------------------ */ 10865.L_OP_UNUSED_B1FF: /* 0x1b1 */ 10866/* File: x86/OP_UNUSED_B1FF.S */ 10867/* File: x86/unused.S */ 10868 jmp common_abort 10869 10870 10871/* ------------------------------ */ 10872.L_OP_UNUSED_B2FF: /* 0x1b2 */ 10873/* File: x86/OP_UNUSED_B2FF.S */ 10874/* File: x86/unused.S */ 10875 jmp common_abort 10876 10877 10878/* ------------------------------ */ 10879.L_OP_UNUSED_B3FF: /* 0x1b3 */ 10880/* File: x86/OP_UNUSED_B3FF.S */ 10881/* File: x86/unused.S */ 10882 jmp common_abort 10883 10884 10885/* ------------------------------ */ 10886.L_OP_UNUSED_B4FF: /* 0x1b4 */ 10887/* File: x86/OP_UNUSED_B4FF.S */ 10888/* File: x86/unused.S */ 10889 jmp common_abort 10890 10891 10892/* ------------------------------ */ 10893.L_OP_UNUSED_B5FF: /* 0x1b5 */ 10894/* File: x86/OP_UNUSED_B5FF.S */ 10895/* File: x86/unused.S */ 10896 jmp common_abort 10897 10898 10899/* ------------------------------ */ 10900.L_OP_UNUSED_B6FF: /* 0x1b6 */ 10901/* File: x86/OP_UNUSED_B6FF.S */ 10902/* File: x86/unused.S */ 10903 jmp common_abort 10904 10905 10906/* ------------------------------ */ 10907.L_OP_UNUSED_B7FF: /* 0x1b7 */ 10908/* File: x86/OP_UNUSED_B7FF.S */ 10909/* File: x86/unused.S */ 10910 jmp common_abort 10911 10912 10913/* ------------------------------ */ 10914.L_OP_UNUSED_B8FF: /* 0x1b8 */ 10915/* File: x86/OP_UNUSED_B8FF.S */ 10916/* File: x86/unused.S */ 10917 jmp common_abort 10918 10919 10920/* ------------------------------ */ 10921.L_OP_UNUSED_B9FF: /* 0x1b9 */ 10922/* File: x86/OP_UNUSED_B9FF.S */ 10923/* File: x86/unused.S */ 10924 jmp common_abort 10925 10926 10927/* ------------------------------ */ 10928.L_OP_UNUSED_BAFF: /* 0x1ba */ 10929/* File: x86/OP_UNUSED_BAFF.S */ 10930/* File: x86/unused.S */ 10931 jmp common_abort 10932 10933 10934/* ------------------------------ */ 10935.L_OP_UNUSED_BBFF: /* 0x1bb */ 10936/* File: x86/OP_UNUSED_BBFF.S */ 10937/* File: x86/unused.S */ 10938 jmp common_abort 10939 10940 10941/* ------------------------------ */ 10942.L_OP_UNUSED_BCFF: /* 0x1bc */ 10943/* File: x86/OP_UNUSED_BCFF.S */ 10944/* File: x86/unused.S */ 10945 jmp common_abort 10946 10947 10948/* ------------------------------ */ 10949.L_OP_UNUSED_BDFF: /* 0x1bd */ 10950/* File: x86/OP_UNUSED_BDFF.S */ 10951/* File: x86/unused.S */ 10952 jmp common_abort 10953 10954 10955/* ------------------------------ */ 10956.L_OP_UNUSED_BEFF: /* 0x1be */ 10957/* File: x86/OP_UNUSED_BEFF.S */ 10958/* File: x86/unused.S */ 10959 jmp common_abort 10960 10961 10962/* ------------------------------ */ 10963.L_OP_UNUSED_BFFF: /* 0x1bf */ 10964/* File: x86/OP_UNUSED_BFFF.S */ 10965/* File: x86/unused.S */ 10966 jmp common_abort 10967 10968 10969/* ------------------------------ */ 10970.L_OP_UNUSED_C0FF: /* 0x1c0 */ 10971/* File: x86/OP_UNUSED_C0FF.S */ 10972/* File: x86/unused.S */ 10973 jmp common_abort 10974 10975 10976/* ------------------------------ */ 10977.L_OP_UNUSED_C1FF: /* 0x1c1 */ 10978/* File: x86/OP_UNUSED_C1FF.S */ 10979/* File: x86/unused.S */ 10980 jmp common_abort 10981 10982 10983/* ------------------------------ */ 10984.L_OP_UNUSED_C2FF: /* 0x1c2 */ 10985/* File: x86/OP_UNUSED_C2FF.S */ 10986/* File: x86/unused.S */ 10987 jmp common_abort 10988 10989 10990/* ------------------------------ */ 10991.L_OP_UNUSED_C3FF: /* 0x1c3 */ 10992/* File: x86/OP_UNUSED_C3FF.S */ 10993/* File: x86/unused.S */ 10994 jmp common_abort 10995 10996 10997/* ------------------------------ */ 10998.L_OP_UNUSED_C4FF: /* 0x1c4 */ 10999/* File: x86/OP_UNUSED_C4FF.S */ 11000/* File: x86/unused.S */ 11001 jmp common_abort 11002 11003 11004/* ------------------------------ */ 11005.L_OP_UNUSED_C5FF: /* 0x1c5 */ 11006/* File: x86/OP_UNUSED_C5FF.S */ 11007/* File: x86/unused.S */ 11008 jmp common_abort 11009 11010 11011/* ------------------------------ */ 11012.L_OP_UNUSED_C6FF: /* 0x1c6 */ 11013/* File: x86/OP_UNUSED_C6FF.S */ 11014/* File: x86/unused.S */ 11015 jmp common_abort 11016 11017 11018/* ------------------------------ */ 11019.L_OP_UNUSED_C7FF: /* 0x1c7 */ 11020/* File: x86/OP_UNUSED_C7FF.S */ 11021/* File: x86/unused.S */ 11022 jmp common_abort 11023 11024 11025/* ------------------------------ */ 11026.L_OP_UNUSED_C8FF: /* 0x1c8 */ 11027/* File: x86/OP_UNUSED_C8FF.S */ 11028/* File: x86/unused.S */ 11029 jmp common_abort 11030 11031 11032/* ------------------------------ */ 11033.L_OP_UNUSED_C9FF: /* 0x1c9 */ 11034/* File: x86/OP_UNUSED_C9FF.S */ 11035/* File: x86/unused.S */ 11036 jmp common_abort 11037 11038 11039/* ------------------------------ */ 11040.L_OP_UNUSED_CAFF: /* 0x1ca */ 11041/* File: x86/OP_UNUSED_CAFF.S */ 11042/* File: x86/unused.S */ 11043 jmp common_abort 11044 11045 11046/* ------------------------------ */ 11047.L_OP_UNUSED_CBFF: /* 0x1cb */ 11048/* File: x86/OP_UNUSED_CBFF.S */ 11049/* File: x86/unused.S */ 11050 jmp common_abort 11051 11052 11053/* ------------------------------ */ 11054.L_OP_UNUSED_CCFF: /* 0x1cc */ 11055/* File: x86/OP_UNUSED_CCFF.S */ 11056/* File: x86/unused.S */ 11057 jmp common_abort 11058 11059 11060/* ------------------------------ */ 11061.L_OP_UNUSED_CDFF: /* 0x1cd */ 11062/* File: x86/OP_UNUSED_CDFF.S */ 11063/* File: x86/unused.S */ 11064 jmp common_abort 11065 11066 11067/* ------------------------------ */ 11068.L_OP_UNUSED_CEFF: /* 0x1ce */ 11069/* File: x86/OP_UNUSED_CEFF.S */ 11070/* File: x86/unused.S */ 11071 jmp common_abort 11072 11073 11074/* ------------------------------ */ 11075.L_OP_UNUSED_CFFF: /* 0x1cf */ 11076/* File: x86/OP_UNUSED_CFFF.S */ 11077/* File: x86/unused.S */ 11078 jmp common_abort 11079 11080 11081/* ------------------------------ */ 11082.L_OP_UNUSED_D0FF: /* 0x1d0 */ 11083/* File: x86/OP_UNUSED_D0FF.S */ 11084/* File: x86/unused.S */ 11085 jmp common_abort 11086 11087 11088/* ------------------------------ */ 11089.L_OP_UNUSED_D1FF: /* 0x1d1 */ 11090/* File: x86/OP_UNUSED_D1FF.S */ 11091/* File: x86/unused.S */ 11092 jmp common_abort 11093 11094 11095/* ------------------------------ */ 11096.L_OP_UNUSED_D2FF: /* 0x1d2 */ 11097/* File: x86/OP_UNUSED_D2FF.S */ 11098/* File: x86/unused.S */ 11099 jmp common_abort 11100 11101 11102/* ------------------------------ */ 11103.L_OP_UNUSED_D3FF: /* 0x1d3 */ 11104/* File: x86/OP_UNUSED_D3FF.S */ 11105/* File: x86/unused.S */ 11106 jmp common_abort 11107 11108 11109/* ------------------------------ */ 11110.L_OP_UNUSED_D4FF: /* 0x1d4 */ 11111/* File: x86/OP_UNUSED_D4FF.S */ 11112/* File: x86/unused.S */ 11113 jmp common_abort 11114 11115 11116/* ------------------------------ */ 11117.L_OP_UNUSED_D5FF: /* 0x1d5 */ 11118/* File: x86/OP_UNUSED_D5FF.S */ 11119/* File: x86/unused.S */ 11120 jmp common_abort 11121 11122 11123/* ------------------------------ */ 11124.L_OP_UNUSED_D6FF: /* 0x1d6 */ 11125/* File: x86/OP_UNUSED_D6FF.S */ 11126/* File: x86/unused.S */ 11127 jmp common_abort 11128 11129 11130/* ------------------------------ */ 11131.L_OP_UNUSED_D7FF: /* 0x1d7 */ 11132/* File: x86/OP_UNUSED_D7FF.S */ 11133/* File: x86/unused.S */ 11134 jmp common_abort 11135 11136 11137/* ------------------------------ */ 11138.L_OP_UNUSED_D8FF: /* 0x1d8 */ 11139/* File: x86/OP_UNUSED_D8FF.S */ 11140/* File: x86/unused.S */ 11141 jmp common_abort 11142 11143 11144/* ------------------------------ */ 11145.L_OP_UNUSED_D9FF: /* 0x1d9 */ 11146/* File: x86/OP_UNUSED_D9FF.S */ 11147/* File: x86/unused.S */ 11148 jmp common_abort 11149 11150 11151/* ------------------------------ */ 11152.L_OP_UNUSED_DAFF: /* 0x1da */ 11153/* File: x86/OP_UNUSED_DAFF.S */ 11154/* File: x86/unused.S */ 11155 jmp common_abort 11156 11157 11158/* ------------------------------ */ 11159.L_OP_UNUSED_DBFF: /* 0x1db */ 11160/* File: x86/OP_UNUSED_DBFF.S */ 11161/* File: x86/unused.S */ 11162 jmp common_abort 11163 11164 11165/* ------------------------------ */ 11166.L_OP_UNUSED_DCFF: /* 0x1dc */ 11167/* File: x86/OP_UNUSED_DCFF.S */ 11168/* File: x86/unused.S */ 11169 jmp common_abort 11170 11171 11172/* ------------------------------ */ 11173.L_OP_UNUSED_DDFF: /* 0x1dd */ 11174/* File: x86/OP_UNUSED_DDFF.S */ 11175/* File: x86/unused.S */ 11176 jmp common_abort 11177 11178 11179/* ------------------------------ */ 11180.L_OP_UNUSED_DEFF: /* 0x1de */ 11181/* File: x86/OP_UNUSED_DEFF.S */ 11182/* File: x86/unused.S */ 11183 jmp common_abort 11184 11185 11186/* ------------------------------ */ 11187.L_OP_UNUSED_DFFF: /* 0x1df */ 11188/* File: x86/OP_UNUSED_DFFF.S */ 11189/* File: x86/unused.S */ 11190 jmp common_abort 11191 11192 11193/* ------------------------------ */ 11194.L_OP_UNUSED_E0FF: /* 0x1e0 */ 11195/* File: x86/OP_UNUSED_E0FF.S */ 11196/* File: x86/unused.S */ 11197 jmp common_abort 11198 11199 11200/* ------------------------------ */ 11201.L_OP_UNUSED_E1FF: /* 0x1e1 */ 11202/* File: x86/OP_UNUSED_E1FF.S */ 11203/* File: x86/unused.S */ 11204 jmp common_abort 11205 11206 11207/* ------------------------------ */ 11208.L_OP_UNUSED_E2FF: /* 0x1e2 */ 11209/* File: x86/OP_UNUSED_E2FF.S */ 11210/* File: x86/unused.S */ 11211 jmp common_abort 11212 11213 11214/* ------------------------------ */ 11215.L_OP_UNUSED_E3FF: /* 0x1e3 */ 11216/* File: x86/OP_UNUSED_E3FF.S */ 11217/* File: x86/unused.S */ 11218 jmp common_abort 11219 11220 11221/* ------------------------------ */ 11222.L_OP_UNUSED_E4FF: /* 0x1e4 */ 11223/* File: x86/OP_UNUSED_E4FF.S */ 11224/* File: x86/unused.S */ 11225 jmp common_abort 11226 11227 11228/* ------------------------------ */ 11229.L_OP_UNUSED_E5FF: /* 0x1e5 */ 11230/* File: x86/OP_UNUSED_E5FF.S */ 11231/* File: x86/unused.S */ 11232 jmp common_abort 11233 11234 11235/* ------------------------------ */ 11236.L_OP_UNUSED_E6FF: /* 0x1e6 */ 11237/* File: x86/OP_UNUSED_E6FF.S */ 11238/* File: x86/unused.S */ 11239 jmp common_abort 11240 11241 11242/* ------------------------------ */ 11243.L_OP_UNUSED_E7FF: /* 0x1e7 */ 11244/* File: x86/OP_UNUSED_E7FF.S */ 11245/* File: x86/unused.S */ 11246 jmp common_abort 11247 11248 11249/* ------------------------------ */ 11250.L_OP_UNUSED_E8FF: /* 0x1e8 */ 11251/* File: x86/OP_UNUSED_E8FF.S */ 11252/* File: x86/unused.S */ 11253 jmp common_abort 11254 11255 11256/* ------------------------------ */ 11257.L_OP_UNUSED_E9FF: /* 0x1e9 */ 11258/* File: x86/OP_UNUSED_E9FF.S */ 11259/* File: x86/unused.S */ 11260 jmp common_abort 11261 11262 11263/* ------------------------------ */ 11264.L_OP_UNUSED_EAFF: /* 0x1ea */ 11265/* File: x86/OP_UNUSED_EAFF.S */ 11266/* File: x86/unused.S */ 11267 jmp common_abort 11268 11269 11270/* ------------------------------ */ 11271.L_OP_UNUSED_EBFF: /* 0x1eb */ 11272/* File: x86/OP_UNUSED_EBFF.S */ 11273/* File: x86/unused.S */ 11274 jmp common_abort 11275 11276 11277/* ------------------------------ */ 11278.L_OP_UNUSED_ECFF: /* 0x1ec */ 11279/* File: x86/OP_UNUSED_ECFF.S */ 11280/* File: x86/unused.S */ 11281 jmp common_abort 11282 11283 11284/* ------------------------------ */ 11285.L_OP_UNUSED_EDFF: /* 0x1ed */ 11286/* File: x86/OP_UNUSED_EDFF.S */ 11287/* File: x86/unused.S */ 11288 jmp common_abort 11289 11290 11291/* ------------------------------ */ 11292.L_OP_UNUSED_EEFF: /* 0x1ee */ 11293/* File: x86/OP_UNUSED_EEFF.S */ 11294/* File: x86/unused.S */ 11295 jmp common_abort 11296 11297 11298/* ------------------------------ */ 11299.L_OP_UNUSED_EFFF: /* 0x1ef */ 11300/* File: x86/OP_UNUSED_EFFF.S */ 11301/* File: x86/unused.S */ 11302 jmp common_abort 11303 11304 11305/* ------------------------------ */ 11306.L_OP_UNUSED_F0FF: /* 0x1f0 */ 11307/* File: x86/OP_UNUSED_F0FF.S */ 11308/* File: x86/unused.S */ 11309 jmp common_abort 11310 11311 11312/* ------------------------------ */ 11313.L_OP_UNUSED_F1FF: /* 0x1f1 */ 11314/* File: x86/OP_UNUSED_F1FF.S */ 11315/* File: x86/unused.S */ 11316 jmp common_abort 11317 11318 11319/* ------------------------------ */ 11320.L_OP_INVOKE_OBJECT_INIT_JUMBO: /* 0x1f2 */ 11321 /* (stub) */ 11322 SAVE_PC_FP_TO_SELF %ecx # leaves rSELF in %ecx 11323 movl %ecx,OUT_ARG0(%esp) # self is first arg to function 11324 call dvmMterp_OP_INVOKE_OBJECT_INIT_JUMBO # do the real work 11325 movl rSELF,%ecx 11326 LOAD_PC_FP_FROM_SELF # retrieve updated values 11327 movl offThread_curHandlerTable(%ecx),rIBASE # set up rIBASE 11328 FETCH_INST 11329 GOTO_NEXT 11330/* ------------------------------ */ 11331.L_OP_IGET_VOLATILE_JUMBO: /* 0x1f3 */ 11332 /* (stub) */ 11333 SAVE_PC_FP_TO_SELF %ecx # leaves rSELF in %ecx 11334 movl %ecx,OUT_ARG0(%esp) # self is first arg to function 11335 call dvmMterp_OP_IGET_VOLATILE_JUMBO # do the real work 11336 movl rSELF,%ecx 11337 LOAD_PC_FP_FROM_SELF # retrieve updated values 11338 movl offThread_curHandlerTable(%ecx),rIBASE # set up rIBASE 11339 FETCH_INST 11340 GOTO_NEXT 11341/* ------------------------------ */ 11342.L_OP_IGET_WIDE_VOLATILE_JUMBO: /* 0x1f4 */ 11343 /* (stub) */ 11344 SAVE_PC_FP_TO_SELF %ecx # leaves rSELF in %ecx 11345 movl %ecx,OUT_ARG0(%esp) # self is first arg to function 11346 call dvmMterp_OP_IGET_WIDE_VOLATILE_JUMBO # do the real work 11347 movl rSELF,%ecx 11348 LOAD_PC_FP_FROM_SELF # retrieve updated values 11349 movl offThread_curHandlerTable(%ecx),rIBASE # set up rIBASE 11350 FETCH_INST 11351 GOTO_NEXT 11352/* ------------------------------ */ 11353.L_OP_IGET_OBJECT_VOLATILE_JUMBO: /* 0x1f5 */ 11354 /* (stub) */ 11355 SAVE_PC_FP_TO_SELF %ecx # leaves rSELF in %ecx 11356 movl %ecx,OUT_ARG0(%esp) # self is first arg to function 11357 call dvmMterp_OP_IGET_OBJECT_VOLATILE_JUMBO # do the real work 11358 movl rSELF,%ecx 11359 LOAD_PC_FP_FROM_SELF # retrieve updated values 11360 movl offThread_curHandlerTable(%ecx),rIBASE # set up rIBASE 11361 FETCH_INST 11362 GOTO_NEXT 11363/* ------------------------------ */ 11364.L_OP_IPUT_VOLATILE_JUMBO: /* 0x1f6 */ 11365 /* (stub) */ 11366 SAVE_PC_FP_TO_SELF %ecx # leaves rSELF in %ecx 11367 movl %ecx,OUT_ARG0(%esp) # self is first arg to function 11368 call dvmMterp_OP_IPUT_VOLATILE_JUMBO # do the real work 11369 movl rSELF,%ecx 11370 LOAD_PC_FP_FROM_SELF # retrieve updated values 11371 movl offThread_curHandlerTable(%ecx),rIBASE # set up rIBASE 11372 FETCH_INST 11373 GOTO_NEXT 11374/* ------------------------------ */ 11375.L_OP_IPUT_WIDE_VOLATILE_JUMBO: /* 0x1f7 */ 11376 /* (stub) */ 11377 SAVE_PC_FP_TO_SELF %ecx # leaves rSELF in %ecx 11378 movl %ecx,OUT_ARG0(%esp) # self is first arg to function 11379 call dvmMterp_OP_IPUT_WIDE_VOLATILE_JUMBO # do the real work 11380 movl rSELF,%ecx 11381 LOAD_PC_FP_FROM_SELF # retrieve updated values 11382 movl offThread_curHandlerTable(%ecx),rIBASE # set up rIBASE 11383 FETCH_INST 11384 GOTO_NEXT 11385/* ------------------------------ */ 11386.L_OP_IPUT_OBJECT_VOLATILE_JUMBO: /* 0x1f8 */ 11387 /* (stub) */ 11388 SAVE_PC_FP_TO_SELF %ecx # leaves rSELF in %ecx 11389 movl %ecx,OUT_ARG0(%esp) # self is first arg to function 11390 call dvmMterp_OP_IPUT_OBJECT_VOLATILE_JUMBO # do the real work 11391 movl rSELF,%ecx 11392 LOAD_PC_FP_FROM_SELF # retrieve updated values 11393 movl offThread_curHandlerTable(%ecx),rIBASE # set up rIBASE 11394 FETCH_INST 11395 GOTO_NEXT 11396/* ------------------------------ */ 11397.L_OP_SGET_VOLATILE_JUMBO: /* 0x1f9 */ 11398 /* (stub) */ 11399 SAVE_PC_FP_TO_SELF %ecx # leaves rSELF in %ecx 11400 movl %ecx,OUT_ARG0(%esp) # self is first arg to function 11401 call dvmMterp_OP_SGET_VOLATILE_JUMBO # do the real work 11402 movl rSELF,%ecx 11403 LOAD_PC_FP_FROM_SELF # retrieve updated values 11404 movl offThread_curHandlerTable(%ecx),rIBASE # set up rIBASE 11405 FETCH_INST 11406 GOTO_NEXT 11407/* ------------------------------ */ 11408.L_OP_SGET_WIDE_VOLATILE_JUMBO: /* 0x1fa */ 11409 /* (stub) */ 11410 SAVE_PC_FP_TO_SELF %ecx # leaves rSELF in %ecx 11411 movl %ecx,OUT_ARG0(%esp) # self is first arg to function 11412 call dvmMterp_OP_SGET_WIDE_VOLATILE_JUMBO # do the real work 11413 movl rSELF,%ecx 11414 LOAD_PC_FP_FROM_SELF # retrieve updated values 11415 movl offThread_curHandlerTable(%ecx),rIBASE # set up rIBASE 11416 FETCH_INST 11417 GOTO_NEXT 11418/* ------------------------------ */ 11419.L_OP_SGET_OBJECT_VOLATILE_JUMBO: /* 0x1fb */ 11420 /* (stub) */ 11421 SAVE_PC_FP_TO_SELF %ecx # leaves rSELF in %ecx 11422 movl %ecx,OUT_ARG0(%esp) # self is first arg to function 11423 call dvmMterp_OP_SGET_OBJECT_VOLATILE_JUMBO # do the real work 11424 movl rSELF,%ecx 11425 LOAD_PC_FP_FROM_SELF # retrieve updated values 11426 movl offThread_curHandlerTable(%ecx),rIBASE # set up rIBASE 11427 FETCH_INST 11428 GOTO_NEXT 11429/* ------------------------------ */ 11430.L_OP_SPUT_VOLATILE_JUMBO: /* 0x1fc */ 11431 /* (stub) */ 11432 SAVE_PC_FP_TO_SELF %ecx # leaves rSELF in %ecx 11433 movl %ecx,OUT_ARG0(%esp) # self is first arg to function 11434 call dvmMterp_OP_SPUT_VOLATILE_JUMBO # do the real work 11435 movl rSELF,%ecx 11436 LOAD_PC_FP_FROM_SELF # retrieve updated values 11437 movl offThread_curHandlerTable(%ecx),rIBASE # set up rIBASE 11438 FETCH_INST 11439 GOTO_NEXT 11440/* ------------------------------ */ 11441.L_OP_SPUT_WIDE_VOLATILE_JUMBO: /* 0x1fd */ 11442 /* (stub) */ 11443 SAVE_PC_FP_TO_SELF %ecx # leaves rSELF in %ecx 11444 movl %ecx,OUT_ARG0(%esp) # self is first arg to function 11445 call dvmMterp_OP_SPUT_WIDE_VOLATILE_JUMBO # do the real work 11446 movl rSELF,%ecx 11447 LOAD_PC_FP_FROM_SELF # retrieve updated values 11448 movl offThread_curHandlerTable(%ecx),rIBASE # set up rIBASE 11449 FETCH_INST 11450 GOTO_NEXT 11451/* ------------------------------ */ 11452.L_OP_SPUT_OBJECT_VOLATILE_JUMBO: /* 0x1fe */ 11453 /* (stub) */ 11454 SAVE_PC_FP_TO_SELF %ecx # leaves rSELF in %ecx 11455 movl %ecx,OUT_ARG0(%esp) # self is first arg to function 11456 call dvmMterp_OP_SPUT_OBJECT_VOLATILE_JUMBO # do the real work 11457 movl rSELF,%ecx 11458 LOAD_PC_FP_FROM_SELF # retrieve updated values 11459 movl offThread_curHandlerTable(%ecx),rIBASE # set up rIBASE 11460 FETCH_INST 11461 GOTO_NEXT 11462/* ------------------------------ */ 11463.L_OP_THROW_VERIFICATION_ERROR_JUMBO: /* 0x1ff */ 11464/* File: x86/OP_THROW_VERIFICATION_ERROR_JUMBO.S */ 11465 /* 11466 * Handle a jumbo throw-verification-error instruction. This throws an 11467 * exception for an error discovered during verification. The 11468 * exception is indicated by BBBB, with some detail provided by AAAAAAAA. 11469 */ 11470 /* exop BBBB, ref@AAAAAAAA */ 11471 movl rSELF,%ecx 11472 movl 2(rPC),%eax # eax<- AAAAAAAA 11473 movl offThread_method(%ecx),%ecx # ecx<- self->method 11474 EXPORT_PC 11475 movl %eax,OUT_ARG2(%esp) # arg2<- AAAAAAAA 11476 movl rINST,OUT_ARG1(%esp) # arg1<- BBBB 11477 movl %ecx,OUT_ARG0(%esp) # arg0<- method 11478 call dvmThrowVerificationError # call(method, kind, ref) 11479 jmp common_exceptionThrown # handle exception 11480 11481 .size dvmAsmInstructionStartCode, .-dvmAsmInstructionStartCode 11482 .global dvmAsmInstructionEndCode 11483dvmAsmInstructionEndCode: 11484 11485 .global dvmAsmAltInstructionStartCode 11486 .type dvmAsmAltInstructionStartCode, %function 11487 .text 11488 11489dvmAsmAltInstructionStartCode = .L_ALT_OP_NOP 11490/* ------------------------------ */ 11491.L_ALT_OP_NOP: /* 0x00 */ 11492/* File: x86/alt_stub.S */ 11493/* 11494 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 11495 * any interesting requests and then jump to the real instruction 11496 * handler. Unlike the Arm handler, we can't do this as a tail call 11497 * because rIBASE is caller save and we need to reload it. 11498 * 11499 * Note that unlike in the Arm implementation, we should never arrive 11500 * here with a zero breakFlag because we always refresh rIBASE on 11501 * return. 11502 */ 11503 EXPORT_PC 11504 movl rSELF, %eax 11505 movl rPC, OUT_ARG0(%esp) 11506 cmpb $0,offThread_breakFlags(%eax) # anything to do? 11507 movl rFP, OUT_ARG1(%esp) 11508 je 1f # reload rIBASE & resume if not 11509 movl %eax, OUT_ARG2(%esp) 11510 call dvmCheckBefore # (dPC, dFP, self) 11511 movl rSELF, %eax 115121: 11513 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 11514 jmp *dvmAsmInstructionStart+(0*4) 11515 11516/* ------------------------------ */ 11517.L_ALT_OP_MOVE: /* 0x01 */ 11518/* File: x86/alt_stub.S */ 11519/* 11520 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 11521 * any interesting requests and then jump to the real instruction 11522 * handler. Unlike the Arm handler, we can't do this as a tail call 11523 * because rIBASE is caller save and we need to reload it. 11524 * 11525 * Note that unlike in the Arm implementation, we should never arrive 11526 * here with a zero breakFlag because we always refresh rIBASE on 11527 * return. 11528 */ 11529 EXPORT_PC 11530 movl rSELF, %eax 11531 movl rPC, OUT_ARG0(%esp) 11532 cmpb $0,offThread_breakFlags(%eax) # anything to do? 11533 movl rFP, OUT_ARG1(%esp) 11534 je 1f # reload rIBASE & resume if not 11535 movl %eax, OUT_ARG2(%esp) 11536 call dvmCheckBefore # (dPC, dFP, self) 11537 movl rSELF, %eax 115381: 11539 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 11540 jmp *dvmAsmInstructionStart+(1*4) 11541 11542/* ------------------------------ */ 11543.L_ALT_OP_MOVE_FROM16: /* 0x02 */ 11544/* File: x86/alt_stub.S */ 11545/* 11546 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 11547 * any interesting requests and then jump to the real instruction 11548 * handler. Unlike the Arm handler, we can't do this as a tail call 11549 * because rIBASE is caller save and we need to reload it. 11550 * 11551 * Note that unlike in the Arm implementation, we should never arrive 11552 * here with a zero breakFlag because we always refresh rIBASE on 11553 * return. 11554 */ 11555 EXPORT_PC 11556 movl rSELF, %eax 11557 movl rPC, OUT_ARG0(%esp) 11558 cmpb $0,offThread_breakFlags(%eax) # anything to do? 11559 movl rFP, OUT_ARG1(%esp) 11560 je 1f # reload rIBASE & resume if not 11561 movl %eax, OUT_ARG2(%esp) 11562 call dvmCheckBefore # (dPC, dFP, self) 11563 movl rSELF, %eax 115641: 11565 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 11566 jmp *dvmAsmInstructionStart+(2*4) 11567 11568/* ------------------------------ */ 11569.L_ALT_OP_MOVE_16: /* 0x03 */ 11570/* File: x86/alt_stub.S */ 11571/* 11572 * Inter-instruction transfer stub. Call out to dvmCheckBefore 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 * Note that unlike in the Arm implementation, we should never arrive 11578 * here with a zero breakFlag because we always refresh rIBASE on 11579 * return. 11580 */ 11581 EXPORT_PC 11582 movl rSELF, %eax 11583 movl rPC, OUT_ARG0(%esp) 11584 cmpb $0,offThread_breakFlags(%eax) # anything to do? 11585 movl rFP, OUT_ARG1(%esp) 11586 je 1f # reload rIBASE & resume if not 11587 movl %eax, OUT_ARG2(%esp) 11588 call dvmCheckBefore # (dPC, dFP, self) 11589 movl rSELF, %eax 115901: 11591 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 11592 jmp *dvmAsmInstructionStart+(3*4) 11593 11594/* ------------------------------ */ 11595.L_ALT_OP_MOVE_WIDE: /* 0x04 */ 11596/* File: x86/alt_stub.S */ 11597/* 11598 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 11599 * any interesting requests and then jump to the real instruction 11600 * handler. Unlike the Arm handler, we can't do this as a tail call 11601 * because rIBASE is caller save and we need to reload it. 11602 * 11603 * Note that unlike in the Arm implementation, we should never arrive 11604 * here with a zero breakFlag because we always refresh rIBASE on 11605 * return. 11606 */ 11607 EXPORT_PC 11608 movl rSELF, %eax 11609 movl rPC, OUT_ARG0(%esp) 11610 cmpb $0,offThread_breakFlags(%eax) # anything to do? 11611 movl rFP, OUT_ARG1(%esp) 11612 je 1f # reload rIBASE & resume if not 11613 movl %eax, OUT_ARG2(%esp) 11614 call dvmCheckBefore # (dPC, dFP, self) 11615 movl rSELF, %eax 116161: 11617 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 11618 jmp *dvmAsmInstructionStart+(4*4) 11619 11620/* ------------------------------ */ 11621.L_ALT_OP_MOVE_WIDE_FROM16: /* 0x05 */ 11622/* File: x86/alt_stub.S */ 11623/* 11624 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 11625 * any interesting requests and then jump to the real instruction 11626 * handler. Unlike the Arm handler, we can't do this as a tail call 11627 * because rIBASE is caller save and we need to reload it. 11628 * 11629 * Note that unlike in the Arm implementation, we should never arrive 11630 * here with a zero breakFlag because we always refresh rIBASE on 11631 * return. 11632 */ 11633 EXPORT_PC 11634 movl rSELF, %eax 11635 movl rPC, OUT_ARG0(%esp) 11636 cmpb $0,offThread_breakFlags(%eax) # anything to do? 11637 movl rFP, OUT_ARG1(%esp) 11638 je 1f # reload rIBASE & resume if not 11639 movl %eax, OUT_ARG2(%esp) 11640 call dvmCheckBefore # (dPC, dFP, self) 11641 movl rSELF, %eax 116421: 11643 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 11644 jmp *dvmAsmInstructionStart+(5*4) 11645 11646/* ------------------------------ */ 11647.L_ALT_OP_MOVE_WIDE_16: /* 0x06 */ 11648/* File: x86/alt_stub.S */ 11649/* 11650 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 11651 * any interesting requests and then jump to the real instruction 11652 * handler. Unlike the Arm handler, we can't do this as a tail call 11653 * because rIBASE is caller save and we need to reload it. 11654 * 11655 * Note that unlike in the Arm implementation, we should never arrive 11656 * here with a zero breakFlag because we always refresh rIBASE on 11657 * return. 11658 */ 11659 EXPORT_PC 11660 movl rSELF, %eax 11661 movl rPC, OUT_ARG0(%esp) 11662 cmpb $0,offThread_breakFlags(%eax) # anything to do? 11663 movl rFP, OUT_ARG1(%esp) 11664 je 1f # reload rIBASE & resume if not 11665 movl %eax, OUT_ARG2(%esp) 11666 call dvmCheckBefore # (dPC, dFP, self) 11667 movl rSELF, %eax 116681: 11669 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 11670 jmp *dvmAsmInstructionStart+(6*4) 11671 11672/* ------------------------------ */ 11673.L_ALT_OP_MOVE_OBJECT: /* 0x07 */ 11674/* File: x86/alt_stub.S */ 11675/* 11676 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 11677 * any interesting requests and then jump to the real instruction 11678 * handler. Unlike the Arm handler, we can't do this as a tail call 11679 * because rIBASE is caller save and we need to reload it. 11680 * 11681 * Note that unlike in the Arm implementation, we should never arrive 11682 * here with a zero breakFlag because we always refresh rIBASE on 11683 * return. 11684 */ 11685 EXPORT_PC 11686 movl rSELF, %eax 11687 movl rPC, OUT_ARG0(%esp) 11688 cmpb $0,offThread_breakFlags(%eax) # anything to do? 11689 movl rFP, OUT_ARG1(%esp) 11690 je 1f # reload rIBASE & resume if not 11691 movl %eax, OUT_ARG2(%esp) 11692 call dvmCheckBefore # (dPC, dFP, self) 11693 movl rSELF, %eax 116941: 11695 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 11696 jmp *dvmAsmInstructionStart+(7*4) 11697 11698/* ------------------------------ */ 11699.L_ALT_OP_MOVE_OBJECT_FROM16: /* 0x08 */ 11700/* File: x86/alt_stub.S */ 11701/* 11702 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 11703 * any interesting requests and then jump to the real instruction 11704 * handler. Unlike the Arm handler, we can't do this as a tail call 11705 * because rIBASE is caller save and we need to reload it. 11706 * 11707 * Note that unlike in the Arm implementation, we should never arrive 11708 * here with a zero breakFlag because we always refresh rIBASE on 11709 * return. 11710 */ 11711 EXPORT_PC 11712 movl rSELF, %eax 11713 movl rPC, OUT_ARG0(%esp) 11714 cmpb $0,offThread_breakFlags(%eax) # anything to do? 11715 movl rFP, OUT_ARG1(%esp) 11716 je 1f # reload rIBASE & resume if not 11717 movl %eax, OUT_ARG2(%esp) 11718 call dvmCheckBefore # (dPC, dFP, self) 11719 movl rSELF, %eax 117201: 11721 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 11722 jmp *dvmAsmInstructionStart+(8*4) 11723 11724/* ------------------------------ */ 11725.L_ALT_OP_MOVE_OBJECT_16: /* 0x09 */ 11726/* File: x86/alt_stub.S */ 11727/* 11728 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 11729 * any interesting requests and then jump to the real instruction 11730 * handler. Unlike the Arm handler, we can't do this as a tail call 11731 * because rIBASE is caller save and we need to reload it. 11732 * 11733 * Note that unlike in the Arm implementation, we should never arrive 11734 * here with a zero breakFlag because we always refresh rIBASE on 11735 * return. 11736 */ 11737 EXPORT_PC 11738 movl rSELF, %eax 11739 movl rPC, OUT_ARG0(%esp) 11740 cmpb $0,offThread_breakFlags(%eax) # anything to do? 11741 movl rFP, OUT_ARG1(%esp) 11742 je 1f # reload rIBASE & resume if not 11743 movl %eax, OUT_ARG2(%esp) 11744 call dvmCheckBefore # (dPC, dFP, self) 11745 movl rSELF, %eax 117461: 11747 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 11748 jmp *dvmAsmInstructionStart+(9*4) 11749 11750/* ------------------------------ */ 11751.L_ALT_OP_MOVE_RESULT: /* 0x0a */ 11752/* File: x86/alt_stub.S */ 11753/* 11754 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 11755 * any interesting requests and then jump to the real instruction 11756 * handler. Unlike the Arm handler, we can't do this as a tail call 11757 * because rIBASE is caller save and we need to reload it. 11758 * 11759 * Note that unlike in the Arm implementation, we should never arrive 11760 * here with a zero breakFlag because we always refresh rIBASE on 11761 * return. 11762 */ 11763 EXPORT_PC 11764 movl rSELF, %eax 11765 movl rPC, OUT_ARG0(%esp) 11766 cmpb $0,offThread_breakFlags(%eax) # anything to do? 11767 movl rFP, OUT_ARG1(%esp) 11768 je 1f # reload rIBASE & resume if not 11769 movl %eax, OUT_ARG2(%esp) 11770 call dvmCheckBefore # (dPC, dFP, self) 11771 movl rSELF, %eax 117721: 11773 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 11774 jmp *dvmAsmInstructionStart+(10*4) 11775 11776/* ------------------------------ */ 11777.L_ALT_OP_MOVE_RESULT_WIDE: /* 0x0b */ 11778/* File: x86/alt_stub.S */ 11779/* 11780 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 11781 * any interesting requests and then jump to the real instruction 11782 * handler. Unlike the Arm handler, we can't do this as a tail call 11783 * because rIBASE is caller save and we need to reload it. 11784 * 11785 * Note that unlike in the Arm implementation, we should never arrive 11786 * here with a zero breakFlag because we always refresh rIBASE on 11787 * return. 11788 */ 11789 EXPORT_PC 11790 movl rSELF, %eax 11791 movl rPC, OUT_ARG0(%esp) 11792 cmpb $0,offThread_breakFlags(%eax) # anything to do? 11793 movl rFP, OUT_ARG1(%esp) 11794 je 1f # reload rIBASE & resume if not 11795 movl %eax, OUT_ARG2(%esp) 11796 call dvmCheckBefore # (dPC, dFP, self) 11797 movl rSELF, %eax 117981: 11799 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 11800 jmp *dvmAsmInstructionStart+(11*4) 11801 11802/* ------------------------------ */ 11803.L_ALT_OP_MOVE_RESULT_OBJECT: /* 0x0c */ 11804/* File: x86/alt_stub.S */ 11805/* 11806 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 11807 * any interesting requests and then jump to the real instruction 11808 * handler. Unlike the Arm handler, we can't do this as a tail call 11809 * because rIBASE is caller save and we need to reload it. 11810 * 11811 * Note that unlike in the Arm implementation, we should never arrive 11812 * here with a zero breakFlag because we always refresh rIBASE on 11813 * return. 11814 */ 11815 EXPORT_PC 11816 movl rSELF, %eax 11817 movl rPC, OUT_ARG0(%esp) 11818 cmpb $0,offThread_breakFlags(%eax) # anything to do? 11819 movl rFP, OUT_ARG1(%esp) 11820 je 1f # reload rIBASE & resume if not 11821 movl %eax, OUT_ARG2(%esp) 11822 call dvmCheckBefore # (dPC, dFP, self) 11823 movl rSELF, %eax 118241: 11825 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 11826 jmp *dvmAsmInstructionStart+(12*4) 11827 11828/* ------------------------------ */ 11829.L_ALT_OP_MOVE_EXCEPTION: /* 0x0d */ 11830/* File: x86/alt_stub.S */ 11831/* 11832 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 11833 * any interesting requests and then jump to the real instruction 11834 * handler. Unlike the Arm handler, we can't do this as a tail call 11835 * because rIBASE is caller save and we need to reload it. 11836 * 11837 * Note that unlike in the Arm implementation, we should never arrive 11838 * here with a zero breakFlag because we always refresh rIBASE on 11839 * return. 11840 */ 11841 EXPORT_PC 11842 movl rSELF, %eax 11843 movl rPC, OUT_ARG0(%esp) 11844 cmpb $0,offThread_breakFlags(%eax) # anything to do? 11845 movl rFP, OUT_ARG1(%esp) 11846 je 1f # reload rIBASE & resume if not 11847 movl %eax, OUT_ARG2(%esp) 11848 call dvmCheckBefore # (dPC, dFP, self) 11849 movl rSELF, %eax 118501: 11851 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 11852 jmp *dvmAsmInstructionStart+(13*4) 11853 11854/* ------------------------------ */ 11855.L_ALT_OP_RETURN_VOID: /* 0x0e */ 11856/* File: x86/alt_stub.S */ 11857/* 11858 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 11859 * any interesting requests and then jump to the real instruction 11860 * handler. Unlike the Arm handler, we can't do this as a tail call 11861 * because rIBASE is caller save and we need to reload it. 11862 * 11863 * Note that unlike in the Arm implementation, we should never arrive 11864 * here with a zero breakFlag because we always refresh rIBASE on 11865 * return. 11866 */ 11867 EXPORT_PC 11868 movl rSELF, %eax 11869 movl rPC, OUT_ARG0(%esp) 11870 cmpb $0,offThread_breakFlags(%eax) # anything to do? 11871 movl rFP, OUT_ARG1(%esp) 11872 je 1f # reload rIBASE & resume if not 11873 movl %eax, OUT_ARG2(%esp) 11874 call dvmCheckBefore # (dPC, dFP, self) 11875 movl rSELF, %eax 118761: 11877 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 11878 jmp *dvmAsmInstructionStart+(14*4) 11879 11880/* ------------------------------ */ 11881.L_ALT_OP_RETURN: /* 0x0f */ 11882/* File: x86/alt_stub.S */ 11883/* 11884 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 11885 * any interesting requests and then jump to the real instruction 11886 * handler. Unlike the Arm handler, we can't do this as a tail call 11887 * because rIBASE is caller save and we need to reload it. 11888 * 11889 * Note that unlike in the Arm implementation, we should never arrive 11890 * here with a zero breakFlag because we always refresh rIBASE on 11891 * return. 11892 */ 11893 EXPORT_PC 11894 movl rSELF, %eax 11895 movl rPC, OUT_ARG0(%esp) 11896 cmpb $0,offThread_breakFlags(%eax) # anything to do? 11897 movl rFP, OUT_ARG1(%esp) 11898 je 1f # reload rIBASE & resume if not 11899 movl %eax, OUT_ARG2(%esp) 11900 call dvmCheckBefore # (dPC, dFP, self) 11901 movl rSELF, %eax 119021: 11903 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 11904 jmp *dvmAsmInstructionStart+(15*4) 11905 11906/* ------------------------------ */ 11907.L_ALT_OP_RETURN_WIDE: /* 0x10 */ 11908/* File: x86/alt_stub.S */ 11909/* 11910 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 11911 * any interesting requests and then jump to the real instruction 11912 * handler. Unlike the Arm handler, we can't do this as a tail call 11913 * because rIBASE is caller save and we need to reload it. 11914 * 11915 * Note that unlike in the Arm implementation, we should never arrive 11916 * here with a zero breakFlag because we always refresh rIBASE on 11917 * return. 11918 */ 11919 EXPORT_PC 11920 movl rSELF, %eax 11921 movl rPC, OUT_ARG0(%esp) 11922 cmpb $0,offThread_breakFlags(%eax) # anything to do? 11923 movl rFP, OUT_ARG1(%esp) 11924 je 1f # reload rIBASE & resume if not 11925 movl %eax, OUT_ARG2(%esp) 11926 call dvmCheckBefore # (dPC, dFP, self) 11927 movl rSELF, %eax 119281: 11929 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 11930 jmp *dvmAsmInstructionStart+(16*4) 11931 11932/* ------------------------------ */ 11933.L_ALT_OP_RETURN_OBJECT: /* 0x11 */ 11934/* File: x86/alt_stub.S */ 11935/* 11936 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 11937 * any interesting requests and then jump to the real instruction 11938 * handler. Unlike the Arm handler, we can't do this as a tail call 11939 * because rIBASE is caller save and we need to reload it. 11940 * 11941 * Note that unlike in the Arm implementation, we should never arrive 11942 * here with a zero breakFlag because we always refresh rIBASE on 11943 * return. 11944 */ 11945 EXPORT_PC 11946 movl rSELF, %eax 11947 movl rPC, OUT_ARG0(%esp) 11948 cmpb $0,offThread_breakFlags(%eax) # anything to do? 11949 movl rFP, OUT_ARG1(%esp) 11950 je 1f # reload rIBASE & resume if not 11951 movl %eax, OUT_ARG2(%esp) 11952 call dvmCheckBefore # (dPC, dFP, self) 11953 movl rSELF, %eax 119541: 11955 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 11956 jmp *dvmAsmInstructionStart+(17*4) 11957 11958/* ------------------------------ */ 11959.L_ALT_OP_CONST_4: /* 0x12 */ 11960/* File: x86/alt_stub.S */ 11961/* 11962 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 11963 * any interesting requests and then jump to the real instruction 11964 * handler. Unlike the Arm handler, we can't do this as a tail call 11965 * because rIBASE is caller save and we need to reload it. 11966 * 11967 * Note that unlike in the Arm implementation, we should never arrive 11968 * here with a zero breakFlag because we always refresh rIBASE on 11969 * return. 11970 */ 11971 EXPORT_PC 11972 movl rSELF, %eax 11973 movl rPC, OUT_ARG0(%esp) 11974 cmpb $0,offThread_breakFlags(%eax) # anything to do? 11975 movl rFP, OUT_ARG1(%esp) 11976 je 1f # reload rIBASE & resume if not 11977 movl %eax, OUT_ARG2(%esp) 11978 call dvmCheckBefore # (dPC, dFP, self) 11979 movl rSELF, %eax 119801: 11981 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 11982 jmp *dvmAsmInstructionStart+(18*4) 11983 11984/* ------------------------------ */ 11985.L_ALT_OP_CONST_16: /* 0x13 */ 11986/* File: x86/alt_stub.S */ 11987/* 11988 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 11989 * any interesting requests and then jump to the real instruction 11990 * handler. Unlike the Arm handler, we can't do this as a tail call 11991 * because rIBASE is caller save and we need to reload it. 11992 * 11993 * Note that unlike in the Arm implementation, we should never arrive 11994 * here with a zero breakFlag because we always refresh rIBASE on 11995 * return. 11996 */ 11997 EXPORT_PC 11998 movl rSELF, %eax 11999 movl rPC, OUT_ARG0(%esp) 12000 cmpb $0,offThread_breakFlags(%eax) # anything to do? 12001 movl rFP, OUT_ARG1(%esp) 12002 je 1f # reload rIBASE & resume if not 12003 movl %eax, OUT_ARG2(%esp) 12004 call dvmCheckBefore # (dPC, dFP, self) 12005 movl rSELF, %eax 120061: 12007 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 12008 jmp *dvmAsmInstructionStart+(19*4) 12009 12010/* ------------------------------ */ 12011.L_ALT_OP_CONST: /* 0x14 */ 12012/* File: x86/alt_stub.S */ 12013/* 12014 * Inter-instruction transfer stub. Call out to dvmCheckBefore 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 * Note that unlike in the Arm implementation, we should never arrive 12020 * here with a zero breakFlag because we always refresh rIBASE on 12021 * return. 12022 */ 12023 EXPORT_PC 12024 movl rSELF, %eax 12025 movl rPC, OUT_ARG0(%esp) 12026 cmpb $0,offThread_breakFlags(%eax) # anything to do? 12027 movl rFP, OUT_ARG1(%esp) 12028 je 1f # reload rIBASE & resume if not 12029 movl %eax, OUT_ARG2(%esp) 12030 call dvmCheckBefore # (dPC, dFP, self) 12031 movl rSELF, %eax 120321: 12033 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 12034 jmp *dvmAsmInstructionStart+(20*4) 12035 12036/* ------------------------------ */ 12037.L_ALT_OP_CONST_HIGH16: /* 0x15 */ 12038/* File: x86/alt_stub.S */ 12039/* 12040 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 12041 * any interesting requests and then jump to the real instruction 12042 * handler. Unlike the Arm handler, we can't do this as a tail call 12043 * because rIBASE is caller save and we need to reload it. 12044 * 12045 * Note that unlike in the Arm implementation, we should never arrive 12046 * here with a zero breakFlag because we always refresh rIBASE on 12047 * return. 12048 */ 12049 EXPORT_PC 12050 movl rSELF, %eax 12051 movl rPC, OUT_ARG0(%esp) 12052 cmpb $0,offThread_breakFlags(%eax) # anything to do? 12053 movl rFP, OUT_ARG1(%esp) 12054 je 1f # reload rIBASE & resume if not 12055 movl %eax, OUT_ARG2(%esp) 12056 call dvmCheckBefore # (dPC, dFP, self) 12057 movl rSELF, %eax 120581: 12059 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 12060 jmp *dvmAsmInstructionStart+(21*4) 12061 12062/* ------------------------------ */ 12063.L_ALT_OP_CONST_WIDE_16: /* 0x16 */ 12064/* File: x86/alt_stub.S */ 12065/* 12066 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 12067 * any interesting requests and then jump to the real instruction 12068 * handler. Unlike the Arm handler, we can't do this as a tail call 12069 * because rIBASE is caller save and we need to reload it. 12070 * 12071 * Note that unlike in the Arm implementation, we should never arrive 12072 * here with a zero breakFlag because we always refresh rIBASE on 12073 * return. 12074 */ 12075 EXPORT_PC 12076 movl rSELF, %eax 12077 movl rPC, OUT_ARG0(%esp) 12078 cmpb $0,offThread_breakFlags(%eax) # anything to do? 12079 movl rFP, OUT_ARG1(%esp) 12080 je 1f # reload rIBASE & resume if not 12081 movl %eax, OUT_ARG2(%esp) 12082 call dvmCheckBefore # (dPC, dFP, self) 12083 movl rSELF, %eax 120841: 12085 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 12086 jmp *dvmAsmInstructionStart+(22*4) 12087 12088/* ------------------------------ */ 12089.L_ALT_OP_CONST_WIDE_32: /* 0x17 */ 12090/* File: x86/alt_stub.S */ 12091/* 12092 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 12093 * any interesting requests and then jump to the real instruction 12094 * handler. Unlike the Arm handler, we can't do this as a tail call 12095 * because rIBASE is caller save and we need to reload it. 12096 * 12097 * Note that unlike in the Arm implementation, we should never arrive 12098 * here with a zero breakFlag because we always refresh rIBASE on 12099 * return. 12100 */ 12101 EXPORT_PC 12102 movl rSELF, %eax 12103 movl rPC, OUT_ARG0(%esp) 12104 cmpb $0,offThread_breakFlags(%eax) # anything to do? 12105 movl rFP, OUT_ARG1(%esp) 12106 je 1f # reload rIBASE & resume if not 12107 movl %eax, OUT_ARG2(%esp) 12108 call dvmCheckBefore # (dPC, dFP, self) 12109 movl rSELF, %eax 121101: 12111 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 12112 jmp *dvmAsmInstructionStart+(23*4) 12113 12114/* ------------------------------ */ 12115.L_ALT_OP_CONST_WIDE: /* 0x18 */ 12116/* File: x86/alt_stub.S */ 12117/* 12118 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 12119 * any interesting requests and then jump to the real instruction 12120 * handler. Unlike the Arm handler, we can't do this as a tail call 12121 * because rIBASE is caller save and we need to reload it. 12122 * 12123 * Note that unlike in the Arm implementation, we should never arrive 12124 * here with a zero breakFlag because we always refresh rIBASE on 12125 * return. 12126 */ 12127 EXPORT_PC 12128 movl rSELF, %eax 12129 movl rPC, OUT_ARG0(%esp) 12130 cmpb $0,offThread_breakFlags(%eax) # anything to do? 12131 movl rFP, OUT_ARG1(%esp) 12132 je 1f # reload rIBASE & resume if not 12133 movl %eax, OUT_ARG2(%esp) 12134 call dvmCheckBefore # (dPC, dFP, self) 12135 movl rSELF, %eax 121361: 12137 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 12138 jmp *dvmAsmInstructionStart+(24*4) 12139 12140/* ------------------------------ */ 12141.L_ALT_OP_CONST_WIDE_HIGH16: /* 0x19 */ 12142/* File: x86/alt_stub.S */ 12143/* 12144 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 12145 * any interesting requests and then jump to the real instruction 12146 * handler. Unlike the Arm handler, we can't do this as a tail call 12147 * because rIBASE is caller save and we need to reload it. 12148 * 12149 * Note that unlike in the Arm implementation, we should never arrive 12150 * here with a zero breakFlag because we always refresh rIBASE on 12151 * return. 12152 */ 12153 EXPORT_PC 12154 movl rSELF, %eax 12155 movl rPC, OUT_ARG0(%esp) 12156 cmpb $0,offThread_breakFlags(%eax) # anything to do? 12157 movl rFP, OUT_ARG1(%esp) 12158 je 1f # reload rIBASE & resume if not 12159 movl %eax, OUT_ARG2(%esp) 12160 call dvmCheckBefore # (dPC, dFP, self) 12161 movl rSELF, %eax 121621: 12163 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 12164 jmp *dvmAsmInstructionStart+(25*4) 12165 12166/* ------------------------------ */ 12167.L_ALT_OP_CONST_STRING: /* 0x1a */ 12168/* File: x86/alt_stub.S */ 12169/* 12170 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 12171 * any interesting requests and then jump to the real instruction 12172 * handler. Unlike the Arm handler, we can't do this as a tail call 12173 * because rIBASE is caller save and we need to reload it. 12174 * 12175 * Note that unlike in the Arm implementation, we should never arrive 12176 * here with a zero breakFlag because we always refresh rIBASE on 12177 * return. 12178 */ 12179 EXPORT_PC 12180 movl rSELF, %eax 12181 movl rPC, OUT_ARG0(%esp) 12182 cmpb $0,offThread_breakFlags(%eax) # anything to do? 12183 movl rFP, OUT_ARG1(%esp) 12184 je 1f # reload rIBASE & resume if not 12185 movl %eax, OUT_ARG2(%esp) 12186 call dvmCheckBefore # (dPC, dFP, self) 12187 movl rSELF, %eax 121881: 12189 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 12190 jmp *dvmAsmInstructionStart+(26*4) 12191 12192/* ------------------------------ */ 12193.L_ALT_OP_CONST_STRING_JUMBO: /* 0x1b */ 12194/* File: x86/alt_stub.S */ 12195/* 12196 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 12197 * any interesting requests and then jump to the real instruction 12198 * handler. Unlike the Arm handler, we can't do this as a tail call 12199 * because rIBASE is caller save and we need to reload it. 12200 * 12201 * Note that unlike in the Arm implementation, we should never arrive 12202 * here with a zero breakFlag because we always refresh rIBASE on 12203 * return. 12204 */ 12205 EXPORT_PC 12206 movl rSELF, %eax 12207 movl rPC, OUT_ARG0(%esp) 12208 cmpb $0,offThread_breakFlags(%eax) # anything to do? 12209 movl rFP, OUT_ARG1(%esp) 12210 je 1f # reload rIBASE & resume if not 12211 movl %eax, OUT_ARG2(%esp) 12212 call dvmCheckBefore # (dPC, dFP, self) 12213 movl rSELF, %eax 122141: 12215 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 12216 jmp *dvmAsmInstructionStart+(27*4) 12217 12218/* ------------------------------ */ 12219.L_ALT_OP_CONST_CLASS: /* 0x1c */ 12220/* File: x86/alt_stub.S */ 12221/* 12222 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 12223 * any interesting requests and then jump to the real instruction 12224 * handler. Unlike the Arm handler, we can't do this as a tail call 12225 * because rIBASE is caller save and we need to reload it. 12226 * 12227 * Note that unlike in the Arm implementation, we should never arrive 12228 * here with a zero breakFlag because we always refresh rIBASE on 12229 * return. 12230 */ 12231 EXPORT_PC 12232 movl rSELF, %eax 12233 movl rPC, OUT_ARG0(%esp) 12234 cmpb $0,offThread_breakFlags(%eax) # anything to do? 12235 movl rFP, OUT_ARG1(%esp) 12236 je 1f # reload rIBASE & resume if not 12237 movl %eax, OUT_ARG2(%esp) 12238 call dvmCheckBefore # (dPC, dFP, self) 12239 movl rSELF, %eax 122401: 12241 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 12242 jmp *dvmAsmInstructionStart+(28*4) 12243 12244/* ------------------------------ */ 12245.L_ALT_OP_MONITOR_ENTER: /* 0x1d */ 12246/* File: x86/alt_stub.S */ 12247/* 12248 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 12249 * any interesting requests and then jump to the real instruction 12250 * handler. Unlike the Arm handler, we can't do this as a tail call 12251 * because rIBASE is caller save and we need to reload it. 12252 * 12253 * Note that unlike in the Arm implementation, we should never arrive 12254 * here with a zero breakFlag because we always refresh rIBASE on 12255 * return. 12256 */ 12257 EXPORT_PC 12258 movl rSELF, %eax 12259 movl rPC, OUT_ARG0(%esp) 12260 cmpb $0,offThread_breakFlags(%eax) # anything to do? 12261 movl rFP, OUT_ARG1(%esp) 12262 je 1f # reload rIBASE & resume if not 12263 movl %eax, OUT_ARG2(%esp) 12264 call dvmCheckBefore # (dPC, dFP, self) 12265 movl rSELF, %eax 122661: 12267 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 12268 jmp *dvmAsmInstructionStart+(29*4) 12269 12270/* ------------------------------ */ 12271.L_ALT_OP_MONITOR_EXIT: /* 0x1e */ 12272/* File: x86/alt_stub.S */ 12273/* 12274 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 12275 * any interesting requests and then jump to the real instruction 12276 * handler. Unlike the Arm handler, we can't do this as a tail call 12277 * because rIBASE is caller save and we need to reload it. 12278 * 12279 * Note that unlike in the Arm implementation, we should never arrive 12280 * here with a zero breakFlag because we always refresh rIBASE on 12281 * return. 12282 */ 12283 EXPORT_PC 12284 movl rSELF, %eax 12285 movl rPC, OUT_ARG0(%esp) 12286 cmpb $0,offThread_breakFlags(%eax) # anything to do? 12287 movl rFP, OUT_ARG1(%esp) 12288 je 1f # reload rIBASE & resume if not 12289 movl %eax, OUT_ARG2(%esp) 12290 call dvmCheckBefore # (dPC, dFP, self) 12291 movl rSELF, %eax 122921: 12293 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 12294 jmp *dvmAsmInstructionStart+(30*4) 12295 12296/* ------------------------------ */ 12297.L_ALT_OP_CHECK_CAST: /* 0x1f */ 12298/* File: x86/alt_stub.S */ 12299/* 12300 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 12301 * any interesting requests and then jump to the real instruction 12302 * handler. Unlike the Arm handler, we can't do this as a tail call 12303 * because rIBASE is caller save and we need to reload it. 12304 * 12305 * Note that unlike in the Arm implementation, we should never arrive 12306 * here with a zero breakFlag because we always refresh rIBASE on 12307 * return. 12308 */ 12309 EXPORT_PC 12310 movl rSELF, %eax 12311 movl rPC, OUT_ARG0(%esp) 12312 cmpb $0,offThread_breakFlags(%eax) # anything to do? 12313 movl rFP, OUT_ARG1(%esp) 12314 je 1f # reload rIBASE & resume if not 12315 movl %eax, OUT_ARG2(%esp) 12316 call dvmCheckBefore # (dPC, dFP, self) 12317 movl rSELF, %eax 123181: 12319 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 12320 jmp *dvmAsmInstructionStart+(31*4) 12321 12322/* ------------------------------ */ 12323.L_ALT_OP_INSTANCE_OF: /* 0x20 */ 12324/* File: x86/alt_stub.S */ 12325/* 12326 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 12327 * any interesting requests and then jump to the real instruction 12328 * handler. Unlike the Arm handler, we can't do this as a tail call 12329 * because rIBASE is caller save and we need to reload it. 12330 * 12331 * Note that unlike in the Arm implementation, we should never arrive 12332 * here with a zero breakFlag because we always refresh rIBASE on 12333 * return. 12334 */ 12335 EXPORT_PC 12336 movl rSELF, %eax 12337 movl rPC, OUT_ARG0(%esp) 12338 cmpb $0,offThread_breakFlags(%eax) # anything to do? 12339 movl rFP, OUT_ARG1(%esp) 12340 je 1f # reload rIBASE & resume if not 12341 movl %eax, OUT_ARG2(%esp) 12342 call dvmCheckBefore # (dPC, dFP, self) 12343 movl rSELF, %eax 123441: 12345 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 12346 jmp *dvmAsmInstructionStart+(32*4) 12347 12348/* ------------------------------ */ 12349.L_ALT_OP_ARRAY_LENGTH: /* 0x21 */ 12350/* File: x86/alt_stub.S */ 12351/* 12352 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 12353 * any interesting requests and then jump to the real instruction 12354 * handler. Unlike the Arm handler, we can't do this as a tail call 12355 * because rIBASE is caller save and we need to reload it. 12356 * 12357 * Note that unlike in the Arm implementation, we should never arrive 12358 * here with a zero breakFlag because we always refresh rIBASE on 12359 * return. 12360 */ 12361 EXPORT_PC 12362 movl rSELF, %eax 12363 movl rPC, OUT_ARG0(%esp) 12364 cmpb $0,offThread_breakFlags(%eax) # anything to do? 12365 movl rFP, OUT_ARG1(%esp) 12366 je 1f # reload rIBASE & resume if not 12367 movl %eax, OUT_ARG2(%esp) 12368 call dvmCheckBefore # (dPC, dFP, self) 12369 movl rSELF, %eax 123701: 12371 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 12372 jmp *dvmAsmInstructionStart+(33*4) 12373 12374/* ------------------------------ */ 12375.L_ALT_OP_NEW_INSTANCE: /* 0x22 */ 12376/* File: x86/alt_stub.S */ 12377/* 12378 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 12379 * any interesting requests and then jump to the real instruction 12380 * handler. Unlike the Arm handler, we can't do this as a tail call 12381 * because rIBASE is caller save and we need to reload it. 12382 * 12383 * Note that unlike in the Arm implementation, we should never arrive 12384 * here with a zero breakFlag because we always refresh rIBASE on 12385 * return. 12386 */ 12387 EXPORT_PC 12388 movl rSELF, %eax 12389 movl rPC, OUT_ARG0(%esp) 12390 cmpb $0,offThread_breakFlags(%eax) # anything to do? 12391 movl rFP, OUT_ARG1(%esp) 12392 je 1f # reload rIBASE & resume if not 12393 movl %eax, OUT_ARG2(%esp) 12394 call dvmCheckBefore # (dPC, dFP, self) 12395 movl rSELF, %eax 123961: 12397 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 12398 jmp *dvmAsmInstructionStart+(34*4) 12399 12400/* ------------------------------ */ 12401.L_ALT_OP_NEW_ARRAY: /* 0x23 */ 12402/* File: x86/alt_stub.S */ 12403/* 12404 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 12405 * any interesting requests and then jump to the real instruction 12406 * handler. Unlike the Arm handler, we can't do this as a tail call 12407 * because rIBASE is caller save and we need to reload it. 12408 * 12409 * Note that unlike in the Arm implementation, we should never arrive 12410 * here with a zero breakFlag because we always refresh rIBASE on 12411 * return. 12412 */ 12413 EXPORT_PC 12414 movl rSELF, %eax 12415 movl rPC, OUT_ARG0(%esp) 12416 cmpb $0,offThread_breakFlags(%eax) # anything to do? 12417 movl rFP, OUT_ARG1(%esp) 12418 je 1f # reload rIBASE & resume if not 12419 movl %eax, OUT_ARG2(%esp) 12420 call dvmCheckBefore # (dPC, dFP, self) 12421 movl rSELF, %eax 124221: 12423 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 12424 jmp *dvmAsmInstructionStart+(35*4) 12425 12426/* ------------------------------ */ 12427.L_ALT_OP_FILLED_NEW_ARRAY: /* 0x24 */ 12428/* File: x86/alt_stub.S */ 12429/* 12430 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 12431 * any interesting requests and then jump to the real instruction 12432 * handler. Unlike the Arm handler, we can't do this as a tail call 12433 * because rIBASE is caller save and we need to reload it. 12434 * 12435 * Note that unlike in the Arm implementation, we should never arrive 12436 * here with a zero breakFlag because we always refresh rIBASE on 12437 * return. 12438 */ 12439 EXPORT_PC 12440 movl rSELF, %eax 12441 movl rPC, OUT_ARG0(%esp) 12442 cmpb $0,offThread_breakFlags(%eax) # anything to do? 12443 movl rFP, OUT_ARG1(%esp) 12444 je 1f # reload rIBASE & resume if not 12445 movl %eax, OUT_ARG2(%esp) 12446 call dvmCheckBefore # (dPC, dFP, self) 12447 movl rSELF, %eax 124481: 12449 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 12450 jmp *dvmAsmInstructionStart+(36*4) 12451 12452/* ------------------------------ */ 12453.L_ALT_OP_FILLED_NEW_ARRAY_RANGE: /* 0x25 */ 12454/* File: x86/alt_stub.S */ 12455/* 12456 * Inter-instruction transfer stub. Call out to dvmCheckBefore 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 * Note that unlike in the Arm implementation, we should never arrive 12462 * here with a zero breakFlag because we always refresh rIBASE on 12463 * return. 12464 */ 12465 EXPORT_PC 12466 movl rSELF, %eax 12467 movl rPC, OUT_ARG0(%esp) 12468 cmpb $0,offThread_breakFlags(%eax) # anything to do? 12469 movl rFP, OUT_ARG1(%esp) 12470 je 1f # reload rIBASE & resume if not 12471 movl %eax, OUT_ARG2(%esp) 12472 call dvmCheckBefore # (dPC, dFP, self) 12473 movl rSELF, %eax 124741: 12475 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 12476 jmp *dvmAsmInstructionStart+(37*4) 12477 12478/* ------------------------------ */ 12479.L_ALT_OP_FILL_ARRAY_DATA: /* 0x26 */ 12480/* File: x86/alt_stub.S */ 12481/* 12482 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 12483 * any interesting requests and then jump to the real instruction 12484 * handler. Unlike the Arm handler, we can't do this as a tail call 12485 * because rIBASE is caller save and we need to reload it. 12486 * 12487 * Note that unlike in the Arm implementation, we should never arrive 12488 * here with a zero breakFlag because we always refresh rIBASE on 12489 * return. 12490 */ 12491 EXPORT_PC 12492 movl rSELF, %eax 12493 movl rPC, OUT_ARG0(%esp) 12494 cmpb $0,offThread_breakFlags(%eax) # anything to do? 12495 movl rFP, OUT_ARG1(%esp) 12496 je 1f # reload rIBASE & resume if not 12497 movl %eax, OUT_ARG2(%esp) 12498 call dvmCheckBefore # (dPC, dFP, self) 12499 movl rSELF, %eax 125001: 12501 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 12502 jmp *dvmAsmInstructionStart+(38*4) 12503 12504/* ------------------------------ */ 12505.L_ALT_OP_THROW: /* 0x27 */ 12506/* File: x86/alt_stub.S */ 12507/* 12508 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 12509 * any interesting requests and then jump to the real instruction 12510 * handler. Unlike the Arm handler, we can't do this as a tail call 12511 * because rIBASE is caller save and we need to reload it. 12512 * 12513 * Note that unlike in the Arm implementation, we should never arrive 12514 * here with a zero breakFlag because we always refresh rIBASE on 12515 * return. 12516 */ 12517 EXPORT_PC 12518 movl rSELF, %eax 12519 movl rPC, OUT_ARG0(%esp) 12520 cmpb $0,offThread_breakFlags(%eax) # anything to do? 12521 movl rFP, OUT_ARG1(%esp) 12522 je 1f # reload rIBASE & resume if not 12523 movl %eax, OUT_ARG2(%esp) 12524 call dvmCheckBefore # (dPC, dFP, self) 12525 movl rSELF, %eax 125261: 12527 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 12528 jmp *dvmAsmInstructionStart+(39*4) 12529 12530/* ------------------------------ */ 12531.L_ALT_OP_GOTO: /* 0x28 */ 12532/* File: x86/alt_stub.S */ 12533/* 12534 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 12535 * any interesting requests and then jump to the real instruction 12536 * handler. Unlike the Arm handler, we can't do this as a tail call 12537 * because rIBASE is caller save and we need to reload it. 12538 * 12539 * Note that unlike in the Arm implementation, we should never arrive 12540 * here with a zero breakFlag because we always refresh rIBASE on 12541 * return. 12542 */ 12543 EXPORT_PC 12544 movl rSELF, %eax 12545 movl rPC, OUT_ARG0(%esp) 12546 cmpb $0,offThread_breakFlags(%eax) # anything to do? 12547 movl rFP, OUT_ARG1(%esp) 12548 je 1f # reload rIBASE & resume if not 12549 movl %eax, OUT_ARG2(%esp) 12550 call dvmCheckBefore # (dPC, dFP, self) 12551 movl rSELF, %eax 125521: 12553 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 12554 jmp *dvmAsmInstructionStart+(40*4) 12555 12556/* ------------------------------ */ 12557.L_ALT_OP_GOTO_16: /* 0x29 */ 12558/* File: x86/alt_stub.S */ 12559/* 12560 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 12561 * any interesting requests and then jump to the real instruction 12562 * handler. Unlike the Arm handler, we can't do this as a tail call 12563 * because rIBASE is caller save and we need to reload it. 12564 * 12565 * Note that unlike in the Arm implementation, we should never arrive 12566 * here with a zero breakFlag because we always refresh rIBASE on 12567 * return. 12568 */ 12569 EXPORT_PC 12570 movl rSELF, %eax 12571 movl rPC, OUT_ARG0(%esp) 12572 cmpb $0,offThread_breakFlags(%eax) # anything to do? 12573 movl rFP, OUT_ARG1(%esp) 12574 je 1f # reload rIBASE & resume if not 12575 movl %eax, OUT_ARG2(%esp) 12576 call dvmCheckBefore # (dPC, dFP, self) 12577 movl rSELF, %eax 125781: 12579 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 12580 jmp *dvmAsmInstructionStart+(41*4) 12581 12582/* ------------------------------ */ 12583.L_ALT_OP_GOTO_32: /* 0x2a */ 12584/* File: x86/alt_stub.S */ 12585/* 12586 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 12587 * any interesting requests and then jump to the real instruction 12588 * handler. Unlike the Arm handler, we can't do this as a tail call 12589 * because rIBASE is caller save and we need to reload it. 12590 * 12591 * Note that unlike in the Arm implementation, we should never arrive 12592 * here with a zero breakFlag because we always refresh rIBASE on 12593 * return. 12594 */ 12595 EXPORT_PC 12596 movl rSELF, %eax 12597 movl rPC, OUT_ARG0(%esp) 12598 cmpb $0,offThread_breakFlags(%eax) # anything to do? 12599 movl rFP, OUT_ARG1(%esp) 12600 je 1f # reload rIBASE & resume if not 12601 movl %eax, OUT_ARG2(%esp) 12602 call dvmCheckBefore # (dPC, dFP, self) 12603 movl rSELF, %eax 126041: 12605 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 12606 jmp *dvmAsmInstructionStart+(42*4) 12607 12608/* ------------------------------ */ 12609.L_ALT_OP_PACKED_SWITCH: /* 0x2b */ 12610/* File: x86/alt_stub.S */ 12611/* 12612 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 12613 * any interesting requests and then jump to the real instruction 12614 * handler. Unlike the Arm handler, we can't do this as a tail call 12615 * because rIBASE is caller save and we need to reload it. 12616 * 12617 * Note that unlike in the Arm implementation, we should never arrive 12618 * here with a zero breakFlag because we always refresh rIBASE on 12619 * return. 12620 */ 12621 EXPORT_PC 12622 movl rSELF, %eax 12623 movl rPC, OUT_ARG0(%esp) 12624 cmpb $0,offThread_breakFlags(%eax) # anything to do? 12625 movl rFP, OUT_ARG1(%esp) 12626 je 1f # reload rIBASE & resume if not 12627 movl %eax, OUT_ARG2(%esp) 12628 call dvmCheckBefore # (dPC, dFP, self) 12629 movl rSELF, %eax 126301: 12631 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 12632 jmp *dvmAsmInstructionStart+(43*4) 12633 12634/* ------------------------------ */ 12635.L_ALT_OP_SPARSE_SWITCH: /* 0x2c */ 12636/* File: x86/alt_stub.S */ 12637/* 12638 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 12639 * any interesting requests and then jump to the real instruction 12640 * handler. Unlike the Arm handler, we can't do this as a tail call 12641 * because rIBASE is caller save and we need to reload it. 12642 * 12643 * Note that unlike in the Arm implementation, we should never arrive 12644 * here with a zero breakFlag because we always refresh rIBASE on 12645 * return. 12646 */ 12647 EXPORT_PC 12648 movl rSELF, %eax 12649 movl rPC, OUT_ARG0(%esp) 12650 cmpb $0,offThread_breakFlags(%eax) # anything to do? 12651 movl rFP, OUT_ARG1(%esp) 12652 je 1f # reload rIBASE & resume if not 12653 movl %eax, OUT_ARG2(%esp) 12654 call dvmCheckBefore # (dPC, dFP, self) 12655 movl rSELF, %eax 126561: 12657 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 12658 jmp *dvmAsmInstructionStart+(44*4) 12659 12660/* ------------------------------ */ 12661.L_ALT_OP_CMPL_FLOAT: /* 0x2d */ 12662/* File: x86/alt_stub.S */ 12663/* 12664 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 12665 * any interesting requests and then jump to the real instruction 12666 * handler. Unlike the Arm handler, we can't do this as a tail call 12667 * because rIBASE is caller save and we need to reload it. 12668 * 12669 * Note that unlike in the Arm implementation, we should never arrive 12670 * here with a zero breakFlag because we always refresh rIBASE on 12671 * return. 12672 */ 12673 EXPORT_PC 12674 movl rSELF, %eax 12675 movl rPC, OUT_ARG0(%esp) 12676 cmpb $0,offThread_breakFlags(%eax) # anything to do? 12677 movl rFP, OUT_ARG1(%esp) 12678 je 1f # reload rIBASE & resume if not 12679 movl %eax, OUT_ARG2(%esp) 12680 call dvmCheckBefore # (dPC, dFP, self) 12681 movl rSELF, %eax 126821: 12683 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 12684 jmp *dvmAsmInstructionStart+(45*4) 12685 12686/* ------------------------------ */ 12687.L_ALT_OP_CMPG_FLOAT: /* 0x2e */ 12688/* File: x86/alt_stub.S */ 12689/* 12690 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 12691 * any interesting requests and then jump to the real instruction 12692 * handler. Unlike the Arm handler, we can't do this as a tail call 12693 * because rIBASE is caller save and we need to reload it. 12694 * 12695 * Note that unlike in the Arm implementation, we should never arrive 12696 * here with a zero breakFlag because we always refresh rIBASE on 12697 * return. 12698 */ 12699 EXPORT_PC 12700 movl rSELF, %eax 12701 movl rPC, OUT_ARG0(%esp) 12702 cmpb $0,offThread_breakFlags(%eax) # anything to do? 12703 movl rFP, OUT_ARG1(%esp) 12704 je 1f # reload rIBASE & resume if not 12705 movl %eax, OUT_ARG2(%esp) 12706 call dvmCheckBefore # (dPC, dFP, self) 12707 movl rSELF, %eax 127081: 12709 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 12710 jmp *dvmAsmInstructionStart+(46*4) 12711 12712/* ------------------------------ */ 12713.L_ALT_OP_CMPL_DOUBLE: /* 0x2f */ 12714/* File: x86/alt_stub.S */ 12715/* 12716 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 12717 * any interesting requests and then jump to the real instruction 12718 * handler. Unlike the Arm handler, we can't do this as a tail call 12719 * because rIBASE is caller save and we need to reload it. 12720 * 12721 * Note that unlike in the Arm implementation, we should never arrive 12722 * here with a zero breakFlag because we always refresh rIBASE on 12723 * return. 12724 */ 12725 EXPORT_PC 12726 movl rSELF, %eax 12727 movl rPC, OUT_ARG0(%esp) 12728 cmpb $0,offThread_breakFlags(%eax) # anything to do? 12729 movl rFP, OUT_ARG1(%esp) 12730 je 1f # reload rIBASE & resume if not 12731 movl %eax, OUT_ARG2(%esp) 12732 call dvmCheckBefore # (dPC, dFP, self) 12733 movl rSELF, %eax 127341: 12735 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 12736 jmp *dvmAsmInstructionStart+(47*4) 12737 12738/* ------------------------------ */ 12739.L_ALT_OP_CMPG_DOUBLE: /* 0x30 */ 12740/* File: x86/alt_stub.S */ 12741/* 12742 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 12743 * any interesting requests and then jump to the real instruction 12744 * handler. Unlike the Arm handler, we can't do this as a tail call 12745 * because rIBASE is caller save and we need to reload it. 12746 * 12747 * Note that unlike in the Arm implementation, we should never arrive 12748 * here with a zero breakFlag because we always refresh rIBASE on 12749 * return. 12750 */ 12751 EXPORT_PC 12752 movl rSELF, %eax 12753 movl rPC, OUT_ARG0(%esp) 12754 cmpb $0,offThread_breakFlags(%eax) # anything to do? 12755 movl rFP, OUT_ARG1(%esp) 12756 je 1f # reload rIBASE & resume if not 12757 movl %eax, OUT_ARG2(%esp) 12758 call dvmCheckBefore # (dPC, dFP, self) 12759 movl rSELF, %eax 127601: 12761 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 12762 jmp *dvmAsmInstructionStart+(48*4) 12763 12764/* ------------------------------ */ 12765.L_ALT_OP_CMP_LONG: /* 0x31 */ 12766/* File: x86/alt_stub.S */ 12767/* 12768 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 12769 * any interesting requests and then jump to the real instruction 12770 * handler. Unlike the Arm handler, we can't do this as a tail call 12771 * because rIBASE is caller save and we need to reload it. 12772 * 12773 * Note that unlike in the Arm implementation, we should never arrive 12774 * here with a zero breakFlag because we always refresh rIBASE on 12775 * return. 12776 */ 12777 EXPORT_PC 12778 movl rSELF, %eax 12779 movl rPC, OUT_ARG0(%esp) 12780 cmpb $0,offThread_breakFlags(%eax) # anything to do? 12781 movl rFP, OUT_ARG1(%esp) 12782 je 1f # reload rIBASE & resume if not 12783 movl %eax, OUT_ARG2(%esp) 12784 call dvmCheckBefore # (dPC, dFP, self) 12785 movl rSELF, %eax 127861: 12787 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 12788 jmp *dvmAsmInstructionStart+(49*4) 12789 12790/* ------------------------------ */ 12791.L_ALT_OP_IF_EQ: /* 0x32 */ 12792/* File: x86/alt_stub.S */ 12793/* 12794 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 12795 * any interesting requests and then jump to the real instruction 12796 * handler. Unlike the Arm handler, we can't do this as a tail call 12797 * because rIBASE is caller save and we need to reload it. 12798 * 12799 * Note that unlike in the Arm implementation, we should never arrive 12800 * here with a zero breakFlag because we always refresh rIBASE on 12801 * return. 12802 */ 12803 EXPORT_PC 12804 movl rSELF, %eax 12805 movl rPC, OUT_ARG0(%esp) 12806 cmpb $0,offThread_breakFlags(%eax) # anything to do? 12807 movl rFP, OUT_ARG1(%esp) 12808 je 1f # reload rIBASE & resume if not 12809 movl %eax, OUT_ARG2(%esp) 12810 call dvmCheckBefore # (dPC, dFP, self) 12811 movl rSELF, %eax 128121: 12813 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 12814 jmp *dvmAsmInstructionStart+(50*4) 12815 12816/* ------------------------------ */ 12817.L_ALT_OP_IF_NE: /* 0x33 */ 12818/* File: x86/alt_stub.S */ 12819/* 12820 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 12821 * any interesting requests and then jump to the real instruction 12822 * handler. Unlike the Arm handler, we can't do this as a tail call 12823 * because rIBASE is caller save and we need to reload it. 12824 * 12825 * Note that unlike in the Arm implementation, we should never arrive 12826 * here with a zero breakFlag because we always refresh rIBASE on 12827 * return. 12828 */ 12829 EXPORT_PC 12830 movl rSELF, %eax 12831 movl rPC, OUT_ARG0(%esp) 12832 cmpb $0,offThread_breakFlags(%eax) # anything to do? 12833 movl rFP, OUT_ARG1(%esp) 12834 je 1f # reload rIBASE & resume if not 12835 movl %eax, OUT_ARG2(%esp) 12836 call dvmCheckBefore # (dPC, dFP, self) 12837 movl rSELF, %eax 128381: 12839 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 12840 jmp *dvmAsmInstructionStart+(51*4) 12841 12842/* ------------------------------ */ 12843.L_ALT_OP_IF_LT: /* 0x34 */ 12844/* File: x86/alt_stub.S */ 12845/* 12846 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 12847 * any interesting requests and then jump to the real instruction 12848 * handler. Unlike the Arm handler, we can't do this as a tail call 12849 * because rIBASE is caller save and we need to reload it. 12850 * 12851 * Note that unlike in the Arm implementation, we should never arrive 12852 * here with a zero breakFlag because we always refresh rIBASE on 12853 * return. 12854 */ 12855 EXPORT_PC 12856 movl rSELF, %eax 12857 movl rPC, OUT_ARG0(%esp) 12858 cmpb $0,offThread_breakFlags(%eax) # anything to do? 12859 movl rFP, OUT_ARG1(%esp) 12860 je 1f # reload rIBASE & resume if not 12861 movl %eax, OUT_ARG2(%esp) 12862 call dvmCheckBefore # (dPC, dFP, self) 12863 movl rSELF, %eax 128641: 12865 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 12866 jmp *dvmAsmInstructionStart+(52*4) 12867 12868/* ------------------------------ */ 12869.L_ALT_OP_IF_GE: /* 0x35 */ 12870/* File: x86/alt_stub.S */ 12871/* 12872 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 12873 * any interesting requests and then jump to the real instruction 12874 * handler. Unlike the Arm handler, we can't do this as a tail call 12875 * because rIBASE is caller save and we need to reload it. 12876 * 12877 * Note that unlike in the Arm implementation, we should never arrive 12878 * here with a zero breakFlag because we always refresh rIBASE on 12879 * return. 12880 */ 12881 EXPORT_PC 12882 movl rSELF, %eax 12883 movl rPC, OUT_ARG0(%esp) 12884 cmpb $0,offThread_breakFlags(%eax) # anything to do? 12885 movl rFP, OUT_ARG1(%esp) 12886 je 1f # reload rIBASE & resume if not 12887 movl %eax, OUT_ARG2(%esp) 12888 call dvmCheckBefore # (dPC, dFP, self) 12889 movl rSELF, %eax 128901: 12891 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 12892 jmp *dvmAsmInstructionStart+(53*4) 12893 12894/* ------------------------------ */ 12895.L_ALT_OP_IF_GT: /* 0x36 */ 12896/* File: x86/alt_stub.S */ 12897/* 12898 * Inter-instruction transfer stub. Call out to dvmCheckBefore 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 * Note that unlike in the Arm implementation, we should never arrive 12904 * here with a zero breakFlag because we always refresh rIBASE on 12905 * return. 12906 */ 12907 EXPORT_PC 12908 movl rSELF, %eax 12909 movl rPC, OUT_ARG0(%esp) 12910 cmpb $0,offThread_breakFlags(%eax) # anything to do? 12911 movl rFP, OUT_ARG1(%esp) 12912 je 1f # reload rIBASE & resume if not 12913 movl %eax, OUT_ARG2(%esp) 12914 call dvmCheckBefore # (dPC, dFP, self) 12915 movl rSELF, %eax 129161: 12917 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 12918 jmp *dvmAsmInstructionStart+(54*4) 12919 12920/* ------------------------------ */ 12921.L_ALT_OP_IF_LE: /* 0x37 */ 12922/* File: x86/alt_stub.S */ 12923/* 12924 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 12925 * any interesting requests and then jump to the real instruction 12926 * handler. Unlike the Arm handler, we can't do this as a tail call 12927 * because rIBASE is caller save and we need to reload it. 12928 * 12929 * Note that unlike in the Arm implementation, we should never arrive 12930 * here with a zero breakFlag because we always refresh rIBASE on 12931 * return. 12932 */ 12933 EXPORT_PC 12934 movl rSELF, %eax 12935 movl rPC, OUT_ARG0(%esp) 12936 cmpb $0,offThread_breakFlags(%eax) # anything to do? 12937 movl rFP, OUT_ARG1(%esp) 12938 je 1f # reload rIBASE & resume if not 12939 movl %eax, OUT_ARG2(%esp) 12940 call dvmCheckBefore # (dPC, dFP, self) 12941 movl rSELF, %eax 129421: 12943 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 12944 jmp *dvmAsmInstructionStart+(55*4) 12945 12946/* ------------------------------ */ 12947.L_ALT_OP_IF_EQZ: /* 0x38 */ 12948/* File: x86/alt_stub.S */ 12949/* 12950 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 12951 * any interesting requests and then jump to the real instruction 12952 * handler. Unlike the Arm handler, we can't do this as a tail call 12953 * because rIBASE is caller save and we need to reload it. 12954 * 12955 * Note that unlike in the Arm implementation, we should never arrive 12956 * here with a zero breakFlag because we always refresh rIBASE on 12957 * return. 12958 */ 12959 EXPORT_PC 12960 movl rSELF, %eax 12961 movl rPC, OUT_ARG0(%esp) 12962 cmpb $0,offThread_breakFlags(%eax) # anything to do? 12963 movl rFP, OUT_ARG1(%esp) 12964 je 1f # reload rIBASE & resume if not 12965 movl %eax, OUT_ARG2(%esp) 12966 call dvmCheckBefore # (dPC, dFP, self) 12967 movl rSELF, %eax 129681: 12969 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 12970 jmp *dvmAsmInstructionStart+(56*4) 12971 12972/* ------------------------------ */ 12973.L_ALT_OP_IF_NEZ: /* 0x39 */ 12974/* File: x86/alt_stub.S */ 12975/* 12976 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 12977 * any interesting requests and then jump to the real instruction 12978 * handler. Unlike the Arm handler, we can't do this as a tail call 12979 * because rIBASE is caller save and we need to reload it. 12980 * 12981 * Note that unlike in the Arm implementation, we should never arrive 12982 * here with a zero breakFlag because we always refresh rIBASE on 12983 * return. 12984 */ 12985 EXPORT_PC 12986 movl rSELF, %eax 12987 movl rPC, OUT_ARG0(%esp) 12988 cmpb $0,offThread_breakFlags(%eax) # anything to do? 12989 movl rFP, OUT_ARG1(%esp) 12990 je 1f # reload rIBASE & resume if not 12991 movl %eax, OUT_ARG2(%esp) 12992 call dvmCheckBefore # (dPC, dFP, self) 12993 movl rSELF, %eax 129941: 12995 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 12996 jmp *dvmAsmInstructionStart+(57*4) 12997 12998/* ------------------------------ */ 12999.L_ALT_OP_IF_LTZ: /* 0x3a */ 13000/* File: x86/alt_stub.S */ 13001/* 13002 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 13003 * any interesting requests and then jump to the real instruction 13004 * handler. Unlike the Arm handler, we can't do this as a tail call 13005 * because rIBASE is caller save and we need to reload it. 13006 * 13007 * Note that unlike in the Arm implementation, we should never arrive 13008 * here with a zero breakFlag because we always refresh rIBASE on 13009 * return. 13010 */ 13011 EXPORT_PC 13012 movl rSELF, %eax 13013 movl rPC, OUT_ARG0(%esp) 13014 cmpb $0,offThread_breakFlags(%eax) # anything to do? 13015 movl rFP, OUT_ARG1(%esp) 13016 je 1f # reload rIBASE & resume if not 13017 movl %eax, OUT_ARG2(%esp) 13018 call dvmCheckBefore # (dPC, dFP, self) 13019 movl rSELF, %eax 130201: 13021 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 13022 jmp *dvmAsmInstructionStart+(58*4) 13023 13024/* ------------------------------ */ 13025.L_ALT_OP_IF_GEZ: /* 0x3b */ 13026/* File: x86/alt_stub.S */ 13027/* 13028 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 13029 * any interesting requests and then jump to the real instruction 13030 * handler. Unlike the Arm handler, we can't do this as a tail call 13031 * because rIBASE is caller save and we need to reload it. 13032 * 13033 * Note that unlike in the Arm implementation, we should never arrive 13034 * here with a zero breakFlag because we always refresh rIBASE on 13035 * return. 13036 */ 13037 EXPORT_PC 13038 movl rSELF, %eax 13039 movl rPC, OUT_ARG0(%esp) 13040 cmpb $0,offThread_breakFlags(%eax) # anything to do? 13041 movl rFP, OUT_ARG1(%esp) 13042 je 1f # reload rIBASE & resume if not 13043 movl %eax, OUT_ARG2(%esp) 13044 call dvmCheckBefore # (dPC, dFP, self) 13045 movl rSELF, %eax 130461: 13047 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 13048 jmp *dvmAsmInstructionStart+(59*4) 13049 13050/* ------------------------------ */ 13051.L_ALT_OP_IF_GTZ: /* 0x3c */ 13052/* File: x86/alt_stub.S */ 13053/* 13054 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 13055 * any interesting requests and then jump to the real instruction 13056 * handler. Unlike the Arm handler, we can't do this as a tail call 13057 * because rIBASE is caller save and we need to reload it. 13058 * 13059 * Note that unlike in the Arm implementation, we should never arrive 13060 * here with a zero breakFlag because we always refresh rIBASE on 13061 * return. 13062 */ 13063 EXPORT_PC 13064 movl rSELF, %eax 13065 movl rPC, OUT_ARG0(%esp) 13066 cmpb $0,offThread_breakFlags(%eax) # anything to do? 13067 movl rFP, OUT_ARG1(%esp) 13068 je 1f # reload rIBASE & resume if not 13069 movl %eax, OUT_ARG2(%esp) 13070 call dvmCheckBefore # (dPC, dFP, self) 13071 movl rSELF, %eax 130721: 13073 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 13074 jmp *dvmAsmInstructionStart+(60*4) 13075 13076/* ------------------------------ */ 13077.L_ALT_OP_IF_LEZ: /* 0x3d */ 13078/* File: x86/alt_stub.S */ 13079/* 13080 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 13081 * any interesting requests and then jump to the real instruction 13082 * handler. Unlike the Arm handler, we can't do this as a tail call 13083 * because rIBASE is caller save and we need to reload it. 13084 * 13085 * Note that unlike in the Arm implementation, we should never arrive 13086 * here with a zero breakFlag because we always refresh rIBASE on 13087 * return. 13088 */ 13089 EXPORT_PC 13090 movl rSELF, %eax 13091 movl rPC, OUT_ARG0(%esp) 13092 cmpb $0,offThread_breakFlags(%eax) # anything to do? 13093 movl rFP, OUT_ARG1(%esp) 13094 je 1f # reload rIBASE & resume if not 13095 movl %eax, OUT_ARG2(%esp) 13096 call dvmCheckBefore # (dPC, dFP, self) 13097 movl rSELF, %eax 130981: 13099 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 13100 jmp *dvmAsmInstructionStart+(61*4) 13101 13102/* ------------------------------ */ 13103.L_ALT_OP_UNUSED_3E: /* 0x3e */ 13104/* File: x86/alt_stub.S */ 13105/* 13106 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 13107 * any interesting requests and then jump to the real instruction 13108 * handler. Unlike the Arm handler, we can't do this as a tail call 13109 * because rIBASE is caller save and we need to reload it. 13110 * 13111 * Note that unlike in the Arm implementation, we should never arrive 13112 * here with a zero breakFlag because we always refresh rIBASE on 13113 * return. 13114 */ 13115 EXPORT_PC 13116 movl rSELF, %eax 13117 movl rPC, OUT_ARG0(%esp) 13118 cmpb $0,offThread_breakFlags(%eax) # anything to do? 13119 movl rFP, OUT_ARG1(%esp) 13120 je 1f # reload rIBASE & resume if not 13121 movl %eax, OUT_ARG2(%esp) 13122 call dvmCheckBefore # (dPC, dFP, self) 13123 movl rSELF, %eax 131241: 13125 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 13126 jmp *dvmAsmInstructionStart+(62*4) 13127 13128/* ------------------------------ */ 13129.L_ALT_OP_UNUSED_3F: /* 0x3f */ 13130/* File: x86/alt_stub.S */ 13131/* 13132 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 13133 * any interesting requests and then jump to the real instruction 13134 * handler. Unlike the Arm handler, we can't do this as a tail call 13135 * because rIBASE is caller save and we need to reload it. 13136 * 13137 * Note that unlike in the Arm implementation, we should never arrive 13138 * here with a zero breakFlag because we always refresh rIBASE on 13139 * return. 13140 */ 13141 EXPORT_PC 13142 movl rSELF, %eax 13143 movl rPC, OUT_ARG0(%esp) 13144 cmpb $0,offThread_breakFlags(%eax) # anything to do? 13145 movl rFP, OUT_ARG1(%esp) 13146 je 1f # reload rIBASE & resume if not 13147 movl %eax, OUT_ARG2(%esp) 13148 call dvmCheckBefore # (dPC, dFP, self) 13149 movl rSELF, %eax 131501: 13151 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 13152 jmp *dvmAsmInstructionStart+(63*4) 13153 13154/* ------------------------------ */ 13155.L_ALT_OP_UNUSED_40: /* 0x40 */ 13156/* File: x86/alt_stub.S */ 13157/* 13158 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 13159 * any interesting requests and then jump to the real instruction 13160 * handler. Unlike the Arm handler, we can't do this as a tail call 13161 * because rIBASE is caller save and we need to reload it. 13162 * 13163 * Note that unlike in the Arm implementation, we should never arrive 13164 * here with a zero breakFlag because we always refresh rIBASE on 13165 * return. 13166 */ 13167 EXPORT_PC 13168 movl rSELF, %eax 13169 movl rPC, OUT_ARG0(%esp) 13170 cmpb $0,offThread_breakFlags(%eax) # anything to do? 13171 movl rFP, OUT_ARG1(%esp) 13172 je 1f # reload rIBASE & resume if not 13173 movl %eax, OUT_ARG2(%esp) 13174 call dvmCheckBefore # (dPC, dFP, self) 13175 movl rSELF, %eax 131761: 13177 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 13178 jmp *dvmAsmInstructionStart+(64*4) 13179 13180/* ------------------------------ */ 13181.L_ALT_OP_UNUSED_41: /* 0x41 */ 13182/* File: x86/alt_stub.S */ 13183/* 13184 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 13185 * any interesting requests and then jump to the real instruction 13186 * handler. Unlike the Arm handler, we can't do this as a tail call 13187 * because rIBASE is caller save and we need to reload it. 13188 * 13189 * Note that unlike in the Arm implementation, we should never arrive 13190 * here with a zero breakFlag because we always refresh rIBASE on 13191 * return. 13192 */ 13193 EXPORT_PC 13194 movl rSELF, %eax 13195 movl rPC, OUT_ARG0(%esp) 13196 cmpb $0,offThread_breakFlags(%eax) # anything to do? 13197 movl rFP, OUT_ARG1(%esp) 13198 je 1f # reload rIBASE & resume if not 13199 movl %eax, OUT_ARG2(%esp) 13200 call dvmCheckBefore # (dPC, dFP, self) 13201 movl rSELF, %eax 132021: 13203 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 13204 jmp *dvmAsmInstructionStart+(65*4) 13205 13206/* ------------------------------ */ 13207.L_ALT_OP_UNUSED_42: /* 0x42 */ 13208/* File: x86/alt_stub.S */ 13209/* 13210 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 13211 * any interesting requests and then jump to the real instruction 13212 * handler. Unlike the Arm handler, we can't do this as a tail call 13213 * because rIBASE is caller save and we need to reload it. 13214 * 13215 * Note that unlike in the Arm implementation, we should never arrive 13216 * here with a zero breakFlag because we always refresh rIBASE on 13217 * return. 13218 */ 13219 EXPORT_PC 13220 movl rSELF, %eax 13221 movl rPC, OUT_ARG0(%esp) 13222 cmpb $0,offThread_breakFlags(%eax) # anything to do? 13223 movl rFP, OUT_ARG1(%esp) 13224 je 1f # reload rIBASE & resume if not 13225 movl %eax, OUT_ARG2(%esp) 13226 call dvmCheckBefore # (dPC, dFP, self) 13227 movl rSELF, %eax 132281: 13229 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 13230 jmp *dvmAsmInstructionStart+(66*4) 13231 13232/* ------------------------------ */ 13233.L_ALT_OP_UNUSED_43: /* 0x43 */ 13234/* File: x86/alt_stub.S */ 13235/* 13236 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 13237 * any interesting requests and then jump to the real instruction 13238 * handler. Unlike the Arm handler, we can't do this as a tail call 13239 * because rIBASE is caller save and we need to reload it. 13240 * 13241 * Note that unlike in the Arm implementation, we should never arrive 13242 * here with a zero breakFlag because we always refresh rIBASE on 13243 * return. 13244 */ 13245 EXPORT_PC 13246 movl rSELF, %eax 13247 movl rPC, OUT_ARG0(%esp) 13248 cmpb $0,offThread_breakFlags(%eax) # anything to do? 13249 movl rFP, OUT_ARG1(%esp) 13250 je 1f # reload rIBASE & resume if not 13251 movl %eax, OUT_ARG2(%esp) 13252 call dvmCheckBefore # (dPC, dFP, self) 13253 movl rSELF, %eax 132541: 13255 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 13256 jmp *dvmAsmInstructionStart+(67*4) 13257 13258/* ------------------------------ */ 13259.L_ALT_OP_AGET: /* 0x44 */ 13260/* File: x86/alt_stub.S */ 13261/* 13262 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 13263 * any interesting requests and then jump to the real instruction 13264 * handler. Unlike the Arm handler, we can't do this as a tail call 13265 * because rIBASE is caller save and we need to reload it. 13266 * 13267 * Note that unlike in the Arm implementation, we should never arrive 13268 * here with a zero breakFlag because we always refresh rIBASE on 13269 * return. 13270 */ 13271 EXPORT_PC 13272 movl rSELF, %eax 13273 movl rPC, OUT_ARG0(%esp) 13274 cmpb $0,offThread_breakFlags(%eax) # anything to do? 13275 movl rFP, OUT_ARG1(%esp) 13276 je 1f # reload rIBASE & resume if not 13277 movl %eax, OUT_ARG2(%esp) 13278 call dvmCheckBefore # (dPC, dFP, self) 13279 movl rSELF, %eax 132801: 13281 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 13282 jmp *dvmAsmInstructionStart+(68*4) 13283 13284/* ------------------------------ */ 13285.L_ALT_OP_AGET_WIDE: /* 0x45 */ 13286/* File: x86/alt_stub.S */ 13287/* 13288 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 13289 * any interesting requests and then jump to the real instruction 13290 * handler. Unlike the Arm handler, we can't do this as a tail call 13291 * because rIBASE is caller save and we need to reload it. 13292 * 13293 * Note that unlike in the Arm implementation, we should never arrive 13294 * here with a zero breakFlag because we always refresh rIBASE on 13295 * return. 13296 */ 13297 EXPORT_PC 13298 movl rSELF, %eax 13299 movl rPC, OUT_ARG0(%esp) 13300 cmpb $0,offThread_breakFlags(%eax) # anything to do? 13301 movl rFP, OUT_ARG1(%esp) 13302 je 1f # reload rIBASE & resume if not 13303 movl %eax, OUT_ARG2(%esp) 13304 call dvmCheckBefore # (dPC, dFP, self) 13305 movl rSELF, %eax 133061: 13307 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 13308 jmp *dvmAsmInstructionStart+(69*4) 13309 13310/* ------------------------------ */ 13311.L_ALT_OP_AGET_OBJECT: /* 0x46 */ 13312/* File: x86/alt_stub.S */ 13313/* 13314 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 13315 * any interesting requests and then jump to the real instruction 13316 * handler. Unlike the Arm handler, we can't do this as a tail call 13317 * because rIBASE is caller save and we need to reload it. 13318 * 13319 * Note that unlike in the Arm implementation, we should never arrive 13320 * here with a zero breakFlag because we always refresh rIBASE on 13321 * return. 13322 */ 13323 EXPORT_PC 13324 movl rSELF, %eax 13325 movl rPC, OUT_ARG0(%esp) 13326 cmpb $0,offThread_breakFlags(%eax) # anything to do? 13327 movl rFP, OUT_ARG1(%esp) 13328 je 1f # reload rIBASE & resume if not 13329 movl %eax, OUT_ARG2(%esp) 13330 call dvmCheckBefore # (dPC, dFP, self) 13331 movl rSELF, %eax 133321: 13333 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 13334 jmp *dvmAsmInstructionStart+(70*4) 13335 13336/* ------------------------------ */ 13337.L_ALT_OP_AGET_BOOLEAN: /* 0x47 */ 13338/* File: x86/alt_stub.S */ 13339/* 13340 * Inter-instruction transfer stub. Call out to dvmCheckBefore 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 * Note that unlike in the Arm implementation, we should never arrive 13346 * here with a zero breakFlag because we always refresh rIBASE on 13347 * return. 13348 */ 13349 EXPORT_PC 13350 movl rSELF, %eax 13351 movl rPC, OUT_ARG0(%esp) 13352 cmpb $0,offThread_breakFlags(%eax) # anything to do? 13353 movl rFP, OUT_ARG1(%esp) 13354 je 1f # reload rIBASE & resume if not 13355 movl %eax, OUT_ARG2(%esp) 13356 call dvmCheckBefore # (dPC, dFP, self) 13357 movl rSELF, %eax 133581: 13359 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 13360 jmp *dvmAsmInstructionStart+(71*4) 13361 13362/* ------------------------------ */ 13363.L_ALT_OP_AGET_BYTE: /* 0x48 */ 13364/* File: x86/alt_stub.S */ 13365/* 13366 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 13367 * any interesting requests and then jump to the real instruction 13368 * handler. Unlike the Arm handler, we can't do this as a tail call 13369 * because rIBASE is caller save and we need to reload it. 13370 * 13371 * Note that unlike in the Arm implementation, we should never arrive 13372 * here with a zero breakFlag because we always refresh rIBASE on 13373 * return. 13374 */ 13375 EXPORT_PC 13376 movl rSELF, %eax 13377 movl rPC, OUT_ARG0(%esp) 13378 cmpb $0,offThread_breakFlags(%eax) # anything to do? 13379 movl rFP, OUT_ARG1(%esp) 13380 je 1f # reload rIBASE & resume if not 13381 movl %eax, OUT_ARG2(%esp) 13382 call dvmCheckBefore # (dPC, dFP, self) 13383 movl rSELF, %eax 133841: 13385 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 13386 jmp *dvmAsmInstructionStart+(72*4) 13387 13388/* ------------------------------ */ 13389.L_ALT_OP_AGET_CHAR: /* 0x49 */ 13390/* File: x86/alt_stub.S */ 13391/* 13392 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 13393 * any interesting requests and then jump to the real instruction 13394 * handler. Unlike the Arm handler, we can't do this as a tail call 13395 * because rIBASE is caller save and we need to reload it. 13396 * 13397 * Note that unlike in the Arm implementation, we should never arrive 13398 * here with a zero breakFlag because we always refresh rIBASE on 13399 * return. 13400 */ 13401 EXPORT_PC 13402 movl rSELF, %eax 13403 movl rPC, OUT_ARG0(%esp) 13404 cmpb $0,offThread_breakFlags(%eax) # anything to do? 13405 movl rFP, OUT_ARG1(%esp) 13406 je 1f # reload rIBASE & resume if not 13407 movl %eax, OUT_ARG2(%esp) 13408 call dvmCheckBefore # (dPC, dFP, self) 13409 movl rSELF, %eax 134101: 13411 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 13412 jmp *dvmAsmInstructionStart+(73*4) 13413 13414/* ------------------------------ */ 13415.L_ALT_OP_AGET_SHORT: /* 0x4a */ 13416/* File: x86/alt_stub.S */ 13417/* 13418 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 13419 * any interesting requests and then jump to the real instruction 13420 * handler. Unlike the Arm handler, we can't do this as a tail call 13421 * because rIBASE is caller save and we need to reload it. 13422 * 13423 * Note that unlike in the Arm implementation, we should never arrive 13424 * here with a zero breakFlag because we always refresh rIBASE on 13425 * return. 13426 */ 13427 EXPORT_PC 13428 movl rSELF, %eax 13429 movl rPC, OUT_ARG0(%esp) 13430 cmpb $0,offThread_breakFlags(%eax) # anything to do? 13431 movl rFP, OUT_ARG1(%esp) 13432 je 1f # reload rIBASE & resume if not 13433 movl %eax, OUT_ARG2(%esp) 13434 call dvmCheckBefore # (dPC, dFP, self) 13435 movl rSELF, %eax 134361: 13437 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 13438 jmp *dvmAsmInstructionStart+(74*4) 13439 13440/* ------------------------------ */ 13441.L_ALT_OP_APUT: /* 0x4b */ 13442/* File: x86/alt_stub.S */ 13443/* 13444 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 13445 * any interesting requests and then jump to the real instruction 13446 * handler. Unlike the Arm handler, we can't do this as a tail call 13447 * because rIBASE is caller save and we need to reload it. 13448 * 13449 * Note that unlike in the Arm implementation, we should never arrive 13450 * here with a zero breakFlag because we always refresh rIBASE on 13451 * return. 13452 */ 13453 EXPORT_PC 13454 movl rSELF, %eax 13455 movl rPC, OUT_ARG0(%esp) 13456 cmpb $0,offThread_breakFlags(%eax) # anything to do? 13457 movl rFP, OUT_ARG1(%esp) 13458 je 1f # reload rIBASE & resume if not 13459 movl %eax, OUT_ARG2(%esp) 13460 call dvmCheckBefore # (dPC, dFP, self) 13461 movl rSELF, %eax 134621: 13463 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 13464 jmp *dvmAsmInstructionStart+(75*4) 13465 13466/* ------------------------------ */ 13467.L_ALT_OP_APUT_WIDE: /* 0x4c */ 13468/* File: x86/alt_stub.S */ 13469/* 13470 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 13471 * any interesting requests and then jump to the real instruction 13472 * handler. Unlike the Arm handler, we can't do this as a tail call 13473 * because rIBASE is caller save and we need to reload it. 13474 * 13475 * Note that unlike in the Arm implementation, we should never arrive 13476 * here with a zero breakFlag because we always refresh rIBASE on 13477 * return. 13478 */ 13479 EXPORT_PC 13480 movl rSELF, %eax 13481 movl rPC, OUT_ARG0(%esp) 13482 cmpb $0,offThread_breakFlags(%eax) # anything to do? 13483 movl rFP, OUT_ARG1(%esp) 13484 je 1f # reload rIBASE & resume if not 13485 movl %eax, OUT_ARG2(%esp) 13486 call dvmCheckBefore # (dPC, dFP, self) 13487 movl rSELF, %eax 134881: 13489 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 13490 jmp *dvmAsmInstructionStart+(76*4) 13491 13492/* ------------------------------ */ 13493.L_ALT_OP_APUT_OBJECT: /* 0x4d */ 13494/* File: x86/alt_stub.S */ 13495/* 13496 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 13497 * any interesting requests and then jump to the real instruction 13498 * handler. Unlike the Arm handler, we can't do this as a tail call 13499 * because rIBASE is caller save and we need to reload it. 13500 * 13501 * Note that unlike in the Arm implementation, we should never arrive 13502 * here with a zero breakFlag because we always refresh rIBASE on 13503 * return. 13504 */ 13505 EXPORT_PC 13506 movl rSELF, %eax 13507 movl rPC, OUT_ARG0(%esp) 13508 cmpb $0,offThread_breakFlags(%eax) # anything to do? 13509 movl rFP, OUT_ARG1(%esp) 13510 je 1f # reload rIBASE & resume if not 13511 movl %eax, OUT_ARG2(%esp) 13512 call dvmCheckBefore # (dPC, dFP, self) 13513 movl rSELF, %eax 135141: 13515 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 13516 jmp *dvmAsmInstructionStart+(77*4) 13517 13518/* ------------------------------ */ 13519.L_ALT_OP_APUT_BOOLEAN: /* 0x4e */ 13520/* File: x86/alt_stub.S */ 13521/* 13522 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 13523 * any interesting requests and then jump to the real instruction 13524 * handler. Unlike the Arm handler, we can't do this as a tail call 13525 * because rIBASE is caller save and we need to reload it. 13526 * 13527 * Note that unlike in the Arm implementation, we should never arrive 13528 * here with a zero breakFlag because we always refresh rIBASE on 13529 * return. 13530 */ 13531 EXPORT_PC 13532 movl rSELF, %eax 13533 movl rPC, OUT_ARG0(%esp) 13534 cmpb $0,offThread_breakFlags(%eax) # anything to do? 13535 movl rFP, OUT_ARG1(%esp) 13536 je 1f # reload rIBASE & resume if not 13537 movl %eax, OUT_ARG2(%esp) 13538 call dvmCheckBefore # (dPC, dFP, self) 13539 movl rSELF, %eax 135401: 13541 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 13542 jmp *dvmAsmInstructionStart+(78*4) 13543 13544/* ------------------------------ */ 13545.L_ALT_OP_APUT_BYTE: /* 0x4f */ 13546/* File: x86/alt_stub.S */ 13547/* 13548 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 13549 * any interesting requests and then jump to the real instruction 13550 * handler. Unlike the Arm handler, we can't do this as a tail call 13551 * because rIBASE is caller save and we need to reload it. 13552 * 13553 * Note that unlike in the Arm implementation, we should never arrive 13554 * here with a zero breakFlag because we always refresh rIBASE on 13555 * return. 13556 */ 13557 EXPORT_PC 13558 movl rSELF, %eax 13559 movl rPC, OUT_ARG0(%esp) 13560 cmpb $0,offThread_breakFlags(%eax) # anything to do? 13561 movl rFP, OUT_ARG1(%esp) 13562 je 1f # reload rIBASE & resume if not 13563 movl %eax, OUT_ARG2(%esp) 13564 call dvmCheckBefore # (dPC, dFP, self) 13565 movl rSELF, %eax 135661: 13567 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 13568 jmp *dvmAsmInstructionStart+(79*4) 13569 13570/* ------------------------------ */ 13571.L_ALT_OP_APUT_CHAR: /* 0x50 */ 13572/* File: x86/alt_stub.S */ 13573/* 13574 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 13575 * any interesting requests and then jump to the real instruction 13576 * handler. Unlike the Arm handler, we can't do this as a tail call 13577 * because rIBASE is caller save and we need to reload it. 13578 * 13579 * Note that unlike in the Arm implementation, we should never arrive 13580 * here with a zero breakFlag because we always refresh rIBASE on 13581 * return. 13582 */ 13583 EXPORT_PC 13584 movl rSELF, %eax 13585 movl rPC, OUT_ARG0(%esp) 13586 cmpb $0,offThread_breakFlags(%eax) # anything to do? 13587 movl rFP, OUT_ARG1(%esp) 13588 je 1f # reload rIBASE & resume if not 13589 movl %eax, OUT_ARG2(%esp) 13590 call dvmCheckBefore # (dPC, dFP, self) 13591 movl rSELF, %eax 135921: 13593 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 13594 jmp *dvmAsmInstructionStart+(80*4) 13595 13596/* ------------------------------ */ 13597.L_ALT_OP_APUT_SHORT: /* 0x51 */ 13598/* File: x86/alt_stub.S */ 13599/* 13600 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 13601 * any interesting requests and then jump to the real instruction 13602 * handler. Unlike the Arm handler, we can't do this as a tail call 13603 * because rIBASE is caller save and we need to reload it. 13604 * 13605 * Note that unlike in the Arm implementation, we should never arrive 13606 * here with a zero breakFlag because we always refresh rIBASE on 13607 * return. 13608 */ 13609 EXPORT_PC 13610 movl rSELF, %eax 13611 movl rPC, OUT_ARG0(%esp) 13612 cmpb $0,offThread_breakFlags(%eax) # anything to do? 13613 movl rFP, OUT_ARG1(%esp) 13614 je 1f # reload rIBASE & resume if not 13615 movl %eax, OUT_ARG2(%esp) 13616 call dvmCheckBefore # (dPC, dFP, self) 13617 movl rSELF, %eax 136181: 13619 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 13620 jmp *dvmAsmInstructionStart+(81*4) 13621 13622/* ------------------------------ */ 13623.L_ALT_OP_IGET: /* 0x52 */ 13624/* File: x86/alt_stub.S */ 13625/* 13626 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 13627 * any interesting requests and then jump to the real instruction 13628 * handler. Unlike the Arm handler, we can't do this as a tail call 13629 * because rIBASE is caller save and we need to reload it. 13630 * 13631 * Note that unlike in the Arm implementation, we should never arrive 13632 * here with a zero breakFlag because we always refresh rIBASE on 13633 * return. 13634 */ 13635 EXPORT_PC 13636 movl rSELF, %eax 13637 movl rPC, OUT_ARG0(%esp) 13638 cmpb $0,offThread_breakFlags(%eax) # anything to do? 13639 movl rFP, OUT_ARG1(%esp) 13640 je 1f # reload rIBASE & resume if not 13641 movl %eax, OUT_ARG2(%esp) 13642 call dvmCheckBefore # (dPC, dFP, self) 13643 movl rSELF, %eax 136441: 13645 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 13646 jmp *dvmAsmInstructionStart+(82*4) 13647 13648/* ------------------------------ */ 13649.L_ALT_OP_IGET_WIDE: /* 0x53 */ 13650/* File: x86/alt_stub.S */ 13651/* 13652 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 13653 * any interesting requests and then jump to the real instruction 13654 * handler. Unlike the Arm handler, we can't do this as a tail call 13655 * because rIBASE is caller save and we need to reload it. 13656 * 13657 * Note that unlike in the Arm implementation, we should never arrive 13658 * here with a zero breakFlag because we always refresh rIBASE on 13659 * return. 13660 */ 13661 EXPORT_PC 13662 movl rSELF, %eax 13663 movl rPC, OUT_ARG0(%esp) 13664 cmpb $0,offThread_breakFlags(%eax) # anything to do? 13665 movl rFP, OUT_ARG1(%esp) 13666 je 1f # reload rIBASE & resume if not 13667 movl %eax, OUT_ARG2(%esp) 13668 call dvmCheckBefore # (dPC, dFP, self) 13669 movl rSELF, %eax 136701: 13671 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 13672 jmp *dvmAsmInstructionStart+(83*4) 13673 13674/* ------------------------------ */ 13675.L_ALT_OP_IGET_OBJECT: /* 0x54 */ 13676/* File: x86/alt_stub.S */ 13677/* 13678 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 13679 * any interesting requests and then jump to the real instruction 13680 * handler. Unlike the Arm handler, we can't do this as a tail call 13681 * because rIBASE is caller save and we need to reload it. 13682 * 13683 * Note that unlike in the Arm implementation, we should never arrive 13684 * here with a zero breakFlag because we always refresh rIBASE on 13685 * return. 13686 */ 13687 EXPORT_PC 13688 movl rSELF, %eax 13689 movl rPC, OUT_ARG0(%esp) 13690 cmpb $0,offThread_breakFlags(%eax) # anything to do? 13691 movl rFP, OUT_ARG1(%esp) 13692 je 1f # reload rIBASE & resume if not 13693 movl %eax, OUT_ARG2(%esp) 13694 call dvmCheckBefore # (dPC, dFP, self) 13695 movl rSELF, %eax 136961: 13697 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 13698 jmp *dvmAsmInstructionStart+(84*4) 13699 13700/* ------------------------------ */ 13701.L_ALT_OP_IGET_BOOLEAN: /* 0x55 */ 13702/* File: x86/alt_stub.S */ 13703/* 13704 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 13705 * any interesting requests and then jump to the real instruction 13706 * handler. Unlike the Arm handler, we can't do this as a tail call 13707 * because rIBASE is caller save and we need to reload it. 13708 * 13709 * Note that unlike in the Arm implementation, we should never arrive 13710 * here with a zero breakFlag because we always refresh rIBASE on 13711 * return. 13712 */ 13713 EXPORT_PC 13714 movl rSELF, %eax 13715 movl rPC, OUT_ARG0(%esp) 13716 cmpb $0,offThread_breakFlags(%eax) # anything to do? 13717 movl rFP, OUT_ARG1(%esp) 13718 je 1f # reload rIBASE & resume if not 13719 movl %eax, OUT_ARG2(%esp) 13720 call dvmCheckBefore # (dPC, dFP, self) 13721 movl rSELF, %eax 137221: 13723 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 13724 jmp *dvmAsmInstructionStart+(85*4) 13725 13726/* ------------------------------ */ 13727.L_ALT_OP_IGET_BYTE: /* 0x56 */ 13728/* File: x86/alt_stub.S */ 13729/* 13730 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 13731 * any interesting requests and then jump to the real instruction 13732 * handler. Unlike the Arm handler, we can't do this as a tail call 13733 * because rIBASE is caller save and we need to reload it. 13734 * 13735 * Note that unlike in the Arm implementation, we should never arrive 13736 * here with a zero breakFlag because we always refresh rIBASE on 13737 * return. 13738 */ 13739 EXPORT_PC 13740 movl rSELF, %eax 13741 movl rPC, OUT_ARG0(%esp) 13742 cmpb $0,offThread_breakFlags(%eax) # anything to do? 13743 movl rFP, OUT_ARG1(%esp) 13744 je 1f # reload rIBASE & resume if not 13745 movl %eax, OUT_ARG2(%esp) 13746 call dvmCheckBefore # (dPC, dFP, self) 13747 movl rSELF, %eax 137481: 13749 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 13750 jmp *dvmAsmInstructionStart+(86*4) 13751 13752/* ------------------------------ */ 13753.L_ALT_OP_IGET_CHAR: /* 0x57 */ 13754/* File: x86/alt_stub.S */ 13755/* 13756 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 13757 * any interesting requests and then jump to the real instruction 13758 * handler. Unlike the Arm handler, we can't do this as a tail call 13759 * because rIBASE is caller save and we need to reload it. 13760 * 13761 * Note that unlike in the Arm implementation, we should never arrive 13762 * here with a zero breakFlag because we always refresh rIBASE on 13763 * return. 13764 */ 13765 EXPORT_PC 13766 movl rSELF, %eax 13767 movl rPC, OUT_ARG0(%esp) 13768 cmpb $0,offThread_breakFlags(%eax) # anything to do? 13769 movl rFP, OUT_ARG1(%esp) 13770 je 1f # reload rIBASE & resume if not 13771 movl %eax, OUT_ARG2(%esp) 13772 call dvmCheckBefore # (dPC, dFP, self) 13773 movl rSELF, %eax 137741: 13775 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 13776 jmp *dvmAsmInstructionStart+(87*4) 13777 13778/* ------------------------------ */ 13779.L_ALT_OP_IGET_SHORT: /* 0x58 */ 13780/* File: x86/alt_stub.S */ 13781/* 13782 * Inter-instruction transfer stub. Call out to dvmCheckBefore 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 * Note that unlike in the Arm implementation, we should never arrive 13788 * here with a zero breakFlag because we always refresh rIBASE on 13789 * return. 13790 */ 13791 EXPORT_PC 13792 movl rSELF, %eax 13793 movl rPC, OUT_ARG0(%esp) 13794 cmpb $0,offThread_breakFlags(%eax) # anything to do? 13795 movl rFP, OUT_ARG1(%esp) 13796 je 1f # reload rIBASE & resume if not 13797 movl %eax, OUT_ARG2(%esp) 13798 call dvmCheckBefore # (dPC, dFP, self) 13799 movl rSELF, %eax 138001: 13801 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 13802 jmp *dvmAsmInstructionStart+(88*4) 13803 13804/* ------------------------------ */ 13805.L_ALT_OP_IPUT: /* 0x59 */ 13806/* File: x86/alt_stub.S */ 13807/* 13808 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 13809 * any interesting requests and then jump to the real instruction 13810 * handler. Unlike the Arm handler, we can't do this as a tail call 13811 * because rIBASE is caller save and we need to reload it. 13812 * 13813 * Note that unlike in the Arm implementation, we should never arrive 13814 * here with a zero breakFlag because we always refresh rIBASE on 13815 * return. 13816 */ 13817 EXPORT_PC 13818 movl rSELF, %eax 13819 movl rPC, OUT_ARG0(%esp) 13820 cmpb $0,offThread_breakFlags(%eax) # anything to do? 13821 movl rFP, OUT_ARG1(%esp) 13822 je 1f # reload rIBASE & resume if not 13823 movl %eax, OUT_ARG2(%esp) 13824 call dvmCheckBefore # (dPC, dFP, self) 13825 movl rSELF, %eax 138261: 13827 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 13828 jmp *dvmAsmInstructionStart+(89*4) 13829 13830/* ------------------------------ */ 13831.L_ALT_OP_IPUT_WIDE: /* 0x5a */ 13832/* File: x86/alt_stub.S */ 13833/* 13834 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 13835 * any interesting requests and then jump to the real instruction 13836 * handler. Unlike the Arm handler, we can't do this as a tail call 13837 * because rIBASE is caller save and we need to reload it. 13838 * 13839 * Note that unlike in the Arm implementation, we should never arrive 13840 * here with a zero breakFlag because we always refresh rIBASE on 13841 * return. 13842 */ 13843 EXPORT_PC 13844 movl rSELF, %eax 13845 movl rPC, OUT_ARG0(%esp) 13846 cmpb $0,offThread_breakFlags(%eax) # anything to do? 13847 movl rFP, OUT_ARG1(%esp) 13848 je 1f # reload rIBASE & resume if not 13849 movl %eax, OUT_ARG2(%esp) 13850 call dvmCheckBefore # (dPC, dFP, self) 13851 movl rSELF, %eax 138521: 13853 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 13854 jmp *dvmAsmInstructionStart+(90*4) 13855 13856/* ------------------------------ */ 13857.L_ALT_OP_IPUT_OBJECT: /* 0x5b */ 13858/* File: x86/alt_stub.S */ 13859/* 13860 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 13861 * any interesting requests and then jump to the real instruction 13862 * handler. Unlike the Arm handler, we can't do this as a tail call 13863 * because rIBASE is caller save and we need to reload it. 13864 * 13865 * Note that unlike in the Arm implementation, we should never arrive 13866 * here with a zero breakFlag because we always refresh rIBASE on 13867 * return. 13868 */ 13869 EXPORT_PC 13870 movl rSELF, %eax 13871 movl rPC, OUT_ARG0(%esp) 13872 cmpb $0,offThread_breakFlags(%eax) # anything to do? 13873 movl rFP, OUT_ARG1(%esp) 13874 je 1f # reload rIBASE & resume if not 13875 movl %eax, OUT_ARG2(%esp) 13876 call dvmCheckBefore # (dPC, dFP, self) 13877 movl rSELF, %eax 138781: 13879 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 13880 jmp *dvmAsmInstructionStart+(91*4) 13881 13882/* ------------------------------ */ 13883.L_ALT_OP_IPUT_BOOLEAN: /* 0x5c */ 13884/* File: x86/alt_stub.S */ 13885/* 13886 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 13887 * any interesting requests and then jump to the real instruction 13888 * handler. Unlike the Arm handler, we can't do this as a tail call 13889 * because rIBASE is caller save and we need to reload it. 13890 * 13891 * Note that unlike in the Arm implementation, we should never arrive 13892 * here with a zero breakFlag because we always refresh rIBASE on 13893 * return. 13894 */ 13895 EXPORT_PC 13896 movl rSELF, %eax 13897 movl rPC, OUT_ARG0(%esp) 13898 cmpb $0,offThread_breakFlags(%eax) # anything to do? 13899 movl rFP, OUT_ARG1(%esp) 13900 je 1f # reload rIBASE & resume if not 13901 movl %eax, OUT_ARG2(%esp) 13902 call dvmCheckBefore # (dPC, dFP, self) 13903 movl rSELF, %eax 139041: 13905 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 13906 jmp *dvmAsmInstructionStart+(92*4) 13907 13908/* ------------------------------ */ 13909.L_ALT_OP_IPUT_BYTE: /* 0x5d */ 13910/* File: x86/alt_stub.S */ 13911/* 13912 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 13913 * any interesting requests and then jump to the real instruction 13914 * handler. Unlike the Arm handler, we can't do this as a tail call 13915 * because rIBASE is caller save and we need to reload it. 13916 * 13917 * Note that unlike in the Arm implementation, we should never arrive 13918 * here with a zero breakFlag because we always refresh rIBASE on 13919 * return. 13920 */ 13921 EXPORT_PC 13922 movl rSELF, %eax 13923 movl rPC, OUT_ARG0(%esp) 13924 cmpb $0,offThread_breakFlags(%eax) # anything to do? 13925 movl rFP, OUT_ARG1(%esp) 13926 je 1f # reload rIBASE & resume if not 13927 movl %eax, OUT_ARG2(%esp) 13928 call dvmCheckBefore # (dPC, dFP, self) 13929 movl rSELF, %eax 139301: 13931 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 13932 jmp *dvmAsmInstructionStart+(93*4) 13933 13934/* ------------------------------ */ 13935.L_ALT_OP_IPUT_CHAR: /* 0x5e */ 13936/* File: x86/alt_stub.S */ 13937/* 13938 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 13939 * any interesting requests and then jump to the real instruction 13940 * handler. Unlike the Arm handler, we can't do this as a tail call 13941 * because rIBASE is caller save and we need to reload it. 13942 * 13943 * Note that unlike in the Arm implementation, we should never arrive 13944 * here with a zero breakFlag because we always refresh rIBASE on 13945 * return. 13946 */ 13947 EXPORT_PC 13948 movl rSELF, %eax 13949 movl rPC, OUT_ARG0(%esp) 13950 cmpb $0,offThread_breakFlags(%eax) # anything to do? 13951 movl rFP, OUT_ARG1(%esp) 13952 je 1f # reload rIBASE & resume if not 13953 movl %eax, OUT_ARG2(%esp) 13954 call dvmCheckBefore # (dPC, dFP, self) 13955 movl rSELF, %eax 139561: 13957 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 13958 jmp *dvmAsmInstructionStart+(94*4) 13959 13960/* ------------------------------ */ 13961.L_ALT_OP_IPUT_SHORT: /* 0x5f */ 13962/* File: x86/alt_stub.S */ 13963/* 13964 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 13965 * any interesting requests and then jump to the real instruction 13966 * handler. Unlike the Arm handler, we can't do this as a tail call 13967 * because rIBASE is caller save and we need to reload it. 13968 * 13969 * Note that unlike in the Arm implementation, we should never arrive 13970 * here with a zero breakFlag because we always refresh rIBASE on 13971 * return. 13972 */ 13973 EXPORT_PC 13974 movl rSELF, %eax 13975 movl rPC, OUT_ARG0(%esp) 13976 cmpb $0,offThread_breakFlags(%eax) # anything to do? 13977 movl rFP, OUT_ARG1(%esp) 13978 je 1f # reload rIBASE & resume if not 13979 movl %eax, OUT_ARG2(%esp) 13980 call dvmCheckBefore # (dPC, dFP, self) 13981 movl rSELF, %eax 139821: 13983 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 13984 jmp *dvmAsmInstructionStart+(95*4) 13985 13986/* ------------------------------ */ 13987.L_ALT_OP_SGET: /* 0x60 */ 13988/* File: x86/alt_stub.S */ 13989/* 13990 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 13991 * any interesting requests and then jump to the real instruction 13992 * handler. Unlike the Arm handler, we can't do this as a tail call 13993 * because rIBASE is caller save and we need to reload it. 13994 * 13995 * Note that unlike in the Arm implementation, we should never arrive 13996 * here with a zero breakFlag because we always refresh rIBASE on 13997 * return. 13998 */ 13999 EXPORT_PC 14000 movl rSELF, %eax 14001 movl rPC, OUT_ARG0(%esp) 14002 cmpb $0,offThread_breakFlags(%eax) # anything to do? 14003 movl rFP, OUT_ARG1(%esp) 14004 je 1f # reload rIBASE & resume if not 14005 movl %eax, OUT_ARG2(%esp) 14006 call dvmCheckBefore # (dPC, dFP, self) 14007 movl rSELF, %eax 140081: 14009 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 14010 jmp *dvmAsmInstructionStart+(96*4) 14011 14012/* ------------------------------ */ 14013.L_ALT_OP_SGET_WIDE: /* 0x61 */ 14014/* File: x86/alt_stub.S */ 14015/* 14016 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 14017 * any interesting requests and then jump to the real instruction 14018 * handler. Unlike the Arm handler, we can't do this as a tail call 14019 * because rIBASE is caller save and we need to reload it. 14020 * 14021 * Note that unlike in the Arm implementation, we should never arrive 14022 * here with a zero breakFlag because we always refresh rIBASE on 14023 * return. 14024 */ 14025 EXPORT_PC 14026 movl rSELF, %eax 14027 movl rPC, OUT_ARG0(%esp) 14028 cmpb $0,offThread_breakFlags(%eax) # anything to do? 14029 movl rFP, OUT_ARG1(%esp) 14030 je 1f # reload rIBASE & resume if not 14031 movl %eax, OUT_ARG2(%esp) 14032 call dvmCheckBefore # (dPC, dFP, self) 14033 movl rSELF, %eax 140341: 14035 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 14036 jmp *dvmAsmInstructionStart+(97*4) 14037 14038/* ------------------------------ */ 14039.L_ALT_OP_SGET_OBJECT: /* 0x62 */ 14040/* File: x86/alt_stub.S */ 14041/* 14042 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 14043 * any interesting requests and then jump to the real instruction 14044 * handler. Unlike the Arm handler, we can't do this as a tail call 14045 * because rIBASE is caller save and we need to reload it. 14046 * 14047 * Note that unlike in the Arm implementation, we should never arrive 14048 * here with a zero breakFlag because we always refresh rIBASE on 14049 * return. 14050 */ 14051 EXPORT_PC 14052 movl rSELF, %eax 14053 movl rPC, OUT_ARG0(%esp) 14054 cmpb $0,offThread_breakFlags(%eax) # anything to do? 14055 movl rFP, OUT_ARG1(%esp) 14056 je 1f # reload rIBASE & resume if not 14057 movl %eax, OUT_ARG2(%esp) 14058 call dvmCheckBefore # (dPC, dFP, self) 14059 movl rSELF, %eax 140601: 14061 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 14062 jmp *dvmAsmInstructionStart+(98*4) 14063 14064/* ------------------------------ */ 14065.L_ALT_OP_SGET_BOOLEAN: /* 0x63 */ 14066/* File: x86/alt_stub.S */ 14067/* 14068 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 14069 * any interesting requests and then jump to the real instruction 14070 * handler. Unlike the Arm handler, we can't do this as a tail call 14071 * because rIBASE is caller save and we need to reload it. 14072 * 14073 * Note that unlike in the Arm implementation, we should never arrive 14074 * here with a zero breakFlag because we always refresh rIBASE on 14075 * return. 14076 */ 14077 EXPORT_PC 14078 movl rSELF, %eax 14079 movl rPC, OUT_ARG0(%esp) 14080 cmpb $0,offThread_breakFlags(%eax) # anything to do? 14081 movl rFP, OUT_ARG1(%esp) 14082 je 1f # reload rIBASE & resume if not 14083 movl %eax, OUT_ARG2(%esp) 14084 call dvmCheckBefore # (dPC, dFP, self) 14085 movl rSELF, %eax 140861: 14087 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 14088 jmp *dvmAsmInstructionStart+(99*4) 14089 14090/* ------------------------------ */ 14091.L_ALT_OP_SGET_BYTE: /* 0x64 */ 14092/* File: x86/alt_stub.S */ 14093/* 14094 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 14095 * any interesting requests and then jump to the real instruction 14096 * handler. Unlike the Arm handler, we can't do this as a tail call 14097 * because rIBASE is caller save and we need to reload it. 14098 * 14099 * Note that unlike in the Arm implementation, we should never arrive 14100 * here with a zero breakFlag because we always refresh rIBASE on 14101 * return. 14102 */ 14103 EXPORT_PC 14104 movl rSELF, %eax 14105 movl rPC, OUT_ARG0(%esp) 14106 cmpb $0,offThread_breakFlags(%eax) # anything to do? 14107 movl rFP, OUT_ARG1(%esp) 14108 je 1f # reload rIBASE & resume if not 14109 movl %eax, OUT_ARG2(%esp) 14110 call dvmCheckBefore # (dPC, dFP, self) 14111 movl rSELF, %eax 141121: 14113 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 14114 jmp *dvmAsmInstructionStart+(100*4) 14115 14116/* ------------------------------ */ 14117.L_ALT_OP_SGET_CHAR: /* 0x65 */ 14118/* File: x86/alt_stub.S */ 14119/* 14120 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 14121 * any interesting requests and then jump to the real instruction 14122 * handler. Unlike the Arm handler, we can't do this as a tail call 14123 * because rIBASE is caller save and we need to reload it. 14124 * 14125 * Note that unlike in the Arm implementation, we should never arrive 14126 * here with a zero breakFlag because we always refresh rIBASE on 14127 * return. 14128 */ 14129 EXPORT_PC 14130 movl rSELF, %eax 14131 movl rPC, OUT_ARG0(%esp) 14132 cmpb $0,offThread_breakFlags(%eax) # anything to do? 14133 movl rFP, OUT_ARG1(%esp) 14134 je 1f # reload rIBASE & resume if not 14135 movl %eax, OUT_ARG2(%esp) 14136 call dvmCheckBefore # (dPC, dFP, self) 14137 movl rSELF, %eax 141381: 14139 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 14140 jmp *dvmAsmInstructionStart+(101*4) 14141 14142/* ------------------------------ */ 14143.L_ALT_OP_SGET_SHORT: /* 0x66 */ 14144/* File: x86/alt_stub.S */ 14145/* 14146 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 14147 * any interesting requests and then jump to the real instruction 14148 * handler. Unlike the Arm handler, we can't do this as a tail call 14149 * because rIBASE is caller save and we need to reload it. 14150 * 14151 * Note that unlike in the Arm implementation, we should never arrive 14152 * here with a zero breakFlag because we always refresh rIBASE on 14153 * return. 14154 */ 14155 EXPORT_PC 14156 movl rSELF, %eax 14157 movl rPC, OUT_ARG0(%esp) 14158 cmpb $0,offThread_breakFlags(%eax) # anything to do? 14159 movl rFP, OUT_ARG1(%esp) 14160 je 1f # reload rIBASE & resume if not 14161 movl %eax, OUT_ARG2(%esp) 14162 call dvmCheckBefore # (dPC, dFP, self) 14163 movl rSELF, %eax 141641: 14165 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 14166 jmp *dvmAsmInstructionStart+(102*4) 14167 14168/* ------------------------------ */ 14169.L_ALT_OP_SPUT: /* 0x67 */ 14170/* File: x86/alt_stub.S */ 14171/* 14172 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 14173 * any interesting requests and then jump to the real instruction 14174 * handler. Unlike the Arm handler, we can't do this as a tail call 14175 * because rIBASE is caller save and we need to reload it. 14176 * 14177 * Note that unlike in the Arm implementation, we should never arrive 14178 * here with a zero breakFlag because we always refresh rIBASE on 14179 * return. 14180 */ 14181 EXPORT_PC 14182 movl rSELF, %eax 14183 movl rPC, OUT_ARG0(%esp) 14184 cmpb $0,offThread_breakFlags(%eax) # anything to do? 14185 movl rFP, OUT_ARG1(%esp) 14186 je 1f # reload rIBASE & resume if not 14187 movl %eax, OUT_ARG2(%esp) 14188 call dvmCheckBefore # (dPC, dFP, self) 14189 movl rSELF, %eax 141901: 14191 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 14192 jmp *dvmAsmInstructionStart+(103*4) 14193 14194/* ------------------------------ */ 14195.L_ALT_OP_SPUT_WIDE: /* 0x68 */ 14196/* File: x86/alt_stub.S */ 14197/* 14198 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 14199 * any interesting requests and then jump to the real instruction 14200 * handler. Unlike the Arm handler, we can't do this as a tail call 14201 * because rIBASE is caller save and we need to reload it. 14202 * 14203 * Note that unlike in the Arm implementation, we should never arrive 14204 * here with a zero breakFlag because we always refresh rIBASE on 14205 * return. 14206 */ 14207 EXPORT_PC 14208 movl rSELF, %eax 14209 movl rPC, OUT_ARG0(%esp) 14210 cmpb $0,offThread_breakFlags(%eax) # anything to do? 14211 movl rFP, OUT_ARG1(%esp) 14212 je 1f # reload rIBASE & resume if not 14213 movl %eax, OUT_ARG2(%esp) 14214 call dvmCheckBefore # (dPC, dFP, self) 14215 movl rSELF, %eax 142161: 14217 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 14218 jmp *dvmAsmInstructionStart+(104*4) 14219 14220/* ------------------------------ */ 14221.L_ALT_OP_SPUT_OBJECT: /* 0x69 */ 14222/* File: x86/alt_stub.S */ 14223/* 14224 * Inter-instruction transfer stub. Call out to dvmCheckBefore 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 * Note that unlike in the Arm implementation, we should never arrive 14230 * here with a zero breakFlag because we always refresh rIBASE on 14231 * return. 14232 */ 14233 EXPORT_PC 14234 movl rSELF, %eax 14235 movl rPC, OUT_ARG0(%esp) 14236 cmpb $0,offThread_breakFlags(%eax) # anything to do? 14237 movl rFP, OUT_ARG1(%esp) 14238 je 1f # reload rIBASE & resume if not 14239 movl %eax, OUT_ARG2(%esp) 14240 call dvmCheckBefore # (dPC, dFP, self) 14241 movl rSELF, %eax 142421: 14243 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 14244 jmp *dvmAsmInstructionStart+(105*4) 14245 14246/* ------------------------------ */ 14247.L_ALT_OP_SPUT_BOOLEAN: /* 0x6a */ 14248/* File: x86/alt_stub.S */ 14249/* 14250 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 14251 * any interesting requests and then jump to the real instruction 14252 * handler. Unlike the Arm handler, we can't do this as a tail call 14253 * because rIBASE is caller save and we need to reload it. 14254 * 14255 * Note that unlike in the Arm implementation, we should never arrive 14256 * here with a zero breakFlag because we always refresh rIBASE on 14257 * return. 14258 */ 14259 EXPORT_PC 14260 movl rSELF, %eax 14261 movl rPC, OUT_ARG0(%esp) 14262 cmpb $0,offThread_breakFlags(%eax) # anything to do? 14263 movl rFP, OUT_ARG1(%esp) 14264 je 1f # reload rIBASE & resume if not 14265 movl %eax, OUT_ARG2(%esp) 14266 call dvmCheckBefore # (dPC, dFP, self) 14267 movl rSELF, %eax 142681: 14269 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 14270 jmp *dvmAsmInstructionStart+(106*4) 14271 14272/* ------------------------------ */ 14273.L_ALT_OP_SPUT_BYTE: /* 0x6b */ 14274/* File: x86/alt_stub.S */ 14275/* 14276 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 14277 * any interesting requests and then jump to the real instruction 14278 * handler. Unlike the Arm handler, we can't do this as a tail call 14279 * because rIBASE is caller save and we need to reload it. 14280 * 14281 * Note that unlike in the Arm implementation, we should never arrive 14282 * here with a zero breakFlag because we always refresh rIBASE on 14283 * return. 14284 */ 14285 EXPORT_PC 14286 movl rSELF, %eax 14287 movl rPC, OUT_ARG0(%esp) 14288 cmpb $0,offThread_breakFlags(%eax) # anything to do? 14289 movl rFP, OUT_ARG1(%esp) 14290 je 1f # reload rIBASE & resume if not 14291 movl %eax, OUT_ARG2(%esp) 14292 call dvmCheckBefore # (dPC, dFP, self) 14293 movl rSELF, %eax 142941: 14295 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 14296 jmp *dvmAsmInstructionStart+(107*4) 14297 14298/* ------------------------------ */ 14299.L_ALT_OP_SPUT_CHAR: /* 0x6c */ 14300/* File: x86/alt_stub.S */ 14301/* 14302 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 14303 * any interesting requests and then jump to the real instruction 14304 * handler. Unlike the Arm handler, we can't do this as a tail call 14305 * because rIBASE is caller save and we need to reload it. 14306 * 14307 * Note that unlike in the Arm implementation, we should never arrive 14308 * here with a zero breakFlag because we always refresh rIBASE on 14309 * return. 14310 */ 14311 EXPORT_PC 14312 movl rSELF, %eax 14313 movl rPC, OUT_ARG0(%esp) 14314 cmpb $0,offThread_breakFlags(%eax) # anything to do? 14315 movl rFP, OUT_ARG1(%esp) 14316 je 1f # reload rIBASE & resume if not 14317 movl %eax, OUT_ARG2(%esp) 14318 call dvmCheckBefore # (dPC, dFP, self) 14319 movl rSELF, %eax 143201: 14321 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 14322 jmp *dvmAsmInstructionStart+(108*4) 14323 14324/* ------------------------------ */ 14325.L_ALT_OP_SPUT_SHORT: /* 0x6d */ 14326/* File: x86/alt_stub.S */ 14327/* 14328 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 14329 * any interesting requests and then jump to the real instruction 14330 * handler. Unlike the Arm handler, we can't do this as a tail call 14331 * because rIBASE is caller save and we need to reload it. 14332 * 14333 * Note that unlike in the Arm implementation, we should never arrive 14334 * here with a zero breakFlag because we always refresh rIBASE on 14335 * return. 14336 */ 14337 EXPORT_PC 14338 movl rSELF, %eax 14339 movl rPC, OUT_ARG0(%esp) 14340 cmpb $0,offThread_breakFlags(%eax) # anything to do? 14341 movl rFP, OUT_ARG1(%esp) 14342 je 1f # reload rIBASE & resume if not 14343 movl %eax, OUT_ARG2(%esp) 14344 call dvmCheckBefore # (dPC, dFP, self) 14345 movl rSELF, %eax 143461: 14347 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 14348 jmp *dvmAsmInstructionStart+(109*4) 14349 14350/* ------------------------------ */ 14351.L_ALT_OP_INVOKE_VIRTUAL: /* 0x6e */ 14352/* File: x86/alt_stub.S */ 14353/* 14354 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 14355 * any interesting requests and then jump to the real instruction 14356 * handler. Unlike the Arm handler, we can't do this as a tail call 14357 * because rIBASE is caller save and we need to reload it. 14358 * 14359 * Note that unlike in the Arm implementation, we should never arrive 14360 * here with a zero breakFlag because we always refresh rIBASE on 14361 * return. 14362 */ 14363 EXPORT_PC 14364 movl rSELF, %eax 14365 movl rPC, OUT_ARG0(%esp) 14366 cmpb $0,offThread_breakFlags(%eax) # anything to do? 14367 movl rFP, OUT_ARG1(%esp) 14368 je 1f # reload rIBASE & resume if not 14369 movl %eax, OUT_ARG2(%esp) 14370 call dvmCheckBefore # (dPC, dFP, self) 14371 movl rSELF, %eax 143721: 14373 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 14374 jmp *dvmAsmInstructionStart+(110*4) 14375 14376/* ------------------------------ */ 14377.L_ALT_OP_INVOKE_SUPER: /* 0x6f */ 14378/* File: x86/alt_stub.S */ 14379/* 14380 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 14381 * any interesting requests and then jump to the real instruction 14382 * handler. Unlike the Arm handler, we can't do this as a tail call 14383 * because rIBASE is caller save and we need to reload it. 14384 * 14385 * Note that unlike in the Arm implementation, we should never arrive 14386 * here with a zero breakFlag because we always refresh rIBASE on 14387 * return. 14388 */ 14389 EXPORT_PC 14390 movl rSELF, %eax 14391 movl rPC, OUT_ARG0(%esp) 14392 cmpb $0,offThread_breakFlags(%eax) # anything to do? 14393 movl rFP, OUT_ARG1(%esp) 14394 je 1f # reload rIBASE & resume if not 14395 movl %eax, OUT_ARG2(%esp) 14396 call dvmCheckBefore # (dPC, dFP, self) 14397 movl rSELF, %eax 143981: 14399 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 14400 jmp *dvmAsmInstructionStart+(111*4) 14401 14402/* ------------------------------ */ 14403.L_ALT_OP_INVOKE_DIRECT: /* 0x70 */ 14404/* File: x86/alt_stub.S */ 14405/* 14406 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 14407 * any interesting requests and then jump to the real instruction 14408 * handler. Unlike the Arm handler, we can't do this as a tail call 14409 * because rIBASE is caller save and we need to reload it. 14410 * 14411 * Note that unlike in the Arm implementation, we should never arrive 14412 * here with a zero breakFlag because we always refresh rIBASE on 14413 * return. 14414 */ 14415 EXPORT_PC 14416 movl rSELF, %eax 14417 movl rPC, OUT_ARG0(%esp) 14418 cmpb $0,offThread_breakFlags(%eax) # anything to do? 14419 movl rFP, OUT_ARG1(%esp) 14420 je 1f # reload rIBASE & resume if not 14421 movl %eax, OUT_ARG2(%esp) 14422 call dvmCheckBefore # (dPC, dFP, self) 14423 movl rSELF, %eax 144241: 14425 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 14426 jmp *dvmAsmInstructionStart+(112*4) 14427 14428/* ------------------------------ */ 14429.L_ALT_OP_INVOKE_STATIC: /* 0x71 */ 14430/* File: x86/alt_stub.S */ 14431/* 14432 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 14433 * any interesting requests and then jump to the real instruction 14434 * handler. Unlike the Arm handler, we can't do this as a tail call 14435 * because rIBASE is caller save and we need to reload it. 14436 * 14437 * Note that unlike in the Arm implementation, we should never arrive 14438 * here with a zero breakFlag because we always refresh rIBASE on 14439 * return. 14440 */ 14441 EXPORT_PC 14442 movl rSELF, %eax 14443 movl rPC, OUT_ARG0(%esp) 14444 cmpb $0,offThread_breakFlags(%eax) # anything to do? 14445 movl rFP, OUT_ARG1(%esp) 14446 je 1f # reload rIBASE & resume if not 14447 movl %eax, OUT_ARG2(%esp) 14448 call dvmCheckBefore # (dPC, dFP, self) 14449 movl rSELF, %eax 144501: 14451 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 14452 jmp *dvmAsmInstructionStart+(113*4) 14453 14454/* ------------------------------ */ 14455.L_ALT_OP_INVOKE_INTERFACE: /* 0x72 */ 14456/* File: x86/alt_stub.S */ 14457/* 14458 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 14459 * any interesting requests and then jump to the real instruction 14460 * handler. Unlike the Arm handler, we can't do this as a tail call 14461 * because rIBASE is caller save and we need to reload it. 14462 * 14463 * Note that unlike in the Arm implementation, we should never arrive 14464 * here with a zero breakFlag because we always refresh rIBASE on 14465 * return. 14466 */ 14467 EXPORT_PC 14468 movl rSELF, %eax 14469 movl rPC, OUT_ARG0(%esp) 14470 cmpb $0,offThread_breakFlags(%eax) # anything to do? 14471 movl rFP, OUT_ARG1(%esp) 14472 je 1f # reload rIBASE & resume if not 14473 movl %eax, OUT_ARG2(%esp) 14474 call dvmCheckBefore # (dPC, dFP, self) 14475 movl rSELF, %eax 144761: 14477 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 14478 jmp *dvmAsmInstructionStart+(114*4) 14479 14480/* ------------------------------ */ 14481.L_ALT_OP_UNUSED_73: /* 0x73 */ 14482/* File: x86/alt_stub.S */ 14483/* 14484 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 14485 * any interesting requests and then jump to the real instruction 14486 * handler. Unlike the Arm handler, we can't do this as a tail call 14487 * because rIBASE is caller save and we need to reload it. 14488 * 14489 * Note that unlike in the Arm implementation, we should never arrive 14490 * here with a zero breakFlag because we always refresh rIBASE on 14491 * return. 14492 */ 14493 EXPORT_PC 14494 movl rSELF, %eax 14495 movl rPC, OUT_ARG0(%esp) 14496 cmpb $0,offThread_breakFlags(%eax) # anything to do? 14497 movl rFP, OUT_ARG1(%esp) 14498 je 1f # reload rIBASE & resume if not 14499 movl %eax, OUT_ARG2(%esp) 14500 call dvmCheckBefore # (dPC, dFP, self) 14501 movl rSELF, %eax 145021: 14503 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 14504 jmp *dvmAsmInstructionStart+(115*4) 14505 14506/* ------------------------------ */ 14507.L_ALT_OP_INVOKE_VIRTUAL_RANGE: /* 0x74 */ 14508/* File: x86/alt_stub.S */ 14509/* 14510 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 14511 * any interesting requests and then jump to the real instruction 14512 * handler. Unlike the Arm handler, we can't do this as a tail call 14513 * because rIBASE is caller save and we need to reload it. 14514 * 14515 * Note that unlike in the Arm implementation, we should never arrive 14516 * here with a zero breakFlag because we always refresh rIBASE on 14517 * return. 14518 */ 14519 EXPORT_PC 14520 movl rSELF, %eax 14521 movl rPC, OUT_ARG0(%esp) 14522 cmpb $0,offThread_breakFlags(%eax) # anything to do? 14523 movl rFP, OUT_ARG1(%esp) 14524 je 1f # reload rIBASE & resume if not 14525 movl %eax, OUT_ARG2(%esp) 14526 call dvmCheckBefore # (dPC, dFP, self) 14527 movl rSELF, %eax 145281: 14529 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 14530 jmp *dvmAsmInstructionStart+(116*4) 14531 14532/* ------------------------------ */ 14533.L_ALT_OP_INVOKE_SUPER_RANGE: /* 0x75 */ 14534/* File: x86/alt_stub.S */ 14535/* 14536 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 14537 * any interesting requests and then jump to the real instruction 14538 * handler. Unlike the Arm handler, we can't do this as a tail call 14539 * because rIBASE is caller save and we need to reload it. 14540 * 14541 * Note that unlike in the Arm implementation, we should never arrive 14542 * here with a zero breakFlag because we always refresh rIBASE on 14543 * return. 14544 */ 14545 EXPORT_PC 14546 movl rSELF, %eax 14547 movl rPC, OUT_ARG0(%esp) 14548 cmpb $0,offThread_breakFlags(%eax) # anything to do? 14549 movl rFP, OUT_ARG1(%esp) 14550 je 1f # reload rIBASE & resume if not 14551 movl %eax, OUT_ARG2(%esp) 14552 call dvmCheckBefore # (dPC, dFP, self) 14553 movl rSELF, %eax 145541: 14555 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 14556 jmp *dvmAsmInstructionStart+(117*4) 14557 14558/* ------------------------------ */ 14559.L_ALT_OP_INVOKE_DIRECT_RANGE: /* 0x76 */ 14560/* File: x86/alt_stub.S */ 14561/* 14562 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 14563 * any interesting requests and then jump to the real instruction 14564 * handler. Unlike the Arm handler, we can't do this as a tail call 14565 * because rIBASE is caller save and we need to reload it. 14566 * 14567 * Note that unlike in the Arm implementation, we should never arrive 14568 * here with a zero breakFlag because we always refresh rIBASE on 14569 * return. 14570 */ 14571 EXPORT_PC 14572 movl rSELF, %eax 14573 movl rPC, OUT_ARG0(%esp) 14574 cmpb $0,offThread_breakFlags(%eax) # anything to do? 14575 movl rFP, OUT_ARG1(%esp) 14576 je 1f # reload rIBASE & resume if not 14577 movl %eax, OUT_ARG2(%esp) 14578 call dvmCheckBefore # (dPC, dFP, self) 14579 movl rSELF, %eax 145801: 14581 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 14582 jmp *dvmAsmInstructionStart+(118*4) 14583 14584/* ------------------------------ */ 14585.L_ALT_OP_INVOKE_STATIC_RANGE: /* 0x77 */ 14586/* File: x86/alt_stub.S */ 14587/* 14588 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 14589 * any interesting requests and then jump to the real instruction 14590 * handler. Unlike the Arm handler, we can't do this as a tail call 14591 * because rIBASE is caller save and we need to reload it. 14592 * 14593 * Note that unlike in the Arm implementation, we should never arrive 14594 * here with a zero breakFlag because we always refresh rIBASE on 14595 * return. 14596 */ 14597 EXPORT_PC 14598 movl rSELF, %eax 14599 movl rPC, OUT_ARG0(%esp) 14600 cmpb $0,offThread_breakFlags(%eax) # anything to do? 14601 movl rFP, OUT_ARG1(%esp) 14602 je 1f # reload rIBASE & resume if not 14603 movl %eax, OUT_ARG2(%esp) 14604 call dvmCheckBefore # (dPC, dFP, self) 14605 movl rSELF, %eax 146061: 14607 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 14608 jmp *dvmAsmInstructionStart+(119*4) 14609 14610/* ------------------------------ */ 14611.L_ALT_OP_INVOKE_INTERFACE_RANGE: /* 0x78 */ 14612/* File: x86/alt_stub.S */ 14613/* 14614 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 14615 * any interesting requests and then jump to the real instruction 14616 * handler. Unlike the Arm handler, we can't do this as a tail call 14617 * because rIBASE is caller save and we need to reload it. 14618 * 14619 * Note that unlike in the Arm implementation, we should never arrive 14620 * here with a zero breakFlag because we always refresh rIBASE on 14621 * return. 14622 */ 14623 EXPORT_PC 14624 movl rSELF, %eax 14625 movl rPC, OUT_ARG0(%esp) 14626 cmpb $0,offThread_breakFlags(%eax) # anything to do? 14627 movl rFP, OUT_ARG1(%esp) 14628 je 1f # reload rIBASE & resume if not 14629 movl %eax, OUT_ARG2(%esp) 14630 call dvmCheckBefore # (dPC, dFP, self) 14631 movl rSELF, %eax 146321: 14633 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 14634 jmp *dvmAsmInstructionStart+(120*4) 14635 14636/* ------------------------------ */ 14637.L_ALT_OP_UNUSED_79: /* 0x79 */ 14638/* File: x86/alt_stub.S */ 14639/* 14640 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 14641 * any interesting requests and then jump to the real instruction 14642 * handler. Unlike the Arm handler, we can't do this as a tail call 14643 * because rIBASE is caller save and we need to reload it. 14644 * 14645 * Note that unlike in the Arm implementation, we should never arrive 14646 * here with a zero breakFlag because we always refresh rIBASE on 14647 * return. 14648 */ 14649 EXPORT_PC 14650 movl rSELF, %eax 14651 movl rPC, OUT_ARG0(%esp) 14652 cmpb $0,offThread_breakFlags(%eax) # anything to do? 14653 movl rFP, OUT_ARG1(%esp) 14654 je 1f # reload rIBASE & resume if not 14655 movl %eax, OUT_ARG2(%esp) 14656 call dvmCheckBefore # (dPC, dFP, self) 14657 movl rSELF, %eax 146581: 14659 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 14660 jmp *dvmAsmInstructionStart+(121*4) 14661 14662/* ------------------------------ */ 14663.L_ALT_OP_UNUSED_7A: /* 0x7a */ 14664/* File: x86/alt_stub.S */ 14665/* 14666 * Inter-instruction transfer stub. Call out to dvmCheckBefore 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 * Note that unlike in the Arm implementation, we should never arrive 14672 * here with a zero breakFlag because we always refresh rIBASE on 14673 * return. 14674 */ 14675 EXPORT_PC 14676 movl rSELF, %eax 14677 movl rPC, OUT_ARG0(%esp) 14678 cmpb $0,offThread_breakFlags(%eax) # anything to do? 14679 movl rFP, OUT_ARG1(%esp) 14680 je 1f # reload rIBASE & resume if not 14681 movl %eax, OUT_ARG2(%esp) 14682 call dvmCheckBefore # (dPC, dFP, self) 14683 movl rSELF, %eax 146841: 14685 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 14686 jmp *dvmAsmInstructionStart+(122*4) 14687 14688/* ------------------------------ */ 14689.L_ALT_OP_NEG_INT: /* 0x7b */ 14690/* File: x86/alt_stub.S */ 14691/* 14692 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 14693 * any interesting requests and then jump to the real instruction 14694 * handler. Unlike the Arm handler, we can't do this as a tail call 14695 * because rIBASE is caller save and we need to reload it. 14696 * 14697 * Note that unlike in the Arm implementation, we should never arrive 14698 * here with a zero breakFlag because we always refresh rIBASE on 14699 * return. 14700 */ 14701 EXPORT_PC 14702 movl rSELF, %eax 14703 movl rPC, OUT_ARG0(%esp) 14704 cmpb $0,offThread_breakFlags(%eax) # anything to do? 14705 movl rFP, OUT_ARG1(%esp) 14706 je 1f # reload rIBASE & resume if not 14707 movl %eax, OUT_ARG2(%esp) 14708 call dvmCheckBefore # (dPC, dFP, self) 14709 movl rSELF, %eax 147101: 14711 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 14712 jmp *dvmAsmInstructionStart+(123*4) 14713 14714/* ------------------------------ */ 14715.L_ALT_OP_NOT_INT: /* 0x7c */ 14716/* File: x86/alt_stub.S */ 14717/* 14718 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 14719 * any interesting requests and then jump to the real instruction 14720 * handler. Unlike the Arm handler, we can't do this as a tail call 14721 * because rIBASE is caller save and we need to reload it. 14722 * 14723 * Note that unlike in the Arm implementation, we should never arrive 14724 * here with a zero breakFlag because we always refresh rIBASE on 14725 * return. 14726 */ 14727 EXPORT_PC 14728 movl rSELF, %eax 14729 movl rPC, OUT_ARG0(%esp) 14730 cmpb $0,offThread_breakFlags(%eax) # anything to do? 14731 movl rFP, OUT_ARG1(%esp) 14732 je 1f # reload rIBASE & resume if not 14733 movl %eax, OUT_ARG2(%esp) 14734 call dvmCheckBefore # (dPC, dFP, self) 14735 movl rSELF, %eax 147361: 14737 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 14738 jmp *dvmAsmInstructionStart+(124*4) 14739 14740/* ------------------------------ */ 14741.L_ALT_OP_NEG_LONG: /* 0x7d */ 14742/* File: x86/alt_stub.S */ 14743/* 14744 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 14745 * any interesting requests and then jump to the real instruction 14746 * handler. Unlike the Arm handler, we can't do this as a tail call 14747 * because rIBASE is caller save and we need to reload it. 14748 * 14749 * Note that unlike in the Arm implementation, we should never arrive 14750 * here with a zero breakFlag because we always refresh rIBASE on 14751 * return. 14752 */ 14753 EXPORT_PC 14754 movl rSELF, %eax 14755 movl rPC, OUT_ARG0(%esp) 14756 cmpb $0,offThread_breakFlags(%eax) # anything to do? 14757 movl rFP, OUT_ARG1(%esp) 14758 je 1f # reload rIBASE & resume if not 14759 movl %eax, OUT_ARG2(%esp) 14760 call dvmCheckBefore # (dPC, dFP, self) 14761 movl rSELF, %eax 147621: 14763 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 14764 jmp *dvmAsmInstructionStart+(125*4) 14765 14766/* ------------------------------ */ 14767.L_ALT_OP_NOT_LONG: /* 0x7e */ 14768/* File: x86/alt_stub.S */ 14769/* 14770 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 14771 * any interesting requests and then jump to the real instruction 14772 * handler. Unlike the Arm handler, we can't do this as a tail call 14773 * because rIBASE is caller save and we need to reload it. 14774 * 14775 * Note that unlike in the Arm implementation, we should never arrive 14776 * here with a zero breakFlag because we always refresh rIBASE on 14777 * return. 14778 */ 14779 EXPORT_PC 14780 movl rSELF, %eax 14781 movl rPC, OUT_ARG0(%esp) 14782 cmpb $0,offThread_breakFlags(%eax) # anything to do? 14783 movl rFP, OUT_ARG1(%esp) 14784 je 1f # reload rIBASE & resume if not 14785 movl %eax, OUT_ARG2(%esp) 14786 call dvmCheckBefore # (dPC, dFP, self) 14787 movl rSELF, %eax 147881: 14789 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 14790 jmp *dvmAsmInstructionStart+(126*4) 14791 14792/* ------------------------------ */ 14793.L_ALT_OP_NEG_FLOAT: /* 0x7f */ 14794/* File: x86/alt_stub.S */ 14795/* 14796 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 14797 * any interesting requests and then jump to the real instruction 14798 * handler. Unlike the Arm handler, we can't do this as a tail call 14799 * because rIBASE is caller save and we need to reload it. 14800 * 14801 * Note that unlike in the Arm implementation, we should never arrive 14802 * here with a zero breakFlag because we always refresh rIBASE on 14803 * return. 14804 */ 14805 EXPORT_PC 14806 movl rSELF, %eax 14807 movl rPC, OUT_ARG0(%esp) 14808 cmpb $0,offThread_breakFlags(%eax) # anything to do? 14809 movl rFP, OUT_ARG1(%esp) 14810 je 1f # reload rIBASE & resume if not 14811 movl %eax, OUT_ARG2(%esp) 14812 call dvmCheckBefore # (dPC, dFP, self) 14813 movl rSELF, %eax 148141: 14815 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 14816 jmp *dvmAsmInstructionStart+(127*4) 14817 14818/* ------------------------------ */ 14819.L_ALT_OP_NEG_DOUBLE: /* 0x80 */ 14820/* File: x86/alt_stub.S */ 14821/* 14822 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 14823 * any interesting requests and then jump to the real instruction 14824 * handler. Unlike the Arm handler, we can't do this as a tail call 14825 * because rIBASE is caller save and we need to reload it. 14826 * 14827 * Note that unlike in the Arm implementation, we should never arrive 14828 * here with a zero breakFlag because we always refresh rIBASE on 14829 * return. 14830 */ 14831 EXPORT_PC 14832 movl rSELF, %eax 14833 movl rPC, OUT_ARG0(%esp) 14834 cmpb $0,offThread_breakFlags(%eax) # anything to do? 14835 movl rFP, OUT_ARG1(%esp) 14836 je 1f # reload rIBASE & resume if not 14837 movl %eax, OUT_ARG2(%esp) 14838 call dvmCheckBefore # (dPC, dFP, self) 14839 movl rSELF, %eax 148401: 14841 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 14842 jmp *dvmAsmInstructionStart+(128*4) 14843 14844/* ------------------------------ */ 14845.L_ALT_OP_INT_TO_LONG: /* 0x81 */ 14846/* File: x86/alt_stub.S */ 14847/* 14848 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 14849 * any interesting requests and then jump to the real instruction 14850 * handler. Unlike the Arm handler, we can't do this as a tail call 14851 * because rIBASE is caller save and we need to reload it. 14852 * 14853 * Note that unlike in the Arm implementation, we should never arrive 14854 * here with a zero breakFlag because we always refresh rIBASE on 14855 * return. 14856 */ 14857 EXPORT_PC 14858 movl rSELF, %eax 14859 movl rPC, OUT_ARG0(%esp) 14860 cmpb $0,offThread_breakFlags(%eax) # anything to do? 14861 movl rFP, OUT_ARG1(%esp) 14862 je 1f # reload rIBASE & resume if not 14863 movl %eax, OUT_ARG2(%esp) 14864 call dvmCheckBefore # (dPC, dFP, self) 14865 movl rSELF, %eax 148661: 14867 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 14868 jmp *dvmAsmInstructionStart+(129*4) 14869 14870/* ------------------------------ */ 14871.L_ALT_OP_INT_TO_FLOAT: /* 0x82 */ 14872/* File: x86/alt_stub.S */ 14873/* 14874 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 14875 * any interesting requests and then jump to the real instruction 14876 * handler. Unlike the Arm handler, we can't do this as a tail call 14877 * because rIBASE is caller save and we need to reload it. 14878 * 14879 * Note that unlike in the Arm implementation, we should never arrive 14880 * here with a zero breakFlag because we always refresh rIBASE on 14881 * return. 14882 */ 14883 EXPORT_PC 14884 movl rSELF, %eax 14885 movl rPC, OUT_ARG0(%esp) 14886 cmpb $0,offThread_breakFlags(%eax) # anything to do? 14887 movl rFP, OUT_ARG1(%esp) 14888 je 1f # reload rIBASE & resume if not 14889 movl %eax, OUT_ARG2(%esp) 14890 call dvmCheckBefore # (dPC, dFP, self) 14891 movl rSELF, %eax 148921: 14893 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 14894 jmp *dvmAsmInstructionStart+(130*4) 14895 14896/* ------------------------------ */ 14897.L_ALT_OP_INT_TO_DOUBLE: /* 0x83 */ 14898/* File: x86/alt_stub.S */ 14899/* 14900 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 14901 * any interesting requests and then jump to the real instruction 14902 * handler. Unlike the Arm handler, we can't do this as a tail call 14903 * because rIBASE is caller save and we need to reload it. 14904 * 14905 * Note that unlike in the Arm implementation, we should never arrive 14906 * here with a zero breakFlag because we always refresh rIBASE on 14907 * return. 14908 */ 14909 EXPORT_PC 14910 movl rSELF, %eax 14911 movl rPC, OUT_ARG0(%esp) 14912 cmpb $0,offThread_breakFlags(%eax) # anything to do? 14913 movl rFP, OUT_ARG1(%esp) 14914 je 1f # reload rIBASE & resume if not 14915 movl %eax, OUT_ARG2(%esp) 14916 call dvmCheckBefore # (dPC, dFP, self) 14917 movl rSELF, %eax 149181: 14919 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 14920 jmp *dvmAsmInstructionStart+(131*4) 14921 14922/* ------------------------------ */ 14923.L_ALT_OP_LONG_TO_INT: /* 0x84 */ 14924/* File: x86/alt_stub.S */ 14925/* 14926 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 14927 * any interesting requests and then jump to the real instruction 14928 * handler. Unlike the Arm handler, we can't do this as a tail call 14929 * because rIBASE is caller save and we need to reload it. 14930 * 14931 * Note that unlike in the Arm implementation, we should never arrive 14932 * here with a zero breakFlag because we always refresh rIBASE on 14933 * return. 14934 */ 14935 EXPORT_PC 14936 movl rSELF, %eax 14937 movl rPC, OUT_ARG0(%esp) 14938 cmpb $0,offThread_breakFlags(%eax) # anything to do? 14939 movl rFP, OUT_ARG1(%esp) 14940 je 1f # reload rIBASE & resume if not 14941 movl %eax, OUT_ARG2(%esp) 14942 call dvmCheckBefore # (dPC, dFP, self) 14943 movl rSELF, %eax 149441: 14945 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 14946 jmp *dvmAsmInstructionStart+(132*4) 14947 14948/* ------------------------------ */ 14949.L_ALT_OP_LONG_TO_FLOAT: /* 0x85 */ 14950/* File: x86/alt_stub.S */ 14951/* 14952 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 14953 * any interesting requests and then jump to the real instruction 14954 * handler. Unlike the Arm handler, we can't do this as a tail call 14955 * because rIBASE is caller save and we need to reload it. 14956 * 14957 * Note that unlike in the Arm implementation, we should never arrive 14958 * here with a zero breakFlag because we always refresh rIBASE on 14959 * return. 14960 */ 14961 EXPORT_PC 14962 movl rSELF, %eax 14963 movl rPC, OUT_ARG0(%esp) 14964 cmpb $0,offThread_breakFlags(%eax) # anything to do? 14965 movl rFP, OUT_ARG1(%esp) 14966 je 1f # reload rIBASE & resume if not 14967 movl %eax, OUT_ARG2(%esp) 14968 call dvmCheckBefore # (dPC, dFP, self) 14969 movl rSELF, %eax 149701: 14971 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 14972 jmp *dvmAsmInstructionStart+(133*4) 14973 14974/* ------------------------------ */ 14975.L_ALT_OP_LONG_TO_DOUBLE: /* 0x86 */ 14976/* File: x86/alt_stub.S */ 14977/* 14978 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 14979 * any interesting requests and then jump to the real instruction 14980 * handler. Unlike the Arm handler, we can't do this as a tail call 14981 * because rIBASE is caller save and we need to reload it. 14982 * 14983 * Note that unlike in the Arm implementation, we should never arrive 14984 * here with a zero breakFlag because we always refresh rIBASE on 14985 * return. 14986 */ 14987 EXPORT_PC 14988 movl rSELF, %eax 14989 movl rPC, OUT_ARG0(%esp) 14990 cmpb $0,offThread_breakFlags(%eax) # anything to do? 14991 movl rFP, OUT_ARG1(%esp) 14992 je 1f # reload rIBASE & resume if not 14993 movl %eax, OUT_ARG2(%esp) 14994 call dvmCheckBefore # (dPC, dFP, self) 14995 movl rSELF, %eax 149961: 14997 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 14998 jmp *dvmAsmInstructionStart+(134*4) 14999 15000/* ------------------------------ */ 15001.L_ALT_OP_FLOAT_TO_INT: /* 0x87 */ 15002/* File: x86/alt_stub.S */ 15003/* 15004 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 15005 * any interesting requests and then jump to the real instruction 15006 * handler. Unlike the Arm handler, we can't do this as a tail call 15007 * because rIBASE is caller save and we need to reload it. 15008 * 15009 * Note that unlike in the Arm implementation, we should never arrive 15010 * here with a zero breakFlag because we always refresh rIBASE on 15011 * return. 15012 */ 15013 EXPORT_PC 15014 movl rSELF, %eax 15015 movl rPC, OUT_ARG0(%esp) 15016 cmpb $0,offThread_breakFlags(%eax) # anything to do? 15017 movl rFP, OUT_ARG1(%esp) 15018 je 1f # reload rIBASE & resume if not 15019 movl %eax, OUT_ARG2(%esp) 15020 call dvmCheckBefore # (dPC, dFP, self) 15021 movl rSELF, %eax 150221: 15023 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 15024 jmp *dvmAsmInstructionStart+(135*4) 15025 15026/* ------------------------------ */ 15027.L_ALT_OP_FLOAT_TO_LONG: /* 0x88 */ 15028/* File: x86/alt_stub.S */ 15029/* 15030 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 15031 * any interesting requests and then jump to the real instruction 15032 * handler. Unlike the Arm handler, we can't do this as a tail call 15033 * because rIBASE is caller save and we need to reload it. 15034 * 15035 * Note that unlike in the Arm implementation, we should never arrive 15036 * here with a zero breakFlag because we always refresh rIBASE on 15037 * return. 15038 */ 15039 EXPORT_PC 15040 movl rSELF, %eax 15041 movl rPC, OUT_ARG0(%esp) 15042 cmpb $0,offThread_breakFlags(%eax) # anything to do? 15043 movl rFP, OUT_ARG1(%esp) 15044 je 1f # reload rIBASE & resume if not 15045 movl %eax, OUT_ARG2(%esp) 15046 call dvmCheckBefore # (dPC, dFP, self) 15047 movl rSELF, %eax 150481: 15049 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 15050 jmp *dvmAsmInstructionStart+(136*4) 15051 15052/* ------------------------------ */ 15053.L_ALT_OP_FLOAT_TO_DOUBLE: /* 0x89 */ 15054/* File: x86/alt_stub.S */ 15055/* 15056 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 15057 * any interesting requests and then jump to the real instruction 15058 * handler. Unlike the Arm handler, we can't do this as a tail call 15059 * because rIBASE is caller save and we need to reload it. 15060 * 15061 * Note that unlike in the Arm implementation, we should never arrive 15062 * here with a zero breakFlag because we always refresh rIBASE on 15063 * return. 15064 */ 15065 EXPORT_PC 15066 movl rSELF, %eax 15067 movl rPC, OUT_ARG0(%esp) 15068 cmpb $0,offThread_breakFlags(%eax) # anything to do? 15069 movl rFP, OUT_ARG1(%esp) 15070 je 1f # reload rIBASE & resume if not 15071 movl %eax, OUT_ARG2(%esp) 15072 call dvmCheckBefore # (dPC, dFP, self) 15073 movl rSELF, %eax 150741: 15075 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 15076 jmp *dvmAsmInstructionStart+(137*4) 15077 15078/* ------------------------------ */ 15079.L_ALT_OP_DOUBLE_TO_INT: /* 0x8a */ 15080/* File: x86/alt_stub.S */ 15081/* 15082 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 15083 * any interesting requests and then jump to the real instruction 15084 * handler. Unlike the Arm handler, we can't do this as a tail call 15085 * because rIBASE is caller save and we need to reload it. 15086 * 15087 * Note that unlike in the Arm implementation, we should never arrive 15088 * here with a zero breakFlag because we always refresh rIBASE on 15089 * return. 15090 */ 15091 EXPORT_PC 15092 movl rSELF, %eax 15093 movl rPC, OUT_ARG0(%esp) 15094 cmpb $0,offThread_breakFlags(%eax) # anything to do? 15095 movl rFP, OUT_ARG1(%esp) 15096 je 1f # reload rIBASE & resume if not 15097 movl %eax, OUT_ARG2(%esp) 15098 call dvmCheckBefore # (dPC, dFP, self) 15099 movl rSELF, %eax 151001: 15101 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 15102 jmp *dvmAsmInstructionStart+(138*4) 15103 15104/* ------------------------------ */ 15105.L_ALT_OP_DOUBLE_TO_LONG: /* 0x8b */ 15106/* File: x86/alt_stub.S */ 15107/* 15108 * Inter-instruction transfer stub. Call out to dvmCheckBefore 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 * Note that unlike in the Arm implementation, we should never arrive 15114 * here with a zero breakFlag because we always refresh rIBASE on 15115 * return. 15116 */ 15117 EXPORT_PC 15118 movl rSELF, %eax 15119 movl rPC, OUT_ARG0(%esp) 15120 cmpb $0,offThread_breakFlags(%eax) # anything to do? 15121 movl rFP, OUT_ARG1(%esp) 15122 je 1f # reload rIBASE & resume if not 15123 movl %eax, OUT_ARG2(%esp) 15124 call dvmCheckBefore # (dPC, dFP, self) 15125 movl rSELF, %eax 151261: 15127 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 15128 jmp *dvmAsmInstructionStart+(139*4) 15129 15130/* ------------------------------ */ 15131.L_ALT_OP_DOUBLE_TO_FLOAT: /* 0x8c */ 15132/* File: x86/alt_stub.S */ 15133/* 15134 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 15135 * any interesting requests and then jump to the real instruction 15136 * handler. Unlike the Arm handler, we can't do this as a tail call 15137 * because rIBASE is caller save and we need to reload it. 15138 * 15139 * Note that unlike in the Arm implementation, we should never arrive 15140 * here with a zero breakFlag because we always refresh rIBASE on 15141 * return. 15142 */ 15143 EXPORT_PC 15144 movl rSELF, %eax 15145 movl rPC, OUT_ARG0(%esp) 15146 cmpb $0,offThread_breakFlags(%eax) # anything to do? 15147 movl rFP, OUT_ARG1(%esp) 15148 je 1f # reload rIBASE & resume if not 15149 movl %eax, OUT_ARG2(%esp) 15150 call dvmCheckBefore # (dPC, dFP, self) 15151 movl rSELF, %eax 151521: 15153 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 15154 jmp *dvmAsmInstructionStart+(140*4) 15155 15156/* ------------------------------ */ 15157.L_ALT_OP_INT_TO_BYTE: /* 0x8d */ 15158/* File: x86/alt_stub.S */ 15159/* 15160 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 15161 * any interesting requests and then jump to the real instruction 15162 * handler. Unlike the Arm handler, we can't do this as a tail call 15163 * because rIBASE is caller save and we need to reload it. 15164 * 15165 * Note that unlike in the Arm implementation, we should never arrive 15166 * here with a zero breakFlag because we always refresh rIBASE on 15167 * return. 15168 */ 15169 EXPORT_PC 15170 movl rSELF, %eax 15171 movl rPC, OUT_ARG0(%esp) 15172 cmpb $0,offThread_breakFlags(%eax) # anything to do? 15173 movl rFP, OUT_ARG1(%esp) 15174 je 1f # reload rIBASE & resume if not 15175 movl %eax, OUT_ARG2(%esp) 15176 call dvmCheckBefore # (dPC, dFP, self) 15177 movl rSELF, %eax 151781: 15179 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 15180 jmp *dvmAsmInstructionStart+(141*4) 15181 15182/* ------------------------------ */ 15183.L_ALT_OP_INT_TO_CHAR: /* 0x8e */ 15184/* File: x86/alt_stub.S */ 15185/* 15186 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 15187 * any interesting requests and then jump to the real instruction 15188 * handler. Unlike the Arm handler, we can't do this as a tail call 15189 * because rIBASE is caller save and we need to reload it. 15190 * 15191 * Note that unlike in the Arm implementation, we should never arrive 15192 * here with a zero breakFlag because we always refresh rIBASE on 15193 * return. 15194 */ 15195 EXPORT_PC 15196 movl rSELF, %eax 15197 movl rPC, OUT_ARG0(%esp) 15198 cmpb $0,offThread_breakFlags(%eax) # anything to do? 15199 movl rFP, OUT_ARG1(%esp) 15200 je 1f # reload rIBASE & resume if not 15201 movl %eax, OUT_ARG2(%esp) 15202 call dvmCheckBefore # (dPC, dFP, self) 15203 movl rSELF, %eax 152041: 15205 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 15206 jmp *dvmAsmInstructionStart+(142*4) 15207 15208/* ------------------------------ */ 15209.L_ALT_OP_INT_TO_SHORT: /* 0x8f */ 15210/* File: x86/alt_stub.S */ 15211/* 15212 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 15213 * any interesting requests and then jump to the real instruction 15214 * handler. Unlike the Arm handler, we can't do this as a tail call 15215 * because rIBASE is caller save and we need to reload it. 15216 * 15217 * Note that unlike in the Arm implementation, we should never arrive 15218 * here with a zero breakFlag because we always refresh rIBASE on 15219 * return. 15220 */ 15221 EXPORT_PC 15222 movl rSELF, %eax 15223 movl rPC, OUT_ARG0(%esp) 15224 cmpb $0,offThread_breakFlags(%eax) # anything to do? 15225 movl rFP, OUT_ARG1(%esp) 15226 je 1f # reload rIBASE & resume if not 15227 movl %eax, OUT_ARG2(%esp) 15228 call dvmCheckBefore # (dPC, dFP, self) 15229 movl rSELF, %eax 152301: 15231 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 15232 jmp *dvmAsmInstructionStart+(143*4) 15233 15234/* ------------------------------ */ 15235.L_ALT_OP_ADD_INT: /* 0x90 */ 15236/* File: x86/alt_stub.S */ 15237/* 15238 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 15239 * any interesting requests and then jump to the real instruction 15240 * handler. Unlike the Arm handler, we can't do this as a tail call 15241 * because rIBASE is caller save and we need to reload it. 15242 * 15243 * Note that unlike in the Arm implementation, we should never arrive 15244 * here with a zero breakFlag because we always refresh rIBASE on 15245 * return. 15246 */ 15247 EXPORT_PC 15248 movl rSELF, %eax 15249 movl rPC, OUT_ARG0(%esp) 15250 cmpb $0,offThread_breakFlags(%eax) # anything to do? 15251 movl rFP, OUT_ARG1(%esp) 15252 je 1f # reload rIBASE & resume if not 15253 movl %eax, OUT_ARG2(%esp) 15254 call dvmCheckBefore # (dPC, dFP, self) 15255 movl rSELF, %eax 152561: 15257 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 15258 jmp *dvmAsmInstructionStart+(144*4) 15259 15260/* ------------------------------ */ 15261.L_ALT_OP_SUB_INT: /* 0x91 */ 15262/* File: x86/alt_stub.S */ 15263/* 15264 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 15265 * any interesting requests and then jump to the real instruction 15266 * handler. Unlike the Arm handler, we can't do this as a tail call 15267 * because rIBASE is caller save and we need to reload it. 15268 * 15269 * Note that unlike in the Arm implementation, we should never arrive 15270 * here with a zero breakFlag because we always refresh rIBASE on 15271 * return. 15272 */ 15273 EXPORT_PC 15274 movl rSELF, %eax 15275 movl rPC, OUT_ARG0(%esp) 15276 cmpb $0,offThread_breakFlags(%eax) # anything to do? 15277 movl rFP, OUT_ARG1(%esp) 15278 je 1f # reload rIBASE & resume if not 15279 movl %eax, OUT_ARG2(%esp) 15280 call dvmCheckBefore # (dPC, dFP, self) 15281 movl rSELF, %eax 152821: 15283 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 15284 jmp *dvmAsmInstructionStart+(145*4) 15285 15286/* ------------------------------ */ 15287.L_ALT_OP_MUL_INT: /* 0x92 */ 15288/* File: x86/alt_stub.S */ 15289/* 15290 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 15291 * any interesting requests and then jump to the real instruction 15292 * handler. Unlike the Arm handler, we can't do this as a tail call 15293 * because rIBASE is caller save and we need to reload it. 15294 * 15295 * Note that unlike in the Arm implementation, we should never arrive 15296 * here with a zero breakFlag because we always refresh rIBASE on 15297 * return. 15298 */ 15299 EXPORT_PC 15300 movl rSELF, %eax 15301 movl rPC, OUT_ARG0(%esp) 15302 cmpb $0,offThread_breakFlags(%eax) # anything to do? 15303 movl rFP, OUT_ARG1(%esp) 15304 je 1f # reload rIBASE & resume if not 15305 movl %eax, OUT_ARG2(%esp) 15306 call dvmCheckBefore # (dPC, dFP, self) 15307 movl rSELF, %eax 153081: 15309 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 15310 jmp *dvmAsmInstructionStart+(146*4) 15311 15312/* ------------------------------ */ 15313.L_ALT_OP_DIV_INT: /* 0x93 */ 15314/* File: x86/alt_stub.S */ 15315/* 15316 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 15317 * any interesting requests and then jump to the real instruction 15318 * handler. Unlike the Arm handler, we can't do this as a tail call 15319 * because rIBASE is caller save and we need to reload it. 15320 * 15321 * Note that unlike in the Arm implementation, we should never arrive 15322 * here with a zero breakFlag because we always refresh rIBASE on 15323 * return. 15324 */ 15325 EXPORT_PC 15326 movl rSELF, %eax 15327 movl rPC, OUT_ARG0(%esp) 15328 cmpb $0,offThread_breakFlags(%eax) # anything to do? 15329 movl rFP, OUT_ARG1(%esp) 15330 je 1f # reload rIBASE & resume if not 15331 movl %eax, OUT_ARG2(%esp) 15332 call dvmCheckBefore # (dPC, dFP, self) 15333 movl rSELF, %eax 153341: 15335 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 15336 jmp *dvmAsmInstructionStart+(147*4) 15337 15338/* ------------------------------ */ 15339.L_ALT_OP_REM_INT: /* 0x94 */ 15340/* File: x86/alt_stub.S */ 15341/* 15342 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 15343 * any interesting requests and then jump to the real instruction 15344 * handler. Unlike the Arm handler, we can't do this as a tail call 15345 * because rIBASE is caller save and we need to reload it. 15346 * 15347 * Note that unlike in the Arm implementation, we should never arrive 15348 * here with a zero breakFlag because we always refresh rIBASE on 15349 * return. 15350 */ 15351 EXPORT_PC 15352 movl rSELF, %eax 15353 movl rPC, OUT_ARG0(%esp) 15354 cmpb $0,offThread_breakFlags(%eax) # anything to do? 15355 movl rFP, OUT_ARG1(%esp) 15356 je 1f # reload rIBASE & resume if not 15357 movl %eax, OUT_ARG2(%esp) 15358 call dvmCheckBefore # (dPC, dFP, self) 15359 movl rSELF, %eax 153601: 15361 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 15362 jmp *dvmAsmInstructionStart+(148*4) 15363 15364/* ------------------------------ */ 15365.L_ALT_OP_AND_INT: /* 0x95 */ 15366/* File: x86/alt_stub.S */ 15367/* 15368 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 15369 * any interesting requests and then jump to the real instruction 15370 * handler. Unlike the Arm handler, we can't do this as a tail call 15371 * because rIBASE is caller save and we need to reload it. 15372 * 15373 * Note that unlike in the Arm implementation, we should never arrive 15374 * here with a zero breakFlag because we always refresh rIBASE on 15375 * return. 15376 */ 15377 EXPORT_PC 15378 movl rSELF, %eax 15379 movl rPC, OUT_ARG0(%esp) 15380 cmpb $0,offThread_breakFlags(%eax) # anything to do? 15381 movl rFP, OUT_ARG1(%esp) 15382 je 1f # reload rIBASE & resume if not 15383 movl %eax, OUT_ARG2(%esp) 15384 call dvmCheckBefore # (dPC, dFP, self) 15385 movl rSELF, %eax 153861: 15387 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 15388 jmp *dvmAsmInstructionStart+(149*4) 15389 15390/* ------------------------------ */ 15391.L_ALT_OP_OR_INT: /* 0x96 */ 15392/* File: x86/alt_stub.S */ 15393/* 15394 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 15395 * any interesting requests and then jump to the real instruction 15396 * handler. Unlike the Arm handler, we can't do this as a tail call 15397 * because rIBASE is caller save and we need to reload it. 15398 * 15399 * Note that unlike in the Arm implementation, we should never arrive 15400 * here with a zero breakFlag because we always refresh rIBASE on 15401 * return. 15402 */ 15403 EXPORT_PC 15404 movl rSELF, %eax 15405 movl rPC, OUT_ARG0(%esp) 15406 cmpb $0,offThread_breakFlags(%eax) # anything to do? 15407 movl rFP, OUT_ARG1(%esp) 15408 je 1f # reload rIBASE & resume if not 15409 movl %eax, OUT_ARG2(%esp) 15410 call dvmCheckBefore # (dPC, dFP, self) 15411 movl rSELF, %eax 154121: 15413 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 15414 jmp *dvmAsmInstructionStart+(150*4) 15415 15416/* ------------------------------ */ 15417.L_ALT_OP_XOR_INT: /* 0x97 */ 15418/* File: x86/alt_stub.S */ 15419/* 15420 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 15421 * any interesting requests and then jump to the real instruction 15422 * handler. Unlike the Arm handler, we can't do this as a tail call 15423 * because rIBASE is caller save and we need to reload it. 15424 * 15425 * Note that unlike in the Arm implementation, we should never arrive 15426 * here with a zero breakFlag because we always refresh rIBASE on 15427 * return. 15428 */ 15429 EXPORT_PC 15430 movl rSELF, %eax 15431 movl rPC, OUT_ARG0(%esp) 15432 cmpb $0,offThread_breakFlags(%eax) # anything to do? 15433 movl rFP, OUT_ARG1(%esp) 15434 je 1f # reload rIBASE & resume if not 15435 movl %eax, OUT_ARG2(%esp) 15436 call dvmCheckBefore # (dPC, dFP, self) 15437 movl rSELF, %eax 154381: 15439 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 15440 jmp *dvmAsmInstructionStart+(151*4) 15441 15442/* ------------------------------ */ 15443.L_ALT_OP_SHL_INT: /* 0x98 */ 15444/* File: x86/alt_stub.S */ 15445/* 15446 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 15447 * any interesting requests and then jump to the real instruction 15448 * handler. Unlike the Arm handler, we can't do this as a tail call 15449 * because rIBASE is caller save and we need to reload it. 15450 * 15451 * Note that unlike in the Arm implementation, we should never arrive 15452 * here with a zero breakFlag because we always refresh rIBASE on 15453 * return. 15454 */ 15455 EXPORT_PC 15456 movl rSELF, %eax 15457 movl rPC, OUT_ARG0(%esp) 15458 cmpb $0,offThread_breakFlags(%eax) # anything to do? 15459 movl rFP, OUT_ARG1(%esp) 15460 je 1f # reload rIBASE & resume if not 15461 movl %eax, OUT_ARG2(%esp) 15462 call dvmCheckBefore # (dPC, dFP, self) 15463 movl rSELF, %eax 154641: 15465 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 15466 jmp *dvmAsmInstructionStart+(152*4) 15467 15468/* ------------------------------ */ 15469.L_ALT_OP_SHR_INT: /* 0x99 */ 15470/* File: x86/alt_stub.S */ 15471/* 15472 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 15473 * any interesting requests and then jump to the real instruction 15474 * handler. Unlike the Arm handler, we can't do this as a tail call 15475 * because rIBASE is caller save and we need to reload it. 15476 * 15477 * Note that unlike in the Arm implementation, we should never arrive 15478 * here with a zero breakFlag because we always refresh rIBASE on 15479 * return. 15480 */ 15481 EXPORT_PC 15482 movl rSELF, %eax 15483 movl rPC, OUT_ARG0(%esp) 15484 cmpb $0,offThread_breakFlags(%eax) # anything to do? 15485 movl rFP, OUT_ARG1(%esp) 15486 je 1f # reload rIBASE & resume if not 15487 movl %eax, OUT_ARG2(%esp) 15488 call dvmCheckBefore # (dPC, dFP, self) 15489 movl rSELF, %eax 154901: 15491 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 15492 jmp *dvmAsmInstructionStart+(153*4) 15493 15494/* ------------------------------ */ 15495.L_ALT_OP_USHR_INT: /* 0x9a */ 15496/* File: x86/alt_stub.S */ 15497/* 15498 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 15499 * any interesting requests and then jump to the real instruction 15500 * handler. Unlike the Arm handler, we can't do this as a tail call 15501 * because rIBASE is caller save and we need to reload it. 15502 * 15503 * Note that unlike in the Arm implementation, we should never arrive 15504 * here with a zero breakFlag because we always refresh rIBASE on 15505 * return. 15506 */ 15507 EXPORT_PC 15508 movl rSELF, %eax 15509 movl rPC, OUT_ARG0(%esp) 15510 cmpb $0,offThread_breakFlags(%eax) # anything to do? 15511 movl rFP, OUT_ARG1(%esp) 15512 je 1f # reload rIBASE & resume if not 15513 movl %eax, OUT_ARG2(%esp) 15514 call dvmCheckBefore # (dPC, dFP, self) 15515 movl rSELF, %eax 155161: 15517 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 15518 jmp *dvmAsmInstructionStart+(154*4) 15519 15520/* ------------------------------ */ 15521.L_ALT_OP_ADD_LONG: /* 0x9b */ 15522/* File: x86/alt_stub.S */ 15523/* 15524 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 15525 * any interesting requests and then jump to the real instruction 15526 * handler. Unlike the Arm handler, we can't do this as a tail call 15527 * because rIBASE is caller save and we need to reload it. 15528 * 15529 * Note that unlike in the Arm implementation, we should never arrive 15530 * here with a zero breakFlag because we always refresh rIBASE on 15531 * return. 15532 */ 15533 EXPORT_PC 15534 movl rSELF, %eax 15535 movl rPC, OUT_ARG0(%esp) 15536 cmpb $0,offThread_breakFlags(%eax) # anything to do? 15537 movl rFP, OUT_ARG1(%esp) 15538 je 1f # reload rIBASE & resume if not 15539 movl %eax, OUT_ARG2(%esp) 15540 call dvmCheckBefore # (dPC, dFP, self) 15541 movl rSELF, %eax 155421: 15543 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 15544 jmp *dvmAsmInstructionStart+(155*4) 15545 15546/* ------------------------------ */ 15547.L_ALT_OP_SUB_LONG: /* 0x9c */ 15548/* File: x86/alt_stub.S */ 15549/* 15550 * Inter-instruction transfer stub. Call out to dvmCheckBefore 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 * Note that unlike in the Arm implementation, we should never arrive 15556 * here with a zero breakFlag because we always refresh rIBASE on 15557 * return. 15558 */ 15559 EXPORT_PC 15560 movl rSELF, %eax 15561 movl rPC, OUT_ARG0(%esp) 15562 cmpb $0,offThread_breakFlags(%eax) # anything to do? 15563 movl rFP, OUT_ARG1(%esp) 15564 je 1f # reload rIBASE & resume if not 15565 movl %eax, OUT_ARG2(%esp) 15566 call dvmCheckBefore # (dPC, dFP, self) 15567 movl rSELF, %eax 155681: 15569 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 15570 jmp *dvmAsmInstructionStart+(156*4) 15571 15572/* ------------------------------ */ 15573.L_ALT_OP_MUL_LONG: /* 0x9d */ 15574/* File: x86/alt_stub.S */ 15575/* 15576 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 15577 * any interesting requests and then jump to the real instruction 15578 * handler. Unlike the Arm handler, we can't do this as a tail call 15579 * because rIBASE is caller save and we need to reload it. 15580 * 15581 * Note that unlike in the Arm implementation, we should never arrive 15582 * here with a zero breakFlag because we always refresh rIBASE on 15583 * return. 15584 */ 15585 EXPORT_PC 15586 movl rSELF, %eax 15587 movl rPC, OUT_ARG0(%esp) 15588 cmpb $0,offThread_breakFlags(%eax) # anything to do? 15589 movl rFP, OUT_ARG1(%esp) 15590 je 1f # reload rIBASE & resume if not 15591 movl %eax, OUT_ARG2(%esp) 15592 call dvmCheckBefore # (dPC, dFP, self) 15593 movl rSELF, %eax 155941: 15595 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 15596 jmp *dvmAsmInstructionStart+(157*4) 15597 15598/* ------------------------------ */ 15599.L_ALT_OP_DIV_LONG: /* 0x9e */ 15600/* File: x86/alt_stub.S */ 15601/* 15602 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 15603 * any interesting requests and then jump to the real instruction 15604 * handler. Unlike the Arm handler, we can't do this as a tail call 15605 * because rIBASE is caller save and we need to reload it. 15606 * 15607 * Note that unlike in the Arm implementation, we should never arrive 15608 * here with a zero breakFlag because we always refresh rIBASE on 15609 * return. 15610 */ 15611 EXPORT_PC 15612 movl rSELF, %eax 15613 movl rPC, OUT_ARG0(%esp) 15614 cmpb $0,offThread_breakFlags(%eax) # anything to do? 15615 movl rFP, OUT_ARG1(%esp) 15616 je 1f # reload rIBASE & resume if not 15617 movl %eax, OUT_ARG2(%esp) 15618 call dvmCheckBefore # (dPC, dFP, self) 15619 movl rSELF, %eax 156201: 15621 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 15622 jmp *dvmAsmInstructionStart+(158*4) 15623 15624/* ------------------------------ */ 15625.L_ALT_OP_REM_LONG: /* 0x9f */ 15626/* File: x86/alt_stub.S */ 15627/* 15628 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 15629 * any interesting requests and then jump to the real instruction 15630 * handler. Unlike the Arm handler, we can't do this as a tail call 15631 * because rIBASE is caller save and we need to reload it. 15632 * 15633 * Note that unlike in the Arm implementation, we should never arrive 15634 * here with a zero breakFlag because we always refresh rIBASE on 15635 * return. 15636 */ 15637 EXPORT_PC 15638 movl rSELF, %eax 15639 movl rPC, OUT_ARG0(%esp) 15640 cmpb $0,offThread_breakFlags(%eax) # anything to do? 15641 movl rFP, OUT_ARG1(%esp) 15642 je 1f # reload rIBASE & resume if not 15643 movl %eax, OUT_ARG2(%esp) 15644 call dvmCheckBefore # (dPC, dFP, self) 15645 movl rSELF, %eax 156461: 15647 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 15648 jmp *dvmAsmInstructionStart+(159*4) 15649 15650/* ------------------------------ */ 15651.L_ALT_OP_AND_LONG: /* 0xa0 */ 15652/* File: x86/alt_stub.S */ 15653/* 15654 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 15655 * any interesting requests and then jump to the real instruction 15656 * handler. Unlike the Arm handler, we can't do this as a tail call 15657 * because rIBASE is caller save and we need to reload it. 15658 * 15659 * Note that unlike in the Arm implementation, we should never arrive 15660 * here with a zero breakFlag because we always refresh rIBASE on 15661 * return. 15662 */ 15663 EXPORT_PC 15664 movl rSELF, %eax 15665 movl rPC, OUT_ARG0(%esp) 15666 cmpb $0,offThread_breakFlags(%eax) # anything to do? 15667 movl rFP, OUT_ARG1(%esp) 15668 je 1f # reload rIBASE & resume if not 15669 movl %eax, OUT_ARG2(%esp) 15670 call dvmCheckBefore # (dPC, dFP, self) 15671 movl rSELF, %eax 156721: 15673 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 15674 jmp *dvmAsmInstructionStart+(160*4) 15675 15676/* ------------------------------ */ 15677.L_ALT_OP_OR_LONG: /* 0xa1 */ 15678/* File: x86/alt_stub.S */ 15679/* 15680 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 15681 * any interesting requests and then jump to the real instruction 15682 * handler. Unlike the Arm handler, we can't do this as a tail call 15683 * because rIBASE is caller save and we need to reload it. 15684 * 15685 * Note that unlike in the Arm implementation, we should never arrive 15686 * here with a zero breakFlag because we always refresh rIBASE on 15687 * return. 15688 */ 15689 EXPORT_PC 15690 movl rSELF, %eax 15691 movl rPC, OUT_ARG0(%esp) 15692 cmpb $0,offThread_breakFlags(%eax) # anything to do? 15693 movl rFP, OUT_ARG1(%esp) 15694 je 1f # reload rIBASE & resume if not 15695 movl %eax, OUT_ARG2(%esp) 15696 call dvmCheckBefore # (dPC, dFP, self) 15697 movl rSELF, %eax 156981: 15699 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 15700 jmp *dvmAsmInstructionStart+(161*4) 15701 15702/* ------------------------------ */ 15703.L_ALT_OP_XOR_LONG: /* 0xa2 */ 15704/* File: x86/alt_stub.S */ 15705/* 15706 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 15707 * any interesting requests and then jump to the real instruction 15708 * handler. Unlike the Arm handler, we can't do this as a tail call 15709 * because rIBASE is caller save and we need to reload it. 15710 * 15711 * Note that unlike in the Arm implementation, we should never arrive 15712 * here with a zero breakFlag because we always refresh rIBASE on 15713 * return. 15714 */ 15715 EXPORT_PC 15716 movl rSELF, %eax 15717 movl rPC, OUT_ARG0(%esp) 15718 cmpb $0,offThread_breakFlags(%eax) # anything to do? 15719 movl rFP, OUT_ARG1(%esp) 15720 je 1f # reload rIBASE & resume if not 15721 movl %eax, OUT_ARG2(%esp) 15722 call dvmCheckBefore # (dPC, dFP, self) 15723 movl rSELF, %eax 157241: 15725 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 15726 jmp *dvmAsmInstructionStart+(162*4) 15727 15728/* ------------------------------ */ 15729.L_ALT_OP_SHL_LONG: /* 0xa3 */ 15730/* File: x86/alt_stub.S */ 15731/* 15732 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 15733 * any interesting requests and then jump to the real instruction 15734 * handler. Unlike the Arm handler, we can't do this as a tail call 15735 * because rIBASE is caller save and we need to reload it. 15736 * 15737 * Note that unlike in the Arm implementation, we should never arrive 15738 * here with a zero breakFlag because we always refresh rIBASE on 15739 * return. 15740 */ 15741 EXPORT_PC 15742 movl rSELF, %eax 15743 movl rPC, OUT_ARG0(%esp) 15744 cmpb $0,offThread_breakFlags(%eax) # anything to do? 15745 movl rFP, OUT_ARG1(%esp) 15746 je 1f # reload rIBASE & resume if not 15747 movl %eax, OUT_ARG2(%esp) 15748 call dvmCheckBefore # (dPC, dFP, self) 15749 movl rSELF, %eax 157501: 15751 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 15752 jmp *dvmAsmInstructionStart+(163*4) 15753 15754/* ------------------------------ */ 15755.L_ALT_OP_SHR_LONG: /* 0xa4 */ 15756/* File: x86/alt_stub.S */ 15757/* 15758 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 15759 * any interesting requests and then jump to the real instruction 15760 * handler. Unlike the Arm handler, we can't do this as a tail call 15761 * because rIBASE is caller save and we need to reload it. 15762 * 15763 * Note that unlike in the Arm implementation, we should never arrive 15764 * here with a zero breakFlag because we always refresh rIBASE on 15765 * return. 15766 */ 15767 EXPORT_PC 15768 movl rSELF, %eax 15769 movl rPC, OUT_ARG0(%esp) 15770 cmpb $0,offThread_breakFlags(%eax) # anything to do? 15771 movl rFP, OUT_ARG1(%esp) 15772 je 1f # reload rIBASE & resume if not 15773 movl %eax, OUT_ARG2(%esp) 15774 call dvmCheckBefore # (dPC, dFP, self) 15775 movl rSELF, %eax 157761: 15777 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 15778 jmp *dvmAsmInstructionStart+(164*4) 15779 15780/* ------------------------------ */ 15781.L_ALT_OP_USHR_LONG: /* 0xa5 */ 15782/* File: x86/alt_stub.S */ 15783/* 15784 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 15785 * any interesting requests and then jump to the real instruction 15786 * handler. Unlike the Arm handler, we can't do this as a tail call 15787 * because rIBASE is caller save and we need to reload it. 15788 * 15789 * Note that unlike in the Arm implementation, we should never arrive 15790 * here with a zero breakFlag because we always refresh rIBASE on 15791 * return. 15792 */ 15793 EXPORT_PC 15794 movl rSELF, %eax 15795 movl rPC, OUT_ARG0(%esp) 15796 cmpb $0,offThread_breakFlags(%eax) # anything to do? 15797 movl rFP, OUT_ARG1(%esp) 15798 je 1f # reload rIBASE & resume if not 15799 movl %eax, OUT_ARG2(%esp) 15800 call dvmCheckBefore # (dPC, dFP, self) 15801 movl rSELF, %eax 158021: 15803 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 15804 jmp *dvmAsmInstructionStart+(165*4) 15805 15806/* ------------------------------ */ 15807.L_ALT_OP_ADD_FLOAT: /* 0xa6 */ 15808/* File: x86/alt_stub.S */ 15809/* 15810 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 15811 * any interesting requests and then jump to the real instruction 15812 * handler. Unlike the Arm handler, we can't do this as a tail call 15813 * because rIBASE is caller save and we need to reload it. 15814 * 15815 * Note that unlike in the Arm implementation, we should never arrive 15816 * here with a zero breakFlag because we always refresh rIBASE on 15817 * return. 15818 */ 15819 EXPORT_PC 15820 movl rSELF, %eax 15821 movl rPC, OUT_ARG0(%esp) 15822 cmpb $0,offThread_breakFlags(%eax) # anything to do? 15823 movl rFP, OUT_ARG1(%esp) 15824 je 1f # reload rIBASE & resume if not 15825 movl %eax, OUT_ARG2(%esp) 15826 call dvmCheckBefore # (dPC, dFP, self) 15827 movl rSELF, %eax 158281: 15829 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 15830 jmp *dvmAsmInstructionStart+(166*4) 15831 15832/* ------------------------------ */ 15833.L_ALT_OP_SUB_FLOAT: /* 0xa7 */ 15834/* File: x86/alt_stub.S */ 15835/* 15836 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 15837 * any interesting requests and then jump to the real instruction 15838 * handler. Unlike the Arm handler, we can't do this as a tail call 15839 * because rIBASE is caller save and we need to reload it. 15840 * 15841 * Note that unlike in the Arm implementation, we should never arrive 15842 * here with a zero breakFlag because we always refresh rIBASE on 15843 * return. 15844 */ 15845 EXPORT_PC 15846 movl rSELF, %eax 15847 movl rPC, OUT_ARG0(%esp) 15848 cmpb $0,offThread_breakFlags(%eax) # anything to do? 15849 movl rFP, OUT_ARG1(%esp) 15850 je 1f # reload rIBASE & resume if not 15851 movl %eax, OUT_ARG2(%esp) 15852 call dvmCheckBefore # (dPC, dFP, self) 15853 movl rSELF, %eax 158541: 15855 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 15856 jmp *dvmAsmInstructionStart+(167*4) 15857 15858/* ------------------------------ */ 15859.L_ALT_OP_MUL_FLOAT: /* 0xa8 */ 15860/* File: x86/alt_stub.S */ 15861/* 15862 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 15863 * any interesting requests and then jump to the real instruction 15864 * handler. Unlike the Arm handler, we can't do this as a tail call 15865 * because rIBASE is caller save and we need to reload it. 15866 * 15867 * Note that unlike in the Arm implementation, we should never arrive 15868 * here with a zero breakFlag because we always refresh rIBASE on 15869 * return. 15870 */ 15871 EXPORT_PC 15872 movl rSELF, %eax 15873 movl rPC, OUT_ARG0(%esp) 15874 cmpb $0,offThread_breakFlags(%eax) # anything to do? 15875 movl rFP, OUT_ARG1(%esp) 15876 je 1f # reload rIBASE & resume if not 15877 movl %eax, OUT_ARG2(%esp) 15878 call dvmCheckBefore # (dPC, dFP, self) 15879 movl rSELF, %eax 158801: 15881 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 15882 jmp *dvmAsmInstructionStart+(168*4) 15883 15884/* ------------------------------ */ 15885.L_ALT_OP_DIV_FLOAT: /* 0xa9 */ 15886/* File: x86/alt_stub.S */ 15887/* 15888 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 15889 * any interesting requests and then jump to the real instruction 15890 * handler. Unlike the Arm handler, we can't do this as a tail call 15891 * because rIBASE is caller save and we need to reload it. 15892 * 15893 * Note that unlike in the Arm implementation, we should never arrive 15894 * here with a zero breakFlag because we always refresh rIBASE on 15895 * return. 15896 */ 15897 EXPORT_PC 15898 movl rSELF, %eax 15899 movl rPC, OUT_ARG0(%esp) 15900 cmpb $0,offThread_breakFlags(%eax) # anything to do? 15901 movl rFP, OUT_ARG1(%esp) 15902 je 1f # reload rIBASE & resume if not 15903 movl %eax, OUT_ARG2(%esp) 15904 call dvmCheckBefore # (dPC, dFP, self) 15905 movl rSELF, %eax 159061: 15907 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 15908 jmp *dvmAsmInstructionStart+(169*4) 15909 15910/* ------------------------------ */ 15911.L_ALT_OP_REM_FLOAT: /* 0xaa */ 15912/* File: x86/alt_stub.S */ 15913/* 15914 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 15915 * any interesting requests and then jump to the real instruction 15916 * handler. Unlike the Arm handler, we can't do this as a tail call 15917 * because rIBASE is caller save and we need to reload it. 15918 * 15919 * Note that unlike in the Arm implementation, we should never arrive 15920 * here with a zero breakFlag because we always refresh rIBASE on 15921 * return. 15922 */ 15923 EXPORT_PC 15924 movl rSELF, %eax 15925 movl rPC, OUT_ARG0(%esp) 15926 cmpb $0,offThread_breakFlags(%eax) # anything to do? 15927 movl rFP, OUT_ARG1(%esp) 15928 je 1f # reload rIBASE & resume if not 15929 movl %eax, OUT_ARG2(%esp) 15930 call dvmCheckBefore # (dPC, dFP, self) 15931 movl rSELF, %eax 159321: 15933 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 15934 jmp *dvmAsmInstructionStart+(170*4) 15935 15936/* ------------------------------ */ 15937.L_ALT_OP_ADD_DOUBLE: /* 0xab */ 15938/* File: x86/alt_stub.S */ 15939/* 15940 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 15941 * any interesting requests and then jump to the real instruction 15942 * handler. Unlike the Arm handler, we can't do this as a tail call 15943 * because rIBASE is caller save and we need to reload it. 15944 * 15945 * Note that unlike in the Arm implementation, we should never arrive 15946 * here with a zero breakFlag because we always refresh rIBASE on 15947 * return. 15948 */ 15949 EXPORT_PC 15950 movl rSELF, %eax 15951 movl rPC, OUT_ARG0(%esp) 15952 cmpb $0,offThread_breakFlags(%eax) # anything to do? 15953 movl rFP, OUT_ARG1(%esp) 15954 je 1f # reload rIBASE & resume if not 15955 movl %eax, OUT_ARG2(%esp) 15956 call dvmCheckBefore # (dPC, dFP, self) 15957 movl rSELF, %eax 159581: 15959 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 15960 jmp *dvmAsmInstructionStart+(171*4) 15961 15962/* ------------------------------ */ 15963.L_ALT_OP_SUB_DOUBLE: /* 0xac */ 15964/* File: x86/alt_stub.S */ 15965/* 15966 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 15967 * any interesting requests and then jump to the real instruction 15968 * handler. Unlike the Arm handler, we can't do this as a tail call 15969 * because rIBASE is caller save and we need to reload it. 15970 * 15971 * Note that unlike in the Arm implementation, we should never arrive 15972 * here with a zero breakFlag because we always refresh rIBASE on 15973 * return. 15974 */ 15975 EXPORT_PC 15976 movl rSELF, %eax 15977 movl rPC, OUT_ARG0(%esp) 15978 cmpb $0,offThread_breakFlags(%eax) # anything to do? 15979 movl rFP, OUT_ARG1(%esp) 15980 je 1f # reload rIBASE & resume if not 15981 movl %eax, OUT_ARG2(%esp) 15982 call dvmCheckBefore # (dPC, dFP, self) 15983 movl rSELF, %eax 159841: 15985 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 15986 jmp *dvmAsmInstructionStart+(172*4) 15987 15988/* ------------------------------ */ 15989.L_ALT_OP_MUL_DOUBLE: /* 0xad */ 15990/* File: x86/alt_stub.S */ 15991/* 15992 * Inter-instruction transfer stub. Call out to dvmCheckBefore 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 * Note that unlike in the Arm implementation, we should never arrive 15998 * here with a zero breakFlag because we always refresh rIBASE on 15999 * return. 16000 */ 16001 EXPORT_PC 16002 movl rSELF, %eax 16003 movl rPC, OUT_ARG0(%esp) 16004 cmpb $0,offThread_breakFlags(%eax) # anything to do? 16005 movl rFP, OUT_ARG1(%esp) 16006 je 1f # reload rIBASE & resume if not 16007 movl %eax, OUT_ARG2(%esp) 16008 call dvmCheckBefore # (dPC, dFP, self) 16009 movl rSELF, %eax 160101: 16011 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 16012 jmp *dvmAsmInstructionStart+(173*4) 16013 16014/* ------------------------------ */ 16015.L_ALT_OP_DIV_DOUBLE: /* 0xae */ 16016/* File: x86/alt_stub.S */ 16017/* 16018 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 16019 * any interesting requests and then jump to the real instruction 16020 * handler. Unlike the Arm handler, we can't do this as a tail call 16021 * because rIBASE is caller save and we need to reload it. 16022 * 16023 * Note that unlike in the Arm implementation, we should never arrive 16024 * here with a zero breakFlag because we always refresh rIBASE on 16025 * return. 16026 */ 16027 EXPORT_PC 16028 movl rSELF, %eax 16029 movl rPC, OUT_ARG0(%esp) 16030 cmpb $0,offThread_breakFlags(%eax) # anything to do? 16031 movl rFP, OUT_ARG1(%esp) 16032 je 1f # reload rIBASE & resume if not 16033 movl %eax, OUT_ARG2(%esp) 16034 call dvmCheckBefore # (dPC, dFP, self) 16035 movl rSELF, %eax 160361: 16037 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 16038 jmp *dvmAsmInstructionStart+(174*4) 16039 16040/* ------------------------------ */ 16041.L_ALT_OP_REM_DOUBLE: /* 0xaf */ 16042/* File: x86/alt_stub.S */ 16043/* 16044 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 16045 * any interesting requests and then jump to the real instruction 16046 * handler. Unlike the Arm handler, we can't do this as a tail call 16047 * because rIBASE is caller save and we need to reload it. 16048 * 16049 * Note that unlike in the Arm implementation, we should never arrive 16050 * here with a zero breakFlag because we always refresh rIBASE on 16051 * return. 16052 */ 16053 EXPORT_PC 16054 movl rSELF, %eax 16055 movl rPC, OUT_ARG0(%esp) 16056 cmpb $0,offThread_breakFlags(%eax) # anything to do? 16057 movl rFP, OUT_ARG1(%esp) 16058 je 1f # reload rIBASE & resume if not 16059 movl %eax, OUT_ARG2(%esp) 16060 call dvmCheckBefore # (dPC, dFP, self) 16061 movl rSELF, %eax 160621: 16063 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 16064 jmp *dvmAsmInstructionStart+(175*4) 16065 16066/* ------------------------------ */ 16067.L_ALT_OP_ADD_INT_2ADDR: /* 0xb0 */ 16068/* File: x86/alt_stub.S */ 16069/* 16070 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 16071 * any interesting requests and then jump to the real instruction 16072 * handler. Unlike the Arm handler, we can't do this as a tail call 16073 * because rIBASE is caller save and we need to reload it. 16074 * 16075 * Note that unlike in the Arm implementation, we should never arrive 16076 * here with a zero breakFlag because we always refresh rIBASE on 16077 * return. 16078 */ 16079 EXPORT_PC 16080 movl rSELF, %eax 16081 movl rPC, OUT_ARG0(%esp) 16082 cmpb $0,offThread_breakFlags(%eax) # anything to do? 16083 movl rFP, OUT_ARG1(%esp) 16084 je 1f # reload rIBASE & resume if not 16085 movl %eax, OUT_ARG2(%esp) 16086 call dvmCheckBefore # (dPC, dFP, self) 16087 movl rSELF, %eax 160881: 16089 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 16090 jmp *dvmAsmInstructionStart+(176*4) 16091 16092/* ------------------------------ */ 16093.L_ALT_OP_SUB_INT_2ADDR: /* 0xb1 */ 16094/* File: x86/alt_stub.S */ 16095/* 16096 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 16097 * any interesting requests and then jump to the real instruction 16098 * handler. Unlike the Arm handler, we can't do this as a tail call 16099 * because rIBASE is caller save and we need to reload it. 16100 * 16101 * Note that unlike in the Arm implementation, we should never arrive 16102 * here with a zero breakFlag because we always refresh rIBASE on 16103 * return. 16104 */ 16105 EXPORT_PC 16106 movl rSELF, %eax 16107 movl rPC, OUT_ARG0(%esp) 16108 cmpb $0,offThread_breakFlags(%eax) # anything to do? 16109 movl rFP, OUT_ARG1(%esp) 16110 je 1f # reload rIBASE & resume if not 16111 movl %eax, OUT_ARG2(%esp) 16112 call dvmCheckBefore # (dPC, dFP, self) 16113 movl rSELF, %eax 161141: 16115 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 16116 jmp *dvmAsmInstructionStart+(177*4) 16117 16118/* ------------------------------ */ 16119.L_ALT_OP_MUL_INT_2ADDR: /* 0xb2 */ 16120/* File: x86/alt_stub.S */ 16121/* 16122 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 16123 * any interesting requests and then jump to the real instruction 16124 * handler. Unlike the Arm handler, we can't do this as a tail call 16125 * because rIBASE is caller save and we need to reload it. 16126 * 16127 * Note that unlike in the Arm implementation, we should never arrive 16128 * here with a zero breakFlag because we always refresh rIBASE on 16129 * return. 16130 */ 16131 EXPORT_PC 16132 movl rSELF, %eax 16133 movl rPC, OUT_ARG0(%esp) 16134 cmpb $0,offThread_breakFlags(%eax) # anything to do? 16135 movl rFP, OUT_ARG1(%esp) 16136 je 1f # reload rIBASE & resume if not 16137 movl %eax, OUT_ARG2(%esp) 16138 call dvmCheckBefore # (dPC, dFP, self) 16139 movl rSELF, %eax 161401: 16141 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 16142 jmp *dvmAsmInstructionStart+(178*4) 16143 16144/* ------------------------------ */ 16145.L_ALT_OP_DIV_INT_2ADDR: /* 0xb3 */ 16146/* File: x86/alt_stub.S */ 16147/* 16148 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 16149 * any interesting requests and then jump to the real instruction 16150 * handler. Unlike the Arm handler, we can't do this as a tail call 16151 * because rIBASE is caller save and we need to reload it. 16152 * 16153 * Note that unlike in the Arm implementation, we should never arrive 16154 * here with a zero breakFlag because we always refresh rIBASE on 16155 * return. 16156 */ 16157 EXPORT_PC 16158 movl rSELF, %eax 16159 movl rPC, OUT_ARG0(%esp) 16160 cmpb $0,offThread_breakFlags(%eax) # anything to do? 16161 movl rFP, OUT_ARG1(%esp) 16162 je 1f # reload rIBASE & resume if not 16163 movl %eax, OUT_ARG2(%esp) 16164 call dvmCheckBefore # (dPC, dFP, self) 16165 movl rSELF, %eax 161661: 16167 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 16168 jmp *dvmAsmInstructionStart+(179*4) 16169 16170/* ------------------------------ */ 16171.L_ALT_OP_REM_INT_2ADDR: /* 0xb4 */ 16172/* File: x86/alt_stub.S */ 16173/* 16174 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 16175 * any interesting requests and then jump to the real instruction 16176 * handler. Unlike the Arm handler, we can't do this as a tail call 16177 * because rIBASE is caller save and we need to reload it. 16178 * 16179 * Note that unlike in the Arm implementation, we should never arrive 16180 * here with a zero breakFlag because we always refresh rIBASE on 16181 * return. 16182 */ 16183 EXPORT_PC 16184 movl rSELF, %eax 16185 movl rPC, OUT_ARG0(%esp) 16186 cmpb $0,offThread_breakFlags(%eax) # anything to do? 16187 movl rFP, OUT_ARG1(%esp) 16188 je 1f # reload rIBASE & resume if not 16189 movl %eax, OUT_ARG2(%esp) 16190 call dvmCheckBefore # (dPC, dFP, self) 16191 movl rSELF, %eax 161921: 16193 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 16194 jmp *dvmAsmInstructionStart+(180*4) 16195 16196/* ------------------------------ */ 16197.L_ALT_OP_AND_INT_2ADDR: /* 0xb5 */ 16198/* File: x86/alt_stub.S */ 16199/* 16200 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 16201 * any interesting requests and then jump to the real instruction 16202 * handler. Unlike the Arm handler, we can't do this as a tail call 16203 * because rIBASE is caller save and we need to reload it. 16204 * 16205 * Note that unlike in the Arm implementation, we should never arrive 16206 * here with a zero breakFlag because we always refresh rIBASE on 16207 * return. 16208 */ 16209 EXPORT_PC 16210 movl rSELF, %eax 16211 movl rPC, OUT_ARG0(%esp) 16212 cmpb $0,offThread_breakFlags(%eax) # anything to do? 16213 movl rFP, OUT_ARG1(%esp) 16214 je 1f # reload rIBASE & resume if not 16215 movl %eax, OUT_ARG2(%esp) 16216 call dvmCheckBefore # (dPC, dFP, self) 16217 movl rSELF, %eax 162181: 16219 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 16220 jmp *dvmAsmInstructionStart+(181*4) 16221 16222/* ------------------------------ */ 16223.L_ALT_OP_OR_INT_2ADDR: /* 0xb6 */ 16224/* File: x86/alt_stub.S */ 16225/* 16226 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 16227 * any interesting requests and then jump to the real instruction 16228 * handler. Unlike the Arm handler, we can't do this as a tail call 16229 * because rIBASE is caller save and we need to reload it. 16230 * 16231 * Note that unlike in the Arm implementation, we should never arrive 16232 * here with a zero breakFlag because we always refresh rIBASE on 16233 * return. 16234 */ 16235 EXPORT_PC 16236 movl rSELF, %eax 16237 movl rPC, OUT_ARG0(%esp) 16238 cmpb $0,offThread_breakFlags(%eax) # anything to do? 16239 movl rFP, OUT_ARG1(%esp) 16240 je 1f # reload rIBASE & resume if not 16241 movl %eax, OUT_ARG2(%esp) 16242 call dvmCheckBefore # (dPC, dFP, self) 16243 movl rSELF, %eax 162441: 16245 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 16246 jmp *dvmAsmInstructionStart+(182*4) 16247 16248/* ------------------------------ */ 16249.L_ALT_OP_XOR_INT_2ADDR: /* 0xb7 */ 16250/* File: x86/alt_stub.S */ 16251/* 16252 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 16253 * any interesting requests and then jump to the real instruction 16254 * handler. Unlike the Arm handler, we can't do this as a tail call 16255 * because rIBASE is caller save and we need to reload it. 16256 * 16257 * Note that unlike in the Arm implementation, we should never arrive 16258 * here with a zero breakFlag because we always refresh rIBASE on 16259 * return. 16260 */ 16261 EXPORT_PC 16262 movl rSELF, %eax 16263 movl rPC, OUT_ARG0(%esp) 16264 cmpb $0,offThread_breakFlags(%eax) # anything to do? 16265 movl rFP, OUT_ARG1(%esp) 16266 je 1f # reload rIBASE & resume if not 16267 movl %eax, OUT_ARG2(%esp) 16268 call dvmCheckBefore # (dPC, dFP, self) 16269 movl rSELF, %eax 162701: 16271 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 16272 jmp *dvmAsmInstructionStart+(183*4) 16273 16274/* ------------------------------ */ 16275.L_ALT_OP_SHL_INT_2ADDR: /* 0xb8 */ 16276/* File: x86/alt_stub.S */ 16277/* 16278 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 16279 * any interesting requests and then jump to the real instruction 16280 * handler. Unlike the Arm handler, we can't do this as a tail call 16281 * because rIBASE is caller save and we need to reload it. 16282 * 16283 * Note that unlike in the Arm implementation, we should never arrive 16284 * here with a zero breakFlag because we always refresh rIBASE on 16285 * return. 16286 */ 16287 EXPORT_PC 16288 movl rSELF, %eax 16289 movl rPC, OUT_ARG0(%esp) 16290 cmpb $0,offThread_breakFlags(%eax) # anything to do? 16291 movl rFP, OUT_ARG1(%esp) 16292 je 1f # reload rIBASE & resume if not 16293 movl %eax, OUT_ARG2(%esp) 16294 call dvmCheckBefore # (dPC, dFP, self) 16295 movl rSELF, %eax 162961: 16297 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 16298 jmp *dvmAsmInstructionStart+(184*4) 16299 16300/* ------------------------------ */ 16301.L_ALT_OP_SHR_INT_2ADDR: /* 0xb9 */ 16302/* File: x86/alt_stub.S */ 16303/* 16304 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 16305 * any interesting requests and then jump to the real instruction 16306 * handler. Unlike the Arm handler, we can't do this as a tail call 16307 * because rIBASE is caller save and we need to reload it. 16308 * 16309 * Note that unlike in the Arm implementation, we should never arrive 16310 * here with a zero breakFlag because we always refresh rIBASE on 16311 * return. 16312 */ 16313 EXPORT_PC 16314 movl rSELF, %eax 16315 movl rPC, OUT_ARG0(%esp) 16316 cmpb $0,offThread_breakFlags(%eax) # anything to do? 16317 movl rFP, OUT_ARG1(%esp) 16318 je 1f # reload rIBASE & resume if not 16319 movl %eax, OUT_ARG2(%esp) 16320 call dvmCheckBefore # (dPC, dFP, self) 16321 movl rSELF, %eax 163221: 16323 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 16324 jmp *dvmAsmInstructionStart+(185*4) 16325 16326/* ------------------------------ */ 16327.L_ALT_OP_USHR_INT_2ADDR: /* 0xba */ 16328/* File: x86/alt_stub.S */ 16329/* 16330 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 16331 * any interesting requests and then jump to the real instruction 16332 * handler. Unlike the Arm handler, we can't do this as a tail call 16333 * because rIBASE is caller save and we need to reload it. 16334 * 16335 * Note that unlike in the Arm implementation, we should never arrive 16336 * here with a zero breakFlag because we always refresh rIBASE on 16337 * return. 16338 */ 16339 EXPORT_PC 16340 movl rSELF, %eax 16341 movl rPC, OUT_ARG0(%esp) 16342 cmpb $0,offThread_breakFlags(%eax) # anything to do? 16343 movl rFP, OUT_ARG1(%esp) 16344 je 1f # reload rIBASE & resume if not 16345 movl %eax, OUT_ARG2(%esp) 16346 call dvmCheckBefore # (dPC, dFP, self) 16347 movl rSELF, %eax 163481: 16349 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 16350 jmp *dvmAsmInstructionStart+(186*4) 16351 16352/* ------------------------------ */ 16353.L_ALT_OP_ADD_LONG_2ADDR: /* 0xbb */ 16354/* File: x86/alt_stub.S */ 16355/* 16356 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 16357 * any interesting requests and then jump to the real instruction 16358 * handler. Unlike the Arm handler, we can't do this as a tail call 16359 * because rIBASE is caller save and we need to reload it. 16360 * 16361 * Note that unlike in the Arm implementation, we should never arrive 16362 * here with a zero breakFlag because we always refresh rIBASE on 16363 * return. 16364 */ 16365 EXPORT_PC 16366 movl rSELF, %eax 16367 movl rPC, OUT_ARG0(%esp) 16368 cmpb $0,offThread_breakFlags(%eax) # anything to do? 16369 movl rFP, OUT_ARG1(%esp) 16370 je 1f # reload rIBASE & resume if not 16371 movl %eax, OUT_ARG2(%esp) 16372 call dvmCheckBefore # (dPC, dFP, self) 16373 movl rSELF, %eax 163741: 16375 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 16376 jmp *dvmAsmInstructionStart+(187*4) 16377 16378/* ------------------------------ */ 16379.L_ALT_OP_SUB_LONG_2ADDR: /* 0xbc */ 16380/* File: x86/alt_stub.S */ 16381/* 16382 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 16383 * any interesting requests and then jump to the real instruction 16384 * handler. Unlike the Arm handler, we can't do this as a tail call 16385 * because rIBASE is caller save and we need to reload it. 16386 * 16387 * Note that unlike in the Arm implementation, we should never arrive 16388 * here with a zero breakFlag because we always refresh rIBASE on 16389 * return. 16390 */ 16391 EXPORT_PC 16392 movl rSELF, %eax 16393 movl rPC, OUT_ARG0(%esp) 16394 cmpb $0,offThread_breakFlags(%eax) # anything to do? 16395 movl rFP, OUT_ARG1(%esp) 16396 je 1f # reload rIBASE & resume if not 16397 movl %eax, OUT_ARG2(%esp) 16398 call dvmCheckBefore # (dPC, dFP, self) 16399 movl rSELF, %eax 164001: 16401 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 16402 jmp *dvmAsmInstructionStart+(188*4) 16403 16404/* ------------------------------ */ 16405.L_ALT_OP_MUL_LONG_2ADDR: /* 0xbd */ 16406/* File: x86/alt_stub.S */ 16407/* 16408 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 16409 * any interesting requests and then jump to the real instruction 16410 * handler. Unlike the Arm handler, we can't do this as a tail call 16411 * because rIBASE is caller save and we need to reload it. 16412 * 16413 * Note that unlike in the Arm implementation, we should never arrive 16414 * here with a zero breakFlag because we always refresh rIBASE on 16415 * return. 16416 */ 16417 EXPORT_PC 16418 movl rSELF, %eax 16419 movl rPC, OUT_ARG0(%esp) 16420 cmpb $0,offThread_breakFlags(%eax) # anything to do? 16421 movl rFP, OUT_ARG1(%esp) 16422 je 1f # reload rIBASE & resume if not 16423 movl %eax, OUT_ARG2(%esp) 16424 call dvmCheckBefore # (dPC, dFP, self) 16425 movl rSELF, %eax 164261: 16427 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 16428 jmp *dvmAsmInstructionStart+(189*4) 16429 16430/* ------------------------------ */ 16431.L_ALT_OP_DIV_LONG_2ADDR: /* 0xbe */ 16432/* File: x86/alt_stub.S */ 16433/* 16434 * Inter-instruction transfer stub. Call out to dvmCheckBefore 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 * Note that unlike in the Arm implementation, we should never arrive 16440 * here with a zero breakFlag because we always refresh rIBASE on 16441 * return. 16442 */ 16443 EXPORT_PC 16444 movl rSELF, %eax 16445 movl rPC, OUT_ARG0(%esp) 16446 cmpb $0,offThread_breakFlags(%eax) # anything to do? 16447 movl rFP, OUT_ARG1(%esp) 16448 je 1f # reload rIBASE & resume if not 16449 movl %eax, OUT_ARG2(%esp) 16450 call dvmCheckBefore # (dPC, dFP, self) 16451 movl rSELF, %eax 164521: 16453 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 16454 jmp *dvmAsmInstructionStart+(190*4) 16455 16456/* ------------------------------ */ 16457.L_ALT_OP_REM_LONG_2ADDR: /* 0xbf */ 16458/* File: x86/alt_stub.S */ 16459/* 16460 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 16461 * any interesting requests and then jump to the real instruction 16462 * handler. Unlike the Arm handler, we can't do this as a tail call 16463 * because rIBASE is caller save and we need to reload it. 16464 * 16465 * Note that unlike in the Arm implementation, we should never arrive 16466 * here with a zero breakFlag because we always refresh rIBASE on 16467 * return. 16468 */ 16469 EXPORT_PC 16470 movl rSELF, %eax 16471 movl rPC, OUT_ARG0(%esp) 16472 cmpb $0,offThread_breakFlags(%eax) # anything to do? 16473 movl rFP, OUT_ARG1(%esp) 16474 je 1f # reload rIBASE & resume if not 16475 movl %eax, OUT_ARG2(%esp) 16476 call dvmCheckBefore # (dPC, dFP, self) 16477 movl rSELF, %eax 164781: 16479 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 16480 jmp *dvmAsmInstructionStart+(191*4) 16481 16482/* ------------------------------ */ 16483.L_ALT_OP_AND_LONG_2ADDR: /* 0xc0 */ 16484/* File: x86/alt_stub.S */ 16485/* 16486 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 16487 * any interesting requests and then jump to the real instruction 16488 * handler. Unlike the Arm handler, we can't do this as a tail call 16489 * because rIBASE is caller save and we need to reload it. 16490 * 16491 * Note that unlike in the Arm implementation, we should never arrive 16492 * here with a zero breakFlag because we always refresh rIBASE on 16493 * return. 16494 */ 16495 EXPORT_PC 16496 movl rSELF, %eax 16497 movl rPC, OUT_ARG0(%esp) 16498 cmpb $0,offThread_breakFlags(%eax) # anything to do? 16499 movl rFP, OUT_ARG1(%esp) 16500 je 1f # reload rIBASE & resume if not 16501 movl %eax, OUT_ARG2(%esp) 16502 call dvmCheckBefore # (dPC, dFP, self) 16503 movl rSELF, %eax 165041: 16505 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 16506 jmp *dvmAsmInstructionStart+(192*4) 16507 16508/* ------------------------------ */ 16509.L_ALT_OP_OR_LONG_2ADDR: /* 0xc1 */ 16510/* File: x86/alt_stub.S */ 16511/* 16512 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 16513 * any interesting requests and then jump to the real instruction 16514 * handler. Unlike the Arm handler, we can't do this as a tail call 16515 * because rIBASE is caller save and we need to reload it. 16516 * 16517 * Note that unlike in the Arm implementation, we should never arrive 16518 * here with a zero breakFlag because we always refresh rIBASE on 16519 * return. 16520 */ 16521 EXPORT_PC 16522 movl rSELF, %eax 16523 movl rPC, OUT_ARG0(%esp) 16524 cmpb $0,offThread_breakFlags(%eax) # anything to do? 16525 movl rFP, OUT_ARG1(%esp) 16526 je 1f # reload rIBASE & resume if not 16527 movl %eax, OUT_ARG2(%esp) 16528 call dvmCheckBefore # (dPC, dFP, self) 16529 movl rSELF, %eax 165301: 16531 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 16532 jmp *dvmAsmInstructionStart+(193*4) 16533 16534/* ------------------------------ */ 16535.L_ALT_OP_XOR_LONG_2ADDR: /* 0xc2 */ 16536/* File: x86/alt_stub.S */ 16537/* 16538 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 16539 * any interesting requests and then jump to the real instruction 16540 * handler. Unlike the Arm handler, we can't do this as a tail call 16541 * because rIBASE is caller save and we need to reload it. 16542 * 16543 * Note that unlike in the Arm implementation, we should never arrive 16544 * here with a zero breakFlag because we always refresh rIBASE on 16545 * return. 16546 */ 16547 EXPORT_PC 16548 movl rSELF, %eax 16549 movl rPC, OUT_ARG0(%esp) 16550 cmpb $0,offThread_breakFlags(%eax) # anything to do? 16551 movl rFP, OUT_ARG1(%esp) 16552 je 1f # reload rIBASE & resume if not 16553 movl %eax, OUT_ARG2(%esp) 16554 call dvmCheckBefore # (dPC, dFP, self) 16555 movl rSELF, %eax 165561: 16557 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 16558 jmp *dvmAsmInstructionStart+(194*4) 16559 16560/* ------------------------------ */ 16561.L_ALT_OP_SHL_LONG_2ADDR: /* 0xc3 */ 16562/* File: x86/alt_stub.S */ 16563/* 16564 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 16565 * any interesting requests and then jump to the real instruction 16566 * handler. Unlike the Arm handler, we can't do this as a tail call 16567 * because rIBASE is caller save and we need to reload it. 16568 * 16569 * Note that unlike in the Arm implementation, we should never arrive 16570 * here with a zero breakFlag because we always refresh rIBASE on 16571 * return. 16572 */ 16573 EXPORT_PC 16574 movl rSELF, %eax 16575 movl rPC, OUT_ARG0(%esp) 16576 cmpb $0,offThread_breakFlags(%eax) # anything to do? 16577 movl rFP, OUT_ARG1(%esp) 16578 je 1f # reload rIBASE & resume if not 16579 movl %eax, OUT_ARG2(%esp) 16580 call dvmCheckBefore # (dPC, dFP, self) 16581 movl rSELF, %eax 165821: 16583 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 16584 jmp *dvmAsmInstructionStart+(195*4) 16585 16586/* ------------------------------ */ 16587.L_ALT_OP_SHR_LONG_2ADDR: /* 0xc4 */ 16588/* File: x86/alt_stub.S */ 16589/* 16590 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 16591 * any interesting requests and then jump to the real instruction 16592 * handler. Unlike the Arm handler, we can't do this as a tail call 16593 * because rIBASE is caller save and we need to reload it. 16594 * 16595 * Note that unlike in the Arm implementation, we should never arrive 16596 * here with a zero breakFlag because we always refresh rIBASE on 16597 * return. 16598 */ 16599 EXPORT_PC 16600 movl rSELF, %eax 16601 movl rPC, OUT_ARG0(%esp) 16602 cmpb $0,offThread_breakFlags(%eax) # anything to do? 16603 movl rFP, OUT_ARG1(%esp) 16604 je 1f # reload rIBASE & resume if not 16605 movl %eax, OUT_ARG2(%esp) 16606 call dvmCheckBefore # (dPC, dFP, self) 16607 movl rSELF, %eax 166081: 16609 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 16610 jmp *dvmAsmInstructionStart+(196*4) 16611 16612/* ------------------------------ */ 16613.L_ALT_OP_USHR_LONG_2ADDR: /* 0xc5 */ 16614/* File: x86/alt_stub.S */ 16615/* 16616 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 16617 * any interesting requests and then jump to the real instruction 16618 * handler. Unlike the Arm handler, we can't do this as a tail call 16619 * because rIBASE is caller save and we need to reload it. 16620 * 16621 * Note that unlike in the Arm implementation, we should never arrive 16622 * here with a zero breakFlag because we always refresh rIBASE on 16623 * return. 16624 */ 16625 EXPORT_PC 16626 movl rSELF, %eax 16627 movl rPC, OUT_ARG0(%esp) 16628 cmpb $0,offThread_breakFlags(%eax) # anything to do? 16629 movl rFP, OUT_ARG1(%esp) 16630 je 1f # reload rIBASE & resume if not 16631 movl %eax, OUT_ARG2(%esp) 16632 call dvmCheckBefore # (dPC, dFP, self) 16633 movl rSELF, %eax 166341: 16635 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 16636 jmp *dvmAsmInstructionStart+(197*4) 16637 16638/* ------------------------------ */ 16639.L_ALT_OP_ADD_FLOAT_2ADDR: /* 0xc6 */ 16640/* File: x86/alt_stub.S */ 16641/* 16642 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 16643 * any interesting requests and then jump to the real instruction 16644 * handler. Unlike the Arm handler, we can't do this as a tail call 16645 * because rIBASE is caller save and we need to reload it. 16646 * 16647 * Note that unlike in the Arm implementation, we should never arrive 16648 * here with a zero breakFlag because we always refresh rIBASE on 16649 * return. 16650 */ 16651 EXPORT_PC 16652 movl rSELF, %eax 16653 movl rPC, OUT_ARG0(%esp) 16654 cmpb $0,offThread_breakFlags(%eax) # anything to do? 16655 movl rFP, OUT_ARG1(%esp) 16656 je 1f # reload rIBASE & resume if not 16657 movl %eax, OUT_ARG2(%esp) 16658 call dvmCheckBefore # (dPC, dFP, self) 16659 movl rSELF, %eax 166601: 16661 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 16662 jmp *dvmAsmInstructionStart+(198*4) 16663 16664/* ------------------------------ */ 16665.L_ALT_OP_SUB_FLOAT_2ADDR: /* 0xc7 */ 16666/* File: x86/alt_stub.S */ 16667/* 16668 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 16669 * any interesting requests and then jump to the real instruction 16670 * handler. Unlike the Arm handler, we can't do this as a tail call 16671 * because rIBASE is caller save and we need to reload it. 16672 * 16673 * Note that unlike in the Arm implementation, we should never arrive 16674 * here with a zero breakFlag because we always refresh rIBASE on 16675 * return. 16676 */ 16677 EXPORT_PC 16678 movl rSELF, %eax 16679 movl rPC, OUT_ARG0(%esp) 16680 cmpb $0,offThread_breakFlags(%eax) # anything to do? 16681 movl rFP, OUT_ARG1(%esp) 16682 je 1f # reload rIBASE & resume if not 16683 movl %eax, OUT_ARG2(%esp) 16684 call dvmCheckBefore # (dPC, dFP, self) 16685 movl rSELF, %eax 166861: 16687 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 16688 jmp *dvmAsmInstructionStart+(199*4) 16689 16690/* ------------------------------ */ 16691.L_ALT_OP_MUL_FLOAT_2ADDR: /* 0xc8 */ 16692/* File: x86/alt_stub.S */ 16693/* 16694 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 16695 * any interesting requests and then jump to the real instruction 16696 * handler. Unlike the Arm handler, we can't do this as a tail call 16697 * because rIBASE is caller save and we need to reload it. 16698 * 16699 * Note that unlike in the Arm implementation, we should never arrive 16700 * here with a zero breakFlag because we always refresh rIBASE on 16701 * return. 16702 */ 16703 EXPORT_PC 16704 movl rSELF, %eax 16705 movl rPC, OUT_ARG0(%esp) 16706 cmpb $0,offThread_breakFlags(%eax) # anything to do? 16707 movl rFP, OUT_ARG1(%esp) 16708 je 1f # reload rIBASE & resume if not 16709 movl %eax, OUT_ARG2(%esp) 16710 call dvmCheckBefore # (dPC, dFP, self) 16711 movl rSELF, %eax 167121: 16713 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 16714 jmp *dvmAsmInstructionStart+(200*4) 16715 16716/* ------------------------------ */ 16717.L_ALT_OP_DIV_FLOAT_2ADDR: /* 0xc9 */ 16718/* File: x86/alt_stub.S */ 16719/* 16720 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 16721 * any interesting requests and then jump to the real instruction 16722 * handler. Unlike the Arm handler, we can't do this as a tail call 16723 * because rIBASE is caller save and we need to reload it. 16724 * 16725 * Note that unlike in the Arm implementation, we should never arrive 16726 * here with a zero breakFlag because we always refresh rIBASE on 16727 * return. 16728 */ 16729 EXPORT_PC 16730 movl rSELF, %eax 16731 movl rPC, OUT_ARG0(%esp) 16732 cmpb $0,offThread_breakFlags(%eax) # anything to do? 16733 movl rFP, OUT_ARG1(%esp) 16734 je 1f # reload rIBASE & resume if not 16735 movl %eax, OUT_ARG2(%esp) 16736 call dvmCheckBefore # (dPC, dFP, self) 16737 movl rSELF, %eax 167381: 16739 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 16740 jmp *dvmAsmInstructionStart+(201*4) 16741 16742/* ------------------------------ */ 16743.L_ALT_OP_REM_FLOAT_2ADDR: /* 0xca */ 16744/* File: x86/alt_stub.S */ 16745/* 16746 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 16747 * any interesting requests and then jump to the real instruction 16748 * handler. Unlike the Arm handler, we can't do this as a tail call 16749 * because rIBASE is caller save and we need to reload it. 16750 * 16751 * Note that unlike in the Arm implementation, we should never arrive 16752 * here with a zero breakFlag because we always refresh rIBASE on 16753 * return. 16754 */ 16755 EXPORT_PC 16756 movl rSELF, %eax 16757 movl rPC, OUT_ARG0(%esp) 16758 cmpb $0,offThread_breakFlags(%eax) # anything to do? 16759 movl rFP, OUT_ARG1(%esp) 16760 je 1f # reload rIBASE & resume if not 16761 movl %eax, OUT_ARG2(%esp) 16762 call dvmCheckBefore # (dPC, dFP, self) 16763 movl rSELF, %eax 167641: 16765 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 16766 jmp *dvmAsmInstructionStart+(202*4) 16767 16768/* ------------------------------ */ 16769.L_ALT_OP_ADD_DOUBLE_2ADDR: /* 0xcb */ 16770/* File: x86/alt_stub.S */ 16771/* 16772 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 16773 * any interesting requests and then jump to the real instruction 16774 * handler. Unlike the Arm handler, we can't do this as a tail call 16775 * because rIBASE is caller save and we need to reload it. 16776 * 16777 * Note that unlike in the Arm implementation, we should never arrive 16778 * here with a zero breakFlag because we always refresh rIBASE on 16779 * return. 16780 */ 16781 EXPORT_PC 16782 movl rSELF, %eax 16783 movl rPC, OUT_ARG0(%esp) 16784 cmpb $0,offThread_breakFlags(%eax) # anything to do? 16785 movl rFP, OUT_ARG1(%esp) 16786 je 1f # reload rIBASE & resume if not 16787 movl %eax, OUT_ARG2(%esp) 16788 call dvmCheckBefore # (dPC, dFP, self) 16789 movl rSELF, %eax 167901: 16791 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 16792 jmp *dvmAsmInstructionStart+(203*4) 16793 16794/* ------------------------------ */ 16795.L_ALT_OP_SUB_DOUBLE_2ADDR: /* 0xcc */ 16796/* File: x86/alt_stub.S */ 16797/* 16798 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 16799 * any interesting requests and then jump to the real instruction 16800 * handler. Unlike the Arm handler, we can't do this as a tail call 16801 * because rIBASE is caller save and we need to reload it. 16802 * 16803 * Note that unlike in the Arm implementation, we should never arrive 16804 * here with a zero breakFlag because we always refresh rIBASE on 16805 * return. 16806 */ 16807 EXPORT_PC 16808 movl rSELF, %eax 16809 movl rPC, OUT_ARG0(%esp) 16810 cmpb $0,offThread_breakFlags(%eax) # anything to do? 16811 movl rFP, OUT_ARG1(%esp) 16812 je 1f # reload rIBASE & resume if not 16813 movl %eax, OUT_ARG2(%esp) 16814 call dvmCheckBefore # (dPC, dFP, self) 16815 movl rSELF, %eax 168161: 16817 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 16818 jmp *dvmAsmInstructionStart+(204*4) 16819 16820/* ------------------------------ */ 16821.L_ALT_OP_MUL_DOUBLE_2ADDR: /* 0xcd */ 16822/* File: x86/alt_stub.S */ 16823/* 16824 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 16825 * any interesting requests and then jump to the real instruction 16826 * handler. Unlike the Arm handler, we can't do this as a tail call 16827 * because rIBASE is caller save and we need to reload it. 16828 * 16829 * Note that unlike in the Arm implementation, we should never arrive 16830 * here with a zero breakFlag because we always refresh rIBASE on 16831 * return. 16832 */ 16833 EXPORT_PC 16834 movl rSELF, %eax 16835 movl rPC, OUT_ARG0(%esp) 16836 cmpb $0,offThread_breakFlags(%eax) # anything to do? 16837 movl rFP, OUT_ARG1(%esp) 16838 je 1f # reload rIBASE & resume if not 16839 movl %eax, OUT_ARG2(%esp) 16840 call dvmCheckBefore # (dPC, dFP, self) 16841 movl rSELF, %eax 168421: 16843 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 16844 jmp *dvmAsmInstructionStart+(205*4) 16845 16846/* ------------------------------ */ 16847.L_ALT_OP_DIV_DOUBLE_2ADDR: /* 0xce */ 16848/* File: x86/alt_stub.S */ 16849/* 16850 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 16851 * any interesting requests and then jump to the real instruction 16852 * handler. Unlike the Arm handler, we can't do this as a tail call 16853 * because rIBASE is caller save and we need to reload it. 16854 * 16855 * Note that unlike in the Arm implementation, we should never arrive 16856 * here with a zero breakFlag because we always refresh rIBASE on 16857 * return. 16858 */ 16859 EXPORT_PC 16860 movl rSELF, %eax 16861 movl rPC, OUT_ARG0(%esp) 16862 cmpb $0,offThread_breakFlags(%eax) # anything to do? 16863 movl rFP, OUT_ARG1(%esp) 16864 je 1f # reload rIBASE & resume if not 16865 movl %eax, OUT_ARG2(%esp) 16866 call dvmCheckBefore # (dPC, dFP, self) 16867 movl rSELF, %eax 168681: 16869 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 16870 jmp *dvmAsmInstructionStart+(206*4) 16871 16872/* ------------------------------ */ 16873.L_ALT_OP_REM_DOUBLE_2ADDR: /* 0xcf */ 16874/* File: x86/alt_stub.S */ 16875/* 16876 * Inter-instruction transfer stub. Call out to dvmCheckBefore 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 * Note that unlike in the Arm implementation, we should never arrive 16882 * here with a zero breakFlag because we always refresh rIBASE on 16883 * return. 16884 */ 16885 EXPORT_PC 16886 movl rSELF, %eax 16887 movl rPC, OUT_ARG0(%esp) 16888 cmpb $0,offThread_breakFlags(%eax) # anything to do? 16889 movl rFP, OUT_ARG1(%esp) 16890 je 1f # reload rIBASE & resume if not 16891 movl %eax, OUT_ARG2(%esp) 16892 call dvmCheckBefore # (dPC, dFP, self) 16893 movl rSELF, %eax 168941: 16895 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 16896 jmp *dvmAsmInstructionStart+(207*4) 16897 16898/* ------------------------------ */ 16899.L_ALT_OP_ADD_INT_LIT16: /* 0xd0 */ 16900/* File: x86/alt_stub.S */ 16901/* 16902 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 16903 * any interesting requests and then jump to the real instruction 16904 * handler. Unlike the Arm handler, we can't do this as a tail call 16905 * because rIBASE is caller save and we need to reload it. 16906 * 16907 * Note that unlike in the Arm implementation, we should never arrive 16908 * here with a zero breakFlag because we always refresh rIBASE on 16909 * return. 16910 */ 16911 EXPORT_PC 16912 movl rSELF, %eax 16913 movl rPC, OUT_ARG0(%esp) 16914 cmpb $0,offThread_breakFlags(%eax) # anything to do? 16915 movl rFP, OUT_ARG1(%esp) 16916 je 1f # reload rIBASE & resume if not 16917 movl %eax, OUT_ARG2(%esp) 16918 call dvmCheckBefore # (dPC, dFP, self) 16919 movl rSELF, %eax 169201: 16921 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 16922 jmp *dvmAsmInstructionStart+(208*4) 16923 16924/* ------------------------------ */ 16925.L_ALT_OP_RSUB_INT: /* 0xd1 */ 16926/* File: x86/alt_stub.S */ 16927/* 16928 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 16929 * any interesting requests and then jump to the real instruction 16930 * handler. Unlike the Arm handler, we can't do this as a tail call 16931 * because rIBASE is caller save and we need to reload it. 16932 * 16933 * Note that unlike in the Arm implementation, we should never arrive 16934 * here with a zero breakFlag because we always refresh rIBASE on 16935 * return. 16936 */ 16937 EXPORT_PC 16938 movl rSELF, %eax 16939 movl rPC, OUT_ARG0(%esp) 16940 cmpb $0,offThread_breakFlags(%eax) # anything to do? 16941 movl rFP, OUT_ARG1(%esp) 16942 je 1f # reload rIBASE & resume if not 16943 movl %eax, OUT_ARG2(%esp) 16944 call dvmCheckBefore # (dPC, dFP, self) 16945 movl rSELF, %eax 169461: 16947 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 16948 jmp *dvmAsmInstructionStart+(209*4) 16949 16950/* ------------------------------ */ 16951.L_ALT_OP_MUL_INT_LIT16: /* 0xd2 */ 16952/* File: x86/alt_stub.S */ 16953/* 16954 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 16955 * any interesting requests and then jump to the real instruction 16956 * handler. Unlike the Arm handler, we can't do this as a tail call 16957 * because rIBASE is caller save and we need to reload it. 16958 * 16959 * Note that unlike in the Arm implementation, we should never arrive 16960 * here with a zero breakFlag because we always refresh rIBASE on 16961 * return. 16962 */ 16963 EXPORT_PC 16964 movl rSELF, %eax 16965 movl rPC, OUT_ARG0(%esp) 16966 cmpb $0,offThread_breakFlags(%eax) # anything to do? 16967 movl rFP, OUT_ARG1(%esp) 16968 je 1f # reload rIBASE & resume if not 16969 movl %eax, OUT_ARG2(%esp) 16970 call dvmCheckBefore # (dPC, dFP, self) 16971 movl rSELF, %eax 169721: 16973 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 16974 jmp *dvmAsmInstructionStart+(210*4) 16975 16976/* ------------------------------ */ 16977.L_ALT_OP_DIV_INT_LIT16: /* 0xd3 */ 16978/* File: x86/alt_stub.S */ 16979/* 16980 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 16981 * any interesting requests and then jump to the real instruction 16982 * handler. Unlike the Arm handler, we can't do this as a tail call 16983 * because rIBASE is caller save and we need to reload it. 16984 * 16985 * Note that unlike in the Arm implementation, we should never arrive 16986 * here with a zero breakFlag because we always refresh rIBASE on 16987 * return. 16988 */ 16989 EXPORT_PC 16990 movl rSELF, %eax 16991 movl rPC, OUT_ARG0(%esp) 16992 cmpb $0,offThread_breakFlags(%eax) # anything to do? 16993 movl rFP, OUT_ARG1(%esp) 16994 je 1f # reload rIBASE & resume if not 16995 movl %eax, OUT_ARG2(%esp) 16996 call dvmCheckBefore # (dPC, dFP, self) 16997 movl rSELF, %eax 169981: 16999 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 17000 jmp *dvmAsmInstructionStart+(211*4) 17001 17002/* ------------------------------ */ 17003.L_ALT_OP_REM_INT_LIT16: /* 0xd4 */ 17004/* File: x86/alt_stub.S */ 17005/* 17006 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 17007 * any interesting requests and then jump to the real instruction 17008 * handler. Unlike the Arm handler, we can't do this as a tail call 17009 * because rIBASE is caller save and we need to reload it. 17010 * 17011 * Note that unlike in the Arm implementation, we should never arrive 17012 * here with a zero breakFlag because we always refresh rIBASE on 17013 * return. 17014 */ 17015 EXPORT_PC 17016 movl rSELF, %eax 17017 movl rPC, OUT_ARG0(%esp) 17018 cmpb $0,offThread_breakFlags(%eax) # anything to do? 17019 movl rFP, OUT_ARG1(%esp) 17020 je 1f # reload rIBASE & resume if not 17021 movl %eax, OUT_ARG2(%esp) 17022 call dvmCheckBefore # (dPC, dFP, self) 17023 movl rSELF, %eax 170241: 17025 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 17026 jmp *dvmAsmInstructionStart+(212*4) 17027 17028/* ------------------------------ */ 17029.L_ALT_OP_AND_INT_LIT16: /* 0xd5 */ 17030/* File: x86/alt_stub.S */ 17031/* 17032 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 17033 * any interesting requests and then jump to the real instruction 17034 * handler. Unlike the Arm handler, we can't do this as a tail call 17035 * because rIBASE is caller save and we need to reload it. 17036 * 17037 * Note that unlike in the Arm implementation, we should never arrive 17038 * here with a zero breakFlag because we always refresh rIBASE on 17039 * return. 17040 */ 17041 EXPORT_PC 17042 movl rSELF, %eax 17043 movl rPC, OUT_ARG0(%esp) 17044 cmpb $0,offThread_breakFlags(%eax) # anything to do? 17045 movl rFP, OUT_ARG1(%esp) 17046 je 1f # reload rIBASE & resume if not 17047 movl %eax, OUT_ARG2(%esp) 17048 call dvmCheckBefore # (dPC, dFP, self) 17049 movl rSELF, %eax 170501: 17051 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 17052 jmp *dvmAsmInstructionStart+(213*4) 17053 17054/* ------------------------------ */ 17055.L_ALT_OP_OR_INT_LIT16: /* 0xd6 */ 17056/* File: x86/alt_stub.S */ 17057/* 17058 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 17059 * any interesting requests and then jump to the real instruction 17060 * handler. Unlike the Arm handler, we can't do this as a tail call 17061 * because rIBASE is caller save and we need to reload it. 17062 * 17063 * Note that unlike in the Arm implementation, we should never arrive 17064 * here with a zero breakFlag because we always refresh rIBASE on 17065 * return. 17066 */ 17067 EXPORT_PC 17068 movl rSELF, %eax 17069 movl rPC, OUT_ARG0(%esp) 17070 cmpb $0,offThread_breakFlags(%eax) # anything to do? 17071 movl rFP, OUT_ARG1(%esp) 17072 je 1f # reload rIBASE & resume if not 17073 movl %eax, OUT_ARG2(%esp) 17074 call dvmCheckBefore # (dPC, dFP, self) 17075 movl rSELF, %eax 170761: 17077 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 17078 jmp *dvmAsmInstructionStart+(214*4) 17079 17080/* ------------------------------ */ 17081.L_ALT_OP_XOR_INT_LIT16: /* 0xd7 */ 17082/* File: x86/alt_stub.S */ 17083/* 17084 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 17085 * any interesting requests and then jump to the real instruction 17086 * handler. Unlike the Arm handler, we can't do this as a tail call 17087 * because rIBASE is caller save and we need to reload it. 17088 * 17089 * Note that unlike in the Arm implementation, we should never arrive 17090 * here with a zero breakFlag because we always refresh rIBASE on 17091 * return. 17092 */ 17093 EXPORT_PC 17094 movl rSELF, %eax 17095 movl rPC, OUT_ARG0(%esp) 17096 cmpb $0,offThread_breakFlags(%eax) # anything to do? 17097 movl rFP, OUT_ARG1(%esp) 17098 je 1f # reload rIBASE & resume if not 17099 movl %eax, OUT_ARG2(%esp) 17100 call dvmCheckBefore # (dPC, dFP, self) 17101 movl rSELF, %eax 171021: 17103 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 17104 jmp *dvmAsmInstructionStart+(215*4) 17105 17106/* ------------------------------ */ 17107.L_ALT_OP_ADD_INT_LIT8: /* 0xd8 */ 17108/* File: x86/alt_stub.S */ 17109/* 17110 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 17111 * any interesting requests and then jump to the real instruction 17112 * handler. Unlike the Arm handler, we can't do this as a tail call 17113 * because rIBASE is caller save and we need to reload it. 17114 * 17115 * Note that unlike in the Arm implementation, we should never arrive 17116 * here with a zero breakFlag because we always refresh rIBASE on 17117 * return. 17118 */ 17119 EXPORT_PC 17120 movl rSELF, %eax 17121 movl rPC, OUT_ARG0(%esp) 17122 cmpb $0,offThread_breakFlags(%eax) # anything to do? 17123 movl rFP, OUT_ARG1(%esp) 17124 je 1f # reload rIBASE & resume if not 17125 movl %eax, OUT_ARG2(%esp) 17126 call dvmCheckBefore # (dPC, dFP, self) 17127 movl rSELF, %eax 171281: 17129 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 17130 jmp *dvmAsmInstructionStart+(216*4) 17131 17132/* ------------------------------ */ 17133.L_ALT_OP_RSUB_INT_LIT8: /* 0xd9 */ 17134/* File: x86/alt_stub.S */ 17135/* 17136 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 17137 * any interesting requests and then jump to the real instruction 17138 * handler. Unlike the Arm handler, we can't do this as a tail call 17139 * because rIBASE is caller save and we need to reload it. 17140 * 17141 * Note that unlike in the Arm implementation, we should never arrive 17142 * here with a zero breakFlag because we always refresh rIBASE on 17143 * return. 17144 */ 17145 EXPORT_PC 17146 movl rSELF, %eax 17147 movl rPC, OUT_ARG0(%esp) 17148 cmpb $0,offThread_breakFlags(%eax) # anything to do? 17149 movl rFP, OUT_ARG1(%esp) 17150 je 1f # reload rIBASE & resume if not 17151 movl %eax, OUT_ARG2(%esp) 17152 call dvmCheckBefore # (dPC, dFP, self) 17153 movl rSELF, %eax 171541: 17155 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 17156 jmp *dvmAsmInstructionStart+(217*4) 17157 17158/* ------------------------------ */ 17159.L_ALT_OP_MUL_INT_LIT8: /* 0xda */ 17160/* File: x86/alt_stub.S */ 17161/* 17162 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 17163 * any interesting requests and then jump to the real instruction 17164 * handler. Unlike the Arm handler, we can't do this as a tail call 17165 * because rIBASE is caller save and we need to reload it. 17166 * 17167 * Note that unlike in the Arm implementation, we should never arrive 17168 * here with a zero breakFlag because we always refresh rIBASE on 17169 * return. 17170 */ 17171 EXPORT_PC 17172 movl rSELF, %eax 17173 movl rPC, OUT_ARG0(%esp) 17174 cmpb $0,offThread_breakFlags(%eax) # anything to do? 17175 movl rFP, OUT_ARG1(%esp) 17176 je 1f # reload rIBASE & resume if not 17177 movl %eax, OUT_ARG2(%esp) 17178 call dvmCheckBefore # (dPC, dFP, self) 17179 movl rSELF, %eax 171801: 17181 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 17182 jmp *dvmAsmInstructionStart+(218*4) 17183 17184/* ------------------------------ */ 17185.L_ALT_OP_DIV_INT_LIT8: /* 0xdb */ 17186/* File: x86/alt_stub.S */ 17187/* 17188 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 17189 * any interesting requests and then jump to the real instruction 17190 * handler. Unlike the Arm handler, we can't do this as a tail call 17191 * because rIBASE is caller save and we need to reload it. 17192 * 17193 * Note that unlike in the Arm implementation, we should never arrive 17194 * here with a zero breakFlag because we always refresh rIBASE on 17195 * return. 17196 */ 17197 EXPORT_PC 17198 movl rSELF, %eax 17199 movl rPC, OUT_ARG0(%esp) 17200 cmpb $0,offThread_breakFlags(%eax) # anything to do? 17201 movl rFP, OUT_ARG1(%esp) 17202 je 1f # reload rIBASE & resume if not 17203 movl %eax, OUT_ARG2(%esp) 17204 call dvmCheckBefore # (dPC, dFP, self) 17205 movl rSELF, %eax 172061: 17207 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 17208 jmp *dvmAsmInstructionStart+(219*4) 17209 17210/* ------------------------------ */ 17211.L_ALT_OP_REM_INT_LIT8: /* 0xdc */ 17212/* File: x86/alt_stub.S */ 17213/* 17214 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 17215 * any interesting requests and then jump to the real instruction 17216 * handler. Unlike the Arm handler, we can't do this as a tail call 17217 * because rIBASE is caller save and we need to reload it. 17218 * 17219 * Note that unlike in the Arm implementation, we should never arrive 17220 * here with a zero breakFlag because we always refresh rIBASE on 17221 * return. 17222 */ 17223 EXPORT_PC 17224 movl rSELF, %eax 17225 movl rPC, OUT_ARG0(%esp) 17226 cmpb $0,offThread_breakFlags(%eax) # anything to do? 17227 movl rFP, OUT_ARG1(%esp) 17228 je 1f # reload rIBASE & resume if not 17229 movl %eax, OUT_ARG2(%esp) 17230 call dvmCheckBefore # (dPC, dFP, self) 17231 movl rSELF, %eax 172321: 17233 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 17234 jmp *dvmAsmInstructionStart+(220*4) 17235 17236/* ------------------------------ */ 17237.L_ALT_OP_AND_INT_LIT8: /* 0xdd */ 17238/* File: x86/alt_stub.S */ 17239/* 17240 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 17241 * any interesting requests and then jump to the real instruction 17242 * handler. Unlike the Arm handler, we can't do this as a tail call 17243 * because rIBASE is caller save and we need to reload it. 17244 * 17245 * Note that unlike in the Arm implementation, we should never arrive 17246 * here with a zero breakFlag because we always refresh rIBASE on 17247 * return. 17248 */ 17249 EXPORT_PC 17250 movl rSELF, %eax 17251 movl rPC, OUT_ARG0(%esp) 17252 cmpb $0,offThread_breakFlags(%eax) # anything to do? 17253 movl rFP, OUT_ARG1(%esp) 17254 je 1f # reload rIBASE & resume if not 17255 movl %eax, OUT_ARG2(%esp) 17256 call dvmCheckBefore # (dPC, dFP, self) 17257 movl rSELF, %eax 172581: 17259 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 17260 jmp *dvmAsmInstructionStart+(221*4) 17261 17262/* ------------------------------ */ 17263.L_ALT_OP_OR_INT_LIT8: /* 0xde */ 17264/* File: x86/alt_stub.S */ 17265/* 17266 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 17267 * any interesting requests and then jump to the real instruction 17268 * handler. Unlike the Arm handler, we can't do this as a tail call 17269 * because rIBASE is caller save and we need to reload it. 17270 * 17271 * Note that unlike in the Arm implementation, we should never arrive 17272 * here with a zero breakFlag because we always refresh rIBASE on 17273 * return. 17274 */ 17275 EXPORT_PC 17276 movl rSELF, %eax 17277 movl rPC, OUT_ARG0(%esp) 17278 cmpb $0,offThread_breakFlags(%eax) # anything to do? 17279 movl rFP, OUT_ARG1(%esp) 17280 je 1f # reload rIBASE & resume if not 17281 movl %eax, OUT_ARG2(%esp) 17282 call dvmCheckBefore # (dPC, dFP, self) 17283 movl rSELF, %eax 172841: 17285 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 17286 jmp *dvmAsmInstructionStart+(222*4) 17287 17288/* ------------------------------ */ 17289.L_ALT_OP_XOR_INT_LIT8: /* 0xdf */ 17290/* File: x86/alt_stub.S */ 17291/* 17292 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 17293 * any interesting requests and then jump to the real instruction 17294 * handler. Unlike the Arm handler, we can't do this as a tail call 17295 * because rIBASE is caller save and we need to reload it. 17296 * 17297 * Note that unlike in the Arm implementation, we should never arrive 17298 * here with a zero breakFlag because we always refresh rIBASE on 17299 * return. 17300 */ 17301 EXPORT_PC 17302 movl rSELF, %eax 17303 movl rPC, OUT_ARG0(%esp) 17304 cmpb $0,offThread_breakFlags(%eax) # anything to do? 17305 movl rFP, OUT_ARG1(%esp) 17306 je 1f # reload rIBASE & resume if not 17307 movl %eax, OUT_ARG2(%esp) 17308 call dvmCheckBefore # (dPC, dFP, self) 17309 movl rSELF, %eax 173101: 17311 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 17312 jmp *dvmAsmInstructionStart+(223*4) 17313 17314/* ------------------------------ */ 17315.L_ALT_OP_SHL_INT_LIT8: /* 0xe0 */ 17316/* File: x86/alt_stub.S */ 17317/* 17318 * Inter-instruction transfer stub. Call out to dvmCheckBefore 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 * Note that unlike in the Arm implementation, we should never arrive 17324 * here with a zero breakFlag because we always refresh rIBASE on 17325 * return. 17326 */ 17327 EXPORT_PC 17328 movl rSELF, %eax 17329 movl rPC, OUT_ARG0(%esp) 17330 cmpb $0,offThread_breakFlags(%eax) # anything to do? 17331 movl rFP, OUT_ARG1(%esp) 17332 je 1f # reload rIBASE & resume if not 17333 movl %eax, OUT_ARG2(%esp) 17334 call dvmCheckBefore # (dPC, dFP, self) 17335 movl rSELF, %eax 173361: 17337 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 17338 jmp *dvmAsmInstructionStart+(224*4) 17339 17340/* ------------------------------ */ 17341.L_ALT_OP_SHR_INT_LIT8: /* 0xe1 */ 17342/* File: x86/alt_stub.S */ 17343/* 17344 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 17345 * any interesting requests and then jump to the real instruction 17346 * handler. Unlike the Arm handler, we can't do this as a tail call 17347 * because rIBASE is caller save and we need to reload it. 17348 * 17349 * Note that unlike in the Arm implementation, we should never arrive 17350 * here with a zero breakFlag because we always refresh rIBASE on 17351 * return. 17352 */ 17353 EXPORT_PC 17354 movl rSELF, %eax 17355 movl rPC, OUT_ARG0(%esp) 17356 cmpb $0,offThread_breakFlags(%eax) # anything to do? 17357 movl rFP, OUT_ARG1(%esp) 17358 je 1f # reload rIBASE & resume if not 17359 movl %eax, OUT_ARG2(%esp) 17360 call dvmCheckBefore # (dPC, dFP, self) 17361 movl rSELF, %eax 173621: 17363 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 17364 jmp *dvmAsmInstructionStart+(225*4) 17365 17366/* ------------------------------ */ 17367.L_ALT_OP_USHR_INT_LIT8: /* 0xe2 */ 17368/* File: x86/alt_stub.S */ 17369/* 17370 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 17371 * any interesting requests and then jump to the real instruction 17372 * handler. Unlike the Arm handler, we can't do this as a tail call 17373 * because rIBASE is caller save and we need to reload it. 17374 * 17375 * Note that unlike in the Arm implementation, we should never arrive 17376 * here with a zero breakFlag because we always refresh rIBASE on 17377 * return. 17378 */ 17379 EXPORT_PC 17380 movl rSELF, %eax 17381 movl rPC, OUT_ARG0(%esp) 17382 cmpb $0,offThread_breakFlags(%eax) # anything to do? 17383 movl rFP, OUT_ARG1(%esp) 17384 je 1f # reload rIBASE & resume if not 17385 movl %eax, OUT_ARG2(%esp) 17386 call dvmCheckBefore # (dPC, dFP, self) 17387 movl rSELF, %eax 173881: 17389 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 17390 jmp *dvmAsmInstructionStart+(226*4) 17391 17392/* ------------------------------ */ 17393.L_ALT_OP_IGET_VOLATILE: /* 0xe3 */ 17394/* File: x86/alt_stub.S */ 17395/* 17396 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 17397 * any interesting requests and then jump to the real instruction 17398 * handler. Unlike the Arm handler, we can't do this as a tail call 17399 * because rIBASE is caller save and we need to reload it. 17400 * 17401 * Note that unlike in the Arm implementation, we should never arrive 17402 * here with a zero breakFlag because we always refresh rIBASE on 17403 * return. 17404 */ 17405 EXPORT_PC 17406 movl rSELF, %eax 17407 movl rPC, OUT_ARG0(%esp) 17408 cmpb $0,offThread_breakFlags(%eax) # anything to do? 17409 movl rFP, OUT_ARG1(%esp) 17410 je 1f # reload rIBASE & resume if not 17411 movl %eax, OUT_ARG2(%esp) 17412 call dvmCheckBefore # (dPC, dFP, self) 17413 movl rSELF, %eax 174141: 17415 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 17416 jmp *dvmAsmInstructionStart+(227*4) 17417 17418/* ------------------------------ */ 17419.L_ALT_OP_IPUT_VOLATILE: /* 0xe4 */ 17420/* File: x86/alt_stub.S */ 17421/* 17422 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 17423 * any interesting requests and then jump to the real instruction 17424 * handler. Unlike the Arm handler, we can't do this as a tail call 17425 * because rIBASE is caller save and we need to reload it. 17426 * 17427 * Note that unlike in the Arm implementation, we should never arrive 17428 * here with a zero breakFlag because we always refresh rIBASE on 17429 * return. 17430 */ 17431 EXPORT_PC 17432 movl rSELF, %eax 17433 movl rPC, OUT_ARG0(%esp) 17434 cmpb $0,offThread_breakFlags(%eax) # anything to do? 17435 movl rFP, OUT_ARG1(%esp) 17436 je 1f # reload rIBASE & resume if not 17437 movl %eax, OUT_ARG2(%esp) 17438 call dvmCheckBefore # (dPC, dFP, self) 17439 movl rSELF, %eax 174401: 17441 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 17442 jmp *dvmAsmInstructionStart+(228*4) 17443 17444/* ------------------------------ */ 17445.L_ALT_OP_SGET_VOLATILE: /* 0xe5 */ 17446/* File: x86/alt_stub.S */ 17447/* 17448 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 17449 * any interesting requests and then jump to the real instruction 17450 * handler. Unlike the Arm handler, we can't do this as a tail call 17451 * because rIBASE is caller save and we need to reload it. 17452 * 17453 * Note that unlike in the Arm implementation, we should never arrive 17454 * here with a zero breakFlag because we always refresh rIBASE on 17455 * return. 17456 */ 17457 EXPORT_PC 17458 movl rSELF, %eax 17459 movl rPC, OUT_ARG0(%esp) 17460 cmpb $0,offThread_breakFlags(%eax) # anything to do? 17461 movl rFP, OUT_ARG1(%esp) 17462 je 1f # reload rIBASE & resume if not 17463 movl %eax, OUT_ARG2(%esp) 17464 call dvmCheckBefore # (dPC, dFP, self) 17465 movl rSELF, %eax 174661: 17467 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 17468 jmp *dvmAsmInstructionStart+(229*4) 17469 17470/* ------------------------------ */ 17471.L_ALT_OP_SPUT_VOLATILE: /* 0xe6 */ 17472/* File: x86/alt_stub.S */ 17473/* 17474 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 17475 * any interesting requests and then jump to the real instruction 17476 * handler. Unlike the Arm handler, we can't do this as a tail call 17477 * because rIBASE is caller save and we need to reload it. 17478 * 17479 * Note that unlike in the Arm implementation, we should never arrive 17480 * here with a zero breakFlag because we always refresh rIBASE on 17481 * return. 17482 */ 17483 EXPORT_PC 17484 movl rSELF, %eax 17485 movl rPC, OUT_ARG0(%esp) 17486 cmpb $0,offThread_breakFlags(%eax) # anything to do? 17487 movl rFP, OUT_ARG1(%esp) 17488 je 1f # reload rIBASE & resume if not 17489 movl %eax, OUT_ARG2(%esp) 17490 call dvmCheckBefore # (dPC, dFP, self) 17491 movl rSELF, %eax 174921: 17493 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 17494 jmp *dvmAsmInstructionStart+(230*4) 17495 17496/* ------------------------------ */ 17497.L_ALT_OP_IGET_OBJECT_VOLATILE: /* 0xe7 */ 17498/* File: x86/alt_stub.S */ 17499/* 17500 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 17501 * any interesting requests and then jump to the real instruction 17502 * handler. Unlike the Arm handler, we can't do this as a tail call 17503 * because rIBASE is caller save and we need to reload it. 17504 * 17505 * Note that unlike in the Arm implementation, we should never arrive 17506 * here with a zero breakFlag because we always refresh rIBASE on 17507 * return. 17508 */ 17509 EXPORT_PC 17510 movl rSELF, %eax 17511 movl rPC, OUT_ARG0(%esp) 17512 cmpb $0,offThread_breakFlags(%eax) # anything to do? 17513 movl rFP, OUT_ARG1(%esp) 17514 je 1f # reload rIBASE & resume if not 17515 movl %eax, OUT_ARG2(%esp) 17516 call dvmCheckBefore # (dPC, dFP, self) 17517 movl rSELF, %eax 175181: 17519 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 17520 jmp *dvmAsmInstructionStart+(231*4) 17521 17522/* ------------------------------ */ 17523.L_ALT_OP_IGET_WIDE_VOLATILE: /* 0xe8 */ 17524/* File: x86/alt_stub.S */ 17525/* 17526 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 17527 * any interesting requests and then jump to the real instruction 17528 * handler. Unlike the Arm handler, we can't do this as a tail call 17529 * because rIBASE is caller save and we need to reload it. 17530 * 17531 * Note that unlike in the Arm implementation, we should never arrive 17532 * here with a zero breakFlag because we always refresh rIBASE on 17533 * return. 17534 */ 17535 EXPORT_PC 17536 movl rSELF, %eax 17537 movl rPC, OUT_ARG0(%esp) 17538 cmpb $0,offThread_breakFlags(%eax) # anything to do? 17539 movl rFP, OUT_ARG1(%esp) 17540 je 1f # reload rIBASE & resume if not 17541 movl %eax, OUT_ARG2(%esp) 17542 call dvmCheckBefore # (dPC, dFP, self) 17543 movl rSELF, %eax 175441: 17545 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 17546 jmp *dvmAsmInstructionStart+(232*4) 17547 17548/* ------------------------------ */ 17549.L_ALT_OP_IPUT_WIDE_VOLATILE: /* 0xe9 */ 17550/* File: x86/alt_stub.S */ 17551/* 17552 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 17553 * any interesting requests and then jump to the real instruction 17554 * handler. Unlike the Arm handler, we can't do this as a tail call 17555 * because rIBASE is caller save and we need to reload it. 17556 * 17557 * Note that unlike in the Arm implementation, we should never arrive 17558 * here with a zero breakFlag because we always refresh rIBASE on 17559 * return. 17560 */ 17561 EXPORT_PC 17562 movl rSELF, %eax 17563 movl rPC, OUT_ARG0(%esp) 17564 cmpb $0,offThread_breakFlags(%eax) # anything to do? 17565 movl rFP, OUT_ARG1(%esp) 17566 je 1f # reload rIBASE & resume if not 17567 movl %eax, OUT_ARG2(%esp) 17568 call dvmCheckBefore # (dPC, dFP, self) 17569 movl rSELF, %eax 175701: 17571 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 17572 jmp *dvmAsmInstructionStart+(233*4) 17573 17574/* ------------------------------ */ 17575.L_ALT_OP_SGET_WIDE_VOLATILE: /* 0xea */ 17576/* File: x86/alt_stub.S */ 17577/* 17578 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 17579 * any interesting requests and then jump to the real instruction 17580 * handler. Unlike the Arm handler, we can't do this as a tail call 17581 * because rIBASE is caller save and we need to reload it. 17582 * 17583 * Note that unlike in the Arm implementation, we should never arrive 17584 * here with a zero breakFlag because we always refresh rIBASE on 17585 * return. 17586 */ 17587 EXPORT_PC 17588 movl rSELF, %eax 17589 movl rPC, OUT_ARG0(%esp) 17590 cmpb $0,offThread_breakFlags(%eax) # anything to do? 17591 movl rFP, OUT_ARG1(%esp) 17592 je 1f # reload rIBASE & resume if not 17593 movl %eax, OUT_ARG2(%esp) 17594 call dvmCheckBefore # (dPC, dFP, self) 17595 movl rSELF, %eax 175961: 17597 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 17598 jmp *dvmAsmInstructionStart+(234*4) 17599 17600/* ------------------------------ */ 17601.L_ALT_OP_SPUT_WIDE_VOLATILE: /* 0xeb */ 17602/* File: x86/alt_stub.S */ 17603/* 17604 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 17605 * any interesting requests and then jump to the real instruction 17606 * handler. Unlike the Arm handler, we can't do this as a tail call 17607 * because rIBASE is caller save and we need to reload it. 17608 * 17609 * Note that unlike in the Arm implementation, we should never arrive 17610 * here with a zero breakFlag because we always refresh rIBASE on 17611 * return. 17612 */ 17613 EXPORT_PC 17614 movl rSELF, %eax 17615 movl rPC, OUT_ARG0(%esp) 17616 cmpb $0,offThread_breakFlags(%eax) # anything to do? 17617 movl rFP, OUT_ARG1(%esp) 17618 je 1f # reload rIBASE & resume if not 17619 movl %eax, OUT_ARG2(%esp) 17620 call dvmCheckBefore # (dPC, dFP, self) 17621 movl rSELF, %eax 176221: 17623 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 17624 jmp *dvmAsmInstructionStart+(235*4) 17625 17626/* ------------------------------ */ 17627.L_ALT_OP_BREAKPOINT: /* 0xec */ 17628/* File: x86/alt_stub.S */ 17629/* 17630 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 17631 * any interesting requests and then jump to the real instruction 17632 * handler. Unlike the Arm handler, we can't do this as a tail call 17633 * because rIBASE is caller save and we need to reload it. 17634 * 17635 * Note that unlike in the Arm implementation, we should never arrive 17636 * here with a zero breakFlag because we always refresh rIBASE on 17637 * return. 17638 */ 17639 EXPORT_PC 17640 movl rSELF, %eax 17641 movl rPC, OUT_ARG0(%esp) 17642 cmpb $0,offThread_breakFlags(%eax) # anything to do? 17643 movl rFP, OUT_ARG1(%esp) 17644 je 1f # reload rIBASE & resume if not 17645 movl %eax, OUT_ARG2(%esp) 17646 call dvmCheckBefore # (dPC, dFP, self) 17647 movl rSELF, %eax 176481: 17649 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 17650 jmp *dvmAsmInstructionStart+(236*4) 17651 17652/* ------------------------------ */ 17653.L_ALT_OP_THROW_VERIFICATION_ERROR: /* 0xed */ 17654/* File: x86/alt_stub.S */ 17655/* 17656 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 17657 * any interesting requests and then jump to the real instruction 17658 * handler. Unlike the Arm handler, we can't do this as a tail call 17659 * because rIBASE is caller save and we need to reload it. 17660 * 17661 * Note that unlike in the Arm implementation, we should never arrive 17662 * here with a zero breakFlag because we always refresh rIBASE on 17663 * return. 17664 */ 17665 EXPORT_PC 17666 movl rSELF, %eax 17667 movl rPC, OUT_ARG0(%esp) 17668 cmpb $0,offThread_breakFlags(%eax) # anything to do? 17669 movl rFP, OUT_ARG1(%esp) 17670 je 1f # reload rIBASE & resume if not 17671 movl %eax, OUT_ARG2(%esp) 17672 call dvmCheckBefore # (dPC, dFP, self) 17673 movl rSELF, %eax 176741: 17675 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 17676 jmp *dvmAsmInstructionStart+(237*4) 17677 17678/* ------------------------------ */ 17679.L_ALT_OP_EXECUTE_INLINE: /* 0xee */ 17680/* File: x86/alt_stub.S */ 17681/* 17682 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 17683 * any interesting requests and then jump to the real instruction 17684 * handler. Unlike the Arm handler, we can't do this as a tail call 17685 * because rIBASE is caller save and we need to reload it. 17686 * 17687 * Note that unlike in the Arm implementation, we should never arrive 17688 * here with a zero breakFlag because we always refresh rIBASE on 17689 * return. 17690 */ 17691 EXPORT_PC 17692 movl rSELF, %eax 17693 movl rPC, OUT_ARG0(%esp) 17694 cmpb $0,offThread_breakFlags(%eax) # anything to do? 17695 movl rFP, OUT_ARG1(%esp) 17696 je 1f # reload rIBASE & resume if not 17697 movl %eax, OUT_ARG2(%esp) 17698 call dvmCheckBefore # (dPC, dFP, self) 17699 movl rSELF, %eax 177001: 17701 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 17702 jmp *dvmAsmInstructionStart+(238*4) 17703 17704/* ------------------------------ */ 17705.L_ALT_OP_EXECUTE_INLINE_RANGE: /* 0xef */ 17706/* File: x86/alt_stub.S */ 17707/* 17708 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 17709 * any interesting requests and then jump to the real instruction 17710 * handler. Unlike the Arm handler, we can't do this as a tail call 17711 * because rIBASE is caller save and we need to reload it. 17712 * 17713 * Note that unlike in the Arm implementation, we should never arrive 17714 * here with a zero breakFlag because we always refresh rIBASE on 17715 * return. 17716 */ 17717 EXPORT_PC 17718 movl rSELF, %eax 17719 movl rPC, OUT_ARG0(%esp) 17720 cmpb $0,offThread_breakFlags(%eax) # anything to do? 17721 movl rFP, OUT_ARG1(%esp) 17722 je 1f # reload rIBASE & resume if not 17723 movl %eax, OUT_ARG2(%esp) 17724 call dvmCheckBefore # (dPC, dFP, self) 17725 movl rSELF, %eax 177261: 17727 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 17728 jmp *dvmAsmInstructionStart+(239*4) 17729 17730/* ------------------------------ */ 17731.L_ALT_OP_INVOKE_OBJECT_INIT_RANGE: /* 0xf0 */ 17732/* File: x86/alt_stub.S */ 17733/* 17734 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 17735 * any interesting requests and then jump to the real instruction 17736 * handler. Unlike the Arm handler, we can't do this as a tail call 17737 * because rIBASE is caller save and we need to reload it. 17738 * 17739 * Note that unlike in the Arm implementation, we should never arrive 17740 * here with a zero breakFlag because we always refresh rIBASE on 17741 * return. 17742 */ 17743 EXPORT_PC 17744 movl rSELF, %eax 17745 movl rPC, OUT_ARG0(%esp) 17746 cmpb $0,offThread_breakFlags(%eax) # anything to do? 17747 movl rFP, OUT_ARG1(%esp) 17748 je 1f # reload rIBASE & resume if not 17749 movl %eax, OUT_ARG2(%esp) 17750 call dvmCheckBefore # (dPC, dFP, self) 17751 movl rSELF, %eax 177521: 17753 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 17754 jmp *dvmAsmInstructionStart+(240*4) 17755 17756/* ------------------------------ */ 17757.L_ALT_OP_RETURN_VOID_BARRIER: /* 0xf1 */ 17758/* File: x86/alt_stub.S */ 17759/* 17760 * Inter-instruction transfer stub. Call out to dvmCheckBefore 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 * Note that unlike in the Arm implementation, we should never arrive 17766 * here with a zero breakFlag because we always refresh rIBASE on 17767 * return. 17768 */ 17769 EXPORT_PC 17770 movl rSELF, %eax 17771 movl rPC, OUT_ARG0(%esp) 17772 cmpb $0,offThread_breakFlags(%eax) # anything to do? 17773 movl rFP, OUT_ARG1(%esp) 17774 je 1f # reload rIBASE & resume if not 17775 movl %eax, OUT_ARG2(%esp) 17776 call dvmCheckBefore # (dPC, dFP, self) 17777 movl rSELF, %eax 177781: 17779 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 17780 jmp *dvmAsmInstructionStart+(241*4) 17781 17782/* ------------------------------ */ 17783.L_ALT_OP_IGET_QUICK: /* 0xf2 */ 17784/* File: x86/alt_stub.S */ 17785/* 17786 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 17787 * any interesting requests and then jump to the real instruction 17788 * handler. Unlike the Arm handler, we can't do this as a tail call 17789 * because rIBASE is caller save and we need to reload it. 17790 * 17791 * Note that unlike in the Arm implementation, we should never arrive 17792 * here with a zero breakFlag because we always refresh rIBASE on 17793 * return. 17794 */ 17795 EXPORT_PC 17796 movl rSELF, %eax 17797 movl rPC, OUT_ARG0(%esp) 17798 cmpb $0,offThread_breakFlags(%eax) # anything to do? 17799 movl rFP, OUT_ARG1(%esp) 17800 je 1f # reload rIBASE & resume if not 17801 movl %eax, OUT_ARG2(%esp) 17802 call dvmCheckBefore # (dPC, dFP, self) 17803 movl rSELF, %eax 178041: 17805 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 17806 jmp *dvmAsmInstructionStart+(242*4) 17807 17808/* ------------------------------ */ 17809.L_ALT_OP_IGET_WIDE_QUICK: /* 0xf3 */ 17810/* File: x86/alt_stub.S */ 17811/* 17812 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 17813 * any interesting requests and then jump to the real instruction 17814 * handler. Unlike the Arm handler, we can't do this as a tail call 17815 * because rIBASE is caller save and we need to reload it. 17816 * 17817 * Note that unlike in the Arm implementation, we should never arrive 17818 * here with a zero breakFlag because we always refresh rIBASE on 17819 * return. 17820 */ 17821 EXPORT_PC 17822 movl rSELF, %eax 17823 movl rPC, OUT_ARG0(%esp) 17824 cmpb $0,offThread_breakFlags(%eax) # anything to do? 17825 movl rFP, OUT_ARG1(%esp) 17826 je 1f # reload rIBASE & resume if not 17827 movl %eax, OUT_ARG2(%esp) 17828 call dvmCheckBefore # (dPC, dFP, self) 17829 movl rSELF, %eax 178301: 17831 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 17832 jmp *dvmAsmInstructionStart+(243*4) 17833 17834/* ------------------------------ */ 17835.L_ALT_OP_IGET_OBJECT_QUICK: /* 0xf4 */ 17836/* File: x86/alt_stub.S */ 17837/* 17838 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 17839 * any interesting requests and then jump to the real instruction 17840 * handler. Unlike the Arm handler, we can't do this as a tail call 17841 * because rIBASE is caller save and we need to reload it. 17842 * 17843 * Note that unlike in the Arm implementation, we should never arrive 17844 * here with a zero breakFlag because we always refresh rIBASE on 17845 * return. 17846 */ 17847 EXPORT_PC 17848 movl rSELF, %eax 17849 movl rPC, OUT_ARG0(%esp) 17850 cmpb $0,offThread_breakFlags(%eax) # anything to do? 17851 movl rFP, OUT_ARG1(%esp) 17852 je 1f # reload rIBASE & resume if not 17853 movl %eax, OUT_ARG2(%esp) 17854 call dvmCheckBefore # (dPC, dFP, self) 17855 movl rSELF, %eax 178561: 17857 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 17858 jmp *dvmAsmInstructionStart+(244*4) 17859 17860/* ------------------------------ */ 17861.L_ALT_OP_IPUT_QUICK: /* 0xf5 */ 17862/* File: x86/alt_stub.S */ 17863/* 17864 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 17865 * any interesting requests and then jump to the real instruction 17866 * handler. Unlike the Arm handler, we can't do this as a tail call 17867 * because rIBASE is caller save and we need to reload it. 17868 * 17869 * Note that unlike in the Arm implementation, we should never arrive 17870 * here with a zero breakFlag because we always refresh rIBASE on 17871 * return. 17872 */ 17873 EXPORT_PC 17874 movl rSELF, %eax 17875 movl rPC, OUT_ARG0(%esp) 17876 cmpb $0,offThread_breakFlags(%eax) # anything to do? 17877 movl rFP, OUT_ARG1(%esp) 17878 je 1f # reload rIBASE & resume if not 17879 movl %eax, OUT_ARG2(%esp) 17880 call dvmCheckBefore # (dPC, dFP, self) 17881 movl rSELF, %eax 178821: 17883 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 17884 jmp *dvmAsmInstructionStart+(245*4) 17885 17886/* ------------------------------ */ 17887.L_ALT_OP_IPUT_WIDE_QUICK: /* 0xf6 */ 17888/* File: x86/alt_stub.S */ 17889/* 17890 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 17891 * any interesting requests and then jump to the real instruction 17892 * handler. Unlike the Arm handler, we can't do this as a tail call 17893 * because rIBASE is caller save and we need to reload it. 17894 * 17895 * Note that unlike in the Arm implementation, we should never arrive 17896 * here with a zero breakFlag because we always refresh rIBASE on 17897 * return. 17898 */ 17899 EXPORT_PC 17900 movl rSELF, %eax 17901 movl rPC, OUT_ARG0(%esp) 17902 cmpb $0,offThread_breakFlags(%eax) # anything to do? 17903 movl rFP, OUT_ARG1(%esp) 17904 je 1f # reload rIBASE & resume if not 17905 movl %eax, OUT_ARG2(%esp) 17906 call dvmCheckBefore # (dPC, dFP, self) 17907 movl rSELF, %eax 179081: 17909 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 17910 jmp *dvmAsmInstructionStart+(246*4) 17911 17912/* ------------------------------ */ 17913.L_ALT_OP_IPUT_OBJECT_QUICK: /* 0xf7 */ 17914/* File: x86/alt_stub.S */ 17915/* 17916 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 17917 * any interesting requests and then jump to the real instruction 17918 * handler. Unlike the Arm handler, we can't do this as a tail call 17919 * because rIBASE is caller save and we need to reload it. 17920 * 17921 * Note that unlike in the Arm implementation, we should never arrive 17922 * here with a zero breakFlag because we always refresh rIBASE on 17923 * return. 17924 */ 17925 EXPORT_PC 17926 movl rSELF, %eax 17927 movl rPC, OUT_ARG0(%esp) 17928 cmpb $0,offThread_breakFlags(%eax) # anything to do? 17929 movl rFP, OUT_ARG1(%esp) 17930 je 1f # reload rIBASE & resume if not 17931 movl %eax, OUT_ARG2(%esp) 17932 call dvmCheckBefore # (dPC, dFP, self) 17933 movl rSELF, %eax 179341: 17935 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 17936 jmp *dvmAsmInstructionStart+(247*4) 17937 17938/* ------------------------------ */ 17939.L_ALT_OP_INVOKE_VIRTUAL_QUICK: /* 0xf8 */ 17940/* File: x86/alt_stub.S */ 17941/* 17942 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 17943 * any interesting requests and then jump to the real instruction 17944 * handler. Unlike the Arm handler, we can't do this as a tail call 17945 * because rIBASE is caller save and we need to reload it. 17946 * 17947 * Note that unlike in the Arm implementation, we should never arrive 17948 * here with a zero breakFlag because we always refresh rIBASE on 17949 * return. 17950 */ 17951 EXPORT_PC 17952 movl rSELF, %eax 17953 movl rPC, OUT_ARG0(%esp) 17954 cmpb $0,offThread_breakFlags(%eax) # anything to do? 17955 movl rFP, OUT_ARG1(%esp) 17956 je 1f # reload rIBASE & resume if not 17957 movl %eax, OUT_ARG2(%esp) 17958 call dvmCheckBefore # (dPC, dFP, self) 17959 movl rSELF, %eax 179601: 17961 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 17962 jmp *dvmAsmInstructionStart+(248*4) 17963 17964/* ------------------------------ */ 17965.L_ALT_OP_INVOKE_VIRTUAL_QUICK_RANGE: /* 0xf9 */ 17966/* File: x86/alt_stub.S */ 17967/* 17968 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 17969 * any interesting requests and then jump to the real instruction 17970 * handler. Unlike the Arm handler, we can't do this as a tail call 17971 * because rIBASE is caller save and we need to reload it. 17972 * 17973 * Note that unlike in the Arm implementation, we should never arrive 17974 * here with a zero breakFlag because we always refresh rIBASE on 17975 * return. 17976 */ 17977 EXPORT_PC 17978 movl rSELF, %eax 17979 movl rPC, OUT_ARG0(%esp) 17980 cmpb $0,offThread_breakFlags(%eax) # anything to do? 17981 movl rFP, OUT_ARG1(%esp) 17982 je 1f # reload rIBASE & resume if not 17983 movl %eax, OUT_ARG2(%esp) 17984 call dvmCheckBefore # (dPC, dFP, self) 17985 movl rSELF, %eax 179861: 17987 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 17988 jmp *dvmAsmInstructionStart+(249*4) 17989 17990/* ------------------------------ */ 17991.L_ALT_OP_INVOKE_SUPER_QUICK: /* 0xfa */ 17992/* File: x86/alt_stub.S */ 17993/* 17994 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 17995 * any interesting requests and then jump to the real instruction 17996 * handler. Unlike the Arm handler, we can't do this as a tail call 17997 * because rIBASE is caller save and we need to reload it. 17998 * 17999 * Note that unlike in the Arm implementation, we should never arrive 18000 * here with a zero breakFlag because we always refresh rIBASE on 18001 * return. 18002 */ 18003 EXPORT_PC 18004 movl rSELF, %eax 18005 movl rPC, OUT_ARG0(%esp) 18006 cmpb $0,offThread_breakFlags(%eax) # anything to do? 18007 movl rFP, OUT_ARG1(%esp) 18008 je 1f # reload rIBASE & resume if not 18009 movl %eax, OUT_ARG2(%esp) 18010 call dvmCheckBefore # (dPC, dFP, self) 18011 movl rSELF, %eax 180121: 18013 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 18014 jmp *dvmAsmInstructionStart+(250*4) 18015 18016/* ------------------------------ */ 18017.L_ALT_OP_INVOKE_SUPER_QUICK_RANGE: /* 0xfb */ 18018/* File: x86/alt_stub.S */ 18019/* 18020 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 18021 * any interesting requests and then jump to the real instruction 18022 * handler. Unlike the Arm handler, we can't do this as a tail call 18023 * because rIBASE is caller save and we need to reload it. 18024 * 18025 * Note that unlike in the Arm implementation, we should never arrive 18026 * here with a zero breakFlag because we always refresh rIBASE on 18027 * return. 18028 */ 18029 EXPORT_PC 18030 movl rSELF, %eax 18031 movl rPC, OUT_ARG0(%esp) 18032 cmpb $0,offThread_breakFlags(%eax) # anything to do? 18033 movl rFP, OUT_ARG1(%esp) 18034 je 1f # reload rIBASE & resume if not 18035 movl %eax, OUT_ARG2(%esp) 18036 call dvmCheckBefore # (dPC, dFP, self) 18037 movl rSELF, %eax 180381: 18039 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 18040 jmp *dvmAsmInstructionStart+(251*4) 18041 18042/* ------------------------------ */ 18043.L_ALT_OP_IPUT_OBJECT_VOLATILE: /* 0xfc */ 18044/* File: x86/alt_stub.S */ 18045/* 18046 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 18047 * any interesting requests and then jump to the real instruction 18048 * handler. Unlike the Arm handler, we can't do this as a tail call 18049 * because rIBASE is caller save and we need to reload it. 18050 * 18051 * Note that unlike in the Arm implementation, we should never arrive 18052 * here with a zero breakFlag because we always refresh rIBASE on 18053 * return. 18054 */ 18055 EXPORT_PC 18056 movl rSELF, %eax 18057 movl rPC, OUT_ARG0(%esp) 18058 cmpb $0,offThread_breakFlags(%eax) # anything to do? 18059 movl rFP, OUT_ARG1(%esp) 18060 je 1f # reload rIBASE & resume if not 18061 movl %eax, OUT_ARG2(%esp) 18062 call dvmCheckBefore # (dPC, dFP, self) 18063 movl rSELF, %eax 180641: 18065 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 18066 jmp *dvmAsmInstructionStart+(252*4) 18067 18068/* ------------------------------ */ 18069.L_ALT_OP_SGET_OBJECT_VOLATILE: /* 0xfd */ 18070/* File: x86/alt_stub.S */ 18071/* 18072 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 18073 * any interesting requests and then jump to the real instruction 18074 * handler. Unlike the Arm handler, we can't do this as a tail call 18075 * because rIBASE is caller save and we need to reload it. 18076 * 18077 * Note that unlike in the Arm implementation, we should never arrive 18078 * here with a zero breakFlag because we always refresh rIBASE on 18079 * return. 18080 */ 18081 EXPORT_PC 18082 movl rSELF, %eax 18083 movl rPC, OUT_ARG0(%esp) 18084 cmpb $0,offThread_breakFlags(%eax) # anything to do? 18085 movl rFP, OUT_ARG1(%esp) 18086 je 1f # reload rIBASE & resume if not 18087 movl %eax, OUT_ARG2(%esp) 18088 call dvmCheckBefore # (dPC, dFP, self) 18089 movl rSELF, %eax 180901: 18091 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 18092 jmp *dvmAsmInstructionStart+(253*4) 18093 18094/* ------------------------------ */ 18095.L_ALT_OP_SPUT_OBJECT_VOLATILE: /* 0xfe */ 18096/* File: x86/alt_stub.S */ 18097/* 18098 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 18099 * any interesting requests and then jump to the real instruction 18100 * handler. Unlike the Arm handler, we can't do this as a tail call 18101 * because rIBASE is caller save and we need to reload it. 18102 * 18103 * Note that unlike in the Arm implementation, we should never arrive 18104 * here with a zero breakFlag because we always refresh rIBASE on 18105 * return. 18106 */ 18107 EXPORT_PC 18108 movl rSELF, %eax 18109 movl rPC, OUT_ARG0(%esp) 18110 cmpb $0,offThread_breakFlags(%eax) # anything to do? 18111 movl rFP, OUT_ARG1(%esp) 18112 je 1f # reload rIBASE & resume if not 18113 movl %eax, OUT_ARG2(%esp) 18114 call dvmCheckBefore # (dPC, dFP, self) 18115 movl rSELF, %eax 181161: 18117 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 18118 jmp *dvmAsmInstructionStart+(254*4) 18119 18120/* ------------------------------ */ 18121.L_ALT_OP_DISPATCH_FF: /* 0xff */ 18122/* File: x86/alt_stub.S */ 18123/* 18124 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 18125 * any interesting requests and then jump to the real instruction 18126 * handler. Unlike the Arm handler, we can't do this as a tail call 18127 * because rIBASE is caller save and we need to reload it. 18128 * 18129 * Note that unlike in the Arm implementation, we should never arrive 18130 * here with a zero breakFlag because we always refresh rIBASE on 18131 * return. 18132 */ 18133 EXPORT_PC 18134 movl rSELF, %eax 18135 movl rPC, OUT_ARG0(%esp) 18136 cmpb $0,offThread_breakFlags(%eax) # anything to do? 18137 movl rFP, OUT_ARG1(%esp) 18138 je 1f # reload rIBASE & resume if not 18139 movl %eax, OUT_ARG2(%esp) 18140 call dvmCheckBefore # (dPC, dFP, self) 18141 movl rSELF, %eax 181421: 18143 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 18144 jmp *dvmAsmInstructionStart+(255*4) 18145 18146/* ------------------------------ */ 18147.L_ALT_OP_CONST_CLASS_JUMBO: /* 0x100 */ 18148/* File: x86/alt_stub.S */ 18149/* 18150 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 18151 * any interesting requests and then jump to the real instruction 18152 * handler. Unlike the Arm handler, we can't do this as a tail call 18153 * because rIBASE is caller save and we need to reload it. 18154 * 18155 * Note that unlike in the Arm implementation, we should never arrive 18156 * here with a zero breakFlag because we always refresh rIBASE on 18157 * return. 18158 */ 18159 EXPORT_PC 18160 movl rSELF, %eax 18161 movl rPC, OUT_ARG0(%esp) 18162 cmpb $0,offThread_breakFlags(%eax) # anything to do? 18163 movl rFP, OUT_ARG1(%esp) 18164 je 1f # reload rIBASE & resume if not 18165 movl %eax, OUT_ARG2(%esp) 18166 call dvmCheckBefore # (dPC, dFP, self) 18167 movl rSELF, %eax 181681: 18169 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 18170 jmp *dvmAsmInstructionStart+(256*4) 18171 18172/* ------------------------------ */ 18173.L_ALT_OP_CHECK_CAST_JUMBO: /* 0x101 */ 18174/* File: x86/alt_stub.S */ 18175/* 18176 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 18177 * any interesting requests and then jump to the real instruction 18178 * handler. Unlike the Arm handler, we can't do this as a tail call 18179 * because rIBASE is caller save and we need to reload it. 18180 * 18181 * Note that unlike in the Arm implementation, we should never arrive 18182 * here with a zero breakFlag because we always refresh rIBASE on 18183 * return. 18184 */ 18185 EXPORT_PC 18186 movl rSELF, %eax 18187 movl rPC, OUT_ARG0(%esp) 18188 cmpb $0,offThread_breakFlags(%eax) # anything to do? 18189 movl rFP, OUT_ARG1(%esp) 18190 je 1f # reload rIBASE & resume if not 18191 movl %eax, OUT_ARG2(%esp) 18192 call dvmCheckBefore # (dPC, dFP, self) 18193 movl rSELF, %eax 181941: 18195 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 18196 jmp *dvmAsmInstructionStart+(257*4) 18197 18198/* ------------------------------ */ 18199.L_ALT_OP_INSTANCE_OF_JUMBO: /* 0x102 */ 18200/* File: x86/alt_stub.S */ 18201/* 18202 * Inter-instruction transfer stub. Call out to dvmCheckBefore 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 * Note that unlike in the Arm implementation, we should never arrive 18208 * here with a zero breakFlag because we always refresh rIBASE on 18209 * return. 18210 */ 18211 EXPORT_PC 18212 movl rSELF, %eax 18213 movl rPC, OUT_ARG0(%esp) 18214 cmpb $0,offThread_breakFlags(%eax) # anything to do? 18215 movl rFP, OUT_ARG1(%esp) 18216 je 1f # reload rIBASE & resume if not 18217 movl %eax, OUT_ARG2(%esp) 18218 call dvmCheckBefore # (dPC, dFP, self) 18219 movl rSELF, %eax 182201: 18221 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 18222 jmp *dvmAsmInstructionStart+(258*4) 18223 18224/* ------------------------------ */ 18225.L_ALT_OP_NEW_INSTANCE_JUMBO: /* 0x103 */ 18226/* File: x86/alt_stub.S */ 18227/* 18228 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 18229 * any interesting requests and then jump to the real instruction 18230 * handler. Unlike the Arm handler, we can't do this as a tail call 18231 * because rIBASE is caller save and we need to reload it. 18232 * 18233 * Note that unlike in the Arm implementation, we should never arrive 18234 * here with a zero breakFlag because we always refresh rIBASE on 18235 * return. 18236 */ 18237 EXPORT_PC 18238 movl rSELF, %eax 18239 movl rPC, OUT_ARG0(%esp) 18240 cmpb $0,offThread_breakFlags(%eax) # anything to do? 18241 movl rFP, OUT_ARG1(%esp) 18242 je 1f # reload rIBASE & resume if not 18243 movl %eax, OUT_ARG2(%esp) 18244 call dvmCheckBefore # (dPC, dFP, self) 18245 movl rSELF, %eax 182461: 18247 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 18248 jmp *dvmAsmInstructionStart+(259*4) 18249 18250/* ------------------------------ */ 18251.L_ALT_OP_NEW_ARRAY_JUMBO: /* 0x104 */ 18252/* File: x86/alt_stub.S */ 18253/* 18254 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 18255 * any interesting requests and then jump to the real instruction 18256 * handler. Unlike the Arm handler, we can't do this as a tail call 18257 * because rIBASE is caller save and we need to reload it. 18258 * 18259 * Note that unlike in the Arm implementation, we should never arrive 18260 * here with a zero breakFlag because we always refresh rIBASE on 18261 * return. 18262 */ 18263 EXPORT_PC 18264 movl rSELF, %eax 18265 movl rPC, OUT_ARG0(%esp) 18266 cmpb $0,offThread_breakFlags(%eax) # anything to do? 18267 movl rFP, OUT_ARG1(%esp) 18268 je 1f # reload rIBASE & resume if not 18269 movl %eax, OUT_ARG2(%esp) 18270 call dvmCheckBefore # (dPC, dFP, self) 18271 movl rSELF, %eax 182721: 18273 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 18274 jmp *dvmAsmInstructionStart+(260*4) 18275 18276/* ------------------------------ */ 18277.L_ALT_OP_FILLED_NEW_ARRAY_JUMBO: /* 0x105 */ 18278/* File: x86/alt_stub.S */ 18279/* 18280 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 18281 * any interesting requests and then jump to the real instruction 18282 * handler. Unlike the Arm handler, we can't do this as a tail call 18283 * because rIBASE is caller save and we need to reload it. 18284 * 18285 * Note that unlike in the Arm implementation, we should never arrive 18286 * here with a zero breakFlag because we always refresh rIBASE on 18287 * return. 18288 */ 18289 EXPORT_PC 18290 movl rSELF, %eax 18291 movl rPC, OUT_ARG0(%esp) 18292 cmpb $0,offThread_breakFlags(%eax) # anything to do? 18293 movl rFP, OUT_ARG1(%esp) 18294 je 1f # reload rIBASE & resume if not 18295 movl %eax, OUT_ARG2(%esp) 18296 call dvmCheckBefore # (dPC, dFP, self) 18297 movl rSELF, %eax 182981: 18299 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 18300 jmp *dvmAsmInstructionStart+(261*4) 18301 18302/* ------------------------------ */ 18303.L_ALT_OP_IGET_JUMBO: /* 0x106 */ 18304/* File: x86/alt_stub.S */ 18305/* 18306 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 18307 * any interesting requests and then jump to the real instruction 18308 * handler. Unlike the Arm handler, we can't do this as a tail call 18309 * because rIBASE is caller save and we need to reload it. 18310 * 18311 * Note that unlike in the Arm implementation, we should never arrive 18312 * here with a zero breakFlag because we always refresh rIBASE on 18313 * return. 18314 */ 18315 EXPORT_PC 18316 movl rSELF, %eax 18317 movl rPC, OUT_ARG0(%esp) 18318 cmpb $0,offThread_breakFlags(%eax) # anything to do? 18319 movl rFP, OUT_ARG1(%esp) 18320 je 1f # reload rIBASE & resume if not 18321 movl %eax, OUT_ARG2(%esp) 18322 call dvmCheckBefore # (dPC, dFP, self) 18323 movl rSELF, %eax 183241: 18325 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 18326 jmp *dvmAsmInstructionStart+(262*4) 18327 18328/* ------------------------------ */ 18329.L_ALT_OP_IGET_WIDE_JUMBO: /* 0x107 */ 18330/* File: x86/alt_stub.S */ 18331/* 18332 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 18333 * any interesting requests and then jump to the real instruction 18334 * handler. Unlike the Arm handler, we can't do this as a tail call 18335 * because rIBASE is caller save and we need to reload it. 18336 * 18337 * Note that unlike in the Arm implementation, we should never arrive 18338 * here with a zero breakFlag because we always refresh rIBASE on 18339 * return. 18340 */ 18341 EXPORT_PC 18342 movl rSELF, %eax 18343 movl rPC, OUT_ARG0(%esp) 18344 cmpb $0,offThread_breakFlags(%eax) # anything to do? 18345 movl rFP, OUT_ARG1(%esp) 18346 je 1f # reload rIBASE & resume if not 18347 movl %eax, OUT_ARG2(%esp) 18348 call dvmCheckBefore # (dPC, dFP, self) 18349 movl rSELF, %eax 183501: 18351 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 18352 jmp *dvmAsmInstructionStart+(263*4) 18353 18354/* ------------------------------ */ 18355.L_ALT_OP_IGET_OBJECT_JUMBO: /* 0x108 */ 18356/* File: x86/alt_stub.S */ 18357/* 18358 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 18359 * any interesting requests and then jump to the real instruction 18360 * handler. Unlike the Arm handler, we can't do this as a tail call 18361 * because rIBASE is caller save and we need to reload it. 18362 * 18363 * Note that unlike in the Arm implementation, we should never arrive 18364 * here with a zero breakFlag because we always refresh rIBASE on 18365 * return. 18366 */ 18367 EXPORT_PC 18368 movl rSELF, %eax 18369 movl rPC, OUT_ARG0(%esp) 18370 cmpb $0,offThread_breakFlags(%eax) # anything to do? 18371 movl rFP, OUT_ARG1(%esp) 18372 je 1f # reload rIBASE & resume if not 18373 movl %eax, OUT_ARG2(%esp) 18374 call dvmCheckBefore # (dPC, dFP, self) 18375 movl rSELF, %eax 183761: 18377 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 18378 jmp *dvmAsmInstructionStart+(264*4) 18379 18380/* ------------------------------ */ 18381.L_ALT_OP_IGET_BOOLEAN_JUMBO: /* 0x109 */ 18382/* File: x86/alt_stub.S */ 18383/* 18384 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 18385 * any interesting requests and then jump to the real instruction 18386 * handler. Unlike the Arm handler, we can't do this as a tail call 18387 * because rIBASE is caller save and we need to reload it. 18388 * 18389 * Note that unlike in the Arm implementation, we should never arrive 18390 * here with a zero breakFlag because we always refresh rIBASE on 18391 * return. 18392 */ 18393 EXPORT_PC 18394 movl rSELF, %eax 18395 movl rPC, OUT_ARG0(%esp) 18396 cmpb $0,offThread_breakFlags(%eax) # anything to do? 18397 movl rFP, OUT_ARG1(%esp) 18398 je 1f # reload rIBASE & resume if not 18399 movl %eax, OUT_ARG2(%esp) 18400 call dvmCheckBefore # (dPC, dFP, self) 18401 movl rSELF, %eax 184021: 18403 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 18404 jmp *dvmAsmInstructionStart+(265*4) 18405 18406/* ------------------------------ */ 18407.L_ALT_OP_IGET_BYTE_JUMBO: /* 0x10a */ 18408/* File: x86/alt_stub.S */ 18409/* 18410 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 18411 * any interesting requests and then jump to the real instruction 18412 * handler. Unlike the Arm handler, we can't do this as a tail call 18413 * because rIBASE is caller save and we need to reload it. 18414 * 18415 * Note that unlike in the Arm implementation, we should never arrive 18416 * here with a zero breakFlag because we always refresh rIBASE on 18417 * return. 18418 */ 18419 EXPORT_PC 18420 movl rSELF, %eax 18421 movl rPC, OUT_ARG0(%esp) 18422 cmpb $0,offThread_breakFlags(%eax) # anything to do? 18423 movl rFP, OUT_ARG1(%esp) 18424 je 1f # reload rIBASE & resume if not 18425 movl %eax, OUT_ARG2(%esp) 18426 call dvmCheckBefore # (dPC, dFP, self) 18427 movl rSELF, %eax 184281: 18429 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 18430 jmp *dvmAsmInstructionStart+(266*4) 18431 18432/* ------------------------------ */ 18433.L_ALT_OP_IGET_CHAR_JUMBO: /* 0x10b */ 18434/* File: x86/alt_stub.S */ 18435/* 18436 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 18437 * any interesting requests and then jump to the real instruction 18438 * handler. Unlike the Arm handler, we can't do this as a tail call 18439 * because rIBASE is caller save and we need to reload it. 18440 * 18441 * Note that unlike in the Arm implementation, we should never arrive 18442 * here with a zero breakFlag because we always refresh rIBASE on 18443 * return. 18444 */ 18445 EXPORT_PC 18446 movl rSELF, %eax 18447 movl rPC, OUT_ARG0(%esp) 18448 cmpb $0,offThread_breakFlags(%eax) # anything to do? 18449 movl rFP, OUT_ARG1(%esp) 18450 je 1f # reload rIBASE & resume if not 18451 movl %eax, OUT_ARG2(%esp) 18452 call dvmCheckBefore # (dPC, dFP, self) 18453 movl rSELF, %eax 184541: 18455 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 18456 jmp *dvmAsmInstructionStart+(267*4) 18457 18458/* ------------------------------ */ 18459.L_ALT_OP_IGET_SHORT_JUMBO: /* 0x10c */ 18460/* File: x86/alt_stub.S */ 18461/* 18462 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 18463 * any interesting requests and then jump to the real instruction 18464 * handler. Unlike the Arm handler, we can't do this as a tail call 18465 * because rIBASE is caller save and we need to reload it. 18466 * 18467 * Note that unlike in the Arm implementation, we should never arrive 18468 * here with a zero breakFlag because we always refresh rIBASE on 18469 * return. 18470 */ 18471 EXPORT_PC 18472 movl rSELF, %eax 18473 movl rPC, OUT_ARG0(%esp) 18474 cmpb $0,offThread_breakFlags(%eax) # anything to do? 18475 movl rFP, OUT_ARG1(%esp) 18476 je 1f # reload rIBASE & resume if not 18477 movl %eax, OUT_ARG2(%esp) 18478 call dvmCheckBefore # (dPC, dFP, self) 18479 movl rSELF, %eax 184801: 18481 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 18482 jmp *dvmAsmInstructionStart+(268*4) 18483 18484/* ------------------------------ */ 18485.L_ALT_OP_IPUT_JUMBO: /* 0x10d */ 18486/* File: x86/alt_stub.S */ 18487/* 18488 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 18489 * any interesting requests and then jump to the real instruction 18490 * handler. Unlike the Arm handler, we can't do this as a tail call 18491 * because rIBASE is caller save and we need to reload it. 18492 * 18493 * Note that unlike in the Arm implementation, we should never arrive 18494 * here with a zero breakFlag because we always refresh rIBASE on 18495 * return. 18496 */ 18497 EXPORT_PC 18498 movl rSELF, %eax 18499 movl rPC, OUT_ARG0(%esp) 18500 cmpb $0,offThread_breakFlags(%eax) # anything to do? 18501 movl rFP, OUT_ARG1(%esp) 18502 je 1f # reload rIBASE & resume if not 18503 movl %eax, OUT_ARG2(%esp) 18504 call dvmCheckBefore # (dPC, dFP, self) 18505 movl rSELF, %eax 185061: 18507 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 18508 jmp *dvmAsmInstructionStart+(269*4) 18509 18510/* ------------------------------ */ 18511.L_ALT_OP_IPUT_WIDE_JUMBO: /* 0x10e */ 18512/* File: x86/alt_stub.S */ 18513/* 18514 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 18515 * any interesting requests and then jump to the real instruction 18516 * handler. Unlike the Arm handler, we can't do this as a tail call 18517 * because rIBASE is caller save and we need to reload it. 18518 * 18519 * Note that unlike in the Arm implementation, we should never arrive 18520 * here with a zero breakFlag because we always refresh rIBASE on 18521 * return. 18522 */ 18523 EXPORT_PC 18524 movl rSELF, %eax 18525 movl rPC, OUT_ARG0(%esp) 18526 cmpb $0,offThread_breakFlags(%eax) # anything to do? 18527 movl rFP, OUT_ARG1(%esp) 18528 je 1f # reload rIBASE & resume if not 18529 movl %eax, OUT_ARG2(%esp) 18530 call dvmCheckBefore # (dPC, dFP, self) 18531 movl rSELF, %eax 185321: 18533 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 18534 jmp *dvmAsmInstructionStart+(270*4) 18535 18536/* ------------------------------ */ 18537.L_ALT_OP_IPUT_OBJECT_JUMBO: /* 0x10f */ 18538/* File: x86/alt_stub.S */ 18539/* 18540 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 18541 * any interesting requests and then jump to the real instruction 18542 * handler. Unlike the Arm handler, we can't do this as a tail call 18543 * because rIBASE is caller save and we need to reload it. 18544 * 18545 * Note that unlike in the Arm implementation, we should never arrive 18546 * here with a zero breakFlag because we always refresh rIBASE on 18547 * return. 18548 */ 18549 EXPORT_PC 18550 movl rSELF, %eax 18551 movl rPC, OUT_ARG0(%esp) 18552 cmpb $0,offThread_breakFlags(%eax) # anything to do? 18553 movl rFP, OUT_ARG1(%esp) 18554 je 1f # reload rIBASE & resume if not 18555 movl %eax, OUT_ARG2(%esp) 18556 call dvmCheckBefore # (dPC, dFP, self) 18557 movl rSELF, %eax 185581: 18559 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 18560 jmp *dvmAsmInstructionStart+(271*4) 18561 18562/* ------------------------------ */ 18563.L_ALT_OP_IPUT_BOOLEAN_JUMBO: /* 0x110 */ 18564/* File: x86/alt_stub.S */ 18565/* 18566 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 18567 * any interesting requests and then jump to the real instruction 18568 * handler. Unlike the Arm handler, we can't do this as a tail call 18569 * because rIBASE is caller save and we need to reload it. 18570 * 18571 * Note that unlike in the Arm implementation, we should never arrive 18572 * here with a zero breakFlag because we always refresh rIBASE on 18573 * return. 18574 */ 18575 EXPORT_PC 18576 movl rSELF, %eax 18577 movl rPC, OUT_ARG0(%esp) 18578 cmpb $0,offThread_breakFlags(%eax) # anything to do? 18579 movl rFP, OUT_ARG1(%esp) 18580 je 1f # reload rIBASE & resume if not 18581 movl %eax, OUT_ARG2(%esp) 18582 call dvmCheckBefore # (dPC, dFP, self) 18583 movl rSELF, %eax 185841: 18585 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 18586 jmp *dvmAsmInstructionStart+(272*4) 18587 18588/* ------------------------------ */ 18589.L_ALT_OP_IPUT_BYTE_JUMBO: /* 0x111 */ 18590/* File: x86/alt_stub.S */ 18591/* 18592 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 18593 * any interesting requests and then jump to the real instruction 18594 * handler. Unlike the Arm handler, we can't do this as a tail call 18595 * because rIBASE is caller save and we need to reload it. 18596 * 18597 * Note that unlike in the Arm implementation, we should never arrive 18598 * here with a zero breakFlag because we always refresh rIBASE on 18599 * return. 18600 */ 18601 EXPORT_PC 18602 movl rSELF, %eax 18603 movl rPC, OUT_ARG0(%esp) 18604 cmpb $0,offThread_breakFlags(%eax) # anything to do? 18605 movl rFP, OUT_ARG1(%esp) 18606 je 1f # reload rIBASE & resume if not 18607 movl %eax, OUT_ARG2(%esp) 18608 call dvmCheckBefore # (dPC, dFP, self) 18609 movl rSELF, %eax 186101: 18611 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 18612 jmp *dvmAsmInstructionStart+(273*4) 18613 18614/* ------------------------------ */ 18615.L_ALT_OP_IPUT_CHAR_JUMBO: /* 0x112 */ 18616/* File: x86/alt_stub.S */ 18617/* 18618 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 18619 * any interesting requests and then jump to the real instruction 18620 * handler. Unlike the Arm handler, we can't do this as a tail call 18621 * because rIBASE is caller save and we need to reload it. 18622 * 18623 * Note that unlike in the Arm implementation, we should never arrive 18624 * here with a zero breakFlag because we always refresh rIBASE on 18625 * return. 18626 */ 18627 EXPORT_PC 18628 movl rSELF, %eax 18629 movl rPC, OUT_ARG0(%esp) 18630 cmpb $0,offThread_breakFlags(%eax) # anything to do? 18631 movl rFP, OUT_ARG1(%esp) 18632 je 1f # reload rIBASE & resume if not 18633 movl %eax, OUT_ARG2(%esp) 18634 call dvmCheckBefore # (dPC, dFP, self) 18635 movl rSELF, %eax 186361: 18637 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 18638 jmp *dvmAsmInstructionStart+(274*4) 18639 18640/* ------------------------------ */ 18641.L_ALT_OP_IPUT_SHORT_JUMBO: /* 0x113 */ 18642/* File: x86/alt_stub.S */ 18643/* 18644 * Inter-instruction transfer stub. Call out to dvmCheckBefore 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 * Note that unlike in the Arm implementation, we should never arrive 18650 * here with a zero breakFlag because we always refresh rIBASE on 18651 * return. 18652 */ 18653 EXPORT_PC 18654 movl rSELF, %eax 18655 movl rPC, OUT_ARG0(%esp) 18656 cmpb $0,offThread_breakFlags(%eax) # anything to do? 18657 movl rFP, OUT_ARG1(%esp) 18658 je 1f # reload rIBASE & resume if not 18659 movl %eax, OUT_ARG2(%esp) 18660 call dvmCheckBefore # (dPC, dFP, self) 18661 movl rSELF, %eax 186621: 18663 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 18664 jmp *dvmAsmInstructionStart+(275*4) 18665 18666/* ------------------------------ */ 18667.L_ALT_OP_SGET_JUMBO: /* 0x114 */ 18668/* File: x86/alt_stub.S */ 18669/* 18670 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 18671 * any interesting requests and then jump to the real instruction 18672 * handler. Unlike the Arm handler, we can't do this as a tail call 18673 * because rIBASE is caller save and we need to reload it. 18674 * 18675 * Note that unlike in the Arm implementation, we should never arrive 18676 * here with a zero breakFlag because we always refresh rIBASE on 18677 * return. 18678 */ 18679 EXPORT_PC 18680 movl rSELF, %eax 18681 movl rPC, OUT_ARG0(%esp) 18682 cmpb $0,offThread_breakFlags(%eax) # anything to do? 18683 movl rFP, OUT_ARG1(%esp) 18684 je 1f # reload rIBASE & resume if not 18685 movl %eax, OUT_ARG2(%esp) 18686 call dvmCheckBefore # (dPC, dFP, self) 18687 movl rSELF, %eax 186881: 18689 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 18690 jmp *dvmAsmInstructionStart+(276*4) 18691 18692/* ------------------------------ */ 18693.L_ALT_OP_SGET_WIDE_JUMBO: /* 0x115 */ 18694/* File: x86/alt_stub.S */ 18695/* 18696 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 18697 * any interesting requests and then jump to the real instruction 18698 * handler. Unlike the Arm handler, we can't do this as a tail call 18699 * because rIBASE is caller save and we need to reload it. 18700 * 18701 * Note that unlike in the Arm implementation, we should never arrive 18702 * here with a zero breakFlag because we always refresh rIBASE on 18703 * return. 18704 */ 18705 EXPORT_PC 18706 movl rSELF, %eax 18707 movl rPC, OUT_ARG0(%esp) 18708 cmpb $0,offThread_breakFlags(%eax) # anything to do? 18709 movl rFP, OUT_ARG1(%esp) 18710 je 1f # reload rIBASE & resume if not 18711 movl %eax, OUT_ARG2(%esp) 18712 call dvmCheckBefore # (dPC, dFP, self) 18713 movl rSELF, %eax 187141: 18715 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 18716 jmp *dvmAsmInstructionStart+(277*4) 18717 18718/* ------------------------------ */ 18719.L_ALT_OP_SGET_OBJECT_JUMBO: /* 0x116 */ 18720/* File: x86/alt_stub.S */ 18721/* 18722 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 18723 * any interesting requests and then jump to the real instruction 18724 * handler. Unlike the Arm handler, we can't do this as a tail call 18725 * because rIBASE is caller save and we need to reload it. 18726 * 18727 * Note that unlike in the Arm implementation, we should never arrive 18728 * here with a zero breakFlag because we always refresh rIBASE on 18729 * return. 18730 */ 18731 EXPORT_PC 18732 movl rSELF, %eax 18733 movl rPC, OUT_ARG0(%esp) 18734 cmpb $0,offThread_breakFlags(%eax) # anything to do? 18735 movl rFP, OUT_ARG1(%esp) 18736 je 1f # reload rIBASE & resume if not 18737 movl %eax, OUT_ARG2(%esp) 18738 call dvmCheckBefore # (dPC, dFP, self) 18739 movl rSELF, %eax 187401: 18741 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 18742 jmp *dvmAsmInstructionStart+(278*4) 18743 18744/* ------------------------------ */ 18745.L_ALT_OP_SGET_BOOLEAN_JUMBO: /* 0x117 */ 18746/* File: x86/alt_stub.S */ 18747/* 18748 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 18749 * any interesting requests and then jump to the real instruction 18750 * handler. Unlike the Arm handler, we can't do this as a tail call 18751 * because rIBASE is caller save and we need to reload it. 18752 * 18753 * Note that unlike in the Arm implementation, we should never arrive 18754 * here with a zero breakFlag because we always refresh rIBASE on 18755 * return. 18756 */ 18757 EXPORT_PC 18758 movl rSELF, %eax 18759 movl rPC, OUT_ARG0(%esp) 18760 cmpb $0,offThread_breakFlags(%eax) # anything to do? 18761 movl rFP, OUT_ARG1(%esp) 18762 je 1f # reload rIBASE & resume if not 18763 movl %eax, OUT_ARG2(%esp) 18764 call dvmCheckBefore # (dPC, dFP, self) 18765 movl rSELF, %eax 187661: 18767 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 18768 jmp *dvmAsmInstructionStart+(279*4) 18769 18770/* ------------------------------ */ 18771.L_ALT_OP_SGET_BYTE_JUMBO: /* 0x118 */ 18772/* File: x86/alt_stub.S */ 18773/* 18774 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 18775 * any interesting requests and then jump to the real instruction 18776 * handler. Unlike the Arm handler, we can't do this as a tail call 18777 * because rIBASE is caller save and we need to reload it. 18778 * 18779 * Note that unlike in the Arm implementation, we should never arrive 18780 * here with a zero breakFlag because we always refresh rIBASE on 18781 * return. 18782 */ 18783 EXPORT_PC 18784 movl rSELF, %eax 18785 movl rPC, OUT_ARG0(%esp) 18786 cmpb $0,offThread_breakFlags(%eax) # anything to do? 18787 movl rFP, OUT_ARG1(%esp) 18788 je 1f # reload rIBASE & resume if not 18789 movl %eax, OUT_ARG2(%esp) 18790 call dvmCheckBefore # (dPC, dFP, self) 18791 movl rSELF, %eax 187921: 18793 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 18794 jmp *dvmAsmInstructionStart+(280*4) 18795 18796/* ------------------------------ */ 18797.L_ALT_OP_SGET_CHAR_JUMBO: /* 0x119 */ 18798/* File: x86/alt_stub.S */ 18799/* 18800 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 18801 * any interesting requests and then jump to the real instruction 18802 * handler. Unlike the Arm handler, we can't do this as a tail call 18803 * because rIBASE is caller save and we need to reload it. 18804 * 18805 * Note that unlike in the Arm implementation, we should never arrive 18806 * here with a zero breakFlag because we always refresh rIBASE on 18807 * return. 18808 */ 18809 EXPORT_PC 18810 movl rSELF, %eax 18811 movl rPC, OUT_ARG0(%esp) 18812 cmpb $0,offThread_breakFlags(%eax) # anything to do? 18813 movl rFP, OUT_ARG1(%esp) 18814 je 1f # reload rIBASE & resume if not 18815 movl %eax, OUT_ARG2(%esp) 18816 call dvmCheckBefore # (dPC, dFP, self) 18817 movl rSELF, %eax 188181: 18819 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 18820 jmp *dvmAsmInstructionStart+(281*4) 18821 18822/* ------------------------------ */ 18823.L_ALT_OP_SGET_SHORT_JUMBO: /* 0x11a */ 18824/* File: x86/alt_stub.S */ 18825/* 18826 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 18827 * any interesting requests and then jump to the real instruction 18828 * handler. Unlike the Arm handler, we can't do this as a tail call 18829 * because rIBASE is caller save and we need to reload it. 18830 * 18831 * Note that unlike in the Arm implementation, we should never arrive 18832 * here with a zero breakFlag because we always refresh rIBASE on 18833 * return. 18834 */ 18835 EXPORT_PC 18836 movl rSELF, %eax 18837 movl rPC, OUT_ARG0(%esp) 18838 cmpb $0,offThread_breakFlags(%eax) # anything to do? 18839 movl rFP, OUT_ARG1(%esp) 18840 je 1f # reload rIBASE & resume if not 18841 movl %eax, OUT_ARG2(%esp) 18842 call dvmCheckBefore # (dPC, dFP, self) 18843 movl rSELF, %eax 188441: 18845 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 18846 jmp *dvmAsmInstructionStart+(282*4) 18847 18848/* ------------------------------ */ 18849.L_ALT_OP_SPUT_JUMBO: /* 0x11b */ 18850/* File: x86/alt_stub.S */ 18851/* 18852 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 18853 * any interesting requests and then jump to the real instruction 18854 * handler. Unlike the Arm handler, we can't do this as a tail call 18855 * because rIBASE is caller save and we need to reload it. 18856 * 18857 * Note that unlike in the Arm implementation, we should never arrive 18858 * here with a zero breakFlag because we always refresh rIBASE on 18859 * return. 18860 */ 18861 EXPORT_PC 18862 movl rSELF, %eax 18863 movl rPC, OUT_ARG0(%esp) 18864 cmpb $0,offThread_breakFlags(%eax) # anything to do? 18865 movl rFP, OUT_ARG1(%esp) 18866 je 1f # reload rIBASE & resume if not 18867 movl %eax, OUT_ARG2(%esp) 18868 call dvmCheckBefore # (dPC, dFP, self) 18869 movl rSELF, %eax 188701: 18871 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 18872 jmp *dvmAsmInstructionStart+(283*4) 18873 18874/* ------------------------------ */ 18875.L_ALT_OP_SPUT_WIDE_JUMBO: /* 0x11c */ 18876/* File: x86/alt_stub.S */ 18877/* 18878 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 18879 * any interesting requests and then jump to the real instruction 18880 * handler. Unlike the Arm handler, we can't do this as a tail call 18881 * because rIBASE is caller save and we need to reload it. 18882 * 18883 * Note that unlike in the Arm implementation, we should never arrive 18884 * here with a zero breakFlag because we always refresh rIBASE on 18885 * return. 18886 */ 18887 EXPORT_PC 18888 movl rSELF, %eax 18889 movl rPC, OUT_ARG0(%esp) 18890 cmpb $0,offThread_breakFlags(%eax) # anything to do? 18891 movl rFP, OUT_ARG1(%esp) 18892 je 1f # reload rIBASE & resume if not 18893 movl %eax, OUT_ARG2(%esp) 18894 call dvmCheckBefore # (dPC, dFP, self) 18895 movl rSELF, %eax 188961: 18897 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 18898 jmp *dvmAsmInstructionStart+(284*4) 18899 18900/* ------------------------------ */ 18901.L_ALT_OP_SPUT_OBJECT_JUMBO: /* 0x11d */ 18902/* File: x86/alt_stub.S */ 18903/* 18904 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 18905 * any interesting requests and then jump to the real instruction 18906 * handler. Unlike the Arm handler, we can't do this as a tail call 18907 * because rIBASE is caller save and we need to reload it. 18908 * 18909 * Note that unlike in the Arm implementation, we should never arrive 18910 * here with a zero breakFlag because we always refresh rIBASE on 18911 * return. 18912 */ 18913 EXPORT_PC 18914 movl rSELF, %eax 18915 movl rPC, OUT_ARG0(%esp) 18916 cmpb $0,offThread_breakFlags(%eax) # anything to do? 18917 movl rFP, OUT_ARG1(%esp) 18918 je 1f # reload rIBASE & resume if not 18919 movl %eax, OUT_ARG2(%esp) 18920 call dvmCheckBefore # (dPC, dFP, self) 18921 movl rSELF, %eax 189221: 18923 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 18924 jmp *dvmAsmInstructionStart+(285*4) 18925 18926/* ------------------------------ */ 18927.L_ALT_OP_SPUT_BOOLEAN_JUMBO: /* 0x11e */ 18928/* File: x86/alt_stub.S */ 18929/* 18930 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 18931 * any interesting requests and then jump to the real instruction 18932 * handler. Unlike the Arm handler, we can't do this as a tail call 18933 * because rIBASE is caller save and we need to reload it. 18934 * 18935 * Note that unlike in the Arm implementation, we should never arrive 18936 * here with a zero breakFlag because we always refresh rIBASE on 18937 * return. 18938 */ 18939 EXPORT_PC 18940 movl rSELF, %eax 18941 movl rPC, OUT_ARG0(%esp) 18942 cmpb $0,offThread_breakFlags(%eax) # anything to do? 18943 movl rFP, OUT_ARG1(%esp) 18944 je 1f # reload rIBASE & resume if not 18945 movl %eax, OUT_ARG2(%esp) 18946 call dvmCheckBefore # (dPC, dFP, self) 18947 movl rSELF, %eax 189481: 18949 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 18950 jmp *dvmAsmInstructionStart+(286*4) 18951 18952/* ------------------------------ */ 18953.L_ALT_OP_SPUT_BYTE_JUMBO: /* 0x11f */ 18954/* File: x86/alt_stub.S */ 18955/* 18956 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 18957 * any interesting requests and then jump to the real instruction 18958 * handler. Unlike the Arm handler, we can't do this as a tail call 18959 * because rIBASE is caller save and we need to reload it. 18960 * 18961 * Note that unlike in the Arm implementation, we should never arrive 18962 * here with a zero breakFlag because we always refresh rIBASE on 18963 * return. 18964 */ 18965 EXPORT_PC 18966 movl rSELF, %eax 18967 movl rPC, OUT_ARG0(%esp) 18968 cmpb $0,offThread_breakFlags(%eax) # anything to do? 18969 movl rFP, OUT_ARG1(%esp) 18970 je 1f # reload rIBASE & resume if not 18971 movl %eax, OUT_ARG2(%esp) 18972 call dvmCheckBefore # (dPC, dFP, self) 18973 movl rSELF, %eax 189741: 18975 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 18976 jmp *dvmAsmInstructionStart+(287*4) 18977 18978/* ------------------------------ */ 18979.L_ALT_OP_SPUT_CHAR_JUMBO: /* 0x120 */ 18980/* File: x86/alt_stub.S */ 18981/* 18982 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 18983 * any interesting requests and then jump to the real instruction 18984 * handler. Unlike the Arm handler, we can't do this as a tail call 18985 * because rIBASE is caller save and we need to reload it. 18986 * 18987 * Note that unlike in the Arm implementation, we should never arrive 18988 * here with a zero breakFlag because we always refresh rIBASE on 18989 * return. 18990 */ 18991 EXPORT_PC 18992 movl rSELF, %eax 18993 movl rPC, OUT_ARG0(%esp) 18994 cmpb $0,offThread_breakFlags(%eax) # anything to do? 18995 movl rFP, OUT_ARG1(%esp) 18996 je 1f # reload rIBASE & resume if not 18997 movl %eax, OUT_ARG2(%esp) 18998 call dvmCheckBefore # (dPC, dFP, self) 18999 movl rSELF, %eax 190001: 19001 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 19002 jmp *dvmAsmInstructionStart+(288*4) 19003 19004/* ------------------------------ */ 19005.L_ALT_OP_SPUT_SHORT_JUMBO: /* 0x121 */ 19006/* File: x86/alt_stub.S */ 19007/* 19008 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 19009 * any interesting requests and then jump to the real instruction 19010 * handler. Unlike the Arm handler, we can't do this as a tail call 19011 * because rIBASE is caller save and we need to reload it. 19012 * 19013 * Note that unlike in the Arm implementation, we should never arrive 19014 * here with a zero breakFlag because we always refresh rIBASE on 19015 * return. 19016 */ 19017 EXPORT_PC 19018 movl rSELF, %eax 19019 movl rPC, OUT_ARG0(%esp) 19020 cmpb $0,offThread_breakFlags(%eax) # anything to do? 19021 movl rFP, OUT_ARG1(%esp) 19022 je 1f # reload rIBASE & resume if not 19023 movl %eax, OUT_ARG2(%esp) 19024 call dvmCheckBefore # (dPC, dFP, self) 19025 movl rSELF, %eax 190261: 19027 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 19028 jmp *dvmAsmInstructionStart+(289*4) 19029 19030/* ------------------------------ */ 19031.L_ALT_OP_INVOKE_VIRTUAL_JUMBO: /* 0x122 */ 19032/* File: x86/alt_stub.S */ 19033/* 19034 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 19035 * any interesting requests and then jump to the real instruction 19036 * handler. Unlike the Arm handler, we can't do this as a tail call 19037 * because rIBASE is caller save and we need to reload it. 19038 * 19039 * Note that unlike in the Arm implementation, we should never arrive 19040 * here with a zero breakFlag because we always refresh rIBASE on 19041 * return. 19042 */ 19043 EXPORT_PC 19044 movl rSELF, %eax 19045 movl rPC, OUT_ARG0(%esp) 19046 cmpb $0,offThread_breakFlags(%eax) # anything to do? 19047 movl rFP, OUT_ARG1(%esp) 19048 je 1f # reload rIBASE & resume if not 19049 movl %eax, OUT_ARG2(%esp) 19050 call dvmCheckBefore # (dPC, dFP, self) 19051 movl rSELF, %eax 190521: 19053 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 19054 jmp *dvmAsmInstructionStart+(290*4) 19055 19056/* ------------------------------ */ 19057.L_ALT_OP_INVOKE_SUPER_JUMBO: /* 0x123 */ 19058/* File: x86/alt_stub.S */ 19059/* 19060 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 19061 * any interesting requests and then jump to the real instruction 19062 * handler. Unlike the Arm handler, we can't do this as a tail call 19063 * because rIBASE is caller save and we need to reload it. 19064 * 19065 * Note that unlike in the Arm implementation, we should never arrive 19066 * here with a zero breakFlag because we always refresh rIBASE on 19067 * return. 19068 */ 19069 EXPORT_PC 19070 movl rSELF, %eax 19071 movl rPC, OUT_ARG0(%esp) 19072 cmpb $0,offThread_breakFlags(%eax) # anything to do? 19073 movl rFP, OUT_ARG1(%esp) 19074 je 1f # reload rIBASE & resume if not 19075 movl %eax, OUT_ARG2(%esp) 19076 call dvmCheckBefore # (dPC, dFP, self) 19077 movl rSELF, %eax 190781: 19079 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 19080 jmp *dvmAsmInstructionStart+(291*4) 19081 19082/* ------------------------------ */ 19083.L_ALT_OP_INVOKE_DIRECT_JUMBO: /* 0x124 */ 19084/* File: x86/alt_stub.S */ 19085/* 19086 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 19087 * any interesting requests and then jump to the real instruction 19088 * handler. 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 * Note that unlike in the Arm implementation, we should never arrive 19092 * here with a zero breakFlag because we always refresh rIBASE on 19093 * return. 19094 */ 19095 EXPORT_PC 19096 movl rSELF, %eax 19097 movl rPC, OUT_ARG0(%esp) 19098 cmpb $0,offThread_breakFlags(%eax) # anything to do? 19099 movl rFP, OUT_ARG1(%esp) 19100 je 1f # reload rIBASE & resume if not 19101 movl %eax, OUT_ARG2(%esp) 19102 call dvmCheckBefore # (dPC, dFP, self) 19103 movl rSELF, %eax 191041: 19105 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 19106 jmp *dvmAsmInstructionStart+(292*4) 19107 19108/* ------------------------------ */ 19109.L_ALT_OP_INVOKE_STATIC_JUMBO: /* 0x125 */ 19110/* File: x86/alt_stub.S */ 19111/* 19112 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 19113 * any interesting requests and then jump to the real instruction 19114 * handler. Unlike the Arm handler, we can't do this as a tail call 19115 * because rIBASE is caller save and we need to reload it. 19116 * 19117 * Note that unlike in the Arm implementation, we should never arrive 19118 * here with a zero breakFlag because we always refresh rIBASE on 19119 * return. 19120 */ 19121 EXPORT_PC 19122 movl rSELF, %eax 19123 movl rPC, OUT_ARG0(%esp) 19124 cmpb $0,offThread_breakFlags(%eax) # anything to do? 19125 movl rFP, OUT_ARG1(%esp) 19126 je 1f # reload rIBASE & resume if not 19127 movl %eax, OUT_ARG2(%esp) 19128 call dvmCheckBefore # (dPC, dFP, self) 19129 movl rSELF, %eax 191301: 19131 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 19132 jmp *dvmAsmInstructionStart+(293*4) 19133 19134/* ------------------------------ */ 19135.L_ALT_OP_INVOKE_INTERFACE_JUMBO: /* 0x126 */ 19136/* File: x86/alt_stub.S */ 19137/* 19138 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 19139 * any interesting requests and then jump to the real instruction 19140 * handler. Unlike the Arm handler, we can't do this as a tail call 19141 * because rIBASE is caller save and we need to reload it. 19142 * 19143 * Note that unlike in the Arm implementation, we should never arrive 19144 * here with a zero breakFlag because we always refresh rIBASE on 19145 * return. 19146 */ 19147 EXPORT_PC 19148 movl rSELF, %eax 19149 movl rPC, OUT_ARG0(%esp) 19150 cmpb $0,offThread_breakFlags(%eax) # anything to do? 19151 movl rFP, OUT_ARG1(%esp) 19152 je 1f # reload rIBASE & resume if not 19153 movl %eax, OUT_ARG2(%esp) 19154 call dvmCheckBefore # (dPC, dFP, self) 19155 movl rSELF, %eax 191561: 19157 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 19158 jmp *dvmAsmInstructionStart+(294*4) 19159 19160/* ------------------------------ */ 19161.L_ALT_OP_UNUSED_27FF: /* 0x127 */ 19162/* File: x86/alt_stub.S */ 19163/* 19164 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 19165 * any interesting requests and then jump to the real instruction 19166 * handler. Unlike the Arm handler, we can't do this as a tail call 19167 * because rIBASE is caller save and we need to reload it. 19168 * 19169 * Note that unlike in the Arm implementation, we should never arrive 19170 * here with a zero breakFlag because we always refresh rIBASE on 19171 * return. 19172 */ 19173 EXPORT_PC 19174 movl rSELF, %eax 19175 movl rPC, OUT_ARG0(%esp) 19176 cmpb $0,offThread_breakFlags(%eax) # anything to do? 19177 movl rFP, OUT_ARG1(%esp) 19178 je 1f # reload rIBASE & resume if not 19179 movl %eax, OUT_ARG2(%esp) 19180 call dvmCheckBefore # (dPC, dFP, self) 19181 movl rSELF, %eax 191821: 19183 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 19184 jmp *dvmAsmInstructionStart+(295*4) 19185 19186/* ------------------------------ */ 19187.L_ALT_OP_UNUSED_28FF: /* 0x128 */ 19188/* File: x86/alt_stub.S */ 19189/* 19190 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 19191 * any interesting requests and then jump to the real instruction 19192 * handler. Unlike the Arm handler, we can't do this as a tail call 19193 * because rIBASE is caller save and we need to reload it. 19194 * 19195 * Note that unlike in the Arm implementation, we should never arrive 19196 * here with a zero breakFlag because we always refresh rIBASE on 19197 * return. 19198 */ 19199 EXPORT_PC 19200 movl rSELF, %eax 19201 movl rPC, OUT_ARG0(%esp) 19202 cmpb $0,offThread_breakFlags(%eax) # anything to do? 19203 movl rFP, OUT_ARG1(%esp) 19204 je 1f # reload rIBASE & resume if not 19205 movl %eax, OUT_ARG2(%esp) 19206 call dvmCheckBefore # (dPC, dFP, self) 19207 movl rSELF, %eax 192081: 19209 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 19210 jmp *dvmAsmInstructionStart+(296*4) 19211 19212/* ------------------------------ */ 19213.L_ALT_OP_UNUSED_29FF: /* 0x129 */ 19214/* File: x86/alt_stub.S */ 19215/* 19216 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 19217 * any interesting requests and then jump to the real instruction 19218 * handler. Unlike the Arm handler, we can't do this as a tail call 19219 * because rIBASE is caller save and we need to reload it. 19220 * 19221 * Note that unlike in the Arm implementation, we should never arrive 19222 * here with a zero breakFlag because we always refresh rIBASE on 19223 * return. 19224 */ 19225 EXPORT_PC 19226 movl rSELF, %eax 19227 movl rPC, OUT_ARG0(%esp) 19228 cmpb $0,offThread_breakFlags(%eax) # anything to do? 19229 movl rFP, OUT_ARG1(%esp) 19230 je 1f # reload rIBASE & resume if not 19231 movl %eax, OUT_ARG2(%esp) 19232 call dvmCheckBefore # (dPC, dFP, self) 19233 movl rSELF, %eax 192341: 19235 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 19236 jmp *dvmAsmInstructionStart+(297*4) 19237 19238/* ------------------------------ */ 19239.L_ALT_OP_UNUSED_2AFF: /* 0x12a */ 19240/* File: x86/alt_stub.S */ 19241/* 19242 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 19243 * any interesting requests and then jump to the real instruction 19244 * handler. Unlike the Arm handler, we can't do this as a tail call 19245 * because rIBASE is caller save and we need to reload it. 19246 * 19247 * Note that unlike in the Arm implementation, we should never arrive 19248 * here with a zero breakFlag because we always refresh rIBASE on 19249 * return. 19250 */ 19251 EXPORT_PC 19252 movl rSELF, %eax 19253 movl rPC, OUT_ARG0(%esp) 19254 cmpb $0,offThread_breakFlags(%eax) # anything to do? 19255 movl rFP, OUT_ARG1(%esp) 19256 je 1f # reload rIBASE & resume if not 19257 movl %eax, OUT_ARG2(%esp) 19258 call dvmCheckBefore # (dPC, dFP, self) 19259 movl rSELF, %eax 192601: 19261 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 19262 jmp *dvmAsmInstructionStart+(298*4) 19263 19264/* ------------------------------ */ 19265.L_ALT_OP_UNUSED_2BFF: /* 0x12b */ 19266/* File: x86/alt_stub.S */ 19267/* 19268 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 19269 * any interesting requests and then jump to the real instruction 19270 * handler. Unlike the Arm handler, we can't do this as a tail call 19271 * because rIBASE is caller save and we need to reload it. 19272 * 19273 * Note that unlike in the Arm implementation, we should never arrive 19274 * here with a zero breakFlag because we always refresh rIBASE on 19275 * return. 19276 */ 19277 EXPORT_PC 19278 movl rSELF, %eax 19279 movl rPC, OUT_ARG0(%esp) 19280 cmpb $0,offThread_breakFlags(%eax) # anything to do? 19281 movl rFP, OUT_ARG1(%esp) 19282 je 1f # reload rIBASE & resume if not 19283 movl %eax, OUT_ARG2(%esp) 19284 call dvmCheckBefore # (dPC, dFP, self) 19285 movl rSELF, %eax 192861: 19287 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 19288 jmp *dvmAsmInstructionStart+(299*4) 19289 19290/* ------------------------------ */ 19291.L_ALT_OP_UNUSED_2CFF: /* 0x12c */ 19292/* File: x86/alt_stub.S */ 19293/* 19294 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 19295 * any interesting requests and then jump to the real instruction 19296 * handler. Unlike the Arm handler, we can't do this as a tail call 19297 * because rIBASE is caller save and we need to reload it. 19298 * 19299 * Note that unlike in the Arm implementation, we should never arrive 19300 * here with a zero breakFlag because we always refresh rIBASE on 19301 * return. 19302 */ 19303 EXPORT_PC 19304 movl rSELF, %eax 19305 movl rPC, OUT_ARG0(%esp) 19306 cmpb $0,offThread_breakFlags(%eax) # anything to do? 19307 movl rFP, OUT_ARG1(%esp) 19308 je 1f # reload rIBASE & resume if not 19309 movl %eax, OUT_ARG2(%esp) 19310 call dvmCheckBefore # (dPC, dFP, self) 19311 movl rSELF, %eax 193121: 19313 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 19314 jmp *dvmAsmInstructionStart+(300*4) 19315 19316/* ------------------------------ */ 19317.L_ALT_OP_UNUSED_2DFF: /* 0x12d */ 19318/* File: x86/alt_stub.S */ 19319/* 19320 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 19321 * any interesting requests and then jump to the real instruction 19322 * handler. Unlike the Arm handler, we can't do this as a tail call 19323 * because rIBASE is caller save and we need to reload it. 19324 * 19325 * Note that unlike in the Arm implementation, we should never arrive 19326 * here with a zero breakFlag because we always refresh rIBASE on 19327 * return. 19328 */ 19329 EXPORT_PC 19330 movl rSELF, %eax 19331 movl rPC, OUT_ARG0(%esp) 19332 cmpb $0,offThread_breakFlags(%eax) # anything to do? 19333 movl rFP, OUT_ARG1(%esp) 19334 je 1f # reload rIBASE & resume if not 19335 movl %eax, OUT_ARG2(%esp) 19336 call dvmCheckBefore # (dPC, dFP, self) 19337 movl rSELF, %eax 193381: 19339 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 19340 jmp *dvmAsmInstructionStart+(301*4) 19341 19342/* ------------------------------ */ 19343.L_ALT_OP_UNUSED_2EFF: /* 0x12e */ 19344/* File: x86/alt_stub.S */ 19345/* 19346 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 19347 * any interesting requests and then jump to the real instruction 19348 * handler. Unlike the Arm handler, we can't do this as a tail call 19349 * because rIBASE is caller save and we need to reload it. 19350 * 19351 * Note that unlike in the Arm implementation, we should never arrive 19352 * here with a zero breakFlag because we always refresh rIBASE on 19353 * return. 19354 */ 19355 EXPORT_PC 19356 movl rSELF, %eax 19357 movl rPC, OUT_ARG0(%esp) 19358 cmpb $0,offThread_breakFlags(%eax) # anything to do? 19359 movl rFP, OUT_ARG1(%esp) 19360 je 1f # reload rIBASE & resume if not 19361 movl %eax, OUT_ARG2(%esp) 19362 call dvmCheckBefore # (dPC, dFP, self) 19363 movl rSELF, %eax 193641: 19365 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 19366 jmp *dvmAsmInstructionStart+(302*4) 19367 19368/* ------------------------------ */ 19369.L_ALT_OP_UNUSED_2FFF: /* 0x12f */ 19370/* File: x86/alt_stub.S */ 19371/* 19372 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 19373 * any interesting requests and then jump to the real instruction 19374 * handler. Unlike the Arm handler, we can't do this as a tail call 19375 * because rIBASE is caller save and we need to reload it. 19376 * 19377 * Note that unlike in the Arm implementation, we should never arrive 19378 * here with a zero breakFlag because we always refresh rIBASE on 19379 * return. 19380 */ 19381 EXPORT_PC 19382 movl rSELF, %eax 19383 movl rPC, OUT_ARG0(%esp) 19384 cmpb $0,offThread_breakFlags(%eax) # anything to do? 19385 movl rFP, OUT_ARG1(%esp) 19386 je 1f # reload rIBASE & resume if not 19387 movl %eax, OUT_ARG2(%esp) 19388 call dvmCheckBefore # (dPC, dFP, self) 19389 movl rSELF, %eax 193901: 19391 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 19392 jmp *dvmAsmInstructionStart+(303*4) 19393 19394/* ------------------------------ */ 19395.L_ALT_OP_UNUSED_30FF: /* 0x130 */ 19396/* File: x86/alt_stub.S */ 19397/* 19398 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 19399 * any interesting requests and then jump to the real instruction 19400 * handler. Unlike the Arm handler, we can't do this as a tail call 19401 * because rIBASE is caller save and we need to reload it. 19402 * 19403 * Note that unlike in the Arm implementation, we should never arrive 19404 * here with a zero breakFlag because we always refresh rIBASE on 19405 * return. 19406 */ 19407 EXPORT_PC 19408 movl rSELF, %eax 19409 movl rPC, OUT_ARG0(%esp) 19410 cmpb $0,offThread_breakFlags(%eax) # anything to do? 19411 movl rFP, OUT_ARG1(%esp) 19412 je 1f # reload rIBASE & resume if not 19413 movl %eax, OUT_ARG2(%esp) 19414 call dvmCheckBefore # (dPC, dFP, self) 19415 movl rSELF, %eax 194161: 19417 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 19418 jmp *dvmAsmInstructionStart+(304*4) 19419 19420/* ------------------------------ */ 19421.L_ALT_OP_UNUSED_31FF: /* 0x131 */ 19422/* File: x86/alt_stub.S */ 19423/* 19424 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 19425 * any interesting requests and then jump to the real instruction 19426 * handler. Unlike the Arm handler, we can't do this as a tail call 19427 * because rIBASE is caller save and we need to reload it. 19428 * 19429 * Note that unlike in the Arm implementation, we should never arrive 19430 * here with a zero breakFlag because we always refresh rIBASE on 19431 * return. 19432 */ 19433 EXPORT_PC 19434 movl rSELF, %eax 19435 movl rPC, OUT_ARG0(%esp) 19436 cmpb $0,offThread_breakFlags(%eax) # anything to do? 19437 movl rFP, OUT_ARG1(%esp) 19438 je 1f # reload rIBASE & resume if not 19439 movl %eax, OUT_ARG2(%esp) 19440 call dvmCheckBefore # (dPC, dFP, self) 19441 movl rSELF, %eax 194421: 19443 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 19444 jmp *dvmAsmInstructionStart+(305*4) 19445 19446/* ------------------------------ */ 19447.L_ALT_OP_UNUSED_32FF: /* 0x132 */ 19448/* File: x86/alt_stub.S */ 19449/* 19450 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 19451 * any interesting requests and then jump to the real instruction 19452 * handler. Unlike the Arm handler, we can't do this as a tail call 19453 * because rIBASE is caller save and we need to reload it. 19454 * 19455 * Note that unlike in the Arm implementation, we should never arrive 19456 * here with a zero breakFlag because we always refresh rIBASE on 19457 * return. 19458 */ 19459 EXPORT_PC 19460 movl rSELF, %eax 19461 movl rPC, OUT_ARG0(%esp) 19462 cmpb $0,offThread_breakFlags(%eax) # anything to do? 19463 movl rFP, OUT_ARG1(%esp) 19464 je 1f # reload rIBASE & resume if not 19465 movl %eax, OUT_ARG2(%esp) 19466 call dvmCheckBefore # (dPC, dFP, self) 19467 movl rSELF, %eax 194681: 19469 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 19470 jmp *dvmAsmInstructionStart+(306*4) 19471 19472/* ------------------------------ */ 19473.L_ALT_OP_UNUSED_33FF: /* 0x133 */ 19474/* File: x86/alt_stub.S */ 19475/* 19476 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 19477 * any interesting requests and then jump to the real instruction 19478 * handler. Unlike the Arm handler, we can't do this as a tail call 19479 * because rIBASE is caller save and we need to reload it. 19480 * 19481 * Note that unlike in the Arm implementation, we should never arrive 19482 * here with a zero breakFlag because we always refresh rIBASE on 19483 * return. 19484 */ 19485 EXPORT_PC 19486 movl rSELF, %eax 19487 movl rPC, OUT_ARG0(%esp) 19488 cmpb $0,offThread_breakFlags(%eax) # anything to do? 19489 movl rFP, OUT_ARG1(%esp) 19490 je 1f # reload rIBASE & resume if not 19491 movl %eax, OUT_ARG2(%esp) 19492 call dvmCheckBefore # (dPC, dFP, self) 19493 movl rSELF, %eax 194941: 19495 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 19496 jmp *dvmAsmInstructionStart+(307*4) 19497 19498/* ------------------------------ */ 19499.L_ALT_OP_UNUSED_34FF: /* 0x134 */ 19500/* File: x86/alt_stub.S */ 19501/* 19502 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 19503 * any interesting requests and then jump to the real instruction 19504 * handler. Unlike the Arm handler, we can't do this as a tail call 19505 * because rIBASE is caller save and we need to reload it. 19506 * 19507 * Note that unlike in the Arm implementation, we should never arrive 19508 * here with a zero breakFlag because we always refresh rIBASE on 19509 * return. 19510 */ 19511 EXPORT_PC 19512 movl rSELF, %eax 19513 movl rPC, OUT_ARG0(%esp) 19514 cmpb $0,offThread_breakFlags(%eax) # anything to do? 19515 movl rFP, OUT_ARG1(%esp) 19516 je 1f # reload rIBASE & resume if not 19517 movl %eax, OUT_ARG2(%esp) 19518 call dvmCheckBefore # (dPC, dFP, self) 19519 movl rSELF, %eax 195201: 19521 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 19522 jmp *dvmAsmInstructionStart+(308*4) 19523 19524/* ------------------------------ */ 19525.L_ALT_OP_UNUSED_35FF: /* 0x135 */ 19526/* File: x86/alt_stub.S */ 19527/* 19528 * Inter-instruction transfer stub. Call out to dvmCheckBefore 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 * Note that unlike in the Arm implementation, we should never arrive 19534 * here with a zero breakFlag because we always refresh rIBASE on 19535 * return. 19536 */ 19537 EXPORT_PC 19538 movl rSELF, %eax 19539 movl rPC, OUT_ARG0(%esp) 19540 cmpb $0,offThread_breakFlags(%eax) # anything to do? 19541 movl rFP, OUT_ARG1(%esp) 19542 je 1f # reload rIBASE & resume if not 19543 movl %eax, OUT_ARG2(%esp) 19544 call dvmCheckBefore # (dPC, dFP, self) 19545 movl rSELF, %eax 195461: 19547 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 19548 jmp *dvmAsmInstructionStart+(309*4) 19549 19550/* ------------------------------ */ 19551.L_ALT_OP_UNUSED_36FF: /* 0x136 */ 19552/* File: x86/alt_stub.S */ 19553/* 19554 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 19555 * any interesting requests and then jump to the real instruction 19556 * handler. Unlike the Arm handler, we can't do this as a tail call 19557 * because rIBASE is caller save and we need to reload it. 19558 * 19559 * Note that unlike in the Arm implementation, we should never arrive 19560 * here with a zero breakFlag because we always refresh rIBASE on 19561 * return. 19562 */ 19563 EXPORT_PC 19564 movl rSELF, %eax 19565 movl rPC, OUT_ARG0(%esp) 19566 cmpb $0,offThread_breakFlags(%eax) # anything to do? 19567 movl rFP, OUT_ARG1(%esp) 19568 je 1f # reload rIBASE & resume if not 19569 movl %eax, OUT_ARG2(%esp) 19570 call dvmCheckBefore # (dPC, dFP, self) 19571 movl rSELF, %eax 195721: 19573 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 19574 jmp *dvmAsmInstructionStart+(310*4) 19575 19576/* ------------------------------ */ 19577.L_ALT_OP_UNUSED_37FF: /* 0x137 */ 19578/* File: x86/alt_stub.S */ 19579/* 19580 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 19581 * any interesting requests and then jump to the real instruction 19582 * handler. Unlike the Arm handler, we can't do this as a tail call 19583 * because rIBASE is caller save and we need to reload it. 19584 * 19585 * Note that unlike in the Arm implementation, we should never arrive 19586 * here with a zero breakFlag because we always refresh rIBASE on 19587 * return. 19588 */ 19589 EXPORT_PC 19590 movl rSELF, %eax 19591 movl rPC, OUT_ARG0(%esp) 19592 cmpb $0,offThread_breakFlags(%eax) # anything to do? 19593 movl rFP, OUT_ARG1(%esp) 19594 je 1f # reload rIBASE & resume if not 19595 movl %eax, OUT_ARG2(%esp) 19596 call dvmCheckBefore # (dPC, dFP, self) 19597 movl rSELF, %eax 195981: 19599 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 19600 jmp *dvmAsmInstructionStart+(311*4) 19601 19602/* ------------------------------ */ 19603.L_ALT_OP_UNUSED_38FF: /* 0x138 */ 19604/* File: x86/alt_stub.S */ 19605/* 19606 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 19607 * any interesting requests and then jump to the real instruction 19608 * handler. Unlike the Arm handler, we can't do this as a tail call 19609 * because rIBASE is caller save and we need to reload it. 19610 * 19611 * Note that unlike in the Arm implementation, we should never arrive 19612 * here with a zero breakFlag because we always refresh rIBASE on 19613 * return. 19614 */ 19615 EXPORT_PC 19616 movl rSELF, %eax 19617 movl rPC, OUT_ARG0(%esp) 19618 cmpb $0,offThread_breakFlags(%eax) # anything to do? 19619 movl rFP, OUT_ARG1(%esp) 19620 je 1f # reload rIBASE & resume if not 19621 movl %eax, OUT_ARG2(%esp) 19622 call dvmCheckBefore # (dPC, dFP, self) 19623 movl rSELF, %eax 196241: 19625 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 19626 jmp *dvmAsmInstructionStart+(312*4) 19627 19628/* ------------------------------ */ 19629.L_ALT_OP_UNUSED_39FF: /* 0x139 */ 19630/* File: x86/alt_stub.S */ 19631/* 19632 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 19633 * any interesting requests and then jump to the real instruction 19634 * handler. Unlike the Arm handler, we can't do this as a tail call 19635 * because rIBASE is caller save and we need to reload it. 19636 * 19637 * Note that unlike in the Arm implementation, we should never arrive 19638 * here with a zero breakFlag because we always refresh rIBASE on 19639 * return. 19640 */ 19641 EXPORT_PC 19642 movl rSELF, %eax 19643 movl rPC, OUT_ARG0(%esp) 19644 cmpb $0,offThread_breakFlags(%eax) # anything to do? 19645 movl rFP, OUT_ARG1(%esp) 19646 je 1f # reload rIBASE & resume if not 19647 movl %eax, OUT_ARG2(%esp) 19648 call dvmCheckBefore # (dPC, dFP, self) 19649 movl rSELF, %eax 196501: 19651 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 19652 jmp *dvmAsmInstructionStart+(313*4) 19653 19654/* ------------------------------ */ 19655.L_ALT_OP_UNUSED_3AFF: /* 0x13a */ 19656/* File: x86/alt_stub.S */ 19657/* 19658 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 19659 * any interesting requests and then jump to the real instruction 19660 * handler. Unlike the Arm handler, we can't do this as a tail call 19661 * because rIBASE is caller save and we need to reload it. 19662 * 19663 * Note that unlike in the Arm implementation, we should never arrive 19664 * here with a zero breakFlag because we always refresh rIBASE on 19665 * return. 19666 */ 19667 EXPORT_PC 19668 movl rSELF, %eax 19669 movl rPC, OUT_ARG0(%esp) 19670 cmpb $0,offThread_breakFlags(%eax) # anything to do? 19671 movl rFP, OUT_ARG1(%esp) 19672 je 1f # reload rIBASE & resume if not 19673 movl %eax, OUT_ARG2(%esp) 19674 call dvmCheckBefore # (dPC, dFP, self) 19675 movl rSELF, %eax 196761: 19677 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 19678 jmp *dvmAsmInstructionStart+(314*4) 19679 19680/* ------------------------------ */ 19681.L_ALT_OP_UNUSED_3BFF: /* 0x13b */ 19682/* File: x86/alt_stub.S */ 19683/* 19684 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 19685 * any interesting requests and then jump to the real instruction 19686 * handler. Unlike the Arm handler, we can't do this as a tail call 19687 * because rIBASE is caller save and we need to reload it. 19688 * 19689 * Note that unlike in the Arm implementation, we should never arrive 19690 * here with a zero breakFlag because we always refresh rIBASE on 19691 * return. 19692 */ 19693 EXPORT_PC 19694 movl rSELF, %eax 19695 movl rPC, OUT_ARG0(%esp) 19696 cmpb $0,offThread_breakFlags(%eax) # anything to do? 19697 movl rFP, OUT_ARG1(%esp) 19698 je 1f # reload rIBASE & resume if not 19699 movl %eax, OUT_ARG2(%esp) 19700 call dvmCheckBefore # (dPC, dFP, self) 19701 movl rSELF, %eax 197021: 19703 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 19704 jmp *dvmAsmInstructionStart+(315*4) 19705 19706/* ------------------------------ */ 19707.L_ALT_OP_UNUSED_3CFF: /* 0x13c */ 19708/* File: x86/alt_stub.S */ 19709/* 19710 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 19711 * any interesting requests and then jump to the real instruction 19712 * handler. Unlike the Arm handler, we can't do this as a tail call 19713 * because rIBASE is caller save and we need to reload it. 19714 * 19715 * Note that unlike in the Arm implementation, we should never arrive 19716 * here with a zero breakFlag because we always refresh rIBASE on 19717 * return. 19718 */ 19719 EXPORT_PC 19720 movl rSELF, %eax 19721 movl rPC, OUT_ARG0(%esp) 19722 cmpb $0,offThread_breakFlags(%eax) # anything to do? 19723 movl rFP, OUT_ARG1(%esp) 19724 je 1f # reload rIBASE & resume if not 19725 movl %eax, OUT_ARG2(%esp) 19726 call dvmCheckBefore # (dPC, dFP, self) 19727 movl rSELF, %eax 197281: 19729 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 19730 jmp *dvmAsmInstructionStart+(316*4) 19731 19732/* ------------------------------ */ 19733.L_ALT_OP_UNUSED_3DFF: /* 0x13d */ 19734/* File: x86/alt_stub.S */ 19735/* 19736 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 19737 * any interesting requests and then jump to the real instruction 19738 * handler. Unlike the Arm handler, we can't do this as a tail call 19739 * because rIBASE is caller save and we need to reload it. 19740 * 19741 * Note that unlike in the Arm implementation, we should never arrive 19742 * here with a zero breakFlag because we always refresh rIBASE on 19743 * return. 19744 */ 19745 EXPORT_PC 19746 movl rSELF, %eax 19747 movl rPC, OUT_ARG0(%esp) 19748 cmpb $0,offThread_breakFlags(%eax) # anything to do? 19749 movl rFP, OUT_ARG1(%esp) 19750 je 1f # reload rIBASE & resume if not 19751 movl %eax, OUT_ARG2(%esp) 19752 call dvmCheckBefore # (dPC, dFP, self) 19753 movl rSELF, %eax 197541: 19755 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 19756 jmp *dvmAsmInstructionStart+(317*4) 19757 19758/* ------------------------------ */ 19759.L_ALT_OP_UNUSED_3EFF: /* 0x13e */ 19760/* File: x86/alt_stub.S */ 19761/* 19762 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 19763 * any interesting requests and then jump to the real instruction 19764 * handler. Unlike the Arm handler, we can't do this as a tail call 19765 * because rIBASE is caller save and we need to reload it. 19766 * 19767 * Note that unlike in the Arm implementation, we should never arrive 19768 * here with a zero breakFlag because we always refresh rIBASE on 19769 * return. 19770 */ 19771 EXPORT_PC 19772 movl rSELF, %eax 19773 movl rPC, OUT_ARG0(%esp) 19774 cmpb $0,offThread_breakFlags(%eax) # anything to do? 19775 movl rFP, OUT_ARG1(%esp) 19776 je 1f # reload rIBASE & resume if not 19777 movl %eax, OUT_ARG2(%esp) 19778 call dvmCheckBefore # (dPC, dFP, self) 19779 movl rSELF, %eax 197801: 19781 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 19782 jmp *dvmAsmInstructionStart+(318*4) 19783 19784/* ------------------------------ */ 19785.L_ALT_OP_UNUSED_3FFF: /* 0x13f */ 19786/* File: x86/alt_stub.S */ 19787/* 19788 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 19789 * any interesting requests and then jump to the real instruction 19790 * handler. Unlike the Arm handler, we can't do this as a tail call 19791 * because rIBASE is caller save and we need to reload it. 19792 * 19793 * Note that unlike in the Arm implementation, we should never arrive 19794 * here with a zero breakFlag because we always refresh rIBASE on 19795 * return. 19796 */ 19797 EXPORT_PC 19798 movl rSELF, %eax 19799 movl rPC, OUT_ARG0(%esp) 19800 cmpb $0,offThread_breakFlags(%eax) # anything to do? 19801 movl rFP, OUT_ARG1(%esp) 19802 je 1f # reload rIBASE & resume if not 19803 movl %eax, OUT_ARG2(%esp) 19804 call dvmCheckBefore # (dPC, dFP, self) 19805 movl rSELF, %eax 198061: 19807 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 19808 jmp *dvmAsmInstructionStart+(319*4) 19809 19810/* ------------------------------ */ 19811.L_ALT_OP_UNUSED_40FF: /* 0x140 */ 19812/* File: x86/alt_stub.S */ 19813/* 19814 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 19815 * any interesting requests and then jump to the real instruction 19816 * handler. Unlike the Arm handler, we can't do this as a tail call 19817 * because rIBASE is caller save and we need to reload it. 19818 * 19819 * Note that unlike in the Arm implementation, we should never arrive 19820 * here with a zero breakFlag because we always refresh rIBASE on 19821 * return. 19822 */ 19823 EXPORT_PC 19824 movl rSELF, %eax 19825 movl rPC, OUT_ARG0(%esp) 19826 cmpb $0,offThread_breakFlags(%eax) # anything to do? 19827 movl rFP, OUT_ARG1(%esp) 19828 je 1f # reload rIBASE & resume if not 19829 movl %eax, OUT_ARG2(%esp) 19830 call dvmCheckBefore # (dPC, dFP, self) 19831 movl rSELF, %eax 198321: 19833 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 19834 jmp *dvmAsmInstructionStart+(320*4) 19835 19836/* ------------------------------ */ 19837.L_ALT_OP_UNUSED_41FF: /* 0x141 */ 19838/* File: x86/alt_stub.S */ 19839/* 19840 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 19841 * any interesting requests and then jump to the real instruction 19842 * handler. Unlike the Arm handler, we can't do this as a tail call 19843 * because rIBASE is caller save and we need to reload it. 19844 * 19845 * Note that unlike in the Arm implementation, we should never arrive 19846 * here with a zero breakFlag because we always refresh rIBASE on 19847 * return. 19848 */ 19849 EXPORT_PC 19850 movl rSELF, %eax 19851 movl rPC, OUT_ARG0(%esp) 19852 cmpb $0,offThread_breakFlags(%eax) # anything to do? 19853 movl rFP, OUT_ARG1(%esp) 19854 je 1f # reload rIBASE & resume if not 19855 movl %eax, OUT_ARG2(%esp) 19856 call dvmCheckBefore # (dPC, dFP, self) 19857 movl rSELF, %eax 198581: 19859 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 19860 jmp *dvmAsmInstructionStart+(321*4) 19861 19862/* ------------------------------ */ 19863.L_ALT_OP_UNUSED_42FF: /* 0x142 */ 19864/* File: x86/alt_stub.S */ 19865/* 19866 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 19867 * any interesting requests and then jump to the real instruction 19868 * handler. Unlike the Arm handler, we can't do this as a tail call 19869 * because rIBASE is caller save and we need to reload it. 19870 * 19871 * Note that unlike in the Arm implementation, we should never arrive 19872 * here with a zero breakFlag because we always refresh rIBASE on 19873 * return. 19874 */ 19875 EXPORT_PC 19876 movl rSELF, %eax 19877 movl rPC, OUT_ARG0(%esp) 19878 cmpb $0,offThread_breakFlags(%eax) # anything to do? 19879 movl rFP, OUT_ARG1(%esp) 19880 je 1f # reload rIBASE & resume if not 19881 movl %eax, OUT_ARG2(%esp) 19882 call dvmCheckBefore # (dPC, dFP, self) 19883 movl rSELF, %eax 198841: 19885 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 19886 jmp *dvmAsmInstructionStart+(322*4) 19887 19888/* ------------------------------ */ 19889.L_ALT_OP_UNUSED_43FF: /* 0x143 */ 19890/* File: x86/alt_stub.S */ 19891/* 19892 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 19893 * any interesting requests and then jump to the real instruction 19894 * handler. Unlike the Arm handler, we can't do this as a tail call 19895 * because rIBASE is caller save and we need to reload it. 19896 * 19897 * Note that unlike in the Arm implementation, we should never arrive 19898 * here with a zero breakFlag because we always refresh rIBASE on 19899 * return. 19900 */ 19901 EXPORT_PC 19902 movl rSELF, %eax 19903 movl rPC, OUT_ARG0(%esp) 19904 cmpb $0,offThread_breakFlags(%eax) # anything to do? 19905 movl rFP, OUT_ARG1(%esp) 19906 je 1f # reload rIBASE & resume if not 19907 movl %eax, OUT_ARG2(%esp) 19908 call dvmCheckBefore # (dPC, dFP, self) 19909 movl rSELF, %eax 199101: 19911 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 19912 jmp *dvmAsmInstructionStart+(323*4) 19913 19914/* ------------------------------ */ 19915.L_ALT_OP_UNUSED_44FF: /* 0x144 */ 19916/* File: x86/alt_stub.S */ 19917/* 19918 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 19919 * any interesting requests and then jump to the real instruction 19920 * handler. Unlike the Arm handler, we can't do this as a tail call 19921 * because rIBASE is caller save and we need to reload it. 19922 * 19923 * Note that unlike in the Arm implementation, we should never arrive 19924 * here with a zero breakFlag because we always refresh rIBASE on 19925 * return. 19926 */ 19927 EXPORT_PC 19928 movl rSELF, %eax 19929 movl rPC, OUT_ARG0(%esp) 19930 cmpb $0,offThread_breakFlags(%eax) # anything to do? 19931 movl rFP, OUT_ARG1(%esp) 19932 je 1f # reload rIBASE & resume if not 19933 movl %eax, OUT_ARG2(%esp) 19934 call dvmCheckBefore # (dPC, dFP, self) 19935 movl rSELF, %eax 199361: 19937 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 19938 jmp *dvmAsmInstructionStart+(324*4) 19939 19940/* ------------------------------ */ 19941.L_ALT_OP_UNUSED_45FF: /* 0x145 */ 19942/* File: x86/alt_stub.S */ 19943/* 19944 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 19945 * any interesting requests and then jump to the real instruction 19946 * handler. Unlike the Arm handler, we can't do this as a tail call 19947 * because rIBASE is caller save and we need to reload it. 19948 * 19949 * Note that unlike in the Arm implementation, we should never arrive 19950 * here with a zero breakFlag because we always refresh rIBASE on 19951 * return. 19952 */ 19953 EXPORT_PC 19954 movl rSELF, %eax 19955 movl rPC, OUT_ARG0(%esp) 19956 cmpb $0,offThread_breakFlags(%eax) # anything to do? 19957 movl rFP, OUT_ARG1(%esp) 19958 je 1f # reload rIBASE & resume if not 19959 movl %eax, OUT_ARG2(%esp) 19960 call dvmCheckBefore # (dPC, dFP, self) 19961 movl rSELF, %eax 199621: 19963 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 19964 jmp *dvmAsmInstructionStart+(325*4) 19965 19966/* ------------------------------ */ 19967.L_ALT_OP_UNUSED_46FF: /* 0x146 */ 19968/* File: x86/alt_stub.S */ 19969/* 19970 * Inter-instruction transfer stub. Call out to dvmCheckBefore 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 * Note that unlike in the Arm implementation, we should never arrive 19976 * here with a zero breakFlag because we always refresh rIBASE on 19977 * return. 19978 */ 19979 EXPORT_PC 19980 movl rSELF, %eax 19981 movl rPC, OUT_ARG0(%esp) 19982 cmpb $0,offThread_breakFlags(%eax) # anything to do? 19983 movl rFP, OUT_ARG1(%esp) 19984 je 1f # reload rIBASE & resume if not 19985 movl %eax, OUT_ARG2(%esp) 19986 call dvmCheckBefore # (dPC, dFP, self) 19987 movl rSELF, %eax 199881: 19989 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 19990 jmp *dvmAsmInstructionStart+(326*4) 19991 19992/* ------------------------------ */ 19993.L_ALT_OP_UNUSED_47FF: /* 0x147 */ 19994/* File: x86/alt_stub.S */ 19995/* 19996 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 19997 * any interesting requests and then jump to the real instruction 19998 * handler. Unlike the Arm handler, we can't do this as a tail call 19999 * because rIBASE is caller save and we need to reload it. 20000 * 20001 * Note that unlike in the Arm implementation, we should never arrive 20002 * here with a zero breakFlag because we always refresh rIBASE on 20003 * return. 20004 */ 20005 EXPORT_PC 20006 movl rSELF, %eax 20007 movl rPC, OUT_ARG0(%esp) 20008 cmpb $0,offThread_breakFlags(%eax) # anything to do? 20009 movl rFP, OUT_ARG1(%esp) 20010 je 1f # reload rIBASE & resume if not 20011 movl %eax, OUT_ARG2(%esp) 20012 call dvmCheckBefore # (dPC, dFP, self) 20013 movl rSELF, %eax 200141: 20015 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 20016 jmp *dvmAsmInstructionStart+(327*4) 20017 20018/* ------------------------------ */ 20019.L_ALT_OP_UNUSED_48FF: /* 0x148 */ 20020/* File: x86/alt_stub.S */ 20021/* 20022 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 20023 * any interesting requests and then jump to the real instruction 20024 * handler. Unlike the Arm handler, we can't do this as a tail call 20025 * because rIBASE is caller save and we need to reload it. 20026 * 20027 * Note that unlike in the Arm implementation, we should never arrive 20028 * here with a zero breakFlag because we always refresh rIBASE on 20029 * return. 20030 */ 20031 EXPORT_PC 20032 movl rSELF, %eax 20033 movl rPC, OUT_ARG0(%esp) 20034 cmpb $0,offThread_breakFlags(%eax) # anything to do? 20035 movl rFP, OUT_ARG1(%esp) 20036 je 1f # reload rIBASE & resume if not 20037 movl %eax, OUT_ARG2(%esp) 20038 call dvmCheckBefore # (dPC, dFP, self) 20039 movl rSELF, %eax 200401: 20041 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 20042 jmp *dvmAsmInstructionStart+(328*4) 20043 20044/* ------------------------------ */ 20045.L_ALT_OP_UNUSED_49FF: /* 0x149 */ 20046/* File: x86/alt_stub.S */ 20047/* 20048 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 20049 * any interesting requests and then jump to the real instruction 20050 * handler. Unlike the Arm handler, we can't do this as a tail call 20051 * because rIBASE is caller save and we need to reload it. 20052 * 20053 * Note that unlike in the Arm implementation, we should never arrive 20054 * here with a zero breakFlag because we always refresh rIBASE on 20055 * return. 20056 */ 20057 EXPORT_PC 20058 movl rSELF, %eax 20059 movl rPC, OUT_ARG0(%esp) 20060 cmpb $0,offThread_breakFlags(%eax) # anything to do? 20061 movl rFP, OUT_ARG1(%esp) 20062 je 1f # reload rIBASE & resume if not 20063 movl %eax, OUT_ARG2(%esp) 20064 call dvmCheckBefore # (dPC, dFP, self) 20065 movl rSELF, %eax 200661: 20067 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 20068 jmp *dvmAsmInstructionStart+(329*4) 20069 20070/* ------------------------------ */ 20071.L_ALT_OP_UNUSED_4AFF: /* 0x14a */ 20072/* File: x86/alt_stub.S */ 20073/* 20074 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 20075 * any interesting requests and then jump to the real instruction 20076 * handler. Unlike the Arm handler, we can't do this as a tail call 20077 * because rIBASE is caller save and we need to reload it. 20078 * 20079 * Note that unlike in the Arm implementation, we should never arrive 20080 * here with a zero breakFlag because we always refresh rIBASE on 20081 * return. 20082 */ 20083 EXPORT_PC 20084 movl rSELF, %eax 20085 movl rPC, OUT_ARG0(%esp) 20086 cmpb $0,offThread_breakFlags(%eax) # anything to do? 20087 movl rFP, OUT_ARG1(%esp) 20088 je 1f # reload rIBASE & resume if not 20089 movl %eax, OUT_ARG2(%esp) 20090 call dvmCheckBefore # (dPC, dFP, self) 20091 movl rSELF, %eax 200921: 20093 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 20094 jmp *dvmAsmInstructionStart+(330*4) 20095 20096/* ------------------------------ */ 20097.L_ALT_OP_UNUSED_4BFF: /* 0x14b */ 20098/* File: x86/alt_stub.S */ 20099/* 20100 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 20101 * any interesting requests and then jump to the real instruction 20102 * handler. Unlike the Arm handler, we can't do this as a tail call 20103 * because rIBASE is caller save and we need to reload it. 20104 * 20105 * Note that unlike in the Arm implementation, we should never arrive 20106 * here with a zero breakFlag because we always refresh rIBASE on 20107 * return. 20108 */ 20109 EXPORT_PC 20110 movl rSELF, %eax 20111 movl rPC, OUT_ARG0(%esp) 20112 cmpb $0,offThread_breakFlags(%eax) # anything to do? 20113 movl rFP, OUT_ARG1(%esp) 20114 je 1f # reload rIBASE & resume if not 20115 movl %eax, OUT_ARG2(%esp) 20116 call dvmCheckBefore # (dPC, dFP, self) 20117 movl rSELF, %eax 201181: 20119 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 20120 jmp *dvmAsmInstructionStart+(331*4) 20121 20122/* ------------------------------ */ 20123.L_ALT_OP_UNUSED_4CFF: /* 0x14c */ 20124/* File: x86/alt_stub.S */ 20125/* 20126 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 20127 * any interesting requests and then jump to the real instruction 20128 * handler. Unlike the Arm handler, we can't do this as a tail call 20129 * because rIBASE is caller save and we need to reload it. 20130 * 20131 * Note that unlike in the Arm implementation, we should never arrive 20132 * here with a zero breakFlag because we always refresh rIBASE on 20133 * return. 20134 */ 20135 EXPORT_PC 20136 movl rSELF, %eax 20137 movl rPC, OUT_ARG0(%esp) 20138 cmpb $0,offThread_breakFlags(%eax) # anything to do? 20139 movl rFP, OUT_ARG1(%esp) 20140 je 1f # reload rIBASE & resume if not 20141 movl %eax, OUT_ARG2(%esp) 20142 call dvmCheckBefore # (dPC, dFP, self) 20143 movl rSELF, %eax 201441: 20145 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 20146 jmp *dvmAsmInstructionStart+(332*4) 20147 20148/* ------------------------------ */ 20149.L_ALT_OP_UNUSED_4DFF: /* 0x14d */ 20150/* File: x86/alt_stub.S */ 20151/* 20152 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 20153 * any interesting requests and then jump to the real instruction 20154 * handler. Unlike the Arm handler, we can't do this as a tail call 20155 * because rIBASE is caller save and we need to reload it. 20156 * 20157 * Note that unlike in the Arm implementation, we should never arrive 20158 * here with a zero breakFlag because we always refresh rIBASE on 20159 * return. 20160 */ 20161 EXPORT_PC 20162 movl rSELF, %eax 20163 movl rPC, OUT_ARG0(%esp) 20164 cmpb $0,offThread_breakFlags(%eax) # anything to do? 20165 movl rFP, OUT_ARG1(%esp) 20166 je 1f # reload rIBASE & resume if not 20167 movl %eax, OUT_ARG2(%esp) 20168 call dvmCheckBefore # (dPC, dFP, self) 20169 movl rSELF, %eax 201701: 20171 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 20172 jmp *dvmAsmInstructionStart+(333*4) 20173 20174/* ------------------------------ */ 20175.L_ALT_OP_UNUSED_4EFF: /* 0x14e */ 20176/* File: x86/alt_stub.S */ 20177/* 20178 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 20179 * any interesting requests and then jump to the real instruction 20180 * handler. Unlike the Arm handler, we can't do this as a tail call 20181 * because rIBASE is caller save and we need to reload it. 20182 * 20183 * Note that unlike in the Arm implementation, we should never arrive 20184 * here with a zero breakFlag because we always refresh rIBASE on 20185 * return. 20186 */ 20187 EXPORT_PC 20188 movl rSELF, %eax 20189 movl rPC, OUT_ARG0(%esp) 20190 cmpb $0,offThread_breakFlags(%eax) # anything to do? 20191 movl rFP, OUT_ARG1(%esp) 20192 je 1f # reload rIBASE & resume if not 20193 movl %eax, OUT_ARG2(%esp) 20194 call dvmCheckBefore # (dPC, dFP, self) 20195 movl rSELF, %eax 201961: 20197 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 20198 jmp *dvmAsmInstructionStart+(334*4) 20199 20200/* ------------------------------ */ 20201.L_ALT_OP_UNUSED_4FFF: /* 0x14f */ 20202/* File: x86/alt_stub.S */ 20203/* 20204 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 20205 * any interesting requests and then jump to the real instruction 20206 * handler. Unlike the Arm handler, we can't do this as a tail call 20207 * because rIBASE is caller save and we need to reload it. 20208 * 20209 * Note that unlike in the Arm implementation, we should never arrive 20210 * here with a zero breakFlag because we always refresh rIBASE on 20211 * return. 20212 */ 20213 EXPORT_PC 20214 movl rSELF, %eax 20215 movl rPC, OUT_ARG0(%esp) 20216 cmpb $0,offThread_breakFlags(%eax) # anything to do? 20217 movl rFP, OUT_ARG1(%esp) 20218 je 1f # reload rIBASE & resume if not 20219 movl %eax, OUT_ARG2(%esp) 20220 call dvmCheckBefore # (dPC, dFP, self) 20221 movl rSELF, %eax 202221: 20223 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 20224 jmp *dvmAsmInstructionStart+(335*4) 20225 20226/* ------------------------------ */ 20227.L_ALT_OP_UNUSED_50FF: /* 0x150 */ 20228/* File: x86/alt_stub.S */ 20229/* 20230 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 20231 * any interesting requests and then jump to the real instruction 20232 * handler. Unlike the Arm handler, we can't do this as a tail call 20233 * because rIBASE is caller save and we need to reload it. 20234 * 20235 * Note that unlike in the Arm implementation, we should never arrive 20236 * here with a zero breakFlag because we always refresh rIBASE on 20237 * return. 20238 */ 20239 EXPORT_PC 20240 movl rSELF, %eax 20241 movl rPC, OUT_ARG0(%esp) 20242 cmpb $0,offThread_breakFlags(%eax) # anything to do? 20243 movl rFP, OUT_ARG1(%esp) 20244 je 1f # reload rIBASE & resume if not 20245 movl %eax, OUT_ARG2(%esp) 20246 call dvmCheckBefore # (dPC, dFP, self) 20247 movl rSELF, %eax 202481: 20249 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 20250 jmp *dvmAsmInstructionStart+(336*4) 20251 20252/* ------------------------------ */ 20253.L_ALT_OP_UNUSED_51FF: /* 0x151 */ 20254/* File: x86/alt_stub.S */ 20255/* 20256 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 20257 * any interesting requests and then jump to the real instruction 20258 * handler. Unlike the Arm handler, we can't do this as a tail call 20259 * because rIBASE is caller save and we need to reload it. 20260 * 20261 * Note that unlike in the Arm implementation, we should never arrive 20262 * here with a zero breakFlag because we always refresh rIBASE on 20263 * return. 20264 */ 20265 EXPORT_PC 20266 movl rSELF, %eax 20267 movl rPC, OUT_ARG0(%esp) 20268 cmpb $0,offThread_breakFlags(%eax) # anything to do? 20269 movl rFP, OUT_ARG1(%esp) 20270 je 1f # reload rIBASE & resume if not 20271 movl %eax, OUT_ARG2(%esp) 20272 call dvmCheckBefore # (dPC, dFP, self) 20273 movl rSELF, %eax 202741: 20275 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 20276 jmp *dvmAsmInstructionStart+(337*4) 20277 20278/* ------------------------------ */ 20279.L_ALT_OP_UNUSED_52FF: /* 0x152 */ 20280/* File: x86/alt_stub.S */ 20281/* 20282 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 20283 * any interesting requests and then jump to the real instruction 20284 * handler. Unlike the Arm handler, we can't do this as a tail call 20285 * because rIBASE is caller save and we need to reload it. 20286 * 20287 * Note that unlike in the Arm implementation, we should never arrive 20288 * here with a zero breakFlag because we always refresh rIBASE on 20289 * return. 20290 */ 20291 EXPORT_PC 20292 movl rSELF, %eax 20293 movl rPC, OUT_ARG0(%esp) 20294 cmpb $0,offThread_breakFlags(%eax) # anything to do? 20295 movl rFP, OUT_ARG1(%esp) 20296 je 1f # reload rIBASE & resume if not 20297 movl %eax, OUT_ARG2(%esp) 20298 call dvmCheckBefore # (dPC, dFP, self) 20299 movl rSELF, %eax 203001: 20301 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 20302 jmp *dvmAsmInstructionStart+(338*4) 20303 20304/* ------------------------------ */ 20305.L_ALT_OP_UNUSED_53FF: /* 0x153 */ 20306/* File: x86/alt_stub.S */ 20307/* 20308 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 20309 * any interesting requests and then jump to the real instruction 20310 * handler. Unlike the Arm handler, we can't do this as a tail call 20311 * because rIBASE is caller save and we need to reload it. 20312 * 20313 * Note that unlike in the Arm implementation, we should never arrive 20314 * here with a zero breakFlag because we always refresh rIBASE on 20315 * return. 20316 */ 20317 EXPORT_PC 20318 movl rSELF, %eax 20319 movl rPC, OUT_ARG0(%esp) 20320 cmpb $0,offThread_breakFlags(%eax) # anything to do? 20321 movl rFP, OUT_ARG1(%esp) 20322 je 1f # reload rIBASE & resume if not 20323 movl %eax, OUT_ARG2(%esp) 20324 call dvmCheckBefore # (dPC, dFP, self) 20325 movl rSELF, %eax 203261: 20327 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 20328 jmp *dvmAsmInstructionStart+(339*4) 20329 20330/* ------------------------------ */ 20331.L_ALT_OP_UNUSED_54FF: /* 0x154 */ 20332/* File: x86/alt_stub.S */ 20333/* 20334 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 20335 * any interesting requests and then jump to the real instruction 20336 * handler. Unlike the Arm handler, we can't do this as a tail call 20337 * because rIBASE is caller save and we need to reload it. 20338 * 20339 * Note that unlike in the Arm implementation, we should never arrive 20340 * here with a zero breakFlag because we always refresh rIBASE on 20341 * return. 20342 */ 20343 EXPORT_PC 20344 movl rSELF, %eax 20345 movl rPC, OUT_ARG0(%esp) 20346 cmpb $0,offThread_breakFlags(%eax) # anything to do? 20347 movl rFP, OUT_ARG1(%esp) 20348 je 1f # reload rIBASE & resume if not 20349 movl %eax, OUT_ARG2(%esp) 20350 call dvmCheckBefore # (dPC, dFP, self) 20351 movl rSELF, %eax 203521: 20353 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 20354 jmp *dvmAsmInstructionStart+(340*4) 20355 20356/* ------------------------------ */ 20357.L_ALT_OP_UNUSED_55FF: /* 0x155 */ 20358/* File: x86/alt_stub.S */ 20359/* 20360 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 20361 * any interesting requests and then jump to the real instruction 20362 * handler. Unlike the Arm handler, we can't do this as a tail call 20363 * because rIBASE is caller save and we need to reload it. 20364 * 20365 * Note that unlike in the Arm implementation, we should never arrive 20366 * here with a zero breakFlag because we always refresh rIBASE on 20367 * return. 20368 */ 20369 EXPORT_PC 20370 movl rSELF, %eax 20371 movl rPC, OUT_ARG0(%esp) 20372 cmpb $0,offThread_breakFlags(%eax) # anything to do? 20373 movl rFP, OUT_ARG1(%esp) 20374 je 1f # reload rIBASE & resume if not 20375 movl %eax, OUT_ARG2(%esp) 20376 call dvmCheckBefore # (dPC, dFP, self) 20377 movl rSELF, %eax 203781: 20379 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 20380 jmp *dvmAsmInstructionStart+(341*4) 20381 20382/* ------------------------------ */ 20383.L_ALT_OP_UNUSED_56FF: /* 0x156 */ 20384/* File: x86/alt_stub.S */ 20385/* 20386 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 20387 * any interesting requests and then jump to the real instruction 20388 * handler. Unlike the Arm handler, we can't do this as a tail call 20389 * because rIBASE is caller save and we need to reload it. 20390 * 20391 * Note that unlike in the Arm implementation, we should never arrive 20392 * here with a zero breakFlag because we always refresh rIBASE on 20393 * return. 20394 */ 20395 EXPORT_PC 20396 movl rSELF, %eax 20397 movl rPC, OUT_ARG0(%esp) 20398 cmpb $0,offThread_breakFlags(%eax) # anything to do? 20399 movl rFP, OUT_ARG1(%esp) 20400 je 1f # reload rIBASE & resume if not 20401 movl %eax, OUT_ARG2(%esp) 20402 call dvmCheckBefore # (dPC, dFP, self) 20403 movl rSELF, %eax 204041: 20405 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 20406 jmp *dvmAsmInstructionStart+(342*4) 20407 20408/* ------------------------------ */ 20409.L_ALT_OP_UNUSED_57FF: /* 0x157 */ 20410/* File: x86/alt_stub.S */ 20411/* 20412 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 20413 * any interesting requests and then jump to the real instruction 20414 * handler. Unlike the Arm handler, we can't do this as a tail call 20415 * because rIBASE is caller save and we need to reload it. 20416 * 20417 * Note that unlike in the Arm implementation, we should never arrive 20418 * here with a zero breakFlag because we always refresh rIBASE on 20419 * return. 20420 */ 20421 EXPORT_PC 20422 movl rSELF, %eax 20423 movl rPC, OUT_ARG0(%esp) 20424 cmpb $0,offThread_breakFlags(%eax) # anything to do? 20425 movl rFP, OUT_ARG1(%esp) 20426 je 1f # reload rIBASE & resume if not 20427 movl %eax, OUT_ARG2(%esp) 20428 call dvmCheckBefore # (dPC, dFP, self) 20429 movl rSELF, %eax 204301: 20431 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 20432 jmp *dvmAsmInstructionStart+(343*4) 20433 20434/* ------------------------------ */ 20435.L_ALT_OP_UNUSED_58FF: /* 0x158 */ 20436/* File: x86/alt_stub.S */ 20437/* 20438 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 20439 * any interesting requests and then jump to the real instruction 20440 * handler. Unlike the Arm handler, we can't do this as a tail call 20441 * because rIBASE is caller save and we need to reload it. 20442 * 20443 * Note that unlike in the Arm implementation, we should never arrive 20444 * here with a zero breakFlag because we always refresh rIBASE on 20445 * return. 20446 */ 20447 EXPORT_PC 20448 movl rSELF, %eax 20449 movl rPC, OUT_ARG0(%esp) 20450 cmpb $0,offThread_breakFlags(%eax) # anything to do? 20451 movl rFP, OUT_ARG1(%esp) 20452 je 1f # reload rIBASE & resume if not 20453 movl %eax, OUT_ARG2(%esp) 20454 call dvmCheckBefore # (dPC, dFP, self) 20455 movl rSELF, %eax 204561: 20457 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 20458 jmp *dvmAsmInstructionStart+(344*4) 20459 20460/* ------------------------------ */ 20461.L_ALT_OP_UNUSED_59FF: /* 0x159 */ 20462/* File: x86/alt_stub.S */ 20463/* 20464 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 20465 * any interesting requests and then jump to the real instruction 20466 * handler. Unlike the Arm handler, we can't do this as a tail call 20467 * because rIBASE is caller save and we need to reload it. 20468 * 20469 * Note that unlike in the Arm implementation, we should never arrive 20470 * here with a zero breakFlag because we always refresh rIBASE on 20471 * return. 20472 */ 20473 EXPORT_PC 20474 movl rSELF, %eax 20475 movl rPC, OUT_ARG0(%esp) 20476 cmpb $0,offThread_breakFlags(%eax) # anything to do? 20477 movl rFP, OUT_ARG1(%esp) 20478 je 1f # reload rIBASE & resume if not 20479 movl %eax, OUT_ARG2(%esp) 20480 call dvmCheckBefore # (dPC, dFP, self) 20481 movl rSELF, %eax 204821: 20483 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 20484 jmp *dvmAsmInstructionStart+(345*4) 20485 20486/* ------------------------------ */ 20487.L_ALT_OP_UNUSED_5AFF: /* 0x15a */ 20488/* File: x86/alt_stub.S */ 20489/* 20490 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 20491 * any interesting requests and then jump to the real instruction 20492 * handler. Unlike the Arm handler, we can't do this as a tail call 20493 * because rIBASE is caller save and we need to reload it. 20494 * 20495 * Note that unlike in the Arm implementation, we should never arrive 20496 * here with a zero breakFlag because we always refresh rIBASE on 20497 * return. 20498 */ 20499 EXPORT_PC 20500 movl rSELF, %eax 20501 movl rPC, OUT_ARG0(%esp) 20502 cmpb $0,offThread_breakFlags(%eax) # anything to do? 20503 movl rFP, OUT_ARG1(%esp) 20504 je 1f # reload rIBASE & resume if not 20505 movl %eax, OUT_ARG2(%esp) 20506 call dvmCheckBefore # (dPC, dFP, self) 20507 movl rSELF, %eax 205081: 20509 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 20510 jmp *dvmAsmInstructionStart+(346*4) 20511 20512/* ------------------------------ */ 20513.L_ALT_OP_UNUSED_5BFF: /* 0x15b */ 20514/* File: x86/alt_stub.S */ 20515/* 20516 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 20517 * any interesting requests and then jump to the real instruction 20518 * handler. Unlike the Arm handler, we can't do this as a tail call 20519 * because rIBASE is caller save and we need to reload it. 20520 * 20521 * Note that unlike in the Arm implementation, we should never arrive 20522 * here with a zero breakFlag because we always refresh rIBASE on 20523 * return. 20524 */ 20525 EXPORT_PC 20526 movl rSELF, %eax 20527 movl rPC, OUT_ARG0(%esp) 20528 cmpb $0,offThread_breakFlags(%eax) # anything to do? 20529 movl rFP, OUT_ARG1(%esp) 20530 je 1f # reload rIBASE & resume if not 20531 movl %eax, OUT_ARG2(%esp) 20532 call dvmCheckBefore # (dPC, dFP, self) 20533 movl rSELF, %eax 205341: 20535 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 20536 jmp *dvmAsmInstructionStart+(347*4) 20537 20538/* ------------------------------ */ 20539.L_ALT_OP_UNUSED_5CFF: /* 0x15c */ 20540/* File: x86/alt_stub.S */ 20541/* 20542 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 20543 * any interesting requests and then jump to the real instruction 20544 * handler. Unlike the Arm handler, we can't do this as a tail call 20545 * because rIBASE is caller save and we need to reload it. 20546 * 20547 * Note that unlike in the Arm implementation, we should never arrive 20548 * here with a zero breakFlag because we always refresh rIBASE on 20549 * return. 20550 */ 20551 EXPORT_PC 20552 movl rSELF, %eax 20553 movl rPC, OUT_ARG0(%esp) 20554 cmpb $0,offThread_breakFlags(%eax) # anything to do? 20555 movl rFP, OUT_ARG1(%esp) 20556 je 1f # reload rIBASE & resume if not 20557 movl %eax, OUT_ARG2(%esp) 20558 call dvmCheckBefore # (dPC, dFP, self) 20559 movl rSELF, %eax 205601: 20561 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 20562 jmp *dvmAsmInstructionStart+(348*4) 20563 20564/* ------------------------------ */ 20565.L_ALT_OP_UNUSED_5DFF: /* 0x15d */ 20566/* File: x86/alt_stub.S */ 20567/* 20568 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 20569 * any interesting requests and then jump to the real instruction 20570 * handler. Unlike the Arm handler, we can't do this as a tail call 20571 * because rIBASE is caller save and we need to reload it. 20572 * 20573 * Note that unlike in the Arm implementation, we should never arrive 20574 * here with a zero breakFlag because we always refresh rIBASE on 20575 * return. 20576 */ 20577 EXPORT_PC 20578 movl rSELF, %eax 20579 movl rPC, OUT_ARG0(%esp) 20580 cmpb $0,offThread_breakFlags(%eax) # anything to do? 20581 movl rFP, OUT_ARG1(%esp) 20582 je 1f # reload rIBASE & resume if not 20583 movl %eax, OUT_ARG2(%esp) 20584 call dvmCheckBefore # (dPC, dFP, self) 20585 movl rSELF, %eax 205861: 20587 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 20588 jmp *dvmAsmInstructionStart+(349*4) 20589 20590/* ------------------------------ */ 20591.L_ALT_OP_UNUSED_5EFF: /* 0x15e */ 20592/* File: x86/alt_stub.S */ 20593/* 20594 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 20595 * any interesting requests and then jump to the real instruction 20596 * handler. Unlike the Arm handler, we can't do this as a tail call 20597 * because rIBASE is caller save and we need to reload it. 20598 * 20599 * Note that unlike in the Arm implementation, we should never arrive 20600 * here with a zero breakFlag because we always refresh rIBASE on 20601 * return. 20602 */ 20603 EXPORT_PC 20604 movl rSELF, %eax 20605 movl rPC, OUT_ARG0(%esp) 20606 cmpb $0,offThread_breakFlags(%eax) # anything to do? 20607 movl rFP, OUT_ARG1(%esp) 20608 je 1f # reload rIBASE & resume if not 20609 movl %eax, OUT_ARG2(%esp) 20610 call dvmCheckBefore # (dPC, dFP, self) 20611 movl rSELF, %eax 206121: 20613 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 20614 jmp *dvmAsmInstructionStart+(350*4) 20615 20616/* ------------------------------ */ 20617.L_ALT_OP_UNUSED_5FFF: /* 0x15f */ 20618/* File: x86/alt_stub.S */ 20619/* 20620 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 20621 * any interesting requests and then jump to the real instruction 20622 * handler. Unlike the Arm handler, we can't do this as a tail call 20623 * because rIBASE is caller save and we need to reload it. 20624 * 20625 * Note that unlike in the Arm implementation, we should never arrive 20626 * here with a zero breakFlag because we always refresh rIBASE on 20627 * return. 20628 */ 20629 EXPORT_PC 20630 movl rSELF, %eax 20631 movl rPC, OUT_ARG0(%esp) 20632 cmpb $0,offThread_breakFlags(%eax) # anything to do? 20633 movl rFP, OUT_ARG1(%esp) 20634 je 1f # reload rIBASE & resume if not 20635 movl %eax, OUT_ARG2(%esp) 20636 call dvmCheckBefore # (dPC, dFP, self) 20637 movl rSELF, %eax 206381: 20639 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 20640 jmp *dvmAsmInstructionStart+(351*4) 20641 20642/* ------------------------------ */ 20643.L_ALT_OP_UNUSED_60FF: /* 0x160 */ 20644/* File: x86/alt_stub.S */ 20645/* 20646 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 20647 * any interesting requests and then jump to the real instruction 20648 * handler. Unlike the Arm handler, we can't do this as a tail call 20649 * because rIBASE is caller save and we need to reload it. 20650 * 20651 * Note that unlike in the Arm implementation, we should never arrive 20652 * here with a zero breakFlag because we always refresh rIBASE on 20653 * return. 20654 */ 20655 EXPORT_PC 20656 movl rSELF, %eax 20657 movl rPC, OUT_ARG0(%esp) 20658 cmpb $0,offThread_breakFlags(%eax) # anything to do? 20659 movl rFP, OUT_ARG1(%esp) 20660 je 1f # reload rIBASE & resume if not 20661 movl %eax, OUT_ARG2(%esp) 20662 call dvmCheckBefore # (dPC, dFP, self) 20663 movl rSELF, %eax 206641: 20665 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 20666 jmp *dvmAsmInstructionStart+(352*4) 20667 20668/* ------------------------------ */ 20669.L_ALT_OP_UNUSED_61FF: /* 0x161 */ 20670/* File: x86/alt_stub.S */ 20671/* 20672 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 20673 * any interesting requests and then jump to the real instruction 20674 * handler. Unlike the Arm handler, we can't do this as a tail call 20675 * because rIBASE is caller save and we need to reload it. 20676 * 20677 * Note that unlike in the Arm implementation, we should never arrive 20678 * here with a zero breakFlag because we always refresh rIBASE on 20679 * return. 20680 */ 20681 EXPORT_PC 20682 movl rSELF, %eax 20683 movl rPC, OUT_ARG0(%esp) 20684 cmpb $0,offThread_breakFlags(%eax) # anything to do? 20685 movl rFP, OUT_ARG1(%esp) 20686 je 1f # reload rIBASE & resume if not 20687 movl %eax, OUT_ARG2(%esp) 20688 call dvmCheckBefore # (dPC, dFP, self) 20689 movl rSELF, %eax 206901: 20691 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 20692 jmp *dvmAsmInstructionStart+(353*4) 20693 20694/* ------------------------------ */ 20695.L_ALT_OP_UNUSED_62FF: /* 0x162 */ 20696/* File: x86/alt_stub.S */ 20697/* 20698 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 20699 * any interesting requests and then jump to the real instruction 20700 * handler. Unlike the Arm handler, we can't do this as a tail call 20701 * because rIBASE is caller save and we need to reload it. 20702 * 20703 * Note that unlike in the Arm implementation, we should never arrive 20704 * here with a zero breakFlag because we always refresh rIBASE on 20705 * return. 20706 */ 20707 EXPORT_PC 20708 movl rSELF, %eax 20709 movl rPC, OUT_ARG0(%esp) 20710 cmpb $0,offThread_breakFlags(%eax) # anything to do? 20711 movl rFP, OUT_ARG1(%esp) 20712 je 1f # reload rIBASE & resume if not 20713 movl %eax, OUT_ARG2(%esp) 20714 call dvmCheckBefore # (dPC, dFP, self) 20715 movl rSELF, %eax 207161: 20717 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 20718 jmp *dvmAsmInstructionStart+(354*4) 20719 20720/* ------------------------------ */ 20721.L_ALT_OP_UNUSED_63FF: /* 0x163 */ 20722/* File: x86/alt_stub.S */ 20723/* 20724 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 20725 * any interesting requests and then jump to the real instruction 20726 * handler. Unlike the Arm handler, we can't do this as a tail call 20727 * because rIBASE is caller save and we need to reload it. 20728 * 20729 * Note that unlike in the Arm implementation, we should never arrive 20730 * here with a zero breakFlag because we always refresh rIBASE on 20731 * return. 20732 */ 20733 EXPORT_PC 20734 movl rSELF, %eax 20735 movl rPC, OUT_ARG0(%esp) 20736 cmpb $0,offThread_breakFlags(%eax) # anything to do? 20737 movl rFP, OUT_ARG1(%esp) 20738 je 1f # reload rIBASE & resume if not 20739 movl %eax, OUT_ARG2(%esp) 20740 call dvmCheckBefore # (dPC, dFP, self) 20741 movl rSELF, %eax 207421: 20743 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 20744 jmp *dvmAsmInstructionStart+(355*4) 20745 20746/* ------------------------------ */ 20747.L_ALT_OP_UNUSED_64FF: /* 0x164 */ 20748/* File: x86/alt_stub.S */ 20749/* 20750 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 20751 * any interesting requests and then jump to the real instruction 20752 * handler. Unlike the Arm handler, we can't do this as a tail call 20753 * because rIBASE is caller save and we need to reload it. 20754 * 20755 * Note that unlike in the Arm implementation, we should never arrive 20756 * here with a zero breakFlag because we always refresh rIBASE on 20757 * return. 20758 */ 20759 EXPORT_PC 20760 movl rSELF, %eax 20761 movl rPC, OUT_ARG0(%esp) 20762 cmpb $0,offThread_breakFlags(%eax) # anything to do? 20763 movl rFP, OUT_ARG1(%esp) 20764 je 1f # reload rIBASE & resume if not 20765 movl %eax, OUT_ARG2(%esp) 20766 call dvmCheckBefore # (dPC, dFP, self) 20767 movl rSELF, %eax 207681: 20769 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 20770 jmp *dvmAsmInstructionStart+(356*4) 20771 20772/* ------------------------------ */ 20773.L_ALT_OP_UNUSED_65FF: /* 0x165 */ 20774/* File: x86/alt_stub.S */ 20775/* 20776 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 20777 * any interesting requests and then jump to the real instruction 20778 * handler. Unlike the Arm handler, we can't do this as a tail call 20779 * because rIBASE is caller save and we need to reload it. 20780 * 20781 * Note that unlike in the Arm implementation, we should never arrive 20782 * here with a zero breakFlag because we always refresh rIBASE on 20783 * return. 20784 */ 20785 EXPORT_PC 20786 movl rSELF, %eax 20787 movl rPC, OUT_ARG0(%esp) 20788 cmpb $0,offThread_breakFlags(%eax) # anything to do? 20789 movl rFP, OUT_ARG1(%esp) 20790 je 1f # reload rIBASE & resume if not 20791 movl %eax, OUT_ARG2(%esp) 20792 call dvmCheckBefore # (dPC, dFP, self) 20793 movl rSELF, %eax 207941: 20795 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 20796 jmp *dvmAsmInstructionStart+(357*4) 20797 20798/* ------------------------------ */ 20799.L_ALT_OP_UNUSED_66FF: /* 0x166 */ 20800/* File: x86/alt_stub.S */ 20801/* 20802 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 20803 * any interesting requests and then jump to the real instruction 20804 * handler. Unlike the Arm handler, we can't do this as a tail call 20805 * because rIBASE is caller save and we need to reload it. 20806 * 20807 * Note that unlike in the Arm implementation, we should never arrive 20808 * here with a zero breakFlag because we always refresh rIBASE on 20809 * return. 20810 */ 20811 EXPORT_PC 20812 movl rSELF, %eax 20813 movl rPC, OUT_ARG0(%esp) 20814 cmpb $0,offThread_breakFlags(%eax) # anything to do? 20815 movl rFP, OUT_ARG1(%esp) 20816 je 1f # reload rIBASE & resume if not 20817 movl %eax, OUT_ARG2(%esp) 20818 call dvmCheckBefore # (dPC, dFP, self) 20819 movl rSELF, %eax 208201: 20821 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 20822 jmp *dvmAsmInstructionStart+(358*4) 20823 20824/* ------------------------------ */ 20825.L_ALT_OP_UNUSED_67FF: /* 0x167 */ 20826/* File: x86/alt_stub.S */ 20827/* 20828 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 20829 * any interesting requests and then jump to the real instruction 20830 * handler. Unlike the Arm handler, we can't do this as a tail call 20831 * because rIBASE is caller save and we need to reload it. 20832 * 20833 * Note that unlike in the Arm implementation, we should never arrive 20834 * here with a zero breakFlag because we always refresh rIBASE on 20835 * return. 20836 */ 20837 EXPORT_PC 20838 movl rSELF, %eax 20839 movl rPC, OUT_ARG0(%esp) 20840 cmpb $0,offThread_breakFlags(%eax) # anything to do? 20841 movl rFP, OUT_ARG1(%esp) 20842 je 1f # reload rIBASE & resume if not 20843 movl %eax, OUT_ARG2(%esp) 20844 call dvmCheckBefore # (dPC, dFP, self) 20845 movl rSELF, %eax 208461: 20847 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 20848 jmp *dvmAsmInstructionStart+(359*4) 20849 20850/* ------------------------------ */ 20851.L_ALT_OP_UNUSED_68FF: /* 0x168 */ 20852/* File: x86/alt_stub.S */ 20853/* 20854 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 20855 * any interesting requests and then jump to the real instruction 20856 * handler. Unlike the Arm handler, we can't do this as a tail call 20857 * because rIBASE is caller save and we need to reload it. 20858 * 20859 * Note that unlike in the Arm implementation, we should never arrive 20860 * here with a zero breakFlag because we always refresh rIBASE on 20861 * return. 20862 */ 20863 EXPORT_PC 20864 movl rSELF, %eax 20865 movl rPC, OUT_ARG0(%esp) 20866 cmpb $0,offThread_breakFlags(%eax) # anything to do? 20867 movl rFP, OUT_ARG1(%esp) 20868 je 1f # reload rIBASE & resume if not 20869 movl %eax, OUT_ARG2(%esp) 20870 call dvmCheckBefore # (dPC, dFP, self) 20871 movl rSELF, %eax 208721: 20873 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 20874 jmp *dvmAsmInstructionStart+(360*4) 20875 20876/* ------------------------------ */ 20877.L_ALT_OP_UNUSED_69FF: /* 0x169 */ 20878/* File: x86/alt_stub.S */ 20879/* 20880 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 20881 * any interesting requests and then jump to the real instruction 20882 * handler. Unlike the Arm handler, we can't do this as a tail call 20883 * because rIBASE is caller save and we need to reload it. 20884 * 20885 * Note that unlike in the Arm implementation, we should never arrive 20886 * here with a zero breakFlag because we always refresh rIBASE on 20887 * return. 20888 */ 20889 EXPORT_PC 20890 movl rSELF, %eax 20891 movl rPC, OUT_ARG0(%esp) 20892 cmpb $0,offThread_breakFlags(%eax) # anything to do? 20893 movl rFP, OUT_ARG1(%esp) 20894 je 1f # reload rIBASE & resume if not 20895 movl %eax, OUT_ARG2(%esp) 20896 call dvmCheckBefore # (dPC, dFP, self) 20897 movl rSELF, %eax 208981: 20899 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 20900 jmp *dvmAsmInstructionStart+(361*4) 20901 20902/* ------------------------------ */ 20903.L_ALT_OP_UNUSED_6AFF: /* 0x16a */ 20904/* File: x86/alt_stub.S */ 20905/* 20906 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 20907 * any interesting requests and then jump to the real instruction 20908 * handler. Unlike the Arm handler, we can't do this as a tail call 20909 * because rIBASE is caller save and we need to reload it. 20910 * 20911 * Note that unlike in the Arm implementation, we should never arrive 20912 * here with a zero breakFlag because we always refresh rIBASE on 20913 * return. 20914 */ 20915 EXPORT_PC 20916 movl rSELF, %eax 20917 movl rPC, OUT_ARG0(%esp) 20918 cmpb $0,offThread_breakFlags(%eax) # anything to do? 20919 movl rFP, OUT_ARG1(%esp) 20920 je 1f # reload rIBASE & resume if not 20921 movl %eax, OUT_ARG2(%esp) 20922 call dvmCheckBefore # (dPC, dFP, self) 20923 movl rSELF, %eax 209241: 20925 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 20926 jmp *dvmAsmInstructionStart+(362*4) 20927 20928/* ------------------------------ */ 20929.L_ALT_OP_UNUSED_6BFF: /* 0x16b */ 20930/* File: x86/alt_stub.S */ 20931/* 20932 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 20933 * any interesting requests and then jump to the real instruction 20934 * handler. Unlike the Arm handler, we can't do this as a tail call 20935 * because rIBASE is caller save and we need to reload it. 20936 * 20937 * Note that unlike in the Arm implementation, we should never arrive 20938 * here with a zero breakFlag because we always refresh rIBASE on 20939 * return. 20940 */ 20941 EXPORT_PC 20942 movl rSELF, %eax 20943 movl rPC, OUT_ARG0(%esp) 20944 cmpb $0,offThread_breakFlags(%eax) # anything to do? 20945 movl rFP, OUT_ARG1(%esp) 20946 je 1f # reload rIBASE & resume if not 20947 movl %eax, OUT_ARG2(%esp) 20948 call dvmCheckBefore # (dPC, dFP, self) 20949 movl rSELF, %eax 209501: 20951 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 20952 jmp *dvmAsmInstructionStart+(363*4) 20953 20954/* ------------------------------ */ 20955.L_ALT_OP_UNUSED_6CFF: /* 0x16c */ 20956/* File: x86/alt_stub.S */ 20957/* 20958 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 20959 * any interesting requests and then jump to the real instruction 20960 * handler. Unlike the Arm handler, we can't do this as a tail call 20961 * because rIBASE is caller save and we need to reload it. 20962 * 20963 * Note that unlike in the Arm implementation, we should never arrive 20964 * here with a zero breakFlag because we always refresh rIBASE on 20965 * return. 20966 */ 20967 EXPORT_PC 20968 movl rSELF, %eax 20969 movl rPC, OUT_ARG0(%esp) 20970 cmpb $0,offThread_breakFlags(%eax) # anything to do? 20971 movl rFP, OUT_ARG1(%esp) 20972 je 1f # reload rIBASE & resume if not 20973 movl %eax, OUT_ARG2(%esp) 20974 call dvmCheckBefore # (dPC, dFP, self) 20975 movl rSELF, %eax 209761: 20977 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 20978 jmp *dvmAsmInstructionStart+(364*4) 20979 20980/* ------------------------------ */ 20981.L_ALT_OP_UNUSED_6DFF: /* 0x16d */ 20982/* File: x86/alt_stub.S */ 20983/* 20984 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 20985 * any interesting requests and then jump to the real instruction 20986 * handler. Unlike the Arm handler, we can't do this as a tail call 20987 * because rIBASE is caller save and we need to reload it. 20988 * 20989 * Note that unlike in the Arm implementation, we should never arrive 20990 * here with a zero breakFlag because we always refresh rIBASE on 20991 * return. 20992 */ 20993 EXPORT_PC 20994 movl rSELF, %eax 20995 movl rPC, OUT_ARG0(%esp) 20996 cmpb $0,offThread_breakFlags(%eax) # anything to do? 20997 movl rFP, OUT_ARG1(%esp) 20998 je 1f # reload rIBASE & resume if not 20999 movl %eax, OUT_ARG2(%esp) 21000 call dvmCheckBefore # (dPC, dFP, self) 21001 movl rSELF, %eax 210021: 21003 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 21004 jmp *dvmAsmInstructionStart+(365*4) 21005 21006/* ------------------------------ */ 21007.L_ALT_OP_UNUSED_6EFF: /* 0x16e */ 21008/* File: x86/alt_stub.S */ 21009/* 21010 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 21011 * any interesting requests and then jump to the real instruction 21012 * handler. Unlike the Arm handler, we can't do this as a tail call 21013 * because rIBASE is caller save and we need to reload it. 21014 * 21015 * Note that unlike in the Arm implementation, we should never arrive 21016 * here with a zero breakFlag because we always refresh rIBASE on 21017 * return. 21018 */ 21019 EXPORT_PC 21020 movl rSELF, %eax 21021 movl rPC, OUT_ARG0(%esp) 21022 cmpb $0,offThread_breakFlags(%eax) # anything to do? 21023 movl rFP, OUT_ARG1(%esp) 21024 je 1f # reload rIBASE & resume if not 21025 movl %eax, OUT_ARG2(%esp) 21026 call dvmCheckBefore # (dPC, dFP, self) 21027 movl rSELF, %eax 210281: 21029 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 21030 jmp *dvmAsmInstructionStart+(366*4) 21031 21032/* ------------------------------ */ 21033.L_ALT_OP_UNUSED_6FFF: /* 0x16f */ 21034/* File: x86/alt_stub.S */ 21035/* 21036 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 21037 * any interesting requests and then jump to the real instruction 21038 * handler. Unlike the Arm handler, we can't do this as a tail call 21039 * because rIBASE is caller save and we need to reload it. 21040 * 21041 * Note that unlike in the Arm implementation, we should never arrive 21042 * here with a zero breakFlag because we always refresh rIBASE on 21043 * return. 21044 */ 21045 EXPORT_PC 21046 movl rSELF, %eax 21047 movl rPC, OUT_ARG0(%esp) 21048 cmpb $0,offThread_breakFlags(%eax) # anything to do? 21049 movl rFP, OUT_ARG1(%esp) 21050 je 1f # reload rIBASE & resume if not 21051 movl %eax, OUT_ARG2(%esp) 21052 call dvmCheckBefore # (dPC, dFP, self) 21053 movl rSELF, %eax 210541: 21055 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 21056 jmp *dvmAsmInstructionStart+(367*4) 21057 21058/* ------------------------------ */ 21059.L_ALT_OP_UNUSED_70FF: /* 0x170 */ 21060/* File: x86/alt_stub.S */ 21061/* 21062 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 21063 * any interesting requests and then jump to the real instruction 21064 * handler. Unlike the Arm handler, we can't do this as a tail call 21065 * because rIBASE is caller save and we need to reload it. 21066 * 21067 * Note that unlike in the Arm implementation, we should never arrive 21068 * here with a zero breakFlag because we always refresh rIBASE on 21069 * return. 21070 */ 21071 EXPORT_PC 21072 movl rSELF, %eax 21073 movl rPC, OUT_ARG0(%esp) 21074 cmpb $0,offThread_breakFlags(%eax) # anything to do? 21075 movl rFP, OUT_ARG1(%esp) 21076 je 1f # reload rIBASE & resume if not 21077 movl %eax, OUT_ARG2(%esp) 21078 call dvmCheckBefore # (dPC, dFP, self) 21079 movl rSELF, %eax 210801: 21081 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 21082 jmp *dvmAsmInstructionStart+(368*4) 21083 21084/* ------------------------------ */ 21085.L_ALT_OP_UNUSED_71FF: /* 0x171 */ 21086/* File: x86/alt_stub.S */ 21087/* 21088 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 21089 * any interesting requests and then jump to the real instruction 21090 * handler. Unlike the Arm handler, we can't do this as a tail call 21091 * because rIBASE is caller save and we need to reload it. 21092 * 21093 * Note that unlike in the Arm implementation, we should never arrive 21094 * here with a zero breakFlag because we always refresh rIBASE on 21095 * return. 21096 */ 21097 EXPORT_PC 21098 movl rSELF, %eax 21099 movl rPC, OUT_ARG0(%esp) 21100 cmpb $0,offThread_breakFlags(%eax) # anything to do? 21101 movl rFP, OUT_ARG1(%esp) 21102 je 1f # reload rIBASE & resume if not 21103 movl %eax, OUT_ARG2(%esp) 21104 call dvmCheckBefore # (dPC, dFP, self) 21105 movl rSELF, %eax 211061: 21107 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 21108 jmp *dvmAsmInstructionStart+(369*4) 21109 21110/* ------------------------------ */ 21111.L_ALT_OP_UNUSED_72FF: /* 0x172 */ 21112/* File: x86/alt_stub.S */ 21113/* 21114 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 21115 * any interesting requests and then jump to the real instruction 21116 * handler. Unlike the Arm handler, we can't do this as a tail call 21117 * because rIBASE is caller save and we need to reload it. 21118 * 21119 * Note that unlike in the Arm implementation, we should never arrive 21120 * here with a zero breakFlag because we always refresh rIBASE on 21121 * return. 21122 */ 21123 EXPORT_PC 21124 movl rSELF, %eax 21125 movl rPC, OUT_ARG0(%esp) 21126 cmpb $0,offThread_breakFlags(%eax) # anything to do? 21127 movl rFP, OUT_ARG1(%esp) 21128 je 1f # reload rIBASE & resume if not 21129 movl %eax, OUT_ARG2(%esp) 21130 call dvmCheckBefore # (dPC, dFP, self) 21131 movl rSELF, %eax 211321: 21133 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 21134 jmp *dvmAsmInstructionStart+(370*4) 21135 21136/* ------------------------------ */ 21137.L_ALT_OP_UNUSED_73FF: /* 0x173 */ 21138/* File: x86/alt_stub.S */ 21139/* 21140 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 21141 * any interesting requests and then jump to the real instruction 21142 * handler. Unlike the Arm handler, we can't do this as a tail call 21143 * because rIBASE is caller save and we need to reload it. 21144 * 21145 * Note that unlike in the Arm implementation, we should never arrive 21146 * here with a zero breakFlag because we always refresh rIBASE on 21147 * return. 21148 */ 21149 EXPORT_PC 21150 movl rSELF, %eax 21151 movl rPC, OUT_ARG0(%esp) 21152 cmpb $0,offThread_breakFlags(%eax) # anything to do? 21153 movl rFP, OUT_ARG1(%esp) 21154 je 1f # reload rIBASE & resume if not 21155 movl %eax, OUT_ARG2(%esp) 21156 call dvmCheckBefore # (dPC, dFP, self) 21157 movl rSELF, %eax 211581: 21159 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 21160 jmp *dvmAsmInstructionStart+(371*4) 21161 21162/* ------------------------------ */ 21163.L_ALT_OP_UNUSED_74FF: /* 0x174 */ 21164/* File: x86/alt_stub.S */ 21165/* 21166 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 21167 * any interesting requests and then jump to the real instruction 21168 * handler. Unlike the Arm handler, we can't do this as a tail call 21169 * because rIBASE is caller save and we need to reload it. 21170 * 21171 * Note that unlike in the Arm implementation, we should never arrive 21172 * here with a zero breakFlag because we always refresh rIBASE on 21173 * return. 21174 */ 21175 EXPORT_PC 21176 movl rSELF, %eax 21177 movl rPC, OUT_ARG0(%esp) 21178 cmpb $0,offThread_breakFlags(%eax) # anything to do? 21179 movl rFP, OUT_ARG1(%esp) 21180 je 1f # reload rIBASE & resume if not 21181 movl %eax, OUT_ARG2(%esp) 21182 call dvmCheckBefore # (dPC, dFP, self) 21183 movl rSELF, %eax 211841: 21185 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 21186 jmp *dvmAsmInstructionStart+(372*4) 21187 21188/* ------------------------------ */ 21189.L_ALT_OP_UNUSED_75FF: /* 0x175 */ 21190/* File: x86/alt_stub.S */ 21191/* 21192 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 21193 * any interesting requests and then jump to the real instruction 21194 * handler. Unlike the Arm handler, we can't do this as a tail call 21195 * because rIBASE is caller save and we need to reload it. 21196 * 21197 * Note that unlike in the Arm implementation, we should never arrive 21198 * here with a zero breakFlag because we always refresh rIBASE on 21199 * return. 21200 */ 21201 EXPORT_PC 21202 movl rSELF, %eax 21203 movl rPC, OUT_ARG0(%esp) 21204 cmpb $0,offThread_breakFlags(%eax) # anything to do? 21205 movl rFP, OUT_ARG1(%esp) 21206 je 1f # reload rIBASE & resume if not 21207 movl %eax, OUT_ARG2(%esp) 21208 call dvmCheckBefore # (dPC, dFP, self) 21209 movl rSELF, %eax 212101: 21211 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 21212 jmp *dvmAsmInstructionStart+(373*4) 21213 21214/* ------------------------------ */ 21215.L_ALT_OP_UNUSED_76FF: /* 0x176 */ 21216/* File: x86/alt_stub.S */ 21217/* 21218 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 21219 * any interesting requests and then jump to the real instruction 21220 * handler. Unlike the Arm handler, we can't do this as a tail call 21221 * because rIBASE is caller save and we need to reload it. 21222 * 21223 * Note that unlike in the Arm implementation, we should never arrive 21224 * here with a zero breakFlag because we always refresh rIBASE on 21225 * return. 21226 */ 21227 EXPORT_PC 21228 movl rSELF, %eax 21229 movl rPC, OUT_ARG0(%esp) 21230 cmpb $0,offThread_breakFlags(%eax) # anything to do? 21231 movl rFP, OUT_ARG1(%esp) 21232 je 1f # reload rIBASE & resume if not 21233 movl %eax, OUT_ARG2(%esp) 21234 call dvmCheckBefore # (dPC, dFP, self) 21235 movl rSELF, %eax 212361: 21237 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 21238 jmp *dvmAsmInstructionStart+(374*4) 21239 21240/* ------------------------------ */ 21241.L_ALT_OP_UNUSED_77FF: /* 0x177 */ 21242/* File: x86/alt_stub.S */ 21243/* 21244 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 21245 * any interesting requests and then jump to the real instruction 21246 * handler. Unlike the Arm handler, we can't do this as a tail call 21247 * because rIBASE is caller save and we need to reload it. 21248 * 21249 * Note that unlike in the Arm implementation, we should never arrive 21250 * here with a zero breakFlag because we always refresh rIBASE on 21251 * return. 21252 */ 21253 EXPORT_PC 21254 movl rSELF, %eax 21255 movl rPC, OUT_ARG0(%esp) 21256 cmpb $0,offThread_breakFlags(%eax) # anything to do? 21257 movl rFP, OUT_ARG1(%esp) 21258 je 1f # reload rIBASE & resume if not 21259 movl %eax, OUT_ARG2(%esp) 21260 call dvmCheckBefore # (dPC, dFP, self) 21261 movl rSELF, %eax 212621: 21263 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 21264 jmp *dvmAsmInstructionStart+(375*4) 21265 21266/* ------------------------------ */ 21267.L_ALT_OP_UNUSED_78FF: /* 0x178 */ 21268/* File: x86/alt_stub.S */ 21269/* 21270 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 21271 * any interesting requests and then jump to the real instruction 21272 * handler. Unlike the Arm handler, we can't do this as a tail call 21273 * because rIBASE is caller save and we need to reload it. 21274 * 21275 * Note that unlike in the Arm implementation, we should never arrive 21276 * here with a zero breakFlag because we always refresh rIBASE on 21277 * return. 21278 */ 21279 EXPORT_PC 21280 movl rSELF, %eax 21281 movl rPC, OUT_ARG0(%esp) 21282 cmpb $0,offThread_breakFlags(%eax) # anything to do? 21283 movl rFP, OUT_ARG1(%esp) 21284 je 1f # reload rIBASE & resume if not 21285 movl %eax, OUT_ARG2(%esp) 21286 call dvmCheckBefore # (dPC, dFP, self) 21287 movl rSELF, %eax 212881: 21289 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 21290 jmp *dvmAsmInstructionStart+(376*4) 21291 21292/* ------------------------------ */ 21293.L_ALT_OP_UNUSED_79FF: /* 0x179 */ 21294/* File: x86/alt_stub.S */ 21295/* 21296 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 21297 * any interesting requests and then jump to the real instruction 21298 * handler. Unlike the Arm handler, we can't do this as a tail call 21299 * because rIBASE is caller save and we need to reload it. 21300 * 21301 * Note that unlike in the Arm implementation, we should never arrive 21302 * here with a zero breakFlag because we always refresh rIBASE on 21303 * return. 21304 */ 21305 EXPORT_PC 21306 movl rSELF, %eax 21307 movl rPC, OUT_ARG0(%esp) 21308 cmpb $0,offThread_breakFlags(%eax) # anything to do? 21309 movl rFP, OUT_ARG1(%esp) 21310 je 1f # reload rIBASE & resume if not 21311 movl %eax, OUT_ARG2(%esp) 21312 call dvmCheckBefore # (dPC, dFP, self) 21313 movl rSELF, %eax 213141: 21315 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 21316 jmp *dvmAsmInstructionStart+(377*4) 21317 21318/* ------------------------------ */ 21319.L_ALT_OP_UNUSED_7AFF: /* 0x17a */ 21320/* File: x86/alt_stub.S */ 21321/* 21322 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 21323 * any interesting requests and then jump to the real instruction 21324 * handler. Unlike the Arm handler, we can't do this as a tail call 21325 * because rIBASE is caller save and we need to reload it. 21326 * 21327 * Note that unlike in the Arm implementation, we should never arrive 21328 * here with a zero breakFlag because we always refresh rIBASE on 21329 * return. 21330 */ 21331 EXPORT_PC 21332 movl rSELF, %eax 21333 movl rPC, OUT_ARG0(%esp) 21334 cmpb $0,offThread_breakFlags(%eax) # anything to do? 21335 movl rFP, OUT_ARG1(%esp) 21336 je 1f # reload rIBASE & resume if not 21337 movl %eax, OUT_ARG2(%esp) 21338 call dvmCheckBefore # (dPC, dFP, self) 21339 movl rSELF, %eax 213401: 21341 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 21342 jmp *dvmAsmInstructionStart+(378*4) 21343 21344/* ------------------------------ */ 21345.L_ALT_OP_UNUSED_7BFF: /* 0x17b */ 21346/* File: x86/alt_stub.S */ 21347/* 21348 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 21349 * any interesting requests and then jump to the real instruction 21350 * handler. Unlike the Arm handler, we can't do this as a tail call 21351 * because rIBASE is caller save and we need to reload it. 21352 * 21353 * Note that unlike in the Arm implementation, we should never arrive 21354 * here with a zero breakFlag because we always refresh rIBASE on 21355 * return. 21356 */ 21357 EXPORT_PC 21358 movl rSELF, %eax 21359 movl rPC, OUT_ARG0(%esp) 21360 cmpb $0,offThread_breakFlags(%eax) # anything to do? 21361 movl rFP, OUT_ARG1(%esp) 21362 je 1f # reload rIBASE & resume if not 21363 movl %eax, OUT_ARG2(%esp) 21364 call dvmCheckBefore # (dPC, dFP, self) 21365 movl rSELF, %eax 213661: 21367 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 21368 jmp *dvmAsmInstructionStart+(379*4) 21369 21370/* ------------------------------ */ 21371.L_ALT_OP_UNUSED_7CFF: /* 0x17c */ 21372/* File: x86/alt_stub.S */ 21373/* 21374 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 21375 * any interesting requests and then jump to the real instruction 21376 * handler. Unlike the Arm handler, we can't do this as a tail call 21377 * because rIBASE is caller save and we need to reload it. 21378 * 21379 * Note that unlike in the Arm implementation, we should never arrive 21380 * here with a zero breakFlag because we always refresh rIBASE on 21381 * return. 21382 */ 21383 EXPORT_PC 21384 movl rSELF, %eax 21385 movl rPC, OUT_ARG0(%esp) 21386 cmpb $0,offThread_breakFlags(%eax) # anything to do? 21387 movl rFP, OUT_ARG1(%esp) 21388 je 1f # reload rIBASE & resume if not 21389 movl %eax, OUT_ARG2(%esp) 21390 call dvmCheckBefore # (dPC, dFP, self) 21391 movl rSELF, %eax 213921: 21393 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 21394 jmp *dvmAsmInstructionStart+(380*4) 21395 21396/* ------------------------------ */ 21397.L_ALT_OP_UNUSED_7DFF: /* 0x17d */ 21398/* File: x86/alt_stub.S */ 21399/* 21400 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 21401 * any interesting requests and then jump to the real instruction 21402 * handler. Unlike the Arm handler, we can't do this as a tail call 21403 * because rIBASE is caller save and we need to reload it. 21404 * 21405 * Note that unlike in the Arm implementation, we should never arrive 21406 * here with a zero breakFlag because we always refresh rIBASE on 21407 * return. 21408 */ 21409 EXPORT_PC 21410 movl rSELF, %eax 21411 movl rPC, OUT_ARG0(%esp) 21412 cmpb $0,offThread_breakFlags(%eax) # anything to do? 21413 movl rFP, OUT_ARG1(%esp) 21414 je 1f # reload rIBASE & resume if not 21415 movl %eax, OUT_ARG2(%esp) 21416 call dvmCheckBefore # (dPC, dFP, self) 21417 movl rSELF, %eax 214181: 21419 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 21420 jmp *dvmAsmInstructionStart+(381*4) 21421 21422/* ------------------------------ */ 21423.L_ALT_OP_UNUSED_7EFF: /* 0x17e */ 21424/* File: x86/alt_stub.S */ 21425/* 21426 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 21427 * any interesting requests and then jump to the real instruction 21428 * handler. Unlike the Arm handler, we can't do this as a tail call 21429 * because rIBASE is caller save and we need to reload it. 21430 * 21431 * Note that unlike in the Arm implementation, we should never arrive 21432 * here with a zero breakFlag because we always refresh rIBASE on 21433 * return. 21434 */ 21435 EXPORT_PC 21436 movl rSELF, %eax 21437 movl rPC, OUT_ARG0(%esp) 21438 cmpb $0,offThread_breakFlags(%eax) # anything to do? 21439 movl rFP, OUT_ARG1(%esp) 21440 je 1f # reload rIBASE & resume if not 21441 movl %eax, OUT_ARG2(%esp) 21442 call dvmCheckBefore # (dPC, dFP, self) 21443 movl rSELF, %eax 214441: 21445 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 21446 jmp *dvmAsmInstructionStart+(382*4) 21447 21448/* ------------------------------ */ 21449.L_ALT_OP_UNUSED_7FFF: /* 0x17f */ 21450/* File: x86/alt_stub.S */ 21451/* 21452 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 21453 * any interesting requests and then jump to the real instruction 21454 * handler. Unlike the Arm handler, we can't do this as a tail call 21455 * because rIBASE is caller save and we need to reload it. 21456 * 21457 * Note that unlike in the Arm implementation, we should never arrive 21458 * here with a zero breakFlag because we always refresh rIBASE on 21459 * return. 21460 */ 21461 EXPORT_PC 21462 movl rSELF, %eax 21463 movl rPC, OUT_ARG0(%esp) 21464 cmpb $0,offThread_breakFlags(%eax) # anything to do? 21465 movl rFP, OUT_ARG1(%esp) 21466 je 1f # reload rIBASE & resume if not 21467 movl %eax, OUT_ARG2(%esp) 21468 call dvmCheckBefore # (dPC, dFP, self) 21469 movl rSELF, %eax 214701: 21471 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 21472 jmp *dvmAsmInstructionStart+(383*4) 21473 21474/* ------------------------------ */ 21475.L_ALT_OP_UNUSED_80FF: /* 0x180 */ 21476/* File: x86/alt_stub.S */ 21477/* 21478 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 21479 * any interesting requests and then jump to the real instruction 21480 * handler. Unlike the Arm handler, we can't do this as a tail call 21481 * because rIBASE is caller save and we need to reload it. 21482 * 21483 * Note that unlike in the Arm implementation, we should never arrive 21484 * here with a zero breakFlag because we always refresh rIBASE on 21485 * return. 21486 */ 21487 EXPORT_PC 21488 movl rSELF, %eax 21489 movl rPC, OUT_ARG0(%esp) 21490 cmpb $0,offThread_breakFlags(%eax) # anything to do? 21491 movl rFP, OUT_ARG1(%esp) 21492 je 1f # reload rIBASE & resume if not 21493 movl %eax, OUT_ARG2(%esp) 21494 call dvmCheckBefore # (dPC, dFP, self) 21495 movl rSELF, %eax 214961: 21497 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 21498 jmp *dvmAsmInstructionStart+(384*4) 21499 21500/* ------------------------------ */ 21501.L_ALT_OP_UNUSED_81FF: /* 0x181 */ 21502/* File: x86/alt_stub.S */ 21503/* 21504 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 21505 * any interesting requests and then jump to the real instruction 21506 * handler. Unlike the Arm handler, we can't do this as a tail call 21507 * because rIBASE is caller save and we need to reload it. 21508 * 21509 * Note that unlike in the Arm implementation, we should never arrive 21510 * here with a zero breakFlag because we always refresh rIBASE on 21511 * return. 21512 */ 21513 EXPORT_PC 21514 movl rSELF, %eax 21515 movl rPC, OUT_ARG0(%esp) 21516 cmpb $0,offThread_breakFlags(%eax) # anything to do? 21517 movl rFP, OUT_ARG1(%esp) 21518 je 1f # reload rIBASE & resume if not 21519 movl %eax, OUT_ARG2(%esp) 21520 call dvmCheckBefore # (dPC, dFP, self) 21521 movl rSELF, %eax 215221: 21523 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 21524 jmp *dvmAsmInstructionStart+(385*4) 21525 21526/* ------------------------------ */ 21527.L_ALT_OP_UNUSED_82FF: /* 0x182 */ 21528/* File: x86/alt_stub.S */ 21529/* 21530 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 21531 * any interesting requests and then jump to the real instruction 21532 * handler. Unlike the Arm handler, we can't do this as a tail call 21533 * because rIBASE is caller save and we need to reload it. 21534 * 21535 * Note that unlike in the Arm implementation, we should never arrive 21536 * here with a zero breakFlag because we always refresh rIBASE on 21537 * return. 21538 */ 21539 EXPORT_PC 21540 movl rSELF, %eax 21541 movl rPC, OUT_ARG0(%esp) 21542 cmpb $0,offThread_breakFlags(%eax) # anything to do? 21543 movl rFP, OUT_ARG1(%esp) 21544 je 1f # reload rIBASE & resume if not 21545 movl %eax, OUT_ARG2(%esp) 21546 call dvmCheckBefore # (dPC, dFP, self) 21547 movl rSELF, %eax 215481: 21549 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 21550 jmp *dvmAsmInstructionStart+(386*4) 21551 21552/* ------------------------------ */ 21553.L_ALT_OP_UNUSED_83FF: /* 0x183 */ 21554/* File: x86/alt_stub.S */ 21555/* 21556 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 21557 * any interesting requests and then jump to the real instruction 21558 * handler. Unlike the Arm handler, we can't do this as a tail call 21559 * because rIBASE is caller save and we need to reload it. 21560 * 21561 * Note that unlike in the Arm implementation, we should never arrive 21562 * here with a zero breakFlag because we always refresh rIBASE on 21563 * return. 21564 */ 21565 EXPORT_PC 21566 movl rSELF, %eax 21567 movl rPC, OUT_ARG0(%esp) 21568 cmpb $0,offThread_breakFlags(%eax) # anything to do? 21569 movl rFP, OUT_ARG1(%esp) 21570 je 1f # reload rIBASE & resume if not 21571 movl %eax, OUT_ARG2(%esp) 21572 call dvmCheckBefore # (dPC, dFP, self) 21573 movl rSELF, %eax 215741: 21575 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 21576 jmp *dvmAsmInstructionStart+(387*4) 21577 21578/* ------------------------------ */ 21579.L_ALT_OP_UNUSED_84FF: /* 0x184 */ 21580/* File: x86/alt_stub.S */ 21581/* 21582 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 21583 * any interesting requests and then jump to the real instruction 21584 * handler. Unlike the Arm handler, we can't do this as a tail call 21585 * because rIBASE is caller save and we need to reload it. 21586 * 21587 * Note that unlike in the Arm implementation, we should never arrive 21588 * here with a zero breakFlag because we always refresh rIBASE on 21589 * return. 21590 */ 21591 EXPORT_PC 21592 movl rSELF, %eax 21593 movl rPC, OUT_ARG0(%esp) 21594 cmpb $0,offThread_breakFlags(%eax) # anything to do? 21595 movl rFP, OUT_ARG1(%esp) 21596 je 1f # reload rIBASE & resume if not 21597 movl %eax, OUT_ARG2(%esp) 21598 call dvmCheckBefore # (dPC, dFP, self) 21599 movl rSELF, %eax 216001: 21601 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 21602 jmp *dvmAsmInstructionStart+(388*4) 21603 21604/* ------------------------------ */ 21605.L_ALT_OP_UNUSED_85FF: /* 0x185 */ 21606/* File: x86/alt_stub.S */ 21607/* 21608 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 21609 * any interesting requests and then jump to the real instruction 21610 * handler. Unlike the Arm handler, we can't do this as a tail call 21611 * because rIBASE is caller save and we need to reload it. 21612 * 21613 * Note that unlike in the Arm implementation, we should never arrive 21614 * here with a zero breakFlag because we always refresh rIBASE on 21615 * return. 21616 */ 21617 EXPORT_PC 21618 movl rSELF, %eax 21619 movl rPC, OUT_ARG0(%esp) 21620 cmpb $0,offThread_breakFlags(%eax) # anything to do? 21621 movl rFP, OUT_ARG1(%esp) 21622 je 1f # reload rIBASE & resume if not 21623 movl %eax, OUT_ARG2(%esp) 21624 call dvmCheckBefore # (dPC, dFP, self) 21625 movl rSELF, %eax 216261: 21627 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 21628 jmp *dvmAsmInstructionStart+(389*4) 21629 21630/* ------------------------------ */ 21631.L_ALT_OP_UNUSED_86FF: /* 0x186 */ 21632/* File: x86/alt_stub.S */ 21633/* 21634 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 21635 * any interesting requests and then jump to the real instruction 21636 * handler. Unlike the Arm handler, we can't do this as a tail call 21637 * because rIBASE is caller save and we need to reload it. 21638 * 21639 * Note that unlike in the Arm implementation, we should never arrive 21640 * here with a zero breakFlag because we always refresh rIBASE on 21641 * return. 21642 */ 21643 EXPORT_PC 21644 movl rSELF, %eax 21645 movl rPC, OUT_ARG0(%esp) 21646 cmpb $0,offThread_breakFlags(%eax) # anything to do? 21647 movl rFP, OUT_ARG1(%esp) 21648 je 1f # reload rIBASE & resume if not 21649 movl %eax, OUT_ARG2(%esp) 21650 call dvmCheckBefore # (dPC, dFP, self) 21651 movl rSELF, %eax 216521: 21653 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 21654 jmp *dvmAsmInstructionStart+(390*4) 21655 21656/* ------------------------------ */ 21657.L_ALT_OP_UNUSED_87FF: /* 0x187 */ 21658/* File: x86/alt_stub.S */ 21659/* 21660 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 21661 * any interesting requests and then jump to the real instruction 21662 * handler. Unlike the Arm handler, we can't do this as a tail call 21663 * because rIBASE is caller save and we need to reload it. 21664 * 21665 * Note that unlike in the Arm implementation, we should never arrive 21666 * here with a zero breakFlag because we always refresh rIBASE on 21667 * return. 21668 */ 21669 EXPORT_PC 21670 movl rSELF, %eax 21671 movl rPC, OUT_ARG0(%esp) 21672 cmpb $0,offThread_breakFlags(%eax) # anything to do? 21673 movl rFP, OUT_ARG1(%esp) 21674 je 1f # reload rIBASE & resume if not 21675 movl %eax, OUT_ARG2(%esp) 21676 call dvmCheckBefore # (dPC, dFP, self) 21677 movl rSELF, %eax 216781: 21679 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 21680 jmp *dvmAsmInstructionStart+(391*4) 21681 21682/* ------------------------------ */ 21683.L_ALT_OP_UNUSED_88FF: /* 0x188 */ 21684/* File: x86/alt_stub.S */ 21685/* 21686 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 21687 * any interesting requests and then jump to the real instruction 21688 * handler. Unlike the Arm handler, we can't do this as a tail call 21689 * because rIBASE is caller save and we need to reload it. 21690 * 21691 * Note that unlike in the Arm implementation, we should never arrive 21692 * here with a zero breakFlag because we always refresh rIBASE on 21693 * return. 21694 */ 21695 EXPORT_PC 21696 movl rSELF, %eax 21697 movl rPC, OUT_ARG0(%esp) 21698 cmpb $0,offThread_breakFlags(%eax) # anything to do? 21699 movl rFP, OUT_ARG1(%esp) 21700 je 1f # reload rIBASE & resume if not 21701 movl %eax, OUT_ARG2(%esp) 21702 call dvmCheckBefore # (dPC, dFP, self) 21703 movl rSELF, %eax 217041: 21705 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 21706 jmp *dvmAsmInstructionStart+(392*4) 21707 21708/* ------------------------------ */ 21709.L_ALT_OP_UNUSED_89FF: /* 0x189 */ 21710/* File: x86/alt_stub.S */ 21711/* 21712 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 21713 * any interesting requests and then jump to the real instruction 21714 * handler. Unlike the Arm handler, we can't do this as a tail call 21715 * because rIBASE is caller save and we need to reload it. 21716 * 21717 * Note that unlike in the Arm implementation, we should never arrive 21718 * here with a zero breakFlag because we always refresh rIBASE on 21719 * return. 21720 */ 21721 EXPORT_PC 21722 movl rSELF, %eax 21723 movl rPC, OUT_ARG0(%esp) 21724 cmpb $0,offThread_breakFlags(%eax) # anything to do? 21725 movl rFP, OUT_ARG1(%esp) 21726 je 1f # reload rIBASE & resume if not 21727 movl %eax, OUT_ARG2(%esp) 21728 call dvmCheckBefore # (dPC, dFP, self) 21729 movl rSELF, %eax 217301: 21731 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 21732 jmp *dvmAsmInstructionStart+(393*4) 21733 21734/* ------------------------------ */ 21735.L_ALT_OP_UNUSED_8AFF: /* 0x18a */ 21736/* File: x86/alt_stub.S */ 21737/* 21738 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 21739 * any interesting requests and then jump to the real instruction 21740 * handler. Unlike the Arm handler, we can't do this as a tail call 21741 * because rIBASE is caller save and we need to reload it. 21742 * 21743 * Note that unlike in the Arm implementation, we should never arrive 21744 * here with a zero breakFlag because we always refresh rIBASE on 21745 * return. 21746 */ 21747 EXPORT_PC 21748 movl rSELF, %eax 21749 movl rPC, OUT_ARG0(%esp) 21750 cmpb $0,offThread_breakFlags(%eax) # anything to do? 21751 movl rFP, OUT_ARG1(%esp) 21752 je 1f # reload rIBASE & resume if not 21753 movl %eax, OUT_ARG2(%esp) 21754 call dvmCheckBefore # (dPC, dFP, self) 21755 movl rSELF, %eax 217561: 21757 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 21758 jmp *dvmAsmInstructionStart+(394*4) 21759 21760/* ------------------------------ */ 21761.L_ALT_OP_UNUSED_8BFF: /* 0x18b */ 21762/* File: x86/alt_stub.S */ 21763/* 21764 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 21765 * any interesting requests and then jump to the real instruction 21766 * handler. Unlike the Arm handler, we can't do this as a tail call 21767 * because rIBASE is caller save and we need to reload it. 21768 * 21769 * Note that unlike in the Arm implementation, we should never arrive 21770 * here with a zero breakFlag because we always refresh rIBASE on 21771 * return. 21772 */ 21773 EXPORT_PC 21774 movl rSELF, %eax 21775 movl rPC, OUT_ARG0(%esp) 21776 cmpb $0,offThread_breakFlags(%eax) # anything to do? 21777 movl rFP, OUT_ARG1(%esp) 21778 je 1f # reload rIBASE & resume if not 21779 movl %eax, OUT_ARG2(%esp) 21780 call dvmCheckBefore # (dPC, dFP, self) 21781 movl rSELF, %eax 217821: 21783 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 21784 jmp *dvmAsmInstructionStart+(395*4) 21785 21786/* ------------------------------ */ 21787.L_ALT_OP_UNUSED_8CFF: /* 0x18c */ 21788/* File: x86/alt_stub.S */ 21789/* 21790 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 21791 * any interesting requests and then jump to the real instruction 21792 * handler. Unlike the Arm handler, we can't do this as a tail call 21793 * because rIBASE is caller save and we need to reload it. 21794 * 21795 * Note that unlike in the Arm implementation, we should never arrive 21796 * here with a zero breakFlag because we always refresh rIBASE on 21797 * return. 21798 */ 21799 EXPORT_PC 21800 movl rSELF, %eax 21801 movl rPC, OUT_ARG0(%esp) 21802 cmpb $0,offThread_breakFlags(%eax) # anything to do? 21803 movl rFP, OUT_ARG1(%esp) 21804 je 1f # reload rIBASE & resume if not 21805 movl %eax, OUT_ARG2(%esp) 21806 call dvmCheckBefore # (dPC, dFP, self) 21807 movl rSELF, %eax 218081: 21809 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 21810 jmp *dvmAsmInstructionStart+(396*4) 21811 21812/* ------------------------------ */ 21813.L_ALT_OP_UNUSED_8DFF: /* 0x18d */ 21814/* File: x86/alt_stub.S */ 21815/* 21816 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 21817 * any interesting requests and then jump to the real instruction 21818 * handler. Unlike the Arm handler, we can't do this as a tail call 21819 * because rIBASE is caller save and we need to reload it. 21820 * 21821 * Note that unlike in the Arm implementation, we should never arrive 21822 * here with a zero breakFlag because we always refresh rIBASE on 21823 * return. 21824 */ 21825 EXPORT_PC 21826 movl rSELF, %eax 21827 movl rPC, OUT_ARG0(%esp) 21828 cmpb $0,offThread_breakFlags(%eax) # anything to do? 21829 movl rFP, OUT_ARG1(%esp) 21830 je 1f # reload rIBASE & resume if not 21831 movl %eax, OUT_ARG2(%esp) 21832 call dvmCheckBefore # (dPC, dFP, self) 21833 movl rSELF, %eax 218341: 21835 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 21836 jmp *dvmAsmInstructionStart+(397*4) 21837 21838/* ------------------------------ */ 21839.L_ALT_OP_UNUSED_8EFF: /* 0x18e */ 21840/* File: x86/alt_stub.S */ 21841/* 21842 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 21843 * any interesting requests and then jump to the real instruction 21844 * handler. Unlike the Arm handler, we can't do this as a tail call 21845 * because rIBASE is caller save and we need to reload it. 21846 * 21847 * Note that unlike in the Arm implementation, we should never arrive 21848 * here with a zero breakFlag because we always refresh rIBASE on 21849 * return. 21850 */ 21851 EXPORT_PC 21852 movl rSELF, %eax 21853 movl rPC, OUT_ARG0(%esp) 21854 cmpb $0,offThread_breakFlags(%eax) # anything to do? 21855 movl rFP, OUT_ARG1(%esp) 21856 je 1f # reload rIBASE & resume if not 21857 movl %eax, OUT_ARG2(%esp) 21858 call dvmCheckBefore # (dPC, dFP, self) 21859 movl rSELF, %eax 218601: 21861 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 21862 jmp *dvmAsmInstructionStart+(398*4) 21863 21864/* ------------------------------ */ 21865.L_ALT_OP_UNUSED_8FFF: /* 0x18f */ 21866/* File: x86/alt_stub.S */ 21867/* 21868 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 21869 * any interesting requests and then jump to the real instruction 21870 * handler. Unlike the Arm handler, we can't do this as a tail call 21871 * because rIBASE is caller save and we need to reload it. 21872 * 21873 * Note that unlike in the Arm implementation, we should never arrive 21874 * here with a zero breakFlag because we always refresh rIBASE on 21875 * return. 21876 */ 21877 EXPORT_PC 21878 movl rSELF, %eax 21879 movl rPC, OUT_ARG0(%esp) 21880 cmpb $0,offThread_breakFlags(%eax) # anything to do? 21881 movl rFP, OUT_ARG1(%esp) 21882 je 1f # reload rIBASE & resume if not 21883 movl %eax, OUT_ARG2(%esp) 21884 call dvmCheckBefore # (dPC, dFP, self) 21885 movl rSELF, %eax 218861: 21887 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 21888 jmp *dvmAsmInstructionStart+(399*4) 21889 21890/* ------------------------------ */ 21891.L_ALT_OP_UNUSED_90FF: /* 0x190 */ 21892/* File: x86/alt_stub.S */ 21893/* 21894 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 21895 * any interesting requests and then jump to the real instruction 21896 * handler. Unlike the Arm handler, we can't do this as a tail call 21897 * because rIBASE is caller save and we need to reload it. 21898 * 21899 * Note that unlike in the Arm implementation, we should never arrive 21900 * here with a zero breakFlag because we always refresh rIBASE on 21901 * return. 21902 */ 21903 EXPORT_PC 21904 movl rSELF, %eax 21905 movl rPC, OUT_ARG0(%esp) 21906 cmpb $0,offThread_breakFlags(%eax) # anything to do? 21907 movl rFP, OUT_ARG1(%esp) 21908 je 1f # reload rIBASE & resume if not 21909 movl %eax, OUT_ARG2(%esp) 21910 call dvmCheckBefore # (dPC, dFP, self) 21911 movl rSELF, %eax 219121: 21913 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 21914 jmp *dvmAsmInstructionStart+(400*4) 21915 21916/* ------------------------------ */ 21917.L_ALT_OP_UNUSED_91FF: /* 0x191 */ 21918/* File: x86/alt_stub.S */ 21919/* 21920 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 21921 * any interesting requests and then jump to the real instruction 21922 * handler. Unlike the Arm handler, we can't do this as a tail call 21923 * because rIBASE is caller save and we need to reload it. 21924 * 21925 * Note that unlike in the Arm implementation, we should never arrive 21926 * here with a zero breakFlag because we always refresh rIBASE on 21927 * return. 21928 */ 21929 EXPORT_PC 21930 movl rSELF, %eax 21931 movl rPC, OUT_ARG0(%esp) 21932 cmpb $0,offThread_breakFlags(%eax) # anything to do? 21933 movl rFP, OUT_ARG1(%esp) 21934 je 1f # reload rIBASE & resume if not 21935 movl %eax, OUT_ARG2(%esp) 21936 call dvmCheckBefore # (dPC, dFP, self) 21937 movl rSELF, %eax 219381: 21939 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 21940 jmp *dvmAsmInstructionStart+(401*4) 21941 21942/* ------------------------------ */ 21943.L_ALT_OP_UNUSED_92FF: /* 0x192 */ 21944/* File: x86/alt_stub.S */ 21945/* 21946 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 21947 * any interesting requests and then jump to the real instruction 21948 * handler. Unlike the Arm handler, we can't do this as a tail call 21949 * because rIBASE is caller save and we need to reload it. 21950 * 21951 * Note that unlike in the Arm implementation, we should never arrive 21952 * here with a zero breakFlag because we always refresh rIBASE on 21953 * return. 21954 */ 21955 EXPORT_PC 21956 movl rSELF, %eax 21957 movl rPC, OUT_ARG0(%esp) 21958 cmpb $0,offThread_breakFlags(%eax) # anything to do? 21959 movl rFP, OUT_ARG1(%esp) 21960 je 1f # reload rIBASE & resume if not 21961 movl %eax, OUT_ARG2(%esp) 21962 call dvmCheckBefore # (dPC, dFP, self) 21963 movl rSELF, %eax 219641: 21965 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 21966 jmp *dvmAsmInstructionStart+(402*4) 21967 21968/* ------------------------------ */ 21969.L_ALT_OP_UNUSED_93FF: /* 0x193 */ 21970/* File: x86/alt_stub.S */ 21971/* 21972 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 21973 * any interesting requests and then jump to the real instruction 21974 * handler. Unlike the Arm handler, we can't do this as a tail call 21975 * because rIBASE is caller save and we need to reload it. 21976 * 21977 * Note that unlike in the Arm implementation, we should never arrive 21978 * here with a zero breakFlag because we always refresh rIBASE on 21979 * return. 21980 */ 21981 EXPORT_PC 21982 movl rSELF, %eax 21983 movl rPC, OUT_ARG0(%esp) 21984 cmpb $0,offThread_breakFlags(%eax) # anything to do? 21985 movl rFP, OUT_ARG1(%esp) 21986 je 1f # reload rIBASE & resume if not 21987 movl %eax, OUT_ARG2(%esp) 21988 call dvmCheckBefore # (dPC, dFP, self) 21989 movl rSELF, %eax 219901: 21991 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 21992 jmp *dvmAsmInstructionStart+(403*4) 21993 21994/* ------------------------------ */ 21995.L_ALT_OP_UNUSED_94FF: /* 0x194 */ 21996/* File: x86/alt_stub.S */ 21997/* 21998 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 21999 * any interesting requests and then jump to the real instruction 22000 * handler. Unlike the Arm handler, we can't do this as a tail call 22001 * because rIBASE is caller save and we need to reload it. 22002 * 22003 * Note that unlike in the Arm implementation, we should never arrive 22004 * here with a zero breakFlag because we always refresh rIBASE on 22005 * return. 22006 */ 22007 EXPORT_PC 22008 movl rSELF, %eax 22009 movl rPC, OUT_ARG0(%esp) 22010 cmpb $0,offThread_breakFlags(%eax) # anything to do? 22011 movl rFP, OUT_ARG1(%esp) 22012 je 1f # reload rIBASE & resume if not 22013 movl %eax, OUT_ARG2(%esp) 22014 call dvmCheckBefore # (dPC, dFP, self) 22015 movl rSELF, %eax 220161: 22017 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 22018 jmp *dvmAsmInstructionStart+(404*4) 22019 22020/* ------------------------------ */ 22021.L_ALT_OP_UNUSED_95FF: /* 0x195 */ 22022/* File: x86/alt_stub.S */ 22023/* 22024 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 22025 * any interesting requests and then jump to the real instruction 22026 * handler. Unlike the Arm handler, we can't do this as a tail call 22027 * because rIBASE is caller save and we need to reload it. 22028 * 22029 * Note that unlike in the Arm implementation, we should never arrive 22030 * here with a zero breakFlag because we always refresh rIBASE on 22031 * return. 22032 */ 22033 EXPORT_PC 22034 movl rSELF, %eax 22035 movl rPC, OUT_ARG0(%esp) 22036 cmpb $0,offThread_breakFlags(%eax) # anything to do? 22037 movl rFP, OUT_ARG1(%esp) 22038 je 1f # reload rIBASE & resume if not 22039 movl %eax, OUT_ARG2(%esp) 22040 call dvmCheckBefore # (dPC, dFP, self) 22041 movl rSELF, %eax 220421: 22043 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 22044 jmp *dvmAsmInstructionStart+(405*4) 22045 22046/* ------------------------------ */ 22047.L_ALT_OP_UNUSED_96FF: /* 0x196 */ 22048/* File: x86/alt_stub.S */ 22049/* 22050 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 22051 * any interesting requests and then jump to the real instruction 22052 * handler. Unlike the Arm handler, we can't do this as a tail call 22053 * because rIBASE is caller save and we need to reload it. 22054 * 22055 * Note that unlike in the Arm implementation, we should never arrive 22056 * here with a zero breakFlag because we always refresh rIBASE on 22057 * return. 22058 */ 22059 EXPORT_PC 22060 movl rSELF, %eax 22061 movl rPC, OUT_ARG0(%esp) 22062 cmpb $0,offThread_breakFlags(%eax) # anything to do? 22063 movl rFP, OUT_ARG1(%esp) 22064 je 1f # reload rIBASE & resume if not 22065 movl %eax, OUT_ARG2(%esp) 22066 call dvmCheckBefore # (dPC, dFP, self) 22067 movl rSELF, %eax 220681: 22069 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 22070 jmp *dvmAsmInstructionStart+(406*4) 22071 22072/* ------------------------------ */ 22073.L_ALT_OP_UNUSED_97FF: /* 0x197 */ 22074/* File: x86/alt_stub.S */ 22075/* 22076 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 22077 * any interesting requests and then jump to the real instruction 22078 * handler. Unlike the Arm handler, we can't do this as a tail call 22079 * because rIBASE is caller save and we need to reload it. 22080 * 22081 * Note that unlike in the Arm implementation, we should never arrive 22082 * here with a zero breakFlag because we always refresh rIBASE on 22083 * return. 22084 */ 22085 EXPORT_PC 22086 movl rSELF, %eax 22087 movl rPC, OUT_ARG0(%esp) 22088 cmpb $0,offThread_breakFlags(%eax) # anything to do? 22089 movl rFP, OUT_ARG1(%esp) 22090 je 1f # reload rIBASE & resume if not 22091 movl %eax, OUT_ARG2(%esp) 22092 call dvmCheckBefore # (dPC, dFP, self) 22093 movl rSELF, %eax 220941: 22095 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 22096 jmp *dvmAsmInstructionStart+(407*4) 22097 22098/* ------------------------------ */ 22099.L_ALT_OP_UNUSED_98FF: /* 0x198 */ 22100/* File: x86/alt_stub.S */ 22101/* 22102 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 22103 * any interesting requests and then jump to the real instruction 22104 * handler. Unlike the Arm handler, we can't do this as a tail call 22105 * because rIBASE is caller save and we need to reload it. 22106 * 22107 * Note that unlike in the Arm implementation, we should never arrive 22108 * here with a zero breakFlag because we always refresh rIBASE on 22109 * return. 22110 */ 22111 EXPORT_PC 22112 movl rSELF, %eax 22113 movl rPC, OUT_ARG0(%esp) 22114 cmpb $0,offThread_breakFlags(%eax) # anything to do? 22115 movl rFP, OUT_ARG1(%esp) 22116 je 1f # reload rIBASE & resume if not 22117 movl %eax, OUT_ARG2(%esp) 22118 call dvmCheckBefore # (dPC, dFP, self) 22119 movl rSELF, %eax 221201: 22121 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 22122 jmp *dvmAsmInstructionStart+(408*4) 22123 22124/* ------------------------------ */ 22125.L_ALT_OP_UNUSED_99FF: /* 0x199 */ 22126/* File: x86/alt_stub.S */ 22127/* 22128 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 22129 * any interesting requests and then jump to the real instruction 22130 * handler. Unlike the Arm handler, we can't do this as a tail call 22131 * because rIBASE is caller save and we need to reload it. 22132 * 22133 * Note that unlike in the Arm implementation, we should never arrive 22134 * here with a zero breakFlag because we always refresh rIBASE on 22135 * return. 22136 */ 22137 EXPORT_PC 22138 movl rSELF, %eax 22139 movl rPC, OUT_ARG0(%esp) 22140 cmpb $0,offThread_breakFlags(%eax) # anything to do? 22141 movl rFP, OUT_ARG1(%esp) 22142 je 1f # reload rIBASE & resume if not 22143 movl %eax, OUT_ARG2(%esp) 22144 call dvmCheckBefore # (dPC, dFP, self) 22145 movl rSELF, %eax 221461: 22147 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 22148 jmp *dvmAsmInstructionStart+(409*4) 22149 22150/* ------------------------------ */ 22151.L_ALT_OP_UNUSED_9AFF: /* 0x19a */ 22152/* File: x86/alt_stub.S */ 22153/* 22154 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 22155 * any interesting requests and then jump to the real instruction 22156 * handler. Unlike the Arm handler, we can't do this as a tail call 22157 * because rIBASE is caller save and we need to reload it. 22158 * 22159 * Note that unlike in the Arm implementation, we should never arrive 22160 * here with a zero breakFlag because we always refresh rIBASE on 22161 * return. 22162 */ 22163 EXPORT_PC 22164 movl rSELF, %eax 22165 movl rPC, OUT_ARG0(%esp) 22166 cmpb $0,offThread_breakFlags(%eax) # anything to do? 22167 movl rFP, OUT_ARG1(%esp) 22168 je 1f # reload rIBASE & resume if not 22169 movl %eax, OUT_ARG2(%esp) 22170 call dvmCheckBefore # (dPC, dFP, self) 22171 movl rSELF, %eax 221721: 22173 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 22174 jmp *dvmAsmInstructionStart+(410*4) 22175 22176/* ------------------------------ */ 22177.L_ALT_OP_UNUSED_9BFF: /* 0x19b */ 22178/* File: x86/alt_stub.S */ 22179/* 22180 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 22181 * any interesting requests and then jump to the real instruction 22182 * handler. Unlike the Arm handler, we can't do this as a tail call 22183 * because rIBASE is caller save and we need to reload it. 22184 * 22185 * Note that unlike in the Arm implementation, we should never arrive 22186 * here with a zero breakFlag because we always refresh rIBASE on 22187 * return. 22188 */ 22189 EXPORT_PC 22190 movl rSELF, %eax 22191 movl rPC, OUT_ARG0(%esp) 22192 cmpb $0,offThread_breakFlags(%eax) # anything to do? 22193 movl rFP, OUT_ARG1(%esp) 22194 je 1f # reload rIBASE & resume if not 22195 movl %eax, OUT_ARG2(%esp) 22196 call dvmCheckBefore # (dPC, dFP, self) 22197 movl rSELF, %eax 221981: 22199 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 22200 jmp *dvmAsmInstructionStart+(411*4) 22201 22202/* ------------------------------ */ 22203.L_ALT_OP_UNUSED_9CFF: /* 0x19c */ 22204/* File: x86/alt_stub.S */ 22205/* 22206 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 22207 * any interesting requests and then jump to the real instruction 22208 * handler. Unlike the Arm handler, we can't do this as a tail call 22209 * because rIBASE is caller save and we need to reload it. 22210 * 22211 * Note that unlike in the Arm implementation, we should never arrive 22212 * here with a zero breakFlag because we always refresh rIBASE on 22213 * return. 22214 */ 22215 EXPORT_PC 22216 movl rSELF, %eax 22217 movl rPC, OUT_ARG0(%esp) 22218 cmpb $0,offThread_breakFlags(%eax) # anything to do? 22219 movl rFP, OUT_ARG1(%esp) 22220 je 1f # reload rIBASE & resume if not 22221 movl %eax, OUT_ARG2(%esp) 22222 call dvmCheckBefore # (dPC, dFP, self) 22223 movl rSELF, %eax 222241: 22225 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 22226 jmp *dvmAsmInstructionStart+(412*4) 22227 22228/* ------------------------------ */ 22229.L_ALT_OP_UNUSED_9DFF: /* 0x19d */ 22230/* File: x86/alt_stub.S */ 22231/* 22232 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 22233 * any interesting requests and then jump to the real instruction 22234 * handler. Unlike the Arm handler, we can't do this as a tail call 22235 * because rIBASE is caller save and we need to reload it. 22236 * 22237 * Note that unlike in the Arm implementation, we should never arrive 22238 * here with a zero breakFlag because we always refresh rIBASE on 22239 * return. 22240 */ 22241 EXPORT_PC 22242 movl rSELF, %eax 22243 movl rPC, OUT_ARG0(%esp) 22244 cmpb $0,offThread_breakFlags(%eax) # anything to do? 22245 movl rFP, OUT_ARG1(%esp) 22246 je 1f # reload rIBASE & resume if not 22247 movl %eax, OUT_ARG2(%esp) 22248 call dvmCheckBefore # (dPC, dFP, self) 22249 movl rSELF, %eax 222501: 22251 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 22252 jmp *dvmAsmInstructionStart+(413*4) 22253 22254/* ------------------------------ */ 22255.L_ALT_OP_UNUSED_9EFF: /* 0x19e */ 22256/* File: x86/alt_stub.S */ 22257/* 22258 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 22259 * any interesting requests and then jump to the real instruction 22260 * handler. Unlike the Arm handler, we can't do this as a tail call 22261 * because rIBASE is caller save and we need to reload it. 22262 * 22263 * Note that unlike in the Arm implementation, we should never arrive 22264 * here with a zero breakFlag because we always refresh rIBASE on 22265 * return. 22266 */ 22267 EXPORT_PC 22268 movl rSELF, %eax 22269 movl rPC, OUT_ARG0(%esp) 22270 cmpb $0,offThread_breakFlags(%eax) # anything to do? 22271 movl rFP, OUT_ARG1(%esp) 22272 je 1f # reload rIBASE & resume if not 22273 movl %eax, OUT_ARG2(%esp) 22274 call dvmCheckBefore # (dPC, dFP, self) 22275 movl rSELF, %eax 222761: 22277 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 22278 jmp *dvmAsmInstructionStart+(414*4) 22279 22280/* ------------------------------ */ 22281.L_ALT_OP_UNUSED_9FFF: /* 0x19f */ 22282/* File: x86/alt_stub.S */ 22283/* 22284 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 22285 * any interesting requests and then jump to the real instruction 22286 * handler. Unlike the Arm handler, we can't do this as a tail call 22287 * because rIBASE is caller save and we need to reload it. 22288 * 22289 * Note that unlike in the Arm implementation, we should never arrive 22290 * here with a zero breakFlag because we always refresh rIBASE on 22291 * return. 22292 */ 22293 EXPORT_PC 22294 movl rSELF, %eax 22295 movl rPC, OUT_ARG0(%esp) 22296 cmpb $0,offThread_breakFlags(%eax) # anything to do? 22297 movl rFP, OUT_ARG1(%esp) 22298 je 1f # reload rIBASE & resume if not 22299 movl %eax, OUT_ARG2(%esp) 22300 call dvmCheckBefore # (dPC, dFP, self) 22301 movl rSELF, %eax 223021: 22303 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 22304 jmp *dvmAsmInstructionStart+(415*4) 22305 22306/* ------------------------------ */ 22307.L_ALT_OP_UNUSED_A0FF: /* 0x1a0 */ 22308/* File: x86/alt_stub.S */ 22309/* 22310 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 22311 * any interesting requests and then jump to the real instruction 22312 * handler. Unlike the Arm handler, we can't do this as a tail call 22313 * because rIBASE is caller save and we need to reload it. 22314 * 22315 * Note that unlike in the Arm implementation, we should never arrive 22316 * here with a zero breakFlag because we always refresh rIBASE on 22317 * return. 22318 */ 22319 EXPORT_PC 22320 movl rSELF, %eax 22321 movl rPC, OUT_ARG0(%esp) 22322 cmpb $0,offThread_breakFlags(%eax) # anything to do? 22323 movl rFP, OUT_ARG1(%esp) 22324 je 1f # reload rIBASE & resume if not 22325 movl %eax, OUT_ARG2(%esp) 22326 call dvmCheckBefore # (dPC, dFP, self) 22327 movl rSELF, %eax 223281: 22329 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 22330 jmp *dvmAsmInstructionStart+(416*4) 22331 22332/* ------------------------------ */ 22333.L_ALT_OP_UNUSED_A1FF: /* 0x1a1 */ 22334/* File: x86/alt_stub.S */ 22335/* 22336 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 22337 * any interesting requests and then jump to the real instruction 22338 * handler. Unlike the Arm handler, we can't do this as a tail call 22339 * because rIBASE is caller save and we need to reload it. 22340 * 22341 * Note that unlike in the Arm implementation, we should never arrive 22342 * here with a zero breakFlag because we always refresh rIBASE on 22343 * return. 22344 */ 22345 EXPORT_PC 22346 movl rSELF, %eax 22347 movl rPC, OUT_ARG0(%esp) 22348 cmpb $0,offThread_breakFlags(%eax) # anything to do? 22349 movl rFP, OUT_ARG1(%esp) 22350 je 1f # reload rIBASE & resume if not 22351 movl %eax, OUT_ARG2(%esp) 22352 call dvmCheckBefore # (dPC, dFP, self) 22353 movl rSELF, %eax 223541: 22355 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 22356 jmp *dvmAsmInstructionStart+(417*4) 22357 22358/* ------------------------------ */ 22359.L_ALT_OP_UNUSED_A2FF: /* 0x1a2 */ 22360/* File: x86/alt_stub.S */ 22361/* 22362 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 22363 * any interesting requests and then jump to the real instruction 22364 * handler. Unlike the Arm handler, we can't do this as a tail call 22365 * because rIBASE is caller save and we need to reload it. 22366 * 22367 * Note that unlike in the Arm implementation, we should never arrive 22368 * here with a zero breakFlag because we always refresh rIBASE on 22369 * return. 22370 */ 22371 EXPORT_PC 22372 movl rSELF, %eax 22373 movl rPC, OUT_ARG0(%esp) 22374 cmpb $0,offThread_breakFlags(%eax) # anything to do? 22375 movl rFP, OUT_ARG1(%esp) 22376 je 1f # reload rIBASE & resume if not 22377 movl %eax, OUT_ARG2(%esp) 22378 call dvmCheckBefore # (dPC, dFP, self) 22379 movl rSELF, %eax 223801: 22381 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 22382 jmp *dvmAsmInstructionStart+(418*4) 22383 22384/* ------------------------------ */ 22385.L_ALT_OP_UNUSED_A3FF: /* 0x1a3 */ 22386/* File: x86/alt_stub.S */ 22387/* 22388 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 22389 * any interesting requests and then jump to the real instruction 22390 * handler. Unlike the Arm handler, we can't do this as a tail call 22391 * because rIBASE is caller save and we need to reload it. 22392 * 22393 * Note that unlike in the Arm implementation, we should never arrive 22394 * here with a zero breakFlag because we always refresh rIBASE on 22395 * return. 22396 */ 22397 EXPORT_PC 22398 movl rSELF, %eax 22399 movl rPC, OUT_ARG0(%esp) 22400 cmpb $0,offThread_breakFlags(%eax) # anything to do? 22401 movl rFP, OUT_ARG1(%esp) 22402 je 1f # reload rIBASE & resume if not 22403 movl %eax, OUT_ARG2(%esp) 22404 call dvmCheckBefore # (dPC, dFP, self) 22405 movl rSELF, %eax 224061: 22407 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 22408 jmp *dvmAsmInstructionStart+(419*4) 22409 22410/* ------------------------------ */ 22411.L_ALT_OP_UNUSED_A4FF: /* 0x1a4 */ 22412/* File: x86/alt_stub.S */ 22413/* 22414 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 22415 * any interesting requests and then jump to the real instruction 22416 * handler. Unlike the Arm handler, we can't do this as a tail call 22417 * because rIBASE is caller save and we need to reload it. 22418 * 22419 * Note that unlike in the Arm implementation, we should never arrive 22420 * here with a zero breakFlag because we always refresh rIBASE on 22421 * return. 22422 */ 22423 EXPORT_PC 22424 movl rSELF, %eax 22425 movl rPC, OUT_ARG0(%esp) 22426 cmpb $0,offThread_breakFlags(%eax) # anything to do? 22427 movl rFP, OUT_ARG1(%esp) 22428 je 1f # reload rIBASE & resume if not 22429 movl %eax, OUT_ARG2(%esp) 22430 call dvmCheckBefore # (dPC, dFP, self) 22431 movl rSELF, %eax 224321: 22433 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 22434 jmp *dvmAsmInstructionStart+(420*4) 22435 22436/* ------------------------------ */ 22437.L_ALT_OP_UNUSED_A5FF: /* 0x1a5 */ 22438/* File: x86/alt_stub.S */ 22439/* 22440 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 22441 * any interesting requests and then jump to the real instruction 22442 * handler. Unlike the Arm handler, we can't do this as a tail call 22443 * because rIBASE is caller save and we need to reload it. 22444 * 22445 * Note that unlike in the Arm implementation, we should never arrive 22446 * here with a zero breakFlag because we always refresh rIBASE on 22447 * return. 22448 */ 22449 EXPORT_PC 22450 movl rSELF, %eax 22451 movl rPC, OUT_ARG0(%esp) 22452 cmpb $0,offThread_breakFlags(%eax) # anything to do? 22453 movl rFP, OUT_ARG1(%esp) 22454 je 1f # reload rIBASE & resume if not 22455 movl %eax, OUT_ARG2(%esp) 22456 call dvmCheckBefore # (dPC, dFP, self) 22457 movl rSELF, %eax 224581: 22459 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 22460 jmp *dvmAsmInstructionStart+(421*4) 22461 22462/* ------------------------------ */ 22463.L_ALT_OP_UNUSED_A6FF: /* 0x1a6 */ 22464/* File: x86/alt_stub.S */ 22465/* 22466 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 22467 * any interesting requests and then jump to the real instruction 22468 * handler. Unlike the Arm handler, we can't do this as a tail call 22469 * because rIBASE is caller save and we need to reload it. 22470 * 22471 * Note that unlike in the Arm implementation, we should never arrive 22472 * here with a zero breakFlag because we always refresh rIBASE on 22473 * return. 22474 */ 22475 EXPORT_PC 22476 movl rSELF, %eax 22477 movl rPC, OUT_ARG0(%esp) 22478 cmpb $0,offThread_breakFlags(%eax) # anything to do? 22479 movl rFP, OUT_ARG1(%esp) 22480 je 1f # reload rIBASE & resume if not 22481 movl %eax, OUT_ARG2(%esp) 22482 call dvmCheckBefore # (dPC, dFP, self) 22483 movl rSELF, %eax 224841: 22485 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 22486 jmp *dvmAsmInstructionStart+(422*4) 22487 22488/* ------------------------------ */ 22489.L_ALT_OP_UNUSED_A7FF: /* 0x1a7 */ 22490/* File: x86/alt_stub.S */ 22491/* 22492 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 22493 * any interesting requests and then jump to the real instruction 22494 * handler. Unlike the Arm handler, we can't do this as a tail call 22495 * because rIBASE is caller save and we need to reload it. 22496 * 22497 * Note that unlike in the Arm implementation, we should never arrive 22498 * here with a zero breakFlag because we always refresh rIBASE on 22499 * return. 22500 */ 22501 EXPORT_PC 22502 movl rSELF, %eax 22503 movl rPC, OUT_ARG0(%esp) 22504 cmpb $0,offThread_breakFlags(%eax) # anything to do? 22505 movl rFP, OUT_ARG1(%esp) 22506 je 1f # reload rIBASE & resume if not 22507 movl %eax, OUT_ARG2(%esp) 22508 call dvmCheckBefore # (dPC, dFP, self) 22509 movl rSELF, %eax 225101: 22511 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 22512 jmp *dvmAsmInstructionStart+(423*4) 22513 22514/* ------------------------------ */ 22515.L_ALT_OP_UNUSED_A8FF: /* 0x1a8 */ 22516/* File: x86/alt_stub.S */ 22517/* 22518 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 22519 * any interesting requests and then jump to the real instruction 22520 * handler. Unlike the Arm handler, we can't do this as a tail call 22521 * because rIBASE is caller save and we need to reload it. 22522 * 22523 * Note that unlike in the Arm implementation, we should never arrive 22524 * here with a zero breakFlag because we always refresh rIBASE on 22525 * return. 22526 */ 22527 EXPORT_PC 22528 movl rSELF, %eax 22529 movl rPC, OUT_ARG0(%esp) 22530 cmpb $0,offThread_breakFlags(%eax) # anything to do? 22531 movl rFP, OUT_ARG1(%esp) 22532 je 1f # reload rIBASE & resume if not 22533 movl %eax, OUT_ARG2(%esp) 22534 call dvmCheckBefore # (dPC, dFP, self) 22535 movl rSELF, %eax 225361: 22537 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 22538 jmp *dvmAsmInstructionStart+(424*4) 22539 22540/* ------------------------------ */ 22541.L_ALT_OP_UNUSED_A9FF: /* 0x1a9 */ 22542/* File: x86/alt_stub.S */ 22543/* 22544 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 22545 * any interesting requests and then jump to the real instruction 22546 * handler. Unlike the Arm handler, we can't do this as a tail call 22547 * because rIBASE is caller save and we need to reload it. 22548 * 22549 * Note that unlike in the Arm implementation, we should never arrive 22550 * here with a zero breakFlag because we always refresh rIBASE on 22551 * return. 22552 */ 22553 EXPORT_PC 22554 movl rSELF, %eax 22555 movl rPC, OUT_ARG0(%esp) 22556 cmpb $0,offThread_breakFlags(%eax) # anything to do? 22557 movl rFP, OUT_ARG1(%esp) 22558 je 1f # reload rIBASE & resume if not 22559 movl %eax, OUT_ARG2(%esp) 22560 call dvmCheckBefore # (dPC, dFP, self) 22561 movl rSELF, %eax 225621: 22563 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 22564 jmp *dvmAsmInstructionStart+(425*4) 22565 22566/* ------------------------------ */ 22567.L_ALT_OP_UNUSED_AAFF: /* 0x1aa */ 22568/* File: x86/alt_stub.S */ 22569/* 22570 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 22571 * any interesting requests and then jump to the real instruction 22572 * handler. Unlike the Arm handler, we can't do this as a tail call 22573 * because rIBASE is caller save and we need to reload it. 22574 * 22575 * Note that unlike in the Arm implementation, we should never arrive 22576 * here with a zero breakFlag because we always refresh rIBASE on 22577 * return. 22578 */ 22579 EXPORT_PC 22580 movl rSELF, %eax 22581 movl rPC, OUT_ARG0(%esp) 22582 cmpb $0,offThread_breakFlags(%eax) # anything to do? 22583 movl rFP, OUT_ARG1(%esp) 22584 je 1f # reload rIBASE & resume if not 22585 movl %eax, OUT_ARG2(%esp) 22586 call dvmCheckBefore # (dPC, dFP, self) 22587 movl rSELF, %eax 225881: 22589 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 22590 jmp *dvmAsmInstructionStart+(426*4) 22591 22592/* ------------------------------ */ 22593.L_ALT_OP_UNUSED_ABFF: /* 0x1ab */ 22594/* File: x86/alt_stub.S */ 22595/* 22596 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 22597 * any interesting requests and then jump to the real instruction 22598 * handler. Unlike the Arm handler, we can't do this as a tail call 22599 * because rIBASE is caller save and we need to reload it. 22600 * 22601 * Note that unlike in the Arm implementation, we should never arrive 22602 * here with a zero breakFlag because we always refresh rIBASE on 22603 * return. 22604 */ 22605 EXPORT_PC 22606 movl rSELF, %eax 22607 movl rPC, OUT_ARG0(%esp) 22608 cmpb $0,offThread_breakFlags(%eax) # anything to do? 22609 movl rFP, OUT_ARG1(%esp) 22610 je 1f # reload rIBASE & resume if not 22611 movl %eax, OUT_ARG2(%esp) 22612 call dvmCheckBefore # (dPC, dFP, self) 22613 movl rSELF, %eax 226141: 22615 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 22616 jmp *dvmAsmInstructionStart+(427*4) 22617 22618/* ------------------------------ */ 22619.L_ALT_OP_UNUSED_ACFF: /* 0x1ac */ 22620/* File: x86/alt_stub.S */ 22621/* 22622 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 22623 * any interesting requests and then jump to the real instruction 22624 * handler. Unlike the Arm handler, we can't do this as a tail call 22625 * because rIBASE is caller save and we need to reload it. 22626 * 22627 * Note that unlike in the Arm implementation, we should never arrive 22628 * here with a zero breakFlag because we always refresh rIBASE on 22629 * return. 22630 */ 22631 EXPORT_PC 22632 movl rSELF, %eax 22633 movl rPC, OUT_ARG0(%esp) 22634 cmpb $0,offThread_breakFlags(%eax) # anything to do? 22635 movl rFP, OUT_ARG1(%esp) 22636 je 1f # reload rIBASE & resume if not 22637 movl %eax, OUT_ARG2(%esp) 22638 call dvmCheckBefore # (dPC, dFP, self) 22639 movl rSELF, %eax 226401: 22641 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 22642 jmp *dvmAsmInstructionStart+(428*4) 22643 22644/* ------------------------------ */ 22645.L_ALT_OP_UNUSED_ADFF: /* 0x1ad */ 22646/* File: x86/alt_stub.S */ 22647/* 22648 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 22649 * any interesting requests and then jump to the real instruction 22650 * handler. Unlike the Arm handler, we can't do this as a tail call 22651 * because rIBASE is caller save and we need to reload it. 22652 * 22653 * Note that unlike in the Arm implementation, we should never arrive 22654 * here with a zero breakFlag because we always refresh rIBASE on 22655 * return. 22656 */ 22657 EXPORT_PC 22658 movl rSELF, %eax 22659 movl rPC, OUT_ARG0(%esp) 22660 cmpb $0,offThread_breakFlags(%eax) # anything to do? 22661 movl rFP, OUT_ARG1(%esp) 22662 je 1f # reload rIBASE & resume if not 22663 movl %eax, OUT_ARG2(%esp) 22664 call dvmCheckBefore # (dPC, dFP, self) 22665 movl rSELF, %eax 226661: 22667 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 22668 jmp *dvmAsmInstructionStart+(429*4) 22669 22670/* ------------------------------ */ 22671.L_ALT_OP_UNUSED_AEFF: /* 0x1ae */ 22672/* File: x86/alt_stub.S */ 22673/* 22674 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 22675 * any interesting requests and then jump to the real instruction 22676 * handler. Unlike the Arm handler, we can't do this as a tail call 22677 * because rIBASE is caller save and we need to reload it. 22678 * 22679 * Note that unlike in the Arm implementation, we should never arrive 22680 * here with a zero breakFlag because we always refresh rIBASE on 22681 * return. 22682 */ 22683 EXPORT_PC 22684 movl rSELF, %eax 22685 movl rPC, OUT_ARG0(%esp) 22686 cmpb $0,offThread_breakFlags(%eax) # anything to do? 22687 movl rFP, OUT_ARG1(%esp) 22688 je 1f # reload rIBASE & resume if not 22689 movl %eax, OUT_ARG2(%esp) 22690 call dvmCheckBefore # (dPC, dFP, self) 22691 movl rSELF, %eax 226921: 22693 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 22694 jmp *dvmAsmInstructionStart+(430*4) 22695 22696/* ------------------------------ */ 22697.L_ALT_OP_UNUSED_AFFF: /* 0x1af */ 22698/* File: x86/alt_stub.S */ 22699/* 22700 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 22701 * any interesting requests and then jump to the real instruction 22702 * handler. Unlike the Arm handler, we can't do this as a tail call 22703 * because rIBASE is caller save and we need to reload it. 22704 * 22705 * Note that unlike in the Arm implementation, we should never arrive 22706 * here with a zero breakFlag because we always refresh rIBASE on 22707 * return. 22708 */ 22709 EXPORT_PC 22710 movl rSELF, %eax 22711 movl rPC, OUT_ARG0(%esp) 22712 cmpb $0,offThread_breakFlags(%eax) # anything to do? 22713 movl rFP, OUT_ARG1(%esp) 22714 je 1f # reload rIBASE & resume if not 22715 movl %eax, OUT_ARG2(%esp) 22716 call dvmCheckBefore # (dPC, dFP, self) 22717 movl rSELF, %eax 227181: 22719 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 22720 jmp *dvmAsmInstructionStart+(431*4) 22721 22722/* ------------------------------ */ 22723.L_ALT_OP_UNUSED_B0FF: /* 0x1b0 */ 22724/* File: x86/alt_stub.S */ 22725/* 22726 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 22727 * any interesting requests and then jump to the real instruction 22728 * handler. Unlike the Arm handler, we can't do this as a tail call 22729 * because rIBASE is caller save and we need to reload it. 22730 * 22731 * Note that unlike in the Arm implementation, we should never arrive 22732 * here with a zero breakFlag because we always refresh rIBASE on 22733 * return. 22734 */ 22735 EXPORT_PC 22736 movl rSELF, %eax 22737 movl rPC, OUT_ARG0(%esp) 22738 cmpb $0,offThread_breakFlags(%eax) # anything to do? 22739 movl rFP, OUT_ARG1(%esp) 22740 je 1f # reload rIBASE & resume if not 22741 movl %eax, OUT_ARG2(%esp) 22742 call dvmCheckBefore # (dPC, dFP, self) 22743 movl rSELF, %eax 227441: 22745 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 22746 jmp *dvmAsmInstructionStart+(432*4) 22747 22748/* ------------------------------ */ 22749.L_ALT_OP_UNUSED_B1FF: /* 0x1b1 */ 22750/* File: x86/alt_stub.S */ 22751/* 22752 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 22753 * any interesting requests and then jump to the real instruction 22754 * handler. Unlike the Arm handler, we can't do this as a tail call 22755 * because rIBASE is caller save and we need to reload it. 22756 * 22757 * Note that unlike in the Arm implementation, we should never arrive 22758 * here with a zero breakFlag because we always refresh rIBASE on 22759 * return. 22760 */ 22761 EXPORT_PC 22762 movl rSELF, %eax 22763 movl rPC, OUT_ARG0(%esp) 22764 cmpb $0,offThread_breakFlags(%eax) # anything to do? 22765 movl rFP, OUT_ARG1(%esp) 22766 je 1f # reload rIBASE & resume if not 22767 movl %eax, OUT_ARG2(%esp) 22768 call dvmCheckBefore # (dPC, dFP, self) 22769 movl rSELF, %eax 227701: 22771 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 22772 jmp *dvmAsmInstructionStart+(433*4) 22773 22774/* ------------------------------ */ 22775.L_ALT_OP_UNUSED_B2FF: /* 0x1b2 */ 22776/* File: x86/alt_stub.S */ 22777/* 22778 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 22779 * any interesting requests and then jump to the real instruction 22780 * handler. Unlike the Arm handler, we can't do this as a tail call 22781 * because rIBASE is caller save and we need to reload it. 22782 * 22783 * Note that unlike in the Arm implementation, we should never arrive 22784 * here with a zero breakFlag because we always refresh rIBASE on 22785 * return. 22786 */ 22787 EXPORT_PC 22788 movl rSELF, %eax 22789 movl rPC, OUT_ARG0(%esp) 22790 cmpb $0,offThread_breakFlags(%eax) # anything to do? 22791 movl rFP, OUT_ARG1(%esp) 22792 je 1f # reload rIBASE & resume if not 22793 movl %eax, OUT_ARG2(%esp) 22794 call dvmCheckBefore # (dPC, dFP, self) 22795 movl rSELF, %eax 227961: 22797 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 22798 jmp *dvmAsmInstructionStart+(434*4) 22799 22800/* ------------------------------ */ 22801.L_ALT_OP_UNUSED_B3FF: /* 0x1b3 */ 22802/* File: x86/alt_stub.S */ 22803/* 22804 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 22805 * any interesting requests and then jump to the real instruction 22806 * handler. Unlike the Arm handler, we can't do this as a tail call 22807 * because rIBASE is caller save and we need to reload it. 22808 * 22809 * Note that unlike in the Arm implementation, we should never arrive 22810 * here with a zero breakFlag because we always refresh rIBASE on 22811 * return. 22812 */ 22813 EXPORT_PC 22814 movl rSELF, %eax 22815 movl rPC, OUT_ARG0(%esp) 22816 cmpb $0,offThread_breakFlags(%eax) # anything to do? 22817 movl rFP, OUT_ARG1(%esp) 22818 je 1f # reload rIBASE & resume if not 22819 movl %eax, OUT_ARG2(%esp) 22820 call dvmCheckBefore # (dPC, dFP, self) 22821 movl rSELF, %eax 228221: 22823 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 22824 jmp *dvmAsmInstructionStart+(435*4) 22825 22826/* ------------------------------ */ 22827.L_ALT_OP_UNUSED_B4FF: /* 0x1b4 */ 22828/* File: x86/alt_stub.S */ 22829/* 22830 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 22831 * any interesting requests and then jump to the real instruction 22832 * handler. Unlike the Arm handler, we can't do this as a tail call 22833 * because rIBASE is caller save and we need to reload it. 22834 * 22835 * Note that unlike in the Arm implementation, we should never arrive 22836 * here with a zero breakFlag because we always refresh rIBASE on 22837 * return. 22838 */ 22839 EXPORT_PC 22840 movl rSELF, %eax 22841 movl rPC, OUT_ARG0(%esp) 22842 cmpb $0,offThread_breakFlags(%eax) # anything to do? 22843 movl rFP, OUT_ARG1(%esp) 22844 je 1f # reload rIBASE & resume if not 22845 movl %eax, OUT_ARG2(%esp) 22846 call dvmCheckBefore # (dPC, dFP, self) 22847 movl rSELF, %eax 228481: 22849 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 22850 jmp *dvmAsmInstructionStart+(436*4) 22851 22852/* ------------------------------ */ 22853.L_ALT_OP_UNUSED_B5FF: /* 0x1b5 */ 22854/* File: x86/alt_stub.S */ 22855/* 22856 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 22857 * any interesting requests and then jump to the real instruction 22858 * handler. Unlike the Arm handler, we can't do this as a tail call 22859 * because rIBASE is caller save and we need to reload it. 22860 * 22861 * Note that unlike in the Arm implementation, we should never arrive 22862 * here with a zero breakFlag because we always refresh rIBASE on 22863 * return. 22864 */ 22865 EXPORT_PC 22866 movl rSELF, %eax 22867 movl rPC, OUT_ARG0(%esp) 22868 cmpb $0,offThread_breakFlags(%eax) # anything to do? 22869 movl rFP, OUT_ARG1(%esp) 22870 je 1f # reload rIBASE & resume if not 22871 movl %eax, OUT_ARG2(%esp) 22872 call dvmCheckBefore # (dPC, dFP, self) 22873 movl rSELF, %eax 228741: 22875 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 22876 jmp *dvmAsmInstructionStart+(437*4) 22877 22878/* ------------------------------ */ 22879.L_ALT_OP_UNUSED_B6FF: /* 0x1b6 */ 22880/* File: x86/alt_stub.S */ 22881/* 22882 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 22883 * any interesting requests and then jump to the real instruction 22884 * handler. Unlike the Arm handler, we can't do this as a tail call 22885 * because rIBASE is caller save and we need to reload it. 22886 * 22887 * Note that unlike in the Arm implementation, we should never arrive 22888 * here with a zero breakFlag because we always refresh rIBASE on 22889 * return. 22890 */ 22891 EXPORT_PC 22892 movl rSELF, %eax 22893 movl rPC, OUT_ARG0(%esp) 22894 cmpb $0,offThread_breakFlags(%eax) # anything to do? 22895 movl rFP, OUT_ARG1(%esp) 22896 je 1f # reload rIBASE & resume if not 22897 movl %eax, OUT_ARG2(%esp) 22898 call dvmCheckBefore # (dPC, dFP, self) 22899 movl rSELF, %eax 229001: 22901 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 22902 jmp *dvmAsmInstructionStart+(438*4) 22903 22904/* ------------------------------ */ 22905.L_ALT_OP_UNUSED_B7FF: /* 0x1b7 */ 22906/* File: x86/alt_stub.S */ 22907/* 22908 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 22909 * any interesting requests and then jump to the real instruction 22910 * handler. Unlike the Arm handler, we can't do this as a tail call 22911 * because rIBASE is caller save and we need to reload it. 22912 * 22913 * Note that unlike in the Arm implementation, we should never arrive 22914 * here with a zero breakFlag because we always refresh rIBASE on 22915 * return. 22916 */ 22917 EXPORT_PC 22918 movl rSELF, %eax 22919 movl rPC, OUT_ARG0(%esp) 22920 cmpb $0,offThread_breakFlags(%eax) # anything to do? 22921 movl rFP, OUT_ARG1(%esp) 22922 je 1f # reload rIBASE & resume if not 22923 movl %eax, OUT_ARG2(%esp) 22924 call dvmCheckBefore # (dPC, dFP, self) 22925 movl rSELF, %eax 229261: 22927 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 22928 jmp *dvmAsmInstructionStart+(439*4) 22929 22930/* ------------------------------ */ 22931.L_ALT_OP_UNUSED_B8FF: /* 0x1b8 */ 22932/* File: x86/alt_stub.S */ 22933/* 22934 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 22935 * any interesting requests and then jump to the real instruction 22936 * handler. Unlike the Arm handler, we can't do this as a tail call 22937 * because rIBASE is caller save and we need to reload it. 22938 * 22939 * Note that unlike in the Arm implementation, we should never arrive 22940 * here with a zero breakFlag because we always refresh rIBASE on 22941 * return. 22942 */ 22943 EXPORT_PC 22944 movl rSELF, %eax 22945 movl rPC, OUT_ARG0(%esp) 22946 cmpb $0,offThread_breakFlags(%eax) # anything to do? 22947 movl rFP, OUT_ARG1(%esp) 22948 je 1f # reload rIBASE & resume if not 22949 movl %eax, OUT_ARG2(%esp) 22950 call dvmCheckBefore # (dPC, dFP, self) 22951 movl rSELF, %eax 229521: 22953 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 22954 jmp *dvmAsmInstructionStart+(440*4) 22955 22956/* ------------------------------ */ 22957.L_ALT_OP_UNUSED_B9FF: /* 0x1b9 */ 22958/* File: x86/alt_stub.S */ 22959/* 22960 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 22961 * any interesting requests and then jump to the real instruction 22962 * handler. Unlike the Arm handler, we can't do this as a tail call 22963 * because rIBASE is caller save and we need to reload it. 22964 * 22965 * Note that unlike in the Arm implementation, we should never arrive 22966 * here with a zero breakFlag because we always refresh rIBASE on 22967 * return. 22968 */ 22969 EXPORT_PC 22970 movl rSELF, %eax 22971 movl rPC, OUT_ARG0(%esp) 22972 cmpb $0,offThread_breakFlags(%eax) # anything to do? 22973 movl rFP, OUT_ARG1(%esp) 22974 je 1f # reload rIBASE & resume if not 22975 movl %eax, OUT_ARG2(%esp) 22976 call dvmCheckBefore # (dPC, dFP, self) 22977 movl rSELF, %eax 229781: 22979 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 22980 jmp *dvmAsmInstructionStart+(441*4) 22981 22982/* ------------------------------ */ 22983.L_ALT_OP_UNUSED_BAFF: /* 0x1ba */ 22984/* File: x86/alt_stub.S */ 22985/* 22986 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 22987 * any interesting requests and then jump to the real instruction 22988 * handler. Unlike the Arm handler, we can't do this as a tail call 22989 * because rIBASE is caller save and we need to reload it. 22990 * 22991 * Note that unlike in the Arm implementation, we should never arrive 22992 * here with a zero breakFlag because we always refresh rIBASE on 22993 * return. 22994 */ 22995 EXPORT_PC 22996 movl rSELF, %eax 22997 movl rPC, OUT_ARG0(%esp) 22998 cmpb $0,offThread_breakFlags(%eax) # anything to do? 22999 movl rFP, OUT_ARG1(%esp) 23000 je 1f # reload rIBASE & resume if not 23001 movl %eax, OUT_ARG2(%esp) 23002 call dvmCheckBefore # (dPC, dFP, self) 23003 movl rSELF, %eax 230041: 23005 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 23006 jmp *dvmAsmInstructionStart+(442*4) 23007 23008/* ------------------------------ */ 23009.L_ALT_OP_UNUSED_BBFF: /* 0x1bb */ 23010/* File: x86/alt_stub.S */ 23011/* 23012 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 23013 * any interesting requests and then jump to the real instruction 23014 * handler. Unlike the Arm handler, we can't do this as a tail call 23015 * because rIBASE is caller save and we need to reload it. 23016 * 23017 * Note that unlike in the Arm implementation, we should never arrive 23018 * here with a zero breakFlag because we always refresh rIBASE on 23019 * return. 23020 */ 23021 EXPORT_PC 23022 movl rSELF, %eax 23023 movl rPC, OUT_ARG0(%esp) 23024 cmpb $0,offThread_breakFlags(%eax) # anything to do? 23025 movl rFP, OUT_ARG1(%esp) 23026 je 1f # reload rIBASE & resume if not 23027 movl %eax, OUT_ARG2(%esp) 23028 call dvmCheckBefore # (dPC, dFP, self) 23029 movl rSELF, %eax 230301: 23031 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 23032 jmp *dvmAsmInstructionStart+(443*4) 23033 23034/* ------------------------------ */ 23035.L_ALT_OP_UNUSED_BCFF: /* 0x1bc */ 23036/* File: x86/alt_stub.S */ 23037/* 23038 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 23039 * any interesting requests and then jump to the real instruction 23040 * handler. Unlike the Arm handler, we can't do this as a tail call 23041 * because rIBASE is caller save and we need to reload it. 23042 * 23043 * Note that unlike in the Arm implementation, we should never arrive 23044 * here with a zero breakFlag because we always refresh rIBASE on 23045 * return. 23046 */ 23047 EXPORT_PC 23048 movl rSELF, %eax 23049 movl rPC, OUT_ARG0(%esp) 23050 cmpb $0,offThread_breakFlags(%eax) # anything to do? 23051 movl rFP, OUT_ARG1(%esp) 23052 je 1f # reload rIBASE & resume if not 23053 movl %eax, OUT_ARG2(%esp) 23054 call dvmCheckBefore # (dPC, dFP, self) 23055 movl rSELF, %eax 230561: 23057 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 23058 jmp *dvmAsmInstructionStart+(444*4) 23059 23060/* ------------------------------ */ 23061.L_ALT_OP_UNUSED_BDFF: /* 0x1bd */ 23062/* File: x86/alt_stub.S */ 23063/* 23064 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 23065 * any interesting requests and then jump to the real instruction 23066 * handler. Unlike the Arm handler, we can't do this as a tail call 23067 * because rIBASE is caller save and we need to reload it. 23068 * 23069 * Note that unlike in the Arm implementation, we should never arrive 23070 * here with a zero breakFlag because we always refresh rIBASE on 23071 * return. 23072 */ 23073 EXPORT_PC 23074 movl rSELF, %eax 23075 movl rPC, OUT_ARG0(%esp) 23076 cmpb $0,offThread_breakFlags(%eax) # anything to do? 23077 movl rFP, OUT_ARG1(%esp) 23078 je 1f # reload rIBASE & resume if not 23079 movl %eax, OUT_ARG2(%esp) 23080 call dvmCheckBefore # (dPC, dFP, self) 23081 movl rSELF, %eax 230821: 23083 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 23084 jmp *dvmAsmInstructionStart+(445*4) 23085 23086/* ------------------------------ */ 23087.L_ALT_OP_UNUSED_BEFF: /* 0x1be */ 23088/* File: x86/alt_stub.S */ 23089/* 23090 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 23091 * any interesting requests and then jump to the real instruction 23092 * handler. Unlike the Arm handler, we can't do this as a tail call 23093 * because rIBASE is caller save and we need to reload it. 23094 * 23095 * Note that unlike in the Arm implementation, we should never arrive 23096 * here with a zero breakFlag because we always refresh rIBASE on 23097 * return. 23098 */ 23099 EXPORT_PC 23100 movl rSELF, %eax 23101 movl rPC, OUT_ARG0(%esp) 23102 cmpb $0,offThread_breakFlags(%eax) # anything to do? 23103 movl rFP, OUT_ARG1(%esp) 23104 je 1f # reload rIBASE & resume if not 23105 movl %eax, OUT_ARG2(%esp) 23106 call dvmCheckBefore # (dPC, dFP, self) 23107 movl rSELF, %eax 231081: 23109 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 23110 jmp *dvmAsmInstructionStart+(446*4) 23111 23112/* ------------------------------ */ 23113.L_ALT_OP_UNUSED_BFFF: /* 0x1bf */ 23114/* File: x86/alt_stub.S */ 23115/* 23116 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 23117 * any interesting requests and then jump to the real instruction 23118 * handler. Unlike the Arm handler, we can't do this as a tail call 23119 * because rIBASE is caller save and we need to reload it. 23120 * 23121 * Note that unlike in the Arm implementation, we should never arrive 23122 * here with a zero breakFlag because we always refresh rIBASE on 23123 * return. 23124 */ 23125 EXPORT_PC 23126 movl rSELF, %eax 23127 movl rPC, OUT_ARG0(%esp) 23128 cmpb $0,offThread_breakFlags(%eax) # anything to do? 23129 movl rFP, OUT_ARG1(%esp) 23130 je 1f # reload rIBASE & resume if not 23131 movl %eax, OUT_ARG2(%esp) 23132 call dvmCheckBefore # (dPC, dFP, self) 23133 movl rSELF, %eax 231341: 23135 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 23136 jmp *dvmAsmInstructionStart+(447*4) 23137 23138/* ------------------------------ */ 23139.L_ALT_OP_UNUSED_C0FF: /* 0x1c0 */ 23140/* File: x86/alt_stub.S */ 23141/* 23142 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 23143 * any interesting requests and then jump to the real instruction 23144 * handler. Unlike the Arm handler, we can't do this as a tail call 23145 * because rIBASE is caller save and we need to reload it. 23146 * 23147 * Note that unlike in the Arm implementation, we should never arrive 23148 * here with a zero breakFlag because we always refresh rIBASE on 23149 * return. 23150 */ 23151 EXPORT_PC 23152 movl rSELF, %eax 23153 movl rPC, OUT_ARG0(%esp) 23154 cmpb $0,offThread_breakFlags(%eax) # anything to do? 23155 movl rFP, OUT_ARG1(%esp) 23156 je 1f # reload rIBASE & resume if not 23157 movl %eax, OUT_ARG2(%esp) 23158 call dvmCheckBefore # (dPC, dFP, self) 23159 movl rSELF, %eax 231601: 23161 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 23162 jmp *dvmAsmInstructionStart+(448*4) 23163 23164/* ------------------------------ */ 23165.L_ALT_OP_UNUSED_C1FF: /* 0x1c1 */ 23166/* File: x86/alt_stub.S */ 23167/* 23168 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 23169 * any interesting requests and then jump to the real instruction 23170 * handler. Unlike the Arm handler, we can't do this as a tail call 23171 * because rIBASE is caller save and we need to reload it. 23172 * 23173 * Note that unlike in the Arm implementation, we should never arrive 23174 * here with a zero breakFlag because we always refresh rIBASE on 23175 * return. 23176 */ 23177 EXPORT_PC 23178 movl rSELF, %eax 23179 movl rPC, OUT_ARG0(%esp) 23180 cmpb $0,offThread_breakFlags(%eax) # anything to do? 23181 movl rFP, OUT_ARG1(%esp) 23182 je 1f # reload rIBASE & resume if not 23183 movl %eax, OUT_ARG2(%esp) 23184 call dvmCheckBefore # (dPC, dFP, self) 23185 movl rSELF, %eax 231861: 23187 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 23188 jmp *dvmAsmInstructionStart+(449*4) 23189 23190/* ------------------------------ */ 23191.L_ALT_OP_UNUSED_C2FF: /* 0x1c2 */ 23192/* File: x86/alt_stub.S */ 23193/* 23194 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 23195 * any interesting requests and then jump to the real instruction 23196 * handler. Unlike the Arm handler, we can't do this as a tail call 23197 * because rIBASE is caller save and we need to reload it. 23198 * 23199 * Note that unlike in the Arm implementation, we should never arrive 23200 * here with a zero breakFlag because we always refresh rIBASE on 23201 * return. 23202 */ 23203 EXPORT_PC 23204 movl rSELF, %eax 23205 movl rPC, OUT_ARG0(%esp) 23206 cmpb $0,offThread_breakFlags(%eax) # anything to do? 23207 movl rFP, OUT_ARG1(%esp) 23208 je 1f # reload rIBASE & resume if not 23209 movl %eax, OUT_ARG2(%esp) 23210 call dvmCheckBefore # (dPC, dFP, self) 23211 movl rSELF, %eax 232121: 23213 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 23214 jmp *dvmAsmInstructionStart+(450*4) 23215 23216/* ------------------------------ */ 23217.L_ALT_OP_UNUSED_C3FF: /* 0x1c3 */ 23218/* File: x86/alt_stub.S */ 23219/* 23220 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 23221 * any interesting requests and then jump to the real instruction 23222 * handler. Unlike the Arm handler, we can't do this as a tail call 23223 * because rIBASE is caller save and we need to reload it. 23224 * 23225 * Note that unlike in the Arm implementation, we should never arrive 23226 * here with a zero breakFlag because we always refresh rIBASE on 23227 * return. 23228 */ 23229 EXPORT_PC 23230 movl rSELF, %eax 23231 movl rPC, OUT_ARG0(%esp) 23232 cmpb $0,offThread_breakFlags(%eax) # anything to do? 23233 movl rFP, OUT_ARG1(%esp) 23234 je 1f # reload rIBASE & resume if not 23235 movl %eax, OUT_ARG2(%esp) 23236 call dvmCheckBefore # (dPC, dFP, self) 23237 movl rSELF, %eax 232381: 23239 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 23240 jmp *dvmAsmInstructionStart+(451*4) 23241 23242/* ------------------------------ */ 23243.L_ALT_OP_UNUSED_C4FF: /* 0x1c4 */ 23244/* File: x86/alt_stub.S */ 23245/* 23246 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 23247 * any interesting requests and then jump to the real instruction 23248 * handler. Unlike the Arm handler, we can't do this as a tail call 23249 * because rIBASE is caller save and we need to reload it. 23250 * 23251 * Note that unlike in the Arm implementation, we should never arrive 23252 * here with a zero breakFlag because we always refresh rIBASE on 23253 * return. 23254 */ 23255 EXPORT_PC 23256 movl rSELF, %eax 23257 movl rPC, OUT_ARG0(%esp) 23258 cmpb $0,offThread_breakFlags(%eax) # anything to do? 23259 movl rFP, OUT_ARG1(%esp) 23260 je 1f # reload rIBASE & resume if not 23261 movl %eax, OUT_ARG2(%esp) 23262 call dvmCheckBefore # (dPC, dFP, self) 23263 movl rSELF, %eax 232641: 23265 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 23266 jmp *dvmAsmInstructionStart+(452*4) 23267 23268/* ------------------------------ */ 23269.L_ALT_OP_UNUSED_C5FF: /* 0x1c5 */ 23270/* File: x86/alt_stub.S */ 23271/* 23272 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 23273 * any interesting requests and then jump to the real instruction 23274 * handler. Unlike the Arm handler, we can't do this as a tail call 23275 * because rIBASE is caller save and we need to reload it. 23276 * 23277 * Note that unlike in the Arm implementation, we should never arrive 23278 * here with a zero breakFlag because we always refresh rIBASE on 23279 * return. 23280 */ 23281 EXPORT_PC 23282 movl rSELF, %eax 23283 movl rPC, OUT_ARG0(%esp) 23284 cmpb $0,offThread_breakFlags(%eax) # anything to do? 23285 movl rFP, OUT_ARG1(%esp) 23286 je 1f # reload rIBASE & resume if not 23287 movl %eax, OUT_ARG2(%esp) 23288 call dvmCheckBefore # (dPC, dFP, self) 23289 movl rSELF, %eax 232901: 23291 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 23292 jmp *dvmAsmInstructionStart+(453*4) 23293 23294/* ------------------------------ */ 23295.L_ALT_OP_UNUSED_C6FF: /* 0x1c6 */ 23296/* File: x86/alt_stub.S */ 23297/* 23298 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 23299 * any interesting requests and then jump to the real instruction 23300 * handler. Unlike the Arm handler, we can't do this as a tail call 23301 * because rIBASE is caller save and we need to reload it. 23302 * 23303 * Note that unlike in the Arm implementation, we should never arrive 23304 * here with a zero breakFlag because we always refresh rIBASE on 23305 * return. 23306 */ 23307 EXPORT_PC 23308 movl rSELF, %eax 23309 movl rPC, OUT_ARG0(%esp) 23310 cmpb $0,offThread_breakFlags(%eax) # anything to do? 23311 movl rFP, OUT_ARG1(%esp) 23312 je 1f # reload rIBASE & resume if not 23313 movl %eax, OUT_ARG2(%esp) 23314 call dvmCheckBefore # (dPC, dFP, self) 23315 movl rSELF, %eax 233161: 23317 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 23318 jmp *dvmAsmInstructionStart+(454*4) 23319 23320/* ------------------------------ */ 23321.L_ALT_OP_UNUSED_C7FF: /* 0x1c7 */ 23322/* File: x86/alt_stub.S */ 23323/* 23324 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 23325 * any interesting requests and then jump to the real instruction 23326 * handler. Unlike the Arm handler, we can't do this as a tail call 23327 * because rIBASE is caller save and we need to reload it. 23328 * 23329 * Note that unlike in the Arm implementation, we should never arrive 23330 * here with a zero breakFlag because we always refresh rIBASE on 23331 * return. 23332 */ 23333 EXPORT_PC 23334 movl rSELF, %eax 23335 movl rPC, OUT_ARG0(%esp) 23336 cmpb $0,offThread_breakFlags(%eax) # anything to do? 23337 movl rFP, OUT_ARG1(%esp) 23338 je 1f # reload rIBASE & resume if not 23339 movl %eax, OUT_ARG2(%esp) 23340 call dvmCheckBefore # (dPC, dFP, self) 23341 movl rSELF, %eax 233421: 23343 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 23344 jmp *dvmAsmInstructionStart+(455*4) 23345 23346/* ------------------------------ */ 23347.L_ALT_OP_UNUSED_C8FF: /* 0x1c8 */ 23348/* File: x86/alt_stub.S */ 23349/* 23350 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 23351 * any interesting requests and then jump to the real instruction 23352 * handler. Unlike the Arm handler, we can't do this as a tail call 23353 * because rIBASE is caller save and we need to reload it. 23354 * 23355 * Note that unlike in the Arm implementation, we should never arrive 23356 * here with a zero breakFlag because we always refresh rIBASE on 23357 * return. 23358 */ 23359 EXPORT_PC 23360 movl rSELF, %eax 23361 movl rPC, OUT_ARG0(%esp) 23362 cmpb $0,offThread_breakFlags(%eax) # anything to do? 23363 movl rFP, OUT_ARG1(%esp) 23364 je 1f # reload rIBASE & resume if not 23365 movl %eax, OUT_ARG2(%esp) 23366 call dvmCheckBefore # (dPC, dFP, self) 23367 movl rSELF, %eax 233681: 23369 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 23370 jmp *dvmAsmInstructionStart+(456*4) 23371 23372/* ------------------------------ */ 23373.L_ALT_OP_UNUSED_C9FF: /* 0x1c9 */ 23374/* File: x86/alt_stub.S */ 23375/* 23376 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 23377 * any interesting requests and then jump to the real instruction 23378 * handler. Unlike the Arm handler, we can't do this as a tail call 23379 * because rIBASE is caller save and we need to reload it. 23380 * 23381 * Note that unlike in the Arm implementation, we should never arrive 23382 * here with a zero breakFlag because we always refresh rIBASE on 23383 * return. 23384 */ 23385 EXPORT_PC 23386 movl rSELF, %eax 23387 movl rPC, OUT_ARG0(%esp) 23388 cmpb $0,offThread_breakFlags(%eax) # anything to do? 23389 movl rFP, OUT_ARG1(%esp) 23390 je 1f # reload rIBASE & resume if not 23391 movl %eax, OUT_ARG2(%esp) 23392 call dvmCheckBefore # (dPC, dFP, self) 23393 movl rSELF, %eax 233941: 23395 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 23396 jmp *dvmAsmInstructionStart+(457*4) 23397 23398/* ------------------------------ */ 23399.L_ALT_OP_UNUSED_CAFF: /* 0x1ca */ 23400/* File: x86/alt_stub.S */ 23401/* 23402 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 23403 * any interesting requests and then jump to the real instruction 23404 * handler. Unlike the Arm handler, we can't do this as a tail call 23405 * because rIBASE is caller save and we need to reload it. 23406 * 23407 * Note that unlike in the Arm implementation, we should never arrive 23408 * here with a zero breakFlag because we always refresh rIBASE on 23409 * return. 23410 */ 23411 EXPORT_PC 23412 movl rSELF, %eax 23413 movl rPC, OUT_ARG0(%esp) 23414 cmpb $0,offThread_breakFlags(%eax) # anything to do? 23415 movl rFP, OUT_ARG1(%esp) 23416 je 1f # reload rIBASE & resume if not 23417 movl %eax, OUT_ARG2(%esp) 23418 call dvmCheckBefore # (dPC, dFP, self) 23419 movl rSELF, %eax 234201: 23421 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 23422 jmp *dvmAsmInstructionStart+(458*4) 23423 23424/* ------------------------------ */ 23425.L_ALT_OP_UNUSED_CBFF: /* 0x1cb */ 23426/* File: x86/alt_stub.S */ 23427/* 23428 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 23429 * any interesting requests and then jump to the real instruction 23430 * handler. Unlike the Arm handler, we can't do this as a tail call 23431 * because rIBASE is caller save and we need to reload it. 23432 * 23433 * Note that unlike in the Arm implementation, we should never arrive 23434 * here with a zero breakFlag because we always refresh rIBASE on 23435 * return. 23436 */ 23437 EXPORT_PC 23438 movl rSELF, %eax 23439 movl rPC, OUT_ARG0(%esp) 23440 cmpb $0,offThread_breakFlags(%eax) # anything to do? 23441 movl rFP, OUT_ARG1(%esp) 23442 je 1f # reload rIBASE & resume if not 23443 movl %eax, OUT_ARG2(%esp) 23444 call dvmCheckBefore # (dPC, dFP, self) 23445 movl rSELF, %eax 234461: 23447 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 23448 jmp *dvmAsmInstructionStart+(459*4) 23449 23450/* ------------------------------ */ 23451.L_ALT_OP_UNUSED_CCFF: /* 0x1cc */ 23452/* File: x86/alt_stub.S */ 23453/* 23454 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 23455 * any interesting requests and then jump to the real instruction 23456 * handler. Unlike the Arm handler, we can't do this as a tail call 23457 * because rIBASE is caller save and we need to reload it. 23458 * 23459 * Note that unlike in the Arm implementation, we should never arrive 23460 * here with a zero breakFlag because we always refresh rIBASE on 23461 * return. 23462 */ 23463 EXPORT_PC 23464 movl rSELF, %eax 23465 movl rPC, OUT_ARG0(%esp) 23466 cmpb $0,offThread_breakFlags(%eax) # anything to do? 23467 movl rFP, OUT_ARG1(%esp) 23468 je 1f # reload rIBASE & resume if not 23469 movl %eax, OUT_ARG2(%esp) 23470 call dvmCheckBefore # (dPC, dFP, self) 23471 movl rSELF, %eax 234721: 23473 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 23474 jmp *dvmAsmInstructionStart+(460*4) 23475 23476/* ------------------------------ */ 23477.L_ALT_OP_UNUSED_CDFF: /* 0x1cd */ 23478/* File: x86/alt_stub.S */ 23479/* 23480 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 23481 * any interesting requests and then jump to the real instruction 23482 * handler. Unlike the Arm handler, we can't do this as a tail call 23483 * because rIBASE is caller save and we need to reload it. 23484 * 23485 * Note that unlike in the Arm implementation, we should never arrive 23486 * here with a zero breakFlag because we always refresh rIBASE on 23487 * return. 23488 */ 23489 EXPORT_PC 23490 movl rSELF, %eax 23491 movl rPC, OUT_ARG0(%esp) 23492 cmpb $0,offThread_breakFlags(%eax) # anything to do? 23493 movl rFP, OUT_ARG1(%esp) 23494 je 1f # reload rIBASE & resume if not 23495 movl %eax, OUT_ARG2(%esp) 23496 call dvmCheckBefore # (dPC, dFP, self) 23497 movl rSELF, %eax 234981: 23499 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 23500 jmp *dvmAsmInstructionStart+(461*4) 23501 23502/* ------------------------------ */ 23503.L_ALT_OP_UNUSED_CEFF: /* 0x1ce */ 23504/* File: x86/alt_stub.S */ 23505/* 23506 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 23507 * any interesting requests and then jump to the real instruction 23508 * handler. Unlike the Arm handler, we can't do this as a tail call 23509 * because rIBASE is caller save and we need to reload it. 23510 * 23511 * Note that unlike in the Arm implementation, we should never arrive 23512 * here with a zero breakFlag because we always refresh rIBASE on 23513 * return. 23514 */ 23515 EXPORT_PC 23516 movl rSELF, %eax 23517 movl rPC, OUT_ARG0(%esp) 23518 cmpb $0,offThread_breakFlags(%eax) # anything to do? 23519 movl rFP, OUT_ARG1(%esp) 23520 je 1f # reload rIBASE & resume if not 23521 movl %eax, OUT_ARG2(%esp) 23522 call dvmCheckBefore # (dPC, dFP, self) 23523 movl rSELF, %eax 235241: 23525 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 23526 jmp *dvmAsmInstructionStart+(462*4) 23527 23528/* ------------------------------ */ 23529.L_ALT_OP_UNUSED_CFFF: /* 0x1cf */ 23530/* File: x86/alt_stub.S */ 23531/* 23532 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 23533 * any interesting requests and then jump to the real instruction 23534 * handler. Unlike the Arm handler, we can't do this as a tail call 23535 * because rIBASE is caller save and we need to reload it. 23536 * 23537 * Note that unlike in the Arm implementation, we should never arrive 23538 * here with a zero breakFlag because we always refresh rIBASE on 23539 * return. 23540 */ 23541 EXPORT_PC 23542 movl rSELF, %eax 23543 movl rPC, OUT_ARG0(%esp) 23544 cmpb $0,offThread_breakFlags(%eax) # anything to do? 23545 movl rFP, OUT_ARG1(%esp) 23546 je 1f # reload rIBASE & resume if not 23547 movl %eax, OUT_ARG2(%esp) 23548 call dvmCheckBefore # (dPC, dFP, self) 23549 movl rSELF, %eax 235501: 23551 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 23552 jmp *dvmAsmInstructionStart+(463*4) 23553 23554/* ------------------------------ */ 23555.L_ALT_OP_UNUSED_D0FF: /* 0x1d0 */ 23556/* File: x86/alt_stub.S */ 23557/* 23558 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 23559 * any interesting requests and then jump to the real instruction 23560 * handler. Unlike the Arm handler, we can't do this as a tail call 23561 * because rIBASE is caller save and we need to reload it. 23562 * 23563 * Note that unlike in the Arm implementation, we should never arrive 23564 * here with a zero breakFlag because we always refresh rIBASE on 23565 * return. 23566 */ 23567 EXPORT_PC 23568 movl rSELF, %eax 23569 movl rPC, OUT_ARG0(%esp) 23570 cmpb $0,offThread_breakFlags(%eax) # anything to do? 23571 movl rFP, OUT_ARG1(%esp) 23572 je 1f # reload rIBASE & resume if not 23573 movl %eax, OUT_ARG2(%esp) 23574 call dvmCheckBefore # (dPC, dFP, self) 23575 movl rSELF, %eax 235761: 23577 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 23578 jmp *dvmAsmInstructionStart+(464*4) 23579 23580/* ------------------------------ */ 23581.L_ALT_OP_UNUSED_D1FF: /* 0x1d1 */ 23582/* File: x86/alt_stub.S */ 23583/* 23584 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 23585 * any interesting requests and then jump to the real instruction 23586 * handler. Unlike the Arm handler, we can't do this as a tail call 23587 * because rIBASE is caller save and we need to reload it. 23588 * 23589 * Note that unlike in the Arm implementation, we should never arrive 23590 * here with a zero breakFlag because we always refresh rIBASE on 23591 * return. 23592 */ 23593 EXPORT_PC 23594 movl rSELF, %eax 23595 movl rPC, OUT_ARG0(%esp) 23596 cmpb $0,offThread_breakFlags(%eax) # anything to do? 23597 movl rFP, OUT_ARG1(%esp) 23598 je 1f # reload rIBASE & resume if not 23599 movl %eax, OUT_ARG2(%esp) 23600 call dvmCheckBefore # (dPC, dFP, self) 23601 movl rSELF, %eax 236021: 23603 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 23604 jmp *dvmAsmInstructionStart+(465*4) 23605 23606/* ------------------------------ */ 23607.L_ALT_OP_UNUSED_D2FF: /* 0x1d2 */ 23608/* File: x86/alt_stub.S */ 23609/* 23610 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 23611 * any interesting requests and then jump to the real instruction 23612 * handler. Unlike the Arm handler, we can't do this as a tail call 23613 * because rIBASE is caller save and we need to reload it. 23614 * 23615 * Note that unlike in the Arm implementation, we should never arrive 23616 * here with a zero breakFlag because we always refresh rIBASE on 23617 * return. 23618 */ 23619 EXPORT_PC 23620 movl rSELF, %eax 23621 movl rPC, OUT_ARG0(%esp) 23622 cmpb $0,offThread_breakFlags(%eax) # anything to do? 23623 movl rFP, OUT_ARG1(%esp) 23624 je 1f # reload rIBASE & resume if not 23625 movl %eax, OUT_ARG2(%esp) 23626 call dvmCheckBefore # (dPC, dFP, self) 23627 movl rSELF, %eax 236281: 23629 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 23630 jmp *dvmAsmInstructionStart+(466*4) 23631 23632/* ------------------------------ */ 23633.L_ALT_OP_UNUSED_D3FF: /* 0x1d3 */ 23634/* File: x86/alt_stub.S */ 23635/* 23636 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 23637 * any interesting requests and then jump to the real instruction 23638 * handler. Unlike the Arm handler, we can't do this as a tail call 23639 * because rIBASE is caller save and we need to reload it. 23640 * 23641 * Note that unlike in the Arm implementation, we should never arrive 23642 * here with a zero breakFlag because we always refresh rIBASE on 23643 * return. 23644 */ 23645 EXPORT_PC 23646 movl rSELF, %eax 23647 movl rPC, OUT_ARG0(%esp) 23648 cmpb $0,offThread_breakFlags(%eax) # anything to do? 23649 movl rFP, OUT_ARG1(%esp) 23650 je 1f # reload rIBASE & resume if not 23651 movl %eax, OUT_ARG2(%esp) 23652 call dvmCheckBefore # (dPC, dFP, self) 23653 movl rSELF, %eax 236541: 23655 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 23656 jmp *dvmAsmInstructionStart+(467*4) 23657 23658/* ------------------------------ */ 23659.L_ALT_OP_UNUSED_D4FF: /* 0x1d4 */ 23660/* File: x86/alt_stub.S */ 23661/* 23662 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 23663 * any interesting requests and then jump to the real instruction 23664 * handler. Unlike the Arm handler, we can't do this as a tail call 23665 * because rIBASE is caller save and we need to reload it. 23666 * 23667 * Note that unlike in the Arm implementation, we should never arrive 23668 * here with a zero breakFlag because we always refresh rIBASE on 23669 * return. 23670 */ 23671 EXPORT_PC 23672 movl rSELF, %eax 23673 movl rPC, OUT_ARG0(%esp) 23674 cmpb $0,offThread_breakFlags(%eax) # anything to do? 23675 movl rFP, OUT_ARG1(%esp) 23676 je 1f # reload rIBASE & resume if not 23677 movl %eax, OUT_ARG2(%esp) 23678 call dvmCheckBefore # (dPC, dFP, self) 23679 movl rSELF, %eax 236801: 23681 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 23682 jmp *dvmAsmInstructionStart+(468*4) 23683 23684/* ------------------------------ */ 23685.L_ALT_OP_UNUSED_D5FF: /* 0x1d5 */ 23686/* File: x86/alt_stub.S */ 23687/* 23688 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 23689 * any interesting requests and then jump to the real instruction 23690 * handler. Unlike the Arm handler, we can't do this as a tail call 23691 * because rIBASE is caller save and we need to reload it. 23692 * 23693 * Note that unlike in the Arm implementation, we should never arrive 23694 * here with a zero breakFlag because we always refresh rIBASE on 23695 * return. 23696 */ 23697 EXPORT_PC 23698 movl rSELF, %eax 23699 movl rPC, OUT_ARG0(%esp) 23700 cmpb $0,offThread_breakFlags(%eax) # anything to do? 23701 movl rFP, OUT_ARG1(%esp) 23702 je 1f # reload rIBASE & resume if not 23703 movl %eax, OUT_ARG2(%esp) 23704 call dvmCheckBefore # (dPC, dFP, self) 23705 movl rSELF, %eax 237061: 23707 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 23708 jmp *dvmAsmInstructionStart+(469*4) 23709 23710/* ------------------------------ */ 23711.L_ALT_OP_UNUSED_D6FF: /* 0x1d6 */ 23712/* File: x86/alt_stub.S */ 23713/* 23714 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 23715 * any interesting requests and then jump to the real instruction 23716 * handler. Unlike the Arm handler, we can't do this as a tail call 23717 * because rIBASE is caller save and we need to reload it. 23718 * 23719 * Note that unlike in the Arm implementation, we should never arrive 23720 * here with a zero breakFlag because we always refresh rIBASE on 23721 * return. 23722 */ 23723 EXPORT_PC 23724 movl rSELF, %eax 23725 movl rPC, OUT_ARG0(%esp) 23726 cmpb $0,offThread_breakFlags(%eax) # anything to do? 23727 movl rFP, OUT_ARG1(%esp) 23728 je 1f # reload rIBASE & resume if not 23729 movl %eax, OUT_ARG2(%esp) 23730 call dvmCheckBefore # (dPC, dFP, self) 23731 movl rSELF, %eax 237321: 23733 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 23734 jmp *dvmAsmInstructionStart+(470*4) 23735 23736/* ------------------------------ */ 23737.L_ALT_OP_UNUSED_D7FF: /* 0x1d7 */ 23738/* File: x86/alt_stub.S */ 23739/* 23740 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 23741 * any interesting requests and then jump to the real instruction 23742 * handler. Unlike the Arm handler, we can't do this as a tail call 23743 * because rIBASE is caller save and we need to reload it. 23744 * 23745 * Note that unlike in the Arm implementation, we should never arrive 23746 * here with a zero breakFlag because we always refresh rIBASE on 23747 * return. 23748 */ 23749 EXPORT_PC 23750 movl rSELF, %eax 23751 movl rPC, OUT_ARG0(%esp) 23752 cmpb $0,offThread_breakFlags(%eax) # anything to do? 23753 movl rFP, OUT_ARG1(%esp) 23754 je 1f # reload rIBASE & resume if not 23755 movl %eax, OUT_ARG2(%esp) 23756 call dvmCheckBefore # (dPC, dFP, self) 23757 movl rSELF, %eax 237581: 23759 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 23760 jmp *dvmAsmInstructionStart+(471*4) 23761 23762/* ------------------------------ */ 23763.L_ALT_OP_UNUSED_D8FF: /* 0x1d8 */ 23764/* File: x86/alt_stub.S */ 23765/* 23766 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 23767 * any interesting requests and then jump to the real instruction 23768 * handler. Unlike the Arm handler, we can't do this as a tail call 23769 * because rIBASE is caller save and we need to reload it. 23770 * 23771 * Note that unlike in the Arm implementation, we should never arrive 23772 * here with a zero breakFlag because we always refresh rIBASE on 23773 * return. 23774 */ 23775 EXPORT_PC 23776 movl rSELF, %eax 23777 movl rPC, OUT_ARG0(%esp) 23778 cmpb $0,offThread_breakFlags(%eax) # anything to do? 23779 movl rFP, OUT_ARG1(%esp) 23780 je 1f # reload rIBASE & resume if not 23781 movl %eax, OUT_ARG2(%esp) 23782 call dvmCheckBefore # (dPC, dFP, self) 23783 movl rSELF, %eax 237841: 23785 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 23786 jmp *dvmAsmInstructionStart+(472*4) 23787 23788/* ------------------------------ */ 23789.L_ALT_OP_UNUSED_D9FF: /* 0x1d9 */ 23790/* File: x86/alt_stub.S */ 23791/* 23792 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 23793 * any interesting requests and then jump to the real instruction 23794 * handler. Unlike the Arm handler, we can't do this as a tail call 23795 * because rIBASE is caller save and we need to reload it. 23796 * 23797 * Note that unlike in the Arm implementation, we should never arrive 23798 * here with a zero breakFlag because we always refresh rIBASE on 23799 * return. 23800 */ 23801 EXPORT_PC 23802 movl rSELF, %eax 23803 movl rPC, OUT_ARG0(%esp) 23804 cmpb $0,offThread_breakFlags(%eax) # anything to do? 23805 movl rFP, OUT_ARG1(%esp) 23806 je 1f # reload rIBASE & resume if not 23807 movl %eax, OUT_ARG2(%esp) 23808 call dvmCheckBefore # (dPC, dFP, self) 23809 movl rSELF, %eax 238101: 23811 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 23812 jmp *dvmAsmInstructionStart+(473*4) 23813 23814/* ------------------------------ */ 23815.L_ALT_OP_UNUSED_DAFF: /* 0x1da */ 23816/* File: x86/alt_stub.S */ 23817/* 23818 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 23819 * any interesting requests and then jump to the real instruction 23820 * handler. Unlike the Arm handler, we can't do this as a tail call 23821 * because rIBASE is caller save and we need to reload it. 23822 * 23823 * Note that unlike in the Arm implementation, we should never arrive 23824 * here with a zero breakFlag because we always refresh rIBASE on 23825 * return. 23826 */ 23827 EXPORT_PC 23828 movl rSELF, %eax 23829 movl rPC, OUT_ARG0(%esp) 23830 cmpb $0,offThread_breakFlags(%eax) # anything to do? 23831 movl rFP, OUT_ARG1(%esp) 23832 je 1f # reload rIBASE & resume if not 23833 movl %eax, OUT_ARG2(%esp) 23834 call dvmCheckBefore # (dPC, dFP, self) 23835 movl rSELF, %eax 238361: 23837 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 23838 jmp *dvmAsmInstructionStart+(474*4) 23839 23840/* ------------------------------ */ 23841.L_ALT_OP_UNUSED_DBFF: /* 0x1db */ 23842/* File: x86/alt_stub.S */ 23843/* 23844 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 23845 * any interesting requests and then jump to the real instruction 23846 * handler. Unlike the Arm handler, we can't do this as a tail call 23847 * because rIBASE is caller save and we need to reload it. 23848 * 23849 * Note that unlike in the Arm implementation, we should never arrive 23850 * here with a zero breakFlag because we always refresh rIBASE on 23851 * return. 23852 */ 23853 EXPORT_PC 23854 movl rSELF, %eax 23855 movl rPC, OUT_ARG0(%esp) 23856 cmpb $0,offThread_breakFlags(%eax) # anything to do? 23857 movl rFP, OUT_ARG1(%esp) 23858 je 1f # reload rIBASE & resume if not 23859 movl %eax, OUT_ARG2(%esp) 23860 call dvmCheckBefore # (dPC, dFP, self) 23861 movl rSELF, %eax 238621: 23863 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 23864 jmp *dvmAsmInstructionStart+(475*4) 23865 23866/* ------------------------------ */ 23867.L_ALT_OP_UNUSED_DCFF: /* 0x1dc */ 23868/* File: x86/alt_stub.S */ 23869/* 23870 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 23871 * any interesting requests and then jump to the real instruction 23872 * handler. Unlike the Arm handler, we can't do this as a tail call 23873 * because rIBASE is caller save and we need to reload it. 23874 * 23875 * Note that unlike in the Arm implementation, we should never arrive 23876 * here with a zero breakFlag because we always refresh rIBASE on 23877 * return. 23878 */ 23879 EXPORT_PC 23880 movl rSELF, %eax 23881 movl rPC, OUT_ARG0(%esp) 23882 cmpb $0,offThread_breakFlags(%eax) # anything to do? 23883 movl rFP, OUT_ARG1(%esp) 23884 je 1f # reload rIBASE & resume if not 23885 movl %eax, OUT_ARG2(%esp) 23886 call dvmCheckBefore # (dPC, dFP, self) 23887 movl rSELF, %eax 238881: 23889 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 23890 jmp *dvmAsmInstructionStart+(476*4) 23891 23892/* ------------------------------ */ 23893.L_ALT_OP_UNUSED_DDFF: /* 0x1dd */ 23894/* File: x86/alt_stub.S */ 23895/* 23896 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 23897 * any interesting requests and then jump to the real instruction 23898 * handler. Unlike the Arm handler, we can't do this as a tail call 23899 * because rIBASE is caller save and we need to reload it. 23900 * 23901 * Note that unlike in the Arm implementation, we should never arrive 23902 * here with a zero breakFlag because we always refresh rIBASE on 23903 * return. 23904 */ 23905 EXPORT_PC 23906 movl rSELF, %eax 23907 movl rPC, OUT_ARG0(%esp) 23908 cmpb $0,offThread_breakFlags(%eax) # anything to do? 23909 movl rFP, OUT_ARG1(%esp) 23910 je 1f # reload rIBASE & resume if not 23911 movl %eax, OUT_ARG2(%esp) 23912 call dvmCheckBefore # (dPC, dFP, self) 23913 movl rSELF, %eax 239141: 23915 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 23916 jmp *dvmAsmInstructionStart+(477*4) 23917 23918/* ------------------------------ */ 23919.L_ALT_OP_UNUSED_DEFF: /* 0x1de */ 23920/* File: x86/alt_stub.S */ 23921/* 23922 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 23923 * any interesting requests and then jump to the real instruction 23924 * handler. Unlike the Arm handler, we can't do this as a tail call 23925 * because rIBASE is caller save and we need to reload it. 23926 * 23927 * Note that unlike in the Arm implementation, we should never arrive 23928 * here with a zero breakFlag because we always refresh rIBASE on 23929 * return. 23930 */ 23931 EXPORT_PC 23932 movl rSELF, %eax 23933 movl rPC, OUT_ARG0(%esp) 23934 cmpb $0,offThread_breakFlags(%eax) # anything to do? 23935 movl rFP, OUT_ARG1(%esp) 23936 je 1f # reload rIBASE & resume if not 23937 movl %eax, OUT_ARG2(%esp) 23938 call dvmCheckBefore # (dPC, dFP, self) 23939 movl rSELF, %eax 239401: 23941 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 23942 jmp *dvmAsmInstructionStart+(478*4) 23943 23944/* ------------------------------ */ 23945.L_ALT_OP_UNUSED_DFFF: /* 0x1df */ 23946/* File: x86/alt_stub.S */ 23947/* 23948 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 23949 * any interesting requests and then jump to the real instruction 23950 * handler. Unlike the Arm handler, we can't do this as a tail call 23951 * because rIBASE is caller save and we need to reload it. 23952 * 23953 * Note that unlike in the Arm implementation, we should never arrive 23954 * here with a zero breakFlag because we always refresh rIBASE on 23955 * return. 23956 */ 23957 EXPORT_PC 23958 movl rSELF, %eax 23959 movl rPC, OUT_ARG0(%esp) 23960 cmpb $0,offThread_breakFlags(%eax) # anything to do? 23961 movl rFP, OUT_ARG1(%esp) 23962 je 1f # reload rIBASE & resume if not 23963 movl %eax, OUT_ARG2(%esp) 23964 call dvmCheckBefore # (dPC, dFP, self) 23965 movl rSELF, %eax 239661: 23967 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 23968 jmp *dvmAsmInstructionStart+(479*4) 23969 23970/* ------------------------------ */ 23971.L_ALT_OP_UNUSED_E0FF: /* 0x1e0 */ 23972/* File: x86/alt_stub.S */ 23973/* 23974 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 23975 * any interesting requests and then jump to the real instruction 23976 * handler. Unlike the Arm handler, we can't do this as a tail call 23977 * because rIBASE is caller save and we need to reload it. 23978 * 23979 * Note that unlike in the Arm implementation, we should never arrive 23980 * here with a zero breakFlag because we always refresh rIBASE on 23981 * return. 23982 */ 23983 EXPORT_PC 23984 movl rSELF, %eax 23985 movl rPC, OUT_ARG0(%esp) 23986 cmpb $0,offThread_breakFlags(%eax) # anything to do? 23987 movl rFP, OUT_ARG1(%esp) 23988 je 1f # reload rIBASE & resume if not 23989 movl %eax, OUT_ARG2(%esp) 23990 call dvmCheckBefore # (dPC, dFP, self) 23991 movl rSELF, %eax 239921: 23993 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 23994 jmp *dvmAsmInstructionStart+(480*4) 23995 23996/* ------------------------------ */ 23997.L_ALT_OP_UNUSED_E1FF: /* 0x1e1 */ 23998/* File: x86/alt_stub.S */ 23999/* 24000 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 24001 * any interesting requests and then jump to the real instruction 24002 * handler. Unlike the Arm handler, we can't do this as a tail call 24003 * because rIBASE is caller save and we need to reload it. 24004 * 24005 * Note that unlike in the Arm implementation, we should never arrive 24006 * here with a zero breakFlag because we always refresh rIBASE on 24007 * return. 24008 */ 24009 EXPORT_PC 24010 movl rSELF, %eax 24011 movl rPC, OUT_ARG0(%esp) 24012 cmpb $0,offThread_breakFlags(%eax) # anything to do? 24013 movl rFP, OUT_ARG1(%esp) 24014 je 1f # reload rIBASE & resume if not 24015 movl %eax, OUT_ARG2(%esp) 24016 call dvmCheckBefore # (dPC, dFP, self) 24017 movl rSELF, %eax 240181: 24019 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 24020 jmp *dvmAsmInstructionStart+(481*4) 24021 24022/* ------------------------------ */ 24023.L_ALT_OP_UNUSED_E2FF: /* 0x1e2 */ 24024/* File: x86/alt_stub.S */ 24025/* 24026 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 24027 * any interesting requests and then jump to the real instruction 24028 * handler. Unlike the Arm handler, we can't do this as a tail call 24029 * because rIBASE is caller save and we need to reload it. 24030 * 24031 * Note that unlike in the Arm implementation, we should never arrive 24032 * here with a zero breakFlag because we always refresh rIBASE on 24033 * return. 24034 */ 24035 EXPORT_PC 24036 movl rSELF, %eax 24037 movl rPC, OUT_ARG0(%esp) 24038 cmpb $0,offThread_breakFlags(%eax) # anything to do? 24039 movl rFP, OUT_ARG1(%esp) 24040 je 1f # reload rIBASE & resume if not 24041 movl %eax, OUT_ARG2(%esp) 24042 call dvmCheckBefore # (dPC, dFP, self) 24043 movl rSELF, %eax 240441: 24045 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 24046 jmp *dvmAsmInstructionStart+(482*4) 24047 24048/* ------------------------------ */ 24049.L_ALT_OP_UNUSED_E3FF: /* 0x1e3 */ 24050/* File: x86/alt_stub.S */ 24051/* 24052 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 24053 * any interesting requests and then jump to the real instruction 24054 * handler. Unlike the Arm handler, we can't do this as a tail call 24055 * because rIBASE is caller save and we need to reload it. 24056 * 24057 * Note that unlike in the Arm implementation, we should never arrive 24058 * here with a zero breakFlag because we always refresh rIBASE on 24059 * return. 24060 */ 24061 EXPORT_PC 24062 movl rSELF, %eax 24063 movl rPC, OUT_ARG0(%esp) 24064 cmpb $0,offThread_breakFlags(%eax) # anything to do? 24065 movl rFP, OUT_ARG1(%esp) 24066 je 1f # reload rIBASE & resume if not 24067 movl %eax, OUT_ARG2(%esp) 24068 call dvmCheckBefore # (dPC, dFP, self) 24069 movl rSELF, %eax 240701: 24071 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 24072 jmp *dvmAsmInstructionStart+(483*4) 24073 24074/* ------------------------------ */ 24075.L_ALT_OP_UNUSED_E4FF: /* 0x1e4 */ 24076/* File: x86/alt_stub.S */ 24077/* 24078 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 24079 * any interesting requests and then jump to the real instruction 24080 * handler. Unlike the Arm handler, we can't do this as a tail call 24081 * because rIBASE is caller save and we need to reload it. 24082 * 24083 * Note that unlike in the Arm implementation, we should never arrive 24084 * here with a zero breakFlag because we always refresh rIBASE on 24085 * return. 24086 */ 24087 EXPORT_PC 24088 movl rSELF, %eax 24089 movl rPC, OUT_ARG0(%esp) 24090 cmpb $0,offThread_breakFlags(%eax) # anything to do? 24091 movl rFP, OUT_ARG1(%esp) 24092 je 1f # reload rIBASE & resume if not 24093 movl %eax, OUT_ARG2(%esp) 24094 call dvmCheckBefore # (dPC, dFP, self) 24095 movl rSELF, %eax 240961: 24097 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 24098 jmp *dvmAsmInstructionStart+(484*4) 24099 24100/* ------------------------------ */ 24101.L_ALT_OP_UNUSED_E5FF: /* 0x1e5 */ 24102/* File: x86/alt_stub.S */ 24103/* 24104 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 24105 * any interesting requests and then jump to the real instruction 24106 * handler. Unlike the Arm handler, we can't do this as a tail call 24107 * because rIBASE is caller save and we need to reload it. 24108 * 24109 * Note that unlike in the Arm implementation, we should never arrive 24110 * here with a zero breakFlag because we always refresh rIBASE on 24111 * return. 24112 */ 24113 EXPORT_PC 24114 movl rSELF, %eax 24115 movl rPC, OUT_ARG0(%esp) 24116 cmpb $0,offThread_breakFlags(%eax) # anything to do? 24117 movl rFP, OUT_ARG1(%esp) 24118 je 1f # reload rIBASE & resume if not 24119 movl %eax, OUT_ARG2(%esp) 24120 call dvmCheckBefore # (dPC, dFP, self) 24121 movl rSELF, %eax 241221: 24123 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 24124 jmp *dvmAsmInstructionStart+(485*4) 24125 24126/* ------------------------------ */ 24127.L_ALT_OP_UNUSED_E6FF: /* 0x1e6 */ 24128/* File: x86/alt_stub.S */ 24129/* 24130 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 24131 * any interesting requests and then jump to the real instruction 24132 * handler. Unlike the Arm handler, we can't do this as a tail call 24133 * because rIBASE is caller save and we need to reload it. 24134 * 24135 * Note that unlike in the Arm implementation, we should never arrive 24136 * here with a zero breakFlag because we always refresh rIBASE on 24137 * return. 24138 */ 24139 EXPORT_PC 24140 movl rSELF, %eax 24141 movl rPC, OUT_ARG0(%esp) 24142 cmpb $0,offThread_breakFlags(%eax) # anything to do? 24143 movl rFP, OUT_ARG1(%esp) 24144 je 1f # reload rIBASE & resume if not 24145 movl %eax, OUT_ARG2(%esp) 24146 call dvmCheckBefore # (dPC, dFP, self) 24147 movl rSELF, %eax 241481: 24149 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 24150 jmp *dvmAsmInstructionStart+(486*4) 24151 24152/* ------------------------------ */ 24153.L_ALT_OP_UNUSED_E7FF: /* 0x1e7 */ 24154/* File: x86/alt_stub.S */ 24155/* 24156 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 24157 * any interesting requests and then jump to the real instruction 24158 * handler. Unlike the Arm handler, we can't do this as a tail call 24159 * because rIBASE is caller save and we need to reload it. 24160 * 24161 * Note that unlike in the Arm implementation, we should never arrive 24162 * here with a zero breakFlag because we always refresh rIBASE on 24163 * return. 24164 */ 24165 EXPORT_PC 24166 movl rSELF, %eax 24167 movl rPC, OUT_ARG0(%esp) 24168 cmpb $0,offThread_breakFlags(%eax) # anything to do? 24169 movl rFP, OUT_ARG1(%esp) 24170 je 1f # reload rIBASE & resume if not 24171 movl %eax, OUT_ARG2(%esp) 24172 call dvmCheckBefore # (dPC, dFP, self) 24173 movl rSELF, %eax 241741: 24175 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 24176 jmp *dvmAsmInstructionStart+(487*4) 24177 24178/* ------------------------------ */ 24179.L_ALT_OP_UNUSED_E8FF: /* 0x1e8 */ 24180/* File: x86/alt_stub.S */ 24181/* 24182 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 24183 * any interesting requests and then jump to the real instruction 24184 * handler. Unlike the Arm handler, we can't do this as a tail call 24185 * because rIBASE is caller save and we need to reload it. 24186 * 24187 * Note that unlike in the Arm implementation, we should never arrive 24188 * here with a zero breakFlag because we always refresh rIBASE on 24189 * return. 24190 */ 24191 EXPORT_PC 24192 movl rSELF, %eax 24193 movl rPC, OUT_ARG0(%esp) 24194 cmpb $0,offThread_breakFlags(%eax) # anything to do? 24195 movl rFP, OUT_ARG1(%esp) 24196 je 1f # reload rIBASE & resume if not 24197 movl %eax, OUT_ARG2(%esp) 24198 call dvmCheckBefore # (dPC, dFP, self) 24199 movl rSELF, %eax 242001: 24201 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 24202 jmp *dvmAsmInstructionStart+(488*4) 24203 24204/* ------------------------------ */ 24205.L_ALT_OP_UNUSED_E9FF: /* 0x1e9 */ 24206/* File: x86/alt_stub.S */ 24207/* 24208 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 24209 * any interesting requests and then jump to the real instruction 24210 * handler. Unlike the Arm handler, we can't do this as a tail call 24211 * because rIBASE is caller save and we need to reload it. 24212 * 24213 * Note that unlike in the Arm implementation, we should never arrive 24214 * here with a zero breakFlag because we always refresh rIBASE on 24215 * return. 24216 */ 24217 EXPORT_PC 24218 movl rSELF, %eax 24219 movl rPC, OUT_ARG0(%esp) 24220 cmpb $0,offThread_breakFlags(%eax) # anything to do? 24221 movl rFP, OUT_ARG1(%esp) 24222 je 1f # reload rIBASE & resume if not 24223 movl %eax, OUT_ARG2(%esp) 24224 call dvmCheckBefore # (dPC, dFP, self) 24225 movl rSELF, %eax 242261: 24227 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 24228 jmp *dvmAsmInstructionStart+(489*4) 24229 24230/* ------------------------------ */ 24231.L_ALT_OP_UNUSED_EAFF: /* 0x1ea */ 24232/* File: x86/alt_stub.S */ 24233/* 24234 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 24235 * any interesting requests and then jump to the real instruction 24236 * handler. Unlike the Arm handler, we can't do this as a tail call 24237 * because rIBASE is caller save and we need to reload it. 24238 * 24239 * Note that unlike in the Arm implementation, we should never arrive 24240 * here with a zero breakFlag because we always refresh rIBASE on 24241 * return. 24242 */ 24243 EXPORT_PC 24244 movl rSELF, %eax 24245 movl rPC, OUT_ARG0(%esp) 24246 cmpb $0,offThread_breakFlags(%eax) # anything to do? 24247 movl rFP, OUT_ARG1(%esp) 24248 je 1f # reload rIBASE & resume if not 24249 movl %eax, OUT_ARG2(%esp) 24250 call dvmCheckBefore # (dPC, dFP, self) 24251 movl rSELF, %eax 242521: 24253 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 24254 jmp *dvmAsmInstructionStart+(490*4) 24255 24256/* ------------------------------ */ 24257.L_ALT_OP_UNUSED_EBFF: /* 0x1eb */ 24258/* File: x86/alt_stub.S */ 24259/* 24260 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 24261 * any interesting requests and then jump to the real instruction 24262 * handler. Unlike the Arm handler, we can't do this as a tail call 24263 * because rIBASE is caller save and we need to reload it. 24264 * 24265 * Note that unlike in the Arm implementation, we should never arrive 24266 * here with a zero breakFlag because we always refresh rIBASE on 24267 * return. 24268 */ 24269 EXPORT_PC 24270 movl rSELF, %eax 24271 movl rPC, OUT_ARG0(%esp) 24272 cmpb $0,offThread_breakFlags(%eax) # anything to do? 24273 movl rFP, OUT_ARG1(%esp) 24274 je 1f # reload rIBASE & resume if not 24275 movl %eax, OUT_ARG2(%esp) 24276 call dvmCheckBefore # (dPC, dFP, self) 24277 movl rSELF, %eax 242781: 24279 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 24280 jmp *dvmAsmInstructionStart+(491*4) 24281 24282/* ------------------------------ */ 24283.L_ALT_OP_UNUSED_ECFF: /* 0x1ec */ 24284/* File: x86/alt_stub.S */ 24285/* 24286 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 24287 * any interesting requests and then jump to the real instruction 24288 * handler. Unlike the Arm handler, we can't do this as a tail call 24289 * because rIBASE is caller save and we need to reload it. 24290 * 24291 * Note that unlike in the Arm implementation, we should never arrive 24292 * here with a zero breakFlag because we always refresh rIBASE on 24293 * return. 24294 */ 24295 EXPORT_PC 24296 movl rSELF, %eax 24297 movl rPC, OUT_ARG0(%esp) 24298 cmpb $0,offThread_breakFlags(%eax) # anything to do? 24299 movl rFP, OUT_ARG1(%esp) 24300 je 1f # reload rIBASE & resume if not 24301 movl %eax, OUT_ARG2(%esp) 24302 call dvmCheckBefore # (dPC, dFP, self) 24303 movl rSELF, %eax 243041: 24305 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 24306 jmp *dvmAsmInstructionStart+(492*4) 24307 24308/* ------------------------------ */ 24309.L_ALT_OP_UNUSED_EDFF: /* 0x1ed */ 24310/* File: x86/alt_stub.S */ 24311/* 24312 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 24313 * any interesting requests and then jump to the real instruction 24314 * handler. Unlike the Arm handler, we can't do this as a tail call 24315 * because rIBASE is caller save and we need to reload it. 24316 * 24317 * Note that unlike in the Arm implementation, we should never arrive 24318 * here with a zero breakFlag because we always refresh rIBASE on 24319 * return. 24320 */ 24321 EXPORT_PC 24322 movl rSELF, %eax 24323 movl rPC, OUT_ARG0(%esp) 24324 cmpb $0,offThread_breakFlags(%eax) # anything to do? 24325 movl rFP, OUT_ARG1(%esp) 24326 je 1f # reload rIBASE & resume if not 24327 movl %eax, OUT_ARG2(%esp) 24328 call dvmCheckBefore # (dPC, dFP, self) 24329 movl rSELF, %eax 243301: 24331 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 24332 jmp *dvmAsmInstructionStart+(493*4) 24333 24334/* ------------------------------ */ 24335.L_ALT_OP_UNUSED_EEFF: /* 0x1ee */ 24336/* File: x86/alt_stub.S */ 24337/* 24338 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 24339 * any interesting requests and then jump to the real instruction 24340 * handler. Unlike the Arm handler, we can't do this as a tail call 24341 * because rIBASE is caller save and we need to reload it. 24342 * 24343 * Note that unlike in the Arm implementation, we should never arrive 24344 * here with a zero breakFlag because we always refresh rIBASE on 24345 * return. 24346 */ 24347 EXPORT_PC 24348 movl rSELF, %eax 24349 movl rPC, OUT_ARG0(%esp) 24350 cmpb $0,offThread_breakFlags(%eax) # anything to do? 24351 movl rFP, OUT_ARG1(%esp) 24352 je 1f # reload rIBASE & resume if not 24353 movl %eax, OUT_ARG2(%esp) 24354 call dvmCheckBefore # (dPC, dFP, self) 24355 movl rSELF, %eax 243561: 24357 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 24358 jmp *dvmAsmInstructionStart+(494*4) 24359 24360/* ------------------------------ */ 24361.L_ALT_OP_UNUSED_EFFF: /* 0x1ef */ 24362/* File: x86/alt_stub.S */ 24363/* 24364 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 24365 * any interesting requests and then jump to the real instruction 24366 * handler. Unlike the Arm handler, we can't do this as a tail call 24367 * because rIBASE is caller save and we need to reload it. 24368 * 24369 * Note that unlike in the Arm implementation, we should never arrive 24370 * here with a zero breakFlag because we always refresh rIBASE on 24371 * return. 24372 */ 24373 EXPORT_PC 24374 movl rSELF, %eax 24375 movl rPC, OUT_ARG0(%esp) 24376 cmpb $0,offThread_breakFlags(%eax) # anything to do? 24377 movl rFP, OUT_ARG1(%esp) 24378 je 1f # reload rIBASE & resume if not 24379 movl %eax, OUT_ARG2(%esp) 24380 call dvmCheckBefore # (dPC, dFP, self) 24381 movl rSELF, %eax 243821: 24383 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 24384 jmp *dvmAsmInstructionStart+(495*4) 24385 24386/* ------------------------------ */ 24387.L_ALT_OP_UNUSED_F0FF: /* 0x1f0 */ 24388/* File: x86/alt_stub.S */ 24389/* 24390 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 24391 * any interesting requests and then jump to the real instruction 24392 * handler. Unlike the Arm handler, we can't do this as a tail call 24393 * because rIBASE is caller save and we need to reload it. 24394 * 24395 * Note that unlike in the Arm implementation, we should never arrive 24396 * here with a zero breakFlag because we always refresh rIBASE on 24397 * return. 24398 */ 24399 EXPORT_PC 24400 movl rSELF, %eax 24401 movl rPC, OUT_ARG0(%esp) 24402 cmpb $0,offThread_breakFlags(%eax) # anything to do? 24403 movl rFP, OUT_ARG1(%esp) 24404 je 1f # reload rIBASE & resume if not 24405 movl %eax, OUT_ARG2(%esp) 24406 call dvmCheckBefore # (dPC, dFP, self) 24407 movl rSELF, %eax 244081: 24409 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 24410 jmp *dvmAsmInstructionStart+(496*4) 24411 24412/* ------------------------------ */ 24413.L_ALT_OP_UNUSED_F1FF: /* 0x1f1 */ 24414/* File: x86/alt_stub.S */ 24415/* 24416 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 24417 * any interesting requests and then jump to the real instruction 24418 * handler. Unlike the Arm handler, we can't do this as a tail call 24419 * because rIBASE is caller save and we need to reload it. 24420 * 24421 * Note that unlike in the Arm implementation, we should never arrive 24422 * here with a zero breakFlag because we always refresh rIBASE on 24423 * return. 24424 */ 24425 EXPORT_PC 24426 movl rSELF, %eax 24427 movl rPC, OUT_ARG0(%esp) 24428 cmpb $0,offThread_breakFlags(%eax) # anything to do? 24429 movl rFP, OUT_ARG1(%esp) 24430 je 1f # reload rIBASE & resume if not 24431 movl %eax, OUT_ARG2(%esp) 24432 call dvmCheckBefore # (dPC, dFP, self) 24433 movl rSELF, %eax 244341: 24435 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 24436 jmp *dvmAsmInstructionStart+(497*4) 24437 24438/* ------------------------------ */ 24439.L_ALT_OP_INVOKE_OBJECT_INIT_JUMBO: /* 0x1f2 */ 24440/* File: x86/alt_stub.S */ 24441/* 24442 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 24443 * any interesting requests and then jump to the real instruction 24444 * handler. Unlike the Arm handler, we can't do this as a tail call 24445 * because rIBASE is caller save and we need to reload it. 24446 * 24447 * Note that unlike in the Arm implementation, we should never arrive 24448 * here with a zero breakFlag because we always refresh rIBASE on 24449 * return. 24450 */ 24451 EXPORT_PC 24452 movl rSELF, %eax 24453 movl rPC, OUT_ARG0(%esp) 24454 cmpb $0,offThread_breakFlags(%eax) # anything to do? 24455 movl rFP, OUT_ARG1(%esp) 24456 je 1f # reload rIBASE & resume if not 24457 movl %eax, OUT_ARG2(%esp) 24458 call dvmCheckBefore # (dPC, dFP, self) 24459 movl rSELF, %eax 244601: 24461 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 24462 jmp *dvmAsmInstructionStart+(498*4) 24463 24464/* ------------------------------ */ 24465.L_ALT_OP_IGET_VOLATILE_JUMBO: /* 0x1f3 */ 24466/* File: x86/alt_stub.S */ 24467/* 24468 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 24469 * any interesting requests and then jump to the real instruction 24470 * handler. Unlike the Arm handler, we can't do this as a tail call 24471 * because rIBASE is caller save and we need to reload it. 24472 * 24473 * Note that unlike in the Arm implementation, we should never arrive 24474 * here with a zero breakFlag because we always refresh rIBASE on 24475 * return. 24476 */ 24477 EXPORT_PC 24478 movl rSELF, %eax 24479 movl rPC, OUT_ARG0(%esp) 24480 cmpb $0,offThread_breakFlags(%eax) # anything to do? 24481 movl rFP, OUT_ARG1(%esp) 24482 je 1f # reload rIBASE & resume if not 24483 movl %eax, OUT_ARG2(%esp) 24484 call dvmCheckBefore # (dPC, dFP, self) 24485 movl rSELF, %eax 244861: 24487 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 24488 jmp *dvmAsmInstructionStart+(499*4) 24489 24490/* ------------------------------ */ 24491.L_ALT_OP_IGET_WIDE_VOLATILE_JUMBO: /* 0x1f4 */ 24492/* File: x86/alt_stub.S */ 24493/* 24494 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 24495 * any interesting requests and then jump to the real instruction 24496 * handler. Unlike the Arm handler, we can't do this as a tail call 24497 * because rIBASE is caller save and we need to reload it. 24498 * 24499 * Note that unlike in the Arm implementation, we should never arrive 24500 * here with a zero breakFlag because we always refresh rIBASE on 24501 * return. 24502 */ 24503 EXPORT_PC 24504 movl rSELF, %eax 24505 movl rPC, OUT_ARG0(%esp) 24506 cmpb $0,offThread_breakFlags(%eax) # anything to do? 24507 movl rFP, OUT_ARG1(%esp) 24508 je 1f # reload rIBASE & resume if not 24509 movl %eax, OUT_ARG2(%esp) 24510 call dvmCheckBefore # (dPC, dFP, self) 24511 movl rSELF, %eax 245121: 24513 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 24514 jmp *dvmAsmInstructionStart+(500*4) 24515 24516/* ------------------------------ */ 24517.L_ALT_OP_IGET_OBJECT_VOLATILE_JUMBO: /* 0x1f5 */ 24518/* File: x86/alt_stub.S */ 24519/* 24520 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 24521 * any interesting requests and then jump to the real instruction 24522 * handler. Unlike the Arm handler, we can't do this as a tail call 24523 * because rIBASE is caller save and we need to reload it. 24524 * 24525 * Note that unlike in the Arm implementation, we should never arrive 24526 * here with a zero breakFlag because we always refresh rIBASE on 24527 * return. 24528 */ 24529 EXPORT_PC 24530 movl rSELF, %eax 24531 movl rPC, OUT_ARG0(%esp) 24532 cmpb $0,offThread_breakFlags(%eax) # anything to do? 24533 movl rFP, OUT_ARG1(%esp) 24534 je 1f # reload rIBASE & resume if not 24535 movl %eax, OUT_ARG2(%esp) 24536 call dvmCheckBefore # (dPC, dFP, self) 24537 movl rSELF, %eax 245381: 24539 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 24540 jmp *dvmAsmInstructionStart+(501*4) 24541 24542/* ------------------------------ */ 24543.L_ALT_OP_IPUT_VOLATILE_JUMBO: /* 0x1f6 */ 24544/* File: x86/alt_stub.S */ 24545/* 24546 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 24547 * any interesting requests and then jump to the real instruction 24548 * handler. Unlike the Arm handler, we can't do this as a tail call 24549 * because rIBASE is caller save and we need to reload it. 24550 * 24551 * Note that unlike in the Arm implementation, we should never arrive 24552 * here with a zero breakFlag because we always refresh rIBASE on 24553 * return. 24554 */ 24555 EXPORT_PC 24556 movl rSELF, %eax 24557 movl rPC, OUT_ARG0(%esp) 24558 cmpb $0,offThread_breakFlags(%eax) # anything to do? 24559 movl rFP, OUT_ARG1(%esp) 24560 je 1f # reload rIBASE & resume if not 24561 movl %eax, OUT_ARG2(%esp) 24562 call dvmCheckBefore # (dPC, dFP, self) 24563 movl rSELF, %eax 245641: 24565 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 24566 jmp *dvmAsmInstructionStart+(502*4) 24567 24568/* ------------------------------ */ 24569.L_ALT_OP_IPUT_WIDE_VOLATILE_JUMBO: /* 0x1f7 */ 24570/* File: x86/alt_stub.S */ 24571/* 24572 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 24573 * any interesting requests and then jump to the real instruction 24574 * handler. Unlike the Arm handler, we can't do this as a tail call 24575 * because rIBASE is caller save and we need to reload it. 24576 * 24577 * Note that unlike in the Arm implementation, we should never arrive 24578 * here with a zero breakFlag because we always refresh rIBASE on 24579 * return. 24580 */ 24581 EXPORT_PC 24582 movl rSELF, %eax 24583 movl rPC, OUT_ARG0(%esp) 24584 cmpb $0,offThread_breakFlags(%eax) # anything to do? 24585 movl rFP, OUT_ARG1(%esp) 24586 je 1f # reload rIBASE & resume if not 24587 movl %eax, OUT_ARG2(%esp) 24588 call dvmCheckBefore # (dPC, dFP, self) 24589 movl rSELF, %eax 245901: 24591 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 24592 jmp *dvmAsmInstructionStart+(503*4) 24593 24594/* ------------------------------ */ 24595.L_ALT_OP_IPUT_OBJECT_VOLATILE_JUMBO: /* 0x1f8 */ 24596/* File: x86/alt_stub.S */ 24597/* 24598 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 24599 * any interesting requests and then jump to the real instruction 24600 * handler. Unlike the Arm handler, we can't do this as a tail call 24601 * because rIBASE is caller save and we need to reload it. 24602 * 24603 * Note that unlike in the Arm implementation, we should never arrive 24604 * here with a zero breakFlag because we always refresh rIBASE on 24605 * return. 24606 */ 24607 EXPORT_PC 24608 movl rSELF, %eax 24609 movl rPC, OUT_ARG0(%esp) 24610 cmpb $0,offThread_breakFlags(%eax) # anything to do? 24611 movl rFP, OUT_ARG1(%esp) 24612 je 1f # reload rIBASE & resume if not 24613 movl %eax, OUT_ARG2(%esp) 24614 call dvmCheckBefore # (dPC, dFP, self) 24615 movl rSELF, %eax 246161: 24617 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 24618 jmp *dvmAsmInstructionStart+(504*4) 24619 24620/* ------------------------------ */ 24621.L_ALT_OP_SGET_VOLATILE_JUMBO: /* 0x1f9 */ 24622/* File: x86/alt_stub.S */ 24623/* 24624 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 24625 * any interesting requests and then jump to the real instruction 24626 * handler. Unlike the Arm handler, we can't do this as a tail call 24627 * because rIBASE is caller save and we need to reload it. 24628 * 24629 * Note that unlike in the Arm implementation, we should never arrive 24630 * here with a zero breakFlag because we always refresh rIBASE on 24631 * return. 24632 */ 24633 EXPORT_PC 24634 movl rSELF, %eax 24635 movl rPC, OUT_ARG0(%esp) 24636 cmpb $0,offThread_breakFlags(%eax) # anything to do? 24637 movl rFP, OUT_ARG1(%esp) 24638 je 1f # reload rIBASE & resume if not 24639 movl %eax, OUT_ARG2(%esp) 24640 call dvmCheckBefore # (dPC, dFP, self) 24641 movl rSELF, %eax 246421: 24643 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 24644 jmp *dvmAsmInstructionStart+(505*4) 24645 24646/* ------------------------------ */ 24647.L_ALT_OP_SGET_WIDE_VOLATILE_JUMBO: /* 0x1fa */ 24648/* File: x86/alt_stub.S */ 24649/* 24650 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 24651 * any interesting requests and then jump to the real instruction 24652 * handler. Unlike the Arm handler, we can't do this as a tail call 24653 * because rIBASE is caller save and we need to reload it. 24654 * 24655 * Note that unlike in the Arm implementation, we should never arrive 24656 * here with a zero breakFlag because we always refresh rIBASE on 24657 * return. 24658 */ 24659 EXPORT_PC 24660 movl rSELF, %eax 24661 movl rPC, OUT_ARG0(%esp) 24662 cmpb $0,offThread_breakFlags(%eax) # anything to do? 24663 movl rFP, OUT_ARG1(%esp) 24664 je 1f # reload rIBASE & resume if not 24665 movl %eax, OUT_ARG2(%esp) 24666 call dvmCheckBefore # (dPC, dFP, self) 24667 movl rSELF, %eax 246681: 24669 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 24670 jmp *dvmAsmInstructionStart+(506*4) 24671 24672/* ------------------------------ */ 24673.L_ALT_OP_SGET_OBJECT_VOLATILE_JUMBO: /* 0x1fb */ 24674/* File: x86/alt_stub.S */ 24675/* 24676 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 24677 * any interesting requests and then jump to the real instruction 24678 * handler. Unlike the Arm handler, we can't do this as a tail call 24679 * because rIBASE is caller save and we need to reload it. 24680 * 24681 * Note that unlike in the Arm implementation, we should never arrive 24682 * here with a zero breakFlag because we always refresh rIBASE on 24683 * return. 24684 */ 24685 EXPORT_PC 24686 movl rSELF, %eax 24687 movl rPC, OUT_ARG0(%esp) 24688 cmpb $0,offThread_breakFlags(%eax) # anything to do? 24689 movl rFP, OUT_ARG1(%esp) 24690 je 1f # reload rIBASE & resume if not 24691 movl %eax, OUT_ARG2(%esp) 24692 call dvmCheckBefore # (dPC, dFP, self) 24693 movl rSELF, %eax 246941: 24695 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 24696 jmp *dvmAsmInstructionStart+(507*4) 24697 24698/* ------------------------------ */ 24699.L_ALT_OP_SPUT_VOLATILE_JUMBO: /* 0x1fc */ 24700/* File: x86/alt_stub.S */ 24701/* 24702 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 24703 * any interesting requests and then jump to the real instruction 24704 * handler. Unlike the Arm handler, we can't do this as a tail call 24705 * because rIBASE is caller save and we need to reload it. 24706 * 24707 * Note that unlike in the Arm implementation, we should never arrive 24708 * here with a zero breakFlag because we always refresh rIBASE on 24709 * return. 24710 */ 24711 EXPORT_PC 24712 movl rSELF, %eax 24713 movl rPC, OUT_ARG0(%esp) 24714 cmpb $0,offThread_breakFlags(%eax) # anything to do? 24715 movl rFP, OUT_ARG1(%esp) 24716 je 1f # reload rIBASE & resume if not 24717 movl %eax, OUT_ARG2(%esp) 24718 call dvmCheckBefore # (dPC, dFP, self) 24719 movl rSELF, %eax 247201: 24721 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 24722 jmp *dvmAsmInstructionStart+(508*4) 24723 24724/* ------------------------------ */ 24725.L_ALT_OP_SPUT_WIDE_VOLATILE_JUMBO: /* 0x1fd */ 24726/* File: x86/alt_stub.S */ 24727/* 24728 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 24729 * any interesting requests and then jump to the real instruction 24730 * handler. Unlike the Arm handler, we can't do this as a tail call 24731 * because rIBASE is caller save and we need to reload it. 24732 * 24733 * Note that unlike in the Arm implementation, we should never arrive 24734 * here with a zero breakFlag because we always refresh rIBASE on 24735 * return. 24736 */ 24737 EXPORT_PC 24738 movl rSELF, %eax 24739 movl rPC, OUT_ARG0(%esp) 24740 cmpb $0,offThread_breakFlags(%eax) # anything to do? 24741 movl rFP, OUT_ARG1(%esp) 24742 je 1f # reload rIBASE & resume if not 24743 movl %eax, OUT_ARG2(%esp) 24744 call dvmCheckBefore # (dPC, dFP, self) 24745 movl rSELF, %eax 247461: 24747 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 24748 jmp *dvmAsmInstructionStart+(509*4) 24749 24750/* ------------------------------ */ 24751.L_ALT_OP_SPUT_OBJECT_VOLATILE_JUMBO: /* 0x1fe */ 24752/* File: x86/alt_stub.S */ 24753/* 24754 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 24755 * any interesting requests and then jump to the real instruction 24756 * handler. Unlike the Arm handler, we can't do this as a tail call 24757 * because rIBASE is caller save and we need to reload it. 24758 * 24759 * Note that unlike in the Arm implementation, we should never arrive 24760 * here with a zero breakFlag because we always refresh rIBASE on 24761 * return. 24762 */ 24763 EXPORT_PC 24764 movl rSELF, %eax 24765 movl rPC, OUT_ARG0(%esp) 24766 cmpb $0,offThread_breakFlags(%eax) # anything to do? 24767 movl rFP, OUT_ARG1(%esp) 24768 je 1f # reload rIBASE & resume if not 24769 movl %eax, OUT_ARG2(%esp) 24770 call dvmCheckBefore # (dPC, dFP, self) 24771 movl rSELF, %eax 247721: 24773 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 24774 jmp *dvmAsmInstructionStart+(510*4) 24775 24776/* ------------------------------ */ 24777.L_ALT_OP_THROW_VERIFICATION_ERROR_JUMBO: /* 0x1ff */ 24778/* File: x86/alt_stub.S */ 24779/* 24780 * Inter-instruction transfer stub. Call out to dvmCheckBefore to handle 24781 * any interesting requests and then jump to the real instruction 24782 * handler. Unlike the Arm handler, we can't do this as a tail call 24783 * because rIBASE is caller save and we need to reload it. 24784 * 24785 * Note that unlike in the Arm implementation, we should never arrive 24786 * here with a zero breakFlag because we always refresh rIBASE on 24787 * return. 24788 */ 24789 EXPORT_PC 24790 movl rSELF, %eax 24791 movl rPC, OUT_ARG0(%esp) 24792 cmpb $0,offThread_breakFlags(%eax) # anything to do? 24793 movl rFP, OUT_ARG1(%esp) 24794 je 1f # reload rIBASE & resume if not 24795 movl %eax, OUT_ARG2(%esp) 24796 call dvmCheckBefore # (dPC, dFP, self) 24797 movl rSELF, %eax 247981: 24799 movl offThread_curHandlerTable(%eax), rIBASE # reload rIBASE 24800 jmp *dvmAsmInstructionStart+(511*4) 24801 24802 .size dvmAsmAltInstructionStartCode, .-dvmAsmAltInstructionStartCode 24803 .global dvmAsmAltInstructionEndCode 24804dvmAsmAltInstructionEndCode: 24805 24806 .global dvmAsmInstructionStart 24807 .text 24808dvmAsmInstructionStart: 24809 .long .L_OP_NOP /* 0x00 */ 24810 .long .L_OP_MOVE /* 0x01 */ 24811 .long .L_OP_MOVE_FROM16 /* 0x02 */ 24812 .long .L_OP_MOVE_16 /* 0x03 */ 24813 .long .L_OP_MOVE_WIDE /* 0x04 */ 24814 .long .L_OP_MOVE_WIDE_FROM16 /* 0x05 */ 24815 .long .L_OP_MOVE_WIDE_16 /* 0x06 */ 24816 .long .L_OP_MOVE_OBJECT /* 0x07 */ 24817 .long .L_OP_MOVE_OBJECT_FROM16 /* 0x08 */ 24818 .long .L_OP_MOVE_OBJECT_16 /* 0x09 */ 24819 .long .L_OP_MOVE_RESULT /* 0x0a */ 24820 .long .L_OP_MOVE_RESULT_WIDE /* 0x0b */ 24821 .long .L_OP_MOVE_RESULT_OBJECT /* 0x0c */ 24822 .long .L_OP_MOVE_EXCEPTION /* 0x0d */ 24823 .long .L_OP_RETURN_VOID /* 0x0e */ 24824 .long .L_OP_RETURN /* 0x0f */ 24825 .long .L_OP_RETURN_WIDE /* 0x10 */ 24826 .long .L_OP_RETURN_OBJECT /* 0x11 */ 24827 .long .L_OP_CONST_4 /* 0x12 */ 24828 .long .L_OP_CONST_16 /* 0x13 */ 24829 .long .L_OP_CONST /* 0x14 */ 24830 .long .L_OP_CONST_HIGH16 /* 0x15 */ 24831 .long .L_OP_CONST_WIDE_16 /* 0x16 */ 24832 .long .L_OP_CONST_WIDE_32 /* 0x17 */ 24833 .long .L_OP_CONST_WIDE /* 0x18 */ 24834 .long .L_OP_CONST_WIDE_HIGH16 /* 0x19 */ 24835 .long .L_OP_CONST_STRING /* 0x1a */ 24836 .long .L_OP_CONST_STRING_JUMBO /* 0x1b */ 24837 .long .L_OP_CONST_CLASS /* 0x1c */ 24838 .long .L_OP_MONITOR_ENTER /* 0x1d */ 24839 .long .L_OP_MONITOR_EXIT /* 0x1e */ 24840 .long .L_OP_CHECK_CAST /* 0x1f */ 24841 .long .L_OP_INSTANCE_OF /* 0x20 */ 24842 .long .L_OP_ARRAY_LENGTH /* 0x21 */ 24843 .long .L_OP_NEW_INSTANCE /* 0x22 */ 24844 .long .L_OP_NEW_ARRAY /* 0x23 */ 24845 .long .L_OP_FILLED_NEW_ARRAY /* 0x24 */ 24846 .long .L_OP_FILLED_NEW_ARRAY_RANGE /* 0x25 */ 24847 .long .L_OP_FILL_ARRAY_DATA /* 0x26 */ 24848 .long .L_OP_THROW /* 0x27 */ 24849 .long .L_OP_GOTO /* 0x28 */ 24850 .long .L_OP_GOTO_16 /* 0x29 */ 24851 .long .L_OP_GOTO_32 /* 0x2a */ 24852 .long .L_OP_PACKED_SWITCH /* 0x2b */ 24853 .long .L_OP_SPARSE_SWITCH /* 0x2c */ 24854 .long .L_OP_CMPL_FLOAT /* 0x2d */ 24855 .long .L_OP_CMPG_FLOAT /* 0x2e */ 24856 .long .L_OP_CMPL_DOUBLE /* 0x2f */ 24857 .long .L_OP_CMPG_DOUBLE /* 0x30 */ 24858 .long .L_OP_CMP_LONG /* 0x31 */ 24859 .long .L_OP_IF_EQ /* 0x32 */ 24860 .long .L_OP_IF_NE /* 0x33 */ 24861 .long .L_OP_IF_LT /* 0x34 */ 24862 .long .L_OP_IF_GE /* 0x35 */ 24863 .long .L_OP_IF_GT /* 0x36 */ 24864 .long .L_OP_IF_LE /* 0x37 */ 24865 .long .L_OP_IF_EQZ /* 0x38 */ 24866 .long .L_OP_IF_NEZ /* 0x39 */ 24867 .long .L_OP_IF_LTZ /* 0x3a */ 24868 .long .L_OP_IF_GEZ /* 0x3b */ 24869 .long .L_OP_IF_GTZ /* 0x3c */ 24870 .long .L_OP_IF_LEZ /* 0x3d */ 24871 .long .L_OP_UNUSED_3E /* 0x3e */ 24872 .long .L_OP_UNUSED_3F /* 0x3f */ 24873 .long .L_OP_UNUSED_40 /* 0x40 */ 24874 .long .L_OP_UNUSED_41 /* 0x41 */ 24875 .long .L_OP_UNUSED_42 /* 0x42 */ 24876 .long .L_OP_UNUSED_43 /* 0x43 */ 24877 .long .L_OP_AGET /* 0x44 */ 24878 .long .L_OP_AGET_WIDE /* 0x45 */ 24879 .long .L_OP_AGET_OBJECT /* 0x46 */ 24880 .long .L_OP_AGET_BOOLEAN /* 0x47 */ 24881 .long .L_OP_AGET_BYTE /* 0x48 */ 24882 .long .L_OP_AGET_CHAR /* 0x49 */ 24883 .long .L_OP_AGET_SHORT /* 0x4a */ 24884 .long .L_OP_APUT /* 0x4b */ 24885 .long .L_OP_APUT_WIDE /* 0x4c */ 24886 .long .L_OP_APUT_OBJECT /* 0x4d */ 24887 .long .L_OP_APUT_BOOLEAN /* 0x4e */ 24888 .long .L_OP_APUT_BYTE /* 0x4f */ 24889 .long .L_OP_APUT_CHAR /* 0x50 */ 24890 .long .L_OP_APUT_SHORT /* 0x51 */ 24891 .long .L_OP_IGET /* 0x52 */ 24892 .long .L_OP_IGET_WIDE /* 0x53 */ 24893 .long .L_OP_IGET_OBJECT /* 0x54 */ 24894 .long .L_OP_IGET_BOOLEAN /* 0x55 */ 24895 .long .L_OP_IGET_BYTE /* 0x56 */ 24896 .long .L_OP_IGET_CHAR /* 0x57 */ 24897 .long .L_OP_IGET_SHORT /* 0x58 */ 24898 .long .L_OP_IPUT /* 0x59 */ 24899 .long .L_OP_IPUT_WIDE /* 0x5a */ 24900 .long .L_OP_IPUT_OBJECT /* 0x5b */ 24901 .long .L_OP_IPUT_BOOLEAN /* 0x5c */ 24902 .long .L_OP_IPUT_BYTE /* 0x5d */ 24903 .long .L_OP_IPUT_CHAR /* 0x5e */ 24904 .long .L_OP_IPUT_SHORT /* 0x5f */ 24905 .long .L_OP_SGET /* 0x60 */ 24906 .long .L_OP_SGET_WIDE /* 0x61 */ 24907 .long .L_OP_SGET_OBJECT /* 0x62 */ 24908 .long .L_OP_SGET_BOOLEAN /* 0x63 */ 24909 .long .L_OP_SGET_BYTE /* 0x64 */ 24910 .long .L_OP_SGET_CHAR /* 0x65 */ 24911 .long .L_OP_SGET_SHORT /* 0x66 */ 24912 .long .L_OP_SPUT /* 0x67 */ 24913 .long .L_OP_SPUT_WIDE /* 0x68 */ 24914 .long .L_OP_SPUT_OBJECT /* 0x69 */ 24915 .long .L_OP_SPUT_BOOLEAN /* 0x6a */ 24916 .long .L_OP_SPUT_BYTE /* 0x6b */ 24917 .long .L_OP_SPUT_CHAR /* 0x6c */ 24918 .long .L_OP_SPUT_SHORT /* 0x6d */ 24919 .long .L_OP_INVOKE_VIRTUAL /* 0x6e */ 24920 .long .L_OP_INVOKE_SUPER /* 0x6f */ 24921 .long .L_OP_INVOKE_DIRECT /* 0x70 */ 24922 .long .L_OP_INVOKE_STATIC /* 0x71 */ 24923 .long .L_OP_INVOKE_INTERFACE /* 0x72 */ 24924 .long .L_OP_UNUSED_73 /* 0x73 */ 24925 .long .L_OP_INVOKE_VIRTUAL_RANGE /* 0x74 */ 24926 .long .L_OP_INVOKE_SUPER_RANGE /* 0x75 */ 24927 .long .L_OP_INVOKE_DIRECT_RANGE /* 0x76 */ 24928 .long .L_OP_INVOKE_STATIC_RANGE /* 0x77 */ 24929 .long .L_OP_INVOKE_INTERFACE_RANGE /* 0x78 */ 24930 .long .L_OP_UNUSED_79 /* 0x79 */ 24931 .long .L_OP_UNUSED_7A /* 0x7a */ 24932 .long .L_OP_NEG_INT /* 0x7b */ 24933 .long .L_OP_NOT_INT /* 0x7c */ 24934 .long .L_OP_NEG_LONG /* 0x7d */ 24935 .long .L_OP_NOT_LONG /* 0x7e */ 24936 .long .L_OP_NEG_FLOAT /* 0x7f */ 24937 .long .L_OP_NEG_DOUBLE /* 0x80 */ 24938 .long .L_OP_INT_TO_LONG /* 0x81 */ 24939 .long .L_OP_INT_TO_FLOAT /* 0x82 */ 24940 .long .L_OP_INT_TO_DOUBLE /* 0x83 */ 24941 .long .L_OP_LONG_TO_INT /* 0x84 */ 24942 .long .L_OP_LONG_TO_FLOAT /* 0x85 */ 24943 .long .L_OP_LONG_TO_DOUBLE /* 0x86 */ 24944 .long .L_OP_FLOAT_TO_INT /* 0x87 */ 24945 .long .L_OP_FLOAT_TO_LONG /* 0x88 */ 24946 .long .L_OP_FLOAT_TO_DOUBLE /* 0x89 */ 24947 .long .L_OP_DOUBLE_TO_INT /* 0x8a */ 24948 .long .L_OP_DOUBLE_TO_LONG /* 0x8b */ 24949 .long .L_OP_DOUBLE_TO_FLOAT /* 0x8c */ 24950 .long .L_OP_INT_TO_BYTE /* 0x8d */ 24951 .long .L_OP_INT_TO_CHAR /* 0x8e */ 24952 .long .L_OP_INT_TO_SHORT /* 0x8f */ 24953 .long .L_OP_ADD_INT /* 0x90 */ 24954 .long .L_OP_SUB_INT /* 0x91 */ 24955 .long .L_OP_MUL_INT /* 0x92 */ 24956 .long .L_OP_DIV_INT /* 0x93 */ 24957 .long .L_OP_REM_INT /* 0x94 */ 24958 .long .L_OP_AND_INT /* 0x95 */ 24959 .long .L_OP_OR_INT /* 0x96 */ 24960 .long .L_OP_XOR_INT /* 0x97 */ 24961 .long .L_OP_SHL_INT /* 0x98 */ 24962 .long .L_OP_SHR_INT /* 0x99 */ 24963 .long .L_OP_USHR_INT /* 0x9a */ 24964 .long .L_OP_ADD_LONG /* 0x9b */ 24965 .long .L_OP_SUB_LONG /* 0x9c */ 24966 .long .L_OP_MUL_LONG /* 0x9d */ 24967 .long .L_OP_DIV_LONG /* 0x9e */ 24968 .long .L_OP_REM_LONG /* 0x9f */ 24969 .long .L_OP_AND_LONG /* 0xa0 */ 24970 .long .L_OP_OR_LONG /* 0xa1 */ 24971 .long .L_OP_XOR_LONG /* 0xa2 */ 24972 .long .L_OP_SHL_LONG /* 0xa3 */ 24973 .long .L_OP_SHR_LONG /* 0xa4 */ 24974 .long .L_OP_USHR_LONG /* 0xa5 */ 24975 .long .L_OP_ADD_FLOAT /* 0xa6 */ 24976 .long .L_OP_SUB_FLOAT /* 0xa7 */ 24977 .long .L_OP_MUL_FLOAT /* 0xa8 */ 24978 .long .L_OP_DIV_FLOAT /* 0xa9 */ 24979 .long .L_OP_REM_FLOAT /* 0xaa */ 24980 .long .L_OP_ADD_DOUBLE /* 0xab */ 24981 .long .L_OP_SUB_DOUBLE /* 0xac */ 24982 .long .L_OP_MUL_DOUBLE /* 0xad */ 24983 .long .L_OP_DIV_DOUBLE /* 0xae */ 24984 .long .L_OP_REM_DOUBLE /* 0xaf */ 24985 .long .L_OP_ADD_INT_2ADDR /* 0xb0 */ 24986 .long .L_OP_SUB_INT_2ADDR /* 0xb1 */ 24987 .long .L_OP_MUL_INT_2ADDR /* 0xb2 */ 24988 .long .L_OP_DIV_INT_2ADDR /* 0xb3 */ 24989 .long .L_OP_REM_INT_2ADDR /* 0xb4 */ 24990 .long .L_OP_AND_INT_2ADDR /* 0xb5 */ 24991 .long .L_OP_OR_INT_2ADDR /* 0xb6 */ 24992 .long .L_OP_XOR_INT_2ADDR /* 0xb7 */ 24993 .long .L_OP_SHL_INT_2ADDR /* 0xb8 */ 24994 .long .L_OP_SHR_INT_2ADDR /* 0xb9 */ 24995 .long .L_OP_USHR_INT_2ADDR /* 0xba */ 24996 .long .L_OP_ADD_LONG_2ADDR /* 0xbb */ 24997 .long .L_OP_SUB_LONG_2ADDR /* 0xbc */ 24998 .long .L_OP_MUL_LONG_2ADDR /* 0xbd */ 24999 .long .L_OP_DIV_LONG_2ADDR /* 0xbe */ 25000 .long .L_OP_REM_LONG_2ADDR /* 0xbf */ 25001 .long .L_OP_AND_LONG_2ADDR /* 0xc0 */ 25002 .long .L_OP_OR_LONG_2ADDR /* 0xc1 */ 25003 .long .L_OP_XOR_LONG_2ADDR /* 0xc2 */ 25004 .long .L_OP_SHL_LONG_2ADDR /* 0xc3 */ 25005 .long .L_OP_SHR_LONG_2ADDR /* 0xc4 */ 25006 .long .L_OP_USHR_LONG_2ADDR /* 0xc5 */ 25007 .long .L_OP_ADD_FLOAT_2ADDR /* 0xc6 */ 25008 .long .L_OP_SUB_FLOAT_2ADDR /* 0xc7 */ 25009 .long .L_OP_MUL_FLOAT_2ADDR /* 0xc8 */ 25010 .long .L_OP_DIV_FLOAT_2ADDR /* 0xc9 */ 25011 .long .L_OP_REM_FLOAT_2ADDR /* 0xca */ 25012 .long .L_OP_ADD_DOUBLE_2ADDR /* 0xcb */ 25013 .long .L_OP_SUB_DOUBLE_2ADDR /* 0xcc */ 25014 .long .L_OP_MUL_DOUBLE_2ADDR /* 0xcd */ 25015 .long .L_OP_DIV_DOUBLE_2ADDR /* 0xce */ 25016 .long .L_OP_REM_DOUBLE_2ADDR /* 0xcf */ 25017 .long .L_OP_ADD_INT_LIT16 /* 0xd0 */ 25018 .long .L_OP_RSUB_INT /* 0xd1 */ 25019 .long .L_OP_MUL_INT_LIT16 /* 0xd2 */ 25020 .long .L_OP_DIV_INT_LIT16 /* 0xd3 */ 25021 .long .L_OP_REM_INT_LIT16 /* 0xd4 */ 25022 .long .L_OP_AND_INT_LIT16 /* 0xd5 */ 25023 .long .L_OP_OR_INT_LIT16 /* 0xd6 */ 25024 .long .L_OP_XOR_INT_LIT16 /* 0xd7 */ 25025 .long .L_OP_ADD_INT_LIT8 /* 0xd8 */ 25026 .long .L_OP_RSUB_INT_LIT8 /* 0xd9 */ 25027 .long .L_OP_MUL_INT_LIT8 /* 0xda */ 25028 .long .L_OP_DIV_INT_LIT8 /* 0xdb */ 25029 .long .L_OP_REM_INT_LIT8 /* 0xdc */ 25030 .long .L_OP_AND_INT_LIT8 /* 0xdd */ 25031 .long .L_OP_OR_INT_LIT8 /* 0xde */ 25032 .long .L_OP_XOR_INT_LIT8 /* 0xdf */ 25033 .long .L_OP_SHL_INT_LIT8 /* 0xe0 */ 25034 .long .L_OP_SHR_INT_LIT8 /* 0xe1 */ 25035 .long .L_OP_USHR_INT_LIT8 /* 0xe2 */ 25036 .long .L_OP_IGET_VOLATILE /* 0xe3 */ 25037 .long .L_OP_IPUT_VOLATILE /* 0xe4 */ 25038 .long .L_OP_SGET_VOLATILE /* 0xe5 */ 25039 .long .L_OP_SPUT_VOLATILE /* 0xe6 */ 25040 .long .L_OP_IGET_OBJECT_VOLATILE /* 0xe7 */ 25041 .long .L_OP_IGET_WIDE_VOLATILE /* 0xe8 */ 25042 .long .L_OP_IPUT_WIDE_VOLATILE /* 0xe9 */ 25043 .long .L_OP_SGET_WIDE_VOLATILE /* 0xea */ 25044 .long .L_OP_SPUT_WIDE_VOLATILE /* 0xeb */ 25045 .long .L_OP_BREAKPOINT /* 0xec */ 25046 .long .L_OP_THROW_VERIFICATION_ERROR /* 0xed */ 25047 .long .L_OP_EXECUTE_INLINE /* 0xee */ 25048 .long .L_OP_EXECUTE_INLINE_RANGE /* 0xef */ 25049 .long .L_OP_INVOKE_OBJECT_INIT_RANGE /* 0xf0 */ 25050 .long .L_OP_RETURN_VOID_BARRIER /* 0xf1 */ 25051 .long .L_OP_IGET_QUICK /* 0xf2 */ 25052 .long .L_OP_IGET_WIDE_QUICK /* 0xf3 */ 25053 .long .L_OP_IGET_OBJECT_QUICK /* 0xf4 */ 25054 .long .L_OP_IPUT_QUICK /* 0xf5 */ 25055 .long .L_OP_IPUT_WIDE_QUICK /* 0xf6 */ 25056 .long .L_OP_IPUT_OBJECT_QUICK /* 0xf7 */ 25057 .long .L_OP_INVOKE_VIRTUAL_QUICK /* 0xf8 */ 25058 .long .L_OP_INVOKE_VIRTUAL_QUICK_RANGE /* 0xf9 */ 25059 .long .L_OP_INVOKE_SUPER_QUICK /* 0xfa */ 25060 .long .L_OP_INVOKE_SUPER_QUICK_RANGE /* 0xfb */ 25061 .long .L_OP_IPUT_OBJECT_VOLATILE /* 0xfc */ 25062 .long .L_OP_SGET_OBJECT_VOLATILE /* 0xfd */ 25063 .long .L_OP_SPUT_OBJECT_VOLATILE /* 0xfe */ 25064 .long .L_OP_DISPATCH_FF /* 0xff */ 25065 .long .L_OP_CONST_CLASS_JUMBO /* 0x100 */ 25066 .long .L_OP_CHECK_CAST_JUMBO /* 0x101 */ 25067 .long .L_OP_INSTANCE_OF_JUMBO /* 0x102 */ 25068 .long .L_OP_NEW_INSTANCE_JUMBO /* 0x103 */ 25069 .long .L_OP_NEW_ARRAY_JUMBO /* 0x104 */ 25070 .long .L_OP_FILLED_NEW_ARRAY_JUMBO /* 0x105 */ 25071 .long .L_OP_IGET_JUMBO /* 0x106 */ 25072 .long .L_OP_IGET_WIDE_JUMBO /* 0x107 */ 25073 .long .L_OP_IGET_OBJECT_JUMBO /* 0x108 */ 25074 .long .L_OP_IGET_BOOLEAN_JUMBO /* 0x109 */ 25075 .long .L_OP_IGET_BYTE_JUMBO /* 0x10a */ 25076 .long .L_OP_IGET_CHAR_JUMBO /* 0x10b */ 25077 .long .L_OP_IGET_SHORT_JUMBO /* 0x10c */ 25078 .long .L_OP_IPUT_JUMBO /* 0x10d */ 25079 .long .L_OP_IPUT_WIDE_JUMBO /* 0x10e */ 25080 .long .L_OP_IPUT_OBJECT_JUMBO /* 0x10f */ 25081 .long .L_OP_IPUT_BOOLEAN_JUMBO /* 0x110 */ 25082 .long .L_OP_IPUT_BYTE_JUMBO /* 0x111 */ 25083 .long .L_OP_IPUT_CHAR_JUMBO /* 0x112 */ 25084 .long .L_OP_IPUT_SHORT_JUMBO /* 0x113 */ 25085 .long .L_OP_SGET_JUMBO /* 0x114 */ 25086 .long .L_OP_SGET_WIDE_JUMBO /* 0x115 */ 25087 .long .L_OP_SGET_OBJECT_JUMBO /* 0x116 */ 25088 .long .L_OP_SGET_BOOLEAN_JUMBO /* 0x117 */ 25089 .long .L_OP_SGET_BYTE_JUMBO /* 0x118 */ 25090 .long .L_OP_SGET_CHAR_JUMBO /* 0x119 */ 25091 .long .L_OP_SGET_SHORT_JUMBO /* 0x11a */ 25092 .long .L_OP_SPUT_JUMBO /* 0x11b */ 25093 .long .L_OP_SPUT_WIDE_JUMBO /* 0x11c */ 25094 .long .L_OP_SPUT_OBJECT_JUMBO /* 0x11d */ 25095 .long .L_OP_SPUT_BOOLEAN_JUMBO /* 0x11e */ 25096 .long .L_OP_SPUT_BYTE_JUMBO /* 0x11f */ 25097 .long .L_OP_SPUT_CHAR_JUMBO /* 0x120 */ 25098 .long .L_OP_SPUT_SHORT_JUMBO /* 0x121 */ 25099 .long .L_OP_INVOKE_VIRTUAL_JUMBO /* 0x122 */ 25100 .long .L_OP_INVOKE_SUPER_JUMBO /* 0x123 */ 25101 .long .L_OP_INVOKE_DIRECT_JUMBO /* 0x124 */ 25102 .long .L_OP_INVOKE_STATIC_JUMBO /* 0x125 */ 25103 .long .L_OP_INVOKE_INTERFACE_JUMBO /* 0x126 */ 25104 .long .L_OP_UNUSED_27FF /* 0x127 */ 25105 .long .L_OP_UNUSED_28FF /* 0x128 */ 25106 .long .L_OP_UNUSED_29FF /* 0x129 */ 25107 .long .L_OP_UNUSED_2AFF /* 0x12a */ 25108 .long .L_OP_UNUSED_2BFF /* 0x12b */ 25109 .long .L_OP_UNUSED_2CFF /* 0x12c */ 25110 .long .L_OP_UNUSED_2DFF /* 0x12d */ 25111 .long .L_OP_UNUSED_2EFF /* 0x12e */ 25112 .long .L_OP_UNUSED_2FFF /* 0x12f */ 25113 .long .L_OP_UNUSED_30FF /* 0x130 */ 25114 .long .L_OP_UNUSED_31FF /* 0x131 */ 25115 .long .L_OP_UNUSED_32FF /* 0x132 */ 25116 .long .L_OP_UNUSED_33FF /* 0x133 */ 25117 .long .L_OP_UNUSED_34FF /* 0x134 */ 25118 .long .L_OP_UNUSED_35FF /* 0x135 */ 25119 .long .L_OP_UNUSED_36FF /* 0x136 */ 25120 .long .L_OP_UNUSED_37FF /* 0x137 */ 25121 .long .L_OP_UNUSED_38FF /* 0x138 */ 25122 .long .L_OP_UNUSED_39FF /* 0x139 */ 25123 .long .L_OP_UNUSED_3AFF /* 0x13a */ 25124 .long .L_OP_UNUSED_3BFF /* 0x13b */ 25125 .long .L_OP_UNUSED_3CFF /* 0x13c */ 25126 .long .L_OP_UNUSED_3DFF /* 0x13d */ 25127 .long .L_OP_UNUSED_3EFF /* 0x13e */ 25128 .long .L_OP_UNUSED_3FFF /* 0x13f */ 25129 .long .L_OP_UNUSED_40FF /* 0x140 */ 25130 .long .L_OP_UNUSED_41FF /* 0x141 */ 25131 .long .L_OP_UNUSED_42FF /* 0x142 */ 25132 .long .L_OP_UNUSED_43FF /* 0x143 */ 25133 .long .L_OP_UNUSED_44FF /* 0x144 */ 25134 .long .L_OP_UNUSED_45FF /* 0x145 */ 25135 .long .L_OP_UNUSED_46FF /* 0x146 */ 25136 .long .L_OP_UNUSED_47FF /* 0x147 */ 25137 .long .L_OP_UNUSED_48FF /* 0x148 */ 25138 .long .L_OP_UNUSED_49FF /* 0x149 */ 25139 .long .L_OP_UNUSED_4AFF /* 0x14a */ 25140 .long .L_OP_UNUSED_4BFF /* 0x14b */ 25141 .long .L_OP_UNUSED_4CFF /* 0x14c */ 25142 .long .L_OP_UNUSED_4DFF /* 0x14d */ 25143 .long .L_OP_UNUSED_4EFF /* 0x14e */ 25144 .long .L_OP_UNUSED_4FFF /* 0x14f */ 25145 .long .L_OP_UNUSED_50FF /* 0x150 */ 25146 .long .L_OP_UNUSED_51FF /* 0x151 */ 25147 .long .L_OP_UNUSED_52FF /* 0x152 */ 25148 .long .L_OP_UNUSED_53FF /* 0x153 */ 25149 .long .L_OP_UNUSED_54FF /* 0x154 */ 25150 .long .L_OP_UNUSED_55FF /* 0x155 */ 25151 .long .L_OP_UNUSED_56FF /* 0x156 */ 25152 .long .L_OP_UNUSED_57FF /* 0x157 */ 25153 .long .L_OP_UNUSED_58FF /* 0x158 */ 25154 .long .L_OP_UNUSED_59FF /* 0x159 */ 25155 .long .L_OP_UNUSED_5AFF /* 0x15a */ 25156 .long .L_OP_UNUSED_5BFF /* 0x15b */ 25157 .long .L_OP_UNUSED_5CFF /* 0x15c */ 25158 .long .L_OP_UNUSED_5DFF /* 0x15d */ 25159 .long .L_OP_UNUSED_5EFF /* 0x15e */ 25160 .long .L_OP_UNUSED_5FFF /* 0x15f */ 25161 .long .L_OP_UNUSED_60FF /* 0x160 */ 25162 .long .L_OP_UNUSED_61FF /* 0x161 */ 25163 .long .L_OP_UNUSED_62FF /* 0x162 */ 25164 .long .L_OP_UNUSED_63FF /* 0x163 */ 25165 .long .L_OP_UNUSED_64FF /* 0x164 */ 25166 .long .L_OP_UNUSED_65FF /* 0x165 */ 25167 .long .L_OP_UNUSED_66FF /* 0x166 */ 25168 .long .L_OP_UNUSED_67FF /* 0x167 */ 25169 .long .L_OP_UNUSED_68FF /* 0x168 */ 25170 .long .L_OP_UNUSED_69FF /* 0x169 */ 25171 .long .L_OP_UNUSED_6AFF /* 0x16a */ 25172 .long .L_OP_UNUSED_6BFF /* 0x16b */ 25173 .long .L_OP_UNUSED_6CFF /* 0x16c */ 25174 .long .L_OP_UNUSED_6DFF /* 0x16d */ 25175 .long .L_OP_UNUSED_6EFF /* 0x16e */ 25176 .long .L_OP_UNUSED_6FFF /* 0x16f */ 25177 .long .L_OP_UNUSED_70FF /* 0x170 */ 25178 .long .L_OP_UNUSED_71FF /* 0x171 */ 25179 .long .L_OP_UNUSED_72FF /* 0x172 */ 25180 .long .L_OP_UNUSED_73FF /* 0x173 */ 25181 .long .L_OP_UNUSED_74FF /* 0x174 */ 25182 .long .L_OP_UNUSED_75FF /* 0x175 */ 25183 .long .L_OP_UNUSED_76FF /* 0x176 */ 25184 .long .L_OP_UNUSED_77FF /* 0x177 */ 25185 .long .L_OP_UNUSED_78FF /* 0x178 */ 25186 .long .L_OP_UNUSED_79FF /* 0x179 */ 25187 .long .L_OP_UNUSED_7AFF /* 0x17a */ 25188 .long .L_OP_UNUSED_7BFF /* 0x17b */ 25189 .long .L_OP_UNUSED_7CFF /* 0x17c */ 25190 .long .L_OP_UNUSED_7DFF /* 0x17d */ 25191 .long .L_OP_UNUSED_7EFF /* 0x17e */ 25192 .long .L_OP_UNUSED_7FFF /* 0x17f */ 25193 .long .L_OP_UNUSED_80FF /* 0x180 */ 25194 .long .L_OP_UNUSED_81FF /* 0x181 */ 25195 .long .L_OP_UNUSED_82FF /* 0x182 */ 25196 .long .L_OP_UNUSED_83FF /* 0x183 */ 25197 .long .L_OP_UNUSED_84FF /* 0x184 */ 25198 .long .L_OP_UNUSED_85FF /* 0x185 */ 25199 .long .L_OP_UNUSED_86FF /* 0x186 */ 25200 .long .L_OP_UNUSED_87FF /* 0x187 */ 25201 .long .L_OP_UNUSED_88FF /* 0x188 */ 25202 .long .L_OP_UNUSED_89FF /* 0x189 */ 25203 .long .L_OP_UNUSED_8AFF /* 0x18a */ 25204 .long .L_OP_UNUSED_8BFF /* 0x18b */ 25205 .long .L_OP_UNUSED_8CFF /* 0x18c */ 25206 .long .L_OP_UNUSED_8DFF /* 0x18d */ 25207 .long .L_OP_UNUSED_8EFF /* 0x18e */ 25208 .long .L_OP_UNUSED_8FFF /* 0x18f */ 25209 .long .L_OP_UNUSED_90FF /* 0x190 */ 25210 .long .L_OP_UNUSED_91FF /* 0x191 */ 25211 .long .L_OP_UNUSED_92FF /* 0x192 */ 25212 .long .L_OP_UNUSED_93FF /* 0x193 */ 25213 .long .L_OP_UNUSED_94FF /* 0x194 */ 25214 .long .L_OP_UNUSED_95FF /* 0x195 */ 25215 .long .L_OP_UNUSED_96FF /* 0x196 */ 25216 .long .L_OP_UNUSED_97FF /* 0x197 */ 25217 .long .L_OP_UNUSED_98FF /* 0x198 */ 25218 .long .L_OP_UNUSED_99FF /* 0x199 */ 25219 .long .L_OP_UNUSED_9AFF /* 0x19a */ 25220 .long .L_OP_UNUSED_9BFF /* 0x19b */ 25221 .long .L_OP_UNUSED_9CFF /* 0x19c */ 25222 .long .L_OP_UNUSED_9DFF /* 0x19d */ 25223 .long .L_OP_UNUSED_9EFF /* 0x19e */ 25224 .long .L_OP_UNUSED_9FFF /* 0x19f */ 25225 .long .L_OP_UNUSED_A0FF /* 0x1a0 */ 25226 .long .L_OP_UNUSED_A1FF /* 0x1a1 */ 25227 .long .L_OP_UNUSED_A2FF /* 0x1a2 */ 25228 .long .L_OP_UNUSED_A3FF /* 0x1a3 */ 25229 .long .L_OP_UNUSED_A4FF /* 0x1a4 */ 25230 .long .L_OP_UNUSED_A5FF /* 0x1a5 */ 25231 .long .L_OP_UNUSED_A6FF /* 0x1a6 */ 25232 .long .L_OP_UNUSED_A7FF /* 0x1a7 */ 25233 .long .L_OP_UNUSED_A8FF /* 0x1a8 */ 25234 .long .L_OP_UNUSED_A9FF /* 0x1a9 */ 25235 .long .L_OP_UNUSED_AAFF /* 0x1aa */ 25236 .long .L_OP_UNUSED_ABFF /* 0x1ab */ 25237 .long .L_OP_UNUSED_ACFF /* 0x1ac */ 25238 .long .L_OP_UNUSED_ADFF /* 0x1ad */ 25239 .long .L_OP_UNUSED_AEFF /* 0x1ae */ 25240 .long .L_OP_UNUSED_AFFF /* 0x1af */ 25241 .long .L_OP_UNUSED_B0FF /* 0x1b0 */ 25242 .long .L_OP_UNUSED_B1FF /* 0x1b1 */ 25243 .long .L_OP_UNUSED_B2FF /* 0x1b2 */ 25244 .long .L_OP_UNUSED_B3FF /* 0x1b3 */ 25245 .long .L_OP_UNUSED_B4FF /* 0x1b4 */ 25246 .long .L_OP_UNUSED_B5FF /* 0x1b5 */ 25247 .long .L_OP_UNUSED_B6FF /* 0x1b6 */ 25248 .long .L_OP_UNUSED_B7FF /* 0x1b7 */ 25249 .long .L_OP_UNUSED_B8FF /* 0x1b8 */ 25250 .long .L_OP_UNUSED_B9FF /* 0x1b9 */ 25251 .long .L_OP_UNUSED_BAFF /* 0x1ba */ 25252 .long .L_OP_UNUSED_BBFF /* 0x1bb */ 25253 .long .L_OP_UNUSED_BCFF /* 0x1bc */ 25254 .long .L_OP_UNUSED_BDFF /* 0x1bd */ 25255 .long .L_OP_UNUSED_BEFF /* 0x1be */ 25256 .long .L_OP_UNUSED_BFFF /* 0x1bf */ 25257 .long .L_OP_UNUSED_C0FF /* 0x1c0 */ 25258 .long .L_OP_UNUSED_C1FF /* 0x1c1 */ 25259 .long .L_OP_UNUSED_C2FF /* 0x1c2 */ 25260 .long .L_OP_UNUSED_C3FF /* 0x1c3 */ 25261 .long .L_OP_UNUSED_C4FF /* 0x1c4 */ 25262 .long .L_OP_UNUSED_C5FF /* 0x1c5 */ 25263 .long .L_OP_UNUSED_C6FF /* 0x1c6 */ 25264 .long .L_OP_UNUSED_C7FF /* 0x1c7 */ 25265 .long .L_OP_UNUSED_C8FF /* 0x1c8 */ 25266 .long .L_OP_UNUSED_C9FF /* 0x1c9 */ 25267 .long .L_OP_UNUSED_CAFF /* 0x1ca */ 25268 .long .L_OP_UNUSED_CBFF /* 0x1cb */ 25269 .long .L_OP_UNUSED_CCFF /* 0x1cc */ 25270 .long .L_OP_UNUSED_CDFF /* 0x1cd */ 25271 .long .L_OP_UNUSED_CEFF /* 0x1ce */ 25272 .long .L_OP_UNUSED_CFFF /* 0x1cf */ 25273 .long .L_OP_UNUSED_D0FF /* 0x1d0 */ 25274 .long .L_OP_UNUSED_D1FF /* 0x1d1 */ 25275 .long .L_OP_UNUSED_D2FF /* 0x1d2 */ 25276 .long .L_OP_UNUSED_D3FF /* 0x1d3 */ 25277 .long .L_OP_UNUSED_D4FF /* 0x1d4 */ 25278 .long .L_OP_UNUSED_D5FF /* 0x1d5 */ 25279 .long .L_OP_UNUSED_D6FF /* 0x1d6 */ 25280 .long .L_OP_UNUSED_D7FF /* 0x1d7 */ 25281 .long .L_OP_UNUSED_D8FF /* 0x1d8 */ 25282 .long .L_OP_UNUSED_D9FF /* 0x1d9 */ 25283 .long .L_OP_UNUSED_DAFF /* 0x1da */ 25284 .long .L_OP_UNUSED_DBFF /* 0x1db */ 25285 .long .L_OP_UNUSED_DCFF /* 0x1dc */ 25286 .long .L_OP_UNUSED_DDFF /* 0x1dd */ 25287 .long .L_OP_UNUSED_DEFF /* 0x1de */ 25288 .long .L_OP_UNUSED_DFFF /* 0x1df */ 25289 .long .L_OP_UNUSED_E0FF /* 0x1e0 */ 25290 .long .L_OP_UNUSED_E1FF /* 0x1e1 */ 25291 .long .L_OP_UNUSED_E2FF /* 0x1e2 */ 25292 .long .L_OP_UNUSED_E3FF /* 0x1e3 */ 25293 .long .L_OP_UNUSED_E4FF /* 0x1e4 */ 25294 .long .L_OP_UNUSED_E5FF /* 0x1e5 */ 25295 .long .L_OP_UNUSED_E6FF /* 0x1e6 */ 25296 .long .L_OP_UNUSED_E7FF /* 0x1e7 */ 25297 .long .L_OP_UNUSED_E8FF /* 0x1e8 */ 25298 .long .L_OP_UNUSED_E9FF /* 0x1e9 */ 25299 .long .L_OP_UNUSED_EAFF /* 0x1ea */ 25300 .long .L_OP_UNUSED_EBFF /* 0x1eb */ 25301 .long .L_OP_UNUSED_ECFF /* 0x1ec */ 25302 .long .L_OP_UNUSED_EDFF /* 0x1ed */ 25303 .long .L_OP_UNUSED_EEFF /* 0x1ee */ 25304 .long .L_OP_UNUSED_EFFF /* 0x1ef */ 25305 .long .L_OP_UNUSED_F0FF /* 0x1f0 */ 25306 .long .L_OP_UNUSED_F1FF /* 0x1f1 */ 25307 .long .L_OP_INVOKE_OBJECT_INIT_JUMBO /* 0x1f2 */ 25308 .long .L_OP_IGET_VOLATILE_JUMBO /* 0x1f3 */ 25309 .long .L_OP_IGET_WIDE_VOLATILE_JUMBO /* 0x1f4 */ 25310 .long .L_OP_IGET_OBJECT_VOLATILE_JUMBO /* 0x1f5 */ 25311 .long .L_OP_IPUT_VOLATILE_JUMBO /* 0x1f6 */ 25312 .long .L_OP_IPUT_WIDE_VOLATILE_JUMBO /* 0x1f7 */ 25313 .long .L_OP_IPUT_OBJECT_VOLATILE_JUMBO /* 0x1f8 */ 25314 .long .L_OP_SGET_VOLATILE_JUMBO /* 0x1f9 */ 25315 .long .L_OP_SGET_WIDE_VOLATILE_JUMBO /* 0x1fa */ 25316 .long .L_OP_SGET_OBJECT_VOLATILE_JUMBO /* 0x1fb */ 25317 .long .L_OP_SPUT_VOLATILE_JUMBO /* 0x1fc */ 25318 .long .L_OP_SPUT_WIDE_VOLATILE_JUMBO /* 0x1fd */ 25319 .long .L_OP_SPUT_OBJECT_VOLATILE_JUMBO /* 0x1fe */ 25320 .long .L_OP_THROW_VERIFICATION_ERROR_JUMBO /* 0x1ff */ 25321 25322 .global dvmAsmAltInstructionStart 25323 .text 25324dvmAsmAltInstructionStart: 25325 .long .L_ALT_OP_NOP /* 0x00 */ 25326 .long .L_ALT_OP_MOVE /* 0x01 */ 25327 .long .L_ALT_OP_MOVE_FROM16 /* 0x02 */ 25328 .long .L_ALT_OP_MOVE_16 /* 0x03 */ 25329 .long .L_ALT_OP_MOVE_WIDE /* 0x04 */ 25330 .long .L_ALT_OP_MOVE_WIDE_FROM16 /* 0x05 */ 25331 .long .L_ALT_OP_MOVE_WIDE_16 /* 0x06 */ 25332 .long .L_ALT_OP_MOVE_OBJECT /* 0x07 */ 25333 .long .L_ALT_OP_MOVE_OBJECT_FROM16 /* 0x08 */ 25334 .long .L_ALT_OP_MOVE_OBJECT_16 /* 0x09 */ 25335 .long .L_ALT_OP_MOVE_RESULT /* 0x0a */ 25336 .long .L_ALT_OP_MOVE_RESULT_WIDE /* 0x0b */ 25337 .long .L_ALT_OP_MOVE_RESULT_OBJECT /* 0x0c */ 25338 .long .L_ALT_OP_MOVE_EXCEPTION /* 0x0d */ 25339 .long .L_ALT_OP_RETURN_VOID /* 0x0e */ 25340 .long .L_ALT_OP_RETURN /* 0x0f */ 25341 .long .L_ALT_OP_RETURN_WIDE /* 0x10 */ 25342 .long .L_ALT_OP_RETURN_OBJECT /* 0x11 */ 25343 .long .L_ALT_OP_CONST_4 /* 0x12 */ 25344 .long .L_ALT_OP_CONST_16 /* 0x13 */ 25345 .long .L_ALT_OP_CONST /* 0x14 */ 25346 .long .L_ALT_OP_CONST_HIGH16 /* 0x15 */ 25347 .long .L_ALT_OP_CONST_WIDE_16 /* 0x16 */ 25348 .long .L_ALT_OP_CONST_WIDE_32 /* 0x17 */ 25349 .long .L_ALT_OP_CONST_WIDE /* 0x18 */ 25350 .long .L_ALT_OP_CONST_WIDE_HIGH16 /* 0x19 */ 25351 .long .L_ALT_OP_CONST_STRING /* 0x1a */ 25352 .long .L_ALT_OP_CONST_STRING_JUMBO /* 0x1b */ 25353 .long .L_ALT_OP_CONST_CLASS /* 0x1c */ 25354 .long .L_ALT_OP_MONITOR_ENTER /* 0x1d */ 25355 .long .L_ALT_OP_MONITOR_EXIT /* 0x1e */ 25356 .long .L_ALT_OP_CHECK_CAST /* 0x1f */ 25357 .long .L_ALT_OP_INSTANCE_OF /* 0x20 */ 25358 .long .L_ALT_OP_ARRAY_LENGTH /* 0x21 */ 25359 .long .L_ALT_OP_NEW_INSTANCE /* 0x22 */ 25360 .long .L_ALT_OP_NEW_ARRAY /* 0x23 */ 25361 .long .L_ALT_OP_FILLED_NEW_ARRAY /* 0x24 */ 25362 .long .L_ALT_OP_FILLED_NEW_ARRAY_RANGE /* 0x25 */ 25363 .long .L_ALT_OP_FILL_ARRAY_DATA /* 0x26 */ 25364 .long .L_ALT_OP_THROW /* 0x27 */ 25365 .long .L_ALT_OP_GOTO /* 0x28 */ 25366 .long .L_ALT_OP_GOTO_16 /* 0x29 */ 25367 .long .L_ALT_OP_GOTO_32 /* 0x2a */ 25368 .long .L_ALT_OP_PACKED_SWITCH /* 0x2b */ 25369 .long .L_ALT_OP_SPARSE_SWITCH /* 0x2c */ 25370 .long .L_ALT_OP_CMPL_FLOAT /* 0x2d */ 25371 .long .L_ALT_OP_CMPG_FLOAT /* 0x2e */ 25372 .long .L_ALT_OP_CMPL_DOUBLE /* 0x2f */ 25373 .long .L_ALT_OP_CMPG_DOUBLE /* 0x30 */ 25374 .long .L_ALT_OP_CMP_LONG /* 0x31 */ 25375 .long .L_ALT_OP_IF_EQ /* 0x32 */ 25376 .long .L_ALT_OP_IF_NE /* 0x33 */ 25377 .long .L_ALT_OP_IF_LT /* 0x34 */ 25378 .long .L_ALT_OP_IF_GE /* 0x35 */ 25379 .long .L_ALT_OP_IF_GT /* 0x36 */ 25380 .long .L_ALT_OP_IF_LE /* 0x37 */ 25381 .long .L_ALT_OP_IF_EQZ /* 0x38 */ 25382 .long .L_ALT_OP_IF_NEZ /* 0x39 */ 25383 .long .L_ALT_OP_IF_LTZ /* 0x3a */ 25384 .long .L_ALT_OP_IF_GEZ /* 0x3b */ 25385 .long .L_ALT_OP_IF_GTZ /* 0x3c */ 25386 .long .L_ALT_OP_IF_LEZ /* 0x3d */ 25387 .long .L_ALT_OP_UNUSED_3E /* 0x3e */ 25388 .long .L_ALT_OP_UNUSED_3F /* 0x3f */ 25389 .long .L_ALT_OP_UNUSED_40 /* 0x40 */ 25390 .long .L_ALT_OP_UNUSED_41 /* 0x41 */ 25391 .long .L_ALT_OP_UNUSED_42 /* 0x42 */ 25392 .long .L_ALT_OP_UNUSED_43 /* 0x43 */ 25393 .long .L_ALT_OP_AGET /* 0x44 */ 25394 .long .L_ALT_OP_AGET_WIDE /* 0x45 */ 25395 .long .L_ALT_OP_AGET_OBJECT /* 0x46 */ 25396 .long .L_ALT_OP_AGET_BOOLEAN /* 0x47 */ 25397 .long .L_ALT_OP_AGET_BYTE /* 0x48 */ 25398 .long .L_ALT_OP_AGET_CHAR /* 0x49 */ 25399 .long .L_ALT_OP_AGET_SHORT /* 0x4a */ 25400 .long .L_ALT_OP_APUT /* 0x4b */ 25401 .long .L_ALT_OP_APUT_WIDE /* 0x4c */ 25402 .long .L_ALT_OP_APUT_OBJECT /* 0x4d */ 25403 .long .L_ALT_OP_APUT_BOOLEAN /* 0x4e */ 25404 .long .L_ALT_OP_APUT_BYTE /* 0x4f */ 25405 .long .L_ALT_OP_APUT_CHAR /* 0x50 */ 25406 .long .L_ALT_OP_APUT_SHORT /* 0x51 */ 25407 .long .L_ALT_OP_IGET /* 0x52 */ 25408 .long .L_ALT_OP_IGET_WIDE /* 0x53 */ 25409 .long .L_ALT_OP_IGET_OBJECT /* 0x54 */ 25410 .long .L_ALT_OP_IGET_BOOLEAN /* 0x55 */ 25411 .long .L_ALT_OP_IGET_BYTE /* 0x56 */ 25412 .long .L_ALT_OP_IGET_CHAR /* 0x57 */ 25413 .long .L_ALT_OP_IGET_SHORT /* 0x58 */ 25414 .long .L_ALT_OP_IPUT /* 0x59 */ 25415 .long .L_ALT_OP_IPUT_WIDE /* 0x5a */ 25416 .long .L_ALT_OP_IPUT_OBJECT /* 0x5b */ 25417 .long .L_ALT_OP_IPUT_BOOLEAN /* 0x5c */ 25418 .long .L_ALT_OP_IPUT_BYTE /* 0x5d */ 25419 .long .L_ALT_OP_IPUT_CHAR /* 0x5e */ 25420 .long .L_ALT_OP_IPUT_SHORT /* 0x5f */ 25421 .long .L_ALT_OP_SGET /* 0x60 */ 25422 .long .L_ALT_OP_SGET_WIDE /* 0x61 */ 25423 .long .L_ALT_OP_SGET_OBJECT /* 0x62 */ 25424 .long .L_ALT_OP_SGET_BOOLEAN /* 0x63 */ 25425 .long .L_ALT_OP_SGET_BYTE /* 0x64 */ 25426 .long .L_ALT_OP_SGET_CHAR /* 0x65 */ 25427 .long .L_ALT_OP_SGET_SHORT /* 0x66 */ 25428 .long .L_ALT_OP_SPUT /* 0x67 */ 25429 .long .L_ALT_OP_SPUT_WIDE /* 0x68 */ 25430 .long .L_ALT_OP_SPUT_OBJECT /* 0x69 */ 25431 .long .L_ALT_OP_SPUT_BOOLEAN /* 0x6a */ 25432 .long .L_ALT_OP_SPUT_BYTE /* 0x6b */ 25433 .long .L_ALT_OP_SPUT_CHAR /* 0x6c */ 25434 .long .L_ALT_OP_SPUT_SHORT /* 0x6d */ 25435 .long .L_ALT_OP_INVOKE_VIRTUAL /* 0x6e */ 25436 .long .L_ALT_OP_INVOKE_SUPER /* 0x6f */ 25437 .long .L_ALT_OP_INVOKE_DIRECT /* 0x70 */ 25438 .long .L_ALT_OP_INVOKE_STATIC /* 0x71 */ 25439 .long .L_ALT_OP_INVOKE_INTERFACE /* 0x72 */ 25440 .long .L_ALT_OP_UNUSED_73 /* 0x73 */ 25441 .long .L_ALT_OP_INVOKE_VIRTUAL_RANGE /* 0x74 */ 25442 .long .L_ALT_OP_INVOKE_SUPER_RANGE /* 0x75 */ 25443 .long .L_ALT_OP_INVOKE_DIRECT_RANGE /* 0x76 */ 25444 .long .L_ALT_OP_INVOKE_STATIC_RANGE /* 0x77 */ 25445 .long .L_ALT_OP_INVOKE_INTERFACE_RANGE /* 0x78 */ 25446 .long .L_ALT_OP_UNUSED_79 /* 0x79 */ 25447 .long .L_ALT_OP_UNUSED_7A /* 0x7a */ 25448 .long .L_ALT_OP_NEG_INT /* 0x7b */ 25449 .long .L_ALT_OP_NOT_INT /* 0x7c */ 25450 .long .L_ALT_OP_NEG_LONG /* 0x7d */ 25451 .long .L_ALT_OP_NOT_LONG /* 0x7e */ 25452 .long .L_ALT_OP_NEG_FLOAT /* 0x7f */ 25453 .long .L_ALT_OP_NEG_DOUBLE /* 0x80 */ 25454 .long .L_ALT_OP_INT_TO_LONG /* 0x81 */ 25455 .long .L_ALT_OP_INT_TO_FLOAT /* 0x82 */ 25456 .long .L_ALT_OP_INT_TO_DOUBLE /* 0x83 */ 25457 .long .L_ALT_OP_LONG_TO_INT /* 0x84 */ 25458 .long .L_ALT_OP_LONG_TO_FLOAT /* 0x85 */ 25459 .long .L_ALT_OP_LONG_TO_DOUBLE /* 0x86 */ 25460 .long .L_ALT_OP_FLOAT_TO_INT /* 0x87 */ 25461 .long .L_ALT_OP_FLOAT_TO_LONG /* 0x88 */ 25462 .long .L_ALT_OP_FLOAT_TO_DOUBLE /* 0x89 */ 25463 .long .L_ALT_OP_DOUBLE_TO_INT /* 0x8a */ 25464 .long .L_ALT_OP_DOUBLE_TO_LONG /* 0x8b */ 25465 .long .L_ALT_OP_DOUBLE_TO_FLOAT /* 0x8c */ 25466 .long .L_ALT_OP_INT_TO_BYTE /* 0x8d */ 25467 .long .L_ALT_OP_INT_TO_CHAR /* 0x8e */ 25468 .long .L_ALT_OP_INT_TO_SHORT /* 0x8f */ 25469 .long .L_ALT_OP_ADD_INT /* 0x90 */ 25470 .long .L_ALT_OP_SUB_INT /* 0x91 */ 25471 .long .L_ALT_OP_MUL_INT /* 0x92 */ 25472 .long .L_ALT_OP_DIV_INT /* 0x93 */ 25473 .long .L_ALT_OP_REM_INT /* 0x94 */ 25474 .long .L_ALT_OP_AND_INT /* 0x95 */ 25475 .long .L_ALT_OP_OR_INT /* 0x96 */ 25476 .long .L_ALT_OP_XOR_INT /* 0x97 */ 25477 .long .L_ALT_OP_SHL_INT /* 0x98 */ 25478 .long .L_ALT_OP_SHR_INT /* 0x99 */ 25479 .long .L_ALT_OP_USHR_INT /* 0x9a */ 25480 .long .L_ALT_OP_ADD_LONG /* 0x9b */ 25481 .long .L_ALT_OP_SUB_LONG /* 0x9c */ 25482 .long .L_ALT_OP_MUL_LONG /* 0x9d */ 25483 .long .L_ALT_OP_DIV_LONG /* 0x9e */ 25484 .long .L_ALT_OP_REM_LONG /* 0x9f */ 25485 .long .L_ALT_OP_AND_LONG /* 0xa0 */ 25486 .long .L_ALT_OP_OR_LONG /* 0xa1 */ 25487 .long .L_ALT_OP_XOR_LONG /* 0xa2 */ 25488 .long .L_ALT_OP_SHL_LONG /* 0xa3 */ 25489 .long .L_ALT_OP_SHR_LONG /* 0xa4 */ 25490 .long .L_ALT_OP_USHR_LONG /* 0xa5 */ 25491 .long .L_ALT_OP_ADD_FLOAT /* 0xa6 */ 25492 .long .L_ALT_OP_SUB_FLOAT /* 0xa7 */ 25493 .long .L_ALT_OP_MUL_FLOAT /* 0xa8 */ 25494 .long .L_ALT_OP_DIV_FLOAT /* 0xa9 */ 25495 .long .L_ALT_OP_REM_FLOAT /* 0xaa */ 25496 .long .L_ALT_OP_ADD_DOUBLE /* 0xab */ 25497 .long .L_ALT_OP_SUB_DOUBLE /* 0xac */ 25498 .long .L_ALT_OP_MUL_DOUBLE /* 0xad */ 25499 .long .L_ALT_OP_DIV_DOUBLE /* 0xae */ 25500 .long .L_ALT_OP_REM_DOUBLE /* 0xaf */ 25501 .long .L_ALT_OP_ADD_INT_2ADDR /* 0xb0 */ 25502 .long .L_ALT_OP_SUB_INT_2ADDR /* 0xb1 */ 25503 .long .L_ALT_OP_MUL_INT_2ADDR /* 0xb2 */ 25504 .long .L_ALT_OP_DIV_INT_2ADDR /* 0xb3 */ 25505 .long .L_ALT_OP_REM_INT_2ADDR /* 0xb4 */ 25506 .long .L_ALT_OP_AND_INT_2ADDR /* 0xb5 */ 25507 .long .L_ALT_OP_OR_INT_2ADDR /* 0xb6 */ 25508 .long .L_ALT_OP_XOR_INT_2ADDR /* 0xb7 */ 25509 .long .L_ALT_OP_SHL_INT_2ADDR /* 0xb8 */ 25510 .long .L_ALT_OP_SHR_INT_2ADDR /* 0xb9 */ 25511 .long .L_ALT_OP_USHR_INT_2ADDR /* 0xba */ 25512 .long .L_ALT_OP_ADD_LONG_2ADDR /* 0xbb */ 25513 .long .L_ALT_OP_SUB_LONG_2ADDR /* 0xbc */ 25514 .long .L_ALT_OP_MUL_LONG_2ADDR /* 0xbd */ 25515 .long .L_ALT_OP_DIV_LONG_2ADDR /* 0xbe */ 25516 .long .L_ALT_OP_REM_LONG_2ADDR /* 0xbf */ 25517 .long .L_ALT_OP_AND_LONG_2ADDR /* 0xc0 */ 25518 .long .L_ALT_OP_OR_LONG_2ADDR /* 0xc1 */ 25519 .long .L_ALT_OP_XOR_LONG_2ADDR /* 0xc2 */ 25520 .long .L_ALT_OP_SHL_LONG_2ADDR /* 0xc3 */ 25521 .long .L_ALT_OP_SHR_LONG_2ADDR /* 0xc4 */ 25522 .long .L_ALT_OP_USHR_LONG_2ADDR /* 0xc5 */ 25523 .long .L_ALT_OP_ADD_FLOAT_2ADDR /* 0xc6 */ 25524 .long .L_ALT_OP_SUB_FLOAT_2ADDR /* 0xc7 */ 25525 .long .L_ALT_OP_MUL_FLOAT_2ADDR /* 0xc8 */ 25526 .long .L_ALT_OP_DIV_FLOAT_2ADDR /* 0xc9 */ 25527 .long .L_ALT_OP_REM_FLOAT_2ADDR /* 0xca */ 25528 .long .L_ALT_OP_ADD_DOUBLE_2ADDR /* 0xcb */ 25529 .long .L_ALT_OP_SUB_DOUBLE_2ADDR /* 0xcc */ 25530 .long .L_ALT_OP_MUL_DOUBLE_2ADDR /* 0xcd */ 25531 .long .L_ALT_OP_DIV_DOUBLE_2ADDR /* 0xce */ 25532 .long .L_ALT_OP_REM_DOUBLE_2ADDR /* 0xcf */ 25533 .long .L_ALT_OP_ADD_INT_LIT16 /* 0xd0 */ 25534 .long .L_ALT_OP_RSUB_INT /* 0xd1 */ 25535 .long .L_ALT_OP_MUL_INT_LIT16 /* 0xd2 */ 25536 .long .L_ALT_OP_DIV_INT_LIT16 /* 0xd3 */ 25537 .long .L_ALT_OP_REM_INT_LIT16 /* 0xd4 */ 25538 .long .L_ALT_OP_AND_INT_LIT16 /* 0xd5 */ 25539 .long .L_ALT_OP_OR_INT_LIT16 /* 0xd6 */ 25540 .long .L_ALT_OP_XOR_INT_LIT16 /* 0xd7 */ 25541 .long .L_ALT_OP_ADD_INT_LIT8 /* 0xd8 */ 25542 .long .L_ALT_OP_RSUB_INT_LIT8 /* 0xd9 */ 25543 .long .L_ALT_OP_MUL_INT_LIT8 /* 0xda */ 25544 .long .L_ALT_OP_DIV_INT_LIT8 /* 0xdb */ 25545 .long .L_ALT_OP_REM_INT_LIT8 /* 0xdc */ 25546 .long .L_ALT_OP_AND_INT_LIT8 /* 0xdd */ 25547 .long .L_ALT_OP_OR_INT_LIT8 /* 0xde */ 25548 .long .L_ALT_OP_XOR_INT_LIT8 /* 0xdf */ 25549 .long .L_ALT_OP_SHL_INT_LIT8 /* 0xe0 */ 25550 .long .L_ALT_OP_SHR_INT_LIT8 /* 0xe1 */ 25551 .long .L_ALT_OP_USHR_INT_LIT8 /* 0xe2 */ 25552 .long .L_ALT_OP_IGET_VOLATILE /* 0xe3 */ 25553 .long .L_ALT_OP_IPUT_VOLATILE /* 0xe4 */ 25554 .long .L_ALT_OP_SGET_VOLATILE /* 0xe5 */ 25555 .long .L_ALT_OP_SPUT_VOLATILE /* 0xe6 */ 25556 .long .L_ALT_OP_IGET_OBJECT_VOLATILE /* 0xe7 */ 25557 .long .L_ALT_OP_IGET_WIDE_VOLATILE /* 0xe8 */ 25558 .long .L_ALT_OP_IPUT_WIDE_VOLATILE /* 0xe9 */ 25559 .long .L_ALT_OP_SGET_WIDE_VOLATILE /* 0xea */ 25560 .long .L_ALT_OP_SPUT_WIDE_VOLATILE /* 0xeb */ 25561 .long .L_ALT_OP_BREAKPOINT /* 0xec */ 25562 .long .L_ALT_OP_THROW_VERIFICATION_ERROR /* 0xed */ 25563 .long .L_ALT_OP_EXECUTE_INLINE /* 0xee */ 25564 .long .L_ALT_OP_EXECUTE_INLINE_RANGE /* 0xef */ 25565 .long .L_ALT_OP_INVOKE_OBJECT_INIT_RANGE /* 0xf0 */ 25566 .long .L_ALT_OP_RETURN_VOID_BARRIER /* 0xf1 */ 25567 .long .L_ALT_OP_IGET_QUICK /* 0xf2 */ 25568 .long .L_ALT_OP_IGET_WIDE_QUICK /* 0xf3 */ 25569 .long .L_ALT_OP_IGET_OBJECT_QUICK /* 0xf4 */ 25570 .long .L_ALT_OP_IPUT_QUICK /* 0xf5 */ 25571 .long .L_ALT_OP_IPUT_WIDE_QUICK /* 0xf6 */ 25572 .long .L_ALT_OP_IPUT_OBJECT_QUICK /* 0xf7 */ 25573 .long .L_ALT_OP_INVOKE_VIRTUAL_QUICK /* 0xf8 */ 25574 .long .L_ALT_OP_INVOKE_VIRTUAL_QUICK_RANGE /* 0xf9 */ 25575 .long .L_ALT_OP_INVOKE_SUPER_QUICK /* 0xfa */ 25576 .long .L_ALT_OP_INVOKE_SUPER_QUICK_RANGE /* 0xfb */ 25577 .long .L_ALT_OP_IPUT_OBJECT_VOLATILE /* 0xfc */ 25578 .long .L_ALT_OP_SGET_OBJECT_VOLATILE /* 0xfd */ 25579 .long .L_ALT_OP_SPUT_OBJECT_VOLATILE /* 0xfe */ 25580 .long .L_ALT_OP_DISPATCH_FF /* 0xff */ 25581 .long .L_ALT_OP_CONST_CLASS_JUMBO /* 0x100 */ 25582 .long .L_ALT_OP_CHECK_CAST_JUMBO /* 0x101 */ 25583 .long .L_ALT_OP_INSTANCE_OF_JUMBO /* 0x102 */ 25584 .long .L_ALT_OP_NEW_INSTANCE_JUMBO /* 0x103 */ 25585 .long .L_ALT_OP_NEW_ARRAY_JUMBO /* 0x104 */ 25586 .long .L_ALT_OP_FILLED_NEW_ARRAY_JUMBO /* 0x105 */ 25587 .long .L_ALT_OP_IGET_JUMBO /* 0x106 */ 25588 .long .L_ALT_OP_IGET_WIDE_JUMBO /* 0x107 */ 25589 .long .L_ALT_OP_IGET_OBJECT_JUMBO /* 0x108 */ 25590 .long .L_ALT_OP_IGET_BOOLEAN_JUMBO /* 0x109 */ 25591 .long .L_ALT_OP_IGET_BYTE_JUMBO /* 0x10a */ 25592 .long .L_ALT_OP_IGET_CHAR_JUMBO /* 0x10b */ 25593 .long .L_ALT_OP_IGET_SHORT_JUMBO /* 0x10c */ 25594 .long .L_ALT_OP_IPUT_JUMBO /* 0x10d */ 25595 .long .L_ALT_OP_IPUT_WIDE_JUMBO /* 0x10e */ 25596 .long .L_ALT_OP_IPUT_OBJECT_JUMBO /* 0x10f */ 25597 .long .L_ALT_OP_IPUT_BOOLEAN_JUMBO /* 0x110 */ 25598 .long .L_ALT_OP_IPUT_BYTE_JUMBO /* 0x111 */ 25599 .long .L_ALT_OP_IPUT_CHAR_JUMBO /* 0x112 */ 25600 .long .L_ALT_OP_IPUT_SHORT_JUMBO /* 0x113 */ 25601 .long .L_ALT_OP_SGET_JUMBO /* 0x114 */ 25602 .long .L_ALT_OP_SGET_WIDE_JUMBO /* 0x115 */ 25603 .long .L_ALT_OP_SGET_OBJECT_JUMBO /* 0x116 */ 25604 .long .L_ALT_OP_SGET_BOOLEAN_JUMBO /* 0x117 */ 25605 .long .L_ALT_OP_SGET_BYTE_JUMBO /* 0x118 */ 25606 .long .L_ALT_OP_SGET_CHAR_JUMBO /* 0x119 */ 25607 .long .L_ALT_OP_SGET_SHORT_JUMBO /* 0x11a */ 25608 .long .L_ALT_OP_SPUT_JUMBO /* 0x11b */ 25609 .long .L_ALT_OP_SPUT_WIDE_JUMBO /* 0x11c */ 25610 .long .L_ALT_OP_SPUT_OBJECT_JUMBO /* 0x11d */ 25611 .long .L_ALT_OP_SPUT_BOOLEAN_JUMBO /* 0x11e */ 25612 .long .L_ALT_OP_SPUT_BYTE_JUMBO /* 0x11f */ 25613 .long .L_ALT_OP_SPUT_CHAR_JUMBO /* 0x120 */ 25614 .long .L_ALT_OP_SPUT_SHORT_JUMBO /* 0x121 */ 25615 .long .L_ALT_OP_INVOKE_VIRTUAL_JUMBO /* 0x122 */ 25616 .long .L_ALT_OP_INVOKE_SUPER_JUMBO /* 0x123 */ 25617 .long .L_ALT_OP_INVOKE_DIRECT_JUMBO /* 0x124 */ 25618 .long .L_ALT_OP_INVOKE_STATIC_JUMBO /* 0x125 */ 25619 .long .L_ALT_OP_INVOKE_INTERFACE_JUMBO /* 0x126 */ 25620 .long .L_ALT_OP_UNUSED_27FF /* 0x127 */ 25621 .long .L_ALT_OP_UNUSED_28FF /* 0x128 */ 25622 .long .L_ALT_OP_UNUSED_29FF /* 0x129 */ 25623 .long .L_ALT_OP_UNUSED_2AFF /* 0x12a */ 25624 .long .L_ALT_OP_UNUSED_2BFF /* 0x12b */ 25625 .long .L_ALT_OP_UNUSED_2CFF /* 0x12c */ 25626 .long .L_ALT_OP_UNUSED_2DFF /* 0x12d */ 25627 .long .L_ALT_OP_UNUSED_2EFF /* 0x12e */ 25628 .long .L_ALT_OP_UNUSED_2FFF /* 0x12f */ 25629 .long .L_ALT_OP_UNUSED_30FF /* 0x130 */ 25630 .long .L_ALT_OP_UNUSED_31FF /* 0x131 */ 25631 .long .L_ALT_OP_UNUSED_32FF /* 0x132 */ 25632 .long .L_ALT_OP_UNUSED_33FF /* 0x133 */ 25633 .long .L_ALT_OP_UNUSED_34FF /* 0x134 */ 25634 .long .L_ALT_OP_UNUSED_35FF /* 0x135 */ 25635 .long .L_ALT_OP_UNUSED_36FF /* 0x136 */ 25636 .long .L_ALT_OP_UNUSED_37FF /* 0x137 */ 25637 .long .L_ALT_OP_UNUSED_38FF /* 0x138 */ 25638 .long .L_ALT_OP_UNUSED_39FF /* 0x139 */ 25639 .long .L_ALT_OP_UNUSED_3AFF /* 0x13a */ 25640 .long .L_ALT_OP_UNUSED_3BFF /* 0x13b */ 25641 .long .L_ALT_OP_UNUSED_3CFF /* 0x13c */ 25642 .long .L_ALT_OP_UNUSED_3DFF /* 0x13d */ 25643 .long .L_ALT_OP_UNUSED_3EFF /* 0x13e */ 25644 .long .L_ALT_OP_UNUSED_3FFF /* 0x13f */ 25645 .long .L_ALT_OP_UNUSED_40FF /* 0x140 */ 25646 .long .L_ALT_OP_UNUSED_41FF /* 0x141 */ 25647 .long .L_ALT_OP_UNUSED_42FF /* 0x142 */ 25648 .long .L_ALT_OP_UNUSED_43FF /* 0x143 */ 25649 .long .L_ALT_OP_UNUSED_44FF /* 0x144 */ 25650 .long .L_ALT_OP_UNUSED_45FF /* 0x145 */ 25651 .long .L_ALT_OP_UNUSED_46FF /* 0x146 */ 25652 .long .L_ALT_OP_UNUSED_47FF /* 0x147 */ 25653 .long .L_ALT_OP_UNUSED_48FF /* 0x148 */ 25654 .long .L_ALT_OP_UNUSED_49FF /* 0x149 */ 25655 .long .L_ALT_OP_UNUSED_4AFF /* 0x14a */ 25656 .long .L_ALT_OP_UNUSED_4BFF /* 0x14b */ 25657 .long .L_ALT_OP_UNUSED_4CFF /* 0x14c */ 25658 .long .L_ALT_OP_UNUSED_4DFF /* 0x14d */ 25659 .long .L_ALT_OP_UNUSED_4EFF /* 0x14e */ 25660 .long .L_ALT_OP_UNUSED_4FFF /* 0x14f */ 25661 .long .L_ALT_OP_UNUSED_50FF /* 0x150 */ 25662 .long .L_ALT_OP_UNUSED_51FF /* 0x151 */ 25663 .long .L_ALT_OP_UNUSED_52FF /* 0x152 */ 25664 .long .L_ALT_OP_UNUSED_53FF /* 0x153 */ 25665 .long .L_ALT_OP_UNUSED_54FF /* 0x154 */ 25666 .long .L_ALT_OP_UNUSED_55FF /* 0x155 */ 25667 .long .L_ALT_OP_UNUSED_56FF /* 0x156 */ 25668 .long .L_ALT_OP_UNUSED_57FF /* 0x157 */ 25669 .long .L_ALT_OP_UNUSED_58FF /* 0x158 */ 25670 .long .L_ALT_OP_UNUSED_59FF /* 0x159 */ 25671 .long .L_ALT_OP_UNUSED_5AFF /* 0x15a */ 25672 .long .L_ALT_OP_UNUSED_5BFF /* 0x15b */ 25673 .long .L_ALT_OP_UNUSED_5CFF /* 0x15c */ 25674 .long .L_ALT_OP_UNUSED_5DFF /* 0x15d */ 25675 .long .L_ALT_OP_UNUSED_5EFF /* 0x15e */ 25676 .long .L_ALT_OP_UNUSED_5FFF /* 0x15f */ 25677 .long .L_ALT_OP_UNUSED_60FF /* 0x160 */ 25678 .long .L_ALT_OP_UNUSED_61FF /* 0x161 */ 25679 .long .L_ALT_OP_UNUSED_62FF /* 0x162 */ 25680 .long .L_ALT_OP_UNUSED_63FF /* 0x163 */ 25681 .long .L_ALT_OP_UNUSED_64FF /* 0x164 */ 25682 .long .L_ALT_OP_UNUSED_65FF /* 0x165 */ 25683 .long .L_ALT_OP_UNUSED_66FF /* 0x166 */ 25684 .long .L_ALT_OP_UNUSED_67FF /* 0x167 */ 25685 .long .L_ALT_OP_UNUSED_68FF /* 0x168 */ 25686 .long .L_ALT_OP_UNUSED_69FF /* 0x169 */ 25687 .long .L_ALT_OP_UNUSED_6AFF /* 0x16a */ 25688 .long .L_ALT_OP_UNUSED_6BFF /* 0x16b */ 25689 .long .L_ALT_OP_UNUSED_6CFF /* 0x16c */ 25690 .long .L_ALT_OP_UNUSED_6DFF /* 0x16d */ 25691 .long .L_ALT_OP_UNUSED_6EFF /* 0x16e */ 25692 .long .L_ALT_OP_UNUSED_6FFF /* 0x16f */ 25693 .long .L_ALT_OP_UNUSED_70FF /* 0x170 */ 25694 .long .L_ALT_OP_UNUSED_71FF /* 0x171 */ 25695 .long .L_ALT_OP_UNUSED_72FF /* 0x172 */ 25696 .long .L_ALT_OP_UNUSED_73FF /* 0x173 */ 25697 .long .L_ALT_OP_UNUSED_74FF /* 0x174 */ 25698 .long .L_ALT_OP_UNUSED_75FF /* 0x175 */ 25699 .long .L_ALT_OP_UNUSED_76FF /* 0x176 */ 25700 .long .L_ALT_OP_UNUSED_77FF /* 0x177 */ 25701 .long .L_ALT_OP_UNUSED_78FF /* 0x178 */ 25702 .long .L_ALT_OP_UNUSED_79FF /* 0x179 */ 25703 .long .L_ALT_OP_UNUSED_7AFF /* 0x17a */ 25704 .long .L_ALT_OP_UNUSED_7BFF /* 0x17b */ 25705 .long .L_ALT_OP_UNUSED_7CFF /* 0x17c */ 25706 .long .L_ALT_OP_UNUSED_7DFF /* 0x17d */ 25707 .long .L_ALT_OP_UNUSED_7EFF /* 0x17e */ 25708 .long .L_ALT_OP_UNUSED_7FFF /* 0x17f */ 25709 .long .L_ALT_OP_UNUSED_80FF /* 0x180 */ 25710 .long .L_ALT_OP_UNUSED_81FF /* 0x181 */ 25711 .long .L_ALT_OP_UNUSED_82FF /* 0x182 */ 25712 .long .L_ALT_OP_UNUSED_83FF /* 0x183 */ 25713 .long .L_ALT_OP_UNUSED_84FF /* 0x184 */ 25714 .long .L_ALT_OP_UNUSED_85FF /* 0x185 */ 25715 .long .L_ALT_OP_UNUSED_86FF /* 0x186 */ 25716 .long .L_ALT_OP_UNUSED_87FF /* 0x187 */ 25717 .long .L_ALT_OP_UNUSED_88FF /* 0x188 */ 25718 .long .L_ALT_OP_UNUSED_89FF /* 0x189 */ 25719 .long .L_ALT_OP_UNUSED_8AFF /* 0x18a */ 25720 .long .L_ALT_OP_UNUSED_8BFF /* 0x18b */ 25721 .long .L_ALT_OP_UNUSED_8CFF /* 0x18c */ 25722 .long .L_ALT_OP_UNUSED_8DFF /* 0x18d */ 25723 .long .L_ALT_OP_UNUSED_8EFF /* 0x18e */ 25724 .long .L_ALT_OP_UNUSED_8FFF /* 0x18f */ 25725 .long .L_ALT_OP_UNUSED_90FF /* 0x190 */ 25726 .long .L_ALT_OP_UNUSED_91FF /* 0x191 */ 25727 .long .L_ALT_OP_UNUSED_92FF /* 0x192 */ 25728 .long .L_ALT_OP_UNUSED_93FF /* 0x193 */ 25729 .long .L_ALT_OP_UNUSED_94FF /* 0x194 */ 25730 .long .L_ALT_OP_UNUSED_95FF /* 0x195 */ 25731 .long .L_ALT_OP_UNUSED_96FF /* 0x196 */ 25732 .long .L_ALT_OP_UNUSED_97FF /* 0x197 */ 25733 .long .L_ALT_OP_UNUSED_98FF /* 0x198 */ 25734 .long .L_ALT_OP_UNUSED_99FF /* 0x199 */ 25735 .long .L_ALT_OP_UNUSED_9AFF /* 0x19a */ 25736 .long .L_ALT_OP_UNUSED_9BFF /* 0x19b */ 25737 .long .L_ALT_OP_UNUSED_9CFF /* 0x19c */ 25738 .long .L_ALT_OP_UNUSED_9DFF /* 0x19d */ 25739 .long .L_ALT_OP_UNUSED_9EFF /* 0x19e */ 25740 .long .L_ALT_OP_UNUSED_9FFF /* 0x19f */ 25741 .long .L_ALT_OP_UNUSED_A0FF /* 0x1a0 */ 25742 .long .L_ALT_OP_UNUSED_A1FF /* 0x1a1 */ 25743 .long .L_ALT_OP_UNUSED_A2FF /* 0x1a2 */ 25744 .long .L_ALT_OP_UNUSED_A3FF /* 0x1a3 */ 25745 .long .L_ALT_OP_UNUSED_A4FF /* 0x1a4 */ 25746 .long .L_ALT_OP_UNUSED_A5FF /* 0x1a5 */ 25747 .long .L_ALT_OP_UNUSED_A6FF /* 0x1a6 */ 25748 .long .L_ALT_OP_UNUSED_A7FF /* 0x1a7 */ 25749 .long .L_ALT_OP_UNUSED_A8FF /* 0x1a8 */ 25750 .long .L_ALT_OP_UNUSED_A9FF /* 0x1a9 */ 25751 .long .L_ALT_OP_UNUSED_AAFF /* 0x1aa */ 25752 .long .L_ALT_OP_UNUSED_ABFF /* 0x1ab */ 25753 .long .L_ALT_OP_UNUSED_ACFF /* 0x1ac */ 25754 .long .L_ALT_OP_UNUSED_ADFF /* 0x1ad */ 25755 .long .L_ALT_OP_UNUSED_AEFF /* 0x1ae */ 25756 .long .L_ALT_OP_UNUSED_AFFF /* 0x1af */ 25757 .long .L_ALT_OP_UNUSED_B0FF /* 0x1b0 */ 25758 .long .L_ALT_OP_UNUSED_B1FF /* 0x1b1 */ 25759 .long .L_ALT_OP_UNUSED_B2FF /* 0x1b2 */ 25760 .long .L_ALT_OP_UNUSED_B3FF /* 0x1b3 */ 25761 .long .L_ALT_OP_UNUSED_B4FF /* 0x1b4 */ 25762 .long .L_ALT_OP_UNUSED_B5FF /* 0x1b5 */ 25763 .long .L_ALT_OP_UNUSED_B6FF /* 0x1b6 */ 25764 .long .L_ALT_OP_UNUSED_B7FF /* 0x1b7 */ 25765 .long .L_ALT_OP_UNUSED_B8FF /* 0x1b8 */ 25766 .long .L_ALT_OP_UNUSED_B9FF /* 0x1b9 */ 25767 .long .L_ALT_OP_UNUSED_BAFF /* 0x1ba */ 25768 .long .L_ALT_OP_UNUSED_BBFF /* 0x1bb */ 25769 .long .L_ALT_OP_UNUSED_BCFF /* 0x1bc */ 25770 .long .L_ALT_OP_UNUSED_BDFF /* 0x1bd */ 25771 .long .L_ALT_OP_UNUSED_BEFF /* 0x1be */ 25772 .long .L_ALT_OP_UNUSED_BFFF /* 0x1bf */ 25773 .long .L_ALT_OP_UNUSED_C0FF /* 0x1c0 */ 25774 .long .L_ALT_OP_UNUSED_C1FF /* 0x1c1 */ 25775 .long .L_ALT_OP_UNUSED_C2FF /* 0x1c2 */ 25776 .long .L_ALT_OP_UNUSED_C3FF /* 0x1c3 */ 25777 .long .L_ALT_OP_UNUSED_C4FF /* 0x1c4 */ 25778 .long .L_ALT_OP_UNUSED_C5FF /* 0x1c5 */ 25779 .long .L_ALT_OP_UNUSED_C6FF /* 0x1c6 */ 25780 .long .L_ALT_OP_UNUSED_C7FF /* 0x1c7 */ 25781 .long .L_ALT_OP_UNUSED_C8FF /* 0x1c8 */ 25782 .long .L_ALT_OP_UNUSED_C9FF /* 0x1c9 */ 25783 .long .L_ALT_OP_UNUSED_CAFF /* 0x1ca */ 25784 .long .L_ALT_OP_UNUSED_CBFF /* 0x1cb */ 25785 .long .L_ALT_OP_UNUSED_CCFF /* 0x1cc */ 25786 .long .L_ALT_OP_UNUSED_CDFF /* 0x1cd */ 25787 .long .L_ALT_OP_UNUSED_CEFF /* 0x1ce */ 25788 .long .L_ALT_OP_UNUSED_CFFF /* 0x1cf */ 25789 .long .L_ALT_OP_UNUSED_D0FF /* 0x1d0 */ 25790 .long .L_ALT_OP_UNUSED_D1FF /* 0x1d1 */ 25791 .long .L_ALT_OP_UNUSED_D2FF /* 0x1d2 */ 25792 .long .L_ALT_OP_UNUSED_D3FF /* 0x1d3 */ 25793 .long .L_ALT_OP_UNUSED_D4FF /* 0x1d4 */ 25794 .long .L_ALT_OP_UNUSED_D5FF /* 0x1d5 */ 25795 .long .L_ALT_OP_UNUSED_D6FF /* 0x1d6 */ 25796 .long .L_ALT_OP_UNUSED_D7FF /* 0x1d7 */ 25797 .long .L_ALT_OP_UNUSED_D8FF /* 0x1d8 */ 25798 .long .L_ALT_OP_UNUSED_D9FF /* 0x1d9 */ 25799 .long .L_ALT_OP_UNUSED_DAFF /* 0x1da */ 25800 .long .L_ALT_OP_UNUSED_DBFF /* 0x1db */ 25801 .long .L_ALT_OP_UNUSED_DCFF /* 0x1dc */ 25802 .long .L_ALT_OP_UNUSED_DDFF /* 0x1dd */ 25803 .long .L_ALT_OP_UNUSED_DEFF /* 0x1de */ 25804 .long .L_ALT_OP_UNUSED_DFFF /* 0x1df */ 25805 .long .L_ALT_OP_UNUSED_E0FF /* 0x1e0 */ 25806 .long .L_ALT_OP_UNUSED_E1FF /* 0x1e1 */ 25807 .long .L_ALT_OP_UNUSED_E2FF /* 0x1e2 */ 25808 .long .L_ALT_OP_UNUSED_E3FF /* 0x1e3 */ 25809 .long .L_ALT_OP_UNUSED_E4FF /* 0x1e4 */ 25810 .long .L_ALT_OP_UNUSED_E5FF /* 0x1e5 */ 25811 .long .L_ALT_OP_UNUSED_E6FF /* 0x1e6 */ 25812 .long .L_ALT_OP_UNUSED_E7FF /* 0x1e7 */ 25813 .long .L_ALT_OP_UNUSED_E8FF /* 0x1e8 */ 25814 .long .L_ALT_OP_UNUSED_E9FF /* 0x1e9 */ 25815 .long .L_ALT_OP_UNUSED_EAFF /* 0x1ea */ 25816 .long .L_ALT_OP_UNUSED_EBFF /* 0x1eb */ 25817 .long .L_ALT_OP_UNUSED_ECFF /* 0x1ec */ 25818 .long .L_ALT_OP_UNUSED_EDFF /* 0x1ed */ 25819 .long .L_ALT_OP_UNUSED_EEFF /* 0x1ee */ 25820 .long .L_ALT_OP_UNUSED_EFFF /* 0x1ef */ 25821 .long .L_ALT_OP_UNUSED_F0FF /* 0x1f0 */ 25822 .long .L_ALT_OP_UNUSED_F1FF /* 0x1f1 */ 25823 .long .L_ALT_OP_INVOKE_OBJECT_INIT_JUMBO /* 0x1f2 */ 25824 .long .L_ALT_OP_IGET_VOLATILE_JUMBO /* 0x1f3 */ 25825 .long .L_ALT_OP_IGET_WIDE_VOLATILE_JUMBO /* 0x1f4 */ 25826 .long .L_ALT_OP_IGET_OBJECT_VOLATILE_JUMBO /* 0x1f5 */ 25827 .long .L_ALT_OP_IPUT_VOLATILE_JUMBO /* 0x1f6 */ 25828 .long .L_ALT_OP_IPUT_WIDE_VOLATILE_JUMBO /* 0x1f7 */ 25829 .long .L_ALT_OP_IPUT_OBJECT_VOLATILE_JUMBO /* 0x1f8 */ 25830 .long .L_ALT_OP_SGET_VOLATILE_JUMBO /* 0x1f9 */ 25831 .long .L_ALT_OP_SGET_WIDE_VOLATILE_JUMBO /* 0x1fa */ 25832 .long .L_ALT_OP_SGET_OBJECT_VOLATILE_JUMBO /* 0x1fb */ 25833 .long .L_ALT_OP_SPUT_VOLATILE_JUMBO /* 0x1fc */ 25834 .long .L_ALT_OP_SPUT_WIDE_VOLATILE_JUMBO /* 0x1fd */ 25835 .long .L_ALT_OP_SPUT_OBJECT_VOLATILE_JUMBO /* 0x1fe */ 25836 .long .L_ALT_OP_THROW_VERIFICATION_ERROR_JUMBO /* 0x1ff */ 25837/* File: x86/entry.S */ 25838/* 25839 * Copyright (C) 2008 The Android Open Source Project 25840 * 25841 * Licensed under the Apache License, Version 2.0 (the "License"); 25842 * you may not use this file except in compliance with the License. 25843 * You may obtain a copy of the License at 25844 * 25845 * http://www.apache.org/licenses/LICENSE-2.0 25846 * 25847 * Unless required by applicable law or agreed to in writing, software 25848 * distributed under the License is distributed on an "AS IS" BASIS, 25849 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 25850 * See the License for the specific language governing permissions and 25851 * limitations under the License. 25852 */ 25853 25854 25855 .text 25856 .global dvmMterpStdRun 25857 .type dvmMterpStdRun, %function 25858/* 25859 * bool dvmMterpStdRun(Thread* self) 25860 * 25861 * Interpreter entry point. Returns changeInterp. 25862 * 25863 */ 25864dvmMterpStdRun: 25865 push %ebp # save caller base pointer 25866 movl %esp, %ebp # set our %ebp 25867 movl rSELF, %ecx # get incoming rSELF 25868/* 25869 * At this point we've allocated one slot on the stack 25870 * via push and stack is 8-byte aligned. Allocate space 25871 * for 9 spill slots, 4 local slots, 5 arg slots to bring 25872 * us to 16-byte alignment 25873 */ 25874 subl $(FRAME_SIZE-4), %esp 25875 25876/* Spill callee save regs */ 25877 movl %edi,EDI_SPILL(%ebp) 25878 movl %esi,ESI_SPILL(%ebp) 25879 movl %ebx,EBX_SPILL(%ebp) 25880 25881/* Set up "named" registers */ 25882 movl offThread_pc(%ecx),rPC 25883 movl offThread_curFrame(%ecx),rFP 25884 movl offThread_curHandlerTable(%ecx),rIBASE 25885 25886/* Remember %esp for future "longjmp" */ 25887 movl %esp,offThread_bailPtr(%ecx) 25888 25889 /* Normal case: start executing the instruction at rPC */ 25890 FETCH_INST 25891 GOTO_NEXT 25892 25893 .global dvmMterpStdBail 25894 .type dvmMterpStdBail, %function 25895/* 25896 * void dvmMterpStdBail(Thread* self, bool changeInterp) 25897 * 25898 * Restore the stack pointer and PC from the save point established on entry. 25899 * This is essentially the same as a longjmp, but should be cheaper. The 25900 * last instruction causes us to return to whoever called dvmMterpStdRun. 25901 * 25902 * We're not going to build a standard frame here, so the arg accesses will 25903 * look a little strange. 25904 * 25905 * On entry: 25906 * esp+4 (arg0) Thread* self 25907 * esp+8 (arg1) bool changeInterp 25908 */ 25909dvmMterpStdBail: 25910 movl 4(%esp),%ecx # grab self 25911 movl 8(%esp),%eax # changeInterp to return reg 25912 movl offThread_bailPtr(%ecx),%esp # Restore "setjmp" esp 25913 movl %esp,%ebp 25914 addl $(FRAME_SIZE-4), %ebp # Restore %ebp at point of setjmp 25915 movl EDI_SPILL(%ebp),%edi 25916 movl ESI_SPILL(%ebp),%esi 25917 movl EBX_SPILL(%ebp),%ebx 25918 movl %ebp, %esp # strip frame 25919 pop %ebp # restore caller's ebp 25920 ret # return to dvmMterpStdRun's caller 25921 25922 25923/* 25924 * Strings 25925 */ 25926 .section .rodata 25927.LstrBadEntryPoint: 25928 .asciz "Bad entry point %d\n" 25929 25930 25931/* File: x86/footer.S */ 25932/* 25933 * Copyright (C) 2008 The Android Open Source Project 25934 * 25935 * Licensed under the Apache License, Version 2.0 (the "License"); 25936 * you may not use this file except in compliance with the License. 25937 * You may obtain a copy of the License at 25938 * 25939 * http://www.apache.org/licenses/LICENSE-2.0 25940 * 25941 * Unless required by applicable law or agreed to in writing, software 25942 * distributed under the License is distributed on an "AS IS" BASIS, 25943 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 25944 * See the License for the specific language governing permissions and 25945 * limitations under the License. 25946 */ 25947/* 25948 * Common subroutines and data. 25949 */ 25950 25951#if defined(WITH_JIT) 25952/* 25953 * JIT-related re-entries into the interpreter. In general, if the 25954 * exit from a translation can at some point be chained, the entry 25955 * here requires that control arrived via a call, and that the "rp" 25956 * on TOS is actually a pointer to a 32-bit cell containing the Dalvik PC 25957 * of the next insn to handle. If no chaining will happen, the entry 25958 * should be reached via a direct jump and rPC set beforehand. 25959 */ 25960 25961 .global dvmJitToInterpPunt 25962/* 25963 * The compiler will generate a jump to this entry point when it is 25964 * having difficulty translating a Dalvik instruction. We must skip 25965 * the code cache lookup & prevent chaining to avoid bouncing between 25966 * the interpreter and code cache. rPC must be set on entry. 25967 */ 25968dvmJitToInterpPunt: 25969#if defined(WITH_JIT_TUNING) 25970 movl rPC, OUT_ARG0(%esp) 25971 call dvmBumpPunt 25972#endif 25973 movl rSELF, %ecx 25974 movl offThread_curHandlerTable(%ecx),rIBASE 25975 FETCH_INST_R %ecx 25976 GOTO_NEXT_R %ecx 25977 25978 .global dvmJitToInterpSingleStep 25979/* 25980 * Return to the interpreter to handle a single instruction. 25981 * Should be reached via a call. 25982 * On entry: 25983 * 0(%esp) <= native return address within trace 25984 * rPC <= Dalvik PC of this instruction 25985 * OUT_ARG0+4(%esp) <= Dalvik PC of next instruction 25986 */ 25987dvmJitToInterpSingleStep: 25988/* TODO */ 25989 call dvmAbort 25990#if 0 25991 pop %eax 25992 movl rSELF, %ecx 25993 movl OUT_ARG0(%esp), %edx 25994 movl %eax,offThread_jitResumeNPC(%ecx) 25995 movl %edx,offThread_jitResumeDPC(%ecx) 25996 movl $kInterpEntryInstr,offThread_entryPoint(%ecx) 25997 movl $1,rINST # changeInterp <= true 25998 jmp common_gotoBail 25999#endif 26000 26001 .global dvmJitToInterpNoChainNoProfile 26002/* 26003 * Return from the translation cache to the interpreter to do method 26004 * invocation. Check if the translation exists for the callee, but don't 26005 * chain to it. rPC must be set on entry. 26006 */ 26007dvmJitToInterpNoChainNoProfile: 26008#if defined(WITH_JIT_TUNING) 26009 call dvmBumpNoChain 26010#endif 26011 movl rSELF, %eax 26012 movl rPC,OUT_ARG0(%esp) 26013 movl %eax,OUT_ARG1(%esp) 26014 call dvmJitGetTraceAddrThread # (pc, self) 26015 movl rSELF,%ecx # ecx <- self 26016 movl %eax,offThread_inJitCodeCache(%ecx) # set inJitCodeCache flag 26017 cmpl $0, %eax 26018 jz 1f 26019 call *%eax # exec translation if we've got one 26020 # won't return 260211: 26022 movl rSELF, %ecx 26023 movl offThread_curHandlerTable(%ecx),rIBASE 26024 FETCH_INST_R %ecx 26025 GOTO_NEXT_R %ecx 26026 26027/* 26028 * Return from the translation cache and immediately request a 26029 * translation fro the exit target, but don't attempt to chain. 26030 * rPC set on entry. 26031 */ 26032 .global dvmJitToInterpTraceSelectNoChain 26033dvmJitToInterpTraceSelectNoChain: 26034#if defined(WITH_JIT_TUNING) 26035 call dvmBumpNoChain 26036#endif 26037 movl rSELF, %eax 26038 movl rPC,OUT_ARG0(%esp) 26039 movl %eax,OUT_ARG1(%esp) 26040 call dvmJitGetTraceAddrThread # (pc, self) 26041 movl rSELF,%ecx 26042 cmpl $0,%eax 26043 movl %eax,offThread_inJitCodeCache(%ecx) # set inJitCodeCache flag 26044 jz 1f 26045 call *%eax # jump to tranlation 26046 # won't return 26047 26048/* No Translation - request one */ 260491: 26050 GET_JIT_PROF_TABLE %ecx %eax 26051 cmpl $0, %eax # JIT enabled? 26052 jnz 2f # Request one if so 26053 movl rSELF, %ecx 26054 movl offThread_curHandlerTable(%ecx),rIBASE 26055 FETCH_INST_R %ecx # Continue interpreting if not 26056 GOTO_NEXT_R %ecx 260572: 26058 movl $kJitTSelectRequestHot,rINST # ask for trace select 26059 jmp common_selectTrace 26060 26061/* 26062 * Return from the translation cache and immediately request a 26063 * translation for the exit target. Reached via a call, and 26064 * (TOS)->rPC. 26065 */ 26066 .global dvmJitToInterpTraceSelect 26067dvmJitToInterpTraceSelect: 26068 pop rINST # save chain cell address in callee save reg 26069 movl (rINST),rPC 26070 movl rSELF, %eax 26071 movl rPC,OUT_ARG0(%esp) 26072 movl %eax,OUT_ARG1(%esp) 26073 call dvmJitGetTraceAddrThread # (pc, self) 26074 cmpl $0,%eax 26075 jz 1b # no - ask for one 26076 movl %eax,OUT_ARG0(%esp) 26077# TODO - need to adjust rINST to beginning of sequence 26078 movl rINST,OUT_ARG1(%esp) 26079 call dvmJitChain # Attempt dvmJitChain(codeAddr,chainAddr) 26080 cmpl $0,%eax # Success? 26081 jz toInterpreter # didn't chain - interpret 26082 call *%eax 26083 # won't return 26084 26085/* 26086 * Placeholder entries for x86 JIT 26087 */ 26088 .global dvmJitToInterpBackwardBranch 26089dvmJitToInterpBackwardBranch: 26090 .global dvmJitToInterpNormal 26091dvmJitToInterpNormal: 26092 .global dvmJitToInterpNoChain 26093dvmJitToInterpNoChain: 26094toInterpreter: 26095 jmp common_abort 26096 26097common_updateProfile: 26098 # quick & dirty hash 26099 movl rPC, %eax 26100 shrl $12, %eax 26101 xorl rPC, %eax 26102 andl $((1<<JIT_PROF_SIZE_LOG_2)-1),%eax 26103 decb (%edx,%eax) 26104 jz 2f 261051: 26106 GOTO_NEXT 261072: 26108/* 26109 * Here, we switch to the debug interpreter to request 26110 * trace selection. First, though, check to see if there 26111 * is already a native translation in place (and, if so, 26112 * jump to it now. 26113 */ 26114 GET_JIT_THRESHOLD %ecx rINST # leaves rSELF in %ecx 26115 EXPORT_PC 26116 movb rINSTbl,(%edx,%eax) # reset counter 26117 movl %ecx,rINST # preserve rSELF 26118 movl rSELF, %eax 26119 movl rPC,OUT_ARG0(%esp) 26120 movl %eax,OUT_ARG1(%esp) 26121 call dvmJitGetTraceAddr # (pc, self) 26122 movl %eax,offThread_inJitCodeCache(rINST) # set the inJitCodeCache flag 26123 cmpl $0,%eax 26124 jz 1f 26125 call *%eax # TODO: decide call vs/ jmp!. No return either way 261261: 26127 movl $kJitTSelectRequest,%eax 26128 # On entry, eax<- jitState, rPC valid 26129common_selectTrace: 26130/* TODO */ 26131 call dvmAbort 26132#if 0 26133 movl rSELF,%ecx 26134 movl %eax,offThread_jitState(%ecx) 26135 movl $kInterpEntryInstr,offThread_entryPoint(%ecx) 26136 movl $1,rINST 26137 jmp common_gotoBail 26138#endif 26139#endif 26140 26141 26142 26143/* 26144 * Common code for jumbo method invocation. 26145 * 26146 * On entry: 26147 * eax = Method* methodToCall 26148 * rINSTw trashed, must reload 26149 * rIBASE trashed, must reload before resuming interpreter 26150 */ 26151 26152common_invokeMethodJumbo: 26153.LinvokeNewJumbo: 26154 26155 /* 26156 * prepare to copy args to "outs" area of current frame 26157 */ 26158 movzwl 6(rPC),rINST # rINST<- BBBB 26159 movzwl 8(rPC), %ecx # %ecx<- CCCC 26160 ADVANCE_PC 2 # adjust pc to make return similar 26161 SAVEAREA_FROM_FP %edx # %edx<- &StackSaveArea 26162 test rINST, rINST 26163 movl rINST, LOCAL0_OFFSET(%ebp) # LOCAL0_OFFSET(%ebp)<- BBBB 26164 jz .LinvokeArgsDone # no args; jump to args done 26165 jmp .LinvokeRangeArgs # handle args like invoke range 26166 26167/* 26168 * Common code for method invocation with range. 26169 * 26170 * On entry: 26171 * eax = Method* methodToCall 26172 * rINSTw trashed, must reload 26173 * rIBASE trashed, must reload before resuming interpreter 26174 */ 26175 26176common_invokeMethodRange: 26177.LinvokeNewRange: 26178 26179 /* 26180 * prepare to copy args to "outs" area of current frame 26181 */ 26182 26183 movzbl 1(rPC),rINST # rINST<- AA 26184 movzwl 4(rPC), %ecx # %ecx<- CCCC 26185 SAVEAREA_FROM_FP %edx # %edx<- &StackSaveArea 26186 test rINST, rINST 26187 movl rINST, LOCAL0_OFFSET(%ebp) # LOCAL0_OFFSET(%ebp)<- AA 26188 jz .LinvokeArgsDone # no args; jump to args done 26189 26190 26191 /* 26192 * %eax=methodToCall, %ecx=CCCC, LOCAL0_OFFSET(%ebp)=count, 26193 * %edx=&outs (&stackSaveArea). (very few methods have > 10 args; 26194 * could unroll for common cases) 26195 */ 26196 26197.LinvokeRangeArgs: 26198 movl %ebx, LOCAL1_OFFSET(%ebp) # LOCAL1_OFFSET(%ebp)<- save %ebx 26199 lea (rFP, %ecx, 4), %ecx # %ecx<- &vCCCC 26200 shll $2, LOCAL0_OFFSET(%ebp) # LOCAL0_OFFSET(%ebp)<- offset 26201 subl LOCAL0_OFFSET(%ebp), %edx # %edx<- update &outs 26202 shrl $2, LOCAL0_OFFSET(%ebp) # LOCAL0_OFFSET(%ebp)<- offset 262031: 26204 movl (%ecx), %ebx # %ebx<- vCCCC 26205 lea 4(%ecx), %ecx # %ecx<- &vCCCC++ 26206 subl $1, LOCAL0_OFFSET(%ebp) # LOCAL0_OFFSET<- LOCAL0_OFFSET-- 26207 movl %ebx, (%edx) # *outs<- vCCCC 26208 lea 4(%edx), %edx # outs++ 26209 jne 1b # loop if count (LOCAL0_OFFSET(%ebp)) not zero 26210 movl LOCAL1_OFFSET(%ebp), %ebx # %ebx<- restore %ebx 26211 jmp .LinvokeArgsDone # continue 26212 26213 /* 26214 * %eax is "Method* methodToCall", the method we're trying to call 26215 * prepare to copy args to "outs" area of current frame 26216 * rIBASE trashed, must reload before resuming interpreter 26217 */ 26218 26219common_invokeMethodNoRange: 26220.LinvokeNewNoRange: 26221 movzbl 1(rPC),rINST # rINST<- BA 26222 movl rINST, LOCAL0_OFFSET(%ebp) # LOCAL0_OFFSET(%ebp)<- BA 26223 shrl $4, LOCAL0_OFFSET(%ebp) # LOCAL0_OFFSET(%ebp)<- B 26224 je .LinvokeArgsDone # no args; jump to args done 26225 movzwl 4(rPC), %ecx # %ecx<- GFED 26226 SAVEAREA_FROM_FP %edx # %edx<- &StackSaveArea 26227 26228 /* 26229 * %eax=methodToCall, %ecx=GFED, LOCAL0_OFFSET(%ebp)=count, %edx=outs 26230 */ 26231 26232.LinvokeNonRange: 26233 cmp $2, LOCAL0_OFFSET(%ebp) # compare LOCAL0_OFFSET(%ebp) to 2 26234 movl %ecx, LOCAL1_OFFSET(%ebp) # LOCAL1_OFFSET(%ebp)<- GFED 26235 jl 1f # handle 1 arg 26236 je 2f # handle 2 args 26237 cmp $4, LOCAL0_OFFSET(%ebp) # compare LOCAL0_OFFSET(%ebp) to 4 26238 jl 3f # handle 3 args 26239 je 4f # handle 4 args 262405: 26241 andl $15, rINST # rINSTw<- A 26242 lea -4(%edx), %edx # %edx<- update &outs; &outs-- 26243 movl (rFP, rINST, 4), %ecx # %ecx<- vA 26244 movl %ecx, (%edx) # *outs<- vA 26245 movl LOCAL1_OFFSET(%ebp), %ecx # %ecx<- GFED 262464: 26247 shr $12, %ecx # %ecx<- G 26248 lea -4(%edx), %edx # %edx<- update &outs; &outs-- 26249 movl (rFP, %ecx, 4), %ecx # %ecx<- vG 26250 movl %ecx, (%edx) # *outs<- vG 26251 movl LOCAL1_OFFSET(%ebp), %ecx # %ecx<- GFED 262523: 26253 and $0x0f00, %ecx # %ecx<- 0F00 26254 shr $8, %ecx # %ecx<- F 26255 lea -4(%edx), %edx # %edx<- update &outs; &outs-- 26256 movl (rFP, %ecx, 4), %ecx # %ecx<- vF 26257 movl %ecx, (%edx) # *outs<- vF 26258 movl LOCAL1_OFFSET(%ebp), %ecx # %ecx<- GFED 262592: 26260 and $0x00f0, %ecx # %ecx<- 00E0 26261 shr $4, %ecx # %ecx<- E 26262 lea -4(%edx), %edx # %edx<- update &outs; &outs-- 26263 movl (rFP, %ecx, 4), %ecx # %ecx<- vE 26264 movl %ecx, (%edx) # *outs<- vE 26265 movl LOCAL1_OFFSET(%ebp), %ecx # %ecx<- GFED 262661: 26267 and $0x000f, %ecx # %ecx<- 000D 26268 movl (rFP, %ecx, 4), %ecx # %ecx<- vD 26269 movl %ecx, -4(%edx) # *--outs<- vD 262700: 26271 26272 /* 26273 * %eax is "Method* methodToCall", the method we're trying to call 26274 * find space for the new stack frame, check for overflow 26275 */ 26276 26277.LinvokeArgsDone: 26278 movzwl offMethod_registersSize(%eax), %edx # %edx<- methodToCall->regsSize 26279 movzwl offMethod_outsSize(%eax), %ecx # %ecx<- methodToCall->outsSize 26280 movl %eax, LOCAL0_OFFSET(%ebp) # LOCAL0_OFFSET<- methodToCall 26281 shl $2, %edx # %edx<- update offset 26282 SAVEAREA_FROM_FP %eax # %eax<- &StackSaveArea 26283 subl %edx, %eax # %eax<- newFP; (old savearea - regsSize) 26284 movl rSELF,%edx # %edx<- pthread 26285 movl %eax, LOCAL1_OFFSET(%ebp) # LOCAL1_OFFSET(%ebp)<- &outs 26286 subl $sizeofStackSaveArea, %eax # %eax<- newSaveArea (stack save area using newFP) 26287 movl offThread_interpStackEnd(%edx), %edx # %edx<- self->interpStackEnd 26288 movl %edx, TMP_SPILL1(%ebp) # spill self->interpStackEnd 26289 shl $2, %ecx # %ecx<- update offset for outsSize 26290 movl %eax, %edx # %edx<- newSaveArea 26291 sub %ecx, %eax # %eax<- bottom; (newSaveArea - outsSize) 26292 cmp TMP_SPILL1(%ebp), %eax # compare interpStackEnd and bottom 26293 movl LOCAL0_OFFSET(%ebp), %eax # %eax<- restore methodToCall 26294 jl .LstackOverflow # handle frame overflow 26295 26296 /* 26297 * set up newSaveArea 26298 */ 26299 26300#ifdef EASY_GDB 26301 SAVEAREA_FROM_FP %ecx # %ecx<- &StackSaveArea 26302 movl %ecx, offStackSaveArea_prevSave(%edx) # newSaveArea->prevSave<- &outs 26303#endif 26304 movl rSELF,%ecx # %ecx<- pthread 26305 movl rFP, offStackSaveArea_prevFrame(%edx) # newSaveArea->prevFrame<- rFP 26306 movl rPC, offStackSaveArea_savedPc(%edx) # newSaveArea->savedPc<- rPC 26307 26308 /* Any special actions to take? */ 26309 cmpb $0, offThread_subMode(%ecx) 26310 jne 2f # Yes - handle them 263111: 26312 testl $ACC_NATIVE, offMethod_accessFlags(%eax) # check for native call 26313 movl %eax, offStackSaveArea_method(%edx) # newSaveArea->method<- method to call 26314 jne .LinvokeNative # handle native call 26315 26316 /* 26317 * Update "self" values for the new method 26318 * %eax=methodToCall, LOCAL1_OFFSET(%ebp)=newFp 26319 */ 26320 movl offMethod_clazz(%eax), %edx # %edx<- method->clazz 26321 movl offClassObject_pDvmDex(%edx), %edx # %edx<- method->clazz->pDvmDex 26322 movl %eax, offThread_method(%ecx) # self->method<- methodToCall 26323 movl %edx, offThread_methodClassDex(%ecx) # self->methodClassDex<- method->clazz->pDvmDex 26324 movl offMethod_insns(%eax), rPC # rPC<- methodToCall->insns 26325 movl $1, offThread_debugIsMethodEntry(%ecx) 26326 movl LOCAL1_OFFSET(%ebp), rFP # rFP<- newFP 26327 movl rFP, offThread_curFrame(%ecx) # curFrame<-newFP 26328 movl offThread_curHandlerTable(%ecx),rIBASE 26329 FETCH_INST 26330 GOTO_NEXT # jump to methodToCall->insns 26331 263322: 26333 /* 26334 * On entry, preserve all: 26335 * %eax: method 26336 * %ecx: self 26337 * %edx: new save area 26338 */ 26339 SPILL_TMP1(%eax) # preserve methodToCall 26340 SPILL_TMP2(%edx) # preserve newSaveArea 26341 movl rPC, offThread_pc(%ecx) # update interpSave.pc 26342 movl %ecx, OUT_ARG0(%esp) 26343 movl %eax, OUT_ARG1(%esp) 26344 call dvmReportInvoke # (self, method) 26345 UNSPILL_TMP1(%eax) 26346 UNSPILL_TMP2(%edx) 26347 movl rSELF,%ecx # restore rSELF 26348 jmp 1b 26349 26350 /* 26351 * Prep for the native call 26352 * %eax=methodToCall, LOCAL1_OFFSET(%ebp)=newFP, %edx=newSaveArea, %ecx=self 26353 */ 26354 26355.LinvokeNative: 26356 movl offThread_jniLocal_topCookie(%ecx), rINST # rINST<- self->localRef->... 26357 movl rINST, offStackSaveArea_localRefCookie(%edx) # newSaveArea->localRefCookie<- top 26358 movl %edx, LOCAL2_OFFSET(%ebp) # save newSaveArea 26359 movl LOCAL1_OFFSET(%ebp), rINST # rINST<- newFP 26360 movl rINST, offThread_curFrame(%ecx) # curFrame<- newFP 26361 cmpb $0, offThread_subMode(%ecx) # Anything special going on? 26362 jne 11f # yes - handle it 26363 movl %ecx, OUT_ARG3(%esp) # push parameter self 26364 movl %eax, OUT_ARG2(%esp) # push parameter methodToCall 26365 lea offThread_retval(%ecx), %ecx # %ecx<- &retval 26366 movl %ecx, OUT_ARG1(%esp) # push parameter &retval 26367 movl rINST, OUT_ARG0(%esp) # push parameter newFP 26368 call *offMethod_nativeFunc(%eax) # call methodToCall->nativeFunc 263697: 26370 movl LOCAL2_OFFSET(%ebp), %ecx # %ecx<- newSaveArea 26371 movl rSELF, %eax # %eax<- self 26372 movl offStackSaveArea_localRefCookie(%ecx), %edx # %edx<- old top 26373 cmp $0, offThread_exception(%eax) # check for exception 26374 movl rFP, offThread_curFrame(%eax) # curFrame<- rFP 26375 movl %edx, offThread_jniLocal_topCookie(%eax) # new top <- old top 26376 jne common_exceptionThrown # handle exception 26377 movl offThread_curHandlerTable(%eax),rIBASE 26378 FETCH_INST_OPCODE 3 %ecx 26379 ADVANCE_PC 3 26380 GOTO_NEXT_R %ecx # jump to next instruction 26381 2638211: 26383 /* 26384 * Handle any special subMode actions 26385 * %eax=methodToCall, rINST=newFP, %ecx=self 26386 */ 26387 SPILL_TMP1(%eax) # save methodTocall 26388 movl rPC, offThread_pc(%ecx) 26389 movl %ecx, OUT_ARG0(%esp) 26390 movl %eax, OUT_ARG1(%esp) 26391 movl rFP, OUT_ARG2(%esp) 26392 call dvmReportPreNativeInvoke # (self, methodToCall, fp) 26393 UNSPILL_TMP1(%eax) # restore methodToCall 26394 movl rSELF,%ecx # restore self 26395 26396 /* Do the native call */ 26397 movl %ecx, OUT_ARG3(%esp) # push parameter self 26398 lea offThread_retval(%ecx), %ecx # %ecx<- &retval 26399 movl %eax, OUT_ARG2(%esp) # push parameter methodToCall 26400 movl %ecx, OUT_ARG1(%esp) # push parameter &retval 26401 movl rINST, OUT_ARG0(%esp) # push parameter newFP 26402 call *offMethod_nativeFunc(%eax) # call methodToCall->nativeFunc 26403 26404 UNSPILL_TMP1(%eax) # restore methodToCall 26405 movl rSELF, %ecx 26406 movl %ecx, OUT_ARG0(%esp) 26407 movl %eax, OUT_ARG1(%esp) 26408 movl rFP, OUT_ARG2(%esp) 26409 call dvmReportPostNativeInvoke # (self, methodToCall, fp) 26410 jmp 7b # rejoin 26411 26412.LstackOverflow: # eax=methodToCall 26413 movl %eax, OUT_ARG1(%esp) # push parameter methodToCall 26414 movl rSELF,%eax # %eax<- self 26415 movl %eax, OUT_ARG0(%esp) # push parameter self 26416 call dvmHandleStackOverflow # call: (Thread* self, Method* meth) 26417 jmp common_exceptionThrown # handle exception 26418 26419 26420/* 26421 * Common code for handling a return instruction 26422 */ 26423common_returnFromMethod: 26424 movl rSELF,%ecx 26425 SAVEAREA_FROM_FP %eax # eax<- saveArea (old) 26426 movl offStackSaveArea_prevFrame(%eax),rFP # rFP<- prevFrame 26427 cmpb $0, offThread_subMode(%ecx) # special action needed? 26428 jne 19f # go if so 2642914: 26430 movl (offStackSaveArea_method-sizeofStackSaveArea)(rFP),rINST 26431 cmpl $0,rINST # break? 26432 je common_gotoBail # break frame, bail out completely 26433 26434 movl offStackSaveArea_savedPc(%eax),rPC # pc<- saveArea->savedPC 26435 movl rINST,offThread_method(%ecx) # self->method = newSave->meethod 26436 movl rFP,offThread_curFrame(%ecx) # curFrame = fp 26437 movl offMethod_clazz(rINST),%eax # eax<- method->clazz 26438 movl offThread_curHandlerTable(%ecx),rIBASE 26439 movl offClassObject_pDvmDex(%eax),rINST # rINST<- method->clazz->pDvmDex 26440 FETCH_INST_OPCODE 3 %eax 26441 movl rINST,offThread_methodClassDex(%ecx) 26442 ADVANCE_PC 3 26443 GOTO_NEXT_R %eax 26444 2644519: 26446 /* 26447 * Handle special subMode actions 26448 * On entry, rFP: prevFP, %ecx: self, %eax: saveArea 26449 */ 26450 movl rFP, offThread_curFrame(%ecx) # update interpSave.curFrame 26451 movl rPC, offThread_pc(%ecx) # update interpSave.pc 26452 movl %ecx, OUT_ARG0(%esp) # parameter self 26453 call dvmReportReturn # (self) 26454 movl rSELF, %ecx # restore self 26455 SAVEAREA_FROM_FP %eax # restore saveArea 26456 jmp 14b 26457 26458 26459/* 26460 * Prepare to strip the current frame and "longjump" back to caller of 26461 * dvmMterpStdRun. 26462 * 26463 * on entry: 26464 * rINST holds changeInterp 26465 * ecx holds self pointer 26466 * 26467 * expected profile: dvmMterpStdBail(Thread *self, bool changeInterp) 26468 */ 26469common_gotoBail: 26470 movl rPC,offThread_pc(%ecx) # export state to self 26471 movl rFP,offThread_curFrame(%ecx) 26472 movl %ecx,OUT_ARG0(%esp) # self in arg0 26473 movl rINST,OUT_ARG1(%esp) # changeInterp in arg1 26474 call dvmMterpStdBail # bail out.... 26475 26476 26477/* 26478 * After returning from a "selfd" function, pull out the updated values 26479 * and start executing at the next instruction. 26480 */ 26481 common_resumeAfterGlueCall: 26482 movl rSELF, %eax 26483 movl offThread_pc(%eax),rPC 26484 movl offThread_curFrame(%eax),rFP 26485 movl offThread_curHandlerTable(%eax),rIBASE 26486 FETCH_INST 26487 GOTO_NEXT 26488 26489/* 26490 * Integer divide or mod by zero 26491 */ 26492common_errDivideByZero: 26493 EXPORT_PC 26494 movl $.LstrDivideByZero,%eax 26495 movl %eax,OUT_ARG0(%esp) 26496 call dvmThrowArithmeticException 26497 jmp common_exceptionThrown 26498 26499/* 26500 * Attempt to allocate an array with a negative size. 26501 * On entry, len in eax 26502 */ 26503common_errNegativeArraySize: 26504 EXPORT_PC 26505 movl %eax,OUT_ARG0(%esp) # arg0<- len 26506 call dvmThrowNegativeArraySizeException # (len) 26507 jmp common_exceptionThrown 26508 26509/* 26510 * Attempt to allocate an array with a negative size. 26511 * On entry, method name in eax 26512 */ 26513common_errNoSuchMethod: 26514 26515 EXPORT_PC 26516 movl %eax,OUT_ARG0(%esp) 26517 call dvmThrowNoSuchMethodError 26518 jmp common_exceptionThrown 26519 26520/* 26521 * Hit a null object when we weren't expecting one. Export the PC, throw a 26522 * NullPointerException and goto the exception processing code. 26523 */ 26524common_errNullObject: 26525 EXPORT_PC 26526 xorl %eax,%eax 26527 movl %eax,OUT_ARG0(%esp) 26528 call dvmThrowNullPointerException 26529 jmp common_exceptionThrown 26530 26531/* 26532 * Array index exceeds max. 26533 * On entry: 26534 * eax <- array object 26535 * ecx <- index 26536 */ 26537common_errArrayIndex: 26538 EXPORT_PC 26539 movl offArrayObject_length(%eax), %eax 26540 movl %eax,OUT_ARG0(%esp) 26541 movl %ecx,OUT_ARG1(%esp) 26542 call dvmThrowArrayIndexOutOfBoundsException # args (length, index) 26543 jmp common_exceptionThrown 26544 26545/* 26546 * Somebody has thrown an exception. Handle it. 26547 * 26548 * If the exception processing code returns to us (instead of falling 26549 * out of the interpreter), continue with whatever the next instruction 26550 * now happens to be. 26551 * 26552 * NOTE: special subMode handling done in dvmMterp_exceptionThrown 26553 * 26554 * This does not return. 26555 */ 26556common_exceptionThrown: 26557 movl rSELF,%ecx 26558 movl rPC,offThread_pc(%ecx) 26559 movl rFP,offThread_curFrame(%ecx) 26560 movl %ecx,OUT_ARG0(%esp) 26561 call dvmMterp_exceptionThrown 26562 jmp common_resumeAfterGlueCall 26563 26564common_abort: 26565 movl $0xdeadf00d,%eax 26566 call *%eax 26567 26568 26569/* 26570 * Strings 26571 */ 26572 26573 .section .rodata 26574.LstrDivideByZero: 26575 .asciz "divide by zero" 26576.LstrFilledNewArrayNotImplA: 26577 .asciz "filled-new-array only implemented for 'int'" 26578 26579