InterpAsm-x86.S revision a7d59bbafea5430fe81fc21ba94ddf6f6a63b0b3
1/* 2 * This file was generated automatically by gen-mterp.py for 'x86'. 3 * 4 * --> DO NOT EDIT <-- 5 */ 6 7/* File: x86/header.S */ 8/* 9 * Copyright (C) 2008 The Android Open Source Project 10 * 11 * Licensed under the Apache License, Version 2.0 (the "License"); 12 * you may not use this file except in compliance with the License. 13 * You may obtain a copy of the License at 14 * 15 * http://www.apache.org/licenses/LICENSE-2.0 16 * 17 * Unless required by applicable law or agreed to in writing, software 18 * distributed under the License is distributed on an "AS IS" BASIS, 19 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 20 * See the License for the specific language governing permissions and 21 * limitations under the License. 22 */ 23/* 24 * 32-bit x86 definitions and declarations. 25 */ 26 27/* 28386 ABI general notes: 29 30Caller save set: 31 eax, edx, ecx, st(0)-st(7) 32Callee save set: 33 ebx, esi, edi, ebp 34Return regs: 35 32-bit in eax 36 64-bit in edx:eax (low-order 32 in eax) 37 fp on top of fp stack st(0) 38 39Parameters passed on stack, pushed right-to-left. On entry to target, first 40parm is at 4(%esp). Traditional entry code is: 41 42functEntry: 43 push %ebp # save old frame pointer 44 mov %ebp,%esp # establish new frame pointer 45 sub FrameSize,%esp # Allocate storage for spill, locals & outs 46 47Once past the prologue, arguments are referenced at ((argno + 2)*4)(%ebp) 48 49Alignment of stack not strictly required, but should be for performance. We'll 50align frame sizes to 16-byte multiples. 51 52If we're not doing variable stack allocation (alloca), the frame pointer can be 53eliminated and all arg references adjusted to be esp relative. 54 55Mterp notes: 56 57Some key interpreter variables will be assigned to registers. Note that each 58will also have an associated spill location (mostly useful for those assigned 59to callee save registers). 60 61 nick reg purpose 62 rPC edi interpreted program counter, used for fetching instructions 63 rFP esi interpreted frame pointer, used for accessing locals and args 64 rINSTw bx first 16-bit code of current instruction 65 rINSTbl bl opcode portion of instruction word 66 rINSTbh bh high byte of inst word, usually contains src/tgt reg names 67 rIBASE edx base of instruction handler table 68 69Notes: 70 o High order 16 bits of ebx must be zero on entry to handler 71 o rPC, rFP, rINSTw/rINSTbl valid on handler entry and exit 72 o eax and ecx are scratch, rINSTw/ebx sometimes scratch 73 74*/ 75 76#define rSELF (%ebp) 77#define rPC %esi 78#define rFP %edi 79#define rINST %ebx 80#define rINSTw %bx 81#define rINSTbh %bh 82#define rINSTbl %bl 83#define rIBASE %edx 84 85 86/* Frame diagram while executing dvmMterpStdRun, high to low addresses */ 87#define IN_ARG0 ( 12) 88#define CALLER_RP ( 8) 89#define PREV_FP ( 4) 90#define rSELF_SPILL ( 0) /* <- dvmMterpStdRun ebp */ 91/* Spill offsets relative to %ebp */ 92#define EDI_SPILL ( -4) 93#define ESI_SPILL ( -8) 94#define EBX_SPILL (-12) /* <- esp following dmMterpStdRun header */ 95#define rPC_SPILL (-16) 96#define rFP_SPILL (-20) 97#define rINST_SPILL (-24) 98#define rIBASE_SPILL (-28) 99#define TMP_SPILL1 (-32) 100#define TMP_SPILL2 (-36) 101#define TMP_SPILL3 (-20) 102#define LOCAL0_OFFSET (-44) 103#define LOCAL1_OFFSET (-48) 104#define LOCAL2_OFFSET (-52) 105/* Out Arg offsets, relative to %sp */ 106#define OUT_ARG4 ( 16) 107#define OUT_ARG3 ( 12) 108#define OUT_ARG2 ( 8) 109#define OUT_ARG1 ( 4) 110#define OUT_ARG0 ( 0) /* <- dvmMterpStdRun esp */ 111#define FRAME_SIZE 80 112 113#define SPILL(reg) movl reg##,reg##_SPILL(%ebp) 114#define UNSPILL(reg) movl reg##_SPILL(%ebp),reg 115#define SPILL_TMP1(reg) movl reg,TMP_SPILL1(%ebp) 116#define UNSPILL_TMP1(reg) movl TMP_SPILL1(%ebp),reg 117#define SPILL_TMP2(reg) movl reg,TMP_SPILL2(%ebp) 118#define UNSPILL_TMP2(reg) movl TMP_SPILL2(%ebp),reg 119#define SPILL_TMP3(reg) movl reg,TMP_SPILL3(%ebp) 120#define UNSPILL_TMP3(reg) movl TMP_SPILL3(%ebp),reg 121 122#if defined(WITH_JIT) 123.macro GET_JIT_PROF_TABLE _self _reg 124 movl offThread_pJitProfTable(\_self),\_reg 125.endm 126.macro GET_JIT_THRESHOLD _self _reg 127 movl offThread_jitThreshold(\_self),\_reg 128.endm 129#endif 130 131/* save/restore the PC and/or FP from the self struct */ 132.macro SAVE_PC_FP_TO_SELF _reg 133 movl rSELF,\_reg 134 movl rPC,offThread_pc(\_reg) 135 movl rFP,offThread_fp(\_reg) 136.endm 137 138.macro LOAD_PC_FP_FROM_SELF 139 movl rSELF,rFP 140 movl offThread_pc(rFP),rPC 141 movl offThread_fp(rFP),rFP 142.endm 143 144/* The interpreter assumes a properly aligned stack on entry, and 145 * will preserve 16-byte alignment. 146 */ 147 148/* 149 * "export" the PC to the interpreted stack frame, f/b/o future exception 150 * objects. Must * be done *before* something calls dvmThrowException. 151 * 152 * In C this is "SAVEAREA_FROM_FP(fp)->xtra.currentPc = pc", i.e. 153 * fp - sizeof(StackSaveArea) + offsetof(SaveArea, xtra.currentPc) 154 * 155 * It's okay to do this more than once. 156 */ 157.macro EXPORT_PC 158 movl rPC, (-sizeofStackSaveArea + offStackSaveArea_currentPc)(rFP) 159.endm 160 161/* 162 * Given a frame pointer, find the stack save area. 163 * 164 * In C this is "((StackSaveArea*)(_fp) -1)". 165 */ 166.macro SAVEAREA_FROM_FP _reg 167 leal -sizeofStackSaveArea(rFP), \_reg 168.endm 169 170/* 171 * Fetch the next instruction from rPC into rINSTw. Does not advance rPC. 172 */ 173.macro FETCH_INST 174 movzwl (rPC),rINST 175.endm 176 177/* 178 * Fetch the opcode byte and zero-extend it into _reg. Must be used 179 * in conjunction with GOTO_NEXT_R 180 */ 181.macro FETCH_INST_R _reg 182 movzbl (rPC),\_reg 183.endm 184 185/* 186 * Fetch the opcode byte at _count words offset from rPC and zero-extend 187 * it into _reg. Must be used in conjunction with GOTO_NEXT_R 188 */ 189.macro FETCH_INST_OPCODE _count _reg 190 movzbl \_count*2(rPC),\_reg 191.endm 192 193/* 194 * Fetch the nth instruction word from rPC into rINSTw. Does not advance 195 * rPC, and _count is in words 196 */ 197.macro FETCH_INST_WORD _count 198 movzwl \_count*2(rPC),rINST 199.endm 200 201/* 202 * Fetch instruction word indexed (used for branching). 203 * Index is in instruction word units. 204 */ 205.macro FETCH_INST_INDEXED _reg 206 movzwl (rPC,\_reg,2),rINST 207.endm 208 209/* 210 * Advance rPC by instruction count 211 */ 212.macro ADVANCE_PC _count 213 leal 2*\_count(rPC),rPC 214.endm 215 216/* 217 * Advance rPC by branch offset in register 218 */ 219.macro ADVANCE_PC_INDEXED _reg 220 leal (rPC,\_reg,2),rPC 221.endm 222 223.macro GOTO_NEXT 224 movzx rINSTbl,%eax 225 movzbl rINSTbh,rINST 226 jmp *(rIBASE,%eax,4) 227.endm 228 229 /* 230 * Version of GOTO_NEXT that assumes _reg preloaded with opcode. 231 * Should be paired with FETCH_INST_R 232 */ 233.macro GOTO_NEXT_R _reg 234 movzbl 1(rPC),rINST 235 jmp *(rIBASE,\_reg,4) 236.endm 237 238 /* 239 * Jumbo version of GOTO_NEXT that assumes _reg preloaded with table 240 * offset of the jumbo instruction, which is the top half of the extended 241 * opcode + 0x100. Loads rINST with BBBB field, similar to GOTO_NEXT_R 242 */ 243.macro GOTO_NEXT_JUMBO_R _reg 244 movzwl 6(rPC),rINST 245 jmp *(rIBASE,\_reg,4) 246.endm 247 248/* 249 * Get/set the 32-bit value from a Dalvik register. 250 */ 251.macro GET_VREG_R _reg _vreg 252 movl (rFP,\_vreg,4),\_reg 253.endm 254 255.macro SET_VREG _reg _vreg 256 movl \_reg,(rFP,\_vreg,4) 257.endm 258 259.macro GET_VREG_WORD _reg _vreg _offset 260 movl 4*(\_offset)(rFP,\_vreg,4),\_reg 261.endm 262 263.macro SET_VREG_WORD _reg _vreg _offset 264 movl \_reg,4*(\_offset)(rFP,\_vreg,4) 265.endm 266 267#define sReg0 LOCAL0_OFFSET(%ebp) 268#define sReg1 LOCAL1_OFFSET(%ebp) 269#define sReg2 LOCAL2_OFFSET(%ebp) 270 271 /* 272 * Hard coded helper values. 273 */ 274 275.balign 16 276 277.LdoubNeg: 278 .quad 0x8000000000000000 279 280.L64bits: 281 .quad 0xFFFFFFFFFFFFFFFF 282 283.LshiftMask2: 284 .quad 0x0000000000000000 285.LshiftMask: 286 .quad 0x000000000000003F 287 288.Lvalue64: 289 .quad 0x0000000000000040 290 291.LvaluePosInfLong: 292 .quad 0x7FFFFFFFFFFFFFFF 293 294.LvalueNegInfLong: 295 .quad 0x8000000000000000 296 297.LvalueNanLong: 298 .quad 0x0000000000000000 299 300.LintMin: 301.long 0x80000000 302 303.LintMax: 304.long 0x7FFFFFFF 305 306 307/* 308 * This is a #include, not a %include, because we want the C pre-processor 309 * to expand the macros into assembler assignment statements. 310 */ 311#include "../common/asm-constants.h" 312 313#if defined(WITH_JIT) 314#include "../common/jit-config.h" 315#endif 316 317 318 .global dvmAsmInstructionStartCode 319 .type dvmAsmInstructionStartCode, %function 320dvmAsmInstructionStartCode = .L_OP_NOP 321 .text 322 323/* ------------------------------ */ 324.L_OP_NOP: /* 0x00 */ 325/* File: x86/OP_NOP.S */ 326 FETCH_INST_OPCODE 1 %ecx 327 ADVANCE_PC 1 328 GOTO_NEXT_R %ecx 329 330/* ------------------------------ */ 331.L_OP_MOVE: /* 0x01 */ 332/* File: x86/OP_MOVE.S */ 333 /* for move, move-object, long-to-int */ 334 /* op vA, vB */ 335 movzbl rINSTbl,%eax # eax<- BA 336 andb $0xf,%al # eax<- A 337 shrl $4,rINST # rINST<- B 338 GET_VREG_R rINST rINST 339 FETCH_INST_OPCODE 1 %ecx 340 ADVANCE_PC 1 341 SET_VREG rINST %eax # fp[A]<-fp[B] 342 GOTO_NEXT_R %ecx 343 344/* ------------------------------ */ 345.L_OP_MOVE_FROM16: /* 0x02 */ 346/* File: x86/OP_MOVE_FROM16.S */ 347 /* for: move/from16, move-object/from16 */ 348 /* op vAA, vBBBB */ 349 movzx rINSTbl,%eax # eax <= AA 350 movw 2(rPC),rINSTw # rINSTw <= BBBB 351 GET_VREG_R rINST rINST # rINST- fp[BBBB] 352 FETCH_INST_OPCODE 2 %ecx 353 ADVANCE_PC 2 354 SET_VREG rINST %eax # fp[AA]<- ecx] 355 GOTO_NEXT_R %ecx 356 357/* ------------------------------ */ 358.L_OP_MOVE_16: /* 0x03 */ 359/* File: x86/OP_MOVE_16.S */ 360 /* for: move/16, move-object/16 */ 361 /* op vAAAA, vBBBB */ 362 movzwl 4(rPC),%ecx # ecx<- BBBB 363 movzwl 2(rPC),%eax # eax<- AAAA 364 GET_VREG_R rINST %ecx 365 FETCH_INST_OPCODE 3 %ecx 366 ADVANCE_PC 3 367 SET_VREG rINST %eax 368 GOTO_NEXT_R %ecx 369 370/* ------------------------------ */ 371.L_OP_MOVE_WIDE: /* 0x04 */ 372/* File: x86/OP_MOVE_WIDE.S */ 373 /* move-wide vA, vB */ 374 /* NOTE: regs can overlap, e.g. "move v6,v7" or "move v7,v6" */ 375 movzbl rINSTbl,%ecx # ecx <- BA 376 sarl $4,rINST # rINST<- B 377 GET_VREG_WORD %eax rINST 0 # eax<- v[B+0] 378 GET_VREG_WORD rINST rINST 1 # rINST<- v[B+1] 379 andb $0xf,%cl # ecx <- A 380 SET_VREG_WORD rINST %ecx 1 # v[A+1]<- rINST 381 SET_VREG_WORD %eax %ecx 0 # v[A+0]<- eax 382 FETCH_INST_OPCODE 1 %ecx 383 ADVANCE_PC 1 384 GOTO_NEXT_R %ecx 385 386/* ------------------------------ */ 387.L_OP_MOVE_WIDE_FROM16: /* 0x05 */ 388/* File: x86/OP_MOVE_WIDE_FROM16.S */ 389 /* move-wide/from16 vAA, vBBBB */ 390 /* NOTE: regs can overlap, e.g. "move v6,v7" or "move v7,v6" */ 391 movzwl 2(rPC),%ecx # ecx<- BBBB 392 movzbl rINSTbl,%eax # eax<- AAAA 393 GET_VREG_WORD rINST %ecx 0 # rINST<- v[BBBB+0] 394 GET_VREG_WORD %ecx %ecx 1 # ecx<- v[BBBB+1] 395 SET_VREG_WORD rINST %eax 0 # v[AAAA+0]<- rINST 396 SET_VREG_WORD %ecx %eax 1 # v[AAAA+1]<- eax 397 FETCH_INST_OPCODE 2 %ecx 398 ADVANCE_PC 2 399 GOTO_NEXT_R %ecx 400 401/* ------------------------------ */ 402.L_OP_MOVE_WIDE_16: /* 0x06 */ 403/* File: x86/OP_MOVE_WIDE_16.S */ 404 /* move-wide/16 vAAAA, vBBBB */ 405 /* NOTE: regs can overlap, e.g. "move v6,v7" or "move v7,v6" */ 406 movzwl 4(rPC),%ecx # ecx<- BBBB 407 movzwl 2(rPC),%eax # eax<- AAAA 408 GET_VREG_WORD rINST %ecx 0 # rINSTw_WORD<- v[BBBB+0] 409 GET_VREG_WORD %ecx %ecx 1 # ecx<- v[BBBB+1] 410 SET_VREG_WORD rINST %eax 0 # v[AAAA+0]<- rINST 411 SET_VREG_WORD %ecx %eax 1 # v[AAAA+1]<- ecx 412 FETCH_INST_OPCODE 3 %ecx 413 ADVANCE_PC 3 414 GOTO_NEXT_R %ecx 415 416/* ------------------------------ */ 417.L_OP_MOVE_OBJECT: /* 0x07 */ 418/* File: x86/OP_MOVE_OBJECT.S */ 419/* File: x86/OP_MOVE.S */ 420 /* for move, move-object, long-to-int */ 421 /* op vA, vB */ 422 movzbl rINSTbl,%eax # eax<- BA 423 andb $0xf,%al # eax<- A 424 shrl $4,rINST # rINST<- B 425 GET_VREG_R rINST rINST 426 FETCH_INST_OPCODE 1 %ecx 427 ADVANCE_PC 1 428 SET_VREG rINST %eax # fp[A]<-fp[B] 429 GOTO_NEXT_R %ecx 430 431 432/* ------------------------------ */ 433.L_OP_MOVE_OBJECT_FROM16: /* 0x08 */ 434/* File: x86/OP_MOVE_OBJECT_FROM16.S */ 435/* File: x86/OP_MOVE_FROM16.S */ 436 /* for: move/from16, move-object/from16 */ 437 /* op vAA, vBBBB */ 438 movzx rINSTbl,%eax # eax <= AA 439 movw 2(rPC),rINSTw # rINSTw <= BBBB 440 GET_VREG_R rINST rINST # rINST- fp[BBBB] 441 FETCH_INST_OPCODE 2 %ecx 442 ADVANCE_PC 2 443 SET_VREG rINST %eax # fp[AA]<- ecx] 444 GOTO_NEXT_R %ecx 445 446 447/* ------------------------------ */ 448.L_OP_MOVE_OBJECT_16: /* 0x09 */ 449/* File: x86/OP_MOVE_OBJECT_16.S */ 450/* File: x86/OP_MOVE_16.S */ 451 /* for: move/16, move-object/16 */ 452 /* op vAAAA, vBBBB */ 453 movzwl 4(rPC),%ecx # ecx<- BBBB 454 movzwl 2(rPC),%eax # eax<- AAAA 455 GET_VREG_R rINST %ecx 456 FETCH_INST_OPCODE 3 %ecx 457 ADVANCE_PC 3 458 SET_VREG rINST %eax 459 GOTO_NEXT_R %ecx 460 461 462/* ------------------------------ */ 463.L_OP_MOVE_RESULT: /* 0x0a */ 464/* File: x86/OP_MOVE_RESULT.S */ 465 /* for: move-result, move-result-object */ 466 /* op vAA */ 467 movl rSELF,%eax # eax<- rSELF 468 movl offThread_retval(%eax),%eax # eax<- self->retval.l 469 FETCH_INST_OPCODE 1 %ecx 470 ADVANCE_PC 1 471 SET_VREG %eax rINST # fp[AA]<- retval.l 472 GOTO_NEXT_R %ecx 473 474/* ------------------------------ */ 475.L_OP_MOVE_RESULT_WIDE: /* 0x0b */ 476/* File: x86/OP_MOVE_RESULT_WIDE.S */ 477 /* move-result-wide vAA */ 478 movl rSELF,%ecx 479 movl offThread_retval(%ecx),%eax 480 movl 4+offThread_retval(%ecx),%ecx 481 SET_VREG_WORD %eax rINST 0 # v[AA+0] <- eax 482 SET_VREG_WORD %ecx rINST 1 # v[AA+1] <- ecx 483 FETCH_INST_OPCODE 1 %ecx 484 ADVANCE_PC 1 485 GOTO_NEXT_R %ecx 486 487/* ------------------------------ */ 488.L_OP_MOVE_RESULT_OBJECT: /* 0x0c */ 489/* File: x86/OP_MOVE_RESULT_OBJECT.S */ 490/* File: x86/OP_MOVE_RESULT.S */ 491 /* for: move-result, move-result-object */ 492 /* op vAA */ 493 movl rSELF,%eax # eax<- rSELF 494 movl offThread_retval(%eax),%eax # eax<- self->retval.l 495 FETCH_INST_OPCODE 1 %ecx 496 ADVANCE_PC 1 497 SET_VREG %eax rINST # fp[AA]<- retval.l 498 GOTO_NEXT_R %ecx 499 500 501/* ------------------------------ */ 502.L_OP_MOVE_EXCEPTION: /* 0x0d */ 503/* File: x86/OP_MOVE_EXCEPTION.S */ 504 /* move-exception vAA */ 505 movl rSELF,%ecx 506 movl offThread_exception(%ecx),%eax # eax<- dvmGetException bypass 507 SET_VREG %eax rINST # fp[AA]<- exception object 508 FETCH_INST_OPCODE 1 %eax 509 ADVANCE_PC 1 510 movl $0,offThread_exception(%ecx) # dvmClearException bypass 511 GOTO_NEXT_R %eax 512 513/* ------------------------------ */ 514.L_OP_RETURN_VOID: /* 0x0e */ 515/* File: x86/OP_RETURN_VOID.S */ 516 jmp common_returnFromMethod 517 518/* ------------------------------ */ 519.L_OP_RETURN: /* 0x0f */ 520/* File: x86/OP_RETURN.S */ 521 /* 522 * Return a 32-bit value. Copies the return value into the "self" 523 * structure, then jumps to the return handler. 524 * 525 * for: return, return-object 526 */ 527 /* op vAA */ 528 movl rSELF,%ecx 529 GET_VREG_R %eax rINST # eax<- vAA 530 movl %eax,offThread_retval(%ecx) # retval.i <- AA 531 jmp common_returnFromMethod 532 533/* ------------------------------ */ 534.L_OP_RETURN_WIDE: /* 0x10 */ 535/* File: x86/OP_RETURN_WIDE.S */ 536 /* 537 * Return a 64-bit value. Copies the return value into the "self" 538 * structure, then jumps to the return handler. 539 */ 540 /* return-wide vAA */ 541 movl rSELF,%ecx 542 GET_VREG_WORD %eax rINST 0 # eax<- v[AA+0] 543 GET_VREG_WORD rINST rINST 1 # rINST<- v[AA+1] 544 movl %eax,offThread_retval(%ecx) 545 movl rINST,4+offThread_retval(%ecx) 546 jmp common_returnFromMethod 547 548/* ------------------------------ */ 549.L_OP_RETURN_OBJECT: /* 0x11 */ 550/* File: x86/OP_RETURN_OBJECT.S */ 551/* File: x86/OP_RETURN.S */ 552 /* 553 * Return a 32-bit value. Copies the return value into the "self" 554 * structure, then jumps to the return handler. 555 * 556 * for: return, return-object 557 */ 558 /* op vAA */ 559 movl rSELF,%ecx 560 GET_VREG_R %eax rINST # eax<- vAA 561 movl %eax,offThread_retval(%ecx) # retval.i <- AA 562 jmp common_returnFromMethod 563 564 565/* ------------------------------ */ 566.L_OP_CONST_4: /* 0x12 */ 567/* File: x86/OP_CONST_4.S */ 568 /* const/4 vA, #+B */ 569 movsx rINSTbl,%eax # eax<-ssssssBx 570 movl $0xf,rINST 571 andl %eax,rINST # rINST<- A 572 FETCH_INST_OPCODE 1 %ecx 573 ADVANCE_PC 1 574 sarl $4,%eax 575 SET_VREG %eax rINST 576 GOTO_NEXT_R %ecx 577 578/* ------------------------------ */ 579.L_OP_CONST_16: /* 0x13 */ 580/* File: x86/OP_CONST_16.S */ 581 /* const/16 vAA, #+BBBB */ 582 movswl 2(rPC),%ecx # ecx<- ssssBBBB 583 FETCH_INST_OPCODE 2 %eax 584 ADVANCE_PC 2 585 SET_VREG %ecx rINST # vAA<- ssssBBBB 586 GOTO_NEXT_R %eax 587 588/* ------------------------------ */ 589.L_OP_CONST: /* 0x14 */ 590/* File: x86/OP_CONST.S */ 591 /* const vAA, #+BBBBbbbb */ 592 movl 2(rPC),%eax # grab all 32 bits at once 593 movl rINST,rINST # rINST<- AA 594 FETCH_INST_OPCODE 3 %ecx 595 ADVANCE_PC 3 596 SET_VREG %eax rINST # vAA<- eax 597 GOTO_NEXT_R %ecx 598 599/* ------------------------------ */ 600.L_OP_CONST_HIGH16: /* 0x15 */ 601/* File: x86/OP_CONST_HIGH16.S */ 602 /* const/high16 vAA, #+BBBB0000 */ 603 movzwl 2(rPC),%eax # eax<- 0000BBBB 604 FETCH_INST_OPCODE 2 %ecx 605 ADVANCE_PC 2 606 sall $16,%eax # eax<- BBBB0000 607 SET_VREG %eax rINST # vAA<- eax 608 GOTO_NEXT_R %ecx 609 610/* ------------------------------ */ 611.L_OP_CONST_WIDE_16: /* 0x16 */ 612/* File: x86/OP_CONST_WIDE_16.S */ 613 /* const-wide/16 vAA, #+BBBB */ 614 movswl 2(rPC),%eax # eax<- ssssBBBB 615 SPILL(rIBASE) # preserve rIBASE (cltd trashes it) 616 cltd # rIBASE:eax<- ssssssssssssBBBB 617 SET_VREG_WORD rIBASE rINST 1 # store msw 618 FETCH_INST_OPCODE 2 %ecx 619 UNSPILL(rIBASE) # restore rIBASE 620 SET_VREG_WORD %eax rINST 0 # store lsw 621 ADVANCE_PC 2 622 GOTO_NEXT_R %ecx 623 624/* ------------------------------ */ 625.L_OP_CONST_WIDE_32: /* 0x17 */ 626/* File: x86/OP_CONST_WIDE_32.S */ 627 /* const-wide/32 vAA, #+BBBBbbbb */ 628 movl 2(rPC),%eax # eax<- BBBBbbbb 629 SPILL(rIBASE) # save rIBASE (cltd trashes it) 630 cltd # rIBASE:eax<- ssssssssssssBBBB 631 SET_VREG_WORD rIBASE rINST,1 # store msw 632 FETCH_INST_OPCODE 3 %ecx 633 UNSPILL(rIBASE) # restore rIBASE 634 SET_VREG_WORD %eax rINST 0 # store lsw 635 ADVANCE_PC 3 636 GOTO_NEXT_R %ecx 637 638/* ------------------------------ */ 639.L_OP_CONST_WIDE: /* 0x18 */ 640/* File: x86/OP_CONST_WIDE.S */ 641 /* const-wide vAA, #+HHHHhhhhBBBBbbbb */ 642 movl 2(rPC),%eax # eax<- lsw 643 movzbl rINSTbl,%ecx # ecx<- AA 644 movl 6(rPC),rINST # rINST<- msw 645 leal (rFP,%ecx,4),%ecx # dst addr 646 movl rINST,4(%ecx) 647 movl %eax,(%ecx) 648 FETCH_INST_OPCODE 5 %ecx 649 ADVANCE_PC 5 650 GOTO_NEXT_R %ecx 651 652/* ------------------------------ */ 653.L_OP_CONST_WIDE_HIGH16: /* 0x19 */ 654/* File: x86/OP_CONST_WIDE_HIGH16.S */ 655 /* const-wide/high16 vAA, #+BBBB000000000000 */ 656 movzwl 2(rPC),%eax # eax<- 0000BBBB 657 FETCH_INST_OPCODE 2 %ecx 658 ADVANCE_PC 2 659 sall $16,%eax # eax<- BBBB0000 660 SET_VREG_WORD %eax rINST 1 # v[AA+1]<- eax 661 xorl %eax,%eax 662 SET_VREG_WORD %eax rINST 0 # v[AA+0]<- eax 663 GOTO_NEXT_R %ecx 664 665/* ------------------------------ */ 666.L_OP_CONST_STRING: /* 0x1a */ 667/* File: x86/OP_CONST_STRING.S */ 668 669 /* const/string vAA, String@BBBB */ 670 movl rSELF,%ecx 671 movzwl 2(rPC),%eax # eax<- BBBB 672 movl offThread_methodClassDex(%ecx),%ecx# ecx<- self->methodClassDex 673 movl offDvmDex_pResStrings(%ecx),%ecx # ecx<- dvmDex->pResStrings 674 movl (%ecx,%eax,4),%eax # eax<- rResString[BBBB] 675 FETCH_INST_OPCODE 2 %ecx 676 testl %eax,%eax # resolved yet? 677 je .LOP_CONST_STRING_resolve 678 SET_VREG %eax rINST # vAA<- rResString[BBBB] 679 ADVANCE_PC 2 680 GOTO_NEXT_R %ecx 681 682/* This is the less common path, so we'll redo some work 683 here rather than force spills on the common path */ 684.LOP_CONST_STRING_resolve: 685 movl rSELF,%eax 686 EXPORT_PC 687 movl offThread_method(%eax),%eax # eax<- self->method 688 movzwl 2(rPC),%ecx # ecx<- BBBB 689 movl offMethod_clazz(%eax),%eax 690 movl %ecx,OUT_ARG1(%esp) 691 movl %eax,OUT_ARG0(%esp) 692 SPILL(rIBASE) 693 call dvmResolveString # go resolve 694 UNSPILL(rIBASE) 695 testl %eax,%eax # failed? 696 je common_exceptionThrown 697 FETCH_INST_OPCODE 2 %ecx 698 SET_VREG %eax rINST 699 ADVANCE_PC 2 700 GOTO_NEXT_R %ecx 701 702/* ------------------------------ */ 703.L_OP_CONST_STRING_JUMBO: /* 0x1b */ 704/* File: x86/OP_CONST_STRING_JUMBO.S */ 705 706 /* const/string vAA, String@BBBBBBBB */ 707 movl rSELF,%ecx 708 movl 2(rPC),%eax # eax<- BBBBBBBB 709 movl offThread_methodClassDex(%ecx),%ecx# ecx<- self->methodClassDex 710 movl offDvmDex_pResStrings(%ecx),%ecx # ecx<- dvmDex->pResStrings 711 movl (%ecx,%eax,4),%eax # eax<- rResString[BBBB] 712 FETCH_INST_OPCODE 3 %ecx 713 testl %eax,%eax # resolved yet? 714 je .LOP_CONST_STRING_JUMBO_resolve 715 SET_VREG %eax rINST # vAA<- rResString[BBBB] 716 ADVANCE_PC 3 717 GOTO_NEXT_R %ecx 718 719/* This is the less common path, so we'll redo some work 720 here rather than force spills on the common path */ 721.LOP_CONST_STRING_JUMBO_resolve: 722 movl rSELF,%eax 723 EXPORT_PC 724 movl offThread_method(%eax),%eax # eax<- self->method 725 movl 2(rPC),%ecx # ecx<- BBBBBBBB 726 movl offMethod_clazz(%eax),%eax 727 movl %ecx,OUT_ARG1(%esp) 728 movl %eax,OUT_ARG0(%esp) 729 SPILL(rIBASE) 730 call dvmResolveString # go resolve 731 UNSPILL(rIBASE) 732 testl %eax,%eax # failed? 733 je common_exceptionThrown 734 FETCH_INST_OPCODE 3 %ecx 735 SET_VREG %eax rINST 736 ADVANCE_PC 3 737 GOTO_NEXT_R %ecx 738 739/* ------------------------------ */ 740.L_OP_CONST_CLASS: /* 0x1c */ 741/* File: x86/OP_CONST_CLASS.S */ 742 743 /* const/class vAA, Class@BBBB */ 744 movl rSELF,%ecx 745 movzwl 2(rPC),%eax # eax<- BBBB 746 movl offThread_methodClassDex(%ecx),%ecx# ecx<- self->methodClassDex 747 movl offDvmDex_pResClasses(%ecx),%ecx # ecx<- dvmDex->pResClasses 748 movl (%ecx,%eax,4),%eax # eax<- rResClasses[BBBB] 749 testl %eax,%eax # resolved yet? 750 je .LOP_CONST_CLASS_resolve 751 FETCH_INST_OPCODE 2 %ecx 752 SET_VREG %eax rINST # vAA<- rResClasses[BBBB] 753 ADVANCE_PC 2 754 GOTO_NEXT_R %ecx 755 756/* This is the less common path, so we'll redo some work 757 here rather than force spills on the common path */ 758.LOP_CONST_CLASS_resolve: 759 movl rSELF,%eax 760 EXPORT_PC 761 movl offThread_method(%eax),%eax # eax<- self->method 762 movl $1,OUT_ARG2(%esp) # true 763 movzwl 2(rPC),%ecx # ecx<- BBBB 764 movl offMethod_clazz(%eax),%eax 765 movl %ecx,OUT_ARG1(%esp) 766 movl %eax,OUT_ARG0(%esp) 767 SPILL(rIBASE) 768 call dvmResolveClass # go resolve 769 UNSPILL(rIBASE) 770 testl %eax,%eax # failed? 771 je common_exceptionThrown 772 FETCH_INST_OPCODE 2 %ecx 773 SET_VREG %eax rINST 774 ADVANCE_PC 2 775 GOTO_NEXT_R %ecx 776 777/* ------------------------------ */ 778.L_OP_MONITOR_ENTER: /* 0x1d */ 779/* File: x86/OP_MONITOR_ENTER.S */ 780 /* 781 * Synchronize on an object. 782 */ 783 /* monitor-enter vAA */ 784 movl rSELF,%ecx 785 GET_VREG_R %eax rINST # eax<- vAA 786 FETCH_INST_WORD 1 787 testl %eax,%eax # null object? 788 EXPORT_PC # need for precise GC 789 je common_errNullObject 790 movl %ecx,OUT_ARG0(%esp) 791 movl %eax,OUT_ARG1(%esp) 792 SPILL(rIBASE) 793 call dvmLockObject # dvmLockObject(self,object) 794 UNSPILL(rIBASE) 795 FETCH_INST_OPCODE 1 %ecx 796 ADVANCE_PC 1 797 GOTO_NEXT_R %ecx 798 799/* ------------------------------ */ 800.L_OP_MONITOR_EXIT: /* 0x1e */ 801/* File: x86/OP_MONITOR_EXIT.S */ 802 /* 803 * Unlock an object. 804 * 805 * Exceptions that occur when unlocking a monitor need to appear as 806 * if they happened at the following instruction. See the Dalvik 807 * instruction spec. 808 */ 809 /* monitor-exit vAA */ 810 GET_VREG_R %eax rINST 811 movl rSELF,%ecx 812 EXPORT_PC 813 testl %eax,%eax # null object? 814 je .LOP_MONITOR_EXIT_errNullObject # go if so 815 movl %eax,OUT_ARG1(%esp) 816 movl %ecx,OUT_ARG0(%esp) 817 SPILL(rIBASE) 818 call dvmUnlockObject # unlock(self,obj) 819 UNSPILL(rIBASE) 820 FETCH_INST_OPCODE 1 %ecx 821 testl %eax,%eax # success? 822 ADVANCE_PC 1 823 je common_exceptionThrown # no, exception pending 824 GOTO_NEXT_R %ecx 825.LOP_MONITOR_EXIT_errNullObject: 826 ADVANCE_PC 1 # advance before throw 827 jmp common_errNullObject 828 829/* ------------------------------ */ 830.L_OP_CHECK_CAST: /* 0x1f */ 831/* File: x86/OP_CHECK_CAST.S */ 832 /* 833 * Check to see if a cast from one class to another is allowed. 834 */ 835 /* check-cast vAA, class@BBBB */ 836 movl rSELF,%ecx 837 GET_VREG_R rINST,rINST # rINST<- vAA (object) 838 movzwl 2(rPC),%eax # eax<- BBBB 839 movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex 840 testl rINST,rINST # is oject null? 841 movl offDvmDex_pResClasses(%ecx),%ecx # ecx<- pDvmDex->pResClasses 842 je .LOP_CHECK_CAST_okay # null obj, cast always succeeds 843 movl (%ecx,%eax,4),%eax # eax<- resolved class 844 movl offObject_clazz(rINST),%ecx # ecx<- obj->clazz 845 testl %eax,%eax # have we resolved this before? 846 je .LOP_CHECK_CAST_resolve # no, go do it now 847.LOP_CHECK_CAST_resolved: 848 cmpl %eax,%ecx # same class (trivial success)? 849 jne .LOP_CHECK_CAST_fullcheck # no, do full check 850.LOP_CHECK_CAST_okay: 851 FETCH_INST_OPCODE 2 %ecx 852 ADVANCE_PC 2 853 GOTO_NEXT_R %ecx 854 855 /* 856 * Trivial test failed, need to perform full check. This is common. 857 * ecx holds obj->clazz 858 * eax holds class resolved from BBBB 859 * rINST holds object 860 */ 861.LOP_CHECK_CAST_fullcheck: 862 movl %eax,sReg0 # we'll need the desired class on failure 863 movl %eax,OUT_ARG1(%esp) 864 movl %ecx,OUT_ARG0(%esp) 865 SPILL(rIBASE) 866 call dvmInstanceofNonTrivial # eax<- boolean result 867 UNSPILL(rIBASE) 868 testl %eax,%eax # failed? 869 jne .LOP_CHECK_CAST_okay # no, success 870 871 # A cast has failed. We need to throw a ClassCastException. 872 EXPORT_PC 873 movl offObject_clazz(rINST),%eax 874 movl %eax,OUT_ARG0(%esp) # arg0<- obj->clazz 875 movl sReg0,%ecx 876 movl %ecx,OUT_ARG1(%esp) # arg1<- desired class 877 call dvmThrowClassCastException 878 jmp common_exceptionThrown 879 880 /* 881 * Resolution required. This is the least-likely path, and we're 882 * going to have to recreate some data. 883 * 884 * rINST holds object 885 */ 886.LOP_CHECK_CAST_resolve: 887 movl rSELF,%ecx 888 EXPORT_PC 889 movzwl 2(rPC),%eax # eax<- BBBB 890 movl offThread_method(%ecx),%ecx # ecx<- self->method 891 movl %eax,OUT_ARG1(%esp) # arg1<- BBBB 892 movl offMethod_clazz(%ecx),%ecx # ecx<- metho->clazz 893 movl $0,OUT_ARG2(%esp) # arg2<- false 894 movl %ecx,OUT_ARG0(%esp) # arg0<- method->clazz 895 SPILL(rIBASE) 896 call dvmResolveClass # eax<- resolved ClassObject ptr 897 UNSPILL(rIBASE) 898 testl %eax,%eax # got null? 899 je common_exceptionThrown # yes, handle exception 900 movl offObject_clazz(rINST),%ecx # ecx<- obj->clazz 901 jmp .LOP_CHECK_CAST_resolved # pick up where we left off 902 903/* ------------------------------ */ 904.L_OP_INSTANCE_OF: /* 0x20 */ 905/* File: x86/OP_INSTANCE_OF.S */ 906 /* 907 * Check to see if an object reference is an instance of a class. 908 * 909 * Most common situation is a non-null object, being compared against 910 * an already-resolved class. 911 */ 912 /* instance-of vA, vB, class@CCCC */ 913 movl rINST,%eax # eax<- BA 914 sarl $4,%eax # eax<- B 915 GET_VREG_R %eax %eax # eax<- vB (obj) 916 movl rSELF,%ecx 917 testl %eax,%eax # object null? 918 movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex 919 SPILL(rIBASE) # preserve rIBASE 920 je .LOP_INSTANCE_OF_store # null obj, not instance, store it 921 movzwl 2(rPC),rIBASE # rIBASE<- CCCC 922 movl offDvmDex_pResClasses(%ecx),%ecx # ecx<- pDvmDex->pResClasses 923 movl (%ecx,rIBASE,4),%ecx # ecx<- resolved class 924 movl offObject_clazz(%eax),%eax # eax<- obj->clazz 925 testl %ecx,%ecx # have we resolved this before? 926 je .LOP_INSTANCE_OF_resolve # not resolved, do it now 927.LOP_INSTANCE_OF_resolved: # eax<- obj->clazz, ecx<- resolved class 928 cmpl %eax,%ecx # same class (trivial success)? 929 je .LOP_INSTANCE_OF_trivial # yes, trivial finish 930 /* 931 * Trivial test failed, need to perform full check. This is common. 932 * eax holds obj->clazz 933 * ecx holds class resolved from BBBB 934 * rINST has BA 935 */ 936 movl %eax,OUT_ARG0(%esp) 937 movl %ecx,OUT_ARG1(%esp) 938 call dvmInstanceofNonTrivial # eax<- boolean result 939 # fall through to OP_INSTANCE_OF_store 940 941 /* 942 * eax holds boolean result 943 * rINST holds BA 944 */ 945.LOP_INSTANCE_OF_store: 946 FETCH_INST_OPCODE 2 %ecx 947 UNSPILL(rIBASE) 948 andb $0xf,rINSTbl # <- A 949 ADVANCE_PC 2 950 SET_VREG %eax rINST # vA<- eax 951 GOTO_NEXT_R %ecx 952 953 /* 954 * Trivial test succeeded, save and bail. 955 * r9 holds A 956 */ 957.LOP_INSTANCE_OF_trivial: 958 FETCH_INST_OPCODE 2 %ecx 959 UNSPILL(rIBASE) 960 andb $0xf,rINSTbl # <- A 961 ADVANCE_PC 2 962 movl $1,%eax 963 SET_VREG %eax rINST # vA<- true 964 GOTO_NEXT_R %ecx 965 966 /* 967 * Resolution required. This is the least-likely path. 968 * 969 * rIBASE holds BBBB 970 * rINST holds BA 971 */ 972.LOP_INSTANCE_OF_resolve: 973 movl rIBASE,OUT_ARG1(%esp) # arg1<- BBBB 974 movl rSELF,%ecx 975 movl offThread_method(%ecx),%ecx 976 movl $1,OUT_ARG2(%esp) # arg2<- true 977 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 978 EXPORT_PC 979 movl %ecx,OUT_ARG0(%esp) # arg0<- method->clazz 980 call dvmResolveClass # eax<- resolved ClassObject ptr 981 testl %eax,%eax # success? 982 je common_exceptionThrown # no, handle exception 983/* Now, we need to sync up with fast path. We need eax to 984 * hold the obj->clazz, and ecx to hold the resolved class 985 */ 986 movl %eax,%ecx # ecx<- resolved class 987 movl rINST,%eax # eax<- BA 988 sarl $4,%eax # eax<- B 989 GET_VREG_R %eax %eax # eax<- vB (obj) 990 movl offObject_clazz(%eax),%eax # eax<- obj->clazz 991 jmp .LOP_INSTANCE_OF_resolved 992 993/* ------------------------------ */ 994.L_OP_ARRAY_LENGTH: /* 0x21 */ 995/* File: x86/OP_ARRAY_LENGTH.S */ 996 /* 997 * Return the length of an array. 998 */ 999 mov rINST,%eax # eax<- BA 1000 sarl $4,rINST # rINST<- B 1001 GET_VREG_R %ecx rINST # ecx<- vB (object ref) 1002 andb $0xf,%al # eax<- A 1003 testl %ecx,%ecx # is null? 1004 je common_errNullObject 1005 movl offArrayObject_length(%ecx),rINST 1006 FETCH_INST_OPCODE 1 %ecx 1007 ADVANCE_PC 1 1008 SET_VREG rINST %eax 1009 GOTO_NEXT_R %ecx 1010 1011/* ------------------------------ */ 1012.L_OP_NEW_INSTANCE: /* 0x22 */ 1013/* File: x86/OP_NEW_INSTANCE.S */ 1014 /* 1015 * Create a new instance of a class. 1016 */ 1017 /* new-instance vAA, class@BBBB */ 1018 movl rSELF,%ecx 1019 movzwl 2(rPC),%eax # eax<- BBBB 1020 movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex 1021 SPILL(rIBASE) 1022 movl offDvmDex_pResClasses(%ecx),%ecx # ecx<- pDvmDex->pResClasses 1023 EXPORT_PC 1024 movl (%ecx,%eax,4),%ecx # ecx<- resolved class 1025 testl %ecx,%ecx # resolved? 1026 je .LOP_NEW_INSTANCE_resolve # no, go do it 1027.LOP_NEW_INSTANCE_resolved: # on entry, ecx<- class 1028 cmpb $CLASS_INITIALIZED,offClassObject_status(%ecx) 1029 jne .LOP_NEW_INSTANCE_needinit 1030.LOP_NEW_INSTANCE_initialized: # on entry, ecx<- class 1031 /* TODO: remove test for interface/abstract, now done in verifier */ 1032 testl $(ACC_INTERFACE|ACC_ABSTRACT),offClassObject_accessFlags(%ecx) 1033 movl $ALLOC_DONT_TRACK,OUT_ARG1(%esp) 1034 jne .LOP_NEW_INSTANCE_abstract 1035.LOP_NEW_INSTANCE_finish: # ecx=class 1036 movl %ecx,OUT_ARG0(%esp) 1037 call dvmAllocObject # eax<- new object 1038 FETCH_INST_OPCODE 2 %ecx 1039 UNSPILL(rIBASE) 1040 testl %eax,%eax # success? 1041 je common_exceptionThrown # no, bail out 1042 SET_VREG %eax rINST 1043 ADVANCE_PC 2 1044 GOTO_NEXT_R %ecx 1045 1046 /* 1047 * Class initialization required. 1048 * 1049 * ecx holds class object 1050 */ 1051.LOP_NEW_INSTANCE_needinit: 1052 SPILL_TMP1(%ecx) # save object 1053 movl %ecx,OUT_ARG0(%esp) 1054 call dvmInitClass # initialize class 1055 UNSPILL_TMP1(%ecx) # restore object 1056 testl %eax,%eax # success? 1057 jne .LOP_NEW_INSTANCE_initialized # success, continue 1058 jmp common_exceptionThrown # go deal with init exception 1059 1060 /* 1061 * Resolution required. This is the least-likely path. 1062 * 1063 */ 1064.LOP_NEW_INSTANCE_resolve: 1065 movl rSELF,%ecx 1066 movzwl 2(rPC),%eax 1067 movl offThread_method(%ecx),%ecx # ecx<- self->method 1068 movl %eax,OUT_ARG1(%esp) 1069 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 1070 movl $0,OUT_ARG2(%esp) 1071 movl %ecx,OUT_ARG0(%esp) 1072 call dvmResolveClass # call(clazz,off,flags) 1073 movl %eax,%ecx # ecx<- resolved ClassObject ptr 1074 testl %ecx,%ecx # success? 1075 jne .LOP_NEW_INSTANCE_resolved # good to go 1076 jmp common_exceptionThrown # no, handle exception 1077 1078 /* 1079 * TODO: remove this 1080 * We can't instantiate an abstract class or interface, so throw an 1081 * InstantiationError with the class descriptor as the message. 1082 * 1083 * ecx holds class object 1084 */ 1085.LOP_NEW_INSTANCE_abstract: 1086 movl offClassObject_descriptor(%ecx),%eax 1087 movl $.LstrInstantiationError,OUT_ARG0(%esp) 1088 movl %eax,OUT_ARG1(%esp) 1089 call dvmThrowExceptionWithClassMessage 1090 jmp common_exceptionThrown 1091 1092/* ------------------------------ */ 1093.L_OP_NEW_ARRAY: /* 0x23 */ 1094/* File: x86/OP_NEW_ARRAY.S */ 1095 /* 1096 * Allocate an array of objects, specified with the array class 1097 * and a count. 1098 * 1099 * The verifier guarantees that this is an array class, so we don't 1100 * check for it here. 1101 */ 1102 /* new-array vA, vB, class@CCCC */ 1103 movl rSELF,%ecx 1104 EXPORT_PC 1105 movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex 1106 movzwl 2(rPC),%eax # eax<- CCCC 1107 movl offDvmDex_pResClasses(%ecx),%ecx # ecx<- pDvmDex->pResClasses 1108 SPILL(rIBASE) 1109 movl (%ecx,%eax,4),%ecx # ecx<- resolved class 1110 movzbl rINSTbl,%eax 1111 sarl $4,%eax # eax<- B 1112 GET_VREG_R %eax %eax # eax<- vB (array length) 1113 andb $0xf,rINSTbl # rINST<- A 1114 testl %eax,%eax 1115 js common_errNegativeArraySize # bail, passing len in eax 1116 testl %ecx,%ecx # already resolved? 1117 jne .LOP_NEW_ARRAY_finish # yes, fast path 1118 /* 1119 * Resolve class. (This is an uncommon case.) 1120 * ecx holds class (null here) 1121 * eax holds array length (vB) 1122 */ 1123 movl rSELF,%ecx 1124 SPILL_TMP1(%eax) # save array length 1125 movl offThread_method(%ecx),%ecx # ecx<- self->method 1126 movzwl 2(rPC),%eax # eax<- CCCC 1127 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 1128 movl %eax,OUT_ARG1(%esp) 1129 movl $0,OUT_ARG2(%esp) 1130 movl %ecx,OUT_ARG0(%esp) 1131 call dvmResolveClass # eax<- call(clazz,ref,flag) 1132 movl %eax,%ecx 1133 UNSPILL_TMP1(%eax) 1134 testl %ecx,%ecx # successful resolution? 1135 je common_exceptionThrown # no, bail. 1136# fall through to OP_NEW_ARRAY_finish 1137 1138 /* 1139 * Finish allocation 1140 * 1141 * ecx holds class 1142 * eax holds array length (vB) 1143 */ 1144.LOP_NEW_ARRAY_finish: 1145 movl %ecx,OUT_ARG0(%esp) 1146 movl %eax,OUT_ARG1(%esp) 1147 movl $ALLOC_DONT_TRACK,OUT_ARG2(%esp) 1148 call dvmAllocArrayByClass # eax<- call(clazz,length,flags) 1149 FETCH_INST_OPCODE 2 %ecx 1150 UNSPILL(rIBASE) 1151 testl %eax,%eax # failed? 1152 je common_exceptionThrown # yup - go handle 1153 SET_VREG %eax rINST 1154 ADVANCE_PC 2 1155 GOTO_NEXT_R %ecx 1156 1157/* ------------------------------ */ 1158.L_OP_FILLED_NEW_ARRAY: /* 0x24 */ 1159/* File: x86/OP_FILLED_NEW_ARRAY.S */ 1160 /* 1161 * Create a new array with elements filled from registers. 1162 * 1163 * for: filled-new-array, filled-new-array/range 1164 */ 1165 /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ 1166 /* op {vCCCC..v(CCCC+AA-1)}, type@BBBB */ 1167 movl rSELF,%eax 1168 movl offThread_methodClassDex(%eax),%eax # eax<- pDvmDex 1169 movzwl 2(rPC),%ecx # ecx<- BBBB 1170 movl offDvmDex_pResClasses(%eax),%eax # eax<- pDvmDex->pResClasses 1171 SPILL(rIBASE) # preserve rIBASE 1172 movl (%eax,%ecx,4),%eax # eax<- resolved class 1173 EXPORT_PC 1174 testl %eax,%eax # already resolved? 1175 jne .LOP_FILLED_NEW_ARRAY_continue # yes, continue 1176 # less frequent path, so we'll redo some work 1177 movl rSELF,%eax 1178 movl $0,OUT_ARG2(%esp) # arg2<- false 1179 movl %ecx,OUT_ARG1(%esp) # arg1<- BBBB 1180 movl offThread_method(%eax),%eax # eax<- self->method 1181 movl offMethod_clazz(%eax),%eax # eax<- method->clazz 1182 movl %eax,OUT_ARG0(%esp) # arg0<- clazz 1183 call dvmResolveClass # eax<- call(clazz,ref,flag) 1184 testl %eax,%eax # null? 1185 je common_exceptionThrown # yes, handle it 1186 1187 # note: fall through to .LOP_FILLED_NEW_ARRAY_continue 1188 1189 /* 1190 * On entry: 1191 * eax holds array class [r0] 1192 * rINST holds AA or BB [r10] 1193 * ecx is scratch 1194 */ 1195.LOP_FILLED_NEW_ARRAY_continue: 1196 movl offClassObject_descriptor(%eax),%ecx # ecx<- arrayClass->descriptor 1197 movl $ALLOC_DONT_TRACK,OUT_ARG2(%esp) # arg2<- flags 1198 movzbl 1(%ecx),%ecx # ecx<- descriptor[1] 1199 movl %eax,OUT_ARG0(%esp) # arg0<- arrayClass 1200 movl rSELF,%eax 1201 cmpb $'I',%cl # supported? 1202 je 1f 1203 cmpb $'L',%cl 1204 je 1f 1205 cmpb $'[',%cl 1206 jne .LOP_FILLED_NEW_ARRAY_notimpl # no, not handled yet 12071: 1208 movl %ecx,offThread_retval+4(%eax) # save type 1209 .if (!0) 1210 SPILL_TMP1(rINST) # save copy, need "B" later 1211 sarl $4,rINST 1212 .endif 1213 movl rINST,OUT_ARG1(%esp) # arg1<- A or AA (length) 1214 call dvmAllocArrayByClass # eax<- call(arrayClass, length, flags) 1215 movl rSELF,%ecx 1216 testl %eax,%eax # alloc successful? 1217 je common_exceptionThrown # no, handle exception 1218 movl %eax,offThread_retval(%ecx) # retval.l<- new array 1219 movzwl 4(rPC),%ecx # ecx<- FEDC or CCCC 1220 leal offArrayObject_contents(%eax),%eax # eax<- newArray->contents 1221 1222/* at this point: 1223 * eax is pointer to tgt 1224 * rINST is length 1225 * ecx is FEDC or CCCC 1226 * TMP_SPILL1 is BA 1227 * We now need to copy values from registers into the array 1228 */ 1229 1230 .if 0 1231 # set up src pointer 1232 SPILL_TMP2(%esi) 1233 SPILL_TMP3(%edi) 1234 leal (rFP,%ecx,4),%esi # set up src ptr 1235 movl %eax,%edi # set up dst ptr 1236 movl rINST,%ecx # load count register 1237 rep 1238 movsd 1239 UNSPILL_TMP2(%esi) 1240 UNSPILL_TMP3(%edi) 1241 movl rSELF,%ecx 1242 movl offThread_retval+4(%ecx),%eax # eax<- type 1243 .else 1244 testl rINST,rINST 1245 je 4f 1246 UNSPILL_TMP1(rIBASE) # restore "BA" 1247 andl $0x0f,rIBASE # rIBASE<- 0000000A 1248 sall $16,rIBASE # rIBASE<- 000A0000 1249 orl %ecx,rIBASE # rIBASE<- 000AFEDC 12503: 1251 movl $0xf,%ecx 1252 andl rIBASE,%ecx # ecx<- next reg to load 1253 GET_VREG_R %ecx %ecx 1254 shrl $4,rIBASE 1255 leal 4(%eax),%eax 1256 movl %ecx,-4(%eax) 1257 sub $1,rINST 1258 jne 3b 12594: 1260 movl rSELF,%ecx 1261 movl offThread_retval+4(%ecx),%eax # eax<- type 1262 .endif 1263 1264 cmpb $'I',%al # Int array? 1265 je 5f # skip card mark if so 1266 movl offThread_retval(%ecx),%eax # eax<- object head 1267 movl offThread_cardTable(%ecx),%ecx # card table base 1268 shrl $GC_CARD_SHIFT,%eax # convert to card num 1269 movb %cl,(%ecx,%eax) # mark card based on object head 12705: 1271 UNSPILL(rIBASE) # restore rIBASE 1272 FETCH_INST_OPCODE 3 %ecx 1273 ADVANCE_PC 3 1274 GOTO_NEXT_R %ecx 1275 1276 1277 /* 1278 * Throw an exception indicating that we have not implemented this 1279 * mode of filled-new-array. 1280 */ 1281.LOP_FILLED_NEW_ARRAY_notimpl: 1282 movl $.LstrInternalErrorA,%eax 1283 movl %eax,OUT_ARG0(%esp) 1284 movl $.LstrFilledNewArrayNotImplA,%eax 1285 movl %eax,OUT_ARG1(%esp) 1286 call dvmThrowException 1287 jmp common_exceptionThrown 1288 1289/* ------------------------------ */ 1290.L_OP_FILLED_NEW_ARRAY_RANGE: /* 0x25 */ 1291/* File: x86/OP_FILLED_NEW_ARRAY_RANGE.S */ 1292/* File: x86/OP_FILLED_NEW_ARRAY.S */ 1293 /* 1294 * Create a new array with elements filled from registers. 1295 * 1296 * for: filled-new-array, filled-new-array/range 1297 */ 1298 /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ 1299 /* op {vCCCC..v(CCCC+AA-1)}, type@BBBB */ 1300 movl rSELF,%eax 1301 movl offThread_methodClassDex(%eax),%eax # eax<- pDvmDex 1302 movzwl 2(rPC),%ecx # ecx<- BBBB 1303 movl offDvmDex_pResClasses(%eax),%eax # eax<- pDvmDex->pResClasses 1304 SPILL(rIBASE) # preserve rIBASE 1305 movl (%eax,%ecx,4),%eax # eax<- resolved class 1306 EXPORT_PC 1307 testl %eax,%eax # already resolved? 1308 jne .LOP_FILLED_NEW_ARRAY_RANGE_continue # yes, continue 1309 # less frequent path, so we'll redo some work 1310 movl rSELF,%eax 1311 movl $0,OUT_ARG2(%esp) # arg2<- false 1312 movl %ecx,OUT_ARG1(%esp) # arg1<- BBBB 1313 movl offThread_method(%eax),%eax # eax<- self->method 1314 movl offMethod_clazz(%eax),%eax # eax<- method->clazz 1315 movl %eax,OUT_ARG0(%esp) # arg0<- clazz 1316 call dvmResolveClass # eax<- call(clazz,ref,flag) 1317 testl %eax,%eax # null? 1318 je common_exceptionThrown # yes, handle it 1319 1320 # note: fall through to .LOP_FILLED_NEW_ARRAY_RANGE_continue 1321 1322 /* 1323 * On entry: 1324 * eax holds array class [r0] 1325 * rINST holds AA or BB [r10] 1326 * ecx is scratch 1327 */ 1328.LOP_FILLED_NEW_ARRAY_RANGE_continue: 1329 movl offClassObject_descriptor(%eax),%ecx # ecx<- arrayClass->descriptor 1330 movl $ALLOC_DONT_TRACK,OUT_ARG2(%esp) # arg2<- flags 1331 movzbl 1(%ecx),%ecx # ecx<- descriptor[1] 1332 movl %eax,OUT_ARG0(%esp) # arg0<- arrayClass 1333 movl rSELF,%eax 1334 cmpb $'I',%cl # supported? 1335 je 1f 1336 cmpb $'L',%cl 1337 je 1f 1338 cmpb $'[',%cl 1339 jne .LOP_FILLED_NEW_ARRAY_RANGE_notimpl # no, not handled yet 13401: 1341 movl %ecx,offThread_retval+4(%eax) # save type 1342 .if (!1) 1343 SPILL_TMP1(rINST) # save copy, need "B" later 1344 sarl $4,rINST 1345 .endif 1346 movl rINST,OUT_ARG1(%esp) # arg1<- A or AA (length) 1347 call dvmAllocArrayByClass # eax<- call(arrayClass, length, flags) 1348 movl rSELF,%ecx 1349 testl %eax,%eax # alloc successful? 1350 je common_exceptionThrown # no, handle exception 1351 movl %eax,offThread_retval(%ecx) # retval.l<- new array 1352 movzwl 4(rPC),%ecx # ecx<- FEDC or CCCC 1353 leal offArrayObject_contents(%eax),%eax # eax<- newArray->contents 1354 1355/* at this point: 1356 * eax is pointer to tgt 1357 * rINST is length 1358 * ecx is FEDC or CCCC 1359 * TMP_SPILL1 is BA 1360 * We now need to copy values from registers into the array 1361 */ 1362 1363 .if 1 1364 # set up src pointer 1365 SPILL_TMP2(%esi) 1366 SPILL_TMP3(%edi) 1367 leal (rFP,%ecx,4),%esi # set up src ptr 1368 movl %eax,%edi # set up dst ptr 1369 movl rINST,%ecx # load count register 1370 rep 1371 movsd 1372 UNSPILL_TMP2(%esi) 1373 UNSPILL_TMP3(%edi) 1374 movl rSELF,%ecx 1375 movl offThread_retval+4(%ecx),%eax # eax<- type 1376 .else 1377 testl rINST,rINST 1378 je 4f 1379 UNSPILL_TMP1(rIBASE) # restore "BA" 1380 andl $0x0f,rIBASE # rIBASE<- 0000000A 1381 sall $16,rIBASE # rIBASE<- 000A0000 1382 orl %ecx,rIBASE # rIBASE<- 000AFEDC 13833: 1384 movl $0xf,%ecx 1385 andl rIBASE,%ecx # ecx<- next reg to load 1386 GET_VREG_R %ecx %ecx 1387 shrl $4,rIBASE 1388 leal 4(%eax),%eax 1389 movl %ecx,-4(%eax) 1390 sub $1,rINST 1391 jne 3b 13924: 1393 movl rSELF,%ecx 1394 movl offThread_retval+4(%ecx),%eax # eax<- type 1395 .endif 1396 1397 cmpb $'I',%al # Int array? 1398 je 5f # skip card mark if so 1399 movl offThread_retval(%ecx),%eax # eax<- object head 1400 movl offThread_cardTable(%ecx),%ecx # card table base 1401 shrl $GC_CARD_SHIFT,%eax # convert to card num 1402 movb %cl,(%ecx,%eax) # mark card based on object head 14035: 1404 UNSPILL(rIBASE) # restore rIBASE 1405 FETCH_INST_OPCODE 3 %ecx 1406 ADVANCE_PC 3 1407 GOTO_NEXT_R %ecx 1408 1409 1410 /* 1411 * Throw an exception indicating that we have not implemented this 1412 * mode of filled-new-array. 1413 */ 1414.LOP_FILLED_NEW_ARRAY_RANGE_notimpl: 1415 movl $.LstrInternalErrorA,%eax 1416 movl %eax,OUT_ARG0(%esp) 1417 movl $.LstrFilledNewArrayNotImplA,%eax 1418 movl %eax,OUT_ARG1(%esp) 1419 call dvmThrowException 1420 jmp common_exceptionThrown 1421 1422 1423/* ------------------------------ */ 1424.L_OP_FILL_ARRAY_DATA: /* 0x26 */ 1425/* File: x86/OP_FILL_ARRAY_DATA.S */ 1426 /* fill-array-data vAA, +BBBBBBBB */ 1427 movl 2(rPC),%ecx # ecx<- BBBBbbbb 1428 leal (rPC,%ecx,2),%ecx # ecx<- PC + BBBBbbbb*2 1429 GET_VREG_R %eax rINST 1430 EXPORT_PC 1431 movl %eax,OUT_ARG0(%esp) 1432 movl %ecx,OUT_ARG1(%esp) 1433 SPILL(rIBASE) 1434 call dvmInterpHandleFillArrayData 1435 UNSPILL(rIBASE) 1436 FETCH_INST_OPCODE 3 %ecx 1437 testl %eax,%eax # exception thrown? 1438 je common_exceptionThrown 1439 ADVANCE_PC 3 1440 GOTO_NEXT_R %ecx 1441 1442/* ------------------------------ */ 1443.L_OP_THROW: /* 0x27 */ 1444/* File: x86/OP_THROW.S */ 1445 /* 1446 * Throw an exception object in the current thread. 1447 */ 1448 /* throw vAA */ 1449 EXPORT_PC 1450 GET_VREG_R %eax rINST # eax<- exception object 1451 movl rSELF,%ecx # ecx<- self 1452 testl %eax,%eax # null object? 1453 je common_errNullObject 1454 movl %eax,offThread_exception(%ecx) # thread->exception<- obj 1455 jmp common_exceptionThrown 1456 1457/* ------------------------------ */ 1458.L_OP_GOTO: /* 0x28 */ 1459/* File: x86/OP_GOTO.S */ 1460 /* 1461 * Unconditional branch, 8-bit offset. 1462 * 1463 * The branch distance is a signed code-unit offset, which we need to 1464 * double to get a byte offset. 1465 */ 1466 /* goto +AA */ 1467 movsbl rINSTbl,rINST # ebx<- ssssssAA 1468 testl rINST,rINST # test for <0 1469 js common_backwardBranch 1470 movl rINST,%eax 1471 FETCH_INST_INDEXED %eax 1472 ADVANCE_PC_INDEXED %eax 1473 GOTO_NEXT 1474 1475/* ------------------------------ */ 1476.L_OP_GOTO_16: /* 0x29 */ 1477/* File: x86/OP_GOTO_16.S */ 1478 /* 1479 * Unconditional branch, 16-bit offset. 1480 * 1481 * The branch distance is a signed code-unit offset 1482 */ 1483 /* goto/16 +AAAA */ 1484 movswl 2(rPC),rINST # rINST<- ssssAAAA 1485 testl rINST,rINST # test for <0 1486 js common_backwardBranch 1487 movl rINST,%eax 1488 FETCH_INST_INDEXED %eax 1489 ADVANCE_PC_INDEXED %eax 1490 GOTO_NEXT 1491 1492/* ------------------------------ */ 1493.L_OP_GOTO_32: /* 0x2a */ 1494/* File: x86/OP_GOTO_32.S */ 1495 /* 1496 * Unconditional branch, 32-bit offset. 1497 * 1498 * The branch distance is a signed code-unit offset. 1499 * 1500 * Unlike most opcodes, this one is allowed to branch to itself, so 1501 * our "backward branch" test must be "<=0" instead of "<0". 1502 */ 1503 /* goto/32 AAAAAAAA */ 1504 movl 2(rPC),rINST # rINST<- AAAAAAAA 1505 cmpl $0,rINST # test for <= 0 1506 jle common_backwardBranch 1507 movl rINST,%eax 1508 FETCH_INST_INDEXED %eax 1509 ADVANCE_PC_INDEXED %eax 1510 GOTO_NEXT 1511 1512/* ------------------------------ */ 1513.L_OP_PACKED_SWITCH: /* 0x2b */ 1514/* File: x86/OP_PACKED_SWITCH.S */ 1515 /* 1516 * Handle a packed-switch or sparse-switch instruction. In both cases 1517 * we decode it and hand it off to a helper function. 1518 * 1519 * We don't really expect backward branches in a switch statement, but 1520 * they're perfectly legal, so we check for them here. 1521 * 1522 * for: packed-switch, sparse-switch 1523 */ 1524 /* op vAA, +BBBB */ 1525 movl 2(rPC),%ecx # ecx<- BBBBbbbb 1526 GET_VREG_R %eax rINST # eax<- vAA 1527 leal (rPC,%ecx,2),%ecx # ecx<- PC + BBBBbbbb*2 1528 movl %eax,OUT_ARG1(%esp) # ARG1<- vAA 1529 movl %ecx,OUT_ARG0(%esp) # ARG0<- switchData 1530 SPILL(rIBASE) 1531 call dvmInterpHandlePackedSwitch 1532 UNSPILL(rIBASE) 1533 testl %eax,%eax 1534 movl %eax,rINST # set up word offset 1535 jle common_backwardBranch # check on special actions 1536 ADVANCE_PC_INDEXED rINST 1537 FETCH_INST 1538 GOTO_NEXT 1539 1540/* ------------------------------ */ 1541.L_OP_SPARSE_SWITCH: /* 0x2c */ 1542/* File: x86/OP_SPARSE_SWITCH.S */ 1543/* File: x86/OP_PACKED_SWITCH.S */ 1544 /* 1545 * Handle a packed-switch or sparse-switch instruction. In both cases 1546 * we decode it and hand it off to a helper function. 1547 * 1548 * We don't really expect backward branches in a switch statement, but 1549 * they're perfectly legal, so we check for them here. 1550 * 1551 * for: packed-switch, sparse-switch 1552 */ 1553 /* op vAA, +BBBB */ 1554 movl 2(rPC),%ecx # ecx<- BBBBbbbb 1555 GET_VREG_R %eax rINST # eax<- vAA 1556 leal (rPC,%ecx,2),%ecx # ecx<- PC + BBBBbbbb*2 1557 movl %eax,OUT_ARG1(%esp) # ARG1<- vAA 1558 movl %ecx,OUT_ARG0(%esp) # ARG0<- switchData 1559 SPILL(rIBASE) 1560 call dvmInterpHandleSparseSwitch 1561 UNSPILL(rIBASE) 1562 testl %eax,%eax 1563 movl %eax,rINST # set up word offset 1564 jle common_backwardBranch # check on special actions 1565 ADVANCE_PC_INDEXED rINST 1566 FETCH_INST 1567 GOTO_NEXT 1568 1569 1570/* ------------------------------ */ 1571.L_OP_CMPL_FLOAT: /* 0x2d */ 1572/* File: x86/OP_CMPL_FLOAT.S */ 1573/* File: x86/OP_CMPG_DOUBLE.S */ 1574 /* float/double_cmp[gl] vAA, vBB, vCC */ 1575 movzbl 3(rPC),%eax # eax<- CC 1576 movzbl 2(rPC),%ecx # ecx<- BB 1577 .if 0 1578 fldl (rFP,%eax,4) 1579 fldl (rFP,%ecx,4) 1580 .else 1581 flds (rFP,%eax,4) 1582 flds (rFP,%ecx,4) 1583 .endif 1584 xorl %ecx,%ecx 1585 fucompp # z if equal, p set if NaN, c set if st0 < st1 1586 fnstsw %ax 1587 sahf 1588 FETCH_INST_OPCODE 2 %eax 1589 jp .LOP_CMPL_FLOAT_isNaN 1590 je .LOP_CMPL_FLOAT_finish 1591 sbbl %ecx,%ecx 1592 jb .LOP_CMPL_FLOAT_finish 1593 incl %ecx 1594.LOP_CMPL_FLOAT_finish: 1595 SET_VREG %ecx rINST 1596 ADVANCE_PC 2 1597 GOTO_NEXT_R %eax 1598 1599.LOP_CMPL_FLOAT_isNaN: 1600 movl $-1,%ecx 1601 jmp .LOP_CMPL_FLOAT_finish 1602 1603 1604/* ------------------------------ */ 1605.L_OP_CMPG_FLOAT: /* 0x2e */ 1606/* File: x86/OP_CMPG_FLOAT.S */ 1607/* File: x86/OP_CMPG_DOUBLE.S */ 1608 /* float/double_cmp[gl] vAA, vBB, vCC */ 1609 movzbl 3(rPC),%eax # eax<- CC 1610 movzbl 2(rPC),%ecx # ecx<- BB 1611 .if 0 1612 fldl (rFP,%eax,4) 1613 fldl (rFP,%ecx,4) 1614 .else 1615 flds (rFP,%eax,4) 1616 flds (rFP,%ecx,4) 1617 .endif 1618 xorl %ecx,%ecx 1619 fucompp # z if equal, p set if NaN, c set if st0 < st1 1620 fnstsw %ax 1621 sahf 1622 FETCH_INST_OPCODE 2 %eax 1623 jp .LOP_CMPG_FLOAT_isNaN 1624 je .LOP_CMPG_FLOAT_finish 1625 sbbl %ecx,%ecx 1626 jb .LOP_CMPG_FLOAT_finish 1627 incl %ecx 1628.LOP_CMPG_FLOAT_finish: 1629 SET_VREG %ecx rINST 1630 ADVANCE_PC 2 1631 GOTO_NEXT_R %eax 1632 1633.LOP_CMPG_FLOAT_isNaN: 1634 movl $1,%ecx 1635 jmp .LOP_CMPG_FLOAT_finish 1636 1637 1638/* ------------------------------ */ 1639.L_OP_CMPL_DOUBLE: /* 0x2f */ 1640/* File: x86/OP_CMPL_DOUBLE.S */ 1641/* File: x86/OP_CMPG_DOUBLE.S */ 1642 /* float/double_cmp[gl] vAA, vBB, vCC */ 1643 movzbl 3(rPC),%eax # eax<- CC 1644 movzbl 2(rPC),%ecx # ecx<- BB 1645 .if 1 1646 fldl (rFP,%eax,4) 1647 fldl (rFP,%ecx,4) 1648 .else 1649 flds (rFP,%eax,4) 1650 flds (rFP,%ecx,4) 1651 .endif 1652 xorl %ecx,%ecx 1653 fucompp # z if equal, p set if NaN, c set if st0 < st1 1654 fnstsw %ax 1655 sahf 1656 FETCH_INST_OPCODE 2 %eax 1657 jp .LOP_CMPL_DOUBLE_isNaN 1658 je .LOP_CMPL_DOUBLE_finish 1659 sbbl %ecx,%ecx 1660 jb .LOP_CMPL_DOUBLE_finish 1661 incl %ecx 1662.LOP_CMPL_DOUBLE_finish: 1663 SET_VREG %ecx rINST 1664 ADVANCE_PC 2 1665 GOTO_NEXT_R %eax 1666 1667.LOP_CMPL_DOUBLE_isNaN: 1668 movl $-1,%ecx 1669 jmp .LOP_CMPL_DOUBLE_finish 1670 1671 1672/* ------------------------------ */ 1673.L_OP_CMPG_DOUBLE: /* 0x30 */ 1674/* File: x86/OP_CMPG_DOUBLE.S */ 1675 /* float/double_cmp[gl] vAA, vBB, vCC */ 1676 movzbl 3(rPC),%eax # eax<- CC 1677 movzbl 2(rPC),%ecx # ecx<- BB 1678 .if 1 1679 fldl (rFP,%eax,4) 1680 fldl (rFP,%ecx,4) 1681 .else 1682 flds (rFP,%eax,4) 1683 flds (rFP,%ecx,4) 1684 .endif 1685 xorl %ecx,%ecx 1686 fucompp # z if equal, p set if NaN, c set if st0 < st1 1687 fnstsw %ax 1688 sahf 1689 FETCH_INST_OPCODE 2 %eax 1690 jp .LOP_CMPG_DOUBLE_isNaN 1691 je .LOP_CMPG_DOUBLE_finish 1692 sbbl %ecx,%ecx 1693 jb .LOP_CMPG_DOUBLE_finish 1694 incl %ecx 1695.LOP_CMPG_DOUBLE_finish: 1696 SET_VREG %ecx rINST 1697 ADVANCE_PC 2 1698 GOTO_NEXT_R %eax 1699 1700.LOP_CMPG_DOUBLE_isNaN: 1701 movl $1,%ecx 1702 jmp .LOP_CMPG_DOUBLE_finish 1703 1704/* ------------------------------ */ 1705.L_OP_CMP_LONG: /* 0x31 */ 1706/* File: x86/OP_CMP_LONG.S */ 1707 /* 1708 * Compare two 64-bit values. Puts 0, 1, or -1 into the destination 1709 * register based on the results of the comparison. 1710 */ 1711 // TUNING: rework to avoid rIBASE spill 1712 /* cmp-long vAA, vBB, vCC */ 1713 movzbl 2(rPC),%ecx # ecx<- BB 1714 SPILL(rIBASE) 1715 movzbl 3(rPC),rIBASE # rIBASE- CC 1716 GET_VREG_WORD %eax %ecx,1 # eax<- v[BB+1] 1717 GET_VREG_WORD %ecx %ecx 0 # ecx<- v[BB+0] 1718 cmpl 4(rFP,rIBASE,4),%eax 1719 jl .LOP_CMP_LONG_smaller 1720 jg .LOP_CMP_LONG_bigger 1721 sub (rFP,rIBASE,4),%ecx 1722 ja .LOP_CMP_LONG_bigger 1723 jb .LOP_CMP_LONG_smaller 1724 SET_VREG %ecx rINST 1725 FETCH_INST_OPCODE 2 %ecx 1726 UNSPILL(rIBASE) 1727 ADVANCE_PC 2 1728 GOTO_NEXT_R %ecx 1729 1730.LOP_CMP_LONG_bigger: 1731 movl $1,%ecx 1732 SET_VREG %ecx rINST 1733 FETCH_INST_OPCODE 2 %ecx 1734 UNSPILL(rIBASE) 1735 ADVANCE_PC 2 1736 GOTO_NEXT_R %ecx 1737 1738.LOP_CMP_LONG_smaller: 1739 movl $-1,%ecx 1740 SET_VREG %ecx rINST 1741 FETCH_INST_OPCODE 2 %ecx 1742 UNSPILL(rIBASE) 1743 ADVANCE_PC 2 1744 GOTO_NEXT_R %ecx 1745 1746/* ------------------------------ */ 1747.L_OP_IF_EQ: /* 0x32 */ 1748/* File: x86/OP_IF_EQ.S */ 1749/* File: x86/bincmp.S */ 1750 /* 1751 * Generic two-operand compare-and-branch operation. Provide a "revcmp" 1752 * fragment that specifies the *reverse* comparison to perform, e.g. 1753 * for "if-le" you would use "gt". 1754 * 1755 * For: if-eq, if-ne, if-lt, if-ge, if-gt, if-le 1756 */ 1757 /* if-cmp vA, vB, +CCCC */ 1758 movzx rINSTbl,%ecx # ecx <- A+ 1759 andb $0xf,%cl # ecx <- A 1760 GET_VREG_R %eax %ecx # eax <- vA 1761 sarl $4,rINST # rINST<- B 1762 cmpl (rFP,rINST,4),%eax # compare (vA, vB) 1763 movswl 2(rPC),rINST # Get signed branch offset 1764 movl $2,%eax # assume not taken 1765 jne 1f 1766 testl rINST,rINST 1767 js common_backwardBranch 1768 movl rINST,%eax 17691: 1770 FETCH_INST_INDEXED %eax 1771 ADVANCE_PC_INDEXED %eax 1772 GOTO_NEXT 1773 1774 1775/* ------------------------------ */ 1776.L_OP_IF_NE: /* 0x33 */ 1777/* File: x86/OP_IF_NE.S */ 1778/* File: x86/bincmp.S */ 1779 /* 1780 * Generic two-operand compare-and-branch operation. Provide a "revcmp" 1781 * fragment that specifies the *reverse* comparison to perform, e.g. 1782 * for "if-le" you would use "gt". 1783 * 1784 * For: if-eq, if-ne, if-lt, if-ge, if-gt, if-le 1785 */ 1786 /* if-cmp vA, vB, +CCCC */ 1787 movzx rINSTbl,%ecx # ecx <- A+ 1788 andb $0xf,%cl # ecx <- A 1789 GET_VREG_R %eax %ecx # eax <- vA 1790 sarl $4,rINST # rINST<- B 1791 cmpl (rFP,rINST,4),%eax # compare (vA, vB) 1792 movswl 2(rPC),rINST # Get signed branch offset 1793 movl $2,%eax # assume not taken 1794 je 1f 1795 testl rINST,rINST 1796 js common_backwardBranch 1797 movl rINST,%eax 17981: 1799 FETCH_INST_INDEXED %eax 1800 ADVANCE_PC_INDEXED %eax 1801 GOTO_NEXT 1802 1803 1804/* ------------------------------ */ 1805.L_OP_IF_LT: /* 0x34 */ 1806/* File: x86/OP_IF_LT.S */ 1807/* File: x86/bincmp.S */ 1808 /* 1809 * Generic two-operand compare-and-branch operation. Provide a "revcmp" 1810 * fragment that specifies the *reverse* comparison to perform, e.g. 1811 * for "if-le" you would use "gt". 1812 * 1813 * For: if-eq, if-ne, if-lt, if-ge, if-gt, if-le 1814 */ 1815 /* if-cmp vA, vB, +CCCC */ 1816 movzx rINSTbl,%ecx # ecx <- A+ 1817 andb $0xf,%cl # ecx <- A 1818 GET_VREG_R %eax %ecx # eax <- vA 1819 sarl $4,rINST # rINST<- B 1820 cmpl (rFP,rINST,4),%eax # compare (vA, vB) 1821 movswl 2(rPC),rINST # Get signed branch offset 1822 movl $2,%eax # assume not taken 1823 jge 1f 1824 testl rINST,rINST 1825 js common_backwardBranch 1826 movl rINST,%eax 18271: 1828 FETCH_INST_INDEXED %eax 1829 ADVANCE_PC_INDEXED %eax 1830 GOTO_NEXT 1831 1832 1833/* ------------------------------ */ 1834.L_OP_IF_GE: /* 0x35 */ 1835/* File: x86/OP_IF_GE.S */ 1836/* File: x86/bincmp.S */ 1837 /* 1838 * Generic two-operand compare-and-branch operation. Provide a "revcmp" 1839 * fragment that specifies the *reverse* comparison to perform, e.g. 1840 * for "if-le" you would use "gt". 1841 * 1842 * For: if-eq, if-ne, if-lt, if-ge, if-gt, if-le 1843 */ 1844 /* if-cmp vA, vB, +CCCC */ 1845 movzx rINSTbl,%ecx # ecx <- A+ 1846 andb $0xf,%cl # ecx <- A 1847 GET_VREG_R %eax %ecx # eax <- vA 1848 sarl $4,rINST # rINST<- B 1849 cmpl (rFP,rINST,4),%eax # compare (vA, vB) 1850 movswl 2(rPC),rINST # Get signed branch offset 1851 movl $2,%eax # assume not taken 1852 jl 1f 1853 testl rINST,rINST 1854 js common_backwardBranch 1855 movl rINST,%eax 18561: 1857 FETCH_INST_INDEXED %eax 1858 ADVANCE_PC_INDEXED %eax 1859 GOTO_NEXT 1860 1861 1862/* ------------------------------ */ 1863.L_OP_IF_GT: /* 0x36 */ 1864/* File: x86/OP_IF_GT.S */ 1865/* File: x86/bincmp.S */ 1866 /* 1867 * Generic two-operand compare-and-branch operation. Provide a "revcmp" 1868 * fragment that specifies the *reverse* comparison to perform, e.g. 1869 * for "if-le" you would use "gt". 1870 * 1871 * For: if-eq, if-ne, if-lt, if-ge, if-gt, if-le 1872 */ 1873 /* if-cmp vA, vB, +CCCC */ 1874 movzx rINSTbl,%ecx # ecx <- A+ 1875 andb $0xf,%cl # ecx <- A 1876 GET_VREG_R %eax %ecx # eax <- vA 1877 sarl $4,rINST # rINST<- B 1878 cmpl (rFP,rINST,4),%eax # compare (vA, vB) 1879 movswl 2(rPC),rINST # Get signed branch offset 1880 movl $2,%eax # assume not taken 1881 jle 1f 1882 testl rINST,rINST 1883 js common_backwardBranch 1884 movl rINST,%eax 18851: 1886 FETCH_INST_INDEXED %eax 1887 ADVANCE_PC_INDEXED %eax 1888 GOTO_NEXT 1889 1890 1891/* ------------------------------ */ 1892.L_OP_IF_LE: /* 0x37 */ 1893/* File: x86/OP_IF_LE.S */ 1894/* File: x86/bincmp.S */ 1895 /* 1896 * Generic two-operand compare-and-branch operation. Provide a "revcmp" 1897 * fragment that specifies the *reverse* comparison to perform, e.g. 1898 * for "if-le" you would use "gt". 1899 * 1900 * For: if-eq, if-ne, if-lt, if-ge, if-gt, if-le 1901 */ 1902 /* if-cmp vA, vB, +CCCC */ 1903 movzx rINSTbl,%ecx # ecx <- A+ 1904 andb $0xf,%cl # ecx <- A 1905 GET_VREG_R %eax %ecx # eax <- vA 1906 sarl $4,rINST # rINST<- B 1907 cmpl (rFP,rINST,4),%eax # compare (vA, vB) 1908 movswl 2(rPC),rINST # Get signed branch offset 1909 movl $2,%eax # assume not taken 1910 jg 1f 1911 testl rINST,rINST 1912 js common_backwardBranch 1913 movl rINST,%eax 19141: 1915 FETCH_INST_INDEXED %eax 1916 ADVANCE_PC_INDEXED %eax 1917 GOTO_NEXT 1918 1919 1920/* ------------------------------ */ 1921.L_OP_IF_EQZ: /* 0x38 */ 1922/* File: x86/OP_IF_EQZ.S */ 1923/* File: x86/zcmp.S */ 1924 /* 1925 * Generic one-operand compare-and-branch operation. Provide a "revcmp" 1926 * fragment that specifies the *reverse* comparison to perform, e.g. 1927 * for "if-le" you would use "gt". 1928 * 1929 * for: if-eqz, if-nez, if-ltz, if-gez, if-gtz, if-lez 1930 */ 1931 /* if-cmp vAA, +BBBB */ 1932 cmpl $0,(rFP,rINST,4) # compare (vA, 0) 1933 movswl 2(rPC),rINST # fetch signed displacement 1934 movl $2,%eax # assume branch not taken 1935 jne 1f 1936 testl rINST,rINST 1937 js common_backwardBranch 1938 movl rINST,%eax 19391: 1940 FETCH_INST_INDEXED %eax 1941 ADVANCE_PC_INDEXED %eax 1942 GOTO_NEXT 1943 1944 1945/* ------------------------------ */ 1946.L_OP_IF_NEZ: /* 0x39 */ 1947/* File: x86/OP_IF_NEZ.S */ 1948/* File: x86/zcmp.S */ 1949 /* 1950 * Generic one-operand compare-and-branch operation. Provide a "revcmp" 1951 * fragment that specifies the *reverse* comparison to perform, e.g. 1952 * for "if-le" you would use "gt". 1953 * 1954 * for: if-eqz, if-nez, if-ltz, if-gez, if-gtz, if-lez 1955 */ 1956 /* if-cmp vAA, +BBBB */ 1957 cmpl $0,(rFP,rINST,4) # compare (vA, 0) 1958 movswl 2(rPC),rINST # fetch signed displacement 1959 movl $2,%eax # assume branch not taken 1960 je 1f 1961 testl rINST,rINST 1962 js common_backwardBranch 1963 movl rINST,%eax 19641: 1965 FETCH_INST_INDEXED %eax 1966 ADVANCE_PC_INDEXED %eax 1967 GOTO_NEXT 1968 1969 1970/* ------------------------------ */ 1971.L_OP_IF_LTZ: /* 0x3a */ 1972/* File: x86/OP_IF_LTZ.S */ 1973/* File: x86/zcmp.S */ 1974 /* 1975 * Generic one-operand compare-and-branch operation. Provide a "revcmp" 1976 * fragment that specifies the *reverse* comparison to perform, e.g. 1977 * for "if-le" you would use "gt". 1978 * 1979 * for: if-eqz, if-nez, if-ltz, if-gez, if-gtz, if-lez 1980 */ 1981 /* if-cmp vAA, +BBBB */ 1982 cmpl $0,(rFP,rINST,4) # compare (vA, 0) 1983 movswl 2(rPC),rINST # fetch signed displacement 1984 movl $2,%eax # assume branch not taken 1985 jge 1f 1986 testl rINST,rINST 1987 js common_backwardBranch 1988 movl rINST,%eax 19891: 1990 FETCH_INST_INDEXED %eax 1991 ADVANCE_PC_INDEXED %eax 1992 GOTO_NEXT 1993 1994 1995/* ------------------------------ */ 1996.L_OP_IF_GEZ: /* 0x3b */ 1997/* File: x86/OP_IF_GEZ.S */ 1998/* File: x86/zcmp.S */ 1999 /* 2000 * Generic one-operand compare-and-branch operation. Provide a "revcmp" 2001 * fragment that specifies the *reverse* comparison to perform, e.g. 2002 * for "if-le" you would use "gt". 2003 * 2004 * for: if-eqz, if-nez, if-ltz, if-gez, if-gtz, if-lez 2005 */ 2006 /* if-cmp vAA, +BBBB */ 2007 cmpl $0,(rFP,rINST,4) # compare (vA, 0) 2008 movswl 2(rPC),rINST # fetch signed displacement 2009 movl $2,%eax # assume branch not taken 2010 jl 1f 2011 testl rINST,rINST 2012 js common_backwardBranch 2013 movl rINST,%eax 20141: 2015 FETCH_INST_INDEXED %eax 2016 ADVANCE_PC_INDEXED %eax 2017 GOTO_NEXT 2018 2019 2020/* ------------------------------ */ 2021.L_OP_IF_GTZ: /* 0x3c */ 2022/* File: x86/OP_IF_GTZ.S */ 2023/* File: x86/zcmp.S */ 2024 /* 2025 * Generic one-operand compare-and-branch operation. Provide a "revcmp" 2026 * fragment that specifies the *reverse* comparison to perform, e.g. 2027 * for "if-le" you would use "gt". 2028 * 2029 * for: if-eqz, if-nez, if-ltz, if-gez, if-gtz, if-lez 2030 */ 2031 /* if-cmp vAA, +BBBB */ 2032 cmpl $0,(rFP,rINST,4) # compare (vA, 0) 2033 movswl 2(rPC),rINST # fetch signed displacement 2034 movl $2,%eax # assume branch not taken 2035 jle 1f 2036 testl rINST,rINST 2037 js common_backwardBranch 2038 movl rINST,%eax 20391: 2040 FETCH_INST_INDEXED %eax 2041 ADVANCE_PC_INDEXED %eax 2042 GOTO_NEXT 2043 2044 2045/* ------------------------------ */ 2046.L_OP_IF_LEZ: /* 0x3d */ 2047/* File: x86/OP_IF_LEZ.S */ 2048/* File: x86/zcmp.S */ 2049 /* 2050 * Generic one-operand compare-and-branch operation. Provide a "revcmp" 2051 * fragment that specifies the *reverse* comparison to perform, e.g. 2052 * for "if-le" you would use "gt". 2053 * 2054 * for: if-eqz, if-nez, if-ltz, if-gez, if-gtz, if-lez 2055 */ 2056 /* if-cmp vAA, +BBBB */ 2057 cmpl $0,(rFP,rINST,4) # compare (vA, 0) 2058 movswl 2(rPC),rINST # fetch signed displacement 2059 movl $2,%eax # assume branch not taken 2060 jg 1f 2061 testl rINST,rINST 2062 js common_backwardBranch 2063 movl rINST,%eax 20641: 2065 FETCH_INST_INDEXED %eax 2066 ADVANCE_PC_INDEXED %eax 2067 GOTO_NEXT 2068 2069 2070/* ------------------------------ */ 2071.L_OP_UNUSED_3E: /* 0x3e */ 2072/* File: x86/OP_UNUSED_3E.S */ 2073/* File: x86/unused.S */ 2074 jmp common_abort 2075 2076 2077/* ------------------------------ */ 2078.L_OP_UNUSED_3F: /* 0x3f */ 2079/* File: x86/OP_UNUSED_3F.S */ 2080/* File: x86/unused.S */ 2081 jmp common_abort 2082 2083 2084/* ------------------------------ */ 2085.L_OP_UNUSED_40: /* 0x40 */ 2086/* File: x86/OP_UNUSED_40.S */ 2087/* File: x86/unused.S */ 2088 jmp common_abort 2089 2090 2091/* ------------------------------ */ 2092.L_OP_UNUSED_41: /* 0x41 */ 2093/* File: x86/OP_UNUSED_41.S */ 2094/* File: x86/unused.S */ 2095 jmp common_abort 2096 2097 2098/* ------------------------------ */ 2099.L_OP_UNUSED_42: /* 0x42 */ 2100/* File: x86/OP_UNUSED_42.S */ 2101/* File: x86/unused.S */ 2102 jmp common_abort 2103 2104 2105/* ------------------------------ */ 2106.L_OP_UNUSED_43: /* 0x43 */ 2107/* File: x86/OP_UNUSED_43.S */ 2108/* File: x86/unused.S */ 2109 jmp common_abort 2110 2111 2112/* ------------------------------ */ 2113.L_OP_AGET: /* 0x44 */ 2114/* File: x86/OP_AGET.S */ 2115 /* 2116 * Array get, 32 bits or less. vAA <- vBB[vCC]. 2117 * 2118 * for: aget, aget-object, aget-boolean, aget-byte, aget-char, aget-short 2119 */ 2120 /* op vAA, vBB, vCC */ 2121 movzbl 2(rPC),%eax # eax<- BB 2122 movzbl 3(rPC),%ecx # ecx<- CC 2123 GET_VREG_R %eax %eax # eax<- vBB (array object) 2124 GET_VREG_R %ecx %ecx # ecs<- vCC (requested index) 2125 testl %eax,%eax # null array object? 2126 je common_errNullObject # bail if so 2127 cmpl offArrayObject_length(%eax),%ecx 2128 jae common_errArrayIndex # index >= length, bail. Expects 2129 # arrayObj in eax 2130 # index in ecx 2131 movl offArrayObject_contents(%eax,%ecx,4),%eax 2132.LOP_AGET_finish: 2133 FETCH_INST_OPCODE 2 %ecx 2134 SET_VREG %eax rINST 2135 ADVANCE_PC 2 2136 GOTO_NEXT_R %ecx 2137 2138/* ------------------------------ */ 2139.L_OP_AGET_WIDE: /* 0x45 */ 2140/* File: x86/OP_AGET_WIDE.S */ 2141 /* 2142 * Array get, 64 bits. vAA <- vBB[vCC]. 2143 * 2144 */ 2145 /* op vAA, vBB, vCC */ 2146 movzbl 2(rPC),%eax # eax<- BB 2147 movzbl 3(rPC),%ecx # ecx<- CC 2148 GET_VREG_R %eax %eax # eax<- vBB (array object) 2149 GET_VREG_R %ecx %ecx # ecs<- vCC (requested index) 2150 testl %eax,%eax # null array object? 2151 je common_errNullObject # bail if so 2152 cmpl offArrayObject_length(%eax),%ecx 2153 jae common_errArrayIndex # index >= length, bail. Expects 2154 # arrayObj in eax 2155 # index in ecx 2156 leal offArrayObject_contents(%eax,%ecx,8),%eax 2157 movl (%eax),%ecx 2158 movl 4(%eax),%eax 2159 SET_VREG_WORD %ecx rINST 0 2160 SET_VREG_WORD %eax rINST 1 2161 FETCH_INST_OPCODE 2 %ecx 2162 ADVANCE_PC 2 2163 GOTO_NEXT_R %ecx 2164 2165/* ------------------------------ */ 2166.L_OP_AGET_OBJECT: /* 0x46 */ 2167/* File: x86/OP_AGET_OBJECT.S */ 2168/* File: x86/OP_AGET.S */ 2169 /* 2170 * Array get, 32 bits or less. vAA <- vBB[vCC]. 2171 * 2172 * for: aget, aget-object, aget-boolean, aget-byte, aget-char, aget-short 2173 */ 2174 /* op vAA, vBB, vCC */ 2175 movzbl 2(rPC),%eax # eax<- BB 2176 movzbl 3(rPC),%ecx # ecx<- CC 2177 GET_VREG_R %eax %eax # eax<- vBB (array object) 2178 GET_VREG_R %ecx %ecx # ecs<- vCC (requested index) 2179 testl %eax,%eax # null array object? 2180 je common_errNullObject # bail if so 2181 cmpl offArrayObject_length(%eax),%ecx 2182 jae common_errArrayIndex # index >= length, bail. Expects 2183 # arrayObj in eax 2184 # index in ecx 2185 movl offArrayObject_contents(%eax,%ecx,4),%eax 2186.LOP_AGET_OBJECT_finish: 2187 FETCH_INST_OPCODE 2 %ecx 2188 SET_VREG %eax rINST 2189 ADVANCE_PC 2 2190 GOTO_NEXT_R %ecx 2191 2192 2193/* ------------------------------ */ 2194.L_OP_AGET_BOOLEAN: /* 0x47 */ 2195/* File: x86/OP_AGET_BOOLEAN.S */ 2196/* File: x86/OP_AGET.S */ 2197 /* 2198 * Array get, 32 bits or less. vAA <- vBB[vCC]. 2199 * 2200 * for: aget, aget-object, aget-boolean, aget-byte, aget-char, aget-short 2201 */ 2202 /* op vAA, vBB, vCC */ 2203 movzbl 2(rPC),%eax # eax<- BB 2204 movzbl 3(rPC),%ecx # ecx<- CC 2205 GET_VREG_R %eax %eax # eax<- vBB (array object) 2206 GET_VREG_R %ecx %ecx # ecs<- vCC (requested index) 2207 testl %eax,%eax # null array object? 2208 je common_errNullObject # bail if so 2209 cmpl offArrayObject_length(%eax),%ecx 2210 jae common_errArrayIndex # index >= length, bail. Expects 2211 # arrayObj in eax 2212 # index in ecx 2213 movzbl offArrayObject_contents(%eax,%ecx,1),%eax 2214.LOP_AGET_BOOLEAN_finish: 2215 FETCH_INST_OPCODE 2 %ecx 2216 SET_VREG %eax rINST 2217 ADVANCE_PC 2 2218 GOTO_NEXT_R %ecx 2219 2220 2221/* ------------------------------ */ 2222.L_OP_AGET_BYTE: /* 0x48 */ 2223/* File: x86/OP_AGET_BYTE.S */ 2224/* File: x86/OP_AGET.S */ 2225 /* 2226 * Array get, 32 bits or less. vAA <- vBB[vCC]. 2227 * 2228 * for: aget, aget-object, aget-boolean, aget-byte, aget-char, aget-short 2229 */ 2230 /* op vAA, vBB, vCC */ 2231 movzbl 2(rPC),%eax # eax<- BB 2232 movzbl 3(rPC),%ecx # ecx<- CC 2233 GET_VREG_R %eax %eax # eax<- vBB (array object) 2234 GET_VREG_R %ecx %ecx # ecs<- vCC (requested index) 2235 testl %eax,%eax # null array object? 2236 je common_errNullObject # bail if so 2237 cmpl offArrayObject_length(%eax),%ecx 2238 jae common_errArrayIndex # index >= length, bail. Expects 2239 # arrayObj in eax 2240 # index in ecx 2241 movsbl offArrayObject_contents(%eax,%ecx,1),%eax 2242.LOP_AGET_BYTE_finish: 2243 FETCH_INST_OPCODE 2 %ecx 2244 SET_VREG %eax rINST 2245 ADVANCE_PC 2 2246 GOTO_NEXT_R %ecx 2247 2248 2249/* ------------------------------ */ 2250.L_OP_AGET_CHAR: /* 0x49 */ 2251/* File: x86/OP_AGET_CHAR.S */ 2252/* File: x86/OP_AGET.S */ 2253 /* 2254 * Array get, 32 bits or less. vAA <- vBB[vCC]. 2255 * 2256 * for: aget, aget-object, aget-boolean, aget-byte, aget-char, aget-short 2257 */ 2258 /* op vAA, vBB, vCC */ 2259 movzbl 2(rPC),%eax # eax<- BB 2260 movzbl 3(rPC),%ecx # ecx<- CC 2261 GET_VREG_R %eax %eax # eax<- vBB (array object) 2262 GET_VREG_R %ecx %ecx # ecs<- vCC (requested index) 2263 testl %eax,%eax # null array object? 2264 je common_errNullObject # bail if so 2265 cmpl offArrayObject_length(%eax),%ecx 2266 jae common_errArrayIndex # index >= length, bail. Expects 2267 # arrayObj in eax 2268 # index in ecx 2269 movzwl offArrayObject_contents(%eax,%ecx,2),%eax 2270.LOP_AGET_CHAR_finish: 2271 FETCH_INST_OPCODE 2 %ecx 2272 SET_VREG %eax rINST 2273 ADVANCE_PC 2 2274 GOTO_NEXT_R %ecx 2275 2276 2277/* ------------------------------ */ 2278.L_OP_AGET_SHORT: /* 0x4a */ 2279/* File: x86/OP_AGET_SHORT.S */ 2280/* File: x86/OP_AGET.S */ 2281 /* 2282 * Array get, 32 bits or less. vAA <- vBB[vCC]. 2283 * 2284 * for: aget, aget-object, aget-boolean, aget-byte, aget-char, aget-short 2285 */ 2286 /* op vAA, vBB, vCC */ 2287 movzbl 2(rPC),%eax # eax<- BB 2288 movzbl 3(rPC),%ecx # ecx<- CC 2289 GET_VREG_R %eax %eax # eax<- vBB (array object) 2290 GET_VREG_R %ecx %ecx # ecs<- vCC (requested index) 2291 testl %eax,%eax # null array object? 2292 je common_errNullObject # bail if so 2293 cmpl offArrayObject_length(%eax),%ecx 2294 jae common_errArrayIndex # index >= length, bail. Expects 2295 # arrayObj in eax 2296 # index in ecx 2297 movswl offArrayObject_contents(%eax,%ecx,2),%eax 2298.LOP_AGET_SHORT_finish: 2299 FETCH_INST_OPCODE 2 %ecx 2300 SET_VREG %eax rINST 2301 ADVANCE_PC 2 2302 GOTO_NEXT_R %ecx 2303 2304 2305/* ------------------------------ */ 2306.L_OP_APUT: /* 0x4b */ 2307/* File: x86/OP_APUT.S */ 2308 /* 2309 * Array put, 32 bits or less. vBB[vCC] <- vAA 2310 * 2311 * for: aput, aput-object, aput-boolean, aput-byte, aput-char, aput-short 2312 */ 2313 /* op vAA, vBB, vCC */ 2314 movzbl 2(rPC),%eax # eax<- BB 2315 movzbl 3(rPC),%ecx # ecx<- CC 2316 GET_VREG_R %eax %eax # eax<- vBB (array object) 2317 GET_VREG_R %ecx %ecx # ecs<- vCC (requested index) 2318 testl %eax,%eax # null array object? 2319 je common_errNullObject # bail if so 2320 cmpl offArrayObject_length(%eax),%ecx 2321 jae common_errArrayIndex # index >= length, bail. Expects: 2322 # arrayObj in eax 2323 # index in ecx 2324 leal offArrayObject_contents(%eax,%ecx,4),%eax 2325.LOP_APUT_finish: 2326 GET_VREG_R rINST rINST 2327 FETCH_INST_OPCODE 2 %ecx 2328 movl rINST,(%eax) 2329 ADVANCE_PC 2 2330 GOTO_NEXT_R %ecx 2331 2332/* ------------------------------ */ 2333.L_OP_APUT_WIDE: /* 0x4c */ 2334/* File: x86/OP_APUT_WIDE.S */ 2335 /* 2336 * Array put, 64 bits. vBB[vCC]<-vAA. 2337 * 2338 */ 2339 /* op vAA, vBB, vCC */ 2340 movzbl 2(rPC),%eax # eax<- BB 2341 movzbl 3(rPC),%ecx # ecx<- CC 2342 GET_VREG_R %eax %eax # eax<- vBB (array object) 2343 GET_VREG_R %ecx %ecx # ecs<- vCC (requested index) 2344 testl %eax,%eax # null array object? 2345 je common_errNullObject # bail if so 2346 cmpl offArrayObject_length(%eax),%ecx 2347 jae common_errArrayIndex # index >= length, bail. Expects: 2348 # arrayObj in eax 2349 # index in ecx 2350 leal offArrayObject_contents(%eax,%ecx,8),%eax 2351 GET_VREG_WORD %ecx rINST 0 2352 GET_VREG_WORD rINST rINST 1 2353 movl %ecx,(%eax) 2354 FETCH_INST_OPCODE 2 %ecx 2355 movl rINST,4(%eax) 2356 ADVANCE_PC 2 2357 GOTO_NEXT_R %ecx 2358 2359/* ------------------------------ */ 2360.L_OP_APUT_OBJECT: /* 0x4d */ 2361/* File: x86/OP_APUT_OBJECT.S */ 2362 /* 2363 * Array put, 32 bits or less. vBB[vCC] <- vAA 2364 * 2365 * for: aput, aput-object, aput-boolean, aput-byte, aput-char, aput-short 2366 */ 2367 /* op vAA, vBB, vCC */ 2368 movzbl 2(rPC),%eax # eax<- BB 2369 movzbl 3(rPC),%ecx # ecx<- CC 2370 GET_VREG_R %eax %eax # eax<- vBB (array object) 2371 GET_VREG_R %ecx %ecx # ecs<- vCC (requested index) 2372 GET_VREG_R rINST rINST # rINST<- vAA 2373 testl %eax,%eax # null array object? 2374 je common_errNullObject # bail if so 2375 cmpl offArrayObject_length(%eax),%ecx 2376 jae common_errArrayIndex # index >= length, bail. Expects 2377 # arrayObj in eax 2378 # index in ecx 2379 /* On entry: 2380 * eax<- array object 2381 * ecx<- index 2382 * rINST<- vAA 2383 */ 2384 leal offArrayObject_contents(%eax,%ecx,4),%ecx 2385 testl rINST,rINST # storing null reference? 2386 je .LOP_APUT_OBJECT_skip_check 2387 SPILL_TMP1(%ecx) # save target address 2388 SPILL_TMP2(%eax) # save object head 2389 movl offObject_clazz(%eax),%eax # eax<- arrayObj->clazz 2390 movl offObject_clazz(rINST),%ecx # ecx<- obj->clazz 2391 movl %eax,OUT_ARG1(%esp) 2392 movl %ecx,OUT_ARG0(%esp) 2393 movl %ecx,sReg0 # store the two classes for later 2394 movl %eax,sReg1 2395 SPILL(rIBASE) 2396 call dvmCanPutArrayElement # test object type vs. array type 2397 UNSPILL(rIBASE) 2398 UNSPILL_TMP1(%ecx) # recover target address 2399 testl %eax,%eax 2400 movl rSELF,%eax 2401 jne .LOP_APUT_OBJECT_types_okay 2402 2403 # The types don't match. We need to throw an ArrayStoreException. 2404 EXPORT_PC 2405 movl sReg0,%eax # restore the two classes... 2406 movl %eax,OUT_ARG0(%esp) 2407 movl sReg1,%ecx 2408 movl %ecx,OUT_ARG1(%esp) 2409 call dvmThrowArrayStoreException # ...and throw 2410 jmp common_exceptionThrown 2411 2412.LOP_APUT_OBJECT_types_okay: 2413 movl offThread_cardTable(%eax),%eax # get card table base 2414 movl rINST,(%ecx) # store into array 2415 UNSPILL_TMP2(rINST) # recover object head 2416 FETCH_INST_OPCODE 2 %ecx 2417 shrl $GC_CARD_SHIFT,rINST # object head to card number 2418 movb %al,(%eax,rINST) # mark card using object head 2419 ADVANCE_PC 2 2420 GOTO_NEXT_R %ecx 2421 2422.LOP_APUT_OBJECT_skip_check: 2423 movl rINST,(%ecx) 2424 FETCH_INST_OPCODE 2 %ecx 2425 ADVANCE_PC 2 2426 GOTO_NEXT_R %ecx 2427 2428/* ------------------------------ */ 2429.L_OP_APUT_BOOLEAN: /* 0x4e */ 2430/* File: x86/OP_APUT_BOOLEAN.S */ 2431/* File: x86/OP_APUT.S */ 2432 /* 2433 * Array put, 32 bits or less. vBB[vCC] <- vAA 2434 * 2435 * for: aput, aput-object, aput-boolean, aput-byte, aput-char, aput-short 2436 */ 2437 /* op vAA, vBB, vCC */ 2438 movzbl 2(rPC),%eax # eax<- BB 2439 movzbl 3(rPC),%ecx # ecx<- CC 2440 GET_VREG_R %eax %eax # eax<- vBB (array object) 2441 GET_VREG_R %ecx %ecx # ecs<- vCC (requested index) 2442 testl %eax,%eax # null array object? 2443 je common_errNullObject # bail if so 2444 cmpl offArrayObject_length(%eax),%ecx 2445 jae common_errArrayIndex # index >= length, bail. Expects: 2446 # arrayObj in eax 2447 # index in ecx 2448 leal offArrayObject_contents(%eax,%ecx,1),%eax 2449.LOP_APUT_BOOLEAN_finish: 2450 GET_VREG_R rINST rINST 2451 FETCH_INST_OPCODE 2 %ecx 2452 movb rINSTbl,(%eax) 2453 ADVANCE_PC 2 2454 GOTO_NEXT_R %ecx 2455 2456 2457/* ------------------------------ */ 2458.L_OP_APUT_BYTE: /* 0x4f */ 2459/* File: x86/OP_APUT_BYTE.S */ 2460/* File: x86/OP_APUT.S */ 2461 /* 2462 * Array put, 32 bits or less. vBB[vCC] <- vAA 2463 * 2464 * for: aput, aput-object, aput-boolean, aput-byte, aput-char, aput-short 2465 */ 2466 /* op vAA, vBB, vCC */ 2467 movzbl 2(rPC),%eax # eax<- BB 2468 movzbl 3(rPC),%ecx # ecx<- CC 2469 GET_VREG_R %eax %eax # eax<- vBB (array object) 2470 GET_VREG_R %ecx %ecx # ecs<- vCC (requested index) 2471 testl %eax,%eax # null array object? 2472 je common_errNullObject # bail if so 2473 cmpl offArrayObject_length(%eax),%ecx 2474 jae common_errArrayIndex # index >= length, bail. Expects: 2475 # arrayObj in eax 2476 # index in ecx 2477 leal offArrayObject_contents(%eax,%ecx,1),%eax 2478.LOP_APUT_BYTE_finish: 2479 GET_VREG_R rINST rINST 2480 FETCH_INST_OPCODE 2 %ecx 2481 movb rINSTbl,(%eax) 2482 ADVANCE_PC 2 2483 GOTO_NEXT_R %ecx 2484 2485 2486/* ------------------------------ */ 2487.L_OP_APUT_CHAR: /* 0x50 */ 2488/* File: x86/OP_APUT_CHAR.S */ 2489/* File: x86/OP_APUT.S */ 2490 /* 2491 * Array put, 32 bits or less. vBB[vCC] <- vAA 2492 * 2493 * for: aput, aput-object, aput-boolean, aput-byte, aput-char, aput-short 2494 */ 2495 /* op vAA, vBB, vCC */ 2496 movzbl 2(rPC),%eax # eax<- BB 2497 movzbl 3(rPC),%ecx # ecx<- CC 2498 GET_VREG_R %eax %eax # eax<- vBB (array object) 2499 GET_VREG_R %ecx %ecx # ecs<- vCC (requested index) 2500 testl %eax,%eax # null array object? 2501 je common_errNullObject # bail if so 2502 cmpl offArrayObject_length(%eax),%ecx 2503 jae common_errArrayIndex # index >= length, bail. Expects: 2504 # arrayObj in eax 2505 # index in ecx 2506 leal offArrayObject_contents(%eax,%ecx,2),%eax 2507.LOP_APUT_CHAR_finish: 2508 GET_VREG_R rINST rINST 2509 FETCH_INST_OPCODE 2 %ecx 2510 movw rINSTw,(%eax) 2511 ADVANCE_PC 2 2512 GOTO_NEXT_R %ecx 2513 2514 2515/* ------------------------------ */ 2516.L_OP_APUT_SHORT: /* 0x51 */ 2517/* File: x86/OP_APUT_SHORT.S */ 2518/* File: x86/OP_APUT.S */ 2519 /* 2520 * Array put, 32 bits or less. vBB[vCC] <- vAA 2521 * 2522 * for: aput, aput-object, aput-boolean, aput-byte, aput-char, aput-short 2523 */ 2524 /* op vAA, vBB, vCC */ 2525 movzbl 2(rPC),%eax # eax<- BB 2526 movzbl 3(rPC),%ecx # ecx<- CC 2527 GET_VREG_R %eax %eax # eax<- vBB (array object) 2528 GET_VREG_R %ecx %ecx # ecs<- vCC (requested index) 2529 testl %eax,%eax # null array object? 2530 je common_errNullObject # bail if so 2531 cmpl offArrayObject_length(%eax),%ecx 2532 jae common_errArrayIndex # index >= length, bail. Expects: 2533 # arrayObj in eax 2534 # index in ecx 2535 leal offArrayObject_contents(%eax,%ecx,2),%eax 2536.LOP_APUT_SHORT_finish: 2537 GET_VREG_R rINST rINST 2538 FETCH_INST_OPCODE 2 %ecx 2539 movw rINSTw,(%eax) 2540 ADVANCE_PC 2 2541 GOTO_NEXT_R %ecx 2542 2543 2544/* ------------------------------ */ 2545.L_OP_IGET: /* 0x52 */ 2546/* File: x86/OP_IGET.S */ 2547 /* 2548 * General 32-bit instance field get. 2549 * 2550 * for: iget, iget-object, iget-boolean, iget-byte, iget-char, iget-short 2551 */ 2552 /* op vA, vB, field@CCCC */ 2553 movl rSELF,%ecx 2554 SPILL(rIBASE) # preserve rIBASE 2555 movzwl 2(rPC),rIBASE # rIBASE<- 0000CCCC 2556 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex 2557 movzbl rINSTbl,%ecx # ecx<- BA 2558 sarl $4,%ecx # ecx<- B 2559 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields 2560 andb $0xf,rINSTbl # rINST<- A 2561 GET_VREG_R %ecx %ecx # ecx<- fp[B], the object ptr 2562 movl (%eax,rIBASE,4),%eax # resolved entry 2563 testl %eax,%eax # is resolved entry null? 2564 jne .LOP_IGET_finish # no, already resolved 2565 movl rIBASE,OUT_ARG1(%esp) # needed by dvmResolveInstField 2566 movl rSELF,rIBASE 2567 EXPORT_PC 2568 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method 2569 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz 2570 SPILL_TMP1(%ecx) # save obj pointer across call 2571 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz 2572 call dvmResolveInstField # ... to dvmResolveInstField 2573 UNSPILL_TMP1(%ecx) 2574 testl %eax,%eax # returns InstrField ptr 2575 jne .LOP_IGET_finish 2576 jmp common_exceptionThrown 2577 2578.LOP_IGET_finish: 2579 /* 2580 * Currently: 2581 * eax holds resolved field 2582 * ecx holds object 2583 * rINST holds A 2584 */ 2585 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field 2586 testl %ecx,%ecx # object null? 2587 je common_errNullObject # object was null 2588 movl (%ecx,%eax,1),%ecx # ecx<- obj.field (8/16/32 bits) 2589 FETCH_INST_OPCODE 2 %eax 2590 UNSPILL(rIBASE) 2591 SET_VREG %ecx rINST 2592 ADVANCE_PC 2 2593 GOTO_NEXT_R %eax 2594 2595/* ------------------------------ */ 2596.L_OP_IGET_WIDE: /* 0x53 */ 2597/* File: x86/OP_IGET_WIDE.S */ 2598 /* 2599 * 64-bit instance field get. 2600 * 2601 */ 2602 /* op vA, vB, field@CCCC */ 2603 movl rSELF,%ecx 2604 SPILL(rIBASE) # preserve rIBASE 2605 movzwl 2(rPC),rIBASE # rIBASE<- 0000CCCC 2606 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex 2607 movzbl rINSTbl,%ecx # ecx<- BA 2608 sarl $4,%ecx # ecx<- B 2609 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields 2610 andb $0xf,rINSTbl # rINST<- A 2611 GET_VREG_R %ecx %ecx # ecx<- fp[B], the object ptr 2612 movl (%eax,rIBASE,4),%eax # resolved entry 2613 testl %eax,%eax # is resolved entry null? 2614 jne .LOP_IGET_WIDE_finish # no, already resolved 2615 movl rIBASE,OUT_ARG1(%esp) # for dvmResolveInstField 2616 movl rSELF,rIBASE 2617 EXPORT_PC 2618 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method 2619 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz 2620 SPILL_TMP1(%ecx) # save objpointer across call 2621 movl rPC,OUT_ARG0(%esp) # pass in method->clazz 2622 call dvmResolveInstField # ... to dvmResolveInstField 2623 UNSPILL_TMP1(%ecx) 2624 testl %eax,%eax # returns InstrField ptr 2625 jne .LOP_IGET_WIDE_finish 2626 jmp common_exceptionThrown 2627 2628.LOP_IGET_WIDE_finish: 2629 /* 2630 * Currently: 2631 * eax holds resolved field 2632 * ecx holds object 2633 * rINST holds A 2634 */ 2635 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field 2636 testl %ecx,%ecx # object null? 2637 je common_errNullObject # object was null 2638 leal (%ecx,%eax,1),%eax # eax<- address of field 2639 movl (%eax),%ecx # ecx<- lsw 2640 movl 4(%eax),%eax # eax<- msw 2641 SET_VREG_WORD %ecx rINST 0 2642 FETCH_INST_OPCODE 2 %ecx 2643 UNSPILL(rIBASE) # restore rIBASE 2644 SET_VREG_WORD %eax rINST 1 2645 ADVANCE_PC 2 2646 GOTO_NEXT_R %ecx 2647 2648/* ------------------------------ */ 2649.L_OP_IGET_OBJECT: /* 0x54 */ 2650/* File: x86/OP_IGET_OBJECT.S */ 2651/* File: x86/OP_IGET.S */ 2652 /* 2653 * General 32-bit instance field get. 2654 * 2655 * for: iget, iget-object, iget-boolean, iget-byte, iget-char, iget-short 2656 */ 2657 /* op vA, vB, field@CCCC */ 2658 movl rSELF,%ecx 2659 SPILL(rIBASE) # preserve rIBASE 2660 movzwl 2(rPC),rIBASE # rIBASE<- 0000CCCC 2661 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex 2662 movzbl rINSTbl,%ecx # ecx<- BA 2663 sarl $4,%ecx # ecx<- B 2664 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields 2665 andb $0xf,rINSTbl # rINST<- A 2666 GET_VREG_R %ecx %ecx # ecx<- fp[B], the object ptr 2667 movl (%eax,rIBASE,4),%eax # resolved entry 2668 testl %eax,%eax # is resolved entry null? 2669 jne .LOP_IGET_OBJECT_finish # no, already resolved 2670 movl rIBASE,OUT_ARG1(%esp) # needed by dvmResolveInstField 2671 movl rSELF,rIBASE 2672 EXPORT_PC 2673 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method 2674 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz 2675 SPILL_TMP1(%ecx) # save obj pointer across call 2676 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz 2677 call dvmResolveInstField # ... to dvmResolveInstField 2678 UNSPILL_TMP1(%ecx) 2679 testl %eax,%eax # returns InstrField ptr 2680 jne .LOP_IGET_OBJECT_finish 2681 jmp common_exceptionThrown 2682 2683.LOP_IGET_OBJECT_finish: 2684 /* 2685 * Currently: 2686 * eax holds resolved field 2687 * ecx holds object 2688 * rINST holds A 2689 */ 2690 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field 2691 testl %ecx,%ecx # object null? 2692 je common_errNullObject # object was null 2693 movl (%ecx,%eax,1),%ecx # ecx<- obj.field (8/16/32 bits) 2694 FETCH_INST_OPCODE 2 %eax 2695 UNSPILL(rIBASE) 2696 SET_VREG %ecx rINST 2697 ADVANCE_PC 2 2698 GOTO_NEXT_R %eax 2699 2700 2701/* ------------------------------ */ 2702.L_OP_IGET_BOOLEAN: /* 0x55 */ 2703/* File: x86/OP_IGET_BOOLEAN.S */ 2704/* File: x86/OP_IGET.S */ 2705 /* 2706 * General 32-bit instance field get. 2707 * 2708 * for: iget, iget-object, iget-boolean, iget-byte, iget-char, iget-short 2709 */ 2710 /* op vA, vB, field@CCCC */ 2711 movl rSELF,%ecx 2712 SPILL(rIBASE) # preserve rIBASE 2713 movzwl 2(rPC),rIBASE # rIBASE<- 0000CCCC 2714 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex 2715 movzbl rINSTbl,%ecx # ecx<- BA 2716 sarl $4,%ecx # ecx<- B 2717 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields 2718 andb $0xf,rINSTbl # rINST<- A 2719 GET_VREG_R %ecx %ecx # ecx<- fp[B], the object ptr 2720 movl (%eax,rIBASE,4),%eax # resolved entry 2721 testl %eax,%eax # is resolved entry null? 2722 jne .LOP_IGET_BOOLEAN_finish # no, already resolved 2723 movl rIBASE,OUT_ARG1(%esp) # needed by dvmResolveInstField 2724 movl rSELF,rIBASE 2725 EXPORT_PC 2726 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method 2727 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz 2728 SPILL_TMP1(%ecx) # save obj pointer across call 2729 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz 2730 call dvmResolveInstField # ... to dvmResolveInstField 2731 UNSPILL_TMP1(%ecx) 2732 testl %eax,%eax # returns InstrField ptr 2733 jne .LOP_IGET_BOOLEAN_finish 2734 jmp common_exceptionThrown 2735 2736.LOP_IGET_BOOLEAN_finish: 2737 /* 2738 * Currently: 2739 * eax holds resolved field 2740 * ecx holds object 2741 * rINST holds A 2742 */ 2743 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field 2744 testl %ecx,%ecx # object null? 2745 je common_errNullObject # object was null 2746 movzbl (%ecx,%eax,1),%ecx # ecx<- obj.field (8/16/32 bits) 2747 FETCH_INST_OPCODE 2 %eax 2748 UNSPILL(rIBASE) 2749 SET_VREG %ecx rINST 2750 ADVANCE_PC 2 2751 GOTO_NEXT_R %eax 2752 2753 2754/* ------------------------------ */ 2755.L_OP_IGET_BYTE: /* 0x56 */ 2756/* File: x86/OP_IGET_BYTE.S */ 2757/* File: x86/OP_IGET.S */ 2758 /* 2759 * General 32-bit instance field get. 2760 * 2761 * for: iget, iget-object, iget-boolean, iget-byte, iget-char, iget-short 2762 */ 2763 /* op vA, vB, field@CCCC */ 2764 movl rSELF,%ecx 2765 SPILL(rIBASE) # preserve rIBASE 2766 movzwl 2(rPC),rIBASE # rIBASE<- 0000CCCC 2767 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex 2768 movzbl rINSTbl,%ecx # ecx<- BA 2769 sarl $4,%ecx # ecx<- B 2770 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields 2771 andb $0xf,rINSTbl # rINST<- A 2772 GET_VREG_R %ecx %ecx # ecx<- fp[B], the object ptr 2773 movl (%eax,rIBASE,4),%eax # resolved entry 2774 testl %eax,%eax # is resolved entry null? 2775 jne .LOP_IGET_BYTE_finish # no, already resolved 2776 movl rIBASE,OUT_ARG1(%esp) # needed by dvmResolveInstField 2777 movl rSELF,rIBASE 2778 EXPORT_PC 2779 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method 2780 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz 2781 SPILL_TMP1(%ecx) # save obj pointer across call 2782 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz 2783 call dvmResolveInstField # ... to dvmResolveInstField 2784 UNSPILL_TMP1(%ecx) 2785 testl %eax,%eax # returns InstrField ptr 2786 jne .LOP_IGET_BYTE_finish 2787 jmp common_exceptionThrown 2788 2789.LOP_IGET_BYTE_finish: 2790 /* 2791 * Currently: 2792 * eax holds resolved field 2793 * ecx holds object 2794 * rINST holds A 2795 */ 2796 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field 2797 testl %ecx,%ecx # object null? 2798 je common_errNullObject # object was null 2799 movsbl (%ecx,%eax,1),%ecx # ecx<- obj.field (8/16/32 bits) 2800 FETCH_INST_OPCODE 2 %eax 2801 UNSPILL(rIBASE) 2802 SET_VREG %ecx rINST 2803 ADVANCE_PC 2 2804 GOTO_NEXT_R %eax 2805 2806 2807/* ------------------------------ */ 2808.L_OP_IGET_CHAR: /* 0x57 */ 2809/* File: x86/OP_IGET_CHAR.S */ 2810/* File: x86/OP_IGET.S */ 2811 /* 2812 * General 32-bit instance field get. 2813 * 2814 * for: iget, iget-object, iget-boolean, iget-byte, iget-char, iget-short 2815 */ 2816 /* op vA, vB, field@CCCC */ 2817 movl rSELF,%ecx 2818 SPILL(rIBASE) # preserve rIBASE 2819 movzwl 2(rPC),rIBASE # rIBASE<- 0000CCCC 2820 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex 2821 movzbl rINSTbl,%ecx # ecx<- BA 2822 sarl $4,%ecx # ecx<- B 2823 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields 2824 andb $0xf,rINSTbl # rINST<- A 2825 GET_VREG_R %ecx %ecx # ecx<- fp[B], the object ptr 2826 movl (%eax,rIBASE,4),%eax # resolved entry 2827 testl %eax,%eax # is resolved entry null? 2828 jne .LOP_IGET_CHAR_finish # no, already resolved 2829 movl rIBASE,OUT_ARG1(%esp) # needed by dvmResolveInstField 2830 movl rSELF,rIBASE 2831 EXPORT_PC 2832 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method 2833 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz 2834 SPILL_TMP1(%ecx) # save obj pointer across call 2835 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz 2836 call dvmResolveInstField # ... to dvmResolveInstField 2837 UNSPILL_TMP1(%ecx) 2838 testl %eax,%eax # returns InstrField ptr 2839 jne .LOP_IGET_CHAR_finish 2840 jmp common_exceptionThrown 2841 2842.LOP_IGET_CHAR_finish: 2843 /* 2844 * Currently: 2845 * eax holds resolved field 2846 * ecx holds object 2847 * rINST holds A 2848 */ 2849 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field 2850 testl %ecx,%ecx # object null? 2851 je common_errNullObject # object was null 2852 movzwl (%ecx,%eax,1),%ecx # ecx<- obj.field (8/16/32 bits) 2853 FETCH_INST_OPCODE 2 %eax 2854 UNSPILL(rIBASE) 2855 SET_VREG %ecx rINST 2856 ADVANCE_PC 2 2857 GOTO_NEXT_R %eax 2858 2859 2860/* ------------------------------ */ 2861.L_OP_IGET_SHORT: /* 0x58 */ 2862/* File: x86/OP_IGET_SHORT.S */ 2863/* File: x86/OP_IGET.S */ 2864 /* 2865 * General 32-bit instance field get. 2866 * 2867 * for: iget, iget-object, iget-boolean, iget-byte, iget-char, iget-short 2868 */ 2869 /* op vA, vB, field@CCCC */ 2870 movl rSELF,%ecx 2871 SPILL(rIBASE) # preserve rIBASE 2872 movzwl 2(rPC),rIBASE # rIBASE<- 0000CCCC 2873 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex 2874 movzbl rINSTbl,%ecx # ecx<- BA 2875 sarl $4,%ecx # ecx<- B 2876 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields 2877 andb $0xf,rINSTbl # rINST<- A 2878 GET_VREG_R %ecx %ecx # ecx<- fp[B], the object ptr 2879 movl (%eax,rIBASE,4),%eax # resolved entry 2880 testl %eax,%eax # is resolved entry null? 2881 jne .LOP_IGET_SHORT_finish # no, already resolved 2882 movl rIBASE,OUT_ARG1(%esp) # needed by dvmResolveInstField 2883 movl rSELF,rIBASE 2884 EXPORT_PC 2885 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method 2886 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz 2887 SPILL_TMP1(%ecx) # save obj pointer across call 2888 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz 2889 call dvmResolveInstField # ... to dvmResolveInstField 2890 UNSPILL_TMP1(%ecx) 2891 testl %eax,%eax # returns InstrField ptr 2892 jne .LOP_IGET_SHORT_finish 2893 jmp common_exceptionThrown 2894 2895.LOP_IGET_SHORT_finish: 2896 /* 2897 * Currently: 2898 * eax holds resolved field 2899 * ecx holds object 2900 * rINST holds A 2901 */ 2902 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field 2903 testl %ecx,%ecx # object null? 2904 je common_errNullObject # object was null 2905 movswl (%ecx,%eax,1),%ecx # ecx<- obj.field (8/16/32 bits) 2906 FETCH_INST_OPCODE 2 %eax 2907 UNSPILL(rIBASE) 2908 SET_VREG %ecx rINST 2909 ADVANCE_PC 2 2910 GOTO_NEXT_R %eax 2911 2912 2913/* ------------------------------ */ 2914.L_OP_IPUT: /* 0x59 */ 2915/* File: x86/OP_IPUT.S */ 2916 2917 /* 2918 * General 32-bit instance field put. 2919 * 2920 * for: iput, iput-object, iput-boolean, iput-byte, iput-char, iput-short 2921 */ 2922 /* op vA, vB, field@CCCC */ 2923 movl rSELF,%ecx 2924 SPILL (rIBASE) 2925 movzwl 2(rPC),rIBASE # rIBASE<- 0000CCCC 2926 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex 2927 movzbl rINSTbl,%ecx # ecx<- BA 2928 sarl $4,%ecx # ecx<- B 2929 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields 2930 andb $0xf,rINSTbl # rINST<- A 2931 GET_VREG_R %ecx %ecx # ecx<- fp[B], the object ptr 2932 movl (%eax,rIBASE,4),%eax # resolved entry 2933 testl %eax,%eax # is resolved entry null? 2934 jne .LOP_IPUT_finish # no, already resolved 2935 movl rIBASE,OUT_ARG1(%esp) 2936 movl rSELF,rIBASE 2937 EXPORT_PC 2938 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method 2939 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz 2940 SPILL_TMP1(%ecx) # save obj pointer across call 2941 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz 2942 call dvmResolveInstField # ... to dvmResolveInstField 2943 UNSPILL_TMP1(%ecx) 2944 testl %eax,%eax # returns InstrField ptr 2945 jne .LOP_IPUT_finish 2946 jmp common_exceptionThrown 2947 2948.LOP_IPUT_finish: 2949 /* 2950 * Currently: 2951 * eax holds resolved field 2952 * ecx holds object 2953 * rINST holds A 2954 */ 2955 GET_VREG_R rINST rINST # rINST<- v[A] 2956 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field 2957 testl %ecx,%ecx # object null? 2958 je common_errNullObject # object was null 2959 movl rINST,(%ecx,%eax,1) # obj.field <- v[A](8/16/32 bits) 2960 FETCH_INST_OPCODE 2 %ecx 2961 UNSPILL(rIBASE) 2962 ADVANCE_PC 2 2963 GOTO_NEXT_R %ecx 2964 2965/* ------------------------------ */ 2966.L_OP_IPUT_WIDE: /* 0x5a */ 2967/* File: x86/OP_IPUT_WIDE.S */ 2968 /* 2969 * 64-bit instance field put. 2970 * 2971 */ 2972 /* op vA, vB, field@CCCC */ 2973 movl rSELF,%ecx 2974 SPILL(rIBASE) 2975 movzwl 2(rPC),rIBASE # rIBASE<- 0000CCCC 2976 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex 2977 movzbl rINSTbl,%ecx # ecx<- BA 2978 sarl $4,%ecx # ecx<- B 2979 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields 2980 andb $0xf,rINSTbl # rINST<- A 2981 GET_VREG_R %ecx %ecx # ecx<- fp[B], the object ptr 2982 movl (%eax,rIBASE,4),%eax # resolved entry 2983 testl %eax,%eax # is resolved entry null? 2984 jne .LOP_IPUT_WIDE_finish # no, already resolved 2985 movl rIBASE,OUT_ARG1(%esp) 2986 movl rSELF,rIBASE 2987 EXPORT_PC 2988 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method 2989 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz 2990 SPILL_TMP1(%ecx) # save obj pointer across call 2991 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz 2992 call dvmResolveInstField # ... to dvmResolveInstField 2993 UNSPILL_TMP1(%ecx) 2994 testl %eax,%eax # ... which returns InstrField ptr 2995 jne .LOP_IPUT_WIDE_finish 2996 jmp common_exceptionThrown 2997 2998.LOP_IPUT_WIDE_finish: 2999 /* 3000 * Currently: 3001 * eax holds resolved field 3002 * ecx holds object 3003 * rIBASE is scratch, but needs to be unspilled 3004 * rINST holds A 3005 */ 3006 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field 3007 testl %ecx,%ecx # object null? 3008 je common_errNullObject # object was null 3009 leal (%ecx,%eax,1),%eax # eax<- address of field 3010 GET_VREG_WORD %ecx rINST 0 # ecx<- lsw 3011 GET_VREG_WORD rINST rINST 1 # rINST<- msw 3012 movl rINST,4(%eax) 3013 movl %ecx,(%eax) 3014 FETCH_INST_OPCODE 2 %ecx 3015 UNSPILL(rIBASE) 3016 ADVANCE_PC 2 3017 GOTO_NEXT_R %ecx 3018 3019/* ------------------------------ */ 3020.L_OP_IPUT_OBJECT: /* 0x5b */ 3021/* File: x86/OP_IPUT_OBJECT.S */ 3022 /* 3023 * Object field put. 3024 * 3025 * for: iput-object 3026 */ 3027 /* op vA, vB, field@CCCC */ 3028 movl rSELF,%ecx 3029 SPILL(rIBASE) 3030 movzwl 2(rPC),rIBASE # rIBASE<- 0000CCCC 3031 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex 3032 movzbl rINSTbl,%ecx # ecx<- BA 3033 sarl $4,%ecx # ecx<- B 3034 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields 3035 andb $0xf,rINSTbl # rINST<- A 3036 GET_VREG_R %ecx %ecx # ecx<- fp[B], the object ptr 3037 movl (%eax,rIBASE,4),%eax # resolved entry 3038 testl %eax,%eax # is resolved entry null? 3039 jne .LOP_IPUT_OBJECT_finish # no, already resolved 3040 movl rIBASE,OUT_ARG1(%esp) 3041 movl rSELF,rIBASE 3042 EXPORT_PC 3043 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method 3044 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz 3045 SPILL_TMP1(%ecx) # save obj pointer across call 3046 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz 3047 call dvmResolveInstField # ... to dvmResolveInstField 3048 UNSPILL_TMP1(%ecx) 3049 testl %eax,%eax # returns InstrField ptr 3050 jne .LOP_IPUT_OBJECT_finish 3051 jmp common_exceptionThrown 3052 3053.LOP_IPUT_OBJECT_finish: 3054 /* 3055 * Currently: 3056 * eax holds resolved field 3057 * ecx holds object 3058 * rIBASE is scratch, but needs to be unspilled 3059 * rINST holds A 3060 */ 3061 GET_VREG_R rINST rINST # rINST<- v[A] 3062 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field 3063 testl %ecx,%ecx # object null? 3064 je common_errNullObject # object was null 3065 movl rINST,(%ecx,%eax) # obj.field <- v[A](8/16/32 bits) 3066 movl rSELF,%eax 3067 testl rINST,rINST # stored a NULL? 3068 movl offThread_cardTable(%eax),%eax # get card table base 3069 je 1f # skip card mark if null store 3070 shrl $GC_CARD_SHIFT,%ecx # object head to card number 3071 movb %al,(%eax,%ecx) # mark card using object head 30721: 3073 UNSPILL(rIBASE) 3074 FETCH_INST_OPCODE 2 %ecx 3075 ADVANCE_PC 2 3076 GOTO_NEXT_R %ecx 3077 3078/* ------------------------------ */ 3079.L_OP_IPUT_BOOLEAN: /* 0x5c */ 3080/* File: x86/OP_IPUT_BOOLEAN.S */ 3081/* File: x86/OP_IPUT.S */ 3082 3083 /* 3084 * General 32-bit instance field put. 3085 * 3086 * for: iput, iput-object, iput-boolean, iput-byte, iput-char, iput-short 3087 */ 3088 /* op vA, vB, field@CCCC */ 3089 movl rSELF,%ecx 3090 SPILL (rIBASE) 3091 movzwl 2(rPC),rIBASE # rIBASE<- 0000CCCC 3092 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex 3093 movzbl rINSTbl,%ecx # ecx<- BA 3094 sarl $4,%ecx # ecx<- B 3095 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields 3096 andb $0xf,rINSTbl # rINST<- A 3097 GET_VREG_R %ecx %ecx # ecx<- fp[B], the object ptr 3098 movl (%eax,rIBASE,4),%eax # resolved entry 3099 testl %eax,%eax # is resolved entry null? 3100 jne .LOP_IPUT_BOOLEAN_finish # no, already resolved 3101 movl rIBASE,OUT_ARG1(%esp) 3102 movl rSELF,rIBASE 3103 EXPORT_PC 3104 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method 3105 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz 3106 SPILL_TMP1(%ecx) # save obj pointer across call 3107 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz 3108 call dvmResolveInstField # ... to dvmResolveInstField 3109 UNSPILL_TMP1(%ecx) 3110 testl %eax,%eax # returns InstrField ptr 3111 jne .LOP_IPUT_BOOLEAN_finish 3112 jmp common_exceptionThrown 3113 3114.LOP_IPUT_BOOLEAN_finish: 3115 /* 3116 * Currently: 3117 * eax holds resolved field 3118 * ecx holds object 3119 * rINST holds A 3120 */ 3121 GET_VREG_R rINST rINST # rINST<- v[A] 3122 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field 3123 testl %ecx,%ecx # object null? 3124 je common_errNullObject # object was null 3125 movb rINSTbl,(%ecx,%eax,1) # obj.field <- v[A](8/16/32 bits) 3126 FETCH_INST_OPCODE 2 %ecx 3127 UNSPILL(rIBASE) 3128 ADVANCE_PC 2 3129 GOTO_NEXT_R %ecx 3130 3131 3132/* ------------------------------ */ 3133.L_OP_IPUT_BYTE: /* 0x5d */ 3134/* File: x86/OP_IPUT_BYTE.S */ 3135/* File: x86/OP_IPUT.S */ 3136 3137 /* 3138 * General 32-bit instance field put. 3139 * 3140 * for: iput, iput-object, iput-boolean, iput-byte, iput-char, iput-short 3141 */ 3142 /* op vA, vB, field@CCCC */ 3143 movl rSELF,%ecx 3144 SPILL (rIBASE) 3145 movzwl 2(rPC),rIBASE # rIBASE<- 0000CCCC 3146 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex 3147 movzbl rINSTbl,%ecx # ecx<- BA 3148 sarl $4,%ecx # ecx<- B 3149 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields 3150 andb $0xf,rINSTbl # rINST<- A 3151 GET_VREG_R %ecx %ecx # ecx<- fp[B], the object ptr 3152 movl (%eax,rIBASE,4),%eax # resolved entry 3153 testl %eax,%eax # is resolved entry null? 3154 jne .LOP_IPUT_BYTE_finish # no, already resolved 3155 movl rIBASE,OUT_ARG1(%esp) 3156 movl rSELF,rIBASE 3157 EXPORT_PC 3158 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method 3159 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz 3160 SPILL_TMP1(%ecx) # save obj pointer across call 3161 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz 3162 call dvmResolveInstField # ... to dvmResolveInstField 3163 UNSPILL_TMP1(%ecx) 3164 testl %eax,%eax # returns InstrField ptr 3165 jne .LOP_IPUT_BYTE_finish 3166 jmp common_exceptionThrown 3167 3168.LOP_IPUT_BYTE_finish: 3169 /* 3170 * Currently: 3171 * eax holds resolved field 3172 * ecx holds object 3173 * rINST holds A 3174 */ 3175 GET_VREG_R rINST rINST # rINST<- v[A] 3176 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field 3177 testl %ecx,%ecx # object null? 3178 je common_errNullObject # object was null 3179 movb rINSTbl,(%ecx,%eax,1) # obj.field <- v[A](8/16/32 bits) 3180 FETCH_INST_OPCODE 2 %ecx 3181 UNSPILL(rIBASE) 3182 ADVANCE_PC 2 3183 GOTO_NEXT_R %ecx 3184 3185 3186/* ------------------------------ */ 3187.L_OP_IPUT_CHAR: /* 0x5e */ 3188/* File: x86/OP_IPUT_CHAR.S */ 3189/* File: x86/OP_IPUT.S */ 3190 3191 /* 3192 * General 32-bit instance field put. 3193 * 3194 * for: iput, iput-object, iput-boolean, iput-byte, iput-char, iput-short 3195 */ 3196 /* op vA, vB, field@CCCC */ 3197 movl rSELF,%ecx 3198 SPILL (rIBASE) 3199 movzwl 2(rPC),rIBASE # rIBASE<- 0000CCCC 3200 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex 3201 movzbl rINSTbl,%ecx # ecx<- BA 3202 sarl $4,%ecx # ecx<- B 3203 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields 3204 andb $0xf,rINSTbl # rINST<- A 3205 GET_VREG_R %ecx %ecx # ecx<- fp[B], the object ptr 3206 movl (%eax,rIBASE,4),%eax # resolved entry 3207 testl %eax,%eax # is resolved entry null? 3208 jne .LOP_IPUT_CHAR_finish # no, already resolved 3209 movl rIBASE,OUT_ARG1(%esp) 3210 movl rSELF,rIBASE 3211 EXPORT_PC 3212 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method 3213 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz 3214 SPILL_TMP1(%ecx) # save obj pointer across call 3215 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz 3216 call dvmResolveInstField # ... to dvmResolveInstField 3217 UNSPILL_TMP1(%ecx) 3218 testl %eax,%eax # returns InstrField ptr 3219 jne .LOP_IPUT_CHAR_finish 3220 jmp common_exceptionThrown 3221 3222.LOP_IPUT_CHAR_finish: 3223 /* 3224 * Currently: 3225 * eax holds resolved field 3226 * ecx holds object 3227 * rINST holds A 3228 */ 3229 GET_VREG_R rINST rINST # rINST<- v[A] 3230 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field 3231 testl %ecx,%ecx # object null? 3232 je common_errNullObject # object was null 3233 movw rINSTw,(%ecx,%eax,1) # obj.field <- v[A](8/16/32 bits) 3234 FETCH_INST_OPCODE 2 %ecx 3235 UNSPILL(rIBASE) 3236 ADVANCE_PC 2 3237 GOTO_NEXT_R %ecx 3238 3239 3240/* ------------------------------ */ 3241.L_OP_IPUT_SHORT: /* 0x5f */ 3242/* File: x86/OP_IPUT_SHORT.S */ 3243/* File: x86/OP_IPUT.S */ 3244 3245 /* 3246 * General 32-bit instance field put. 3247 * 3248 * for: iput, iput-object, iput-boolean, iput-byte, iput-char, iput-short 3249 */ 3250 /* op vA, vB, field@CCCC */ 3251 movl rSELF,%ecx 3252 SPILL (rIBASE) 3253 movzwl 2(rPC),rIBASE # rIBASE<- 0000CCCC 3254 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex 3255 movzbl rINSTbl,%ecx # ecx<- BA 3256 sarl $4,%ecx # ecx<- B 3257 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields 3258 andb $0xf,rINSTbl # rINST<- A 3259 GET_VREG_R %ecx %ecx # ecx<- fp[B], the object ptr 3260 movl (%eax,rIBASE,4),%eax # resolved entry 3261 testl %eax,%eax # is resolved entry null? 3262 jne .LOP_IPUT_SHORT_finish # no, already resolved 3263 movl rIBASE,OUT_ARG1(%esp) 3264 movl rSELF,rIBASE 3265 EXPORT_PC 3266 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method 3267 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz 3268 SPILL_TMP1(%ecx) # save obj pointer across call 3269 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz 3270 call dvmResolveInstField # ... to dvmResolveInstField 3271 UNSPILL_TMP1(%ecx) 3272 testl %eax,%eax # returns InstrField ptr 3273 jne .LOP_IPUT_SHORT_finish 3274 jmp common_exceptionThrown 3275 3276.LOP_IPUT_SHORT_finish: 3277 /* 3278 * Currently: 3279 * eax holds resolved field 3280 * ecx holds object 3281 * rINST holds A 3282 */ 3283 GET_VREG_R rINST rINST # rINST<- v[A] 3284 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field 3285 testl %ecx,%ecx # object null? 3286 je common_errNullObject # object was null 3287 movw rINSTw,(%ecx,%eax,1) # obj.field <- v[A](8/16/32 bits) 3288 FETCH_INST_OPCODE 2 %ecx 3289 UNSPILL(rIBASE) 3290 ADVANCE_PC 2 3291 GOTO_NEXT_R %ecx 3292 3293 3294/* ------------------------------ */ 3295.L_OP_SGET: /* 0x60 */ 3296/* File: x86/OP_SGET.S */ 3297 /* 3298 * General 32-bit SGET handler. 3299 * 3300 * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short 3301 */ 3302 /* op vAA, field@BBBB */ 3303 movl rSELF,%ecx 3304 movzwl 2(rPC),%eax # eax<- field ref BBBB 3305 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex 3306 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields 3307 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr 3308 testl %eax,%eax # resolved entry null? 3309 je .LOP_SGET_resolve # if not, make it so 3310.LOP_SGET_finish: # field ptr in eax 3311 movl offStaticField_value(%eax),%eax 3312 FETCH_INST_OPCODE 2 %ecx 3313 ADVANCE_PC 2 3314 SET_VREG %eax rINST 3315 GOTO_NEXT_R %ecx 3316 3317 /* 3318 * Go resolve the field 3319 */ 3320.LOP_SGET_resolve: 3321 movl rSELF,%ecx 3322 movzwl 2(rPC),%eax # eax<- field ref BBBB 3323 movl offThread_method(%ecx),%ecx # ecx<- current method 3324 EXPORT_PC # could throw, need to export 3325 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 3326 movl %eax,OUT_ARG1(%esp) 3327 movl %ecx,OUT_ARG0(%esp) 3328 SPILL(rIBASE) 3329 call dvmResolveStaticField # eax<- resolved StaticField ptr 3330 UNSPILL(rIBASE) 3331 testl %eax,%eax 3332 jne .LOP_SGET_finish # success, continue 3333 jmp common_exceptionThrown # no, handle exception 3334 3335/* ------------------------------ */ 3336.L_OP_SGET_WIDE: /* 0x61 */ 3337/* File: x86/OP_SGET_WIDE.S */ 3338 /* 3339 * 64-bit SGET handler. 3340 * 3341 */ 3342 /* sget-wide vAA, field@BBBB */ 3343 movl rSELF,%ecx 3344 movzwl 2(rPC),%eax # eax<- field ref BBBB 3345 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex 3346 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields 3347 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr 3348 testl %eax,%eax # resolved entry null? 3349 je .LOP_SGET_WIDE_resolve # if not, make it so 3350.LOP_SGET_WIDE_finish: # field ptr in eax 3351 movl offStaticField_value(%eax),%ecx # ecx<- lsw 3352 movl 4+offStaticField_value(%eax),%eax # eax<- msw 3353 SET_VREG_WORD %ecx rINST 0 3354 FETCH_INST_OPCODE 2 %ecx 3355 SET_VREG_WORD %eax rINST 1 3356 ADVANCE_PC 2 3357 GOTO_NEXT_R %ecx 3358 3359 /* 3360 * Go resolve the field 3361 */ 3362.LOP_SGET_WIDE_resolve: 3363 movl rSELF,%ecx 3364 movzwl 2(rPC),%eax # eax<- field ref BBBB 3365 movl offThread_method(%ecx),%ecx # ecx<- current method 3366 EXPORT_PC # could throw, need to export 3367 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 3368 movl %eax,OUT_ARG1(%esp) 3369 movl %ecx,OUT_ARG0(%esp) 3370 SPILL(rIBASE) 3371 call dvmResolveStaticField # eax<- resolved StaticField ptr 3372 UNSPILL(rIBASE) 3373 testl %eax,%eax 3374 jne .LOP_SGET_WIDE_finish # success, continue 3375 jmp common_exceptionThrown # no, handle exception 3376 3377/* ------------------------------ */ 3378.L_OP_SGET_OBJECT: /* 0x62 */ 3379/* File: x86/OP_SGET_OBJECT.S */ 3380/* File: x86/OP_SGET.S */ 3381 /* 3382 * General 32-bit SGET handler. 3383 * 3384 * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short 3385 */ 3386 /* op vAA, field@BBBB */ 3387 movl rSELF,%ecx 3388 movzwl 2(rPC),%eax # eax<- field ref BBBB 3389 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex 3390 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields 3391 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr 3392 testl %eax,%eax # resolved entry null? 3393 je .LOP_SGET_OBJECT_resolve # if not, make it so 3394.LOP_SGET_OBJECT_finish: # field ptr in eax 3395 movl offStaticField_value(%eax),%eax 3396 FETCH_INST_OPCODE 2 %ecx 3397 ADVANCE_PC 2 3398 SET_VREG %eax rINST 3399 GOTO_NEXT_R %ecx 3400 3401 /* 3402 * Go resolve the field 3403 */ 3404.LOP_SGET_OBJECT_resolve: 3405 movl rSELF,%ecx 3406 movzwl 2(rPC),%eax # eax<- field ref BBBB 3407 movl offThread_method(%ecx),%ecx # ecx<- current method 3408 EXPORT_PC # could throw, need to export 3409 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 3410 movl %eax,OUT_ARG1(%esp) 3411 movl %ecx,OUT_ARG0(%esp) 3412 SPILL(rIBASE) 3413 call dvmResolveStaticField # eax<- resolved StaticField ptr 3414 UNSPILL(rIBASE) 3415 testl %eax,%eax 3416 jne .LOP_SGET_OBJECT_finish # success, continue 3417 jmp common_exceptionThrown # no, handle exception 3418 3419 3420/* ------------------------------ */ 3421.L_OP_SGET_BOOLEAN: /* 0x63 */ 3422/* File: x86/OP_SGET_BOOLEAN.S */ 3423/* File: x86/OP_SGET.S */ 3424 /* 3425 * General 32-bit SGET handler. 3426 * 3427 * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short 3428 */ 3429 /* op vAA, field@BBBB */ 3430 movl rSELF,%ecx 3431 movzwl 2(rPC),%eax # eax<- field ref BBBB 3432 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex 3433 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields 3434 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr 3435 testl %eax,%eax # resolved entry null? 3436 je .LOP_SGET_BOOLEAN_resolve # if not, make it so 3437.LOP_SGET_BOOLEAN_finish: # field ptr in eax 3438 movl offStaticField_value(%eax),%eax 3439 FETCH_INST_OPCODE 2 %ecx 3440 ADVANCE_PC 2 3441 SET_VREG %eax rINST 3442 GOTO_NEXT_R %ecx 3443 3444 /* 3445 * Go resolve the field 3446 */ 3447.LOP_SGET_BOOLEAN_resolve: 3448 movl rSELF,%ecx 3449 movzwl 2(rPC),%eax # eax<- field ref BBBB 3450 movl offThread_method(%ecx),%ecx # ecx<- current method 3451 EXPORT_PC # could throw, need to export 3452 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 3453 movl %eax,OUT_ARG1(%esp) 3454 movl %ecx,OUT_ARG0(%esp) 3455 SPILL(rIBASE) 3456 call dvmResolveStaticField # eax<- resolved StaticField ptr 3457 UNSPILL(rIBASE) 3458 testl %eax,%eax 3459 jne .LOP_SGET_BOOLEAN_finish # success, continue 3460 jmp common_exceptionThrown # no, handle exception 3461 3462 3463/* ------------------------------ */ 3464.L_OP_SGET_BYTE: /* 0x64 */ 3465/* File: x86/OP_SGET_BYTE.S */ 3466/* File: x86/OP_SGET.S */ 3467 /* 3468 * General 32-bit SGET handler. 3469 * 3470 * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short 3471 */ 3472 /* op vAA, field@BBBB */ 3473 movl rSELF,%ecx 3474 movzwl 2(rPC),%eax # eax<- field ref BBBB 3475 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex 3476 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields 3477 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr 3478 testl %eax,%eax # resolved entry null? 3479 je .LOP_SGET_BYTE_resolve # if not, make it so 3480.LOP_SGET_BYTE_finish: # field ptr in eax 3481 movl offStaticField_value(%eax),%eax 3482 FETCH_INST_OPCODE 2 %ecx 3483 ADVANCE_PC 2 3484 SET_VREG %eax rINST 3485 GOTO_NEXT_R %ecx 3486 3487 /* 3488 * Go resolve the field 3489 */ 3490.LOP_SGET_BYTE_resolve: 3491 movl rSELF,%ecx 3492 movzwl 2(rPC),%eax # eax<- field ref BBBB 3493 movl offThread_method(%ecx),%ecx # ecx<- current method 3494 EXPORT_PC # could throw, need to export 3495 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 3496 movl %eax,OUT_ARG1(%esp) 3497 movl %ecx,OUT_ARG0(%esp) 3498 SPILL(rIBASE) 3499 call dvmResolveStaticField # eax<- resolved StaticField ptr 3500 UNSPILL(rIBASE) 3501 testl %eax,%eax 3502 jne .LOP_SGET_BYTE_finish # success, continue 3503 jmp common_exceptionThrown # no, handle exception 3504 3505 3506/* ------------------------------ */ 3507.L_OP_SGET_CHAR: /* 0x65 */ 3508/* File: x86/OP_SGET_CHAR.S */ 3509/* File: x86/OP_SGET.S */ 3510 /* 3511 * General 32-bit SGET handler. 3512 * 3513 * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short 3514 */ 3515 /* op vAA, field@BBBB */ 3516 movl rSELF,%ecx 3517 movzwl 2(rPC),%eax # eax<- field ref BBBB 3518 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex 3519 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields 3520 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr 3521 testl %eax,%eax # resolved entry null? 3522 je .LOP_SGET_CHAR_resolve # if not, make it so 3523.LOP_SGET_CHAR_finish: # field ptr in eax 3524 movl offStaticField_value(%eax),%eax 3525 FETCH_INST_OPCODE 2 %ecx 3526 ADVANCE_PC 2 3527 SET_VREG %eax rINST 3528 GOTO_NEXT_R %ecx 3529 3530 /* 3531 * Go resolve the field 3532 */ 3533.LOP_SGET_CHAR_resolve: 3534 movl rSELF,%ecx 3535 movzwl 2(rPC),%eax # eax<- field ref BBBB 3536 movl offThread_method(%ecx),%ecx # ecx<- current method 3537 EXPORT_PC # could throw, need to export 3538 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 3539 movl %eax,OUT_ARG1(%esp) 3540 movl %ecx,OUT_ARG0(%esp) 3541 SPILL(rIBASE) 3542 call dvmResolveStaticField # eax<- resolved StaticField ptr 3543 UNSPILL(rIBASE) 3544 testl %eax,%eax 3545 jne .LOP_SGET_CHAR_finish # success, continue 3546 jmp common_exceptionThrown # no, handle exception 3547 3548 3549/* ------------------------------ */ 3550.L_OP_SGET_SHORT: /* 0x66 */ 3551/* File: x86/OP_SGET_SHORT.S */ 3552/* File: x86/OP_SGET.S */ 3553 /* 3554 * General 32-bit SGET handler. 3555 * 3556 * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short 3557 */ 3558 /* op vAA, field@BBBB */ 3559 movl rSELF,%ecx 3560 movzwl 2(rPC),%eax # eax<- field ref BBBB 3561 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex 3562 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields 3563 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr 3564 testl %eax,%eax # resolved entry null? 3565 je .LOP_SGET_SHORT_resolve # if not, make it so 3566.LOP_SGET_SHORT_finish: # field ptr in eax 3567 movl offStaticField_value(%eax),%eax 3568 FETCH_INST_OPCODE 2 %ecx 3569 ADVANCE_PC 2 3570 SET_VREG %eax rINST 3571 GOTO_NEXT_R %ecx 3572 3573 /* 3574 * Go resolve the field 3575 */ 3576.LOP_SGET_SHORT_resolve: 3577 movl rSELF,%ecx 3578 movzwl 2(rPC),%eax # eax<- field ref BBBB 3579 movl offThread_method(%ecx),%ecx # ecx<- current method 3580 EXPORT_PC # could throw, need to export 3581 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 3582 movl %eax,OUT_ARG1(%esp) 3583 movl %ecx,OUT_ARG0(%esp) 3584 SPILL(rIBASE) 3585 call dvmResolveStaticField # eax<- resolved StaticField ptr 3586 UNSPILL(rIBASE) 3587 testl %eax,%eax 3588 jne .LOP_SGET_SHORT_finish # success, continue 3589 jmp common_exceptionThrown # no, handle exception 3590 3591 3592/* ------------------------------ */ 3593.L_OP_SPUT: /* 0x67 */ 3594/* File: x86/OP_SPUT.S */ 3595 /* 3596 * General 32-bit SPUT handler. 3597 * 3598 * for: sput, sput-boolean, sput-byte, sput-char, sput-short 3599 */ 3600 /* op vAA, field@BBBB */ 3601 movl rSELF,%ecx 3602 movzwl 2(rPC),%eax # eax<- field ref BBBB 3603 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex 3604 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields 3605 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr 3606 testl %eax,%eax # resolved entry null? 3607 je .LOP_SPUT_resolve # if not, make it so 3608.LOP_SPUT_finish: # field ptr in eax 3609 GET_VREG_R rINST rINST 3610 FETCH_INST_OPCODE 2 %ecx 3611 ADVANCE_PC 2 3612 movl rINST,offStaticField_value(%eax) 3613 GOTO_NEXT_R %ecx 3614 3615 /* 3616 * Go resolve the field 3617 */ 3618.LOP_SPUT_resolve: 3619 movl rSELF,%ecx 3620 movzwl 2(rPC),%eax # eax<- field ref BBBB 3621 movl offThread_method(%ecx),%ecx # ecx<- current method 3622 EXPORT_PC # could throw, need to export 3623 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 3624 movl %eax,OUT_ARG1(%esp) 3625 movl %ecx,OUT_ARG0(%esp) 3626 SPILL(rIBASE) 3627 call dvmResolveStaticField # eax<- resolved StaticField ptr 3628 UNSPILL(rIBASE) 3629 testl %eax,%eax 3630 jne .LOP_SPUT_finish # success, continue 3631 jmp common_exceptionThrown # no, handle exception 3632 3633/* ------------------------------ */ 3634.L_OP_SPUT_WIDE: /* 0x68 */ 3635/* File: x86/OP_SPUT_WIDE.S */ 3636 /* 3637 * General 32-bit SPUT handler. 3638 * 3639 * for: sput, sput-object, sput-boolean, sput-byte, sput-char, sput-short 3640 */ 3641 /* op vAA, field@BBBB */ 3642 movl rSELF,%ecx 3643 movzwl 2(rPC),%eax # eax<- field ref BBBB 3644 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex 3645 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields 3646 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr 3647 testl %eax,%eax # resolved entry null? 3648 je .LOP_SPUT_WIDE_resolve # if not, make it so 3649.LOP_SPUT_WIDE_finish: # field ptr in eax 3650 GET_VREG_WORD %ecx rINST 0 # rINST<- lsw 3651 GET_VREG_WORD rINST rINST 1 # ecx<- msw 3652 movl %ecx,offStaticField_value(%eax) 3653 FETCH_INST_OPCODE 2 %ecx 3654 movl rINST,4+offStaticField_value(%eax) 3655 ADVANCE_PC 2 3656 GOTO_NEXT_R %ecx 3657 3658 /* 3659 * Go resolve the field 3660 */ 3661.LOP_SPUT_WIDE_resolve: 3662 movl rSELF,%ecx 3663 movzwl 2(rPC),%eax # eax<- field ref BBBB 3664 movl offThread_method(%ecx),%ecx # ecx<- current method 3665 EXPORT_PC # could throw, need to export 3666 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 3667 movl %eax,OUT_ARG1(%esp) 3668 movl %ecx,OUT_ARG0(%esp) 3669 SPILL(rIBASE) 3670 call dvmResolveStaticField # eax<- resolved StaticField ptr 3671 UNSPILL(rIBASE) 3672 testl %eax,%eax 3673 jne .LOP_SPUT_WIDE_finish # success, continue 3674 jmp common_exceptionThrown # no, handle exception 3675 3676/* ------------------------------ */ 3677.L_OP_SPUT_OBJECT: /* 0x69 */ 3678/* File: x86/OP_SPUT_OBJECT.S */ 3679 /* 3680 * SPUT object handler. 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 3688 testl %eax,%eax # resolved entry null? 3689 je .LOP_SPUT_OBJECT_resolve # if not, make it so 3690.LOP_SPUT_OBJECT_finish: # field ptr in eax 3691 movzbl rINSTbl,%ecx # ecx<- AA 3692 GET_VREG_R %ecx %ecx 3693 movl %ecx,offStaticField_value(%eax) # do the store 3694 testl %ecx,%ecx # stored null object ptr? 3695 je 1f # skip card mark if null 3696 movl rSELF,%ecx 3697 movl offField_clazz(%eax),%eax # eax<- method->clazz 3698 movl offThread_cardTable(%ecx),%ecx # get card table base 3699 shrl $GC_CARD_SHIFT,%eax # head to card number 3700 movb %cl,(%ecx,%eax) # mark card 37011: 3702 FETCH_INST_OPCODE 2 %ecx 3703 ADVANCE_PC 2 3704 GOTO_NEXT_R %ecx 3705 3706.LOP_SPUT_OBJECT_resolve: 3707 movl rSELF,%ecx 3708 movzwl 2(rPC),%eax # eax<- field ref BBBB 3709 movl offThread_method(%ecx),%ecx # ecx<- current method 3710 EXPORT_PC # could throw, need to export 3711 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 3712 movl %eax,OUT_ARG1(%esp) 3713 movl %ecx,OUT_ARG0(%esp) 3714 SPILL(rIBASE) 3715 call dvmResolveStaticField # eax<- resolved StaticField ptr 3716 UNSPILL(rIBASE) 3717 testl %eax,%eax 3718 jne .LOP_SPUT_OBJECT_finish # success, continue 3719 jmp common_exceptionThrown # no, handle exception 3720 3721/* ------------------------------ */ 3722.L_OP_SPUT_BOOLEAN: /* 0x6a */ 3723/* File: x86/OP_SPUT_BOOLEAN.S */ 3724/* File: x86/OP_SPUT.S */ 3725 /* 3726 * General 32-bit SPUT handler. 3727 * 3728 * for: sput, sput-boolean, sput-byte, sput-char, sput-short 3729 */ 3730 /* op vAA, field@BBBB */ 3731 movl rSELF,%ecx 3732 movzwl 2(rPC),%eax # eax<- field ref BBBB 3733 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex 3734 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields 3735 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr 3736 testl %eax,%eax # resolved entry null? 3737 je .LOP_SPUT_BOOLEAN_resolve # if not, make it so 3738.LOP_SPUT_BOOLEAN_finish: # field ptr in eax 3739 GET_VREG_R rINST rINST 3740 FETCH_INST_OPCODE 2 %ecx 3741 ADVANCE_PC 2 3742 movl rINST,offStaticField_value(%eax) 3743 GOTO_NEXT_R %ecx 3744 3745 /* 3746 * Go resolve the field 3747 */ 3748.LOP_SPUT_BOOLEAN_resolve: 3749 movl rSELF,%ecx 3750 movzwl 2(rPC),%eax # eax<- field ref BBBB 3751 movl offThread_method(%ecx),%ecx # ecx<- current method 3752 EXPORT_PC # could throw, need to export 3753 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 3754 movl %eax,OUT_ARG1(%esp) 3755 movl %ecx,OUT_ARG0(%esp) 3756 SPILL(rIBASE) 3757 call dvmResolveStaticField # eax<- resolved StaticField ptr 3758 UNSPILL(rIBASE) 3759 testl %eax,%eax 3760 jne .LOP_SPUT_BOOLEAN_finish # success, continue 3761 jmp common_exceptionThrown # no, handle exception 3762 3763 3764/* ------------------------------ */ 3765.L_OP_SPUT_BYTE: /* 0x6b */ 3766/* File: x86/OP_SPUT_BYTE.S */ 3767/* File: x86/OP_SPUT.S */ 3768 /* 3769 * General 32-bit SPUT handler. 3770 * 3771 * for: sput, sput-boolean, sput-byte, sput-char, sput-short 3772 */ 3773 /* op vAA, field@BBBB */ 3774 movl rSELF,%ecx 3775 movzwl 2(rPC),%eax # eax<- field ref BBBB 3776 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex 3777 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields 3778 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr 3779 testl %eax,%eax # resolved entry null? 3780 je .LOP_SPUT_BYTE_resolve # if not, make it so 3781.LOP_SPUT_BYTE_finish: # field ptr in eax 3782 GET_VREG_R rINST rINST 3783 FETCH_INST_OPCODE 2 %ecx 3784 ADVANCE_PC 2 3785 movl rINST,offStaticField_value(%eax) 3786 GOTO_NEXT_R %ecx 3787 3788 /* 3789 * Go resolve the field 3790 */ 3791.LOP_SPUT_BYTE_resolve: 3792 movl rSELF,%ecx 3793 movzwl 2(rPC),%eax # eax<- field ref BBBB 3794 movl offThread_method(%ecx),%ecx # ecx<- current method 3795 EXPORT_PC # could throw, need to export 3796 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 3797 movl %eax,OUT_ARG1(%esp) 3798 movl %ecx,OUT_ARG0(%esp) 3799 SPILL(rIBASE) 3800 call dvmResolveStaticField # eax<- resolved StaticField ptr 3801 UNSPILL(rIBASE) 3802 testl %eax,%eax 3803 jne .LOP_SPUT_BYTE_finish # success, continue 3804 jmp common_exceptionThrown # no, handle exception 3805 3806 3807/* ------------------------------ */ 3808.L_OP_SPUT_CHAR: /* 0x6c */ 3809/* File: x86/OP_SPUT_CHAR.S */ 3810/* File: x86/OP_SPUT.S */ 3811 /* 3812 * General 32-bit SPUT handler. 3813 * 3814 * for: sput, sput-boolean, sput-byte, sput-char, sput-short 3815 */ 3816 /* op vAA, field@BBBB */ 3817 movl rSELF,%ecx 3818 movzwl 2(rPC),%eax # eax<- field ref BBBB 3819 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex 3820 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields 3821 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr 3822 testl %eax,%eax # resolved entry null? 3823 je .LOP_SPUT_CHAR_resolve # if not, make it so 3824.LOP_SPUT_CHAR_finish: # field ptr in eax 3825 GET_VREG_R rINST rINST 3826 FETCH_INST_OPCODE 2 %ecx 3827 ADVANCE_PC 2 3828 movl rINST,offStaticField_value(%eax) 3829 GOTO_NEXT_R %ecx 3830 3831 /* 3832 * Go resolve the field 3833 */ 3834.LOP_SPUT_CHAR_resolve: 3835 movl rSELF,%ecx 3836 movzwl 2(rPC),%eax # eax<- field ref BBBB 3837 movl offThread_method(%ecx),%ecx # ecx<- current method 3838 EXPORT_PC # could throw, need to export 3839 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 3840 movl %eax,OUT_ARG1(%esp) 3841 movl %ecx,OUT_ARG0(%esp) 3842 SPILL(rIBASE) 3843 call dvmResolveStaticField # eax<- resolved StaticField ptr 3844 UNSPILL(rIBASE) 3845 testl %eax,%eax 3846 jne .LOP_SPUT_CHAR_finish # success, continue 3847 jmp common_exceptionThrown # no, handle exception 3848 3849 3850/* ------------------------------ */ 3851.L_OP_SPUT_SHORT: /* 0x6d */ 3852/* File: x86/OP_SPUT_SHORT.S */ 3853/* File: x86/OP_SPUT.S */ 3854 /* 3855 * General 32-bit SPUT handler. 3856 * 3857 * for: sput, sput-boolean, sput-byte, sput-char, sput-short 3858 */ 3859 /* op vAA, field@BBBB */ 3860 movl rSELF,%ecx 3861 movzwl 2(rPC),%eax # eax<- field ref BBBB 3862 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex 3863 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields 3864 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr 3865 testl %eax,%eax # resolved entry null? 3866 je .LOP_SPUT_SHORT_resolve # if not, make it so 3867.LOP_SPUT_SHORT_finish: # field ptr in eax 3868 GET_VREG_R rINST rINST 3869 FETCH_INST_OPCODE 2 %ecx 3870 ADVANCE_PC 2 3871 movl rINST,offStaticField_value(%eax) 3872 GOTO_NEXT_R %ecx 3873 3874 /* 3875 * Go resolve the field 3876 */ 3877.LOP_SPUT_SHORT_resolve: 3878 movl rSELF,%ecx 3879 movzwl 2(rPC),%eax # eax<- field ref BBBB 3880 movl offThread_method(%ecx),%ecx # ecx<- current method 3881 EXPORT_PC # could throw, need to export 3882 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 3883 movl %eax,OUT_ARG1(%esp) 3884 movl %ecx,OUT_ARG0(%esp) 3885 SPILL(rIBASE) 3886 call dvmResolveStaticField # eax<- resolved StaticField ptr 3887 UNSPILL(rIBASE) 3888 testl %eax,%eax 3889 jne .LOP_SPUT_SHORT_finish # success, continue 3890 jmp common_exceptionThrown # no, handle exception 3891 3892 3893/* ------------------------------ */ 3894.L_OP_INVOKE_VIRTUAL: /* 0x6e */ 3895/* File: x86/OP_INVOKE_VIRTUAL.S */ 3896 3897 /* 3898 * Handle a virtual method call. 3899 * 3900 * for: invoke-virtual, invoke-virtual/range 3901 */ 3902 /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ 3903 /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ 3904 movl rSELF,%eax 3905 movzwl 2(rPC),%ecx # ecx<- BBBB 3906 movl offThread_methodClassDex(%eax),%eax # eax<- pDvmDex 3907 EXPORT_PC 3908 movl offDvmDex_pResMethods(%eax),%eax # eax<- pDvmDex->pResMethods 3909 movl (%eax,%ecx,4),%eax # eax<- resolved baseMethod 3910 testl %eax,%eax # already resolved? 3911 jne .LOP_INVOKE_VIRTUAL_continue # yes, continue 3912 movl rSELF,%eax 3913 movl %ecx,OUT_ARG1(%esp) # arg1<- ref 3914 movl offThread_method(%eax),%eax # eax<- self->method 3915 movl offMethod_clazz(%eax),%eax # ecx<- method->clazz 3916 movl %eax,OUT_ARG0(%esp) # arg0<- clazz 3917 movl $METHOD_VIRTUAL,OUT_ARG2(%esp) # arg2<- flags 3918 call dvmResolveMethod # eax<- call(clazz, ref, flags) 3919 testl %eax,%eax # got null? 3920 jne .LOP_INVOKE_VIRTUAL_continue # no, continue 3921 jmp common_exceptionThrown # yes, handle exception 3922 3923 /* At this point: 3924 * eax = resolved base method 3925 * ecx = scratch 3926 */ 3927.LOP_INVOKE_VIRTUAL_continue: 3928 movzwl 4(rPC),%ecx # ecx<- GFED or CCCC 3929 .if (!0) 3930 andl $0xf,%ecx # ecx<- D (or stays CCCC) 3931 .endif 3932 GET_VREG_R %ecx %ecx # ecx<- "this" 3933 movzwl offMethod_methodIndex(%eax),%eax # eax<- baseMethod->methodIndex 3934 testl %ecx,%ecx # null this? 3935 je common_errNullObject # go if so 3936 movl offObject_clazz(%ecx),%ecx # ecx<- thisPtr->clazz 3937 movl offClassObject_vtable(%ecx),%ecx # ecx<- thisPtr->clazz->vtable 3938 movl (%ecx,%eax,4),%eax # eax<- vtable[methodIndex] 3939 jmp common_invokeMethodNoRange 3940 3941/* ------------------------------ */ 3942.L_OP_INVOKE_SUPER: /* 0x6f */ 3943/* File: x86/OP_INVOKE_SUPER.S */ 3944 /* 3945 * Handle a "super" method call. 3946 * 3947 * for: invoke-super, invoke-super/range 3948 */ 3949 /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ 3950 /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ 3951 movl rSELF,rINST 3952 movzwl 2(rPC),%eax # eax<- BBBB 3953 movl offThread_methodClassDex(rINST),%ecx # ecx<- pDvmDex 3954 EXPORT_PC 3955 movl offDvmDex_pResMethods(%ecx),%ecx # ecx<- pDvmDex->pResMethods 3956 movl (%ecx,%eax,4),%ecx # ecx<- resolved baseMethod 3957 movl offThread_method(rINST),%eax # eax<- method 3958 movzwl 4(rPC),rINST # rINST<- GFED or CCCC 3959 .if (!0) 3960 andl $0xf,rINST # rINST<- D (or stays CCCC) 3961 .endif 3962 GET_VREG_R rINST rINST # rINST<- "this" ptr 3963 testl rINST,rINST # null "this"? 3964 je common_errNullObject # yes, throw 3965 movl offMethod_clazz(%eax),%eax # eax<- method->clazz 3966 testl %ecx,%ecx # already resolved? 3967 je .LOP_INVOKE_SUPER_resolve 3968 /* 3969 * At this point: 3970 * ecx = resolved base method [r0] 3971 * eax = method->clazz [r9] 3972 */ 3973.LOP_INVOKE_SUPER_continue: 3974 movl offClassObject_super(%eax),%eax # eax<- method->clazz->super 3975 movzwl offMethod_methodIndex(%ecx),%ecx # ecx<- baseMthod->methodIndex 3976 cmpl offClassObject_vtableCount(%eax),%ecx # compare(methodIndex,vtableCount) 3977 jae .LOP_INVOKE_SUPER_nsm # method not present in superclass 3978 movl offClassObject_vtable(%eax),%eax # eax<- ...clazz->super->vtable 3979 movl (%eax,%ecx,4),%eax # eax<- vtable[methodIndex] 3980 jmp common_invokeMethodNoRange 3981 3982 3983 /* At this point: 3984 * ecx = null (needs to be resolved base method) 3985 * eax = method->clazz 3986 */ 3987.LOP_INVOKE_SUPER_resolve: 3988 SPILL_TMP1(%eax) # method->clazz 3989 movl %eax,OUT_ARG0(%esp) # arg0<- method->clazz 3990 movzwl 2(rPC),%ecx # ecx<- BBBB 3991 movl $METHOD_VIRTUAL,OUT_ARG2(%esp) # arg2<- resolver method type 3992 movl %ecx,OUT_ARG1(%esp) # arg1<- ref 3993 call dvmResolveMethod # eax<- call(clazz, ref, flags) 3994 testl %eax,%eax # got null? 3995 movl %eax,%ecx # ecx<- resolved base method 3996 UNSPILL_TMP1(%eax) # restore method->clazz 3997 jne .LOP_INVOKE_SUPER_continue # good to go - continue 3998 jmp common_exceptionThrown # handle exception 3999 4000 /* 4001 * Throw a NoSuchMethodError with the method name as the message. 4002 * ecx = resolved base method 4003 */ 4004.LOP_INVOKE_SUPER_nsm: 4005 movl offMethod_name(%ecx),%eax 4006 mov %eax,OUT_ARG1(%esp) 4007 jmp common_errNoSuchMethod 4008 4009/* ------------------------------ */ 4010.L_OP_INVOKE_DIRECT: /* 0x70 */ 4011/* File: x86/OP_INVOKE_DIRECT.S */ 4012 /* 4013 * Handle a direct method call. 4014 * 4015 * (We could defer the "is 'this' pointer null" test to the common 4016 * method invocation code, and use a flag to indicate that static 4017 * calls don't count. If we do this as part of copying the arguments 4018 * out we could avoiding loading the first arg twice.) 4019 * 4020 * for: invoke-direct, invoke-direct/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 movzwl 4(rPC),rIBASE # rIBASE<- GFED or CCCC 4030 movl (%ecx,%eax,4),%eax # eax<- resolved methodToCall 4031 .if (!0) 4032 andl $0xf,rIBASE # rIBASE<- D (or stays CCCC) 4033 .endif 4034 testl %eax,%eax # already resolved? 4035 GET_VREG_R %ecx rIBASE # ecx<- "this" ptr 4036 je .LOP_INVOKE_DIRECT_resolve # not resolved, do it now 4037.LOP_INVOKE_DIRECT_finish: 4038 testl %ecx,%ecx # null "this"? 4039 jne common_invokeMethodNoRange # no, continue on 4040 jmp common_errNullObject 4041 4042 /* 4043 * On entry: 4044 * TMP_SPILL <- "this" register 4045 * Things a bit ugly on this path, but it's the less 4046 * frequent one. We'll have to do some reloading. 4047 */ 4048.LOP_INVOKE_DIRECT_resolve: 4049 SPILL_TMP1(%ecx) 4050 movl rSELF,%ecx 4051 movl offThread_method(%ecx),%ecx # ecx<- self->method 4052 movzwl 2(rPC),%eax # reference (BBBB or CCCC) 4053 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 4054 movl $METHOD_DIRECT,OUT_ARG2(%esp) 4055 movl %eax,OUT_ARG1(%esp) 4056 movl %ecx,OUT_ARG0(%esp) 4057 call dvmResolveMethod # eax<- call(clazz, ref, flags) 4058 UNSPILL_TMP1(%ecx) 4059 testl %eax,%eax 4060 jne .LOP_INVOKE_DIRECT_finish 4061 jmp common_exceptionThrown 4062 4063/* ------------------------------ */ 4064.L_OP_INVOKE_STATIC: /* 0x71 */ 4065/* File: x86/OP_INVOKE_STATIC.S */ 4066 /* 4067 * Handle a static method call. 4068 * 4069 * for: invoke-static, invoke-static/range 4070 */ 4071 /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ 4072 /* op {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ 4073 movl rSELF,%ecx 4074 movzwl 2(rPC),%eax # eax<- BBBB 4075 movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex 4076 EXPORT_PC 4077 movl offDvmDex_pResMethods(%ecx),%ecx # ecx<- pDvmDex->pResMethods 4078 movl (%ecx,%eax,4),%eax # eax<- resolved methodToCall 4079 testl %eax,%eax 4080 jne common_invokeMethodNoRange 4081 movl rSELF,%ecx 4082 movl offThread_method(%ecx),%ecx # ecx<- self->method 4083 movzwl 2(rPC),%eax 4084 movl offMethod_clazz(%ecx),%ecx# ecx<- method->clazz 4085 movl %eax,OUT_ARG1(%esp) # arg1<- BBBB 4086 movl %ecx,OUT_ARG0(%esp) # arg0<- clazz 4087 movl $METHOD_STATIC,%eax 4088 movl %eax,OUT_ARG2(%esp) # arg2<- flags 4089 call dvmResolveMethod # call(clazz,ref,flags) 4090 testl %eax,%eax # got null? 4091 jne common_invokeMethodNoRange 4092 jmp common_exceptionThrown 4093 4094/* ------------------------------ */ 4095.L_OP_INVOKE_INTERFACE: /* 0x72 */ 4096/* File: x86/OP_INVOKE_INTERFACE.S */ 4097 /* 4098 * Handle an interface method call. 4099 * 4100 * for: invoke-interface, invoke-interface/range 4101 */ 4102 /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ 4103 /* op {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ 4104 movzwl 4(rPC),%eax # eax<- FEDC or CCCC 4105 movl rSELF,%ecx 4106 .if (!0) 4107 andl $0xf,%eax # eax<- C (or stays CCCC) 4108 .endif 4109 GET_VREG_R %eax %eax # eax<- "this" 4110 EXPORT_PC 4111 testl %eax,%eax # null this? 4112 je common_errNullObject # yes, fail 4113 movl offObject_clazz(%eax),%eax# eax<- thisPtr->clazz 4114 movl %eax,OUT_ARG0(%esp) # arg0<- class 4115 movl offThread_methodClassDex(%ecx),%eax # eax<- methodClassDex 4116 movl offThread_method(%ecx),%ecx # ecx<- method 4117 movl %eax,OUT_ARG3(%esp) # arg3<- dex 4118 movzwl 2(rPC),%eax # eax<- BBBB 4119 movl %ecx,OUT_ARG2(%esp) # arg2<- method 4120 movl %eax,OUT_ARG1(%esp) # arg1<- BBBB 4121 call dvmFindInterfaceMethodInCache # eax<- call(class, ref, method, dex) 4122 testl %eax,%eax 4123 je common_exceptionThrown 4124 jmp common_invokeMethodNoRange 4125 4126/* ------------------------------ */ 4127.L_OP_UNUSED_73: /* 0x73 */ 4128/* File: x86/OP_UNUSED_73.S */ 4129/* File: x86/unused.S */ 4130 jmp common_abort 4131 4132 4133/* ------------------------------ */ 4134.L_OP_INVOKE_VIRTUAL_RANGE: /* 0x74 */ 4135/* File: x86/OP_INVOKE_VIRTUAL_RANGE.S */ 4136/* File: x86/OP_INVOKE_VIRTUAL.S */ 4137 4138 /* 4139 * Handle a virtual method call. 4140 * 4141 * for: invoke-virtual, invoke-virtual/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,%eax 4146 movzwl 2(rPC),%ecx # ecx<- BBBB 4147 movl offThread_methodClassDex(%eax),%eax # eax<- pDvmDex 4148 EXPORT_PC 4149 movl offDvmDex_pResMethods(%eax),%eax # eax<- pDvmDex->pResMethods 4150 movl (%eax,%ecx,4),%eax # eax<- resolved baseMethod 4151 testl %eax,%eax # already resolved? 4152 jne .LOP_INVOKE_VIRTUAL_RANGE_continue # yes, continue 4153 movl rSELF,%eax 4154 movl %ecx,OUT_ARG1(%esp) # arg1<- ref 4155 movl offThread_method(%eax),%eax # eax<- self->method 4156 movl offMethod_clazz(%eax),%eax # ecx<- method->clazz 4157 movl %eax,OUT_ARG0(%esp) # arg0<- clazz 4158 movl $METHOD_VIRTUAL,OUT_ARG2(%esp) # arg2<- flags 4159 call dvmResolveMethod # eax<- call(clazz, ref, flags) 4160 testl %eax,%eax # got null? 4161 jne .LOP_INVOKE_VIRTUAL_RANGE_continue # no, continue 4162 jmp common_exceptionThrown # yes, handle exception 4163 4164 /* At this point: 4165 * eax = resolved base method 4166 * ecx = scratch 4167 */ 4168.LOP_INVOKE_VIRTUAL_RANGE_continue: 4169 movzwl 4(rPC),%ecx # ecx<- GFED or CCCC 4170 .if (!1) 4171 andl $0xf,%ecx # ecx<- D (or stays CCCC) 4172 .endif 4173 GET_VREG_R %ecx %ecx # ecx<- "this" 4174 movzwl offMethod_methodIndex(%eax),%eax # eax<- baseMethod->methodIndex 4175 testl %ecx,%ecx # null this? 4176 je common_errNullObject # go if so 4177 movl offObject_clazz(%ecx),%ecx # ecx<- thisPtr->clazz 4178 movl offClassObject_vtable(%ecx),%ecx # ecx<- thisPtr->clazz->vtable 4179 movl (%ecx,%eax,4),%eax # eax<- vtable[methodIndex] 4180 jmp common_invokeMethodRange 4181 4182 4183/* ------------------------------ */ 4184.L_OP_INVOKE_SUPER_RANGE: /* 0x75 */ 4185/* File: x86/OP_INVOKE_SUPER_RANGE.S */ 4186/* File: x86/OP_INVOKE_SUPER.S */ 4187 /* 4188 * Handle a "super" method call. 4189 * 4190 * for: invoke-super, invoke-super/range 4191 */ 4192 /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ 4193 /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ 4194 movl rSELF,rINST 4195 movzwl 2(rPC),%eax # eax<- BBBB 4196 movl offThread_methodClassDex(rINST),%ecx # ecx<- pDvmDex 4197 EXPORT_PC 4198 movl offDvmDex_pResMethods(%ecx),%ecx # ecx<- pDvmDex->pResMethods 4199 movl (%ecx,%eax,4),%ecx # ecx<- resolved baseMethod 4200 movl offThread_method(rINST),%eax # eax<- method 4201 movzwl 4(rPC),rINST # rINST<- GFED or CCCC 4202 .if (!1) 4203 andl $0xf,rINST # rINST<- D (or stays CCCC) 4204 .endif 4205 GET_VREG_R rINST rINST # rINST<- "this" ptr 4206 testl rINST,rINST # null "this"? 4207 je common_errNullObject # yes, throw 4208 movl offMethod_clazz(%eax),%eax # eax<- method->clazz 4209 testl %ecx,%ecx # already resolved? 4210 je .LOP_INVOKE_SUPER_RANGE_resolve 4211 /* 4212 * At this point: 4213 * ecx = resolved base method [r0] 4214 * eax = method->clazz [r9] 4215 */ 4216.LOP_INVOKE_SUPER_RANGE_continue: 4217 movl offClassObject_super(%eax),%eax # eax<- method->clazz->super 4218 movzwl offMethod_methodIndex(%ecx),%ecx # ecx<- baseMthod->methodIndex 4219 cmpl offClassObject_vtableCount(%eax),%ecx # compare(methodIndex,vtableCount) 4220 jae .LOP_INVOKE_SUPER_RANGE_nsm # method not present in superclass 4221 movl offClassObject_vtable(%eax),%eax # eax<- ...clazz->super->vtable 4222 movl (%eax,%ecx,4),%eax # eax<- vtable[methodIndex] 4223 jmp common_invokeMethodRange 4224 4225 4226 /* At this point: 4227 * ecx = null (needs to be resolved base method) 4228 * eax = method->clazz 4229 */ 4230.LOP_INVOKE_SUPER_RANGE_resolve: 4231 SPILL_TMP1(%eax) # method->clazz 4232 movl %eax,OUT_ARG0(%esp) # arg0<- method->clazz 4233 movzwl 2(rPC),%ecx # ecx<- BBBB 4234 movl $METHOD_VIRTUAL,OUT_ARG2(%esp) # arg2<- resolver method type 4235 movl %ecx,OUT_ARG1(%esp) # arg1<- ref 4236 call dvmResolveMethod # eax<- call(clazz, ref, flags) 4237 testl %eax,%eax # got null? 4238 movl %eax,%ecx # ecx<- resolved base method 4239 UNSPILL_TMP1(%eax) # restore method->clazz 4240 jne .LOP_INVOKE_SUPER_RANGE_continue # good to go - continue 4241 jmp common_exceptionThrown # handle exception 4242 4243 /* 4244 * Throw a NoSuchMethodError with the method name as the message. 4245 * ecx = resolved base method 4246 */ 4247.LOP_INVOKE_SUPER_RANGE_nsm: 4248 movl offMethod_name(%ecx),%eax 4249 mov %eax,OUT_ARG1(%esp) 4250 jmp common_errNoSuchMethod 4251 4252 4253/* ------------------------------ */ 4254.L_OP_INVOKE_DIRECT_RANGE: /* 0x76 */ 4255/* File: x86/OP_INVOKE_DIRECT_RANGE.S */ 4256/* File: x86/OP_INVOKE_DIRECT.S */ 4257 /* 4258 * Handle a direct method call. 4259 * 4260 * (We could defer the "is 'this' pointer null" test to the common 4261 * method invocation code, and use a flag to indicate that static 4262 * calls don't count. If we do this as part of copying the arguments 4263 * out we could avoiding loading the first arg twice.) 4264 * 4265 * for: invoke-direct, invoke-direct/range 4266 */ 4267 /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ 4268 /* op {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ 4269 movl rSELF,%ecx 4270 movzwl 2(rPC),%eax # eax<- BBBB 4271 movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex 4272 EXPORT_PC 4273 movl offDvmDex_pResMethods(%ecx),%ecx # ecx<- pDvmDex->pResMethods 4274 movzwl 4(rPC),rIBASE # rIBASE<- GFED or CCCC 4275 movl (%ecx,%eax,4),%eax # eax<- resolved methodToCall 4276 .if (!1) 4277 andl $0xf,rIBASE # rIBASE<- D (or stays CCCC) 4278 .endif 4279 testl %eax,%eax # already resolved? 4280 GET_VREG_R %ecx rIBASE # ecx<- "this" ptr 4281 je .LOP_INVOKE_DIRECT_RANGE_resolve # not resolved, do it now 4282.LOP_INVOKE_DIRECT_RANGE_finish: 4283 testl %ecx,%ecx # null "this"? 4284 jne common_invokeMethodRange # no, continue on 4285 jmp common_errNullObject 4286 4287 /* 4288 * On entry: 4289 * TMP_SPILL <- "this" register 4290 * Things a bit ugly on this path, but it's the less 4291 * frequent one. We'll have to do some reloading. 4292 */ 4293.LOP_INVOKE_DIRECT_RANGE_resolve: 4294 SPILL_TMP1(%ecx) 4295 movl rSELF,%ecx 4296 movl offThread_method(%ecx),%ecx # ecx<- self->method 4297 movzwl 2(rPC),%eax # reference (BBBB or CCCC) 4298 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 4299 movl $METHOD_DIRECT,OUT_ARG2(%esp) 4300 movl %eax,OUT_ARG1(%esp) 4301 movl %ecx,OUT_ARG0(%esp) 4302 call dvmResolveMethod # eax<- call(clazz, ref, flags) 4303 UNSPILL_TMP1(%ecx) 4304 testl %eax,%eax 4305 jne .LOP_INVOKE_DIRECT_RANGE_finish 4306 jmp common_exceptionThrown 4307 4308 4309/* ------------------------------ */ 4310.L_OP_INVOKE_STATIC_RANGE: /* 0x77 */ 4311/* File: x86/OP_INVOKE_STATIC_RANGE.S */ 4312/* File: x86/OP_INVOKE_STATIC.S */ 4313 /* 4314 * Handle a static method call. 4315 * 4316 * for: invoke-static, invoke-static/range 4317 */ 4318 /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ 4319 /* op {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ 4320 movl rSELF,%ecx 4321 movzwl 2(rPC),%eax # eax<- BBBB 4322 movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex 4323 EXPORT_PC 4324 movl offDvmDex_pResMethods(%ecx),%ecx # ecx<- pDvmDex->pResMethods 4325 movl (%ecx,%eax,4),%eax # eax<- resolved methodToCall 4326 testl %eax,%eax 4327 jne common_invokeMethodRange 4328 movl rSELF,%ecx 4329 movl offThread_method(%ecx),%ecx # ecx<- self->method 4330 movzwl 2(rPC),%eax 4331 movl offMethod_clazz(%ecx),%ecx# ecx<- method->clazz 4332 movl %eax,OUT_ARG1(%esp) # arg1<- BBBB 4333 movl %ecx,OUT_ARG0(%esp) # arg0<- clazz 4334 movl $METHOD_STATIC,%eax 4335 movl %eax,OUT_ARG2(%esp) # arg2<- flags 4336 call dvmResolveMethod # call(clazz,ref,flags) 4337 testl %eax,%eax # got null? 4338 jne common_invokeMethodRange 4339 jmp common_exceptionThrown 4340 4341 4342/* ------------------------------ */ 4343.L_OP_INVOKE_INTERFACE_RANGE: /* 0x78 */ 4344/* File: x86/OP_INVOKE_INTERFACE_RANGE.S */ 4345/* File: x86/OP_INVOKE_INTERFACE.S */ 4346 /* 4347 * Handle an interface method call. 4348 * 4349 * for: invoke-interface, invoke-interface/range 4350 */ 4351 /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ 4352 /* op {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ 4353 movzwl 4(rPC),%eax # eax<- FEDC or CCCC 4354 movl rSELF,%ecx 4355 .if (!1) 4356 andl $0xf,%eax # eax<- C (or stays CCCC) 4357 .endif 4358 GET_VREG_R %eax %eax # eax<- "this" 4359 EXPORT_PC 4360 testl %eax,%eax # null this? 4361 je common_errNullObject # yes, fail 4362 movl offObject_clazz(%eax),%eax# eax<- thisPtr->clazz 4363 movl %eax,OUT_ARG0(%esp) # arg0<- class 4364 movl offThread_methodClassDex(%ecx),%eax # eax<- methodClassDex 4365 movl offThread_method(%ecx),%ecx # ecx<- method 4366 movl %eax,OUT_ARG3(%esp) # arg3<- dex 4367 movzwl 2(rPC),%eax # eax<- BBBB 4368 movl %ecx,OUT_ARG2(%esp) # arg2<- method 4369 movl %eax,OUT_ARG1(%esp) # arg1<- BBBB 4370 call dvmFindInterfaceMethodInCache # eax<- call(class, ref, method, dex) 4371 testl %eax,%eax 4372 je common_exceptionThrown 4373 jmp common_invokeMethodRange 4374 4375 4376/* ------------------------------ */ 4377.L_OP_UNUSED_79: /* 0x79 */ 4378/* File: x86/OP_UNUSED_79.S */ 4379/* File: x86/unused.S */ 4380 jmp common_abort 4381 4382 4383/* ------------------------------ */ 4384.L_OP_UNUSED_7A: /* 0x7a */ 4385/* File: x86/OP_UNUSED_7A.S */ 4386/* File: x86/unused.S */ 4387 jmp common_abort 4388 4389 4390/* ------------------------------ */ 4391.L_OP_NEG_INT: /* 0x7b */ 4392/* File: x86/OP_NEG_INT.S */ 4393/* File: x86/unop.S */ 4394 /* 4395 * Generic 32-bit unary operation. Provide an "instr" line that 4396 * specifies an instruction that performs "result = op eax". 4397 */ 4398 /* unop vA, vB */ 4399 movzbl rINSTbl,%ecx # ecx<- A+ 4400 sarl $4,rINST # rINST<- B 4401 GET_VREG_R %eax rINST # eax<- vB 4402 andb $0xf,%cl # ecx<- A 4403 4404 4405 negl %eax 4406 SET_VREG %eax %ecx 4407 FETCH_INST_OPCODE 1 %ecx 4408 ADVANCE_PC 1 4409 GOTO_NEXT_R %ecx 4410 4411 4412/* ------------------------------ */ 4413.L_OP_NOT_INT: /* 0x7c */ 4414/* File: x86/OP_NOT_INT.S */ 4415/* File: x86/unop.S */ 4416 /* 4417 * Generic 32-bit unary operation. Provide an "instr" line that 4418 * specifies an instruction that performs "result = op eax". 4419 */ 4420 /* unop vA, vB */ 4421 movzbl rINSTbl,%ecx # ecx<- A+ 4422 sarl $4,rINST # rINST<- B 4423 GET_VREG_R %eax rINST # eax<- vB 4424 andb $0xf,%cl # ecx<- A 4425 4426 4427 notl %eax 4428 SET_VREG %eax %ecx 4429 FETCH_INST_OPCODE 1 %ecx 4430 ADVANCE_PC 1 4431 GOTO_NEXT_R %ecx 4432 4433 4434/* ------------------------------ */ 4435.L_OP_NEG_LONG: /* 0x7d */ 4436/* File: x86/OP_NEG_LONG.S */ 4437 /* unop vA, vB */ 4438 movzbl rINSTbl,%ecx # ecx<- BA 4439 sarl $4,%ecx # ecx<- B 4440 andb $0xf,rINSTbl # rINST<- A 4441 GET_VREG_WORD %eax %ecx 0 # eax<- v[B+0] 4442 GET_VREG_WORD %ecx %ecx 1 # ecx<- v[B+1] 4443 negl %eax 4444 adcl $0,%ecx 4445 negl %ecx 4446 SET_VREG_WORD %eax rINST 0 # v[A+0]<- eax 4447 FETCH_INST_OPCODE 1 %eax 4448 SET_VREG_WORD %ecx rINST 1 # v[A+1]<- ecx 4449 ADVANCE_PC 1 4450 GOTO_NEXT_R %eax 4451 4452/* ------------------------------ */ 4453.L_OP_NOT_LONG: /* 0x7e */ 4454/* File: x86/OP_NOT_LONG.S */ 4455 /* unop vA, vB */ 4456 movzbl rINSTbl,%ecx # ecx<- BA 4457 sarl $4,%ecx # ecx<- B 4458 andb $0xf,rINSTbl # rINST<- A 4459 GET_VREG_WORD %eax %ecx 0 # eax<- v[B+0] 4460 GET_VREG_WORD %ecx %ecx 1 # ecx<- v[B+1] 4461 notl %eax 4462 notl %ecx 4463 SET_VREG_WORD %eax rINST 0 # v[A+0]<- eax 4464 FETCH_INST_OPCODE 1 %eax 4465 SET_VREG_WORD %ecx rINST 1 # v[A+1]<- ecx 4466 ADVANCE_PC 1 4467 GOTO_NEXT_R %eax 4468 4469/* ------------------------------ */ 4470.L_OP_NEG_FLOAT: /* 0x7f */ 4471/* File: x86/OP_NEG_FLOAT.S */ 4472/* File: x86/fpcvt.S */ 4473 /* 4474 * Generic 32-bit FP conversion operation. 4475 */ 4476 /* unop vA, vB */ 4477 movzbl rINSTbl,%ecx # ecx<- A+ 4478 sarl $4,rINST # rINST<- B 4479 flds (rFP,rINST,4) # %st0<- vB 4480 andb $0xf,%cl # ecx<- A 4481 fchs 4482 fstps (rFP,%ecx,4) # vA<- %st0 4483 FETCH_INST_OPCODE 1 %ecx 4484 ADVANCE_PC 1 4485 GOTO_NEXT_R %ecx 4486 4487 4488/* ------------------------------ */ 4489.L_OP_NEG_DOUBLE: /* 0x80 */ 4490/* File: x86/OP_NEG_DOUBLE.S */ 4491/* File: x86/fpcvt.S */ 4492 /* 4493 * Generic 32-bit FP conversion operation. 4494 */ 4495 /* unop vA, vB */ 4496 movzbl rINSTbl,%ecx # ecx<- A+ 4497 sarl $4,rINST # rINST<- B 4498 fldl (rFP,rINST,4) # %st0<- vB 4499 andb $0xf,%cl # ecx<- A 4500 fchs 4501 fstpl (rFP,%ecx,4) # vA<- %st0 4502 FETCH_INST_OPCODE 1 %ecx 4503 ADVANCE_PC 1 4504 GOTO_NEXT_R %ecx 4505 4506 4507/* ------------------------------ */ 4508.L_OP_INT_TO_LONG: /* 0x81 */ 4509/* File: x86/OP_INT_TO_LONG.S */ 4510 /* int to long vA, vB */ 4511 movzbl rINSTbl,%eax # eax<- +A 4512 sarl $4,%eax # eax<- B 4513 GET_VREG_R %eax %eax # eax<- vB 4514 andb $0xf,rINSTbl # rINST<- A 4515 SPILL(rIBASE) # cltd trashes rIBASE/edx 4516 cltd # rINST:eax<- sssssssBBBBBBBB 4517 SET_VREG_WORD rIBASE rINST 1 # v[A+1]<- rIBASE/rPC 4518 FETCH_INST_OPCODE 1 %ecx 4519 UNSPILL(rIBASE) 4520 SET_VREG_WORD %eax rINST 0 # v[A+0]<- %eax 4521 ADVANCE_PC 1 4522 GOTO_NEXT_R %ecx 4523 4524/* ------------------------------ */ 4525.L_OP_INT_TO_FLOAT: /* 0x82 */ 4526/* File: x86/OP_INT_TO_FLOAT.S */ 4527/* File: x86/fpcvt.S */ 4528 /* 4529 * Generic 32-bit FP conversion operation. 4530 */ 4531 /* unop vA, vB */ 4532 movzbl rINSTbl,%ecx # ecx<- A+ 4533 sarl $4,rINST # rINST<- B 4534 fildl (rFP,rINST,4) # %st0<- vB 4535 andb $0xf,%cl # ecx<- A 4536 4537 fstps (rFP,%ecx,4) # vA<- %st0 4538 FETCH_INST_OPCODE 1 %ecx 4539 ADVANCE_PC 1 4540 GOTO_NEXT_R %ecx 4541 4542 4543/* ------------------------------ */ 4544.L_OP_INT_TO_DOUBLE: /* 0x83 */ 4545/* File: x86/OP_INT_TO_DOUBLE.S */ 4546/* File: x86/fpcvt.S */ 4547 /* 4548 * Generic 32-bit FP conversion operation. 4549 */ 4550 /* unop vA, vB */ 4551 movzbl rINSTbl,%ecx # ecx<- A+ 4552 sarl $4,rINST # rINST<- B 4553 fildl (rFP,rINST,4) # %st0<- vB 4554 andb $0xf,%cl # ecx<- A 4555 4556 fstpl (rFP,%ecx,4) # vA<- %st0 4557 FETCH_INST_OPCODE 1 %ecx 4558 ADVANCE_PC 1 4559 GOTO_NEXT_R %ecx 4560 4561 4562/* ------------------------------ */ 4563.L_OP_LONG_TO_INT: /* 0x84 */ 4564/* File: x86/OP_LONG_TO_INT.S */ 4565/* we ignore the high word, making this equivalent to a 32-bit reg move */ 4566/* File: x86/OP_MOVE.S */ 4567 /* for move, move-object, long-to-int */ 4568 /* op vA, vB */ 4569 movzbl rINSTbl,%eax # eax<- BA 4570 andb $0xf,%al # eax<- A 4571 shrl $4,rINST # rINST<- B 4572 GET_VREG_R rINST rINST 4573 FETCH_INST_OPCODE 1 %ecx 4574 ADVANCE_PC 1 4575 SET_VREG rINST %eax # fp[A]<-fp[B] 4576 GOTO_NEXT_R %ecx 4577 4578 4579/* ------------------------------ */ 4580.L_OP_LONG_TO_FLOAT: /* 0x85 */ 4581/* File: x86/OP_LONG_TO_FLOAT.S */ 4582/* File: x86/fpcvt.S */ 4583 /* 4584 * Generic 32-bit FP conversion operation. 4585 */ 4586 /* unop vA, vB */ 4587 movzbl rINSTbl,%ecx # ecx<- A+ 4588 sarl $4,rINST # rINST<- B 4589 fildll (rFP,rINST,4) # %st0<- vB 4590 andb $0xf,%cl # ecx<- A 4591 4592 fstps (rFP,%ecx,4) # vA<- %st0 4593 FETCH_INST_OPCODE 1 %ecx 4594 ADVANCE_PC 1 4595 GOTO_NEXT_R %ecx 4596 4597 4598/* ------------------------------ */ 4599.L_OP_LONG_TO_DOUBLE: /* 0x86 */ 4600/* File: x86/OP_LONG_TO_DOUBLE.S */ 4601/* File: x86/fpcvt.S */ 4602 /* 4603 * Generic 32-bit FP conversion operation. 4604 */ 4605 /* unop vA, vB */ 4606 movzbl rINSTbl,%ecx # ecx<- A+ 4607 sarl $4,rINST # rINST<- B 4608 fildll (rFP,rINST,4) # %st0<- vB 4609 andb $0xf,%cl # ecx<- A 4610 4611 fstpl (rFP,%ecx,4) # vA<- %st0 4612 FETCH_INST_OPCODE 1 %ecx 4613 ADVANCE_PC 1 4614 GOTO_NEXT_R %ecx 4615 4616 4617/* ------------------------------ */ 4618.L_OP_FLOAT_TO_INT: /* 0x87 */ 4619/* File: x86/OP_FLOAT_TO_INT.S */ 4620/* File: x86/cvtfp_int.S */ 4621/* On fp to int conversions, Java requires that 4622 * if the result > maxint, it should be clamped to maxint. If it is less 4623 * than minint, it should be clamped to minint. If it is a nan, the result 4624 * should be zero. Further, the rounding mode is to truncate. This model 4625 * differs from what is delivered normally via the x86 fpu, so we have 4626 * to play some games. 4627 */ 4628 /* float/double to int/long vA, vB */ 4629 movzbl rINSTbl,%ecx # ecx<- A+ 4630 sarl $4,rINST # rINST<- B 4631 .if 0 4632 fldl (rFP,rINST,4) # %st0<- vB 4633 .else 4634 flds (rFP,rINST,4) # %st0<- vB 4635 .endif 4636 ftst 4637 fnstcw LOCAL0_OFFSET(%ebp) # remember original rounding mode 4638 movzwl LOCAL0_OFFSET(%ebp),%eax 4639 movb $0xc,%ah 4640 movw %ax,LOCAL0_OFFSET+2(%ebp) 4641 fldcw LOCAL0_OFFSET+2(%ebp) # set "to zero" rounding mode 4642 andb $0xf,%cl # ecx<- A 4643 .if 0 4644 fistpll (rFP,%ecx,4) # convert and store 4645 .else 4646 fistpl (rFP,%ecx,4) # convert and store 4647 .endif 4648 fldcw LOCAL0_OFFSET(%ebp) # restore previous rounding mode 4649 .if 0 4650 movl $0x80000000,%eax 4651 xorl 4(rFP,%ecx,4),%eax 4652 orl (rFP,%ecx,4),%eax 4653 .else 4654 cmpl $0x80000000,(rFP,%ecx,4) 4655 .endif 4656 je .LOP_FLOAT_TO_INT_special_case # fix up result 4657 4658.LOP_FLOAT_TO_INT_finish: 4659 FETCH_INST_OPCODE 1 %ecx 4660 ADVANCE_PC 1 4661 GOTO_NEXT_R %ecx 4662 4663.LOP_FLOAT_TO_INT_special_case: 4664 fnstsw %ax 4665 sahf 4666 jp .LOP_FLOAT_TO_INT_isNaN 4667 adcl $-1,(rFP,%ecx,4) 4668 .if 0 4669 adcl $-1,4(rFP,%ecx,4) 4670 .endif 4671 jmp .LOP_FLOAT_TO_INT_finish 4672.LOP_FLOAT_TO_INT_isNaN: 4673 movl $0,(rFP,%ecx,4) 4674 .if 0 4675 movl $0,4(rFP,%ecx,4) 4676 .endif 4677 jmp .LOP_FLOAT_TO_INT_finish 4678 4679 4680/* ------------------------------ */ 4681.L_OP_FLOAT_TO_LONG: /* 0x88 */ 4682/* File: x86/OP_FLOAT_TO_LONG.S */ 4683/* File: x86/cvtfp_int.S */ 4684/* On fp to int conversions, Java requires that 4685 * if the result > maxint, it should be clamped to maxint. If it is less 4686 * than minint, it should be clamped to minint. If it is a nan, the result 4687 * should be zero. Further, the rounding mode is to truncate. This model 4688 * differs from what is delivered normally via the x86 fpu, so we have 4689 * to play some games. 4690 */ 4691 /* float/double to int/long vA, vB */ 4692 movzbl rINSTbl,%ecx # ecx<- A+ 4693 sarl $4,rINST # rINST<- B 4694 .if 0 4695 fldl (rFP,rINST,4) # %st0<- vB 4696 .else 4697 flds (rFP,rINST,4) # %st0<- vB 4698 .endif 4699 ftst 4700 fnstcw LOCAL0_OFFSET(%ebp) # remember original rounding mode 4701 movzwl LOCAL0_OFFSET(%ebp),%eax 4702 movb $0xc,%ah 4703 movw %ax,LOCAL0_OFFSET+2(%ebp) 4704 fldcw LOCAL0_OFFSET+2(%ebp) # set "to zero" rounding mode 4705 andb $0xf,%cl # ecx<- A 4706 .if 1 4707 fistpll (rFP,%ecx,4) # convert and store 4708 .else 4709 fistpl (rFP,%ecx,4) # convert and store 4710 .endif 4711 fldcw LOCAL0_OFFSET(%ebp) # restore previous rounding mode 4712 .if 1 4713 movl $0x80000000,%eax 4714 xorl 4(rFP,%ecx,4),%eax 4715 orl (rFP,%ecx,4),%eax 4716 .else 4717 cmpl $0x80000000,(rFP,%ecx,4) 4718 .endif 4719 je .LOP_FLOAT_TO_LONG_special_case # fix up result 4720 4721.LOP_FLOAT_TO_LONG_finish: 4722 FETCH_INST_OPCODE 1 %ecx 4723 ADVANCE_PC 1 4724 GOTO_NEXT_R %ecx 4725 4726.LOP_FLOAT_TO_LONG_special_case: 4727 fnstsw %ax 4728 sahf 4729 jp .LOP_FLOAT_TO_LONG_isNaN 4730 adcl $-1,(rFP,%ecx,4) 4731 .if 1 4732 adcl $-1,4(rFP,%ecx,4) 4733 .endif 4734 jmp .LOP_FLOAT_TO_LONG_finish 4735.LOP_FLOAT_TO_LONG_isNaN: 4736 movl $0,(rFP,%ecx,4) 4737 .if 1 4738 movl $0,4(rFP,%ecx,4) 4739 .endif 4740 jmp .LOP_FLOAT_TO_LONG_finish 4741 4742 4743/* ------------------------------ */ 4744.L_OP_FLOAT_TO_DOUBLE: /* 0x89 */ 4745/* File: x86/OP_FLOAT_TO_DOUBLE.S */ 4746/* File: x86/fpcvt.S */ 4747 /* 4748 * Generic 32-bit FP conversion operation. 4749 */ 4750 /* unop vA, vB */ 4751 movzbl rINSTbl,%ecx # ecx<- A+ 4752 sarl $4,rINST # rINST<- B 4753 flds (rFP,rINST,4) # %st0<- vB 4754 andb $0xf,%cl # ecx<- A 4755 4756 fstpl (rFP,%ecx,4) # vA<- %st0 4757 FETCH_INST_OPCODE 1 %ecx 4758 ADVANCE_PC 1 4759 GOTO_NEXT_R %ecx 4760 4761 4762/* ------------------------------ */ 4763.L_OP_DOUBLE_TO_INT: /* 0x8a */ 4764/* File: x86/OP_DOUBLE_TO_INT.S */ 4765/* File: x86/cvtfp_int.S */ 4766/* On fp to int conversions, Java requires that 4767 * if the result > maxint, it should be clamped to maxint. If it is less 4768 * than minint, it should be clamped to minint. If it is a nan, the result 4769 * should be zero. Further, the rounding mode is to truncate. This model 4770 * differs from what is delivered normally via the x86 fpu, so we have 4771 * to play some games. 4772 */ 4773 /* float/double to int/long vA, vB */ 4774 movzbl rINSTbl,%ecx # ecx<- A+ 4775 sarl $4,rINST # rINST<- B 4776 .if 1 4777 fldl (rFP,rINST,4) # %st0<- vB 4778 .else 4779 flds (rFP,rINST,4) # %st0<- vB 4780 .endif 4781 ftst 4782 fnstcw LOCAL0_OFFSET(%ebp) # remember original rounding mode 4783 movzwl LOCAL0_OFFSET(%ebp),%eax 4784 movb $0xc,%ah 4785 movw %ax,LOCAL0_OFFSET+2(%ebp) 4786 fldcw LOCAL0_OFFSET+2(%ebp) # set "to zero" rounding mode 4787 andb $0xf,%cl # ecx<- A 4788 .if 0 4789 fistpll (rFP,%ecx,4) # convert and store 4790 .else 4791 fistpl (rFP,%ecx,4) # convert and store 4792 .endif 4793 fldcw LOCAL0_OFFSET(%ebp) # restore previous rounding mode 4794 .if 0 4795 movl $0x80000000,%eax 4796 xorl 4(rFP,%ecx,4),%eax 4797 orl (rFP,%ecx,4),%eax 4798 .else 4799 cmpl $0x80000000,(rFP,%ecx,4) 4800 .endif 4801 je .LOP_DOUBLE_TO_INT_special_case # fix up result 4802 4803.LOP_DOUBLE_TO_INT_finish: 4804 FETCH_INST_OPCODE 1 %ecx 4805 ADVANCE_PC 1 4806 GOTO_NEXT_R %ecx 4807 4808.LOP_DOUBLE_TO_INT_special_case: 4809 fnstsw %ax 4810 sahf 4811 jp .LOP_DOUBLE_TO_INT_isNaN 4812 adcl $-1,(rFP,%ecx,4) 4813 .if 0 4814 adcl $-1,4(rFP,%ecx,4) 4815 .endif 4816 jmp .LOP_DOUBLE_TO_INT_finish 4817.LOP_DOUBLE_TO_INT_isNaN: 4818 movl $0,(rFP,%ecx,4) 4819 .if 0 4820 movl $0,4(rFP,%ecx,4) 4821 .endif 4822 jmp .LOP_DOUBLE_TO_INT_finish 4823 4824 4825/* ------------------------------ */ 4826.L_OP_DOUBLE_TO_LONG: /* 0x8b */ 4827/* File: x86/OP_DOUBLE_TO_LONG.S */ 4828/* File: x86/cvtfp_int.S */ 4829/* On fp to int conversions, Java requires that 4830 * if the result > maxint, it should be clamped to maxint. If it is less 4831 * than minint, it should be clamped to minint. If it is a nan, the result 4832 * should be zero. Further, the rounding mode is to truncate. This model 4833 * differs from what is delivered normally via the x86 fpu, so we have 4834 * to play some games. 4835 */ 4836 /* float/double to int/long vA, vB */ 4837 movzbl rINSTbl,%ecx # ecx<- A+ 4838 sarl $4,rINST # rINST<- B 4839 .if 1 4840 fldl (rFP,rINST,4) # %st0<- vB 4841 .else 4842 flds (rFP,rINST,4) # %st0<- vB 4843 .endif 4844 ftst 4845 fnstcw LOCAL0_OFFSET(%ebp) # remember original rounding mode 4846 movzwl LOCAL0_OFFSET(%ebp),%eax 4847 movb $0xc,%ah 4848 movw %ax,LOCAL0_OFFSET+2(%ebp) 4849 fldcw LOCAL0_OFFSET+2(%ebp) # set "to zero" rounding mode 4850 andb $0xf,%cl # ecx<- A 4851 .if 1 4852 fistpll (rFP,%ecx,4) # convert and store 4853 .else 4854 fistpl (rFP,%ecx,4) # convert and store 4855 .endif 4856 fldcw LOCAL0_OFFSET(%ebp) # restore previous rounding mode 4857 .if 1 4858 movl $0x80000000,%eax 4859 xorl 4(rFP,%ecx,4),%eax 4860 orl (rFP,%ecx,4),%eax 4861 .else 4862 cmpl $0x80000000,(rFP,%ecx,4) 4863 .endif 4864 je .LOP_DOUBLE_TO_LONG_special_case # fix up result 4865 4866.LOP_DOUBLE_TO_LONG_finish: 4867 FETCH_INST_OPCODE 1 %ecx 4868 ADVANCE_PC 1 4869 GOTO_NEXT_R %ecx 4870 4871.LOP_DOUBLE_TO_LONG_special_case: 4872 fnstsw %ax 4873 sahf 4874 jp .LOP_DOUBLE_TO_LONG_isNaN 4875 adcl $-1,(rFP,%ecx,4) 4876 .if 1 4877 adcl $-1,4(rFP,%ecx,4) 4878 .endif 4879 jmp .LOP_DOUBLE_TO_LONG_finish 4880.LOP_DOUBLE_TO_LONG_isNaN: 4881 movl $0,(rFP,%ecx,4) 4882 .if 1 4883 movl $0,4(rFP,%ecx,4) 4884 .endif 4885 jmp .LOP_DOUBLE_TO_LONG_finish 4886 4887 4888/* ------------------------------ */ 4889.L_OP_DOUBLE_TO_FLOAT: /* 0x8c */ 4890/* File: x86/OP_DOUBLE_TO_FLOAT.S */ 4891/* File: x86/fpcvt.S */ 4892 /* 4893 * Generic 32-bit FP conversion operation. 4894 */ 4895 /* unop vA, vB */ 4896 movzbl rINSTbl,%ecx # ecx<- A+ 4897 sarl $4,rINST # rINST<- B 4898 fldl (rFP,rINST,4) # %st0<- vB 4899 andb $0xf,%cl # ecx<- A 4900 4901 fstps (rFP,%ecx,4) # vA<- %st0 4902 FETCH_INST_OPCODE 1 %ecx 4903 ADVANCE_PC 1 4904 GOTO_NEXT_R %ecx 4905 4906 4907/* ------------------------------ */ 4908.L_OP_INT_TO_BYTE: /* 0x8d */ 4909/* File: x86/OP_INT_TO_BYTE.S */ 4910/* File: x86/unop.S */ 4911 /* 4912 * Generic 32-bit unary operation. Provide an "instr" line that 4913 * specifies an instruction that performs "result = op eax". 4914 */ 4915 /* unop vA, vB */ 4916 movzbl rINSTbl,%ecx # ecx<- A+ 4917 sarl $4,rINST # rINST<- B 4918 GET_VREG_R %eax rINST # eax<- vB 4919 andb $0xf,%cl # ecx<- A 4920 4921 4922 movsbl %al,%eax 4923 SET_VREG %eax %ecx 4924 FETCH_INST_OPCODE 1 %ecx 4925 ADVANCE_PC 1 4926 GOTO_NEXT_R %ecx 4927 4928 4929/* ------------------------------ */ 4930.L_OP_INT_TO_CHAR: /* 0x8e */ 4931/* File: x86/OP_INT_TO_CHAR.S */ 4932/* File: x86/unop.S */ 4933 /* 4934 * Generic 32-bit unary operation. Provide an "instr" line that 4935 * specifies an instruction that performs "result = op eax". 4936 */ 4937 /* unop vA, vB */ 4938 movzbl rINSTbl,%ecx # ecx<- A+ 4939 sarl $4,rINST # rINST<- B 4940 GET_VREG_R %eax rINST # eax<- vB 4941 andb $0xf,%cl # ecx<- A 4942 4943 4944 movzwl %ax,%eax 4945 SET_VREG %eax %ecx 4946 FETCH_INST_OPCODE 1 %ecx 4947 ADVANCE_PC 1 4948 GOTO_NEXT_R %ecx 4949 4950 4951/* ------------------------------ */ 4952.L_OP_INT_TO_SHORT: /* 0x8f */ 4953/* File: x86/OP_INT_TO_SHORT.S */ 4954/* File: x86/unop.S */ 4955 /* 4956 * Generic 32-bit unary operation. Provide an "instr" line that 4957 * specifies an instruction that performs "result = op eax". 4958 */ 4959 /* unop vA, vB */ 4960 movzbl rINSTbl,%ecx # ecx<- A+ 4961 sarl $4,rINST # rINST<- B 4962 GET_VREG_R %eax rINST # eax<- vB 4963 andb $0xf,%cl # ecx<- A 4964 4965 4966 movswl %ax,%eax 4967 SET_VREG %eax %ecx 4968 FETCH_INST_OPCODE 1 %ecx 4969 ADVANCE_PC 1 4970 GOTO_NEXT_R %ecx 4971 4972 4973/* ------------------------------ */ 4974.L_OP_ADD_INT: /* 0x90 */ 4975/* File: x86/OP_ADD_INT.S */ 4976/* File: x86/binop.S */ 4977 /* 4978 * Generic 32-bit binary operation. Provide an "instr" line that 4979 * specifies an instruction that performs "result = eax op (rFP,%ecx,4)". 4980 * This could be an x86 instruction or a function call. (If the result 4981 * comes back in a register other than eax, you can override "result".) 4982 * 4983 * For: add-int, sub-int, and-int, or-int, 4984 * xor-int, shl-int, shr-int, ushr-int 4985 */ 4986 /* binop vAA, vBB, vCC */ 4987 movzbl 2(rPC),%eax # eax<- BB 4988 movzbl 3(rPC),%ecx # ecx<- CC 4989 GET_VREG_R %eax %eax # eax<- vBB 4990 addl (rFP,%ecx,4),%eax # ex: addl (rFP,%ecx,4),%eax 4991 SET_VREG %eax rINST 4992 FETCH_INST_OPCODE 2 %ecx 4993 ADVANCE_PC 2 4994 GOTO_NEXT_R %ecx 4995 4996 4997/* ------------------------------ */ 4998.L_OP_SUB_INT: /* 0x91 */ 4999/* File: x86/OP_SUB_INT.S */ 5000/* File: x86/binop.S */ 5001 /* 5002 * Generic 32-bit binary operation. Provide an "instr" line that 5003 * specifies an instruction that performs "result = eax op (rFP,%ecx,4)". 5004 * This could be an x86 instruction or a function call. (If the result 5005 * comes back in a register other than eax, you can override "result".) 5006 * 5007 * For: add-int, sub-int, and-int, or-int, 5008 * xor-int, shl-int, shr-int, ushr-int 5009 */ 5010 /* binop vAA, vBB, vCC */ 5011 movzbl 2(rPC),%eax # eax<- BB 5012 movzbl 3(rPC),%ecx # ecx<- CC 5013 GET_VREG_R %eax %eax # eax<- vBB 5014 subl (rFP,%ecx,4),%eax # ex: addl (rFP,%ecx,4),%eax 5015 SET_VREG %eax rINST 5016 FETCH_INST_OPCODE 2 %ecx 5017 ADVANCE_PC 2 5018 GOTO_NEXT_R %ecx 5019 5020 5021/* ------------------------------ */ 5022.L_OP_MUL_INT: /* 0x92 */ 5023/* File: x86/OP_MUL_INT.S */ 5024 /* 5025 * 32-bit binary multiplication. 5026 */ 5027 /* mul vAA, vBB, vCC */ 5028 movzbl 2(rPC),%eax # eax<- BB 5029 movzbl 3(rPC),%ecx # ecx<- CC 5030 GET_VREG_R %eax %eax # eax<- vBB 5031 SPILL(rIBASE) 5032 imull (rFP,%ecx,4),%eax # trashes rIBASE/edx 5033 UNSPILL(rIBASE) 5034 FETCH_INST_OPCODE 2 %ecx 5035 ADVANCE_PC 2 5036 SET_VREG %eax rINST 5037 GOTO_NEXT_R %ecx 5038 5039/* ------------------------------ */ 5040.L_OP_DIV_INT: /* 0x93 */ 5041/* File: x86/OP_DIV_INT.S */ 5042/* File: x86/bindiv.S */ 5043 5044 /* 5045 * 32-bit binary div/rem operation. Handles special case of op0=minint and 5046 * op1=-1. 5047 */ 5048 /* binop vAA, vBB, vCC */ 5049 movzbl 2(rPC),%eax # eax<- BB 5050 movzbl 3(rPC),%ecx # ecx<- CC 5051 GET_VREG_R %eax %eax # eax<- vBB 5052 GET_VREG_R %ecx %ecx # eax<- vBB 5053 SPILL(rIBASE) 5054 cmpl $0,%ecx 5055 je common_errDivideByZero 5056 cmpl $-1,%ecx 5057 jne .LOP_DIV_INT_continue_div 5058 cmpl $0x80000000,%eax 5059 jne .LOP_DIV_INT_continue_div 5060 movl $0x80000000,%eax 5061 SET_VREG %eax rINST 5062 UNSPILL(rIBASE) 5063 FETCH_INST_OPCODE 2 %ecx 5064 ADVANCE_PC 2 5065 GOTO_NEXT_R %ecx 5066 5067.LOP_DIV_INT_continue_div: 5068 cltd 5069 idivl %ecx 5070 SET_VREG %eax rINST 5071 UNSPILL(rIBASE) 5072 FETCH_INST_OPCODE 2 %ecx 5073 ADVANCE_PC 2 5074 GOTO_NEXT_R %ecx 5075 5076 5077/* ------------------------------ */ 5078.L_OP_REM_INT: /* 0x94 */ 5079/* File: x86/OP_REM_INT.S */ 5080/* File: x86/bindiv.S */ 5081 5082 /* 5083 * 32-bit binary div/rem operation. Handles special case of op0=minint and 5084 * op1=-1. 5085 */ 5086 /* binop vAA, vBB, vCC */ 5087 movzbl 2(rPC),%eax # eax<- BB 5088 movzbl 3(rPC),%ecx # ecx<- CC 5089 GET_VREG_R %eax %eax # eax<- vBB 5090 GET_VREG_R %ecx %ecx # eax<- vBB 5091 SPILL(rIBASE) 5092 cmpl $0,%ecx 5093 je common_errDivideByZero 5094 cmpl $-1,%ecx 5095 jne .LOP_REM_INT_continue_div 5096 cmpl $0x80000000,%eax 5097 jne .LOP_REM_INT_continue_div 5098 movl $0,rIBASE 5099 SET_VREG rIBASE rINST 5100 UNSPILL(rIBASE) 5101 FETCH_INST_OPCODE 2 %ecx 5102 ADVANCE_PC 2 5103 GOTO_NEXT_R %ecx 5104 5105.LOP_REM_INT_continue_div: 5106 cltd 5107 idivl %ecx 5108 SET_VREG rIBASE rINST 5109 UNSPILL(rIBASE) 5110 FETCH_INST_OPCODE 2 %ecx 5111 ADVANCE_PC 2 5112 GOTO_NEXT_R %ecx 5113 5114 5115/* ------------------------------ */ 5116.L_OP_AND_INT: /* 0x95 */ 5117/* File: x86/OP_AND_INT.S */ 5118/* File: x86/binop.S */ 5119 /* 5120 * Generic 32-bit binary operation. Provide an "instr" line that 5121 * specifies an instruction that performs "result = eax op (rFP,%ecx,4)". 5122 * This could be an x86 instruction or a function call. (If the result 5123 * comes back in a register other than eax, you can override "result".) 5124 * 5125 * For: add-int, sub-int, and-int, or-int, 5126 * xor-int, shl-int, shr-int, ushr-int 5127 */ 5128 /* binop vAA, vBB, vCC */ 5129 movzbl 2(rPC),%eax # eax<- BB 5130 movzbl 3(rPC),%ecx # ecx<- CC 5131 GET_VREG_R %eax %eax # eax<- vBB 5132 andl (rFP,%ecx,4),%eax # ex: addl (rFP,%ecx,4),%eax 5133 SET_VREG %eax rINST 5134 FETCH_INST_OPCODE 2 %ecx 5135 ADVANCE_PC 2 5136 GOTO_NEXT_R %ecx 5137 5138 5139/* ------------------------------ */ 5140.L_OP_OR_INT: /* 0x96 */ 5141/* File: x86/OP_OR_INT.S */ 5142/* File: x86/binop.S */ 5143 /* 5144 * Generic 32-bit binary operation. Provide an "instr" line that 5145 * specifies an instruction that performs "result = eax op (rFP,%ecx,4)". 5146 * This could be an x86 instruction or a function call. (If the result 5147 * comes back in a register other than eax, you can override "result".) 5148 * 5149 * For: add-int, sub-int, and-int, or-int, 5150 * xor-int, shl-int, shr-int, ushr-int 5151 */ 5152 /* binop vAA, vBB, vCC */ 5153 movzbl 2(rPC),%eax # eax<- BB 5154 movzbl 3(rPC),%ecx # ecx<- CC 5155 GET_VREG_R %eax %eax # eax<- vBB 5156 orl (rFP,%ecx,4),%eax # ex: addl (rFP,%ecx,4),%eax 5157 SET_VREG %eax rINST 5158 FETCH_INST_OPCODE 2 %ecx 5159 ADVANCE_PC 2 5160 GOTO_NEXT_R %ecx 5161 5162 5163/* ------------------------------ */ 5164.L_OP_XOR_INT: /* 0x97 */ 5165/* File: x86/OP_XOR_INT.S */ 5166/* File: x86/binop.S */ 5167 /* 5168 * Generic 32-bit binary operation. Provide an "instr" line that 5169 * specifies an instruction that performs "result = eax op (rFP,%ecx,4)". 5170 * This could be an x86 instruction or a function call. (If the result 5171 * comes back in a register other than eax, you can override "result".) 5172 * 5173 * For: add-int, sub-int, and-int, or-int, 5174 * xor-int, shl-int, shr-int, ushr-int 5175 */ 5176 /* binop vAA, vBB, vCC */ 5177 movzbl 2(rPC),%eax # eax<- BB 5178 movzbl 3(rPC),%ecx # ecx<- CC 5179 GET_VREG_R %eax %eax # eax<- vBB 5180 xorl (rFP,%ecx,4),%eax # ex: addl (rFP,%ecx,4),%eax 5181 SET_VREG %eax rINST 5182 FETCH_INST_OPCODE 2 %ecx 5183 ADVANCE_PC 2 5184 GOTO_NEXT_R %ecx 5185 5186 5187/* ------------------------------ */ 5188.L_OP_SHL_INT: /* 0x98 */ 5189/* File: x86/OP_SHL_INT.S */ 5190/* File: x86/binop1.S */ 5191 /* 5192 * Generic 32-bit binary operation in which both operands loaded to 5193 * registers (op0 in eax, op1 in ecx). 5194 */ 5195 /* binop vAA, vBB, vCC */ 5196 movzbl 2(rPC),%eax # eax<- BB 5197 movzbl 3(rPC),%ecx # ecx<- CC 5198 GET_VREG_R %eax %eax # eax<- vBB 5199 GET_VREG_R %ecx %ecx # eax<- vBB 5200 sall %cl,%eax # ex: addl %ecx,%eax 5201 SET_VREG %eax rINST 5202 FETCH_INST_OPCODE 2 %ecx 5203 ADVANCE_PC 2 5204 GOTO_NEXT_R %ecx 5205 5206 5207/* ------------------------------ */ 5208.L_OP_SHR_INT: /* 0x99 */ 5209/* File: x86/OP_SHR_INT.S */ 5210/* File: x86/binop1.S */ 5211 /* 5212 * Generic 32-bit binary operation in which both operands loaded to 5213 * registers (op0 in eax, op1 in ecx). 5214 */ 5215 /* binop vAA, vBB, vCC */ 5216 movzbl 2(rPC),%eax # eax<- BB 5217 movzbl 3(rPC),%ecx # ecx<- CC 5218 GET_VREG_R %eax %eax # eax<- vBB 5219 GET_VREG_R %ecx %ecx # eax<- vBB 5220 sarl %cl,%eax # ex: addl %ecx,%eax 5221 SET_VREG %eax rINST 5222 FETCH_INST_OPCODE 2 %ecx 5223 ADVANCE_PC 2 5224 GOTO_NEXT_R %ecx 5225 5226 5227/* ------------------------------ */ 5228.L_OP_USHR_INT: /* 0x9a */ 5229/* File: x86/OP_USHR_INT.S */ 5230/* File: x86/binop1.S */ 5231 /* 5232 * Generic 32-bit binary operation in which both operands loaded to 5233 * registers (op0 in eax, op1 in ecx). 5234 */ 5235 /* binop vAA, vBB, vCC */ 5236 movzbl 2(rPC),%eax # eax<- BB 5237 movzbl 3(rPC),%ecx # ecx<- CC 5238 GET_VREG_R %eax %eax # eax<- vBB 5239 GET_VREG_R %ecx %ecx # eax<- vBB 5240 shrl %cl,%eax # ex: addl %ecx,%eax 5241 SET_VREG %eax rINST 5242 FETCH_INST_OPCODE 2 %ecx 5243 ADVANCE_PC 2 5244 GOTO_NEXT_R %ecx 5245 5246 5247/* ------------------------------ */ 5248.L_OP_ADD_LONG: /* 0x9b */ 5249/* File: x86/OP_ADD_LONG.S */ 5250/* File: x86/binopWide.S */ 5251 /* 5252 * Generic 64-bit binary operation. 5253 */ 5254 /* binop vAA, vBB, vCC */ 5255 5256 movzbl 2(rPC),%eax # eax<- BB 5257 movzbl 3(rPC),%ecx # ecx<- CC 5258 SPILL(rIBASE) # save rIBASE 5259 GET_VREG_WORD rIBASE %eax 0 # rIBASE<- v[BB+0] 5260 GET_VREG_WORD %eax %eax 1 # eax<- v[BB+1] 5261 addl (rFP,%ecx,4),rIBASE # ex: addl (rFP,%ecx,4),rIBASE 5262 adcl 4(rFP,%ecx,4),%eax # ex: adcl 4(rFP,%ecx,4),%eax 5263 SET_VREG_WORD rIBASE rINST 0 # v[AA+0] <- rIBASE 5264 FETCH_INST_OPCODE 2 %ecx 5265 UNSPILL(rIBASE) # restore rIBASE 5266 SET_VREG_WORD %eax rINST 1 # v[AA+1] <- eax 5267 ADVANCE_PC 2 5268 GOTO_NEXT_R %ecx 5269 5270 5271/* ------------------------------ */ 5272.L_OP_SUB_LONG: /* 0x9c */ 5273/* File: x86/OP_SUB_LONG.S */ 5274/* File: x86/binopWide.S */ 5275 /* 5276 * Generic 64-bit binary operation. 5277 */ 5278 /* binop vAA, vBB, vCC */ 5279 5280 movzbl 2(rPC),%eax # eax<- BB 5281 movzbl 3(rPC),%ecx # ecx<- CC 5282 SPILL(rIBASE) # save rIBASE 5283 GET_VREG_WORD rIBASE %eax 0 # rIBASE<- v[BB+0] 5284 GET_VREG_WORD %eax %eax 1 # eax<- v[BB+1] 5285 subl (rFP,%ecx,4),rIBASE # ex: addl (rFP,%ecx,4),rIBASE 5286 sbbl 4(rFP,%ecx,4),%eax # ex: adcl 4(rFP,%ecx,4),%eax 5287 SET_VREG_WORD rIBASE rINST 0 # v[AA+0] <- rIBASE 5288 FETCH_INST_OPCODE 2 %ecx 5289 UNSPILL(rIBASE) # restore rIBASE 5290 SET_VREG_WORD %eax rINST 1 # v[AA+1] <- eax 5291 ADVANCE_PC 2 5292 GOTO_NEXT_R %ecx 5293 5294 5295/* ------------------------------ */ 5296.L_OP_MUL_LONG: /* 0x9d */ 5297/* File: x86/OP_MUL_LONG.S */ 5298 /* 5299 * Signed 64-bit integer multiply. 5300 * 5301 * We could definately use more free registers for 5302 * this code. We spill rINSTw (ebx), 5303 * giving us eax, ebc, ecx and edx as computational 5304 * temps. On top of that, we'll spill edi (rFP) 5305 * for use as the vB pointer and esi (rPC) for use 5306 * as the vC pointer. Yuck. 5307 */ 5308 /* mul-long vAA, vBB, vCC */ 5309 movzbl 2(rPC),%eax # eax<- B 5310 movzbl 3(rPC),%ecx # ecx<- C 5311 SPILL_TMP2(%esi) # save Dalvik PC 5312 SPILL(rFP) 5313 SPILL(rINST) 5314 SPILL(rIBASE) 5315 leal (rFP,%eax,4),%esi # esi<- &v[B] 5316 leal (rFP,%ecx,4),rFP # rFP<- &v[C] 5317 movl 4(%esi),%ecx # ecx<- Bmsw 5318 imull (rFP),%ecx # ecx<- (Bmsw*Clsw) 5319 movl 4(rFP),%eax # eax<- Cmsw 5320 imull (%esi),%eax # eax<- (Cmsw*Blsw) 5321 addl %eax,%ecx # ecx<- (Bmsw*Clsw)+(Cmsw*Blsw) 5322 movl (rFP),%eax # eax<- Clsw 5323 mull (%esi) # eax<- (Clsw*Alsw) 5324 UNSPILL(rINST) 5325 UNSPILL(rFP) 5326 leal (%ecx,rIBASE),rIBASE # full result now in rIBASE:%eax 5327 UNSPILL_TMP2(%esi) # Restore Dalvik PC 5328 FETCH_INST_OPCODE 2 %ecx # Fetch next instruction 5329 movl rIBASE,4(rFP,rINST,4)# v[B+1]<- rIBASE 5330 UNSPILL(rIBASE) 5331 movl %eax,(rFP,rINST,4) # v[B]<- %eax 5332 ADVANCE_PC 2 5333 GOTO_NEXT_R %ecx 5334 5335/* ------------------------------ */ 5336.L_OP_DIV_LONG: /* 0x9e */ 5337/* File: x86/OP_DIV_LONG.S */ 5338 /* div vAA, vBB, vCC */ 5339 movzbl 3(rPC),%eax # eax<- CC 5340 movzbl 2(rPC),%ecx # ecx<- BB 5341 SPILL(rIBASE) # save rIBASE/%edx 5342 GET_VREG_WORD rIBASE %eax 0 5343 GET_VREG_WORD %eax %eax 1 5344 movl rIBASE,OUT_ARG2(%esp) 5345 testl %eax,%eax 5346 je .LOP_DIV_LONG_check_zero 5347 cmpl $-1,%eax 5348 je .LOP_DIV_LONG_check_neg1 5349.LOP_DIV_LONG_notSpecial: 5350 GET_VREG_WORD rIBASE %ecx 0 5351 GET_VREG_WORD %ecx %ecx 1 5352.LOP_DIV_LONG_notSpecial1: 5353 movl %eax,OUT_ARG3(%esp) 5354 movl rIBASE,OUT_ARG0(%esp) 5355 movl %ecx,OUT_ARG1(%esp) 5356 call __divdi3 5357.LOP_DIV_LONG_finish: 5358 SET_VREG_WORD rIBASE rINST 1 5359 UNSPILL(rIBASE) # restore rIBASE/%edx 5360 SET_VREG_WORD %eax rINST 0 5361 FETCH_INST_OPCODE 2 %ecx 5362 ADVANCE_PC 2 5363 GOTO_NEXT_R %ecx 5364 5365.LOP_DIV_LONG_check_zero: 5366 testl rIBASE,rIBASE 5367 jne .LOP_DIV_LONG_notSpecial 5368 jmp common_errDivideByZero 5369.LOP_DIV_LONG_check_neg1: 5370 testl rIBASE,%eax 5371 jne .LOP_DIV_LONG_notSpecial 5372 GET_VREG_WORD rIBASE %ecx 0 5373 GET_VREG_WORD %ecx %ecx 1 5374 testl rIBASE,rIBASE 5375 jne .LOP_DIV_LONG_notSpecial1 5376 cmpl $0x80000000,%ecx 5377 jne .LOP_DIV_LONG_notSpecial1 5378 /* minint / -1, return minint on div, 0 on rem */ 5379 xorl %eax,%eax 5380 movl $0x80000000,rIBASE 5381 jmp .LOP_DIV_LONG_finish 5382 5383/* ------------------------------ */ 5384.L_OP_REM_LONG: /* 0x9f */ 5385/* File: x86/OP_REM_LONG.S */ 5386/* File: x86/OP_DIV_LONG.S */ 5387 /* div vAA, vBB, vCC */ 5388 movzbl 3(rPC),%eax # eax<- CC 5389 movzbl 2(rPC),%ecx # ecx<- BB 5390 SPILL(rIBASE) # save rIBASE/%edx 5391 GET_VREG_WORD rIBASE %eax 0 5392 GET_VREG_WORD %eax %eax 1 5393 movl rIBASE,OUT_ARG2(%esp) 5394 testl %eax,%eax 5395 je .LOP_REM_LONG_check_zero 5396 cmpl $-1,%eax 5397 je .LOP_REM_LONG_check_neg1 5398.LOP_REM_LONG_notSpecial: 5399 GET_VREG_WORD rIBASE %ecx 0 5400 GET_VREG_WORD %ecx %ecx 1 5401.LOP_REM_LONG_notSpecial1: 5402 movl %eax,OUT_ARG3(%esp) 5403 movl rIBASE,OUT_ARG0(%esp) 5404 movl %ecx,OUT_ARG1(%esp) 5405 call __moddi3 5406.LOP_REM_LONG_finish: 5407 SET_VREG_WORD rIBASE rINST 1 5408 UNSPILL(rIBASE) # restore rIBASE/%edx 5409 SET_VREG_WORD %eax rINST 0 5410 FETCH_INST_OPCODE 2 %ecx 5411 ADVANCE_PC 2 5412 GOTO_NEXT_R %ecx 5413 5414.LOP_REM_LONG_check_zero: 5415 testl rIBASE,rIBASE 5416 jne .LOP_REM_LONG_notSpecial 5417 jmp common_errDivideByZero 5418.LOP_REM_LONG_check_neg1: 5419 testl rIBASE,%eax 5420 jne .LOP_REM_LONG_notSpecial 5421 GET_VREG_WORD rIBASE %ecx 0 5422 GET_VREG_WORD %ecx %ecx 1 5423 testl rIBASE,rIBASE 5424 jne .LOP_REM_LONG_notSpecial1 5425 cmpl $0x80000000,%ecx 5426 jne .LOP_REM_LONG_notSpecial1 5427 /* minint / -1, return minint on div, 0 on rem */ 5428 xorl %eax,%eax 5429 movl $0,rIBASE 5430 jmp .LOP_REM_LONG_finish 5431 5432 5433/* ------------------------------ */ 5434.L_OP_AND_LONG: /* 0xa0 */ 5435/* File: x86/OP_AND_LONG.S */ 5436/* File: x86/binopWide.S */ 5437 /* 5438 * Generic 64-bit binary operation. 5439 */ 5440 /* binop vAA, vBB, vCC */ 5441 5442 movzbl 2(rPC),%eax # eax<- BB 5443 movzbl 3(rPC),%ecx # ecx<- CC 5444 SPILL(rIBASE) # save rIBASE 5445 GET_VREG_WORD rIBASE %eax 0 # rIBASE<- v[BB+0] 5446 GET_VREG_WORD %eax %eax 1 # eax<- v[BB+1] 5447 andl (rFP,%ecx,4),rIBASE # ex: addl (rFP,%ecx,4),rIBASE 5448 andl 4(rFP,%ecx,4),%eax # ex: adcl 4(rFP,%ecx,4),%eax 5449 SET_VREG_WORD rIBASE rINST 0 # v[AA+0] <- rIBASE 5450 FETCH_INST_OPCODE 2 %ecx 5451 UNSPILL(rIBASE) # restore rIBASE 5452 SET_VREG_WORD %eax rINST 1 # v[AA+1] <- eax 5453 ADVANCE_PC 2 5454 GOTO_NEXT_R %ecx 5455 5456 5457/* ------------------------------ */ 5458.L_OP_OR_LONG: /* 0xa1 */ 5459/* File: x86/OP_OR_LONG.S */ 5460/* File: x86/binopWide.S */ 5461 /* 5462 * Generic 64-bit binary operation. 5463 */ 5464 /* binop vAA, vBB, vCC */ 5465 5466 movzbl 2(rPC),%eax # eax<- BB 5467 movzbl 3(rPC),%ecx # ecx<- CC 5468 SPILL(rIBASE) # save rIBASE 5469 GET_VREG_WORD rIBASE %eax 0 # rIBASE<- v[BB+0] 5470 GET_VREG_WORD %eax %eax 1 # eax<- v[BB+1] 5471 orl (rFP,%ecx,4),rIBASE # ex: addl (rFP,%ecx,4),rIBASE 5472 orl 4(rFP,%ecx,4),%eax # ex: adcl 4(rFP,%ecx,4),%eax 5473 SET_VREG_WORD rIBASE rINST 0 # v[AA+0] <- rIBASE 5474 FETCH_INST_OPCODE 2 %ecx 5475 UNSPILL(rIBASE) # restore rIBASE 5476 SET_VREG_WORD %eax rINST 1 # v[AA+1] <- eax 5477 ADVANCE_PC 2 5478 GOTO_NEXT_R %ecx 5479 5480 5481/* ------------------------------ */ 5482.L_OP_XOR_LONG: /* 0xa2 */ 5483/* File: x86/OP_XOR_LONG.S */ 5484/* File: x86/binopWide.S */ 5485 /* 5486 * Generic 64-bit binary operation. 5487 */ 5488 /* binop vAA, vBB, vCC */ 5489 5490 movzbl 2(rPC),%eax # eax<- BB 5491 movzbl 3(rPC),%ecx # ecx<- CC 5492 SPILL(rIBASE) # save rIBASE 5493 GET_VREG_WORD rIBASE %eax 0 # rIBASE<- v[BB+0] 5494 GET_VREG_WORD %eax %eax 1 # eax<- v[BB+1] 5495 xorl (rFP,%ecx,4),rIBASE # ex: addl (rFP,%ecx,4),rIBASE 5496 xorl 4(rFP,%ecx,4),%eax # ex: adcl 4(rFP,%ecx,4),%eax 5497 SET_VREG_WORD rIBASE rINST 0 # v[AA+0] <- rIBASE 5498 FETCH_INST_OPCODE 2 %ecx 5499 UNSPILL(rIBASE) # restore rIBASE 5500 SET_VREG_WORD %eax rINST 1 # v[AA+1] <- eax 5501 ADVANCE_PC 2 5502 GOTO_NEXT_R %ecx 5503 5504 5505/* ------------------------------ */ 5506.L_OP_SHL_LONG: /* 0xa3 */ 5507/* File: x86/OP_SHL_LONG.S */ 5508 /* 5509 * Long integer shift. This is different from the generic 32/64-bit 5510 * binary operations because vAA/vBB are 64-bit but vCC (the shift 5511 * distance) is 32-bit. Also, Dalvik requires us to mask off the low 5512 * 6 bits of the shift distance. x86 shifts automatically mask off 5513 * the low 5 bits of %cl, so have to handle the 64 > shiftcount > 31 5514 * case specially. 5515 */ 5516 /* shl-long vAA, vBB, vCC */ 5517 /* ecx gets shift count */ 5518 /* Need to spill rINST */ 5519 /* rINSTw gets AA */ 5520 movzbl 2(rPC),%eax # eax<- BB 5521 movzbl 3(rPC),%ecx # ecx<- CC 5522 SPILL(rIBASE) 5523 GET_VREG_WORD rIBASE %eax 1 # ecx<- v[BB+1] 5524 GET_VREG_R %ecx %ecx # ecx<- vCC 5525 GET_VREG_WORD %eax %eax 0 # eax<- v[BB+0] 5526 shldl %eax,rIBASE 5527 sall %cl,%eax 5528 testb $32,%cl 5529 je 2f 5530 movl %eax,rIBASE 5531 xorl %eax,%eax 55322: 5533 SET_VREG_WORD rIBASE rINST 1 # v[AA+1]<- rIBASE 5534 FETCH_INST_OPCODE 2 %ecx 5535 UNSPILL(rIBASE) 5536 SET_VREG_WORD %eax rINST 0 # v[AA+0]<- %eax 5537 ADVANCE_PC 2 5538 GOTO_NEXT_R %ecx 5539 5540/* ------------------------------ */ 5541.L_OP_SHR_LONG: /* 0xa4 */ 5542/* File: x86/OP_SHR_LONG.S */ 5543 /* 5544 * Long integer shift. This is different from the generic 32/64-bit 5545 * binary operations because vAA/vBB are 64-bit but vCC (the shift 5546 * distance) is 32-bit. Also, Dalvik requires us to mask off the low 5547 * 6 bits of the shift distance. x86 shifts automatically mask off 5548 * the low 5 bits of %cl, so have to handle the 64 > shiftcount > 31 5549 * case specially. 5550 */ 5551 /* shr-long vAA, vBB, vCC */ 5552 /* ecx gets shift count */ 5553 /* Need to spill rIBASE */ 5554 /* rINSTw gets AA */ 5555 movzbl 2(rPC),%eax # eax<- BB 5556 movzbl 3(rPC),%ecx # ecx<- CC 5557 SPILL(rIBASE) 5558 GET_VREG_WORD rIBASE %eax 1 # rIBASE<- v[BB+1] 5559 GET_VREG_R %ecx %ecx # ecx<- vCC 5560 GET_VREG_WORD %eax %eax 0 # eax<- v[BB+0] 5561 shrdl rIBASE,%eax 5562 sarl %cl,rIBASE 5563 testb $32,%cl 5564 je 2f 5565 movl rIBASE,%eax 5566 sarl $31,rIBASE 55672: 5568 SET_VREG_WORD rIBASE rINST 1 # v[AA+1]<- rIBASE 5569 FETCH_INST_OPCODE 2 %ecx 5570 UNSPILL(rIBASE) 5571 SET_VREG_WORD %eax rINST 0 # v[AA+0]<- eax 5572 ADVANCE_PC 2 5573 GOTO_NEXT_R %ecx 5574 5575/* ------------------------------ */ 5576.L_OP_USHR_LONG: /* 0xa5 */ 5577/* File: x86/OP_USHR_LONG.S */ 5578 /* 5579 * Long integer shift. This is different from the generic 32/64-bit 5580 * binary operations because vAA/vBB are 64-bit but vCC (the shift 5581 * distance) is 32-bit. Also, Dalvik requires us to mask off the low 5582 * 6 bits of the shift distance. x86 shifts automatically mask off 5583 * the low 5 bits of %cl, so have to handle the 64 > shiftcount > 31 5584 * case specially. 5585 */ 5586 /* shr-long vAA, vBB, vCC */ 5587 /* ecx gets shift count */ 5588 /* Need to spill rIBASE */ 5589 /* rINSTw gets AA */ 5590 movzbl 2(rPC),%eax # eax<- BB 5591 movzbl 3(rPC),%ecx # ecx<- CC 5592 SPILL(rIBASE) 5593 GET_VREG_WORD rIBASE %eax 1 # rIBASE<- v[BB+1] 5594 GET_VREG_R %ecx %ecx # ecx<- vCC 5595 GET_VREG_WORD %eax %eax 0 # eax<- v[BB+0] 5596 shrdl rIBASE,%eax 5597 shrl %cl,rIBASE 5598 testb $32,%cl 5599 je 2f 5600 movl rIBASE,%eax 5601 xorl rIBASE,rIBASE 56022: 5603 SET_VREG_WORD rIBASE rINST 1 # v[AA+1]<- rIBASE 5604 FETCH_INST_OPCODE 2 %ecx 5605 UNSPILL(rIBASE) 5606 SET_VREG_WORD %eax rINST 0 # v[BB+0]<- eax 5607 ADVANCE_PC 2 5608 GOTO_NEXT_R %ecx 5609 5610/* ------------------------------ */ 5611.L_OP_ADD_FLOAT: /* 0xa6 */ 5612/* File: x86/OP_ADD_FLOAT.S */ 5613/* File: x86/binflop.S */ 5614 /* 5615 * Generic 32-bit binary float operation. 5616 * 5617 * For: add-fp, sub-fp, mul-fp, div-fp 5618 */ 5619 /* binop vAA, vBB, vCC */ 5620 movzbl 2(rPC),%eax # eax<- CC 5621 movzbl 3(rPC),%ecx # ecx<- BB 5622 flds (rFP,%eax,4) # vCC to fp stack 5623 fadds (rFP,%ecx,4) # ex: faddp 5624 FETCH_INST_OPCODE 2 %ecx 5625 ADVANCE_PC 2 5626 fstps (rFP,rINST,4) # %st to vAA 5627 GOTO_NEXT_R %ecx 5628 5629 5630/* ------------------------------ */ 5631.L_OP_SUB_FLOAT: /* 0xa7 */ 5632/* File: x86/OP_SUB_FLOAT.S */ 5633/* File: x86/binflop.S */ 5634 /* 5635 * Generic 32-bit binary float operation. 5636 * 5637 * For: add-fp, sub-fp, mul-fp, div-fp 5638 */ 5639 /* binop vAA, vBB, vCC */ 5640 movzbl 2(rPC),%eax # eax<- CC 5641 movzbl 3(rPC),%ecx # ecx<- BB 5642 flds (rFP,%eax,4) # vCC to fp stack 5643 fsubs (rFP,%ecx,4) # ex: faddp 5644 FETCH_INST_OPCODE 2 %ecx 5645 ADVANCE_PC 2 5646 fstps (rFP,rINST,4) # %st to vAA 5647 GOTO_NEXT_R %ecx 5648 5649 5650/* ------------------------------ */ 5651.L_OP_MUL_FLOAT: /* 0xa8 */ 5652/* File: x86/OP_MUL_FLOAT.S */ 5653/* File: x86/binflop.S */ 5654 /* 5655 * Generic 32-bit binary float operation. 5656 * 5657 * For: add-fp, sub-fp, mul-fp, div-fp 5658 */ 5659 /* binop vAA, vBB, vCC */ 5660 movzbl 2(rPC),%eax # eax<- CC 5661 movzbl 3(rPC),%ecx # ecx<- BB 5662 flds (rFP,%eax,4) # vCC to fp stack 5663 fmuls (rFP,%ecx,4) # ex: faddp 5664 FETCH_INST_OPCODE 2 %ecx 5665 ADVANCE_PC 2 5666 fstps (rFP,rINST,4) # %st to vAA 5667 GOTO_NEXT_R %ecx 5668 5669 5670/* ------------------------------ */ 5671.L_OP_DIV_FLOAT: /* 0xa9 */ 5672/* File: x86/OP_DIV_FLOAT.S */ 5673/* File: x86/binflop.S */ 5674 /* 5675 * Generic 32-bit binary float operation. 5676 * 5677 * For: add-fp, sub-fp, mul-fp, div-fp 5678 */ 5679 /* binop vAA, vBB, vCC */ 5680 movzbl 2(rPC),%eax # eax<- CC 5681 movzbl 3(rPC),%ecx # ecx<- BB 5682 flds (rFP,%eax,4) # vCC to fp stack 5683 fdivs (rFP,%ecx,4) # ex: faddp 5684 FETCH_INST_OPCODE 2 %ecx 5685 ADVANCE_PC 2 5686 fstps (rFP,rINST,4) # %st to vAA 5687 GOTO_NEXT_R %ecx 5688 5689 5690/* ------------------------------ */ 5691.L_OP_REM_FLOAT: /* 0xaa */ 5692/* File: x86/OP_REM_FLOAT.S */ 5693 /* rem_float vAA, vBB, vCC */ 5694 movzbl 3(rPC),%ecx # ecx<- BB 5695 movzbl 2(rPC),%eax # eax<- CC 5696 flds (rFP,%ecx,4) # vCC to fp stack 5697 flds (rFP,%eax,4) # vCC to fp stack 5698 movzbl rINSTbl,%ecx # ecx<- AA 56991: 5700 fprem 5701 fstsw %ax 5702 sahf 5703 jp 1b 5704 fstp %st(1) 5705 FETCH_INST_OPCODE 2 %eax 5706 ADVANCE_PC 2 5707 fstps (rFP,%ecx,4) # %st to vAA 5708 GOTO_NEXT_R %eax 5709 5710/* ------------------------------ */ 5711.L_OP_ADD_DOUBLE: /* 0xab */ 5712/* File: x86/OP_ADD_DOUBLE.S */ 5713/* File: x86/binflop.S */ 5714 /* 5715 * Generic 32-bit binary float operation. 5716 * 5717 * For: add-fp, sub-fp, mul-fp, div-fp 5718 */ 5719 /* binop vAA, vBB, vCC */ 5720 movzbl 2(rPC),%eax # eax<- CC 5721 movzbl 3(rPC),%ecx # ecx<- BB 5722 fldl (rFP,%eax,4) # vCC to fp stack 5723 faddl (rFP,%ecx,4) # ex: faddp 5724 FETCH_INST_OPCODE 2 %ecx 5725 ADVANCE_PC 2 5726 fstpl (rFP,rINST,4) # %st to vAA 5727 GOTO_NEXT_R %ecx 5728 5729 5730/* ------------------------------ */ 5731.L_OP_SUB_DOUBLE: /* 0xac */ 5732/* File: x86/OP_SUB_DOUBLE.S */ 5733/* File: x86/binflop.S */ 5734 /* 5735 * Generic 32-bit binary float operation. 5736 * 5737 * For: add-fp, sub-fp, mul-fp, div-fp 5738 */ 5739 /* binop vAA, vBB, vCC */ 5740 movzbl 2(rPC),%eax # eax<- CC 5741 movzbl 3(rPC),%ecx # ecx<- BB 5742 fldl (rFP,%eax,4) # vCC to fp stack 5743 fsubl (rFP,%ecx,4) # ex: faddp 5744 FETCH_INST_OPCODE 2 %ecx 5745 ADVANCE_PC 2 5746 fstpl (rFP,rINST,4) # %st to vAA 5747 GOTO_NEXT_R %ecx 5748 5749 5750/* ------------------------------ */ 5751.L_OP_MUL_DOUBLE: /* 0xad */ 5752/* File: x86/OP_MUL_DOUBLE.S */ 5753/* File: x86/binflop.S */ 5754 /* 5755 * Generic 32-bit binary float operation. 5756 * 5757 * For: add-fp, sub-fp, mul-fp, div-fp 5758 */ 5759 /* binop vAA, vBB, vCC */ 5760 movzbl 2(rPC),%eax # eax<- CC 5761 movzbl 3(rPC),%ecx # ecx<- BB 5762 fldl (rFP,%eax,4) # vCC to fp stack 5763 fmull (rFP,%ecx,4) # ex: faddp 5764 FETCH_INST_OPCODE 2 %ecx 5765 ADVANCE_PC 2 5766 fstpl (rFP,rINST,4) # %st to vAA 5767 GOTO_NEXT_R %ecx 5768 5769 5770/* ------------------------------ */ 5771.L_OP_DIV_DOUBLE: /* 0xae */ 5772/* File: x86/OP_DIV_DOUBLE.S */ 5773/* File: x86/binflop.S */ 5774 /* 5775 * Generic 32-bit binary float operation. 5776 * 5777 * For: add-fp, sub-fp, mul-fp, div-fp 5778 */ 5779 /* binop vAA, vBB, vCC */ 5780 movzbl 2(rPC),%eax # eax<- CC 5781 movzbl 3(rPC),%ecx # ecx<- BB 5782 fldl (rFP,%eax,4) # vCC to fp stack 5783 fdivl (rFP,%ecx,4) # ex: faddp 5784 FETCH_INST_OPCODE 2 %ecx 5785 ADVANCE_PC 2 5786 fstpl (rFP,rINST,4) # %st to vAA 5787 GOTO_NEXT_R %ecx 5788 5789 5790/* ------------------------------ */ 5791.L_OP_REM_DOUBLE: /* 0xaf */ 5792/* File: x86/OP_REM_DOUBLE.S */ 5793 /* rem_float vAA, vBB, vCC */ 5794 movzbl 3(rPC),%ecx # ecx<- BB 5795 movzbl 2(rPC),%eax # eax<- CC 5796 fldl (rFP,%ecx,4) # vCC to fp stack 5797 fldl (rFP,%eax,4) # vCC to fp stack 5798 FETCH_INST_OPCODE 2 %ecx 57991: 5800 fprem 5801 fstsw %ax 5802 sahf 5803 jp 1b 5804 fstp %st(1) 5805 ADVANCE_PC 2 5806 fstpl (rFP,rINST,4) # %st to vAA 5807 GOTO_NEXT_R %ecx 5808 5809/* ------------------------------ */ 5810.L_OP_ADD_INT_2ADDR: /* 0xb0 */ 5811/* File: x86/OP_ADD_INT_2ADDR.S */ 5812/* File: x86/binop2addr.S */ 5813 /* 5814 * Generic 32-bit "/2addr" binary operation. Provide an "instr" line 5815 * that specifies an instruction that performs "result = r0 op r1". 5816 * This could be an ARM instruction or a function call. (If the result 5817 * comes back in a register other than r0, you can override "result".) 5818 * 5819 * If "chkzero" is set to 1, we perform a divide-by-zero check on 5820 * vCC (r1). Useful for integer division and modulus. 5821 * 5822 * For: add-int/2addr, sub-int/2addr, mul-int/2addr, div-int/2addr, 5823 * rem-int/2addr, and-int/2addr, or-int/2addr, xor-int/2addr, 5824 * shl-int/2addr, shr-int/2addr, ushr-int/2addr, add-float/2addr, 5825 * sub-float/2addr, mul-float/2addr, div-float/2addr, rem-float/2addr 5826 */ 5827 /* binop/2addr vA, vB */ 5828 movzx rINSTbl,%ecx # ecx<- A+ 5829 sarl $4,rINST # rINST<- B 5830 GET_VREG_R %eax rINST # eax<- vB 5831 andb $0xf,%cl # ecx<- A 5832 addl %eax,(rFP,%ecx,4) # for ex: addl %eax,(rFP,%ecx,4) 5833 FETCH_INST_OPCODE 1 %ecx 5834 ADVANCE_PC 1 5835 GOTO_NEXT_R %ecx 5836 5837 5838/* ------------------------------ */ 5839.L_OP_SUB_INT_2ADDR: /* 0xb1 */ 5840/* File: x86/OP_SUB_INT_2ADDR.S */ 5841/* File: x86/binop2addr.S */ 5842 /* 5843 * Generic 32-bit "/2addr" binary operation. Provide an "instr" line 5844 * that specifies an instruction that performs "result = r0 op r1". 5845 * This could be an ARM instruction or a function call. (If the result 5846 * comes back in a register other than r0, you can override "result".) 5847 * 5848 * If "chkzero" is set to 1, we perform a divide-by-zero check on 5849 * vCC (r1). Useful for integer division and modulus. 5850 * 5851 * For: add-int/2addr, sub-int/2addr, mul-int/2addr, div-int/2addr, 5852 * rem-int/2addr, and-int/2addr, or-int/2addr, xor-int/2addr, 5853 * shl-int/2addr, shr-int/2addr, ushr-int/2addr, add-float/2addr, 5854 * sub-float/2addr, mul-float/2addr, div-float/2addr, rem-float/2addr 5855 */ 5856 /* binop/2addr vA, vB */ 5857 movzx rINSTbl,%ecx # ecx<- A+ 5858 sarl $4,rINST # rINST<- B 5859 GET_VREG_R %eax rINST # eax<- vB 5860 andb $0xf,%cl # ecx<- A 5861 subl %eax,(rFP,%ecx,4) # for ex: addl %eax,(rFP,%ecx,4) 5862 FETCH_INST_OPCODE 1 %ecx 5863 ADVANCE_PC 1 5864 GOTO_NEXT_R %ecx 5865 5866 5867/* ------------------------------ */ 5868.L_OP_MUL_INT_2ADDR: /* 0xb2 */ 5869/* File: x86/OP_MUL_INT_2ADDR.S */ 5870 /* mul vA, vB */ 5871 movzx rINSTbl,%ecx # ecx<- A+ 5872 sarl $4,rINST # rINST<- B 5873 GET_VREG_R %eax rINST # eax<- vB 5874 andb $0xf,%cl # ecx<- A 5875 SPILL(rIBASE) 5876 imull (rFP,%ecx,4),%eax # trashes rIBASE/edx 5877 UNSPILL(rIBASE) 5878 SET_VREG %eax %ecx 5879 FETCH_INST_OPCODE 1 %ecx 5880 ADVANCE_PC 1 5881 GOTO_NEXT_R %ecx 5882 5883/* ------------------------------ */ 5884.L_OP_DIV_INT_2ADDR: /* 0xb3 */ 5885/* File: x86/OP_DIV_INT_2ADDR.S */ 5886/* File: x86/bindiv2addr.S */ 5887 /* 5888 * 32-bit binary div/rem operation. Handles special case of op0=minint and 5889 * op1=-1. 5890 */ 5891 /* div/rem/2addr vA, vB */ 5892 movzx rINSTbl,%ecx # eax<- BA 5893 SPILL(rIBASE) 5894 sarl $4,%ecx # ecx<- B 5895 GET_VREG_R %ecx %ecx # eax<- vBB 5896 andb $0xf,rINSTbl # rINST<- A 5897 GET_VREG_R %eax rINST # eax<- vBB 5898 cmpl $0,%ecx 5899 je common_errDivideByZero 5900 cmpl $-1,%ecx 5901 jne .LOP_DIV_INT_2ADDR_continue_div2addr 5902 cmpl $0x80000000,%eax 5903 jne .LOP_DIV_INT_2ADDR_continue_div2addr 5904 movl $0x80000000,%eax 5905 SET_VREG %eax rINST 5906 UNSPILL(rIBASE) 5907 FETCH_INST_OPCODE 1 %ecx 5908 ADVANCE_PC 1 5909 GOTO_NEXT_R %ecx 5910 5911.LOP_DIV_INT_2ADDR_continue_div2addr: 5912 cltd 5913 idivl %ecx 5914 SET_VREG %eax rINST 5915 UNSPILL(rIBASE) 5916 FETCH_INST_OPCODE 1 %ecx 5917 ADVANCE_PC 1 5918 GOTO_NEXT_R %ecx 5919 5920 5921/* ------------------------------ */ 5922.L_OP_REM_INT_2ADDR: /* 0xb4 */ 5923/* File: x86/OP_REM_INT_2ADDR.S */ 5924/* File: x86/bindiv2addr.S */ 5925 /* 5926 * 32-bit binary div/rem operation. Handles special case of op0=minint and 5927 * op1=-1. 5928 */ 5929 /* div/rem/2addr vA, vB */ 5930 movzx rINSTbl,%ecx # eax<- BA 5931 SPILL(rIBASE) 5932 sarl $4,%ecx # ecx<- B 5933 GET_VREG_R %ecx %ecx # eax<- vBB 5934 andb $0xf,rINSTbl # rINST<- A 5935 GET_VREG_R %eax rINST # eax<- vBB 5936 cmpl $0,%ecx 5937 je common_errDivideByZero 5938 cmpl $-1,%ecx 5939 jne .LOP_REM_INT_2ADDR_continue_div2addr 5940 cmpl $0x80000000,%eax 5941 jne .LOP_REM_INT_2ADDR_continue_div2addr 5942 movl $0,rIBASE 5943 SET_VREG rIBASE rINST 5944 UNSPILL(rIBASE) 5945 FETCH_INST_OPCODE 1 %ecx 5946 ADVANCE_PC 1 5947 GOTO_NEXT_R %ecx 5948 5949.LOP_REM_INT_2ADDR_continue_div2addr: 5950 cltd 5951 idivl %ecx 5952 SET_VREG rIBASE rINST 5953 UNSPILL(rIBASE) 5954 FETCH_INST_OPCODE 1 %ecx 5955 ADVANCE_PC 1 5956 GOTO_NEXT_R %ecx 5957 5958 5959/* ------------------------------ */ 5960.L_OP_AND_INT_2ADDR: /* 0xb5 */ 5961/* File: x86/OP_AND_INT_2ADDR.S */ 5962/* File: x86/binop2addr.S */ 5963 /* 5964 * Generic 32-bit "/2addr" binary operation. Provide an "instr" line 5965 * that specifies an instruction that performs "result = r0 op r1". 5966 * This could be an ARM instruction or a function call. (If the result 5967 * comes back in a register other than r0, you can override "result".) 5968 * 5969 * If "chkzero" is set to 1, we perform a divide-by-zero check on 5970 * vCC (r1). Useful for integer division and modulus. 5971 * 5972 * For: add-int/2addr, sub-int/2addr, mul-int/2addr, div-int/2addr, 5973 * rem-int/2addr, and-int/2addr, or-int/2addr, xor-int/2addr, 5974 * shl-int/2addr, shr-int/2addr, ushr-int/2addr, add-float/2addr, 5975 * sub-float/2addr, mul-float/2addr, div-float/2addr, rem-float/2addr 5976 */ 5977 /* binop/2addr vA, vB */ 5978 movzx rINSTbl,%ecx # ecx<- A+ 5979 sarl $4,rINST # rINST<- B 5980 GET_VREG_R %eax rINST # eax<- vB 5981 andb $0xf,%cl # ecx<- A 5982 andl %eax,(rFP,%ecx,4) # for ex: addl %eax,(rFP,%ecx,4) 5983 FETCH_INST_OPCODE 1 %ecx 5984 ADVANCE_PC 1 5985 GOTO_NEXT_R %ecx 5986 5987 5988/* ------------------------------ */ 5989.L_OP_OR_INT_2ADDR: /* 0xb6 */ 5990/* File: x86/OP_OR_INT_2ADDR.S */ 5991/* File: x86/binop2addr.S */ 5992 /* 5993 * Generic 32-bit "/2addr" binary operation. Provide an "instr" line 5994 * that specifies an instruction that performs "result = r0 op r1". 5995 * This could be an ARM instruction or a function call. (If the result 5996 * comes back in a register other than r0, you can override "result".) 5997 * 5998 * If "chkzero" is set to 1, we perform a divide-by-zero check on 5999 * vCC (r1). Useful for integer division and modulus. 6000 * 6001 * For: add-int/2addr, sub-int/2addr, mul-int/2addr, div-int/2addr, 6002 * rem-int/2addr, and-int/2addr, or-int/2addr, xor-int/2addr, 6003 * shl-int/2addr, shr-int/2addr, ushr-int/2addr, add-float/2addr, 6004 * sub-float/2addr, mul-float/2addr, div-float/2addr, rem-float/2addr 6005 */ 6006 /* binop/2addr vA, vB */ 6007 movzx rINSTbl,%ecx # ecx<- A+ 6008 sarl $4,rINST # rINST<- B 6009 GET_VREG_R %eax rINST # eax<- vB 6010 andb $0xf,%cl # ecx<- A 6011 orl %eax,(rFP,%ecx,4) # for ex: addl %eax,(rFP,%ecx,4) 6012 FETCH_INST_OPCODE 1 %ecx 6013 ADVANCE_PC 1 6014 GOTO_NEXT_R %ecx 6015 6016 6017/* ------------------------------ */ 6018.L_OP_XOR_INT_2ADDR: /* 0xb7 */ 6019/* File: x86/OP_XOR_INT_2ADDR.S */ 6020/* File: x86/binop2addr.S */ 6021 /* 6022 * Generic 32-bit "/2addr" binary operation. Provide an "instr" line 6023 * that specifies an instruction that performs "result = r0 op r1". 6024 * This could be an ARM instruction or a function call. (If the result 6025 * comes back in a register other than r0, you can override "result".) 6026 * 6027 * If "chkzero" is set to 1, we perform a divide-by-zero check on 6028 * vCC (r1). Useful for integer division and modulus. 6029 * 6030 * For: add-int/2addr, sub-int/2addr, mul-int/2addr, div-int/2addr, 6031 * rem-int/2addr, and-int/2addr, or-int/2addr, xor-int/2addr, 6032 * shl-int/2addr, shr-int/2addr, ushr-int/2addr, add-float/2addr, 6033 * sub-float/2addr, mul-float/2addr, div-float/2addr, rem-float/2addr 6034 */ 6035 /* binop/2addr vA, vB */ 6036 movzx rINSTbl,%ecx # ecx<- A+ 6037 sarl $4,rINST # rINST<- B 6038 GET_VREG_R %eax rINST # eax<- vB 6039 andb $0xf,%cl # ecx<- A 6040 xorl %eax,(rFP,%ecx,4) # for ex: addl %eax,(rFP,%ecx,4) 6041 FETCH_INST_OPCODE 1 %ecx 6042 ADVANCE_PC 1 6043 GOTO_NEXT_R %ecx 6044 6045 6046/* ------------------------------ */ 6047.L_OP_SHL_INT_2ADDR: /* 0xb8 */ 6048/* File: x86/OP_SHL_INT_2ADDR.S */ 6049/* File: x86/shop2addr.S */ 6050 /* 6051 * Generic 32-bit "shift/2addr" operation. 6052 */ 6053 /* shift/2addr vA, vB */ 6054 movzx rINSTbl,%ecx # eax<- BA 6055 sarl $4,%ecx # ecx<- B 6056 GET_VREG_R %ecx %ecx # eax<- vBB 6057 andb $0xf,rINSTbl # rINST<- A 6058 GET_VREG_R %eax rINST # eax<- vAA 6059 sall %cl,%eax # ex: sarl %cl,%eax 6060 FETCH_INST_OPCODE 1 %ecx 6061 SET_VREG %eax rINST 6062 ADVANCE_PC 1 6063 GOTO_NEXT_R %ecx 6064 6065 6066/* ------------------------------ */ 6067.L_OP_SHR_INT_2ADDR: /* 0xb9 */ 6068/* File: x86/OP_SHR_INT_2ADDR.S */ 6069/* File: x86/shop2addr.S */ 6070 /* 6071 * Generic 32-bit "shift/2addr" operation. 6072 */ 6073 /* shift/2addr vA, vB */ 6074 movzx rINSTbl,%ecx # eax<- BA 6075 sarl $4,%ecx # ecx<- B 6076 GET_VREG_R %ecx %ecx # eax<- vBB 6077 andb $0xf,rINSTbl # rINST<- A 6078 GET_VREG_R %eax rINST # eax<- vAA 6079 sarl %cl,%eax # ex: sarl %cl,%eax 6080 FETCH_INST_OPCODE 1 %ecx 6081 SET_VREG %eax rINST 6082 ADVANCE_PC 1 6083 GOTO_NEXT_R %ecx 6084 6085 6086/* ------------------------------ */ 6087.L_OP_USHR_INT_2ADDR: /* 0xba */ 6088/* File: x86/OP_USHR_INT_2ADDR.S */ 6089/* File: x86/shop2addr.S */ 6090 /* 6091 * Generic 32-bit "shift/2addr" operation. 6092 */ 6093 /* shift/2addr vA, vB */ 6094 movzx rINSTbl,%ecx # eax<- BA 6095 sarl $4,%ecx # ecx<- B 6096 GET_VREG_R %ecx %ecx # eax<- vBB 6097 andb $0xf,rINSTbl # rINST<- A 6098 GET_VREG_R %eax rINST # eax<- vAA 6099 shrl %cl,%eax # ex: sarl %cl,%eax 6100 FETCH_INST_OPCODE 1 %ecx 6101 SET_VREG %eax rINST 6102 ADVANCE_PC 1 6103 GOTO_NEXT_R %ecx 6104 6105 6106/* ------------------------------ */ 6107.L_OP_ADD_LONG_2ADDR: /* 0xbb */ 6108/* File: x86/OP_ADD_LONG_2ADDR.S */ 6109/* File: x86/binopWide2addr.S */ 6110 /* 6111 * Generic 64-bit binary operation. 6112 */ 6113 /* binop/2addr vA, vB */ 6114 movzbl rINSTbl,%ecx # ecx<- BA 6115 sarl $4,%ecx # ecx<- B 6116 GET_VREG_WORD %eax %ecx 0 # eax<- v[B+0] 6117 GET_VREG_WORD %ecx %ecx 1 # eax<- v[B+1] 6118 andb $0xF,rINSTbl # rINST<- A 6119 addl %eax,(rFP,rINST,4) # example: addl %eax,(rFP,rINST,4) 6120 adcl %ecx,4(rFP,rINST,4) # example: adcl %ecx,4(rFP,rINST,4) 6121 FETCH_INST_OPCODE 1 %ecx 6122 ADVANCE_PC 1 6123 GOTO_NEXT_R %ecx 6124 6125 6126/* ------------------------------ */ 6127.L_OP_SUB_LONG_2ADDR: /* 0xbc */ 6128/* File: x86/OP_SUB_LONG_2ADDR.S */ 6129/* File: x86/binopWide2addr.S */ 6130 /* 6131 * Generic 64-bit binary operation. 6132 */ 6133 /* binop/2addr vA, vB */ 6134 movzbl rINSTbl,%ecx # ecx<- BA 6135 sarl $4,%ecx # ecx<- B 6136 GET_VREG_WORD %eax %ecx 0 # eax<- v[B+0] 6137 GET_VREG_WORD %ecx %ecx 1 # eax<- v[B+1] 6138 andb $0xF,rINSTbl # rINST<- A 6139 subl %eax,(rFP,rINST,4) # example: addl %eax,(rFP,rINST,4) 6140 sbbl %ecx,4(rFP,rINST,4) # example: adcl %ecx,4(rFP,rINST,4) 6141 FETCH_INST_OPCODE 1 %ecx 6142 ADVANCE_PC 1 6143 GOTO_NEXT_R %ecx 6144 6145 6146/* ------------------------------ */ 6147.L_OP_MUL_LONG_2ADDR: /* 0xbd */ 6148/* File: x86/OP_MUL_LONG_2ADDR.S */ 6149 /* 6150 * Signed 64-bit integer multiply, 2-addr version 6151 * 6152 * We could definately use more free registers for 6153 * this code. We must spill %edx (rIBASE) because it 6154 * is used by imul. We'll also spill rINST (ebx), 6155 * giving us eax, ebc, ecx and rIBASE as computational 6156 * temps. On top of that, we'll spill %esi (edi) 6157 * for use as the vA pointer and rFP (esi) for use 6158 * as the vB pointer. Yuck. 6159 */ 6160 /* mul-long/2addr vA, vB */ 6161 movzbl rINSTbl,%eax # eax<- BA 6162 andb $0xf,%al # eax<- A 6163 sarl $4,rINST # rINST<- B 6164 SPILL_TMP2(%esi) 6165 SPILL(rFP) 6166 SPILL(rIBASE) 6167 leal (rFP,%eax,4),%esi # %esi<- &v[A] 6168 leal (rFP,rINST,4),rFP # rFP<- &v[B] 6169 movl 4(%esi),%ecx # ecx<- Amsw 6170 imull (rFP),%ecx # ecx<- (Amsw*Blsw) 6171 movl 4(rFP),%eax # eax<- Bmsw 6172 imull (%esi),%eax # eax<- (Bmsw*Alsw) 6173 addl %eax,%ecx # ecx<- (Amsw*Blsw)+(Bmsw*Alsw) 6174 movl (rFP),%eax # eax<- Blsw 6175 mull (%esi) # eax<- (Blsw*Alsw) 6176 leal (%ecx,rIBASE),rIBASE # full result now in %edx:%eax 6177 movl rIBASE,4(%esi) # v[A+1]<- rIBASE 6178 movl %eax,(%esi) # v[A]<- %eax 6179 UNSPILL_TMP2(%esi) 6180 FETCH_INST_OPCODE 1 %ecx 6181 UNSPILL(rIBASE) 6182 UNSPILL(rFP) 6183 ADVANCE_PC 1 6184 GOTO_NEXT_R %ecx 6185 6186/* ------------------------------ */ 6187.L_OP_DIV_LONG_2ADDR: /* 0xbe */ 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_DIV_LONG_2ADDR_check_zero 6199 cmpl $-1,%eax 6200 je .LOP_DIV_LONG_2ADDR_check_neg1 6201.LOP_DIV_LONG_2ADDR_notSpecial: 6202 GET_VREG_WORD rIBASE rINST 0 6203 GET_VREG_WORD %ecx rINST 1 6204.LOP_DIV_LONG_2ADDR_notSpecial1: 6205 movl %eax,OUT_ARG3(%esp) 6206 movl rIBASE,OUT_ARG0(%esp) 6207 movl %ecx,OUT_ARG1(%esp) 6208 call __divdi3 6209.LOP_DIV_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_DIV_LONG_2ADDR_check_zero: 6218 testl rIBASE,rIBASE 6219 jne .LOP_DIV_LONG_2ADDR_notSpecial 6220 jmp common_errDivideByZero 6221.LOP_DIV_LONG_2ADDR_check_neg1: 6222 testl rIBASE,%eax 6223 jne .LOP_DIV_LONG_2ADDR_notSpecial 6224 GET_VREG_WORD rIBASE rINST 0 6225 GET_VREG_WORD %ecx rINST 1 6226 testl rIBASE,rIBASE 6227 jne .LOP_DIV_LONG_2ADDR_notSpecial1 6228 cmpl $0x80000000,%ecx 6229 jne .LOP_DIV_LONG_2ADDR_notSpecial1 6230 /* minint / -1, return minint on div, 0 on rem */ 6231 xorl %eax,%eax 6232 movl $0x80000000,rIBASE 6233 jmp .LOP_DIV_LONG_2ADDR_finish 6234 6235/* ------------------------------ */ 6236.L_OP_REM_LONG_2ADDR: /* 0xbf */ 6237/* File: x86/OP_REM_LONG_2ADDR.S */ 6238/* File: x86/OP_DIV_LONG_2ADDR.S */ 6239 /* div/2addr vA, vB */ 6240 movzbl rINSTbl,%eax 6241 shrl $4,%eax # eax<- B 6242 andb $0xf,rINSTbl # rINST<- A 6243 SPILL(rIBASE) # save rIBASE/%edx 6244 GET_VREG_WORD rIBASE %eax 0 6245 GET_VREG_WORD %eax %eax 1 6246 movl rIBASE,OUT_ARG2(%esp) 6247 testl %eax,%eax 6248 je .LOP_REM_LONG_2ADDR_check_zero 6249 cmpl $-1,%eax 6250 je .LOP_REM_LONG_2ADDR_check_neg1 6251.LOP_REM_LONG_2ADDR_notSpecial: 6252 GET_VREG_WORD rIBASE rINST 0 6253 GET_VREG_WORD %ecx rINST 1 6254.LOP_REM_LONG_2ADDR_notSpecial1: 6255 movl %eax,OUT_ARG3(%esp) 6256 movl rIBASE,OUT_ARG0(%esp) 6257 movl %ecx,OUT_ARG1(%esp) 6258 call __moddi3 6259.LOP_REM_LONG_2ADDR_finish: 6260 SET_VREG_WORD rIBASE rINST 1 6261 UNSPILL(rIBASE) # restore rIBASE/%edx 6262 SET_VREG_WORD %eax rINST 0 6263 FETCH_INST_OPCODE 1 %ecx 6264 ADVANCE_PC 1 6265 GOTO_NEXT_R %ecx 6266 6267.LOP_REM_LONG_2ADDR_check_zero: 6268 testl rIBASE,rIBASE 6269 jne .LOP_REM_LONG_2ADDR_notSpecial 6270 jmp common_errDivideByZero 6271.LOP_REM_LONG_2ADDR_check_neg1: 6272 testl rIBASE,%eax 6273 jne .LOP_REM_LONG_2ADDR_notSpecial 6274 GET_VREG_WORD rIBASE rINST 0 6275 GET_VREG_WORD %ecx rINST 1 6276 testl rIBASE,rIBASE 6277 jne .LOP_REM_LONG_2ADDR_notSpecial1 6278 cmpl $0x80000000,%ecx 6279 jne .LOP_REM_LONG_2ADDR_notSpecial1 6280 /* minint / -1, return minint on div, 0 on rem */ 6281 xorl %eax,%eax 6282 movl $0,rIBASE 6283 jmp .LOP_REM_LONG_2ADDR_finish 6284 6285 6286/* ------------------------------ */ 6287.L_OP_AND_LONG_2ADDR: /* 0xc0 */ 6288/* File: x86/OP_AND_LONG_2ADDR.S */ 6289/* File: x86/binopWide2addr.S */ 6290 /* 6291 * Generic 64-bit binary operation. 6292 */ 6293 /* binop/2addr vA, vB */ 6294 movzbl rINSTbl,%ecx # ecx<- BA 6295 sarl $4,%ecx # ecx<- B 6296 GET_VREG_WORD %eax %ecx 0 # eax<- v[B+0] 6297 GET_VREG_WORD %ecx %ecx 1 # eax<- v[B+1] 6298 andb $0xF,rINSTbl # rINST<- A 6299 andl %eax,(rFP,rINST,4) # example: addl %eax,(rFP,rINST,4) 6300 andl %ecx,4(rFP,rINST,4) # example: adcl %ecx,4(rFP,rINST,4) 6301 FETCH_INST_OPCODE 1 %ecx 6302 ADVANCE_PC 1 6303 GOTO_NEXT_R %ecx 6304 6305 6306/* ------------------------------ */ 6307.L_OP_OR_LONG_2ADDR: /* 0xc1 */ 6308/* File: x86/OP_OR_LONG_2ADDR.S */ 6309/* File: x86/binopWide2addr.S */ 6310 /* 6311 * Generic 64-bit binary operation. 6312 */ 6313 /* binop/2addr vA, vB */ 6314 movzbl rINSTbl,%ecx # ecx<- BA 6315 sarl $4,%ecx # ecx<- B 6316 GET_VREG_WORD %eax %ecx 0 # eax<- v[B+0] 6317 GET_VREG_WORD %ecx %ecx 1 # eax<- v[B+1] 6318 andb $0xF,rINSTbl # rINST<- A 6319 orl %eax,(rFP,rINST,4) # example: addl %eax,(rFP,rINST,4) 6320 orl %ecx,4(rFP,rINST,4) # example: adcl %ecx,4(rFP,rINST,4) 6321 FETCH_INST_OPCODE 1 %ecx 6322 ADVANCE_PC 1 6323 GOTO_NEXT_R %ecx 6324 6325 6326/* ------------------------------ */ 6327.L_OP_XOR_LONG_2ADDR: /* 0xc2 */ 6328/* File: x86/OP_XOR_LONG_2ADDR.S */ 6329/* File: x86/binopWide2addr.S */ 6330 /* 6331 * Generic 64-bit binary operation. 6332 */ 6333 /* binop/2addr vA, vB */ 6334 movzbl rINSTbl,%ecx # ecx<- BA 6335 sarl $4,%ecx # ecx<- B 6336 GET_VREG_WORD %eax %ecx 0 # eax<- v[B+0] 6337 GET_VREG_WORD %ecx %ecx 1 # eax<- v[B+1] 6338 andb $0xF,rINSTbl # rINST<- A 6339 xorl %eax,(rFP,rINST,4) # example: addl %eax,(rFP,rINST,4) 6340 xorl %ecx,4(rFP,rINST,4) # example: adcl %ecx,4(rFP,rINST,4) 6341 FETCH_INST_OPCODE 1 %ecx 6342 ADVANCE_PC 1 6343 GOTO_NEXT_R %ecx 6344 6345 6346/* ------------------------------ */ 6347.L_OP_SHL_LONG_2ADDR: /* 0xc3 */ 6348/* File: x86/OP_SHL_LONG_2ADDR.S */ 6349 /* 6350 * Long integer shift, 2addr version. vA is 64-bit value/result, vB is 6351 * 32-bit shift distance. 6352 */ 6353 /* shl-long/2addr vA, vB */ 6354 /* ecx gets shift count */ 6355 /* Need to spill rIBASE */ 6356 /* rINSTw gets AA */ 6357 movzbl rINSTbl,%ecx # ecx<- BA 6358 andb $0xf,rINSTbl # rINST<- A 6359 GET_VREG_WORD %eax rINST 0 # eax<- v[AA+0] 6360 sarl $4,%ecx # ecx<- B 6361 SPILL(rIBASE) 6362 GET_VREG_WORD rIBASE rINST 1 # rIBASE<- v[AA+1] 6363 GET_VREG_R %ecx %ecx # ecx<- vBB 6364 shldl %eax,rIBASE 6365 sall %cl,%eax 6366 testb $32,%cl 6367 je 2f 6368 movl %eax,rIBASE 6369 xorl %eax,%eax 63702: 6371 SET_VREG_WORD rIBASE rINST 1 # v[AA+1]<- rIBASE 6372 UNSPILL(rIBASE) 6373 FETCH_INST_OPCODE 1 %ecx 6374 SET_VREG_WORD %eax rINST 0 # v[AA+0]<- eax 6375 ADVANCE_PC 1 6376 GOTO_NEXT_R %ecx 6377 6378/* ------------------------------ */ 6379.L_OP_SHR_LONG_2ADDR: /* 0xc4 */ 6380/* File: x86/OP_SHR_LONG_2ADDR.S */ 6381 /* 6382 * Long integer shift, 2addr version. vA is 64-bit value/result, vB is 6383 * 32-bit shift distance. 6384 */ 6385 /* shl-long/2addr vA, vB */ 6386 /* ecx gets shift count */ 6387 /* Need to spill rIBASE */ 6388 /* rINSTw gets AA */ 6389 movzbl rINSTbl,%ecx # ecx<- BA 6390 andb $0xf,rINSTbl # rINST<- A 6391 GET_VREG_WORD %eax rINST 0 # eax<- v[AA+0] 6392 sarl $4,%ecx # ecx<- B 6393 SPILL(rIBASE) 6394 GET_VREG_WORD rIBASE rINST 1 # rIBASE<- v[AA+1] 6395 GET_VREG_R %ecx %ecx # ecx<- vBB 6396 shrdl rIBASE,%eax 6397 sarl %cl,rIBASE 6398 testb $32,%cl 6399 je 2f 6400 movl rIBASE,%eax 6401 sarl $31,rIBASE 64022: 6403 SET_VREG_WORD rIBASE rINST 1 # v[AA+1]<- rIBASE 6404 UNSPILL(rIBASE) 6405 FETCH_INST_OPCODE 1 %ecx 6406 SET_VREG_WORD %eax rINST 0 # v[AA+0]<- eax 6407 ADVANCE_PC 1 6408 GOTO_NEXT_R %ecx 6409 6410/* ------------------------------ */ 6411.L_OP_USHR_LONG_2ADDR: /* 0xc5 */ 6412/* File: x86/OP_USHR_LONG_2ADDR.S */ 6413 /* 6414 * Long integer shift, 2addr version. vA is 64-bit value/result, vB is 6415 * 32-bit shift distance. 6416 */ 6417 /* shl-long/2addr vA, vB */ 6418 /* ecx gets shift count */ 6419 /* Need to spill rIBASE */ 6420 /* rINSTw gets AA */ 6421 movzbl rINSTbl,%ecx # ecx<- BA 6422 andb $0xf,rINSTbl # rINST<- A 6423 GET_VREG_WORD %eax rINST 0 # eax<- v[AA+0] 6424 sarl $4,%ecx # ecx<- B 6425 SPILL(rIBASE) 6426 GET_VREG_WORD rIBASE rINST 1 # rIBASE<- v[AA+1] 6427 GET_VREG_R %ecx %ecx # ecx<- vBB 6428 shrdl rIBASE,%eax 6429 shrl %cl,rIBASE 6430 testb $32,%cl 6431 je 2f 6432 movl rIBASE,%eax 6433 xorl rIBASE,rIBASE 64342: 6435 SET_VREG_WORD rIBASE rINST 1 # v[AA+1]<- rIBASE 6436 FETCH_INST_OPCODE 1 %ecx 6437 UNSPILL(rIBASE) 6438 SET_VREG_WORD %eax rINST 0 # v[AA+0]<- eax 6439 ADVANCE_PC 1 6440 GOTO_NEXT_R %ecx 6441 6442/* ------------------------------ */ 6443.L_OP_ADD_FLOAT_2ADDR: /* 0xc6 */ 6444/* File: x86/OP_ADD_FLOAT_2ADDR.S */ 6445/* File: x86/binflop2addr.S */ 6446 /* 6447 * Generic 32-bit binary float operation. 6448 * 6449 * For: add-fp, sub-fp, mul-fp, div-fp 6450 */ 6451 6452 /* binop/2addr vA, vB */ 6453 movzx rINSTbl,%ecx # ecx<- A+ 6454 andb $0xf,%cl # ecx<- A 6455 flds (rFP,%ecx,4) # vAA to fp stack 6456 sarl $4,rINST # rINST<- B 6457 fadds (rFP,rINST,4) # ex: faddp 6458 FETCH_INST_OPCODE 1 %eax 6459 ADVANCE_PC 1 6460 fstps (rFP,%ecx,4) # %st to vA 6461 GOTO_NEXT_R %eax 6462 6463 6464/* ------------------------------ */ 6465.L_OP_SUB_FLOAT_2ADDR: /* 0xc7 */ 6466/* File: x86/OP_SUB_FLOAT_2ADDR.S */ 6467/* File: x86/binflop2addr.S */ 6468 /* 6469 * Generic 32-bit binary float operation. 6470 * 6471 * For: add-fp, sub-fp, mul-fp, div-fp 6472 */ 6473 6474 /* binop/2addr vA, vB */ 6475 movzx rINSTbl,%ecx # ecx<- A+ 6476 andb $0xf,%cl # ecx<- A 6477 flds (rFP,%ecx,4) # vAA to fp stack 6478 sarl $4,rINST # rINST<- B 6479 fsubs (rFP,rINST,4) # ex: faddp 6480 FETCH_INST_OPCODE 1 %eax 6481 ADVANCE_PC 1 6482 fstps (rFP,%ecx,4) # %st to vA 6483 GOTO_NEXT_R %eax 6484 6485 6486/* ------------------------------ */ 6487.L_OP_MUL_FLOAT_2ADDR: /* 0xc8 */ 6488/* File: x86/OP_MUL_FLOAT_2ADDR.S */ 6489/* File: x86/binflop2addr.S */ 6490 /* 6491 * Generic 32-bit binary float operation. 6492 * 6493 * For: add-fp, sub-fp, mul-fp, div-fp 6494 */ 6495 6496 /* binop/2addr vA, vB */ 6497 movzx rINSTbl,%ecx # ecx<- A+ 6498 andb $0xf,%cl # ecx<- A 6499 flds (rFP,%ecx,4) # vAA to fp stack 6500 sarl $4,rINST # rINST<- B 6501 fmuls (rFP,rINST,4) # ex: faddp 6502 FETCH_INST_OPCODE 1 %eax 6503 ADVANCE_PC 1 6504 fstps (rFP,%ecx,4) # %st to vA 6505 GOTO_NEXT_R %eax 6506 6507 6508/* ------------------------------ */ 6509.L_OP_DIV_FLOAT_2ADDR: /* 0xc9 */ 6510/* File: x86/OP_DIV_FLOAT_2ADDR.S */ 6511/* File: x86/binflop2addr.S */ 6512 /* 6513 * Generic 32-bit binary float operation. 6514 * 6515 * For: add-fp, sub-fp, mul-fp, div-fp 6516 */ 6517 6518 /* binop/2addr vA, vB */ 6519 movzx rINSTbl,%ecx # ecx<- A+ 6520 andb $0xf,%cl # ecx<- A 6521 flds (rFP,%ecx,4) # vAA to fp stack 6522 sarl $4,rINST # rINST<- B 6523 fdivs (rFP,rINST,4) # ex: faddp 6524 FETCH_INST_OPCODE 1 %eax 6525 ADVANCE_PC 1 6526 fstps (rFP,%ecx,4) # %st to vA 6527 GOTO_NEXT_R %eax 6528 6529 6530/* ------------------------------ */ 6531.L_OP_REM_FLOAT_2ADDR: /* 0xca */ 6532/* File: x86/OP_REM_FLOAT_2ADDR.S */ 6533 /* rem_float/2addr vA, vB */ 6534 movzx rINSTbl,%ecx # ecx<- A+ 6535 sarl $4,rINST # rINST<- B 6536 flds (rFP,rINST,4) # vBB to fp stack 6537 andb $0xf,%cl # ecx<- A 6538 flds (rFP,%ecx,4) # vAA to fp stack 65391: 6540 fprem 6541 fstsw %ax 6542 sahf 6543 jp 1b 6544 fstp %st(1) 6545 FETCH_INST_OPCODE 1 %eax 6546 ADVANCE_PC 1 6547 fstps (rFP,%ecx,4) # %st to vA 6548 GOTO_NEXT_R %eax 6549 6550/* ------------------------------ */ 6551.L_OP_ADD_DOUBLE_2ADDR: /* 0xcb */ 6552/* File: x86/OP_ADD_DOUBLE_2ADDR.S */ 6553/* File: x86/binflop2addr.S */ 6554 /* 6555 * Generic 32-bit binary float operation. 6556 * 6557 * For: add-fp, sub-fp, mul-fp, div-fp 6558 */ 6559 6560 /* binop/2addr vA, vB */ 6561 movzx rINSTbl,%ecx # ecx<- A+ 6562 andb $0xf,%cl # ecx<- A 6563 fldl (rFP,%ecx,4) # vAA to fp stack 6564 sarl $4,rINST # rINST<- B 6565 faddl (rFP,rINST,4) # ex: faddp 6566 FETCH_INST_OPCODE 1 %eax 6567 ADVANCE_PC 1 6568 fstpl (rFP,%ecx,4) # %st to vA 6569 GOTO_NEXT_R %eax 6570 6571 6572/* ------------------------------ */ 6573.L_OP_SUB_DOUBLE_2ADDR: /* 0xcc */ 6574/* File: x86/OP_SUB_DOUBLE_2ADDR.S */ 6575/* File: x86/binflop2addr.S */ 6576 /* 6577 * Generic 32-bit binary float operation. 6578 * 6579 * For: add-fp, sub-fp, mul-fp, div-fp 6580 */ 6581 6582 /* binop/2addr vA, vB */ 6583 movzx rINSTbl,%ecx # ecx<- A+ 6584 andb $0xf,%cl # ecx<- A 6585 fldl (rFP,%ecx,4) # vAA to fp stack 6586 sarl $4,rINST # rINST<- B 6587 fsubl (rFP,rINST,4) # ex: faddp 6588 FETCH_INST_OPCODE 1 %eax 6589 ADVANCE_PC 1 6590 fstpl (rFP,%ecx,4) # %st to vA 6591 GOTO_NEXT_R %eax 6592 6593 6594/* ------------------------------ */ 6595.L_OP_MUL_DOUBLE_2ADDR: /* 0xcd */ 6596/* File: x86/OP_MUL_DOUBLE_2ADDR.S */ 6597/* File: x86/binflop2addr.S */ 6598 /* 6599 * Generic 32-bit binary float operation. 6600 * 6601 * For: add-fp, sub-fp, mul-fp, div-fp 6602 */ 6603 6604 /* binop/2addr vA, vB */ 6605 movzx rINSTbl,%ecx # ecx<- A+ 6606 andb $0xf,%cl # ecx<- A 6607 fldl (rFP,%ecx,4) # vAA to fp stack 6608 sarl $4,rINST # rINST<- B 6609 fmull (rFP,rINST,4) # ex: faddp 6610 FETCH_INST_OPCODE 1 %eax 6611 ADVANCE_PC 1 6612 fstpl (rFP,%ecx,4) # %st to vA 6613 GOTO_NEXT_R %eax 6614 6615 6616/* ------------------------------ */ 6617.L_OP_DIV_DOUBLE_2ADDR: /* 0xce */ 6618/* File: x86/OP_DIV_DOUBLE_2ADDR.S */ 6619/* File: x86/binflop2addr.S */ 6620 /* 6621 * Generic 32-bit binary float operation. 6622 * 6623 * For: add-fp, sub-fp, mul-fp, div-fp 6624 */ 6625 6626 /* binop/2addr vA, vB */ 6627 movzx rINSTbl,%ecx # ecx<- A+ 6628 andb $0xf,%cl # ecx<- A 6629 fldl (rFP,%ecx,4) # vAA to fp stack 6630 sarl $4,rINST # rINST<- B 6631 fdivl (rFP,rINST,4) # ex: faddp 6632 FETCH_INST_OPCODE 1 %eax 6633 ADVANCE_PC 1 6634 fstpl (rFP,%ecx,4) # %st to vA 6635 GOTO_NEXT_R %eax 6636 6637 6638/* ------------------------------ */ 6639.L_OP_REM_DOUBLE_2ADDR: /* 0xcf */ 6640/* File: x86/OP_REM_DOUBLE_2ADDR.S */ 6641 /* rem_float/2addr vA, vB */ 6642 movzx rINSTbl,%ecx # ecx<- A+ 6643 sarl $4,rINST # rINST<- B 6644 fldl (rFP,rINST,4) # vBB to fp stack 6645 andb $0xf,%cl # ecx<- A 6646 fldl (rFP,%ecx,4) # vAA to fp stack 66471: 6648 fprem 6649 fstsw %ax 6650 sahf 6651 jp 1b 6652 fstp %st(1) 6653 FETCH_INST_OPCODE 1 %eax 6654 ADVANCE_PC 1 6655 fstpl (rFP,%ecx,4) # %st to vA 6656 GOTO_NEXT_R %eax 6657 6658/* ------------------------------ */ 6659.L_OP_ADD_INT_LIT16: /* 0xd0 */ 6660/* File: x86/OP_ADD_INT_LIT16.S */ 6661/* File: x86/binopLit16.S */ 6662 /* 6663 * Generic 32-bit "lit16" binary operation. Provide an "instr" line 6664 * that specifies an instruction that performs "result = eax op ecx". 6665 * This could be an x86 instruction or a function call. (If the result 6666 * comes back in a register other than eax, you can override "result".) 6667 * 6668 * For: add-int/lit16, rsub-int, 6669 * and-int/lit16, or-int/lit16, xor-int/lit16 6670 */ 6671 /* binop/lit16 vA, vB, #+CCCC */ 6672 movzbl rINSTbl,%eax # eax<- 000000BA 6673 sarl $4,%eax # eax<- B 6674 GET_VREG_R %eax %eax # eax<- vB 6675 movswl 2(rPC),%ecx # ecx<- ssssCCCC 6676 andb $0xf,rINSTbl # rINST<- A 6677 addl %ecx,%eax # for example: addl %ecx, %eax 6678 SET_VREG %eax rINST 6679 FETCH_INST_OPCODE 2 %ecx 6680 ADVANCE_PC 2 6681 GOTO_NEXT_R %ecx 6682 6683 6684/* ------------------------------ */ 6685.L_OP_RSUB_INT: /* 0xd1 */ 6686/* File: x86/OP_RSUB_INT.S */ 6687/* File: x86/binopLit16.S */ 6688 /* 6689 * Generic 32-bit "lit16" binary operation. Provide an "instr" line 6690 * that specifies an instruction that performs "result = eax op ecx". 6691 * This could be an x86 instruction or a function call. (If the result 6692 * comes back in a register other than eax, you can override "result".) 6693 * 6694 * For: add-int/lit16, rsub-int, 6695 * and-int/lit16, or-int/lit16, xor-int/lit16 6696 */ 6697 /* binop/lit16 vA, vB, #+CCCC */ 6698 movzbl rINSTbl,%eax # eax<- 000000BA 6699 sarl $4,%eax # eax<- B 6700 GET_VREG_R %eax %eax # eax<- vB 6701 movswl 2(rPC),%ecx # ecx<- ssssCCCC 6702 andb $0xf,rINSTbl # rINST<- A 6703 subl %eax,%ecx # for example: addl %ecx, %eax 6704 SET_VREG %ecx rINST 6705 FETCH_INST_OPCODE 2 %ecx 6706 ADVANCE_PC 2 6707 GOTO_NEXT_R %ecx 6708 6709 6710/* ------------------------------ */ 6711.L_OP_MUL_INT_LIT16: /* 0xd2 */ 6712/* File: x86/OP_MUL_INT_LIT16.S */ 6713 /* mul/lit16 vA, vB, #+CCCC */ 6714 /* Need A in rINST, ssssCCCC in ecx, vB in eax */ 6715 movzbl rINSTbl,%eax # eax<- 000000BA 6716 sarl $4,%eax # eax<- B 6717 GET_VREG_R %eax %eax # eax<- vB 6718 movswl 2(rPC),%ecx # ecx<- ssssCCCC 6719 andb $0xf,rINSTbl # rINST<- A 6720 SPILL(rIBASE) 6721 imull %ecx,%eax # trashes rIBASE/edx 6722 UNSPILL(rIBASE) 6723 FETCH_INST_OPCODE 2 %ecx 6724 ADVANCE_PC 2 6725 SET_VREG %eax rINST 6726 GOTO_NEXT_R %ecx 6727 6728/* ------------------------------ */ 6729.L_OP_DIV_INT_LIT16: /* 0xd3 */ 6730/* File: x86/OP_DIV_INT_LIT16.S */ 6731/* File: x86/bindivLit16.S */ 6732 /* 6733 * 32-bit binary div/rem operation. Handles special case of op0=minint and 6734 * op1=-1. 6735 */ 6736 /* div/rem/lit16 vA, vB, #+CCCC */ 6737 /* Need A in rINST, ssssCCCC in ecx, vB in eax */ 6738 movzbl rINSTbl,%eax # eax<- 000000BA 6739 SPILL(rIBASE) 6740 sarl $4,%eax # eax<- B 6741 GET_VREG_R %eax %eax # eax<- vB 6742 movswl 2(rPC),%ecx # ecx<- ssssCCCC 6743 andb $0xf,rINSTbl # rINST<- A 6744 cmpl $0,%ecx 6745 je common_errDivideByZero 6746 cmpl $-1,%ecx 6747 jne .LOP_DIV_INT_LIT16_continue_div 6748 cmpl $0x80000000,%eax 6749 jne .LOP_DIV_INT_LIT16_continue_div 6750 movl $0x80000000,%eax 6751 SET_VREG %eax rINST 6752 UNSPILL(rIBASE) 6753 FETCH_INST_OPCODE 2 %ecx 6754 ADVANCE_PC 2 6755 GOTO_NEXT_R %ecx 6756 6757.LOP_DIV_INT_LIT16_continue_div: 6758 cltd 6759 idivl %ecx 6760 SET_VREG %eax rINST 6761 UNSPILL(rIBASE) 6762 FETCH_INST_OPCODE 2 %ecx 6763 ADVANCE_PC 2 6764 GOTO_NEXT_R %ecx 6765 6766 6767/* ------------------------------ */ 6768.L_OP_REM_INT_LIT16: /* 0xd4 */ 6769/* File: x86/OP_REM_INT_LIT16.S */ 6770/* File: x86/bindivLit16.S */ 6771 /* 6772 * 32-bit binary div/rem operation. Handles special case of op0=minint and 6773 * op1=-1. 6774 */ 6775 /* div/rem/lit16 vA, vB, #+CCCC */ 6776 /* Need A in rINST, ssssCCCC in ecx, vB in eax */ 6777 movzbl rINSTbl,%eax # eax<- 000000BA 6778 SPILL(rIBASE) 6779 sarl $4,%eax # eax<- B 6780 GET_VREG_R %eax %eax # eax<- vB 6781 movswl 2(rPC),%ecx # ecx<- ssssCCCC 6782 andb $0xf,rINSTbl # rINST<- A 6783 cmpl $0,%ecx 6784 je common_errDivideByZero 6785 cmpl $-1,%ecx 6786 jne .LOP_REM_INT_LIT16_continue_div 6787 cmpl $0x80000000,%eax 6788 jne .LOP_REM_INT_LIT16_continue_div 6789 movl $0,rIBASE 6790 SET_VREG rIBASE rINST 6791 UNSPILL(rIBASE) 6792 FETCH_INST_OPCODE 2 %ecx 6793 ADVANCE_PC 2 6794 GOTO_NEXT_R %ecx 6795 6796.LOP_REM_INT_LIT16_continue_div: 6797 cltd 6798 idivl %ecx 6799 SET_VREG rIBASE rINST 6800 UNSPILL(rIBASE) 6801 FETCH_INST_OPCODE 2 %ecx 6802 ADVANCE_PC 2 6803 GOTO_NEXT_R %ecx 6804 6805 6806/* ------------------------------ */ 6807.L_OP_AND_INT_LIT16: /* 0xd5 */ 6808/* File: x86/OP_AND_INT_LIT16.S */ 6809/* File: x86/binopLit16.S */ 6810 /* 6811 * Generic 32-bit "lit16" binary operation. Provide an "instr" line 6812 * that specifies an instruction that performs "result = eax op ecx". 6813 * This could be an x86 instruction or a function call. (If the result 6814 * comes back in a register other than eax, you can override "result".) 6815 * 6816 * For: add-int/lit16, rsub-int, 6817 * and-int/lit16, or-int/lit16, xor-int/lit16 6818 */ 6819 /* binop/lit16 vA, vB, #+CCCC */ 6820 movzbl rINSTbl,%eax # eax<- 000000BA 6821 sarl $4,%eax # eax<- B 6822 GET_VREG_R %eax %eax # eax<- vB 6823 movswl 2(rPC),%ecx # ecx<- ssssCCCC 6824 andb $0xf,rINSTbl # rINST<- A 6825 andl %ecx,%eax # for example: addl %ecx, %eax 6826 SET_VREG %eax rINST 6827 FETCH_INST_OPCODE 2 %ecx 6828 ADVANCE_PC 2 6829 GOTO_NEXT_R %ecx 6830 6831 6832/* ------------------------------ */ 6833.L_OP_OR_INT_LIT16: /* 0xd6 */ 6834/* File: x86/OP_OR_INT_LIT16.S */ 6835/* File: x86/binopLit16.S */ 6836 /* 6837 * Generic 32-bit "lit16" binary operation. Provide an "instr" line 6838 * that specifies an instruction that performs "result = eax op ecx". 6839 * This could be an x86 instruction or a function call. (If the result 6840 * comes back in a register other than eax, you can override "result".) 6841 * 6842 * For: add-int/lit16, rsub-int, 6843 * and-int/lit16, or-int/lit16, xor-int/lit16 6844 */ 6845 /* binop/lit16 vA, vB, #+CCCC */ 6846 movzbl rINSTbl,%eax # eax<- 000000BA 6847 sarl $4,%eax # eax<- B 6848 GET_VREG_R %eax %eax # eax<- vB 6849 movswl 2(rPC),%ecx # ecx<- ssssCCCC 6850 andb $0xf,rINSTbl # rINST<- A 6851 orl %ecx,%eax # for example: addl %ecx, %eax 6852 SET_VREG %eax rINST 6853 FETCH_INST_OPCODE 2 %ecx 6854 ADVANCE_PC 2 6855 GOTO_NEXT_R %ecx 6856 6857 6858/* ------------------------------ */ 6859.L_OP_XOR_INT_LIT16: /* 0xd7 */ 6860/* File: x86/OP_XOR_INT_LIT16.S */ 6861/* File: x86/binopLit16.S */ 6862 /* 6863 * Generic 32-bit "lit16" binary operation. Provide an "instr" line 6864 * that specifies an instruction that performs "result = eax op ecx". 6865 * This could be an x86 instruction or a function call. (If the result 6866 * comes back in a register other than eax, you can override "result".) 6867 * 6868 * For: add-int/lit16, rsub-int, 6869 * and-int/lit16, or-int/lit16, xor-int/lit16 6870 */ 6871 /* binop/lit16 vA, vB, #+CCCC */ 6872 movzbl rINSTbl,%eax # eax<- 000000BA 6873 sarl $4,%eax # eax<- B 6874 GET_VREG_R %eax %eax # eax<- vB 6875 movswl 2(rPC),%ecx # ecx<- ssssCCCC 6876 andb $0xf,rINSTbl # rINST<- A 6877 xor %ecx,%eax # for example: addl %ecx, %eax 6878 SET_VREG %eax rINST 6879 FETCH_INST_OPCODE 2 %ecx 6880 ADVANCE_PC 2 6881 GOTO_NEXT_R %ecx 6882 6883 6884/* ------------------------------ */ 6885.L_OP_ADD_INT_LIT8: /* 0xd8 */ 6886/* File: x86/OP_ADD_INT_LIT8.S */ 6887/* File: x86/binopLit8.S */ 6888 /* 6889 * Generic 32-bit "lit8" binary operation. Provide an "instr" line 6890 * that specifies an instruction that performs "result = eax op ecx". 6891 * This could be an x86 instruction or a function call. (If the result 6892 * comes back in a register other than r0, you can override "result".) 6893 * 6894 * For: add-int/lit8, rsub-int/lit8 6895 * and-int/lit8, or-int/lit8, xor-int/lit8, 6896 * shl-int/lit8, shr-int/lit8, ushr-int/lit8 6897 */ 6898 /* binop/lit8 vAA, vBB, #+CC */ 6899 movzbl 2(rPC),%eax # eax<- BB 6900 movsbl 3(rPC),%ecx # ecx<- ssssssCC 6901 GET_VREG_R %eax %eax # eax<- rBB 6902 addl %ecx,%eax # ex: addl %ecx,%eax 6903 SET_VREG %eax rINST 6904 FETCH_INST_OPCODE 2 %ecx 6905 ADVANCE_PC 2 6906 GOTO_NEXT_R %ecx 6907 6908 6909/* ------------------------------ */ 6910.L_OP_RSUB_INT_LIT8: /* 0xd9 */ 6911/* File: x86/OP_RSUB_INT_LIT8.S */ 6912/* File: x86/binopLit8.S */ 6913 /* 6914 * Generic 32-bit "lit8" binary operation. Provide an "instr" line 6915 * that specifies an instruction that performs "result = eax op ecx". 6916 * This could be an x86 instruction or a function call. (If the result 6917 * comes back in a register other than r0, you can override "result".) 6918 * 6919 * For: add-int/lit8, rsub-int/lit8 6920 * and-int/lit8, or-int/lit8, xor-int/lit8, 6921 * shl-int/lit8, shr-int/lit8, ushr-int/lit8 6922 */ 6923 /* binop/lit8 vAA, vBB, #+CC */ 6924 movzbl 2(rPC),%eax # eax<- BB 6925 movsbl 3(rPC),%ecx # ecx<- ssssssCC 6926 GET_VREG_R %eax %eax # eax<- rBB 6927 subl %eax,%ecx # ex: addl %ecx,%eax 6928 SET_VREG %ecx rINST 6929 FETCH_INST_OPCODE 2 %ecx 6930 ADVANCE_PC 2 6931 GOTO_NEXT_R %ecx 6932 6933 6934/* ------------------------------ */ 6935.L_OP_MUL_INT_LIT8: /* 0xda */ 6936/* File: x86/OP_MUL_INT_LIT8.S */ 6937 /* mul/lit8 vAA, vBB, #+CC */ 6938 movzbl 2(rPC),%eax # eax<- BB 6939 movsbl 3(rPC),%ecx # ecx<- ssssssCC 6940 GET_VREG_R %eax %eax # eax<- rBB 6941 SPILL(rIBASE) 6942 imull %ecx,%eax # trashes rIBASE/edx 6943 UNSPILL(rIBASE) 6944 FETCH_INST_OPCODE 2 %ecx 6945 ADVANCE_PC 2 6946 SET_VREG %eax rINST 6947 GOTO_NEXT_R %ecx 6948 6949/* ------------------------------ */ 6950.L_OP_DIV_INT_LIT8: /* 0xdb */ 6951/* File: x86/OP_DIV_INT_LIT8.S */ 6952/* File: x86/bindivLit8.S */ 6953 /* 6954 * 32-bit div/rem "lit8" binary operation. Handles special case of 6955 * op0=minint & op1=-1 6956 */ 6957 /* div/rem/lit8 vAA, vBB, #+CC */ 6958 movzbl 2(rPC),%eax # eax<- BB 6959 movsbl 3(rPC),%ecx # ecx<- ssssssCC 6960 SPILL(rIBASE) 6961 GET_VREG_R %eax %eax # eax<- rBB 6962 cmpl $0,%ecx 6963 je common_errDivideByZero 6964 cmpl $0x80000000,%eax 6965 jne .LOP_DIV_INT_LIT8_continue_div 6966 cmpl $-1,%ecx 6967 jne .LOP_DIV_INT_LIT8_continue_div 6968 movl $0x80000000,%eax 6969 SET_VREG %eax rINST 6970 UNSPILL(rIBASE) 6971 FETCH_INST_OPCODE 2 %ecx 6972 ADVANCE_PC 2 6973 GOTO_NEXT_R %ecx 6974 6975.LOP_DIV_INT_LIT8_continue_div: 6976 cltd 6977 idivl %ecx 6978 SET_VREG %eax rINST 6979 UNSPILL(rIBASE) 6980 FETCH_INST_OPCODE 2 %ecx 6981 ADVANCE_PC 2 6982 GOTO_NEXT_R %ecx 6983 6984 6985/* ------------------------------ */ 6986.L_OP_REM_INT_LIT8: /* 0xdc */ 6987/* File: x86/OP_REM_INT_LIT8.S */ 6988/* File: x86/bindivLit8.S */ 6989 /* 6990 * 32-bit div/rem "lit8" binary operation. Handles special case of 6991 * op0=minint & op1=-1 6992 */ 6993 /* div/rem/lit8 vAA, vBB, #+CC */ 6994 movzbl 2(rPC),%eax # eax<- BB 6995 movsbl 3(rPC),%ecx # ecx<- ssssssCC 6996 SPILL(rIBASE) 6997 GET_VREG_R %eax %eax # eax<- rBB 6998 cmpl $0,%ecx 6999 je common_errDivideByZero 7000 cmpl $0x80000000,%eax 7001 jne .LOP_REM_INT_LIT8_continue_div 7002 cmpl $-1,%ecx 7003 jne .LOP_REM_INT_LIT8_continue_div 7004 movl $0,rIBASE 7005 SET_VREG rIBASE rINST 7006 UNSPILL(rIBASE) 7007 FETCH_INST_OPCODE 2 %ecx 7008 ADVANCE_PC 2 7009 GOTO_NEXT_R %ecx 7010 7011.LOP_REM_INT_LIT8_continue_div: 7012 cltd 7013 idivl %ecx 7014 SET_VREG rIBASE rINST 7015 UNSPILL(rIBASE) 7016 FETCH_INST_OPCODE 2 %ecx 7017 ADVANCE_PC 2 7018 GOTO_NEXT_R %ecx 7019 7020 7021/* ------------------------------ */ 7022.L_OP_AND_INT_LIT8: /* 0xdd */ 7023/* File: x86/OP_AND_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 andl %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_OR_INT_LIT8: /* 0xde */ 7048/* File: x86/OP_OR_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 orl %ecx,%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_XOR_INT_LIT8: /* 0xdf */ 7073/* File: x86/OP_XOR_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 xor %ecx,%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_SHL_INT_LIT8: /* 0xe0 */ 7098/* File: x86/OP_SHL_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 sall %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_SHR_INT_LIT8: /* 0xe1 */ 7123/* File: x86/OP_SHR_INT_LIT8.S */ 7124/* File: x86/binopLit8.S */ 7125 /* 7126 * Generic 32-bit "lit8" binary operation. Provide an "instr" line 7127 * that specifies an instruction that performs "result = eax op ecx". 7128 * This could be an x86 instruction or a function call. (If the result 7129 * comes back in a register other than r0, you can override "result".) 7130 * 7131 * For: add-int/lit8, rsub-int/lit8 7132 * and-int/lit8, or-int/lit8, xor-int/lit8, 7133 * shl-int/lit8, shr-int/lit8, ushr-int/lit8 7134 */ 7135 /* binop/lit8 vAA, vBB, #+CC */ 7136 movzbl 2(rPC),%eax # eax<- BB 7137 movsbl 3(rPC),%ecx # ecx<- ssssssCC 7138 GET_VREG_R %eax %eax # eax<- rBB 7139 sarl %cl,%eax # ex: addl %ecx,%eax 7140 SET_VREG %eax rINST 7141 FETCH_INST_OPCODE 2 %ecx 7142 ADVANCE_PC 2 7143 GOTO_NEXT_R %ecx 7144 7145 7146/* ------------------------------ */ 7147.L_OP_USHR_INT_LIT8: /* 0xe2 */ 7148/* File: x86/OP_USHR_INT_LIT8.S */ 7149/* File: x86/binopLit8.S */ 7150 /* 7151 * Generic 32-bit "lit8" binary operation. Provide an "instr" line 7152 * that specifies an instruction that performs "result = eax op ecx". 7153 * This could be an x86 instruction or a function call. (If the result 7154 * comes back in a register other than r0, you can override "result".) 7155 * 7156 * For: add-int/lit8, rsub-int/lit8 7157 * and-int/lit8, or-int/lit8, xor-int/lit8, 7158 * shl-int/lit8, shr-int/lit8, ushr-int/lit8 7159 */ 7160 /* binop/lit8 vAA, vBB, #+CC */ 7161 movzbl 2(rPC),%eax # eax<- BB 7162 movsbl 3(rPC),%ecx # ecx<- ssssssCC 7163 GET_VREG_R %eax %eax # eax<- rBB 7164 shrl %cl,%eax # ex: addl %ecx,%eax 7165 SET_VREG %eax rINST 7166 FETCH_INST_OPCODE 2 %ecx 7167 ADVANCE_PC 2 7168 GOTO_NEXT_R %ecx 7169 7170 7171/* ------------------------------ */ 7172.L_OP_IGET_VOLATILE: /* 0xe3 */ 7173/* File: x86/OP_IGET_VOLATILE.S */ 7174/* File: x86/OP_IGET.S */ 7175 /* 7176 * General 32-bit instance field get. 7177 * 7178 * for: iget, iget-object, iget-boolean, iget-byte, iget-char, iget-short 7179 */ 7180 /* op vA, vB, field@CCCC */ 7181 movl rSELF,%ecx 7182 SPILL(rIBASE) # preserve rIBASE 7183 movzwl 2(rPC),rIBASE # rIBASE<- 0000CCCC 7184 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex 7185 movzbl rINSTbl,%ecx # ecx<- BA 7186 sarl $4,%ecx # ecx<- B 7187 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields 7188 andb $0xf,rINSTbl # rINST<- A 7189 GET_VREG_R %ecx %ecx # ecx<- fp[B], the object ptr 7190 movl (%eax,rIBASE,4),%eax # resolved entry 7191 testl %eax,%eax # is resolved entry null? 7192 jne .LOP_IGET_VOLATILE_finish # no, already resolved 7193 movl rIBASE,OUT_ARG1(%esp) # needed by dvmResolveInstField 7194 movl rSELF,rIBASE 7195 EXPORT_PC 7196 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method 7197 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz 7198 SPILL_TMP1(%ecx) # save obj pointer across call 7199 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz 7200 call dvmResolveInstField # ... to dvmResolveInstField 7201 UNSPILL_TMP1(%ecx) 7202 testl %eax,%eax # returns InstrField ptr 7203 jne .LOP_IGET_VOLATILE_finish 7204 jmp common_exceptionThrown 7205 7206.LOP_IGET_VOLATILE_finish: 7207 /* 7208 * Currently: 7209 * eax holds resolved field 7210 * ecx holds object 7211 * rINST holds A 7212 */ 7213 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field 7214 testl %ecx,%ecx # object null? 7215 je common_errNullObject # object was null 7216 movl (%ecx,%eax,1),%ecx # ecx<- obj.field (8/16/32 bits) 7217 FETCH_INST_OPCODE 2 %eax 7218 UNSPILL(rIBASE) 7219 SET_VREG %ecx rINST 7220 ADVANCE_PC 2 7221 GOTO_NEXT_R %eax 7222 7223 7224/* ------------------------------ */ 7225.L_OP_IPUT_VOLATILE: /* 0xe4 */ 7226/* File: x86/OP_IPUT_VOLATILE.S */ 7227/* File: x86/OP_IPUT.S */ 7228 7229 /* 7230 * General 32-bit instance field put. 7231 * 7232 * for: iput, iput-object, iput-boolean, iput-byte, iput-char, iput-short 7233 */ 7234 /* op vA, vB, field@CCCC */ 7235 movl rSELF,%ecx 7236 SPILL (rIBASE) 7237 movzwl 2(rPC),rIBASE # rIBASE<- 0000CCCC 7238 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex 7239 movzbl rINSTbl,%ecx # ecx<- BA 7240 sarl $4,%ecx # ecx<- B 7241 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields 7242 andb $0xf,rINSTbl # rINST<- A 7243 GET_VREG_R %ecx %ecx # ecx<- fp[B], the object ptr 7244 movl (%eax,rIBASE,4),%eax # resolved entry 7245 testl %eax,%eax # is resolved entry null? 7246 jne .LOP_IPUT_VOLATILE_finish # no, already resolved 7247 movl rIBASE,OUT_ARG1(%esp) 7248 movl rSELF,rIBASE 7249 EXPORT_PC 7250 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method 7251 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz 7252 SPILL_TMP1(%ecx) # save obj pointer across call 7253 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz 7254 call dvmResolveInstField # ... to dvmResolveInstField 7255 UNSPILL_TMP1(%ecx) 7256 testl %eax,%eax # returns InstrField ptr 7257 jne .LOP_IPUT_VOLATILE_finish 7258 jmp common_exceptionThrown 7259 7260.LOP_IPUT_VOLATILE_finish: 7261 /* 7262 * Currently: 7263 * eax holds resolved field 7264 * ecx holds object 7265 * rINST holds A 7266 */ 7267 GET_VREG_R rINST rINST # rINST<- v[A] 7268 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field 7269 testl %ecx,%ecx # object null? 7270 je common_errNullObject # object was null 7271 movl rINST,(%ecx,%eax,1) # obj.field <- v[A](8/16/32 bits) 7272 FETCH_INST_OPCODE 2 %ecx 7273 UNSPILL(rIBASE) 7274 ADVANCE_PC 2 7275 GOTO_NEXT_R %ecx 7276 7277 7278/* ------------------------------ */ 7279.L_OP_SGET_VOLATILE: /* 0xe5 */ 7280/* File: x86/OP_SGET_VOLATILE.S */ 7281/* File: x86/OP_SGET.S */ 7282 /* 7283 * General 32-bit SGET handler. 7284 * 7285 * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short 7286 */ 7287 /* op vAA, field@BBBB */ 7288 movl rSELF,%ecx 7289 movzwl 2(rPC),%eax # eax<- field ref BBBB 7290 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex 7291 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields 7292 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr 7293 testl %eax,%eax # resolved entry null? 7294 je .LOP_SGET_VOLATILE_resolve # if not, make it so 7295.LOP_SGET_VOLATILE_finish: # field ptr in eax 7296 movl offStaticField_value(%eax),%eax 7297 FETCH_INST_OPCODE 2 %ecx 7298 ADVANCE_PC 2 7299 SET_VREG %eax rINST 7300 GOTO_NEXT_R %ecx 7301 7302 /* 7303 * Go resolve the field 7304 */ 7305.LOP_SGET_VOLATILE_resolve: 7306 movl rSELF,%ecx 7307 movzwl 2(rPC),%eax # eax<- field ref BBBB 7308 movl offThread_method(%ecx),%ecx # ecx<- current method 7309 EXPORT_PC # could throw, need to export 7310 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 7311 movl %eax,OUT_ARG1(%esp) 7312 movl %ecx,OUT_ARG0(%esp) 7313 SPILL(rIBASE) 7314 call dvmResolveStaticField # eax<- resolved StaticField ptr 7315 UNSPILL(rIBASE) 7316 testl %eax,%eax 7317 jne .LOP_SGET_VOLATILE_finish # success, continue 7318 jmp common_exceptionThrown # no, handle exception 7319 7320 7321/* ------------------------------ */ 7322.L_OP_SPUT_VOLATILE: /* 0xe6 */ 7323/* File: x86/OP_SPUT_VOLATILE.S */ 7324/* File: x86/OP_SPUT.S */ 7325 /* 7326 * General 32-bit SPUT handler. 7327 * 7328 * for: sput, sput-boolean, sput-byte, sput-char, sput-short 7329 */ 7330 /* op vAA, field@BBBB */ 7331 movl rSELF,%ecx 7332 movzwl 2(rPC),%eax # eax<- field ref BBBB 7333 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex 7334 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields 7335 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr 7336 testl %eax,%eax # resolved entry null? 7337 je .LOP_SPUT_VOLATILE_resolve # if not, make it so 7338.LOP_SPUT_VOLATILE_finish: # field ptr in eax 7339 GET_VREG_R rINST rINST 7340 FETCH_INST_OPCODE 2 %ecx 7341 ADVANCE_PC 2 7342 movl rINST,offStaticField_value(%eax) 7343 GOTO_NEXT_R %ecx 7344 7345 /* 7346 * Go resolve the field 7347 */ 7348.LOP_SPUT_VOLATILE_resolve: 7349 movl rSELF,%ecx 7350 movzwl 2(rPC),%eax # eax<- field ref BBBB 7351 movl offThread_method(%ecx),%ecx # ecx<- current method 7352 EXPORT_PC # could throw, need to export 7353 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 7354 movl %eax,OUT_ARG1(%esp) 7355 movl %ecx,OUT_ARG0(%esp) 7356 SPILL(rIBASE) 7357 call dvmResolveStaticField # eax<- resolved StaticField ptr 7358 UNSPILL(rIBASE) 7359 testl %eax,%eax 7360 jne .LOP_SPUT_VOLATILE_finish # success, continue 7361 jmp common_exceptionThrown # no, handle exception 7362 7363 7364/* ------------------------------ */ 7365.L_OP_IGET_OBJECT_VOLATILE: /* 0xe7 */ 7366/* File: x86/OP_IGET_OBJECT_VOLATILE.S */ 7367/* File: x86/OP_IGET.S */ 7368 /* 7369 * General 32-bit instance field get. 7370 * 7371 * for: iget, iget-object, iget-boolean, iget-byte, iget-char, iget-short 7372 */ 7373 /* op vA, vB, field@CCCC */ 7374 movl rSELF,%ecx 7375 SPILL(rIBASE) # preserve rIBASE 7376 movzwl 2(rPC),rIBASE # rIBASE<- 0000CCCC 7377 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex 7378 movzbl rINSTbl,%ecx # ecx<- BA 7379 sarl $4,%ecx # ecx<- B 7380 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields 7381 andb $0xf,rINSTbl # rINST<- A 7382 GET_VREG_R %ecx %ecx # ecx<- fp[B], the object ptr 7383 movl (%eax,rIBASE,4),%eax # resolved entry 7384 testl %eax,%eax # is resolved entry null? 7385 jne .LOP_IGET_OBJECT_VOLATILE_finish # no, already resolved 7386 movl rIBASE,OUT_ARG1(%esp) # needed by dvmResolveInstField 7387 movl rSELF,rIBASE 7388 EXPORT_PC 7389 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method 7390 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz 7391 SPILL_TMP1(%ecx) # save obj pointer across call 7392 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz 7393 call dvmResolveInstField # ... to dvmResolveInstField 7394 UNSPILL_TMP1(%ecx) 7395 testl %eax,%eax # returns InstrField ptr 7396 jne .LOP_IGET_OBJECT_VOLATILE_finish 7397 jmp common_exceptionThrown 7398 7399.LOP_IGET_OBJECT_VOLATILE_finish: 7400 /* 7401 * Currently: 7402 * eax holds resolved field 7403 * ecx holds object 7404 * rINST holds A 7405 */ 7406 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field 7407 testl %ecx,%ecx # object null? 7408 je common_errNullObject # object was null 7409 movl (%ecx,%eax,1),%ecx # ecx<- obj.field (8/16/32 bits) 7410 FETCH_INST_OPCODE 2 %eax 7411 UNSPILL(rIBASE) 7412 SET_VREG %ecx rINST 7413 ADVANCE_PC 2 7414 GOTO_NEXT_R %eax 7415 7416 7417/* ------------------------------ */ 7418.L_OP_IGET_WIDE_VOLATILE: /* 0xe8 */ 7419 /* (stub) */ 7420 SAVE_PC_FP_TO_SELF %ecx # leaves rSELF in %ecx 7421 movl %ecx,OUT_ARG0(%esp) # self is first arg to function 7422 call dvmMterp_OP_IGET_WIDE_VOLATILE # do the real work 7423 movl rSELF,%ecx 7424 LOAD_PC_FP_FROM_SELF # retrieve updated values 7425 movl offThread_curHandlerTable(%ecx),rIBASE # set up rIBASE 7426 FETCH_INST 7427 GOTO_NEXT 7428/* ------------------------------ */ 7429.L_OP_IPUT_WIDE_VOLATILE: /* 0xe9 */ 7430 /* (stub) */ 7431 SAVE_PC_FP_TO_SELF %ecx # leaves rSELF in %ecx 7432 movl %ecx,OUT_ARG0(%esp) # self is first arg to function 7433 call dvmMterp_OP_IPUT_WIDE_VOLATILE # do the real work 7434 movl rSELF,%ecx 7435 LOAD_PC_FP_FROM_SELF # retrieve updated values 7436 movl offThread_curHandlerTable(%ecx),rIBASE # set up rIBASE 7437 FETCH_INST 7438 GOTO_NEXT 7439/* ------------------------------ */ 7440.L_OP_SGET_WIDE_VOLATILE: /* 0xea */ 7441 /* (stub) */ 7442 SAVE_PC_FP_TO_SELF %ecx # leaves rSELF in %ecx 7443 movl %ecx,OUT_ARG0(%esp) # self is first arg to function 7444 call dvmMterp_OP_SGET_WIDE_VOLATILE # do the real work 7445 movl rSELF,%ecx 7446 LOAD_PC_FP_FROM_SELF # retrieve updated values 7447 movl offThread_curHandlerTable(%ecx),rIBASE # set up rIBASE 7448 FETCH_INST 7449 GOTO_NEXT 7450/* ------------------------------ */ 7451.L_OP_SPUT_WIDE_VOLATILE: /* 0xeb */ 7452 /* (stub) */ 7453 SAVE_PC_FP_TO_SELF %ecx # leaves rSELF in %ecx 7454 movl %ecx,OUT_ARG0(%esp) # self is first arg to function 7455 call dvmMterp_OP_SPUT_WIDE_VOLATILE # do the real work 7456 movl rSELF,%ecx 7457 LOAD_PC_FP_FROM_SELF # retrieve updated values 7458 movl offThread_curHandlerTable(%ecx),rIBASE # set up rIBASE 7459 FETCH_INST 7460 GOTO_NEXT 7461/* ------------------------------ */ 7462.L_OP_BREAKPOINT: /* 0xec */ 7463/* File: x86/OP_BREAKPOINT.S */ 7464/* File: x86/unused.S */ 7465 jmp common_abort 7466 7467 7468/* ------------------------------ */ 7469.L_OP_THROW_VERIFICATION_ERROR: /* 0xed */ 7470/* File: x86/OP_THROW_VERIFICATION_ERROR.S */ 7471 /* 7472 * Handle a throw-verification-error instruction. This throws an 7473 * exception for an error discovered during verification. The 7474 * exception is indicated by AA, with some detail provided by BBBB. 7475 */ 7476 /* op AA, ref@BBBB */ 7477 movl rSELF,%ecx 7478 movzwl 2(rPC),%eax # eax<- BBBB 7479 movl offThread_method(%ecx),%ecx # ecx<- self->method 7480 EXPORT_PC 7481 movl %eax,OUT_ARG2(%esp) # arg2<- BBBB 7482 movl rINST,OUT_ARG1(%esp) # arg1<- AA 7483 movl %ecx,OUT_ARG0(%esp) # arg0<- method 7484 call dvmThrowVerificationError # call(method, kind, ref) 7485 jmp common_exceptionThrown # handle exception 7486 7487/* ------------------------------ */ 7488.L_OP_EXECUTE_INLINE: /* 0xee */ 7489/* File: x86/OP_EXECUTE_INLINE.S */ 7490 /* 7491 * Execute a "native inline" instruction. 7492 * 7493 * We will be calling through a function table: 7494 * 7495 * (*gDvmInlineOpsTable[opIndex].func)(arg0, arg1, arg2, arg3, pResult) 7496 * 7497 * Ignores argument count - always loads 4. 7498 * 7499 */ 7500 /* [opt] execute-inline vAA, {vC, vD, vE, vF}, inline@BBBB */ 7501 movl rSELF,%ecx 7502 EXPORT_PC 7503 movzwl 2(rPC),%eax # eax<- BBBB 7504 leal offThread_retval(%ecx),%ecx # ecx<- & self->retval 7505 SPILL(rIBASE) # preserve rIBASE 7506 movl %ecx,OUT_ARG4(%esp) 7507 call .LOP_EXECUTE_INLINE_continue # make call; will return after 7508 UNSPILL(rIBASE) # restore rIBASE 7509 testl %eax,%eax # successful? 7510 FETCH_INST_OPCODE 3 %ecx 7511 je common_exceptionThrown # no, handle exception 7512 ADVANCE_PC 3 7513 GOTO_NEXT_R %ecx 7514 7515.LOP_EXECUTE_INLINE_continue: 7516 /* 7517 * Extract args, call function. 7518 * ecx = #of args (0-4) 7519 * eax = call index 7520 * @esp = return addr 7521 * esp is -4 from normal 7522 * 7523 * Go ahead and load all 4 args, even if not used. 7524 */ 7525 movzwl 4(rPC),rIBASE 7526 7527 movl $0xf,%ecx 7528 andl rIBASE,%ecx 7529 GET_VREG_R %ecx %ecx 7530 sarl $4,rIBASE 7531 movl %ecx,4+OUT_ARG0(%esp) 7532 7533 movl $0xf,%ecx 7534 andl rIBASE,%ecx 7535 GET_VREG_R %ecx %ecx 7536 sarl $4,rIBASE 7537 movl %ecx,4+OUT_ARG1(%esp) 7538 7539 movl $0xf,%ecx 7540 andl rIBASE,%ecx 7541 GET_VREG_R %ecx %ecx 7542 sarl $4,rIBASE 7543 movl %ecx,4+OUT_ARG2(%esp) 7544 7545 movl $0xf,%ecx 7546 andl rIBASE,%ecx 7547 GET_VREG_R %ecx %ecx 7548 sarl $4,rIBASE 7549 movl %ecx,4+OUT_ARG3(%esp) 7550 7551 sall $4,%eax # index *= sizeof(table entry) 7552 jmp *gDvmInlineOpsTable(%eax) 7553 # will return to caller of .LOP_EXECUTE_INLINE_continue 7554 7555/* ------------------------------ */ 7556.L_OP_EXECUTE_INLINE_RANGE: /* 0xef */ 7557 /* (stub) */ 7558 SAVE_PC_FP_TO_SELF %ecx # leaves rSELF in %ecx 7559 movl %ecx,OUT_ARG0(%esp) # self is first arg to function 7560 call dvmMterp_OP_EXECUTE_INLINE_RANGE # do the real work 7561 movl rSELF,%ecx 7562 LOAD_PC_FP_FROM_SELF # retrieve updated values 7563 movl offThread_curHandlerTable(%ecx),rIBASE # set up rIBASE 7564 FETCH_INST 7565 GOTO_NEXT 7566/* ------------------------------ */ 7567.L_OP_INVOKE_OBJECT_INIT: /* 0xf0 */ 7568 /* (stub) */ 7569 SAVE_PC_FP_TO_SELF %ecx # leaves rSELF in %ecx 7570 movl %ecx,OUT_ARG0(%esp) # self is first arg to function 7571 call dvmMterp_OP_INVOKE_OBJECT_INIT # do the real work 7572 movl rSELF,%ecx 7573 LOAD_PC_FP_FROM_SELF # retrieve updated values 7574 movl offThread_curHandlerTable(%ecx),rIBASE # set up rIBASE 7575 FETCH_INST 7576 GOTO_NEXT 7577/* ------------------------------ */ 7578.L_OP_RETURN_VOID_BARRIER: /* 0xf1 */ 7579 /* (stub) */ 7580 SAVE_PC_FP_TO_SELF %ecx # leaves rSELF in %ecx 7581 movl %ecx,OUT_ARG0(%esp) # self is first arg to function 7582 call dvmMterp_OP_RETURN_VOID_BARRIER # do the real work 7583 movl rSELF,%ecx 7584 LOAD_PC_FP_FROM_SELF # retrieve updated values 7585 movl offThread_curHandlerTable(%ecx),rIBASE # set up rIBASE 7586 FETCH_INST 7587 GOTO_NEXT 7588/* ------------------------------ */ 7589.L_OP_IGET_QUICK: /* 0xf2 */ 7590/* File: x86/OP_IGET_QUICK.S */ 7591 /* For: iget-quick, iget-object-quick */ 7592 /* op vA, vB, offset@CCCC */ 7593 movzbl rINSTbl,%ecx # ecx<- BA 7594 sarl $4,%ecx # ecx<- B 7595 GET_VREG_R %ecx %ecx # vB (object we're operating on) 7596 movzwl 2(rPC),%eax # eax<- field byte offset 7597 cmpl $0,%ecx # is object null? 7598 je common_errNullObject 7599 movl (%ecx,%eax,1),%eax 7600 FETCH_INST_OPCODE 2 %ecx 7601 ADVANCE_PC 2 7602 andb $0xf,rINSTbl # rINST<- A 7603 SET_VREG %eax rINST # fp[A]<- result 7604 GOTO_NEXT_R %ecx 7605 7606/* ------------------------------ */ 7607.L_OP_IGET_WIDE_QUICK: /* 0xf3 */ 7608/* File: x86/OP_IGET_WIDE_QUICK.S */ 7609 /* For: iget-wide-quick */ 7610 /* op vA, vB, offset@CCCC */ 7611 movzbl rINSTbl,%ecx # ecx<- BA 7612 sarl $4,%ecx # ecx<- B 7613 GET_VREG_R %ecx %ecx # vB (object we're operating on) 7614 movzwl 2(rPC),%eax # eax<- field byte offset 7615 cmpl $0,%ecx # is object null? 7616 je common_errNullObject 7617 leal (%ecx,%eax,1),%eax # eax<- address of 64-bit source 7618 movl (%eax),%ecx # ecx<- lsw 7619 movl 4(%eax),%eax # eax<- msw 7620 andb $0xf,rINSTbl # rINST<- A 7621 SET_VREG_WORD %ecx rINST 0 # v[A+0]<- lsw 7622 FETCH_INST_OPCODE 2 %ecx 7623 SET_VREG_WORD %eax rINST 1 # v[A+1]<- msw 7624 ADVANCE_PC 2 7625 GOTO_NEXT_R %ecx 7626 7627/* ------------------------------ */ 7628.L_OP_IGET_OBJECT_QUICK: /* 0xf4 */ 7629/* File: x86/OP_IGET_OBJECT_QUICK.S */ 7630/* File: x86/OP_IGET_QUICK.S */ 7631 /* For: iget-quick, iget-object-quick */ 7632 /* op vA, vB, offset@CCCC */ 7633 movzbl rINSTbl,%ecx # ecx<- BA 7634 sarl $4,%ecx # ecx<- B 7635 GET_VREG_R %ecx %ecx # vB (object we're operating on) 7636 movzwl 2(rPC),%eax # eax<- field byte offset 7637 cmpl $0,%ecx # is object null? 7638 je common_errNullObject 7639 movl (%ecx,%eax,1),%eax 7640 FETCH_INST_OPCODE 2 %ecx 7641 ADVANCE_PC 2 7642 andb $0xf,rINSTbl # rINST<- A 7643 SET_VREG %eax rINST # fp[A]<- result 7644 GOTO_NEXT_R %ecx 7645 7646 7647/* ------------------------------ */ 7648.L_OP_IPUT_QUICK: /* 0xf5 */ 7649/* File: x86/OP_IPUT_QUICK.S */ 7650 /* For: iput-quick */ 7651 /* op vA, vB, offset@CCCC */ 7652 movzbl rINSTbl,%ecx # ecx<- BA 7653 sarl $4,%ecx # ecx<- B 7654 GET_VREG_R %ecx %ecx # vB (object we're operating on) 7655 andb $0xf,rINSTbl # rINST<- A 7656 GET_VREG_R rINST,rINST # rINST<- v[A] 7657 movzwl 2(rPC),%eax # eax<- field byte offset 7658 testl %ecx,%ecx # is object null? 7659 je common_errNullObject 7660 movl rINST,(%ecx,%eax,1) 7661 FETCH_INST_OPCODE 2 %ecx 7662 ADVANCE_PC 2 7663 GOTO_NEXT_R %ecx 7664 7665/* ------------------------------ */ 7666.L_OP_IPUT_WIDE_QUICK: /* 0xf6 */ 7667/* File: x86/OP_IPUT_WIDE_QUICK.S */ 7668 /* For: iput-wide-quick */ 7669 /* op vA, vB, offset@CCCC */ 7670 movzbl rINSTbl,%ecx # ecx<- BA 7671 sarl $4,%ecx # ecx<- B 7672 GET_VREG_R %ecx %ecx # vB (object we're operating on) 7673 movzwl 2(rPC),%eax # eax<- field byte offset 7674 testl %ecx,%ecx # is object null? 7675 je common_errNullObject 7676 leal (%ecx,%eax,1),%ecx # ecx<- Address of 64-bit target 7677 andb $0xf,rINSTbl # rINST<- A 7678 GET_VREG_WORD %eax rINST 0 # eax<- lsw 7679 GET_VREG_WORD rINST rINST 1 # rINST<- msw 7680 movl %eax,(%ecx) 7681 movl rINST,4(%ecx) 7682 FETCH_INST_OPCODE 2 %ecx 7683 ADVANCE_PC 2 7684 GOTO_NEXT_R %ecx 7685 7686/* ------------------------------ */ 7687.L_OP_IPUT_OBJECT_QUICK: /* 0xf7 */ 7688/* File: x86/OP_IPUT_OBJECT_QUICK.S */ 7689 /* For: iput-object-quick */ 7690 /* op vA, vB, offset@CCCC */ 7691 movzbl rINSTbl,%ecx # ecx<- BA 7692 sarl $4,%ecx # ecx<- B 7693 GET_VREG_R %ecx %ecx # vB (object we're operating on) 7694 andb $0xf,rINSTbl # rINST<- A 7695 GET_VREG_R rINST rINST # rINST<- v[A] 7696 movzwl 2(rPC),%eax # eax<- field byte offset 7697 testl %ecx,%ecx # is object null? 7698 je common_errNullObject 7699 movl rINST,(%ecx,%eax,1) 7700 movl rSELF,%eax 7701 testl rINST,rINST # did we store null? 7702 movl offThread_cardTable(%eax),%eax # get card table base 7703 je 1f # skip card mark if null store 7704 shrl $GC_CARD_SHIFT,%ecx # object head to card number 7705 movb %al,(%eax,%ecx) # mark card based on object head 77061: 7707 FETCH_INST_OPCODE 2 %ecx 7708 ADVANCE_PC 2 7709 GOTO_NEXT_R %ecx 7710 7711/* ------------------------------ */ 7712.L_OP_INVOKE_VIRTUAL_QUICK: /* 0xf8 */ 7713/* File: x86/OP_INVOKE_VIRTUAL_QUICK.S */ 7714 /* 7715 * Handle an optimized virtual method call. 7716 * 7717 * for: [opt] invoke-virtual-quick, invoke-virtual-quick/range 7718 */ 7719 /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ 7720 /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ 7721 movzwl 4(rPC),%eax # eax<- FEDC or CCCC 7722 movzwl 2(rPC),%ecx # ecx<- BBBB 7723 .if (!0) 7724 andl $0xf,%eax # eax<- C (or stays CCCC) 7725 .endif 7726 GET_VREG_R %eax %eax # eax<- vC ("this" ptr) 7727 testl %eax,%eax # null? 7728 je common_errNullObject # yep, throw exception 7729 movl offObject_clazz(%eax),%eax # eax<- thisPtr->clazz 7730 movl offClassObject_vtable(%eax),%eax # eax<- thisPtr->clazz->vtable 7731 EXPORT_PC # might throw later - get ready 7732 movl (%eax,%ecx,4),%eax # eax<- vtable[BBBB] 7733 jmp common_invokeMethodNoRange 7734 7735/* ------------------------------ */ 7736.L_OP_INVOKE_VIRTUAL_QUICK_RANGE: /* 0xf9 */ 7737/* File: x86/OP_INVOKE_VIRTUAL_QUICK_RANGE.S */ 7738/* File: x86/OP_INVOKE_VIRTUAL_QUICK.S */ 7739 /* 7740 * Handle an optimized virtual method call. 7741 * 7742 * for: [opt] invoke-virtual-quick, invoke-virtual-quick/range 7743 */ 7744 /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ 7745 /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ 7746 movzwl 4(rPC),%eax # eax<- FEDC or CCCC 7747 movzwl 2(rPC),%ecx # ecx<- BBBB 7748 .if (!1) 7749 andl $0xf,%eax # eax<- C (or stays CCCC) 7750 .endif 7751 GET_VREG_R %eax %eax # eax<- vC ("this" ptr) 7752 testl %eax,%eax # null? 7753 je common_errNullObject # yep, throw exception 7754 movl offObject_clazz(%eax),%eax # eax<- thisPtr->clazz 7755 movl offClassObject_vtable(%eax),%eax # eax<- thisPtr->clazz->vtable 7756 EXPORT_PC # might throw later - get ready 7757 movl (%eax,%ecx,4),%eax # eax<- vtable[BBBB] 7758 jmp common_invokeMethodRange 7759 7760 7761/* ------------------------------ */ 7762.L_OP_INVOKE_SUPER_QUICK: /* 0xfa */ 7763/* File: x86/OP_INVOKE_SUPER_QUICK.S */ 7764 /* 7765 * Handle an optimized "super" method call. 7766 * 7767 * for: [opt] invoke-super-quick, invoke-super-quick/range 7768 */ 7769 /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ 7770 /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ 7771 movl rSELF,%ecx 7772 movzwl 4(rPC),%eax # eax<- GFED or CCCC 7773 movl offThread_method(%ecx),%ecx # ecx<- current method 7774 .if (!0) 7775 andl $0xf,%eax # eax<- D (or stays CCCC) 7776 .endif 7777 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 7778 GET_VREG_R %eax %eax # eax<- "this" 7779 movl offClassObject_super(%ecx),%ecx # ecx<- method->clazz->super 7780 testl %eax,%eax # null "this"? 7781 je common_errNullObject # "this" is null, throw exception 7782 movzwl 2(rPC),%eax # eax<- BBBB 7783 movl offClassObject_vtable(%ecx),%ecx # ecx<- vtable 7784 EXPORT_PC 7785 movl (%ecx,%eax,4),%eax # eax<- super->vtable[BBBB] 7786 jmp common_invokeMethodNoRange 7787 7788/* ------------------------------ */ 7789.L_OP_INVOKE_SUPER_QUICK_RANGE: /* 0xfb */ 7790/* File: x86/OP_INVOKE_SUPER_QUICK_RANGE.S */ 7791/* File: x86/OP_INVOKE_SUPER_QUICK.S */ 7792 /* 7793 * Handle an optimized "super" method call. 7794 * 7795 * for: [opt] invoke-super-quick, invoke-super-quick/range 7796 */ 7797 /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ 7798 /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ 7799 movl rSELF,%ecx 7800 movzwl 4(rPC),%eax # eax<- GFED or CCCC 7801 movl offThread_method(%ecx),%ecx # ecx<- current method 7802 .if (!1) 7803 andl $0xf,%eax # eax<- D (or stays CCCC) 7804 .endif 7805 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 7806 GET_VREG_R %eax %eax # eax<- "this" 7807 movl offClassObject_super(%ecx),%ecx # ecx<- method->clazz->super 7808 testl %eax,%eax # null "this"? 7809 je common_errNullObject # "this" is null, throw exception 7810 movzwl 2(rPC),%eax # eax<- BBBB 7811 movl offClassObject_vtable(%ecx),%ecx # ecx<- vtable 7812 EXPORT_PC 7813 movl (%ecx,%eax,4),%eax # eax<- super->vtable[BBBB] 7814 jmp common_invokeMethodRange 7815 7816 7817/* ------------------------------ */ 7818.L_OP_IPUT_OBJECT_VOLATILE: /* 0xfc */ 7819/* File: x86/OP_IPUT_OBJECT_VOLATILE.S */ 7820/* File: x86/OP_IPUT_OBJECT.S */ 7821 /* 7822 * Object field put. 7823 * 7824 * for: iput-object 7825 */ 7826 /* op vA, vB, field@CCCC */ 7827 movl rSELF,%ecx 7828 SPILL(rIBASE) 7829 movzwl 2(rPC),rIBASE # rIBASE<- 0000CCCC 7830 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex 7831 movzbl rINSTbl,%ecx # ecx<- BA 7832 sarl $4,%ecx # ecx<- B 7833 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields 7834 andb $0xf,rINSTbl # rINST<- A 7835 GET_VREG_R %ecx %ecx # ecx<- fp[B], the object ptr 7836 movl (%eax,rIBASE,4),%eax # resolved entry 7837 testl %eax,%eax # is resolved entry null? 7838 jne .LOP_IPUT_OBJECT_VOLATILE_finish # no, already resolved 7839 movl rIBASE,OUT_ARG1(%esp) 7840 movl rSELF,rIBASE 7841 EXPORT_PC 7842 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method 7843 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz 7844 SPILL_TMP1(%ecx) # save obj pointer across call 7845 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz 7846 call dvmResolveInstField # ... to dvmResolveInstField 7847 UNSPILL_TMP1(%ecx) 7848 testl %eax,%eax # returns InstrField ptr 7849 jne .LOP_IPUT_OBJECT_VOLATILE_finish 7850 jmp common_exceptionThrown 7851 7852.LOP_IPUT_OBJECT_VOLATILE_finish: 7853 /* 7854 * Currently: 7855 * eax holds resolved field 7856 * ecx holds object 7857 * rIBASE is scratch, but needs to be unspilled 7858 * rINST holds A 7859 */ 7860 GET_VREG_R rINST rINST # rINST<- v[A] 7861 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field 7862 testl %ecx,%ecx # object null? 7863 je common_errNullObject # object was null 7864 movl rINST,(%ecx,%eax) # obj.field <- v[A](8/16/32 bits) 7865 movl rSELF,%eax 7866 testl rINST,rINST # stored a NULL? 7867 movl offThread_cardTable(%eax),%eax # get card table base 7868 je 1f # skip card mark if null store 7869 shrl $GC_CARD_SHIFT,%ecx # object head to card number 7870 movb %al,(%eax,%ecx) # mark card using object head 78711: 7872 UNSPILL(rIBASE) 7873 FETCH_INST_OPCODE 2 %ecx 7874 ADVANCE_PC 2 7875 GOTO_NEXT_R %ecx 7876 7877 7878/* ------------------------------ */ 7879.L_OP_SGET_OBJECT_VOLATILE: /* 0xfd */ 7880/* File: x86/OP_SGET_OBJECT_VOLATILE.S */ 7881/* File: x86/OP_SGET.S */ 7882 /* 7883 * General 32-bit SGET handler. 7884 * 7885 * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short 7886 */ 7887 /* op vAA, field@BBBB */ 7888 movl rSELF,%ecx 7889 movzwl 2(rPC),%eax # eax<- field ref BBBB 7890 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex 7891 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields 7892 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr 7893 testl %eax,%eax # resolved entry null? 7894 je .LOP_SGET_OBJECT_VOLATILE_resolve # if not, make it so 7895.LOP_SGET_OBJECT_VOLATILE_finish: # field ptr in eax 7896 movl offStaticField_value(%eax),%eax 7897 FETCH_INST_OPCODE 2 %ecx 7898 ADVANCE_PC 2 7899 SET_VREG %eax rINST 7900 GOTO_NEXT_R %ecx 7901 7902 /* 7903 * Go resolve the field 7904 */ 7905.LOP_SGET_OBJECT_VOLATILE_resolve: 7906 movl rSELF,%ecx 7907 movzwl 2(rPC),%eax # eax<- field ref BBBB 7908 movl offThread_method(%ecx),%ecx # ecx<- current method 7909 EXPORT_PC # could throw, need to export 7910 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 7911 movl %eax,OUT_ARG1(%esp) 7912 movl %ecx,OUT_ARG0(%esp) 7913 SPILL(rIBASE) 7914 call dvmResolveStaticField # eax<- resolved StaticField ptr 7915 UNSPILL(rIBASE) 7916 testl %eax,%eax 7917 jne .LOP_SGET_OBJECT_VOLATILE_finish # success, continue 7918 jmp common_exceptionThrown # no, handle exception 7919 7920 7921/* ------------------------------ */ 7922.L_OP_SPUT_OBJECT_VOLATILE: /* 0xfe */ 7923/* File: x86/OP_SPUT_OBJECT_VOLATILE.S */ 7924/* File: x86/OP_SPUT_OBJECT.S */ 7925 /* 7926 * SPUT object handler. 7927 */ 7928 /* op vAA, field@BBBB */ 7929 movl rSELF,%ecx 7930 movzwl 2(rPC),%eax # eax<- field ref BBBB 7931 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex 7932 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields 7933 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField 7934 testl %eax,%eax # resolved entry null? 7935 je .LOP_SPUT_OBJECT_VOLATILE_resolve # if not, make it so 7936.LOP_SPUT_OBJECT_VOLATILE_finish: # field ptr in eax 7937 movzbl rINSTbl,%ecx # ecx<- AA 7938 GET_VREG_R %ecx %ecx 7939 movl %ecx,offStaticField_value(%eax) # do the store 7940 testl %ecx,%ecx # stored null object ptr? 7941 je 1f # skip card mark if null 7942 movl rSELF,%ecx 7943 movl offField_clazz(%eax),%eax # eax<- method->clazz 7944 movl offThread_cardTable(%ecx),%ecx # get card table base 7945 shrl $GC_CARD_SHIFT,%eax # head to card number 7946 movb %cl,(%ecx,%eax) # mark card 79471: 7948 FETCH_INST_OPCODE 2 %ecx 7949 ADVANCE_PC 2 7950 GOTO_NEXT_R %ecx 7951 7952.LOP_SPUT_OBJECT_VOLATILE_resolve: 7953 movl rSELF,%ecx 7954 movzwl 2(rPC),%eax # eax<- field ref BBBB 7955 movl offThread_method(%ecx),%ecx # ecx<- current method 7956 EXPORT_PC # could throw, need to export 7957 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 7958 movl %eax,OUT_ARG1(%esp) 7959 movl %ecx,OUT_ARG0(%esp) 7960 SPILL(rIBASE) 7961 call dvmResolveStaticField # eax<- resolved StaticField ptr 7962 UNSPILL(rIBASE) 7963 testl %eax,%eax 7964 jne .LOP_SPUT_OBJECT_VOLATILE_finish # success, continue 7965 jmp common_exceptionThrown # no, handle exception 7966 7967 7968/* ------------------------------ */ 7969.L_OP_DISPATCH_FF: /* 0xff */ 7970/* File: x86/OP_DISPATCH_FF.S */ 7971 leal 256(rINST),%ecx 7972 GOTO_NEXT_JUMBO_R %ecx 7973 7974/* ------------------------------ */ 7975.L_OP_CONST_CLASS_JUMBO: /* 0x100 */ 7976/* File: x86/OP_CONST_CLASS_JUMBO.S */ 7977 /* const-class/jumbo vBBBB, Class@AAAAAAAA */ 7978 movl rSELF,%ecx 7979 movl 2(rPC),%eax # eax<- AAAAAAAA 7980 movl offThread_methodClassDex(%ecx),%ecx# ecx<- self->methodClassDex 7981 movl offDvmDex_pResClasses(%ecx),%ecx # ecx<- dvmDex->pResClasses 7982 FETCH_INST_OPCODE 4 %ecx 7983 movl (%ecx,%eax,4),%eax # eax<- rResClasses[AAAAAAAA] 7984 testl %eax,%eax # resolved yet? 7985 je .LOP_CONST_CLASS_JUMBO_resolve 7986 SET_VREG %eax rINST # vBBBB<- rResClasses[AAAAAAAA] 7987 ADVANCE_PC 4 7988 GOTO_NEXT_R %ecx 7989 7990/* This is the less common path, so we'll redo some work 7991 here rather than force spills on the common path */ 7992.LOP_CONST_CLASS_JUMBO_resolve: 7993 movl rSELF,%eax 7994 EXPORT_PC 7995 movl offThread_method(%eax),%eax # eax<- self->method 7996 movl $1,OUT_ARG2(%esp) # true 7997 movl 2(rPC),%ecx # ecx<- AAAAAAAA 7998 movl offMethod_clazz(%eax),%eax 7999 movl %ecx,OUT_ARG1(%esp) 8000 movl %eax,OUT_ARG0(%esp) 8001 SPILL(rIBASE) 8002 call dvmResolveClass # go resolve 8003 UNSPILL(rIBASE) 8004 testl %eax,%eax # failed? 8005 je common_exceptionThrown 8006 FETCH_INST_OPCODE 4 %ecx 8007 SET_VREG %eax rINST 8008 ADVANCE_PC 4 8009 GOTO_NEXT_R %ecx 8010 8011/* ------------------------------ */ 8012.L_OP_CHECK_CAST_JUMBO: /* 0x101 */ 8013/* File: x86/OP_CHECK_CAST_JUMBO.S */ 8014 /* 8015 * Check to see if a cast from one class to another is allowed. 8016 */ 8017 /* check-cast/jumbo vBBBB, class@AAAAAAAA */ 8018 movl rSELF,%ecx 8019 GET_VREG_R rINST,rINST # rINST<- vBBBB (object) 8020 movl 2(rPC),%eax # eax<- AAAAAAAA 8021 movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex 8022 testl rINST,rINST # is oject null? 8023 movl offDvmDex_pResClasses(%ecx),%ecx # ecx<- pDvmDex->pResClasses 8024 je .LOP_CHECK_CAST_JUMBO_okay # null obj, cast always succeeds 8025 movl (%ecx,%eax,4),%eax # eax<- resolved class 8026 movl offObject_clazz(rINST),%ecx # ecx<- obj->clazz 8027 testl %eax,%eax # have we resolved this before? 8028 je .LOP_CHECK_CAST_JUMBO_resolve # no, go do it now 8029.LOP_CHECK_CAST_JUMBO_resolved: 8030 cmpl %eax,%ecx # same class (trivial success)? 8031 jne .LOP_CHECK_CAST_JUMBO_fullcheck # no, do full check 8032.LOP_CHECK_CAST_JUMBO_okay: 8033 FETCH_INST_OPCODE 4 %ecx 8034 ADVANCE_PC 4 8035 GOTO_NEXT_R %ecx 8036 8037 /* 8038 * Trivial test failed, need to perform full check. This is common. 8039 * ecx holds obj->clazz 8040 * eax holds class resolved from AAAAAAAA 8041 * rINST holds object 8042 */ 8043.LOP_CHECK_CAST_JUMBO_fullcheck: 8044 movl %eax,sReg0 # we'll need the desired class on failure 8045 movl %eax,OUT_ARG1(%esp) 8046 movl %ecx,OUT_ARG0(%esp) 8047 SPILL(rIBASE) 8048 call dvmInstanceofNonTrivial # eax<- boolean result 8049 UNSPILL(rIBASE) 8050 testl %eax,%eax # failed? 8051 jne .LOP_CHECK_CAST_JUMBO_okay # no, success 8052 8053 # A cast has failed. We need to throw a ClassCastException. 8054 EXPORT_PC 8055 movl offObject_clazz(rINST),%eax 8056 movl %eax,OUT_ARG0(%esp) # arg0<- obj->clazz 8057 movl sReg0,%ecx 8058 movl %ecx,OUT_ARG1(%esp) # arg1<- desired class 8059 call dvmThrowClassCastException 8060 jmp common_exceptionThrown 8061 8062 /* 8063 * Resolution required. This is the least-likely path, and we're 8064 * going to have to recreate some data. 8065 * 8066 * rINST holds object 8067 */ 8068.LOP_CHECK_CAST_JUMBO_resolve: 8069 movl rSELF,%ecx 8070 EXPORT_PC 8071 movl 2(rPC),%eax # eax<- AAAAAAAA 8072 movl offThread_method(%ecx),%ecx # ecx<- self->method 8073 movl %eax,OUT_ARG1(%esp) # arg1<- AAAAAAAA 8074 movl offMethod_clazz(%ecx),%ecx # ecx<- metho->clazz 8075 movl $0,OUT_ARG2(%esp) # arg2<- false 8076 movl %ecx,OUT_ARG0(%esp) # arg0<- method->clazz 8077 SPILL(rIBASE) 8078 call dvmResolveClass # eax<- resolved ClassObject ptr 8079 UNSPILL(rIBASE) 8080 testl %eax,%eax # got null? 8081 je common_exceptionThrown # yes, handle exception 8082 movl offObject_clazz(rINST),%ecx # ecx<- obj->clazz 8083 jmp .LOP_CHECK_CAST_JUMBO_resolved # pick up where we left off 8084 8085/* ------------------------------ */ 8086.L_OP_INSTANCE_OF_JUMBO: /* 0x102 */ 8087/* File: x86/OP_INSTANCE_OF_JUMBO.S */ 8088 /* 8089 * Check to see if an object reference is an instance of a class. 8090 * 8091 * Most common situation is a non-null object, being compared against 8092 * an already-resolved class. 8093 */ 8094 /* instance-of/jumbo vBBBB, vCCCC, class@AAAAAAAA */ 8095 movzwl 8(rPC),%eax # eax<- CCCC 8096 GET_VREG_R %eax %eax # eax<- vCCCC (obj) 8097 movl rSELF,%ecx 8098 testl %eax,%eax # object null? 8099 movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex 8100 SPILL(rIBASE) # preserve rIBASE 8101 je .LOP_INSTANCE_OF_JUMBO_store # null obj, not instance, store it 8102 movl 2(rPC),rIBASE # edx<- AAAAAAAA 8103 movl offDvmDex_pResClasses(%ecx),%ecx # ecx<- pDvmDex->pResClasses 8104 movl (%ecx,rIBASE,4),%ecx # ecx<- resolved class 8105 movl offObject_clazz(%eax),%eax # eax<- obj->clazz 8106 testl %ecx,%ecx # have we resolved this before? 8107 je .LOP_INSTANCE_OF_JUMBO_resolve # not resolved, do it now 8108.LOP_INSTANCE_OF_JUMBO_resolved: # eax<- obj->clazz, ecx<- resolved class 8109 cmpl %eax,%ecx # same class (trivial success)? 8110 je .LOP_INSTANCE_OF_JUMBO_trivial # yes, trivial finish 8111 /* 8112 * Trivial test failed, need to perform full check. This is common. 8113 * eax holds obj->clazz 8114 * ecx holds class resolved from BBBB 8115 * rINST has BA 8116 */ 8117 movl %eax,OUT_ARG0(%esp) 8118 movl %ecx,OUT_ARG1(%esp) 8119 call dvmInstanceofNonTrivial # eax<- boolean result 8120 # fall through to OP_INSTANCE_OF_JUMBO_store 8121 8122 /* 8123 * eax holds boolean result 8124 * rINST holds BBBB 8125 */ 8126.LOP_INSTANCE_OF_JUMBO_store: 8127 FETCH_INST_OPCODE 5 %ecx 8128 UNSPILL(rIBASE) 8129 ADVANCE_PC 5 8130 SET_VREG %eax rINST # vBBBB<- eax 8131 GOTO_NEXT_R %ecx 8132 8133 /* 8134 * Trivial test succeeded, save and bail. 8135 * r9 holds BBBB 8136 */ 8137.LOP_INSTANCE_OF_JUMBO_trivial: 8138 FETCH_INST_OPCODE 5 %ecx 8139 UNSPILL(rIBASE) 8140 ADVANCE_PC 5 8141 movl $1,%eax 8142 SET_VREG %eax rINST # vBBBB<- true 8143 GOTO_NEXT_R %ecx 8144 8145 /* 8146 * Resolution required. This is the least-likely path. 8147 * 8148 * edx holds AAAAAAAA 8149 */ 8150.LOP_INSTANCE_OF_JUMBO_resolve: 8151 movl rIBASE,OUT_ARG1(%esp) # arg1<- AAAAAAAA 8152 movl rSELF,%ecx 8153 movl offThread_method(%ecx),%ecx 8154 movl $1,OUT_ARG2(%esp) # arg2<- true 8155 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 8156 EXPORT_PC 8157 movl %ecx,OUT_ARG0(%esp) # arg0<- method->clazz 8158 call dvmResolveClass # eax<- resolved ClassObject ptr 8159 testl %eax,%eax # success? 8160 je common_exceptionThrown # no, handle exception 8161/* Now, we need to sync up with fast path. We need eax to 8162 * hold the obj->clazz, and ecx to hold the resolved class 8163 */ 8164 movl %eax,%ecx # ecx<- resolved class 8165 movzwl 8(rPC),%eax # eax<- CCCC 8166 GET_VREG_R %eax %eax # eax<- vCCCC (obj) 8167 movl offObject_clazz(%eax),%eax # eax<- obj->clazz 8168 jmp .LOP_INSTANCE_OF_JUMBO_resolved 8169 8170/* ------------------------------ */ 8171.L_OP_NEW_INSTANCE_JUMBO: /* 0x103 */ 8172/* File: x86/OP_NEW_INSTANCE_JUMBO.S */ 8173 /* 8174 * Create a new instance of a class. 8175 */ 8176 /* new-instance/jumbo vBBBB, class@AAAAAAAA */ 8177 movl rSELF,%ecx 8178 movl 2(rPC),%eax # eax<- AAAAAAAA 8179 movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex 8180 movl offDvmDex_pResClasses(%ecx),%ecx # ecx<- pDvmDex->pResClasses 8181 EXPORT_PC 8182 movl (%ecx,%eax,4),%ecx # ecx<- resolved class 8183 SPILL(rIBASE) 8184 testl %ecx,%ecx # resolved? 8185 je .LOP_NEW_INSTANCE_JUMBO_resolve # no, go do it 8186.LOP_NEW_INSTANCE_JUMBO_resolved: # on entry, ecx<- class 8187 cmpb $CLASS_INITIALIZED,offClassObject_status(%ecx) 8188 jne .LOP_NEW_INSTANCE_JUMBO_needinit 8189.LOP_NEW_INSTANCE_JUMBO_initialized: # on entry, ecx<- class 8190 /* TODO: remove test for interface/abstract, now done in verifier */ 8191 testl $(ACC_INTERFACE|ACC_ABSTRACT),offClassObject_accessFlags(%ecx) 8192 movl $ALLOC_DONT_TRACK,OUT_ARG1(%esp) 8193 jne .LOP_NEW_INSTANCE_JUMBO_abstract 8194.LOP_NEW_INSTANCE_JUMBO_finish: # ecx=class 8195 movl %ecx,OUT_ARG0(%esp) 8196 call dvmAllocObject # eax<- new object 8197 UNSPILL(rIBASE) 8198 FETCH_INST_OPCODE 4 %ecx 8199 testl %eax,%eax # success? 8200 je common_exceptionThrown # no, bail out 8201 SET_VREG %eax rINST 8202 ADVANCE_PC 4 8203 GOTO_NEXT_R %ecx 8204 8205 /* 8206 * Class initialization required. 8207 * 8208 * ecx holds class object 8209 */ 8210.LOP_NEW_INSTANCE_JUMBO_needinit: 8211 SPILL_TMP1(%ecx) # save object 8212 movl %ecx,OUT_ARG0(%esp) 8213 call dvmInitClass # initialize class 8214 UNSPILL_TMP1(%ecx) # restore object 8215 testl %eax,%eax # success? 8216 jne .LOP_NEW_INSTANCE_JUMBO_initialized # success, continue 8217 jmp common_exceptionThrown # go deal with init exception 8218 8219 /* 8220 * Resolution required. This is the least-likely path. 8221 * 8222 */ 8223.LOP_NEW_INSTANCE_JUMBO_resolve: 8224 movl rSELF,%ecx 8225 movl 2(rPC),%eax # eax<- AAAAAAAA 8226 movl offThread_method(%ecx),%ecx # ecx<- self->method 8227 movl %eax,OUT_ARG1(%esp) 8228 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 8229 movl $0,OUT_ARG2(%esp) 8230 movl %ecx,OUT_ARG0(%esp) 8231 call dvmResolveClass # call(clazz,off,flags) 8232 movl %eax,%ecx # ecx<- resolved ClassObject ptr 8233 testl %ecx,%ecx # success? 8234 jne .LOP_NEW_INSTANCE_JUMBO_resolved # good to go 8235 jmp common_exceptionThrown # no, handle exception 8236 8237 /* 8238 * TODO: remove this 8239 * We can't instantiate an abstract class or interface, so throw an 8240 * InstantiationError with the class descriptor as the message. 8241 * 8242 * ecx holds class object 8243 */ 8244.LOP_NEW_INSTANCE_JUMBO_abstract: 8245 movl offClassObject_descriptor(%ecx),%eax 8246 movl $.LstrInstantiationError,OUT_ARG0(%esp) 8247 movl %eax,OUT_ARG1(%esp) 8248 call dvmThrowExceptionWithClassMessage 8249 jmp common_exceptionThrown 8250 8251/* ------------------------------ */ 8252.L_OP_NEW_ARRAY_JUMBO: /* 0x104 */ 8253/* File: x86/OP_NEW_ARRAY_JUMBO.S */ 8254 /* 8255 * Allocate an array of objects, specified with the array class 8256 * and a count. 8257 * 8258 * The verifier guarantees that this is an array class, so we don't 8259 * check for it here. 8260 */ 8261 /* new-array/jumbo vBBBB, vCCCC, class@AAAAAAAA */ 8262 movl rSELF,%ecx 8263 EXPORT_PC 8264 movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex 8265 movl 2(rPC),%eax # eax<- AAAAAAAA 8266 movl offDvmDex_pResClasses(%ecx),%ecx # ecx<- pDvmDex->pResClasses 8267 SPILL(rIBASE) 8268 movl (%ecx,%eax,4),%ecx # ecx<- resolved class 8269 movzwl 8(rPC),%eax # eax<- CCCC 8270 GET_VREG_R %eax %eax # eax<- vCCCC (array length) 8271 testl %eax,%eax 8272 js common_errNegativeArraySize # bail, passing len in eax 8273 testl %ecx,%ecx # already resolved? 8274 jne .LOP_NEW_ARRAY_JUMBO_finish # yes, fast path 8275 /* 8276 * Resolve class. (This is an uncommon case.) 8277 * ecx holds class (null here) 8278 * eax holds array length (vCCCC) 8279 */ 8280 movl rSELF,%ecx 8281 SPILL_TMP1(%eax) # save array length 8282 movl offThread_method(%ecx),%ecx # ecx<- self->method 8283 movl 2(rPC),%eax # eax<- AAAAAAAA 8284 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 8285 movl %eax,OUT_ARG1(%esp) 8286 movl $0,OUT_ARG2(%esp) 8287 movl %ecx,OUT_ARG0(%esp) 8288 call dvmResolveClass # eax<- call(clazz,ref,flag) 8289 movl %eax,%ecx 8290 UNSPILL_TMP1(%eax) 8291 testl %ecx,%ecx # successful resolution? 8292 je common_exceptionThrown # no, bail. 8293# fall through to OP_NEW_ARRAY_JUMBO_finish 8294 8295 /* 8296 * Finish allocation 8297 * 8298 * ecx holds class 8299 * eax holds array length (vCCCC) 8300 */ 8301.LOP_NEW_ARRAY_JUMBO_finish: 8302 movl %ecx,OUT_ARG0(%esp) 8303 movl %eax,OUT_ARG1(%esp) 8304 movl $ALLOC_DONT_TRACK,OUT_ARG2(%esp) 8305 call dvmAllocArrayByClass # eax<- call(clazz,length,flags) 8306 UNSPILL(rIBASE) 8307 FETCH_INST_OPCODE 5 %ecx 8308 testl %eax,%eax # failed? 8309 je common_exceptionThrown # yup - go handle 8310 SET_VREG %eax rINST 8311 ADVANCE_PC 5 8312 GOTO_NEXT_R %ecx 8313 8314/* ------------------------------ */ 8315.L_OP_FILLED_NEW_ARRAY_JUMBO: /* 0x105 */ 8316/* File: x86/OP_FILLED_NEW_ARRAY_JUMBO.S */ 8317 /* 8318 * Create a new array with elements filled from registers. 8319 */ 8320 /* filled-new-array/jumbo {vCCCC..v(CCCC+BBBB-1)}, type@AAAAAAAA */ 8321 movl rSELF,%eax 8322 movl offThread_methodClassDex(%eax),%eax # eax<- pDvmDex 8323 movl 2(rPC),%ecx # ecx<- AAAAAAAA 8324 movl offDvmDex_pResClasses(%eax),%eax # eax<- pDvmDex->pResClasses 8325 movl (%eax,%ecx,4),%eax # eax<- resolved class 8326 EXPORT_PC 8327 testl %eax,%eax # already resolved? 8328 jne .LOP_FILLED_NEW_ARRAY_JUMBO_continue # yes, continue 8329 # less frequent path, so we'll redo some work 8330 movl rSELF,%eax 8331 movl $0,OUT_ARG2(%esp) # arg2<- false 8332 movl %ecx,OUT_ARG1(%esp) # arg1<- AAAAAAAA 8333 movl offThread_method(%eax),%eax # eax<- self->method 8334 movl offMethod_clazz(%eax),%eax # eax<- method->clazz 8335 movl %eax,OUT_ARG0(%esp) # arg0<- clazz 8336 SPILL(rIBASE) 8337 call dvmResolveClass # eax<- call(clazz,ref,flag) 8338 UNSPILL(rIBASE) 8339 testl %eax,%eax # null? 8340 je common_exceptionThrown # yes, handle it 8341 8342 # note: fall through to .LOP_FILLED_NEW_ARRAY_JUMBO_continue 8343 8344 /* 8345 * On entry: 8346 * eax holds array class [r0] 8347 * ecx is scratch 8348 */ 8349.LOP_FILLED_NEW_ARRAY_JUMBO_continue: 8350 movl offClassObject_descriptor(%eax),%ecx # ecx<- arrayClass->descriptor 8351 movl $ALLOC_DONT_TRACK,OUT_ARG2(%esp) # arg2<- flags 8352 movzbl 1(%ecx),%ecx # ecx<- descriptor[1] 8353 movl %eax,OUT_ARG0(%esp) # arg0<- arrayClass 8354 movl rSELF,%eax 8355 cmpb $'I',%cl # supported? 8356 je 1f 8357 cmpb $'L',%cl 8358 je 1f 8359 cmpb $'[',%cl 8360 jne .LOP_FILLED_NEW_ARRAY_JUMBO_notimpl # no, not handled yet 83611: 8362 movl %ecx,offThread_retval+4(%eax) # save type 8363 movl rINST,OUT_ARG1(%esp) # arg1<- BBBB (length) 8364 SPILL(rIBASE) 8365 call dvmAllocArrayByClass # eax<- call(arrayClass, length, flags) 8366 UNSPILL(rIBASE) 8367 movl rSELF,%ecx 8368 testl %eax,%eax # alloc successful? 8369 je common_exceptionThrown # no, handle exception 8370 movl %eax,offThread_retval(%ecx) # retval.l<- new array 8371 movzwl 8(rPC),%ecx # ecx<- CCCC 8372 leal offArrayObject_contents(%eax),%eax # eax<- newArray->contents 8373 8374/* at this point: 8375 * eax is pointer to tgt 8376 * rINST is length 8377 * ecx is CCCC 8378 * We now need to copy values from registers into the array 8379 */ 8380 8381 # set up src pointer 8382 SPILL_TMP2(%esi) 8383 SPILL_TMP3(%edi) 8384 leal (rFP,%ecx,4),%esi # set up src ptr 8385 movl %eax,%edi # set up dst ptr 8386 movl rINST,%ecx # load count register 8387 rep 8388 movsd 8389 UNSPILL_TMP2(%esi) 8390 UNSPILL_TMP3(%edi) 8391 movl rSELF,%ecx 8392 movl offThread_retval+4(%ecx),%eax # eax<- type 8393 8394 cmpb $'I',%al # Int array? 8395 je 5f # skip card mark if so 8396 movl offThread_retval(%ecx),%eax # eax<- object head 8397 movl offThread_cardTable(%ecx),%ecx # card table base 8398 shrl $GC_CARD_SHIFT,%eax # convert to card num 8399 movb %cl,(%ecx,%eax) # mark card based on object head 84005: 8401 FETCH_INST_OPCODE 5 %ecx 8402 ADVANCE_PC 5 8403 GOTO_NEXT_R %ecx 8404 8405 8406 /* 8407 * Throw an exception indicating that we have not implemented this 8408 * mode of filled-new-array. 8409 */ 8410.LOP_FILLED_NEW_ARRAY_JUMBO_notimpl: 8411 movl $.LstrInternalErrorA,%eax 8412 movl %eax,OUT_ARG0(%esp) 8413 movl $.LstrFilledNewArrayNotImplA,%eax 8414 movl %eax,OUT_ARG1(%esp) 8415 call dvmThrowException 8416 jmp common_exceptionThrown 8417 8418/* ------------------------------ */ 8419.L_OP_IGET_JUMBO: /* 0x106 */ 8420/* File: x86/OP_IGET_JUMBO.S */ 8421 /* 8422 * Jumbo 32-bit instance field get. 8423 * 8424 * for: iget/jumbo, iget-object/jumbo, iget-boolean/jumbo, iget-byte/jumbo, 8425 * iget-char/jumbo, iget-short/jumbo 8426 */ 8427 /* exop vBBBB, vCCCC, field@AAAAAAAA */ 8428 movl rSELF,%ecx 8429 SPILL(rIBASE) # preserve rIBASE 8430 movl 2(rPC),rIBASE # rIBASE<- AAAAAAAA 8431 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex 8432 movzwl 8(rPC),%ecx # ecx<- CCCC 8433 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields 8434 GET_VREG_R %ecx %ecx # ecx<- fp[CCCC], the object ptr 8435 movl (%eax,rIBASE,4),%eax # resolved entry 8436 testl %eax,%eax # is resolved entry null? 8437 jne .LOP_IGET_JUMBO_finish # no, already resolved 8438 movl rIBASE,OUT_ARG1(%esp) # needed by dvmResolveInstField 8439 movl rSELF,rIBASE 8440 EXPORT_PC 8441 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method 8442 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz 8443 SPILL_TMP1(%ecx) # save obj pointer across call 8444 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz 8445 call dvmResolveInstField # ... to dvmResolveInstField 8446 UNSPILL_TMP1(%ecx) 8447 testl %eax,%eax # returns InstrField ptr 8448 jne .LOP_IGET_JUMBO_finish 8449 jmp common_exceptionThrown 8450 8451.LOP_IGET_JUMBO_finish: 8452 /* 8453 * Currently: 8454 * eax holds resolved field 8455 * ecx holds object 8456 * rINST holds BBBB 8457 */ 8458 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field 8459 testl %ecx,%ecx # object null? 8460 je common_errNullObject # object was null 8461 movl (%ecx,%eax,1),%ecx # ecx<- obj.field (8/16/32 bits) 8462 FETCH_INST_OPCODE 5 %eax 8463 UNSPILL(rIBASE) # restore rIBASE 8464 SET_VREG %ecx rINST 8465 ADVANCE_PC 5 8466 GOTO_NEXT_R %eax 8467 8468/* ------------------------------ */ 8469.L_OP_IGET_WIDE_JUMBO: /* 0x107 */ 8470/* File: x86/OP_IGET_WIDE_JUMBO.S */ 8471 /* 8472 * Jumbo 64-bit instance field get. 8473 */ 8474 /* iget-wide/jumbo vBBBB, vCCCC, field@AAAA */ 8475 movl rSELF,%ecx 8476 SPILL(rIBASE) # preserve rIBASE 8477 movl 2(rPC),rIBASE # rIBASE<- AAAAAAAA 8478 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex 8479 movzwl 8(rPC),%ecx # ecx<- CCCC 8480 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields 8481 GET_VREG_R %ecx %ecx # ecx<- fp[CCCC], the object ptr 8482 movl (%eax,rIBASE,4),%eax # resolved entry 8483 testl %eax,%eax # is resolved entry null? 8484 jne .LOP_IGET_WIDE_JUMBO_finish # no, already resolved 8485 movl rIBASE,OUT_ARG1(%esp) # for dvmResolveInstField 8486 movl rSELF,rIBASE 8487 EXPORT_PC 8488 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method 8489 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz 8490 SPILL_TMP1(%ecx) # save objpointer across call 8491 movl rPC,OUT_ARG0(%esp) # pass in method->clazz 8492 call dvmResolveInstField # ... to dvmResolveInstField 8493 UNSPILL_TMP1(%ecx) 8494 testl %eax,%eax # returns InstrField ptr 8495 jne .LOP_IGET_WIDE_JUMBO_finish 8496 jmp common_exceptionThrown 8497 8498.LOP_IGET_WIDE_JUMBO_finish: 8499 /* 8500 * Currently: 8501 * eax holds resolved field 8502 * ecx holds object 8503 * rINST holds BBBB 8504 */ 8505 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field 8506 testl %ecx,%ecx # object null? 8507 je common_errNullObject # object was null 8508 leal (%ecx,%eax,1),%eax # eax<- address of field 8509 movl (%eax),%ecx # ecx<- lsw 8510 movl 4(%eax),%eax # eax<- msw 8511 SET_VREG_WORD %ecx rINST 0 8512 FETCH_INST_OPCODE 5 %ecx 8513 UNSPILL(rIBASE) # restore rIBASE 8514 SET_VREG_WORD %eax rINST 1 8515 ADVANCE_PC 5 8516 GOTO_NEXT_R %ecx 8517 8518/* ------------------------------ */ 8519.L_OP_IGET_OBJECT_JUMBO: /* 0x108 */ 8520/* File: x86/OP_IGET_OBJECT_JUMBO.S */ 8521/* File: x86/OP_IGET_JUMBO.S */ 8522 /* 8523 * Jumbo 32-bit instance field get. 8524 * 8525 * for: iget/jumbo, iget-object/jumbo, iget-boolean/jumbo, iget-byte/jumbo, 8526 * iget-char/jumbo, iget-short/jumbo 8527 */ 8528 /* exop vBBBB, vCCCC, field@AAAAAAAA */ 8529 movl rSELF,%ecx 8530 SPILL(rIBASE) # preserve rIBASE 8531 movl 2(rPC),rIBASE # rIBASE<- AAAAAAAA 8532 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex 8533 movzwl 8(rPC),%ecx # ecx<- CCCC 8534 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields 8535 GET_VREG_R %ecx %ecx # ecx<- fp[CCCC], the object ptr 8536 movl (%eax,rIBASE,4),%eax # resolved entry 8537 testl %eax,%eax # is resolved entry null? 8538 jne .LOP_IGET_OBJECT_JUMBO_finish # no, already resolved 8539 movl rIBASE,OUT_ARG1(%esp) # needed by dvmResolveInstField 8540 movl rSELF,rIBASE 8541 EXPORT_PC 8542 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method 8543 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz 8544 SPILL_TMP1(%ecx) # save obj pointer across call 8545 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz 8546 call dvmResolveInstField # ... to dvmResolveInstField 8547 UNSPILL_TMP1(%ecx) 8548 testl %eax,%eax # returns InstrField ptr 8549 jne .LOP_IGET_OBJECT_JUMBO_finish 8550 jmp common_exceptionThrown 8551 8552.LOP_IGET_OBJECT_JUMBO_finish: 8553 /* 8554 * Currently: 8555 * eax holds resolved field 8556 * ecx holds object 8557 * rINST holds BBBB 8558 */ 8559 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field 8560 testl %ecx,%ecx # object null? 8561 je common_errNullObject # object was null 8562 movl (%ecx,%eax,1),%ecx # ecx<- obj.field (8/16/32 bits) 8563 FETCH_INST_OPCODE 5 %eax 8564 UNSPILL(rIBASE) # restore rIBASE 8565 SET_VREG %ecx rINST 8566 ADVANCE_PC 5 8567 GOTO_NEXT_R %eax 8568 8569 8570/* ------------------------------ */ 8571.L_OP_IGET_BOOLEAN_JUMBO: /* 0x109 */ 8572/* File: x86/OP_IGET_BOOLEAN_JUMBO.S */ 8573/* File: x86/OP_IGET_JUMBO.S */ 8574 /* 8575 * Jumbo 32-bit instance field get. 8576 * 8577 * for: iget/jumbo, iget-object/jumbo, iget-boolean/jumbo, iget-byte/jumbo, 8578 * iget-char/jumbo, iget-short/jumbo 8579 */ 8580 /* exop vBBBB, vCCCC, field@AAAAAAAA */ 8581 movl rSELF,%ecx 8582 SPILL(rIBASE) # preserve rIBASE 8583 movl 2(rPC),rIBASE # rIBASE<- AAAAAAAA 8584 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex 8585 movzwl 8(rPC),%ecx # ecx<- CCCC 8586 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields 8587 GET_VREG_R %ecx %ecx # ecx<- fp[CCCC], the object ptr 8588 movl (%eax,rIBASE,4),%eax # resolved entry 8589 testl %eax,%eax # is resolved entry null? 8590 jne .LOP_IGET_BOOLEAN_JUMBO_finish # no, already resolved 8591 movl rIBASE,OUT_ARG1(%esp) # needed by dvmResolveInstField 8592 movl rSELF,rIBASE 8593 EXPORT_PC 8594 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method 8595 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz 8596 SPILL_TMP1(%ecx) # save obj pointer across call 8597 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz 8598 call dvmResolveInstField # ... to dvmResolveInstField 8599 UNSPILL_TMP1(%ecx) 8600 testl %eax,%eax # returns InstrField ptr 8601 jne .LOP_IGET_BOOLEAN_JUMBO_finish 8602 jmp common_exceptionThrown 8603 8604.LOP_IGET_BOOLEAN_JUMBO_finish: 8605 /* 8606 * Currently: 8607 * eax holds resolved field 8608 * ecx holds object 8609 * rINST holds BBBB 8610 */ 8611 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field 8612 testl %ecx,%ecx # object null? 8613 je common_errNullObject # object was null 8614 movzbl (%ecx,%eax,1),%ecx # ecx<- obj.field (8/16/32 bits) 8615 FETCH_INST_OPCODE 5 %eax 8616 UNSPILL(rIBASE) # restore rIBASE 8617 SET_VREG %ecx rINST 8618 ADVANCE_PC 5 8619 GOTO_NEXT_R %eax 8620 8621 8622/* ------------------------------ */ 8623.L_OP_IGET_BYTE_JUMBO: /* 0x10a */ 8624/* File: x86/OP_IGET_BYTE_JUMBO.S */ 8625/* File: x86/OP_IGET_JUMBO.S */ 8626 /* 8627 * Jumbo 32-bit instance field get. 8628 * 8629 * for: iget/jumbo, iget-object/jumbo, iget-boolean/jumbo, iget-byte/jumbo, 8630 * iget-char/jumbo, iget-short/jumbo 8631 */ 8632 /* exop vBBBB, vCCCC, field@AAAAAAAA */ 8633 movl rSELF,%ecx 8634 SPILL(rIBASE) # preserve rIBASE 8635 movl 2(rPC),rIBASE # rIBASE<- AAAAAAAA 8636 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex 8637 movzwl 8(rPC),%ecx # ecx<- CCCC 8638 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields 8639 GET_VREG_R %ecx %ecx # ecx<- fp[CCCC], the object ptr 8640 movl (%eax,rIBASE,4),%eax # resolved entry 8641 testl %eax,%eax # is resolved entry null? 8642 jne .LOP_IGET_BYTE_JUMBO_finish # no, already resolved 8643 movl rIBASE,OUT_ARG1(%esp) # needed by dvmResolveInstField 8644 movl rSELF,rIBASE 8645 EXPORT_PC 8646 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method 8647 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz 8648 SPILL_TMP1(%ecx) # save obj pointer across call 8649 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz 8650 call dvmResolveInstField # ... to dvmResolveInstField 8651 UNSPILL_TMP1(%ecx) 8652 testl %eax,%eax # returns InstrField ptr 8653 jne .LOP_IGET_BYTE_JUMBO_finish 8654 jmp common_exceptionThrown 8655 8656.LOP_IGET_BYTE_JUMBO_finish: 8657 /* 8658 * Currently: 8659 * eax holds resolved field 8660 * ecx holds object 8661 * rINST holds BBBB 8662 */ 8663 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field 8664 testl %ecx,%ecx # object null? 8665 je common_errNullObject # object was null 8666 movsbl (%ecx,%eax,1),%ecx # ecx<- obj.field (8/16/32 bits) 8667 FETCH_INST_OPCODE 5 %eax 8668 UNSPILL(rIBASE) # restore rIBASE 8669 SET_VREG %ecx rINST 8670 ADVANCE_PC 5 8671 GOTO_NEXT_R %eax 8672 8673 8674/* ------------------------------ */ 8675.L_OP_IGET_CHAR_JUMBO: /* 0x10b */ 8676/* File: x86/OP_IGET_CHAR_JUMBO.S */ 8677/* File: x86/OP_IGET_JUMBO.S */ 8678 /* 8679 * Jumbo 32-bit instance field get. 8680 * 8681 * for: iget/jumbo, iget-object/jumbo, iget-boolean/jumbo, iget-byte/jumbo, 8682 * iget-char/jumbo, iget-short/jumbo 8683 */ 8684 /* exop vBBBB, vCCCC, field@AAAAAAAA */ 8685 movl rSELF,%ecx 8686 SPILL(rIBASE) # preserve rIBASE 8687 movl 2(rPC),rIBASE # rIBASE<- AAAAAAAA 8688 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex 8689 movzwl 8(rPC),%ecx # ecx<- CCCC 8690 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields 8691 GET_VREG_R %ecx %ecx # ecx<- fp[CCCC], the object ptr 8692 movl (%eax,rIBASE,4),%eax # resolved entry 8693 testl %eax,%eax # is resolved entry null? 8694 jne .LOP_IGET_CHAR_JUMBO_finish # no, already resolved 8695 movl rIBASE,OUT_ARG1(%esp) # needed by dvmResolveInstField 8696 movl rSELF,rIBASE 8697 EXPORT_PC 8698 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method 8699 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz 8700 SPILL_TMP1(%ecx) # save obj pointer across call 8701 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz 8702 call dvmResolveInstField # ... to dvmResolveInstField 8703 UNSPILL_TMP1(%ecx) 8704 testl %eax,%eax # returns InstrField ptr 8705 jne .LOP_IGET_CHAR_JUMBO_finish 8706 jmp common_exceptionThrown 8707 8708.LOP_IGET_CHAR_JUMBO_finish: 8709 /* 8710 * Currently: 8711 * eax holds resolved field 8712 * ecx holds object 8713 * rINST holds BBBB 8714 */ 8715 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field 8716 testl %ecx,%ecx # object null? 8717 je common_errNullObject # object was null 8718 movzwl (%ecx,%eax,1),%ecx # ecx<- obj.field (8/16/32 bits) 8719 FETCH_INST_OPCODE 5 %eax 8720 UNSPILL(rIBASE) # restore rIBASE 8721 SET_VREG %ecx rINST 8722 ADVANCE_PC 5 8723 GOTO_NEXT_R %eax 8724 8725 8726/* ------------------------------ */ 8727.L_OP_IGET_SHORT_JUMBO: /* 0x10c */ 8728/* File: x86/OP_IGET_SHORT_JUMBO.S */ 8729/* File: x86/OP_IGET_JUMBO.S */ 8730 /* 8731 * Jumbo 32-bit instance field get. 8732 * 8733 * for: iget/jumbo, iget-object/jumbo, iget-boolean/jumbo, iget-byte/jumbo, 8734 * iget-char/jumbo, iget-short/jumbo 8735 */ 8736 /* exop vBBBB, vCCCC, field@AAAAAAAA */ 8737 movl rSELF,%ecx 8738 SPILL(rIBASE) # preserve rIBASE 8739 movl 2(rPC),rIBASE # rIBASE<- AAAAAAAA 8740 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex 8741 movzwl 8(rPC),%ecx # ecx<- CCCC 8742 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields 8743 GET_VREG_R %ecx %ecx # ecx<- fp[CCCC], the object ptr 8744 movl (%eax,rIBASE,4),%eax # resolved entry 8745 testl %eax,%eax # is resolved entry null? 8746 jne .LOP_IGET_SHORT_JUMBO_finish # no, already resolved 8747 movl rIBASE,OUT_ARG1(%esp) # needed by dvmResolveInstField 8748 movl rSELF,rIBASE 8749 EXPORT_PC 8750 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method 8751 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz 8752 SPILL_TMP1(%ecx) # save obj pointer across call 8753 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz 8754 call dvmResolveInstField # ... to dvmResolveInstField 8755 UNSPILL_TMP1(%ecx) 8756 testl %eax,%eax # returns InstrField ptr 8757 jne .LOP_IGET_SHORT_JUMBO_finish 8758 jmp common_exceptionThrown 8759 8760.LOP_IGET_SHORT_JUMBO_finish: 8761 /* 8762 * Currently: 8763 * eax holds resolved field 8764 * ecx holds object 8765 * rINST holds BBBB 8766 */ 8767 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field 8768 testl %ecx,%ecx # object null? 8769 je common_errNullObject # object was null 8770 movswl (%ecx,%eax,1),%ecx # ecx<- obj.field (8/16/32 bits) 8771 FETCH_INST_OPCODE 5 %eax 8772 UNSPILL(rIBASE) # restore rIBASE 8773 SET_VREG %ecx rINST 8774 ADVANCE_PC 5 8775 GOTO_NEXT_R %eax 8776 8777 8778/* ------------------------------ */ 8779.L_OP_IPUT_JUMBO: /* 0x10d */ 8780/* File: x86/OP_IPUT_JUMBO.S */ 8781 /* 8782 * Jumbo 32-bit instance field put. 8783 * 8784 * for: iput/jumbo, iput-object/jumbo, iput-boolean/jumbo, iput-byte/jumbo, 8785 iput-char/jumbo, iput-short/jumbo 8786 */ 8787 /* exop vBBBB, vCCCC, field@AAAAAAAA */ 8788 movl rSELF,%ecx 8789 SPILL(rIBASE) 8790 movl 2(rPC),rIBASE # rIBASE<- AAAAAAAA 8791 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex 8792 movzwl 8(rPC),%ecx # ecx<- CCCC 8793 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields 8794 GET_VREG_R %ecx %ecx # ecx<- fp[CCCC], the object ptr 8795 movl (%eax,rIBASE,4),%eax # resolved entry 8796 testl %eax,%eax # is resolved entry null? 8797 jne .LOP_IPUT_JUMBO_finish # no, already resolved 8798 movl rIBASE,OUT_ARG1(%esp) 8799 movl rSELF,rIBASE 8800 EXPORT_PC 8801 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method 8802 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz 8803 SPILL_TMP1(%ecx) # save obj pointer across call 8804 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz 8805 call dvmResolveInstField # ... to dvmResolveInstField 8806 UNSPILL_TMP1(%ecx) 8807 testl %eax,%eax # returns InstrField ptr 8808 jne .LOP_IPUT_JUMBO_finish 8809 jmp common_exceptionThrown 8810 8811.LOP_IPUT_JUMBO_finish: 8812 /* 8813 * Currently: 8814 * eax holds resolved field 8815 * ecx holds object 8816 * rINST holds BBBB 8817 */ 8818 GET_VREG_R rINST rINST # rINST<- v[BBBB] 8819 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field 8820 testl %ecx,%ecx # object null? 8821 je common_errNullObject # object was null 8822 movl rINST,(%ecx,%eax,1) # obj.field <- v[BBBB](8/16/32 bits) 8823 FETCH_INST_OPCODE 5 %ecx 8824 UNSPILL(rIBASE) 8825 ADVANCE_PC 5 8826 GOTO_NEXT_R %ecx 8827 8828/* ------------------------------ */ 8829.L_OP_IPUT_WIDE_JUMBO: /* 0x10e */ 8830/* File: x86/OP_IPUT_WIDE_JUMBO.S */ 8831 /* 8832 * Jumbo 64-bit instance field put. 8833 */ 8834 /* iput-wide/jumbo vBBBB, vCCCC, field@AAAAAAAA */ 8835 movl rSELF,%ecx 8836 SPILL(rIBASE) 8837 movl 2(rPC),rIBASE # rIBASE<- AAAAAAAA 8838 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex 8839 movzwl 8(rPC),%ecx # ecx<- CCCC 8840 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields 8841 GET_VREG_R %ecx %ecx # ecx<- fp[CCCC], the object ptr 8842 movl (%eax,rIBASE,4),%eax # resolved entry 8843 testl %eax,%eax # is resolved entry null? 8844 jne .LOP_IPUT_WIDE_JUMBO_finish # no, already resolved 8845 movl rIBASE,OUT_ARG1(%esp) 8846 movl rSELF,rIBASE 8847 EXPORT_PC 8848 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method 8849 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz 8850 SPILL_TMP1(%ecx) # save obj pointer across call 8851 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz 8852 call dvmResolveInstField # ... to dvmResolveInstField 8853 UNSPILL_TMP1(%ecx) 8854 testl %eax,%eax # ... which returns InstrField ptr 8855 jne .LOP_IPUT_WIDE_JUMBO_finish 8856 jmp common_exceptionThrown 8857 8858.LOP_IPUT_WIDE_JUMBO_finish: 8859 /* 8860 * Currently: 8861 * eax holds resolved field 8862 * ecx holds object 8863 * rIBASE is scratch, but needs to be unspilled 8864 * rINST holds BBBB 8865 */ 8866 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field 8867 testl %ecx,%ecx # object null? 8868 je common_errNullObject # object was null 8869 leal (%ecx,%eax,1),%eax # eax<- address of field 8870 GET_VREG_WORD %ecx rINST 0 # ecx<- lsw 8871 GET_VREG_WORD rINST rINST 1 # rINST<- msw 8872 movl rINST,4(%eax) 8873 movl %ecx,(%eax) 8874 FETCH_INST_OPCODE 5 %ecx 8875 UNSPILL(rIBASE) 8876 ADVANCE_PC 5 8877 GOTO_NEXT_R %ecx 8878 8879/* ------------------------------ */ 8880.L_OP_IPUT_OBJECT_JUMBO: /* 0x10f */ 8881/* File: x86/OP_IPUT_OBJECT_JUMBO.S */ 8882 /* 8883 * Jumbo object field put. 8884 */ 8885 /* iput-object/jumbo vBBBB, vCCCC, field@AAAAAAAA */ 8886 movl rSELF,%ecx 8887 SPILL(rIBASE) 8888 movl 2(rPC),rIBASE # rIBASE<- AAAAAAAA 8889 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex 8890 movzwl 8(rPC),%ecx # ecx<- CCCC 8891 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields 8892 GET_VREG_R %ecx %ecx # ecx<- fp[CCCC], the object ptr 8893 movl (%eax,rIBASE,4),%eax # resolved entry 8894 testl %eax,%eax # is resolved entry null? 8895 jne .LOP_IPUT_OBJECT_JUMBO_finish # no, already resolved 8896 movl rIBASE,OUT_ARG1(%esp) 8897 movl rSELF,rIBASE 8898 EXPORT_PC 8899 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method 8900 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz 8901 SPILL_TMP1(%ecx) # save obj pointer across call 8902 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz 8903 call dvmResolveInstField # ... to dvmResolveInstField 8904 UNSPILL_TMP1(%ecx) 8905 testl %eax,%eax # returns InstrField ptr 8906 jne .LOP_IPUT_OBJECT_JUMBO_finish 8907 jmp common_exceptionThrown 8908 8909.LOP_IPUT_OBJECT_JUMBO_finish: 8910 /* 8911 * Currently: 8912 * eax holds resolved field 8913 * ecx holds object 8914 * rIBASE is scratch, but needs to be unspilled 8915 * rINST holds BBBB 8916 */ 8917 GET_VREG_R rINST rINST # rINST<- v[BBBB] 8918 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field 8919 testl %ecx,%ecx # object null? 8920 je common_errNullObject # object was null 8921 movl rINST,(%ecx,%eax) # obj.field <- v[BBBB](8/16/32 bits) 8922 movl rSELF,%eax 8923 testl rINST,rINST # stored a NULL? 8924 movl offThread_cardTable(%eax),%eax # get card table base 8925 je 1f # skip card mark if null store 8926 shrl $GC_CARD_SHIFT,%ecx # object head to card number 8927 movb %al,(%eax,%ecx) # mark card using object head 89281: 8929 FETCH_INST_OPCODE 5 %ecx 8930 UNSPILL(rIBASE) 8931 ADVANCE_PC 5 8932 GOTO_NEXT_R %ecx 8933 8934/* ------------------------------ */ 8935.L_OP_IPUT_BOOLEAN_JUMBO: /* 0x110 */ 8936/* File: x86/OP_IPUT_BOOLEAN_JUMBO.S */ 8937/* File: x86/OP_IPUT_JUMBO.S */ 8938 /* 8939 * Jumbo 32-bit instance field put. 8940 * 8941 * for: iput/jumbo, iput-object/jumbo, iput-boolean/jumbo, iput-byte/jumbo, 8942 iput-char/jumbo, iput-short/jumbo 8943 */ 8944 /* exop vBBBB, vCCCC, field@AAAAAAAA */ 8945 movl rSELF,%ecx 8946 SPILL(rIBASE) 8947 movl 2(rPC),rIBASE # rIBASE<- AAAAAAAA 8948 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex 8949 movzwl 8(rPC),%ecx # ecx<- CCCC 8950 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields 8951 GET_VREG_R %ecx %ecx # ecx<- fp[CCCC], the object ptr 8952 movl (%eax,rIBASE,4),%eax # resolved entry 8953 testl %eax,%eax # is resolved entry null? 8954 jne .LOP_IPUT_BOOLEAN_JUMBO_finish # no, already resolved 8955 movl rIBASE,OUT_ARG1(%esp) 8956 movl rSELF,rIBASE 8957 EXPORT_PC 8958 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method 8959 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz 8960 SPILL_TMP1(%ecx) # save obj pointer across call 8961 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz 8962 call dvmResolveInstField # ... to dvmResolveInstField 8963 UNSPILL_TMP1(%ecx) 8964 testl %eax,%eax # returns InstrField ptr 8965 jne .LOP_IPUT_BOOLEAN_JUMBO_finish 8966 jmp common_exceptionThrown 8967 8968.LOP_IPUT_BOOLEAN_JUMBO_finish: 8969 /* 8970 * Currently: 8971 * eax holds resolved field 8972 * ecx holds object 8973 * rINST holds BBBB 8974 */ 8975 GET_VREG_R rINST rINST # rINST<- v[BBBB] 8976 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field 8977 testl %ecx,%ecx # object null? 8978 je common_errNullObject # object was null 8979 movb rINSTbl,(%ecx,%eax,1) # obj.field <- v[BBBB](8/16/32 bits) 8980 FETCH_INST_OPCODE 5 %ecx 8981 UNSPILL(rIBASE) 8982 ADVANCE_PC 5 8983 GOTO_NEXT_R %ecx 8984 8985 8986/* ------------------------------ */ 8987.L_OP_IPUT_BYTE_JUMBO: /* 0x111 */ 8988/* File: x86/OP_IPUT_BYTE_JUMBO.S */ 8989/* File: x86/OP_IPUT_JUMBO.S */ 8990 /* 8991 * Jumbo 32-bit instance field put. 8992 * 8993 * for: iput/jumbo, iput-object/jumbo, iput-boolean/jumbo, iput-byte/jumbo, 8994 iput-char/jumbo, iput-short/jumbo 8995 */ 8996 /* exop vBBBB, vCCCC, field@AAAAAAAA */ 8997 movl rSELF,%ecx 8998 SPILL(rIBASE) 8999 movl 2(rPC),rIBASE # rIBASE<- AAAAAAAA 9000 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex 9001 movzwl 8(rPC),%ecx # ecx<- CCCC 9002 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields 9003 GET_VREG_R %ecx %ecx # ecx<- fp[CCCC], the object ptr 9004 movl (%eax,rIBASE,4),%eax # resolved entry 9005 testl %eax,%eax # is resolved entry null? 9006 jne .LOP_IPUT_BYTE_JUMBO_finish # no, already resolved 9007 movl rIBASE,OUT_ARG1(%esp) 9008 movl rSELF,rIBASE 9009 EXPORT_PC 9010 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method 9011 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz 9012 SPILL_TMP1(%ecx) # save obj pointer across call 9013 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz 9014 call dvmResolveInstField # ... to dvmResolveInstField 9015 UNSPILL_TMP1(%ecx) 9016 testl %eax,%eax # returns InstrField ptr 9017 jne .LOP_IPUT_BYTE_JUMBO_finish 9018 jmp common_exceptionThrown 9019 9020.LOP_IPUT_BYTE_JUMBO_finish: 9021 /* 9022 * Currently: 9023 * eax holds resolved field 9024 * ecx holds object 9025 * rINST holds BBBB 9026 */ 9027 GET_VREG_R rINST rINST # rINST<- v[BBBB] 9028 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field 9029 testl %ecx,%ecx # object null? 9030 je common_errNullObject # object was null 9031 movb rINSTbl,(%ecx,%eax,1) # obj.field <- v[BBBB](8/16/32 bits) 9032 FETCH_INST_OPCODE 5 %ecx 9033 UNSPILL(rIBASE) 9034 ADVANCE_PC 5 9035 GOTO_NEXT_R %ecx 9036 9037 9038/* ------------------------------ */ 9039.L_OP_IPUT_CHAR_JUMBO: /* 0x112 */ 9040/* File: x86/OP_IPUT_CHAR_JUMBO.S */ 9041/* File: x86/OP_IPUT_JUMBO.S */ 9042 /* 9043 * Jumbo 32-bit instance field put. 9044 * 9045 * for: iput/jumbo, iput-object/jumbo, iput-boolean/jumbo, iput-byte/jumbo, 9046 iput-char/jumbo, iput-short/jumbo 9047 */ 9048 /* exop vBBBB, vCCCC, field@AAAAAAAA */ 9049 movl rSELF,%ecx 9050 SPILL(rIBASE) 9051 movl 2(rPC),rIBASE # rIBASE<- AAAAAAAA 9052 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex 9053 movzwl 8(rPC),%ecx # ecx<- CCCC 9054 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields 9055 GET_VREG_R %ecx %ecx # ecx<- fp[CCCC], the object ptr 9056 movl (%eax,rIBASE,4),%eax # resolved entry 9057 testl %eax,%eax # is resolved entry null? 9058 jne .LOP_IPUT_CHAR_JUMBO_finish # no, already resolved 9059 movl rIBASE,OUT_ARG1(%esp) 9060 movl rSELF,rIBASE 9061 EXPORT_PC 9062 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method 9063 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz 9064 SPILL_TMP1(%ecx) # save obj pointer across call 9065 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz 9066 call dvmResolveInstField # ... to dvmResolveInstField 9067 UNSPILL_TMP1(%ecx) 9068 testl %eax,%eax # returns InstrField ptr 9069 jne .LOP_IPUT_CHAR_JUMBO_finish 9070 jmp common_exceptionThrown 9071 9072.LOP_IPUT_CHAR_JUMBO_finish: 9073 /* 9074 * Currently: 9075 * eax holds resolved field 9076 * ecx holds object 9077 * rINST holds BBBB 9078 */ 9079 GET_VREG_R rINST rINST # rINST<- v[BBBB] 9080 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field 9081 testl %ecx,%ecx # object null? 9082 je common_errNullObject # object was null 9083 movw rINSTw,(%ecx,%eax,1) # obj.field <- v[BBBB](8/16/32 bits) 9084 FETCH_INST_OPCODE 5 %ecx 9085 UNSPILL(rIBASE) 9086 ADVANCE_PC 5 9087 GOTO_NEXT_R %ecx 9088 9089 9090/* ------------------------------ */ 9091.L_OP_IPUT_SHORT_JUMBO: /* 0x113 */ 9092/* File: x86/OP_IPUT_SHORT_JUMBO.S */ 9093/* File: x86/OP_IPUT_JUMBO.S */ 9094 /* 9095 * Jumbo 32-bit instance field put. 9096 * 9097 * for: iput/jumbo, iput-object/jumbo, iput-boolean/jumbo, iput-byte/jumbo, 9098 iput-char/jumbo, iput-short/jumbo 9099 */ 9100 /* exop vBBBB, vCCCC, field@AAAAAAAA */ 9101 movl rSELF,%ecx 9102 SPILL(rIBASE) 9103 movl 2(rPC),rIBASE # rIBASE<- AAAAAAAA 9104 movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex 9105 movzwl 8(rPC),%ecx # ecx<- CCCC 9106 movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields 9107 GET_VREG_R %ecx %ecx # ecx<- fp[CCCC], the object ptr 9108 movl (%eax,rIBASE,4),%eax # resolved entry 9109 testl %eax,%eax # is resolved entry null? 9110 jne .LOP_IPUT_SHORT_JUMBO_finish # no, already resolved 9111 movl rIBASE,OUT_ARG1(%esp) 9112 movl rSELF,rIBASE 9113 EXPORT_PC 9114 movl offThread_method(rIBASE),rIBASE # rIBASE<- current method 9115 movl offMethod_clazz(rIBASE),rIBASE # rIBASE<- method->clazz 9116 SPILL_TMP1(%ecx) # save obj pointer across call 9117 movl rIBASE,OUT_ARG0(%esp) # pass in method->clazz 9118 call dvmResolveInstField # ... to dvmResolveInstField 9119 UNSPILL_TMP1(%ecx) 9120 testl %eax,%eax # returns InstrField ptr 9121 jne .LOP_IPUT_SHORT_JUMBO_finish 9122 jmp common_exceptionThrown 9123 9124.LOP_IPUT_SHORT_JUMBO_finish: 9125 /* 9126 * Currently: 9127 * eax holds resolved field 9128 * ecx holds object 9129 * rINST holds BBBB 9130 */ 9131 GET_VREG_R rINST rINST # rINST<- v[BBBB] 9132 movl offInstField_byteOffset(%eax),%eax # eax<- byte offset of field 9133 testl %ecx,%ecx # object null? 9134 je common_errNullObject # object was null 9135 movw rINSTw,(%ecx,%eax,1) # obj.field <- v[BBBB](8/16/32 bits) 9136 FETCH_INST_OPCODE 5 %ecx 9137 UNSPILL(rIBASE) 9138 ADVANCE_PC 5 9139 GOTO_NEXT_R %ecx 9140 9141 9142/* ------------------------------ */ 9143.L_OP_SGET_JUMBO: /* 0x114 */ 9144/* File: x86/OP_SGET_JUMBO.S */ 9145 /* 9146 * Jumbo 32-bit SGET handler. 9147 * 9148 * for: sget/jumbo, sget-object/jumbo, sget-boolean/jumbo, sget-byte/jumbo, 9149 * sget-char/jumbo, sget-short/jumbo 9150 */ 9151 /* exop vBBBB, field@AAAAAAAA */ 9152 movl rSELF,%ecx 9153 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex 9154 movl 2(rPC),%eax # eax<- field ref AAAAAAAA 9155 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields 9156 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr 9157 testl %eax,%eax # resolved entry null? 9158 je .LOP_SGET_JUMBO_resolve # if not, make it so 9159.LOP_SGET_JUMBO_finish: # field ptr in eax 9160 movl offStaticField_value(%eax),%eax 9161 FETCH_INST_OPCODE 4 %ecx 9162 ADVANCE_PC 4 9163 SET_VREG %eax rINST 9164 GOTO_NEXT_R %ecx 9165 9166 /* 9167 * Go resolve the field 9168 */ 9169.LOP_SGET_JUMBO_resolve: 9170 movl rSELF,%ecx 9171 movl 2(rPC),%eax # eax<- field ref AAAAAAAA 9172 movl offThread_method(%ecx),%ecx # ecx<- current method 9173 EXPORT_PC # could throw, need to export 9174 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 9175 movl %eax,OUT_ARG1(%esp) 9176 movl %ecx,OUT_ARG0(%esp) 9177 SPILL(rIBASE) 9178 call dvmResolveStaticField # eax<- resolved StaticField ptr 9179 UNSPILL(rIBASE) 9180 testl %eax,%eax 9181 jne .LOP_SGET_JUMBO_finish # success, continue 9182 jmp common_exceptionThrown # no, handle exception 9183 9184/* ------------------------------ */ 9185.L_OP_SGET_WIDE_JUMBO: /* 0x115 */ 9186/* File: x86/OP_SGET_WIDE_JUMBO.S */ 9187 /* 9188 * Jumbo 64-bit SGET handler. 9189 * 9190 */ 9191 /* sget-wide/jumbo vBBBB, field@AAAAAAAA */ 9192 movl rSELF,%ecx 9193 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex 9194 movl 2(rPC),%eax # eax<- field ref AAAAAAAA 9195 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields 9196 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr 9197 testl %eax,%eax # resolved entry null? 9198 je .LOP_SGET_WIDE_JUMBO_resolve # if not, make it so 9199.LOP_SGET_WIDE_JUMBO_finish: # field ptr in eax 9200 movl offStaticField_value(%eax),%ecx # ecx<- lsw 9201 movl 4+offStaticField_value(%eax),%eax # eax<- msw 9202 SET_VREG_WORD %ecx rINST 0 9203 FETCH_INST_OPCODE 2 %ecx 9204 SET_VREG_WORD %eax rINST 1 9205 ADVANCE_PC 2 9206 GOTO_NEXT_R %ecx 9207 9208 /* 9209 * Go resolve the field 9210 */ 9211.LOP_SGET_WIDE_JUMBO_resolve: 9212 movl rSELF,%ecx 9213 movl 2(rPC),%eax # eax<- field ref AAAAAAAA 9214 movl offThread_method(%ecx),%ecx # ecx<- current method 9215 EXPORT_PC # could throw, need to export 9216 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 9217 movl %eax,OUT_ARG1(%esp) 9218 movl %ecx,OUT_ARG0(%esp) 9219 SPILL(rIBASE) 9220 call dvmResolveStaticField # eax<- resolved StaticField ptr 9221 UNSPILL(rIBASE) 9222 testl %eax,%eax 9223 jne .LOP_SGET_WIDE_JUMBO_finish # success, continue 9224 jmp common_exceptionThrown # no, handle exception 9225 9226/* ------------------------------ */ 9227.L_OP_SGET_OBJECT_JUMBO: /* 0x116 */ 9228/* File: x86/OP_SGET_OBJECT_JUMBO.S */ 9229/* File: x86/OP_SGET_JUMBO.S */ 9230 /* 9231 * Jumbo 32-bit SGET handler. 9232 * 9233 * for: sget/jumbo, sget-object/jumbo, sget-boolean/jumbo, sget-byte/jumbo, 9234 * sget-char/jumbo, sget-short/jumbo 9235 */ 9236 /* exop vBBBB, field@AAAAAAAA */ 9237 movl rSELF,%ecx 9238 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex 9239 movl 2(rPC),%eax # eax<- field ref AAAAAAAA 9240 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields 9241 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr 9242 testl %eax,%eax # resolved entry null? 9243 je .LOP_SGET_OBJECT_JUMBO_resolve # if not, make it so 9244.LOP_SGET_OBJECT_JUMBO_finish: # field ptr in eax 9245 movl offStaticField_value(%eax),%eax 9246 FETCH_INST_OPCODE 4 %ecx 9247 ADVANCE_PC 4 9248 SET_VREG %eax rINST 9249 GOTO_NEXT_R %ecx 9250 9251 /* 9252 * Go resolve the field 9253 */ 9254.LOP_SGET_OBJECT_JUMBO_resolve: 9255 movl rSELF,%ecx 9256 movl 2(rPC),%eax # eax<- field ref AAAAAAAA 9257 movl offThread_method(%ecx),%ecx # ecx<- current method 9258 EXPORT_PC # could throw, need to export 9259 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 9260 movl %eax,OUT_ARG1(%esp) 9261 movl %ecx,OUT_ARG0(%esp) 9262 SPILL(rIBASE) 9263 call dvmResolveStaticField # eax<- resolved StaticField ptr 9264 UNSPILL(rIBASE) 9265 testl %eax,%eax 9266 jne .LOP_SGET_OBJECT_JUMBO_finish # success, continue 9267 jmp common_exceptionThrown # no, handle exception 9268 9269 9270/* ------------------------------ */ 9271.L_OP_SGET_BOOLEAN_JUMBO: /* 0x117 */ 9272/* File: x86/OP_SGET_BOOLEAN_JUMBO.S */ 9273/* File: x86/OP_SGET_JUMBO.S */ 9274 /* 9275 * Jumbo 32-bit SGET handler. 9276 * 9277 * for: sget/jumbo, sget-object/jumbo, sget-boolean/jumbo, sget-byte/jumbo, 9278 * sget-char/jumbo, sget-short/jumbo 9279 */ 9280 /* exop vBBBB, field@AAAAAAAA */ 9281 movl rSELF,%ecx 9282 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex 9283 movl 2(rPC),%eax # eax<- field ref AAAAAAAA 9284 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields 9285 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr 9286 testl %eax,%eax # resolved entry null? 9287 je .LOP_SGET_BOOLEAN_JUMBO_resolve # if not, make it so 9288.LOP_SGET_BOOLEAN_JUMBO_finish: # field ptr in eax 9289 movl offStaticField_value(%eax),%eax 9290 FETCH_INST_OPCODE 4 %ecx 9291 ADVANCE_PC 4 9292 SET_VREG %eax rINST 9293 GOTO_NEXT_R %ecx 9294 9295 /* 9296 * Go resolve the field 9297 */ 9298.LOP_SGET_BOOLEAN_JUMBO_resolve: 9299 movl rSELF,%ecx 9300 movl 2(rPC),%eax # eax<- field ref AAAAAAAA 9301 movl offThread_method(%ecx),%ecx # ecx<- current method 9302 EXPORT_PC # could throw, need to export 9303 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 9304 movl %eax,OUT_ARG1(%esp) 9305 movl %ecx,OUT_ARG0(%esp) 9306 SPILL(rIBASE) 9307 call dvmResolveStaticField # eax<- resolved StaticField ptr 9308 UNSPILL(rIBASE) 9309 testl %eax,%eax 9310 jne .LOP_SGET_BOOLEAN_JUMBO_finish # success, continue 9311 jmp common_exceptionThrown # no, handle exception 9312 9313 9314/* ------------------------------ */ 9315.L_OP_SGET_BYTE_JUMBO: /* 0x118 */ 9316/* File: x86/OP_SGET_BYTE_JUMBO.S */ 9317/* File: x86/OP_SGET_JUMBO.S */ 9318 /* 9319 * Jumbo 32-bit SGET handler. 9320 * 9321 * for: sget/jumbo, sget-object/jumbo, sget-boolean/jumbo, sget-byte/jumbo, 9322 * sget-char/jumbo, sget-short/jumbo 9323 */ 9324 /* exop vBBBB, field@AAAAAAAA */ 9325 movl rSELF,%ecx 9326 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex 9327 movl 2(rPC),%eax # eax<- field ref AAAAAAAA 9328 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields 9329 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr 9330 testl %eax,%eax # resolved entry null? 9331 je .LOP_SGET_BYTE_JUMBO_resolve # if not, make it so 9332.LOP_SGET_BYTE_JUMBO_finish: # field ptr in eax 9333 movl offStaticField_value(%eax),%eax 9334 FETCH_INST_OPCODE 4 %ecx 9335 ADVANCE_PC 4 9336 SET_VREG %eax rINST 9337 GOTO_NEXT_R %ecx 9338 9339 /* 9340 * Go resolve the field 9341 */ 9342.LOP_SGET_BYTE_JUMBO_resolve: 9343 movl rSELF,%ecx 9344 movl 2(rPC),%eax # eax<- field ref AAAAAAAA 9345 movl offThread_method(%ecx),%ecx # ecx<- current method 9346 EXPORT_PC # could throw, need to export 9347 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 9348 movl %eax,OUT_ARG1(%esp) 9349 movl %ecx,OUT_ARG0(%esp) 9350 SPILL(rIBASE) 9351 call dvmResolveStaticField # eax<- resolved StaticField ptr 9352 UNSPILL(rIBASE) 9353 testl %eax,%eax 9354 jne .LOP_SGET_BYTE_JUMBO_finish # success, continue 9355 jmp common_exceptionThrown # no, handle exception 9356 9357 9358/* ------------------------------ */ 9359.L_OP_SGET_CHAR_JUMBO: /* 0x119 */ 9360/* File: x86/OP_SGET_CHAR_JUMBO.S */ 9361/* File: x86/OP_SGET_JUMBO.S */ 9362 /* 9363 * Jumbo 32-bit SGET handler. 9364 * 9365 * for: sget/jumbo, sget-object/jumbo, sget-boolean/jumbo, sget-byte/jumbo, 9366 * sget-char/jumbo, sget-short/jumbo 9367 */ 9368 /* exop vBBBB, field@AAAAAAAA */ 9369 movl rSELF,%ecx 9370 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex 9371 movl 2(rPC),%eax # eax<- field ref AAAAAAAA 9372 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields 9373 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr 9374 testl %eax,%eax # resolved entry null? 9375 je .LOP_SGET_CHAR_JUMBO_resolve # if not, make it so 9376.LOP_SGET_CHAR_JUMBO_finish: # field ptr in eax 9377 movl offStaticField_value(%eax),%eax 9378 FETCH_INST_OPCODE 4 %ecx 9379 ADVANCE_PC 4 9380 SET_VREG %eax rINST 9381 GOTO_NEXT_R %ecx 9382 9383 /* 9384 * Go resolve the field 9385 */ 9386.LOP_SGET_CHAR_JUMBO_resolve: 9387 movl rSELF,%ecx 9388 movl 2(rPC),%eax # eax<- field ref AAAAAAAA 9389 movl offThread_method(%ecx),%ecx # ecx<- current method 9390 EXPORT_PC # could throw, need to export 9391 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 9392 movl %eax,OUT_ARG1(%esp) 9393 movl %ecx,OUT_ARG0(%esp) 9394 SPILL(rIBASE) 9395 call dvmResolveStaticField # eax<- resolved StaticField ptr 9396 UNSPILL(rIBASE) 9397 testl %eax,%eax 9398 jne .LOP_SGET_CHAR_JUMBO_finish # success, continue 9399 jmp common_exceptionThrown # no, handle exception 9400 9401 9402/* ------------------------------ */ 9403.L_OP_SGET_SHORT_JUMBO: /* 0x11a */ 9404/* File: x86/OP_SGET_SHORT_JUMBO.S */ 9405/* File: x86/OP_SGET_JUMBO.S */ 9406 /* 9407 * Jumbo 32-bit SGET handler. 9408 * 9409 * for: sget/jumbo, sget-object/jumbo, sget-boolean/jumbo, sget-byte/jumbo, 9410 * sget-char/jumbo, sget-short/jumbo 9411 */ 9412 /* exop vBBBB, field@AAAAAAAA */ 9413 movl rSELF,%ecx 9414 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex 9415 movl 2(rPC),%eax # eax<- field ref AAAAAAAA 9416 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields 9417 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr 9418 testl %eax,%eax # resolved entry null? 9419 je .LOP_SGET_SHORT_JUMBO_resolve # if not, make it so 9420.LOP_SGET_SHORT_JUMBO_finish: # field ptr in eax 9421 movl offStaticField_value(%eax),%eax 9422 FETCH_INST_OPCODE 4 %ecx 9423 ADVANCE_PC 4 9424 SET_VREG %eax rINST 9425 GOTO_NEXT_R %ecx 9426 9427 /* 9428 * Go resolve the field 9429 */ 9430.LOP_SGET_SHORT_JUMBO_resolve: 9431 movl rSELF,%ecx 9432 movl 2(rPC),%eax # eax<- field ref AAAAAAAA 9433 movl offThread_method(%ecx),%ecx # ecx<- current method 9434 EXPORT_PC # could throw, need to export 9435 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 9436 movl %eax,OUT_ARG1(%esp) 9437 movl %ecx,OUT_ARG0(%esp) 9438 SPILL(rIBASE) 9439 call dvmResolveStaticField # eax<- resolved StaticField ptr 9440 UNSPILL(rIBASE) 9441 testl %eax,%eax 9442 jne .LOP_SGET_SHORT_JUMBO_finish # success, continue 9443 jmp common_exceptionThrown # no, handle exception 9444 9445 9446/* ------------------------------ */ 9447.L_OP_SPUT_JUMBO: /* 0x11b */ 9448/* File: x86/OP_SPUT_JUMBO.S */ 9449 /* 9450 * Jumbo 32-bit SPUT handler. 9451 * 9452 * for: sput/jumbo, sput-boolean/jumbo, sput-byte/jumbo, sput-char/jumbo, 9453 * sput-short/jumbo 9454 */ 9455 /* exop vBBBB, field@AAAAAAAA */ 9456 movl rSELF,%ecx 9457 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex 9458 movl 2(rPC),%eax # eax<- field ref AAAAAAAA 9459 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields 9460 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr 9461 testl %eax,%eax # resolved entry null? 9462 je .LOP_SPUT_JUMBO_resolve # if not, make it so 9463.LOP_SPUT_JUMBO_finish: # field ptr in eax 9464 GET_VREG_R rINST rINST 9465 FETCH_INST_OPCODE 4 %ecx 9466 ADVANCE_PC 4 9467 movl rINST,offStaticField_value(%eax) 9468 GOTO_NEXT_R %ecx 9469 9470 /* 9471 * Go resolve the field 9472 */ 9473.LOP_SPUT_JUMBO_resolve: 9474 movl rSELF,%ecx 9475 movl 2(rPC),%eax # eax<- field ref AAAAAAAA 9476 movl offThread_method(%ecx),%ecx # ecx<- current method 9477 EXPORT_PC # could throw, need to export 9478 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 9479 movl %eax,OUT_ARG1(%esp) 9480 movl %ecx,OUT_ARG0(%esp) 9481 SPILL(rIBASE) 9482 call dvmResolveStaticField # eax<- resolved StaticField ptr 9483 UNSPILL(rIBASE) 9484 testl %eax,%eax 9485 jne .LOP_SPUT_JUMBO_finish # success, continue 9486 jmp common_exceptionThrown # no, handle exception 9487 9488/* ------------------------------ */ 9489.L_OP_SPUT_WIDE_JUMBO: /* 0x11c */ 9490/* File: x86/OP_SPUT_WIDE_JUMBO.S */ 9491 /* 9492 * Jumbo 64-bit SPUT handler. 9493 */ 9494 /* sput-wide/jumbo vBBBB, field@AAAAAAAA */ 9495 movl rSELF,%ecx 9496 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex 9497 movl 2(rPC),%eax # eax<- field ref AAAAAAAA 9498 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields 9499 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr 9500 testl %eax,%eax # resolved entry null? 9501 je .LOP_SPUT_WIDE_JUMBO_resolve # if not, make it so 9502.LOP_SPUT_WIDE_JUMBO_finish: # field ptr in eax 9503 GET_VREG_WORD %ecx rINST 0 # ecx<- lsw 9504 GET_VREG_WORD rINST rINST 1 # rINST<- msw 9505 movl %ecx,offStaticField_value(%eax) 9506 FETCH_INST_OPCODE 4 %ecx 9507 movl rINST,4+offStaticField_value(%eax) 9508 ADVANCE_PC 4 9509 GOTO_NEXT_R %ecx 9510 9511 /* 9512 * Go resolve the field 9513 */ 9514.LOP_SPUT_WIDE_JUMBO_resolve: 9515 movl rSELF,%ecx 9516 movl 2(rPC),%eax # eax<- field ref AAAAAAAA 9517 movl offThread_method(%ecx),%ecx # ecx<- current method 9518 EXPORT_PC # could throw, need to export 9519 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 9520 movl %eax,OUT_ARG1(%esp) 9521 movl %ecx,OUT_ARG0(%esp) 9522 SPILL(rIBASE) 9523 call dvmResolveStaticField # eax<- resolved StaticField ptr 9524 UNSPILL(rIBASE) 9525 testl %eax,%eax 9526 jne .LOP_SPUT_WIDE_JUMBO_finish # success, continue 9527 jmp common_exceptionThrown # no, handle exception 9528 9529/* ------------------------------ */ 9530.L_OP_SPUT_OBJECT_JUMBO: /* 0x11d */ 9531/* File: x86/OP_SPUT_OBJECT_JUMBO.S */ 9532 /* 9533 * Jumbo SPUT object handler. 9534 */ 9535 /* sput-object/jumbo vBBBB, field@AAAAAAAA */ 9536 movl rSELF,%ecx 9537 movl 2(rPC),%eax # eax<- field ref AAAAAAAA 9538 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex 9539 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields 9540 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField 9541 testl %eax,%eax # resolved entry null? 9542 je .LOP_SPUT_OBJECT_JUMBO_resolve # if not, make it so 9543.LOP_SPUT_OBJECT_JUMBO_finish: # field ptr in eax 9544 GET_VREG_R %ecx rINST 9545 movl %ecx,offStaticField_value(%eax) # do the store 9546 testl %ecx,%ecx # stored null object ptr? 9547 je 1f # skip card mark if null 9548 movl rSELF,%ecx 9549 movl offField_clazz(%eax),%eax # eax<- method->clazz 9550 movl offThread_cardTable(%ecx),%ecx # get card table base 9551 shrl $GC_CARD_SHIFT,%eax # head to card number 9552 movb %cl,(%ecx,%eax) # mark card 95531: 9554 FETCH_INST_OPCODE 4 %ecx 9555 ADVANCE_PC 4 9556 GOTO_NEXT_R %ecx 9557 9558.LOP_SPUT_OBJECT_JUMBO_resolve: 9559 movl rSELF,%ecx 9560 movl 2(rPC),%eax # eax<- field ref AAAAAAAA 9561 movl offThread_method(%ecx),%ecx # ecx<- current method 9562 EXPORT_PC # could throw, need to export 9563 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 9564 movl %eax,OUT_ARG1(%esp) 9565 movl %ecx,OUT_ARG0(%esp) 9566 SPILL(rIBASE) 9567 call dvmResolveStaticField # eax<- resolved StaticField ptr 9568 UNSPILL(rIBASE) 9569 testl %eax,%eax 9570 jne .LOP_SPUT_OBJECT_JUMBO_finish # success, continue 9571 jmp common_exceptionThrown # no, handle exception 9572 9573/* ------------------------------ */ 9574.L_OP_SPUT_BOOLEAN_JUMBO: /* 0x11e */ 9575/* File: x86/OP_SPUT_BOOLEAN_JUMBO.S */ 9576/* File: x86/OP_SPUT_JUMBO.S */ 9577 /* 9578 * Jumbo 32-bit SPUT handler. 9579 * 9580 * for: sput/jumbo, sput-boolean/jumbo, sput-byte/jumbo, sput-char/jumbo, 9581 * sput-short/jumbo 9582 */ 9583 /* exop vBBBB, field@AAAAAAAA */ 9584 movl rSELF,%ecx 9585 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex 9586 movl 2(rPC),%eax # eax<- field ref AAAAAAAA 9587 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields 9588 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr 9589 testl %eax,%eax # resolved entry null? 9590 je .LOP_SPUT_BOOLEAN_JUMBO_resolve # if not, make it so 9591.LOP_SPUT_BOOLEAN_JUMBO_finish: # field ptr in eax 9592 GET_VREG_R rINST rINST 9593 FETCH_INST_OPCODE 4 %ecx 9594 ADVANCE_PC 4 9595 movl rINST,offStaticField_value(%eax) 9596 GOTO_NEXT_R %ecx 9597 9598 /* 9599 * Go resolve the field 9600 */ 9601.LOP_SPUT_BOOLEAN_JUMBO_resolve: 9602 movl rSELF,%ecx 9603 movl 2(rPC),%eax # eax<- field ref AAAAAAAA 9604 movl offThread_method(%ecx),%ecx # ecx<- current method 9605 EXPORT_PC # could throw, need to export 9606 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 9607 movl %eax,OUT_ARG1(%esp) 9608 movl %ecx,OUT_ARG0(%esp) 9609 SPILL(rIBASE) 9610 call dvmResolveStaticField # eax<- resolved StaticField ptr 9611 UNSPILL(rIBASE) 9612 testl %eax,%eax 9613 jne .LOP_SPUT_BOOLEAN_JUMBO_finish # success, continue 9614 jmp common_exceptionThrown # no, handle exception 9615 9616 9617/* ------------------------------ */ 9618.L_OP_SPUT_BYTE_JUMBO: /* 0x11f */ 9619/* File: x86/OP_SPUT_BYTE_JUMBO.S */ 9620/* File: x86/OP_SPUT_JUMBO.S */ 9621 /* 9622 * Jumbo 32-bit SPUT handler. 9623 * 9624 * for: sput/jumbo, sput-boolean/jumbo, sput-byte/jumbo, sput-char/jumbo, 9625 * sput-short/jumbo 9626 */ 9627 /* exop vBBBB, field@AAAAAAAA */ 9628 movl rSELF,%ecx 9629 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex 9630 movl 2(rPC),%eax # eax<- field ref AAAAAAAA 9631 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields 9632 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr 9633 testl %eax,%eax # resolved entry null? 9634 je .LOP_SPUT_BYTE_JUMBO_resolve # if not, make it so 9635.LOP_SPUT_BYTE_JUMBO_finish: # field ptr in eax 9636 GET_VREG_R rINST rINST 9637 FETCH_INST_OPCODE 4 %ecx 9638 ADVANCE_PC 4 9639 movl rINST,offStaticField_value(%eax) 9640 GOTO_NEXT_R %ecx 9641 9642 /* 9643 * Go resolve the field 9644 */ 9645.LOP_SPUT_BYTE_JUMBO_resolve: 9646 movl rSELF,%ecx 9647 movl 2(rPC),%eax # eax<- field ref AAAAAAAA 9648 movl offThread_method(%ecx),%ecx # ecx<- current method 9649 EXPORT_PC # could throw, need to export 9650 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 9651 movl %eax,OUT_ARG1(%esp) 9652 movl %ecx,OUT_ARG0(%esp) 9653 SPILL(rIBASE) 9654 call dvmResolveStaticField # eax<- resolved StaticField ptr 9655 UNSPILL(rIBASE) 9656 testl %eax,%eax 9657 jne .LOP_SPUT_BYTE_JUMBO_finish # success, continue 9658 jmp common_exceptionThrown # no, handle exception 9659 9660 9661/* ------------------------------ */ 9662.L_OP_SPUT_CHAR_JUMBO: /* 0x120 */ 9663/* File: x86/OP_SPUT_CHAR_JUMBO.S */ 9664/* File: x86/OP_SPUT_JUMBO.S */ 9665 /* 9666 * Jumbo 32-bit SPUT handler. 9667 * 9668 * for: sput/jumbo, sput-boolean/jumbo, sput-byte/jumbo, sput-char/jumbo, 9669 * sput-short/jumbo 9670 */ 9671 /* exop vBBBB, field@AAAAAAAA */ 9672 movl rSELF,%ecx 9673 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex 9674 movl 2(rPC),%eax # eax<- field ref AAAAAAAA 9675 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields 9676 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr 9677 testl %eax,%eax # resolved entry null? 9678 je .LOP_SPUT_CHAR_JUMBO_resolve # if not, make it so 9679.LOP_SPUT_CHAR_JUMBO_finish: # field ptr in eax 9680 GET_VREG_R rINST rINST 9681 FETCH_INST_OPCODE 4 %ecx 9682 ADVANCE_PC 4 9683 movl rINST,offStaticField_value(%eax) 9684 GOTO_NEXT_R %ecx 9685 9686 /* 9687 * Go resolve the field 9688 */ 9689.LOP_SPUT_CHAR_JUMBO_resolve: 9690 movl rSELF,%ecx 9691 movl 2(rPC),%eax # eax<- field ref AAAAAAAA 9692 movl offThread_method(%ecx),%ecx # ecx<- current method 9693 EXPORT_PC # could throw, need to export 9694 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 9695 movl %eax,OUT_ARG1(%esp) 9696 movl %ecx,OUT_ARG0(%esp) 9697 SPILL(rIBASE) 9698 call dvmResolveStaticField # eax<- resolved StaticField ptr 9699 UNSPILL(rIBASE) 9700 testl %eax,%eax 9701 jne .LOP_SPUT_CHAR_JUMBO_finish # success, continue 9702 jmp common_exceptionThrown # no, handle exception 9703 9704 9705/* ------------------------------ */ 9706.L_OP_SPUT_SHORT_JUMBO: /* 0x121 */ 9707/* File: x86/OP_SPUT_SHORT_JUMBO.S */ 9708/* File: x86/OP_SPUT_JUMBO.S */ 9709 /* 9710 * Jumbo 32-bit SPUT handler. 9711 * 9712 * for: sput/jumbo, sput-boolean/jumbo, sput-byte/jumbo, sput-char/jumbo, 9713 * sput-short/jumbo 9714 */ 9715 /* exop vBBBB, field@AAAAAAAA */ 9716 movl rSELF,%ecx 9717 movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex 9718 movl 2(rPC),%eax # eax<- field ref AAAAAAAA 9719 movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields 9720 movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr 9721 testl %eax,%eax # resolved entry null? 9722 je .LOP_SPUT_SHORT_JUMBO_resolve # if not, make it so 9723.LOP_SPUT_SHORT_JUMBO_finish: # field ptr in eax 9724 GET_VREG_R rINST rINST 9725 FETCH_INST_OPCODE 4 %ecx 9726 ADVANCE_PC 4 9727 movl rINST,offStaticField_value(%eax) 9728 GOTO_NEXT_R %ecx 9729 9730 /* 9731 * Go resolve the field 9732 */ 9733.LOP_SPUT_SHORT_JUMBO_resolve: 9734 movl rSELF,%ecx 9735 movl 2(rPC),%eax # eax<- field ref AAAAAAAA 9736 movl offThread_method(%ecx),%ecx # ecx<- current method 9737 EXPORT_PC # could throw, need to export 9738 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 9739 movl %eax,OUT_ARG1(%esp) 9740 movl %ecx,OUT_ARG0(%esp) 9741 SPILL(rIBASE) 9742 call dvmResolveStaticField # eax<- resolved StaticField ptr 9743 UNSPILL(rIBASE) 9744 testl %eax,%eax 9745 jne .LOP_SPUT_SHORT_JUMBO_finish # success, continue 9746 jmp common_exceptionThrown # no, handle exception 9747 9748 9749/* ------------------------------ */ 9750.L_OP_INVOKE_VIRTUAL_JUMBO: /* 0x122 */ 9751/* File: x86/OP_INVOKE_VIRTUAL_JUMBO.S */ 9752 /* 9753 * Handle a jumbo virtual method call. 9754 */ 9755 /* invoke-virtual/jumbo vBBBB, {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */ 9756 movl rSELF,%eax 9757 movl 2(rPC),%ecx # ecx<- AAAAAAAA 9758 movl offThread_methodClassDex(%eax),%eax # eax<- pDvmDex 9759 EXPORT_PC 9760 movl offDvmDex_pResMethods(%eax),%eax # eax<- pDvmDex->pResMethods 9761 movl (%eax,%ecx,4),%eax # eax<- resolved baseMethod 9762 testl %eax,%eax # already resolved? 9763 jne .LOP_INVOKE_VIRTUAL_JUMBO_continue # yes, continue 9764 movl rSELF,%eax 9765 movl %ecx,OUT_ARG1(%esp) # arg1<- ref 9766 movl offThread_method(%eax),%eax # eax<- self->method 9767 movl offMethod_clazz(%eax),%eax # ecx<- method->clazz 9768 movl %eax,OUT_ARG0(%esp) # arg0<- clazz 9769 movl $METHOD_VIRTUAL,OUT_ARG2(%esp) # arg2<- flags 9770 call dvmResolveMethod # eax<- call(clazz, ref, flags) 9771 testl %eax,%eax # got null? 9772 jne .LOP_INVOKE_VIRTUAL_JUMBO_continue # no, continue 9773 jmp common_exceptionThrown # yes, handle exception 9774 9775 /* At this point: 9776 * eax = resolved base method 9777 * ecx = scratch 9778 */ 9779.LOP_INVOKE_VIRTUAL_JUMBO_continue: 9780 movzwl 8(rPC),%ecx # ecx<- CCCC 9781 GET_VREG_R %ecx %ecx # ecx<- "this" 9782 movzwl offMethod_methodIndex(%eax),%eax # eax<- baseMethod->methodIndex 9783 testl %ecx,%ecx # null this? 9784 je common_errNullObject # go if so 9785 movl offObject_clazz(%ecx),%ecx # ecx<- thisPtr->clazz 9786 movl offClassObject_vtable(%ecx),%ecx # ecx<- thisPtr->clazz->vtable 9787 movl (%ecx,%eax,4),%eax # eax<- vtable[methodIndex] 9788 jmp common_invokeMethodJumbo 9789 9790/* ------------------------------ */ 9791.L_OP_INVOKE_SUPER_JUMBO: /* 0x123 */ 9792/* File: x86/OP_INVOKE_SUPER_JUMBO.S */ 9793 /* 9794 * Handle a jumbo "super" method call. 9795 */ 9796 /* invoke-super/jumbo {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */ 9797 movl rSELF,rINST 9798 movl 2(rPC),%eax # eax<- AAAAAAAA 9799 movl offThread_methodClassDex(rINST),%ecx # ecx<- pDvmDex 9800 EXPORT_PC 9801 movl offDvmDex_pResMethods(%ecx),%ecx # ecx<- pDvmDex->pResMethods 9802 movl (%ecx,%eax,4),%ecx # ecx<- resolved baseMethod 9803 movl offThread_method(rINST),%eax # eax<- method 9804 movzwl 8(rPC),rINST # rINST<- CCCC 9805 GET_VREG_R rINST rINST # rINST<- "this" ptr 9806 testl rINST,rINST # null "this"? 9807 je common_errNullObject # yes, throw 9808 movl offMethod_clazz(%eax),%eax # eax<- method->clazz 9809 testl %ecx,%ecx # already resolved? 9810 je .LOP_INVOKE_SUPER_JUMBO_resolve 9811 /* 9812 * At this point: 9813 * ecx = resolved base method [r0] 9814 * eax = method->clazz [r9] 9815 */ 9816.LOP_INVOKE_SUPER_JUMBO_continue: 9817 movl offClassObject_super(%eax),%eax # eax<- method->clazz->super 9818 movzwl offMethod_methodIndex(%ecx),%ecx # ecx<- baseMthod->methodIndex 9819 cmpl offClassObject_vtableCount(%eax),%ecx # compare(methodIndex,vtableCount) 9820 jae .LOP_INVOKE_SUPER_JUMBO_nsm # method not present in superclass 9821 movl offClassObject_vtable(%eax),%eax # eax<- ...clazz->super->vtable 9822 movl (%eax,%ecx,4),%eax # eax<- vtable[methodIndex] 9823 jmp common_invokeMethodJumbo 9824 9825 9826 /* At this point: 9827 * ecx = null (needs to be resolved base method) 9828 * eax = method->clazz 9829 */ 9830.LOP_INVOKE_SUPER_JUMBO_resolve: 9831 SPILL_TMP1(%eax) # method->clazz 9832 movl %eax,OUT_ARG0(%esp) # arg0<- method->clazz 9833 movl 2(rPC),%ecx # ecx<- AAAAAAAA 9834 movl $METHOD_VIRTUAL,OUT_ARG2(%esp) # arg2<- resolver method type 9835 movl %ecx,OUT_ARG1(%esp) # arg1<- ref 9836 call dvmResolveMethod # eax<- call(clazz, ref, flags) 9837 testl %eax,%eax # got null? 9838 movl %eax,%ecx # ecx<- resolved base method 9839 UNSPILL_TMP1(%eax) # restore method->clazz 9840 jne .LOP_INVOKE_SUPER_JUMBO_continue # good to go - continue 9841 jmp common_exceptionThrown # handle exception 9842 9843 /* 9844 * Throw a NoSuchMethodError with the method name as the message. 9845 * ecx = resolved base method 9846 */ 9847.LOP_INVOKE_SUPER_JUMBO_nsm: 9848 movl offMethod_name(%ecx),%eax 9849 mov %eax,OUT_ARG1(%esp) 9850 jmp common_errNoSuchMethod 9851 9852/* ------------------------------ */ 9853.L_OP_INVOKE_DIRECT_JUMBO: /* 0x124 */ 9854/* File: x86/OP_INVOKE_DIRECT_JUMBO.S */ 9855 /* 9856 * Handle a jumbo direct method call. 9857 * 9858 * (We could defer the "is 'this' pointer null" test to the common 9859 * method invocation code, and use a flag to indicate that static 9860 * calls don't count. If we do this as part of copying the arguments 9861 * out we could avoiding loading the first arg twice.) 9862 */ 9863 /* invoke-direct/jumbo {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */ 9864 movl rSELF,%ecx 9865 movl 2(rPC),%eax # eax<- AAAAAAAA 9866 movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex 9867 EXPORT_PC 9868 movl offDvmDex_pResMethods(%ecx),%ecx # ecx<- pDvmDex->pResMethods 9869 movzwl 8(rPC),rIBASE # rIBASE<- CCCC 9870 movl (%ecx,%eax,4),%eax # eax<- resolved methodToCall 9871 testl %eax,%eax # already resolved? 9872 GET_VREG_R %ecx rIBASE # ecx<- "this" ptr 9873 je .LOP_INVOKE_DIRECT_JUMBO_resolve # not resolved, do it now 9874.LOP_INVOKE_DIRECT_JUMBO_finish: 9875 testl %ecx,%ecx # null "this"? 9876 jne common_invokeMethodJumbo # no, continue on 9877 jmp common_errNullObject 9878 9879 /* 9880 * On entry: 9881 * TMP_SPILL <- "this" register 9882 * Things a bit ugly on this path, but it's the less 9883 * frequent one. We'll have to do some reloading. 9884 */ 9885.LOP_INVOKE_DIRECT_JUMBO_resolve: 9886 SPILL_TMP1(%ecx) 9887 movl rSELF,%ecx 9888 movl offThread_method(%ecx),%ecx # ecx<- self->method 9889 movl 2(rPC),%eax # reference AAAAAAAA 9890 movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz 9891 movl $METHOD_DIRECT,OUT_ARG2(%esp) 9892 movl %eax,OUT_ARG1(%esp) 9893 movl %ecx,OUT_ARG0(%esp) 9894 call dvmResolveMethod # eax<- call(clazz, ref, flags) 9895 UNSPILL_TMP1(%ecx) 9896 testl %eax,%eax 9897 jne .LOP_INVOKE_DIRECT_JUMBO_finish 9898 jmp common_exceptionThrown 9899 9900/* ------------------------------ */ 9901.L_OP_INVOKE_STATIC_JUMBO: /* 0x125 */ 9902/* File: x86/OP_INVOKE_STATIC_JUMBO.S */ 9903 /* 9904 * Handle a jumbo static method call. 9905 */ 9906 /* invoke-static/jumbo {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */ 9907 movl rSELF,%ecx 9908 movl 2(rPC),%eax # eax<- AAAAAAAA 9909 movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex 9910 EXPORT_PC 9911 movl offDvmDex_pResMethods(%ecx),%ecx # ecx<- pDvmDex->pResMethods 9912 movl (%ecx,%eax,4),%eax # eax<- resolved methodToCall 9913 testl %eax,%eax 9914 jne common_invokeMethodJumbo 9915 movl rSELF,%ecx 9916 movl offThread_method(%ecx),%ecx # ecx<- self->method 9917 movl 2(rPC),%eax # eax<- AAAAAAAA 9918 movl offMethod_clazz(%ecx),%ecx# ecx<- method->clazz 9919 movl %eax,OUT_ARG1(%esp) # arg1<- AAAAAAAA 9920 movl %ecx,OUT_ARG0(%esp) # arg0<- clazz 9921 movl $METHOD_STATIC,%eax 9922 movl %eax,OUT_ARG2(%esp) # arg2<- flags 9923 call dvmResolveMethod # call(clazz,ref,flags) 9924 testl %eax,%eax # got null? 9925 jne common_invokeMethodJumbo 9926 jmp common_exceptionThrown 9927 9928/* ------------------------------ */ 9929.L_OP_INVOKE_INTERFACE_JUMBO: /* 0x126 */ 9930/* File: x86/OP_INVOKE_INTERFACE_JUMBO.S */ 9931 /* 9932 * Handle a jumbo interface method call. 9933 */ 9934 /* invoke-interface/jumbo {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */ 9935 movzwl 8(rPC),%eax # eax<- CCCC 9936 movl rSELF,%ecx 9937 GET_VREG_R %eax %eax # eax<- "this" 9938 EXPORT_PC 9939 testl %eax,%eax # null this? 9940 je common_errNullObject # yes, fail 9941 movl offObject_clazz(%eax),%eax# eax<- thisPtr->clazz 9942 movl %eax,OUT_ARG0(%esp) # arg0<- class 9943 movl offThread_methodClassDex(%ecx),%eax # eax<- methodClassDex 9944 movl offThread_method(%ecx),%ecx # ecx<- method 9945 movl %eax,OUT_ARG3(%esp) # arg3<- dex 9946 movl 2(rPC),%eax # eax<- AAAAAAAA 9947 movl %ecx,OUT_ARG2(%esp) # arg2<- method 9948 movl %eax,OUT_ARG1(%esp) # arg1<- AAAAAAAA 9949 call dvmFindInterfaceMethodInCache # eax<- call(class, ref, method, dex) 9950 testl %eax,%eax 9951 je common_exceptionThrown 9952 jmp common_invokeMethodJumbo 9953 9954/* ------------------------------ */ 9955.L_OP_UNUSED_27FF: /* 0x127 */ 9956/* File: x86/OP_UNUSED_27FF.S */ 9957/* File: x86/unused.S */ 9958 jmp common_abort 9959 9960 9961/* ------------------------------ */ 9962.L_OP_UNUSED_28FF: /* 0x128 */ 9963/* File: x86/OP_UNUSED_28FF.S */ 9964/* File: x86/unused.S */ 9965 jmp common_abort 9966 9967 9968/* ------------------------------ */ 9969.L_OP_UNUSED_29FF: /* 0x129 */ 9970/* File: x86/OP_UNUSED_29FF.S */ 9971/* File: x86/unused.S */ 9972 jmp common_abort 9973 9974 9975/* ------------------------------ */ 9976.L_OP_UNUSED_2AFF: /* 0x12a */ 9977/* File: x86/OP_UNUSED_2AFF.S */ 9978/* File: x86/unused.S */ 9979 jmp common_abort 9980 9981 9982/* ------------------------------ */ 9983.L_OP_UNUSED_2BFF: /* 0x12b */ 9984/* File: x86/OP_UNUSED_2BFF.S */ 9985/* File: x86/unused.S */ 9986 jmp common_abort 9987 9988 9989/* ------------------------------ */ 9990.L_OP_UNUSED_2CFF: /* 0x12c */ 9991/* File: x86/OP_UNUSED_2CFF.S */ 9992/* File: x86/unused.S */ 9993 jmp common_abort 9994 9995 9996/* ------------------------------ */ 9997.L_OP_UNUSED_2DFF: /* 0x12d */ 9998/* File: x86/OP_UNUSED_2DFF.S */ 9999/* File: x86/unused.S */ 10000 jmp common_abort 10001 10002 10003/* ------------------------------ */ 10004.L_OP_UNUSED_2EFF: /* 0x12e */ 10005/* File: x86/OP_UNUSED_2EFF.S */ 10006/* File: x86/unused.S */ 10007 jmp common_abort 10008 10009 10010/* ------------------------------ */ 10011.L_OP_UNUSED_2FFF: /* 0x12f */ 10012/* File: x86/OP_UNUSED_2FFF.S */ 10013/* File: x86/unused.S */ 10014 jmp common_abort 10015 10016 10017/* ------------------------------ */ 10018.L_OP_UNUSED_30FF: /* 0x130 */ 10019/* File: x86/OP_UNUSED_30FF.S */ 10020/* File: x86/unused.S */ 10021 jmp common_abort 10022 10023 10024/* ------------------------------ */ 10025.L_OP_UNUSED_31FF: /* 0x131 */ 10026/* File: x86/OP_UNUSED_31FF.S */ 10027/* File: x86/unused.S */ 10028 jmp common_abort 10029 10030 10031/* ------------------------------ */ 10032.L_OP_UNUSED_32FF: /* 0x132 */ 10033/* File: x86/OP_UNUSED_32FF.S */ 10034/* File: x86/unused.S */ 10035 jmp common_abort 10036 10037 10038/* ------------------------------ */ 10039.L_OP_UNUSED_33FF: /* 0x133 */ 10040/* File: x86/OP_UNUSED_33FF.S */ 10041/* File: x86/unused.S */ 10042 jmp common_abort 10043 10044 10045/* ------------------------------ */ 10046.L_OP_UNUSED_34FF: /* 0x134 */ 10047/* File: x86/OP_UNUSED_34FF.S */ 10048/* File: x86/unused.S */ 10049 jmp common_abort 10050 10051 10052/* ------------------------------ */ 10053.L_OP_UNUSED_35FF: /* 0x135 */ 10054/* File: x86/OP_UNUSED_35FF.S */ 10055/* File: x86/unused.S */ 10056 jmp common_abort 10057 10058 10059/* ------------------------------ */ 10060.L_OP_UNUSED_36FF: /* 0x136 */ 10061/* File: x86/OP_UNUSED_36FF.S */ 10062/* File: x86/unused.S */ 10063 jmp common_abort 10064 10065 10066/* ------------------------------ */ 10067.L_OP_UNUSED_37FF: /* 0x137 */ 10068/* File: x86/OP_UNUSED_37FF.S */ 10069/* File: x86/unused.S */ 10070 jmp common_abort 10071 10072 10073/* ------------------------------ */ 10074.L_OP_UNUSED_38FF: /* 0x138 */ 10075/* File: x86/OP_UNUSED_38FF.S */ 10076/* File: x86/unused.S */ 10077 jmp common_abort 10078 10079 10080/* ------------------------------ */ 10081.L_OP_UNUSED_39FF: /* 0x139 */ 10082/* File: x86/OP_UNUSED_39FF.S */ 10083/* File: x86/unused.S */ 10084 jmp common_abort 10085 10086 10087/* ------------------------------ */ 10088.L_OP_UNUSED_3AFF: /* 0x13a */ 10089/* File: x86/OP_UNUSED_3AFF.S */ 10090/* File: x86/unused.S */ 10091 jmp common_abort 10092 10093 10094/* ------------------------------ */ 10095.L_OP_UNUSED_3BFF: /* 0x13b */ 10096/* File: x86/OP_UNUSED_3BFF.S */ 10097/* File: x86/unused.S */ 10098 jmp common_abort 10099 10100 10101/* ------------------------------ */ 10102.L_OP_UNUSED_3CFF: /* 0x13c */ 10103/* File: x86/OP_UNUSED_3CFF.S */ 10104/* File: x86/unused.S */ 10105 jmp common_abort 10106 10107 10108/* ------------------------------ */ 10109.L_OP_UNUSED_3DFF: /* 0x13d */ 10110/* File: x86/OP_UNUSED_3DFF.S */ 10111/* File: x86/unused.S */ 10112 jmp common_abort 10113 10114 10115/* ------------------------------ */ 10116.L_OP_UNUSED_3EFF: /* 0x13e */ 10117/* File: x86/OP_UNUSED_3EFF.S */ 10118/* File: x86/unused.S */ 10119 jmp common_abort 10120 10121 10122/* ------------------------------ */ 10123.L_OP_UNUSED_3FFF: /* 0x13f */ 10124/* File: x86/OP_UNUSED_3FFF.S */ 10125/* File: x86/unused.S */ 10126 jmp common_abort 10127 10128 10129/* ------------------------------ */ 10130.L_OP_UNUSED_40FF: /* 0x140 */ 10131/* File: x86/OP_UNUSED_40FF.S */ 10132/* File: x86/unused.S */ 10133 jmp common_abort 10134 10135 10136/* ------------------------------ */ 10137.L_OP_UNUSED_41FF: /* 0x141 */ 10138/* File: x86/OP_UNUSED_41FF.S */ 10139/* File: x86/unused.S */ 10140 jmp common_abort 10141 10142 10143/* ------------------------------ */ 10144.L_OP_UNUSED_42FF: /* 0x142 */ 10145/* File: x86/OP_UNUSED_42FF.S */ 10146/* File: x86/unused.S */ 10147 jmp common_abort 10148 10149 10150/* ------------------------------ */ 10151.L_OP_UNUSED_43FF: /* 0x143 */ 10152/* File: x86/OP_UNUSED_43FF.S */ 10153/* File: x86/unused.S */ 10154 jmp common_abort 10155 10156 10157/* ------------------------------ */ 10158.L_OP_UNUSED_44FF: /* 0x144 */ 10159/* File: x86/OP_UNUSED_44FF.S */ 10160/* File: x86/unused.S */ 10161 jmp common_abort 10162 10163 10164/* ------------------------------ */ 10165.L_OP_UNUSED_45FF: /* 0x145 */ 10166/* File: x86/OP_UNUSED_45FF.S */ 10167/* File: x86/unused.S */ 10168 jmp common_abort 10169 10170 10171/* ------------------------------ */ 10172.L_OP_UNUSED_46FF: /* 0x146 */ 10173/* File: x86/OP_UNUSED_46FF.S */ 10174/* File: x86/unused.S */ 10175 jmp common_abort 10176 10177 10178/* ------------------------------ */ 10179.L_OP_UNUSED_47FF: /* 0x147 */ 10180/* File: x86/OP_UNUSED_47FF.S */ 10181/* File: x86/unused.S */ 10182 jmp common_abort 10183 10184 10185/* ------------------------------ */ 10186.L_OP_UNUSED_48FF: /* 0x148 */ 10187/* File: x86/OP_UNUSED_48FF.S */ 10188/* File: x86/unused.S */ 10189 jmp common_abort 10190 10191 10192/* ------------------------------ */ 10193.L_OP_UNUSED_49FF: /* 0x149 */ 10194/* File: x86/OP_UNUSED_49FF.S */ 10195/* File: x86/unused.S */ 10196 jmp common_abort 10197 10198 10199/* ------------------------------ */ 10200.L_OP_UNUSED_4AFF: /* 0x14a */ 10201/* File: x86/OP_UNUSED_4AFF.S */ 10202/* File: x86/unused.S */ 10203 jmp common_abort 10204 10205 10206/* ------------------------------ */ 10207.L_OP_UNUSED_4BFF: /* 0x14b */ 10208/* File: x86/OP_UNUSED_4BFF.S */ 10209/* File: x86/unused.S */ 10210 jmp common_abort 10211 10212 10213/* ------------------------------ */ 10214.L_OP_UNUSED_4CFF: /* 0x14c */ 10215/* File: x86/OP_UNUSED_4CFF.S */ 10216/* File: x86/unused.S */ 10217 jmp common_abort 10218 10219 10220/* ------------------------------ */ 10221.L_OP_UNUSED_4DFF: /* 0x14d */ 10222/* File: x86/OP_UNUSED_4DFF.S */ 10223/* File: x86/unused.S */ 10224 jmp common_abort 10225 10226 10227/* ------------------------------ */ 10228.L_OP_UNUSED_4EFF: /* 0x14e */ 10229/* File: x86/OP_UNUSED_4EFF.S */ 10230/* File: x86/unused.S */ 10231 jmp common_abort 10232 10233 10234/* ------------------------------ */ 10235.L_OP_UNUSED_4FFF: /* 0x14f */ 10236/* File: x86/OP_UNUSED_4FFF.S */ 10237/* File: x86/unused.S */ 10238 jmp common_abort 10239 10240 10241/* ------------------------------ */ 10242.L_OP_UNUSED_50FF: /* 0x150 */ 10243/* File: x86/OP_UNUSED_50FF.S */ 10244/* File: x86/unused.S */ 10245 jmp common_abort 10246 10247 10248/* ------------------------------ */ 10249.L_OP_UNUSED_51FF: /* 0x151 */ 10250/* File: x86/OP_UNUSED_51FF.S */ 10251/* File: x86/unused.S */ 10252 jmp common_abort 10253 10254 10255/* ------------------------------ */ 10256.L_OP_UNUSED_52FF: /* 0x152 */ 10257/* File: x86/OP_UNUSED_52FF.S */ 10258/* File: x86/unused.S */ 10259 jmp common_abort 10260 10261 10262/* ------------------------------ */ 10263.L_OP_UNUSED_53FF: /* 0x153 */ 10264/* File: x86/OP_UNUSED_53FF.S */ 10265/* File: x86/unused.S */ 10266 jmp common_abort 10267 10268 10269/* ------------------------------ */ 10270.L_OP_UNUSED_54FF: /* 0x154 */ 10271/* File: x86/OP_UNUSED_54FF.S */ 10272/* File: x86/unused.S */ 10273 jmp common_abort 10274 10275 10276/* ------------------------------ */ 10277.L_OP_UNUSED_55FF: /* 0x155 */ 10278/* File: x86/OP_UNUSED_55FF.S */ 10279/* File: x86/unused.S */ 10280 jmp common_abort 10281 10282 10283/* ------------------------------ */ 10284.L_OP_UNUSED_56FF: /* 0x156 */ 10285/* File: x86/OP_UNUSED_56FF.S */ 10286/* File: x86/unused.S */ 10287 jmp common_abort 10288 10289 10290/* ------------------------------ */ 10291.L_OP_UNUSED_57FF: /* 0x157 */ 10292/* File: x86/OP_UNUSED_57FF.S */ 10293/* File: x86/unused.S */ 10294 jmp common_abort 10295 10296 10297/* ------------------------------ */ 10298.L_OP_UNUSED_58FF: /* 0x158 */ 10299/* File: x86/OP_UNUSED_58FF.S */ 10300/* File: x86/unused.S */ 10301 jmp common_abort 10302 10303 10304/* ------------------------------ */ 10305.L_OP_UNUSED_59FF: /* 0x159 */ 10306/* File: x86/OP_UNUSED_59FF.S */ 10307/* File: x86/unused.S */ 10308 jmp common_abort 10309 10310 10311/* ------------------------------ */ 10312.L_OP_UNUSED_5AFF: /* 0x15a */ 10313/* File: x86/OP_UNUSED_5AFF.S */ 10314/* File: x86/unused.S */ 10315 jmp common_abort 10316 10317 10318/* ------------------------------ */ 10319.L_OP_UNUSED_5BFF: /* 0x15b */ 10320/* File: x86/OP_UNUSED_5BFF.S */ 10321/* File: x86/unused.S */ 10322 jmp common_abort 10323 10324 10325/* ------------------------------ */ 10326.L_OP_UNUSED_5CFF: /* 0x15c */ 10327/* File: x86/OP_UNUSED_5CFF.S */ 10328/* File: x86/unused.S */ 10329 jmp common_abort 10330 10331 10332/* ------------------------------ */ 10333.L_OP_UNUSED_5DFF: /* 0x15d */ 10334/* File: x86/OP_UNUSED_5DFF.S */ 10335/* File: x86/unused.S */ 10336 jmp common_abort 10337 10338 10339/* ------------------------------ */ 10340.L_OP_UNUSED_5EFF: /* 0x15e */ 10341/* File: x86/OP_UNUSED_5EFF.S */ 10342/* File: x86/unused.S */ 10343 jmp common_abort 10344 10345 10346/* ------------------------------ */ 10347.L_OP_UNUSED_5FFF: /* 0x15f */ 10348/* File: x86/OP_UNUSED_5FFF.S */ 10349/* File: x86/unused.S */ 10350 jmp common_abort 10351 10352 10353/* ------------------------------ */ 10354.L_OP_UNUSED_60FF: /* 0x160 */ 10355/* File: x86/OP_UNUSED_60FF.S */ 10356/* File: x86/unused.S */ 10357 jmp common_abort 10358 10359 10360/* ------------------------------ */ 10361.L_OP_UNUSED_61FF: /* 0x161 */ 10362/* File: x86/OP_UNUSED_61FF.S */ 10363/* File: x86/unused.S */ 10364 jmp common_abort 10365 10366 10367/* ------------------------------ */ 10368.L_OP_UNUSED_62FF: /* 0x162 */ 10369/* File: x86/OP_UNUSED_62FF.S */ 10370/* File: x86/unused.S */ 10371 jmp common_abort 10372 10373 10374/* ------------------------------ */ 10375.L_OP_UNUSED_63FF: /* 0x163 */ 10376/* File: x86/OP_UNUSED_63FF.S */ 10377/* File: x86/unused.S */ 10378 jmp common_abort 10379 10380 10381/* ------------------------------ */ 10382.L_OP_UNUSED_64FF: /* 0x164 */ 10383/* File: x86/OP_UNUSED_64FF.S */ 10384/* File: x86/unused.S */ 10385 jmp common_abort 10386 10387 10388/* ------------------------------ */ 10389.L_OP_UNUSED_65FF: /* 0x165 */ 10390/* File: x86/OP_UNUSED_65FF.S */ 10391/* File: x86/unused.S */ 10392 jmp common_abort 10393 10394 10395/* ------------------------------ */ 10396.L_OP_UNUSED_66FF: /* 0x166 */ 10397/* File: x86/OP_UNUSED_66FF.S */ 10398/* File: x86/unused.S */ 10399 jmp common_abort 10400 10401 10402/* ------------------------------ */ 10403.L_OP_UNUSED_67FF: /* 0x167 */ 10404/* File: x86/OP_UNUSED_67FF.S */ 10405/* File: x86/unused.S */ 10406 jmp common_abort 10407 10408 10409/* ------------------------------ */ 10410.L_OP_UNUSED_68FF: /* 0x168 */ 10411/* File: x86/OP_UNUSED_68FF.S */ 10412/* File: x86/unused.S */ 10413 jmp common_abort 10414 10415 10416/* ------------------------------ */ 10417.L_OP_UNUSED_69FF: /* 0x169 */ 10418/* File: x86/OP_UNUSED_69FF.S */ 10419/* File: x86/unused.S */ 10420 jmp common_abort 10421 10422 10423/* ------------------------------ */ 10424.L_OP_UNUSED_6AFF: /* 0x16a */ 10425/* File: x86/OP_UNUSED_6AFF.S */ 10426/* File: x86/unused.S */ 10427 jmp common_abort 10428 10429 10430/* ------------------------------ */ 10431.L_OP_UNUSED_6BFF: /* 0x16b */ 10432/* File: x86/OP_UNUSED_6BFF.S */ 10433/* File: x86/unused.S */ 10434 jmp common_abort 10435 10436 10437/* ------------------------------ */ 10438.L_OP_UNUSED_6CFF: /* 0x16c */ 10439/* File: x86/OP_UNUSED_6CFF.S */ 10440/* File: x86/unused.S */ 10441 jmp common_abort 10442 10443 10444/* ------------------------------ */ 10445.L_OP_UNUSED_6DFF: /* 0x16d */ 10446/* File: x86/OP_UNUSED_6DFF.S */ 10447/* File: x86/unused.S */ 10448 jmp common_abort 10449 10450 10451/* ------------------------------ */ 10452.L_OP_UNUSED_6EFF: /* 0x16e */ 10453/* File: x86/OP_UNUSED_6EFF.S */ 10454/* File: x86/unused.S */ 10455 jmp common_abort 10456 10457 10458/* ------------------------------ */ 10459.L_OP_UNUSED_6FFF: /* 0x16f */ 10460/* File: x86/OP_UNUSED_6FFF.S */ 10461/* File: x86/unused.S */ 10462 jmp common_abort 10463 10464 10465/* ------------------------------ */ 10466.L_OP_UNUSED_70FF: /* 0x170 */ 10467/* File: x86/OP_UNUSED_70FF.S */ 10468/* File: x86/unused.S */ 10469 jmp common_abort 10470 10471 10472/* ------------------------------ */ 10473.L_OP_UNUSED_71FF: /* 0x171 */ 10474/* File: x86/OP_UNUSED_71FF.S */ 10475/* File: x86/unused.S */ 10476 jmp common_abort 10477 10478 10479/* ------------------------------ */ 10480.L_OP_UNUSED_72FF: /* 0x172 */ 10481/* File: x86/OP_UNUSED_72FF.S */ 10482/* File: x86/unused.S */ 10483 jmp common_abort 10484 10485 10486/* ------------------------------ */ 10487.L_OP_UNUSED_73FF: /* 0x173 */ 10488/* File: x86/OP_UNUSED_73FF.S */ 10489/* File: x86/unused.S */ 10490 jmp common_abort 10491 10492 10493/* ------------------------------ */ 10494.L_OP_UNUSED_74FF: /* 0x174 */ 10495/* File: x86/OP_UNUSED_74FF.S */ 10496/* File: x86/unused.S */ 10497 jmp common_abort 10498 10499 10500/* ------------------------------ */ 10501.L_OP_UNUSED_75FF: /* 0x175 */ 10502/* File: x86/OP_UNUSED_75FF.S */ 10503/* File: x86/unused.S */ 10504 jmp common_abort 10505 10506 10507/* ------------------------------ */ 10508.L_OP_UNUSED_76FF: /* 0x176 */ 10509/* File: x86/OP_UNUSED_76FF.S */ 10510/* File: x86/unused.S */ 10511 jmp common_abort 10512 10513 10514/* ------------------------------ */ 10515.L_OP_UNUSED_77FF: /* 0x177 */ 10516/* File: x86/OP_UNUSED_77FF.S */ 10517/* File: x86/unused.S */ 10518 jmp common_abort 10519 10520 10521/* ------------------------------ */ 10522.L_OP_UNUSED_78FF: /* 0x178 */ 10523/* File: x86/OP_UNUSED_78FF.S */ 10524/* File: x86/unused.S */ 10525 jmp common_abort 10526 10527 10528/* ------------------------------ */ 10529.L_OP_UNUSED_79FF: /* 0x179 */ 10530/* File: x86/OP_UNUSED_79FF.S */ 10531/* File: x86/unused.S */ 10532 jmp common_abort 10533 10534 10535/* ------------------------------ */ 10536.L_OP_UNUSED_7AFF: /* 0x17a */ 10537/* File: x86/OP_UNUSED_7AFF.S */ 10538/* File: x86/unused.S */ 10539 jmp common_abort 10540 10541 10542/* ------------------------------ */ 10543.L_OP_UNUSED_7BFF: /* 0x17b */ 10544/* File: x86/OP_UNUSED_7BFF.S */ 10545/* File: x86/unused.S */ 10546 jmp common_abort 10547 10548 10549/* ------------------------------ */ 10550.L_OP_UNUSED_7CFF: /* 0x17c */ 10551/* File: x86/OP_UNUSED_7CFF.S */ 10552/* File: x86/unused.S */ 10553 jmp common_abort 10554 10555 10556/* ------------------------------ */ 10557.L_OP_UNUSED_7DFF: /* 0x17d */ 10558/* File: x86/OP_UNUSED_7DFF.S */ 10559/* File: x86/unused.S */ 10560 jmp common_abort 10561 10562 10563/* ------------------------------ */ 10564.L_OP_UNUSED_7EFF: /* 0x17e */ 10565/* File: x86/OP_UNUSED_7EFF.S */ 10566/* File: x86/unused.S */ 10567 jmp common_abort 10568 10569 10570/* ------------------------------ */ 10571.L_OP_UNUSED_7FFF: /* 0x17f */ 10572/* File: x86/OP_UNUSED_7FFF.S */ 10573/* File: x86/unused.S */ 10574 jmp common_abort 10575 10576 10577/* ------------------------------ */ 10578.L_OP_UNUSED_80FF: /* 0x180 */ 10579/* File: x86/OP_UNUSED_80FF.S */ 10580/* File: x86/unused.S */ 10581 jmp common_abort 10582 10583 10584/* ------------------------------ */ 10585.L_OP_UNUSED_81FF: /* 0x181 */ 10586/* File: x86/OP_UNUSED_81FF.S */ 10587/* File: x86/unused.S */ 10588 jmp common_abort 10589 10590 10591/* ------------------------------ */ 10592.L_OP_UNUSED_82FF: /* 0x182 */ 10593/* File: x86/OP_UNUSED_82FF.S */ 10594/* File: x86/unused.S */ 10595 jmp common_abort 10596 10597 10598/* ------------------------------ */ 10599.L_OP_UNUSED_83FF: /* 0x183 */ 10600/* File: x86/OP_UNUSED_83FF.S */ 10601/* File: x86/unused.S */ 10602 jmp common_abort 10603 10604 10605/* ------------------------------ */ 10606.L_OP_UNUSED_84FF: /* 0x184 */ 10607/* File: x86/OP_UNUSED_84FF.S */ 10608/* File: x86/unused.S */ 10609 jmp common_abort 10610 10611 10612/* ------------------------------ */ 10613.L_OP_UNUSED_85FF: /* 0x185 */ 10614/* File: x86/OP_UNUSED_85FF.S */ 10615/* File: x86/unused.S */ 10616 jmp common_abort 10617 10618 10619/* ------------------------------ */ 10620.L_OP_UNUSED_86FF: /* 0x186 */ 10621/* File: x86/OP_UNUSED_86FF.S */ 10622/* File: x86/unused.S */ 10623 jmp common_abort 10624 10625 10626/* ------------------------------ */ 10627.L_OP_UNUSED_87FF: /* 0x187 */ 10628/* File: x86/OP_UNUSED_87FF.S */ 10629/* File: x86/unused.S */ 10630 jmp common_abort 10631 10632 10633/* ------------------------------ */ 10634.L_OP_UNUSED_88FF: /* 0x188 */ 10635/* File: x86/OP_UNUSED_88FF.S */ 10636/* File: x86/unused.S */ 10637 jmp common_abort 10638 10639 10640/* ------------------------------ */ 10641.L_OP_UNUSED_89FF: /* 0x189 */ 10642/* File: x86/OP_UNUSED_89FF.S */ 10643/* File: x86/unused.S */ 10644 jmp common_abort 10645 10646 10647/* ------------------------------ */ 10648.L_OP_UNUSED_8AFF: /* 0x18a */ 10649/* File: x86/OP_UNUSED_8AFF.S */ 10650/* File: x86/unused.S */ 10651 jmp common_abort 10652 10653 10654/* ------------------------------ */ 10655.L_OP_UNUSED_8BFF: /* 0x18b */ 10656/* File: x86/OP_UNUSED_8BFF.S */ 10657/* File: x86/unused.S */ 10658 jmp common_abort 10659 10660 10661/* ------------------------------ */ 10662.L_OP_UNUSED_8CFF: /* 0x18c */ 10663/* File: x86/OP_UNUSED_8CFF.S */ 10664/* File: x86/unused.S */ 10665 jmp common_abort 10666 10667 10668/* ------------------------------ */ 10669.L_OP_UNUSED_8DFF: /* 0x18d */ 10670/* File: x86/OP_UNUSED_8DFF.S */ 10671/* File: x86/unused.S */ 10672 jmp common_abort 10673 10674 10675/* ------------------------------ */ 10676.L_OP_UNUSED_8EFF: /* 0x18e */ 10677/* File: x86/OP_UNUSED_8EFF.S */ 10678/* File: x86/unused.S */ 10679 jmp common_abort 10680 10681 10682/* ------------------------------ */ 10683.L_OP_UNUSED_8FFF: /* 0x18f */ 10684/* File: x86/OP_UNUSED_8FFF.S */ 10685/* File: x86/unused.S */ 10686 jmp common_abort 10687 10688 10689/* ------------------------------ */ 10690.L_OP_UNUSED_90FF: /* 0x190 */ 10691/* File: x86/OP_UNUSED_90FF.S */ 10692/* File: x86/unused.S */ 10693 jmp common_abort 10694 10695 10696/* ------------------------------ */ 10697.L_OP_UNUSED_91FF: /* 0x191 */ 10698/* File: x86/OP_UNUSED_91FF.S */ 10699/* File: x86/unused.S */ 10700 jmp common_abort 10701 10702 10703/* ------------------------------ */ 10704.L_OP_UNUSED_92FF: /* 0x192 */ 10705/* File: x86/OP_UNUSED_92FF.S */ 10706/* File: x86/unused.S */ 10707 jmp common_abort 10708 10709 10710/* ------------------------------ */ 10711.L_OP_UNUSED_93FF: /* 0x193 */ 10712/* File: x86/OP_UNUSED_93FF.S */ 10713/* File: x86/unused.S */ 10714 jmp common_abort 10715 10716 10717/* ------------------------------ */ 10718.L_OP_UNUSED_94FF: /* 0x194 */ 10719/* File: x86/OP_UNUSED_94FF.S */ 10720/* File: x86/unused.S */ 10721 jmp common_abort 10722 10723 10724/* ------------------------------ */ 10725.L_OP_UNUSED_95FF: /* 0x195 */ 10726/* File: x86/OP_UNUSED_95FF.S */ 10727/* File: x86/unused.S */ 10728 jmp common_abort 10729 10730 10731/* ------------------------------ */ 10732.L_OP_UNUSED_96FF: /* 0x196 */ 10733/* File: x86/OP_UNUSED_96FF.S */ 10734/* File: x86/unused.S */ 10735 jmp common_abort 10736 10737 10738/* ------------------------------ */ 10739.L_OP_UNUSED_97FF: /* 0x197 */ 10740/* File: x86/OP_UNUSED_97FF.S */ 10741/* File: x86/unused.S */ 10742 jmp common_abort 10743 10744 10745/* ------------------------------ */ 10746.L_OP_UNUSED_98FF: /* 0x198 */ 10747/* File: x86/OP_UNUSED_98FF.S */ 10748/* File: x86/unused.S */ 10749 jmp common_abort 10750 10751 10752/* ------------------------------ */ 10753.L_OP_UNUSED_99FF: /* 0x199 */ 10754/* File: x86/OP_UNUSED_99FF.S */ 10755/* File: x86/unused.S */ 10756 jmp common_abort 10757 10758 10759/* ------------------------------ */ 10760.L_OP_UNUSED_9AFF: /* 0x19a */ 10761/* File: x86/OP_UNUSED_9AFF.S */ 10762/* File: x86/unused.S */ 10763 jmp common_abort 10764 10765 10766/* ------------------------------ */ 10767.L_OP_UNUSED_9BFF: /* 0x19b */ 10768/* File: x86/OP_UNUSED_9BFF.S */ 10769/* File: x86/unused.S */ 10770 jmp common_abort 10771 10772 10773/* ------------------------------ */ 10774.L_OP_UNUSED_9CFF: /* 0x19c */ 10775/* File: x86/OP_UNUSED_9CFF.S */ 10776/* File: x86/unused.S */ 10777 jmp common_abort 10778 10779 10780/* ------------------------------ */ 10781.L_OP_UNUSED_9DFF: /* 0x19d */ 10782/* File: x86/OP_UNUSED_9DFF.S */ 10783/* File: x86/unused.S */ 10784 jmp common_abort 10785 10786 10787/* ------------------------------ */ 10788.L_OP_UNUSED_9EFF: /* 0x19e */ 10789/* File: x86/OP_UNUSED_9EFF.S */ 10790/* File: x86/unused.S */ 10791 jmp common_abort 10792 10793 10794/* ------------------------------ */ 10795.L_OP_UNUSED_9FFF: /* 0x19f */ 10796/* File: x86/OP_UNUSED_9FFF.S */ 10797/* File: x86/unused.S */ 10798 jmp common_abort 10799 10800 10801/* ------------------------------ */ 10802.L_OP_UNUSED_A0FF: /* 0x1a0 */ 10803/* File: x86/OP_UNUSED_A0FF.S */ 10804/* File: x86/unused.S */ 10805 jmp common_abort 10806 10807 10808/* ------------------------------ */ 10809.L_OP_UNUSED_A1FF: /* 0x1a1 */ 10810/* File: x86/OP_UNUSED_A1FF.S */ 10811/* File: x86/unused.S */ 10812 jmp common_abort 10813 10814 10815/* ------------------------------ */ 10816.L_OP_UNUSED_A2FF: /* 0x1a2 */ 10817/* File: x86/OP_UNUSED_A2FF.S */ 10818/* File: x86/unused.S */ 10819 jmp common_abort 10820 10821 10822/* ------------------------------ */ 10823.L_OP_UNUSED_A3FF: /* 0x1a3 */ 10824/* File: x86/OP_UNUSED_A3FF.S */ 10825/* File: x86/unused.S */ 10826 jmp common_abort 10827 10828 10829/* ------------------------------ */ 10830.L_OP_UNUSED_A4FF: /* 0x1a4 */ 10831/* File: x86/OP_UNUSED_A4FF.S */ 10832/* File: x86/unused.S */ 10833 jmp common_abort 10834 10835 10836/* ------------------------------ */ 10837.L_OP_UNUSED_A5FF: /* 0x1a5 */ 10838/* File: x86/OP_UNUSED_A5FF.S */ 10839/* File: x86/unused.S */ 10840 jmp common_abort 10841 10842 10843/* ------------------------------ */ 10844.L_OP_UNUSED_A6FF: /* 0x1a6 */ 10845/* File: x86/OP_UNUSED_A6FF.S */ 10846/* File: x86/unused.S */ 10847 jmp common_abort 10848 10849 10850/* ------------------------------ */ 10851.L_OP_UNUSED_A7FF: /* 0x1a7 */ 10852/* File: x86/OP_UNUSED_A7FF.S */ 10853/* File: x86/unused.S */ 10854 jmp common_abort 10855 10856 10857/* ------------------------------ */ 10858.L_OP_UNUSED_A8FF: /* 0x1a8 */ 10859/* File: x86/OP_UNUSED_A8FF.S */ 10860/* File: x86/unused.S */ 10861 jmp common_abort 10862 10863 10864/* ------------------------------ */ 10865.L_OP_UNUSED_A9FF: /* 0x1a9 */ 10866/* File: x86/OP_UNUSED_A9FF.S */ 10867/* File: x86/unused.S */ 10868 jmp common_abort 10869 10870 10871/* ------------------------------ */ 10872.L_OP_UNUSED_AAFF: /* 0x1aa */ 10873/* File: x86/OP_UNUSED_AAFF.S */ 10874/* File: x86/unused.S */ 10875 jmp common_abort 10876 10877 10878/* ------------------------------ */ 10879.L_OP_UNUSED_ABFF: /* 0x1ab */ 10880/* File: x86/OP_UNUSED_ABFF.S */ 10881/* File: x86/unused.S */ 10882 jmp common_abort 10883 10884 10885/* ------------------------------ */ 10886.L_OP_UNUSED_ACFF: /* 0x1ac */ 10887/* File: x86/OP_UNUSED_ACFF.S */ 10888/* File: x86/unused.S */ 10889 jmp common_abort 10890 10891 10892/* ------------------------------ */ 10893.L_OP_UNUSED_ADFF: /* 0x1ad */ 10894/* File: x86/OP_UNUSED_ADFF.S */ 10895/* File: x86/unused.S */ 10896 jmp common_abort 10897 10898 10899/* ------------------------------ */ 10900.L_OP_UNUSED_AEFF: /* 0x1ae */ 10901/* File: x86/OP_UNUSED_AEFF.S */ 10902/* File: x86/unused.S */ 10903 jmp common_abort 10904 10905 10906/* ------------------------------ */ 10907.L_OP_UNUSED_AFFF: /* 0x1af */ 10908/* File: x86/OP_UNUSED_AFFF.S */ 10909/* File: x86/unused.S */ 10910 jmp common_abort 10911 10912 10913/* ------------------------------ */ 10914.L_OP_UNUSED_B0FF: /* 0x1b0 */ 10915/* File: x86/OP_UNUSED_B0FF.S */ 10916/* File: x86/unused.S */ 10917 jmp common_abort 10918 10919 10920/* ------------------------------ */ 10921.L_OP_UNUSED_B1FF: /* 0x1b1 */ 10922/* File: x86/OP_UNUSED_B1FF.S */ 10923/* File: x86/unused.S */ 10924 jmp common_abort 10925 10926 10927/* ------------------------------ */ 10928.L_OP_UNUSED_B2FF: /* 0x1b2 */ 10929/* File: x86/OP_UNUSED_B2FF.S */ 10930/* File: x86/unused.S */ 10931 jmp common_abort 10932 10933 10934/* ------------------------------ */ 10935.L_OP_UNUSED_B3FF: /* 0x1b3 */ 10936/* File: x86/OP_UNUSED_B3FF.S */ 10937/* File: x86/unused.S */ 10938 jmp common_abort 10939 10940 10941/* ------------------------------ */ 10942.L_OP_UNUSED_B4FF: /* 0x1b4 */ 10943/* File: x86/OP_UNUSED_B4FF.S */ 10944/* File: x86/unused.S */ 10945 jmp common_abort 10946 10947 10948/* ------------------------------ */ 10949.L_OP_UNUSED_B5FF: /* 0x1b5 */ 10950/* File: x86/OP_UNUSED_B5FF.S */ 10951/* File: x86/unused.S */ 10952 jmp common_abort 10953 10954 10955/* ------------------------------ */ 10956.L_OP_UNUSED_B6FF: /* 0x1b6 */ 10957/* File: x86/OP_UNUSED_B6FF.S */ 10958/* File: x86/unused.S */ 10959 jmp common_abort 10960 10961 10962/* ------------------------------ */ 10963.L_OP_UNUSED_B7FF: /* 0x1b7 */ 10964/* File: x86/OP_UNUSED_B7FF.S */ 10965/* File: x86/unused.S */ 10966 jmp common_abort 10967 10968 10969/* ------------------------------ */ 10970.L_OP_UNUSED_B8FF: /* 0x1b8 */ 10971/* File: x86/OP_UNUSED_B8FF.S */ 10972/* File: x86/unused.S */ 10973 jmp common_abort 10974 10975 10976/* ------------------------------ */ 10977.L_OP_UNUSED_B9FF: /* 0x1b9 */ 10978/* File: x86/OP_UNUSED_B9FF.S */ 10979/* File: x86/unused.S */ 10980 jmp common_abort 10981 10982 10983/* ------------------------------ */ 10984.L_OP_UNUSED_BAFF: /* 0x1ba */ 10985/* File: x86/OP_UNUSED_BAFF.S */ 10986/* File: x86/unused.S */ 10987 jmp common_abort 10988 10989 10990/* ------------------------------ */ 10991.L_OP_UNUSED_BBFF: /* 0x1bb */ 10992/* File: x86/OP_UNUSED_BBFF.S */ 10993/* File: x86/unused.S */ 10994 jmp common_abort 10995 10996 10997/* ------------------------------ */ 10998.L_OP_UNUSED_BCFF: /* 0x1bc */ 10999/* File: x86/OP_UNUSED_BCFF.S */ 11000/* File: x86/unused.S */ 11001 jmp common_abort 11002 11003 11004/* ------------------------------ */ 11005.L_OP_UNUSED_BDFF: /* 0x1bd */ 11006/* File: x86/OP_UNUSED_BDFF.S */ 11007/* File: x86/unused.S */ 11008 jmp common_abort 11009 11010 11011/* ------------------------------ */ 11012.L_OP_UNUSED_BEFF: /* 0x1be */ 11013/* File: x86/OP_UNUSED_BEFF.S */ 11014/* File: x86/unused.S */ 11015 jmp common_abort 11016 11017 11018/* ------------------------------ */ 11019.L_OP_UNUSED_BFFF: /* 0x1bf */ 11020/* File: x86/OP_UNUSED_BFFF.S */ 11021/* File: x86/unused.S */ 11022 jmp common_abort 11023 11024 11025/* ------------------------------ */ 11026.L_OP_UNUSED_C0FF: /* 0x1c0 */ 11027/* File: x86/OP_UNUSED_C0FF.S */ 11028/* File: x86/unused.S */ 11029 jmp common_abort 11030 11031 11032/* ------------------------------ */ 11033.L_OP_UNUSED_C1FF: /* 0x1c1 */ 11034/* File: x86/OP_UNUSED_C1FF.S */ 11035/* File: x86/unused.S */ 11036 jmp common_abort 11037 11038 11039/* ------------------------------ */ 11040.L_OP_UNUSED_C2FF: /* 0x1c2 */ 11041/* File: x86/OP_UNUSED_C2FF.S */ 11042/* File: x86/unused.S */ 11043 jmp common_abort 11044 11045 11046/* ------------------------------ */ 11047.L_OP_UNUSED_C3FF: /* 0x1c3 */ 11048/* File: x86/OP_UNUSED_C3FF.S */ 11049/* File: x86/unused.S */ 11050 jmp common_abort 11051 11052 11053/* ------------------------------ */ 11054.L_OP_UNUSED_C4FF: /* 0x1c4 */ 11055/* File: x86/OP_UNUSED_C4FF.S */ 11056/* File: x86/unused.S */ 11057 jmp common_abort 11058 11059 11060/* ------------------------------ */ 11061.L_OP_UNUSED_C5FF: /* 0x1c5 */ 11062/* File: x86/OP_UNUSED_C5FF.S */ 11063/* File: x86/unused.S */ 11064 jmp common_abort 11065 11066 11067/* ------------------------------ */ 11068.L_OP_UNUSED_C6FF: /* 0x1c6 */ 11069/* File: x86/OP_UNUSED_C6FF.S */ 11070/* File: x86/unused.S */ 11071 jmp common_abort 11072 11073 11074/* ------------------------------ */ 11075.L_OP_UNUSED_C7FF: /* 0x1c7 */ 11076/* File: x86/OP_UNUSED_C7FF.S */ 11077/* File: x86/unused.S */ 11078 jmp common_abort 11079 11080 11081/* ------------------------------ */ 11082.L_OP_UNUSED_C8FF: /* 0x1c8 */ 11083/* File: x86/OP_UNUSED_C8FF.S */ 11084/* File: x86/unused.S */ 11085 jmp common_abort 11086 11087 11088/* ------------------------------ */ 11089.L_OP_UNUSED_C9FF: /* 0x1c9 */ 11090/* File: x86/OP_UNUSED_C9FF.S */ 11091/* File: x86/unused.S */ 11092 jmp common_abort 11093 11094 11095/* ------------------------------ */ 11096.L_OP_UNUSED_CAFF: /* 0x1ca */ 11097/* File: x86/OP_UNUSED_CAFF.S */ 11098/* File: x86/unused.S */ 11099 jmp common_abort 11100 11101 11102/* ------------------------------ */ 11103.L_OP_UNUSED_CBFF: /* 0x1cb */ 11104/* File: x86/OP_UNUSED_CBFF.S */ 11105/* File: x86/unused.S */ 11106 jmp common_abort 11107 11108 11109/* ------------------------------ */ 11110.L_OP_UNUSED_CCFF: /* 0x1cc */ 11111/* File: x86/OP_UNUSED_CCFF.S */ 11112/* File: x86/unused.S */ 11113 jmp common_abort 11114 11115 11116/* ------------------------------ */ 11117.L_OP_UNUSED_CDFF: /* 0x1cd */ 11118/* File: x86/OP_UNUSED_CDFF.S */ 11119/* File: x86/unused.S */ 11120 jmp common_abort 11121 11122 11123/* ------------------------------ */ 11124.L_OP_UNUSED_CEFF: /* 0x1ce */ 11125/* File: x86/OP_UNUSED_CEFF.S */ 11126/* File: x86/unused.S */ 11127 jmp common_abort 11128 11129 11130/* ------------------------------ */ 11131.L_OP_UNUSED_CFFF: /* 0x1cf */ 11132/* File: x86/OP_UNUSED_CFFF.S */ 11133/* File: x86/unused.S */ 11134 jmp common_abort 11135 11136 11137/* ------------------------------ */ 11138.L_OP_UNUSED_D0FF: /* 0x1d0 */ 11139/* File: x86/OP_UNUSED_D0FF.S */ 11140/* File: x86/unused.S */ 11141 jmp common_abort 11142 11143 11144/* ------------------------------ */ 11145.L_OP_UNUSED_D1FF: /* 0x1d1 */ 11146/* File: x86/OP_UNUSED_D1FF.S */ 11147/* File: x86/unused.S */ 11148 jmp common_abort 11149 11150 11151/* ------------------------------ */ 11152.L_OP_UNUSED_D2FF: /* 0x1d2 */ 11153/* File: x86/OP_UNUSED_D2FF.S */ 11154/* File: x86/unused.S */ 11155 jmp common_abort 11156 11157 11158/* ------------------------------ */ 11159.L_OP_UNUSED_D3FF: /* 0x1d3 */ 11160/* File: x86/OP_UNUSED_D3FF.S */ 11161/* File: x86/unused.S */ 11162 jmp common_abort 11163 11164 11165/* ------------------------------ */ 11166.L_OP_UNUSED_D4FF: /* 0x1d4 */ 11167/* File: x86/OP_UNUSED_D4FF.S */ 11168/* File: x86/unused.S */ 11169 jmp common_abort 11170 11171 11172/* ------------------------------ */ 11173.L_OP_UNUSED_D5FF: /* 0x1d5 */ 11174/* File: x86/OP_UNUSED_D5FF.S */ 11175/* File: x86/unused.S */ 11176 jmp common_abort 11177 11178 11179/* ------------------------------ */ 11180.L_OP_UNUSED_D6FF: /* 0x1d6 */ 11181/* File: x86/OP_UNUSED_D6FF.S */ 11182/* File: x86/unused.S */ 11183 jmp common_abort 11184 11185 11186/* ------------------------------ */ 11187.L_OP_UNUSED_D7FF: /* 0x1d7 */ 11188/* File: x86/OP_UNUSED_D7FF.S */ 11189/* File: x86/unused.S */ 11190 jmp common_abort 11191 11192 11193/* ------------------------------ */ 11194.L_OP_UNUSED_D8FF: /* 0x1d8 */ 11195/* File: x86/OP_UNUSED_D8FF.S */ 11196/* File: x86/unused.S */ 11197 jmp common_abort 11198 11199 11200/* ------------------------------ */ 11201.L_OP_UNUSED_D9FF: /* 0x1d9 */ 11202/* File: x86/OP_UNUSED_D9FF.S */ 11203/* File: x86/unused.S */ 11204 jmp common_abort 11205 11206 11207/* ------------------------------ */ 11208.L_OP_UNUSED_DAFF: /* 0x1da */ 11209/* File: x86/OP_UNUSED_DAFF.S */ 11210/* File: x86/unused.S */ 11211 jmp common_abort 11212 11213 11214/* ------------------------------ */ 11215.L_OP_UNUSED_DBFF: /* 0x1db */ 11216/* File: x86/OP_UNUSED_DBFF.S */ 11217/* File: x86/unused.S */ 11218 jmp common_abort 11219 11220 11221/* ------------------------------ */ 11222.L_OP_UNUSED_DCFF: /* 0x1dc */ 11223/* File: x86/OP_UNUSED_DCFF.S */ 11224/* File: x86/unused.S */ 11225 jmp common_abort 11226 11227 11228/* ------------------------------ */ 11229.L_OP_UNUSED_DDFF: /* 0x1dd */ 11230/* File: x86/OP_UNUSED_DDFF.S */ 11231/* File: x86/unused.S */ 11232 jmp common_abort 11233 11234 11235/* ------------------------------ */ 11236.L_OP_UNUSED_DEFF: /* 0x1de */ 11237/* File: x86/OP_UNUSED_DEFF.S */ 11238/* File: x86/unused.S */ 11239 jmp common_abort 11240 11241 11242/* ------------------------------ */ 11243.L_OP_UNUSED_DFFF: /* 0x1df */ 11244/* File: x86/OP_UNUSED_DFFF.S */ 11245/* File: x86/unused.S */ 11246 jmp common_abort 11247 11248 11249/* ------------------------------ */ 11250.L_OP_UNUSED_E0FF: /* 0x1e0 */ 11251/* File: x86/OP_UNUSED_E0FF.S */ 11252/* File: x86/unused.S */ 11253 jmp common_abort 11254 11255 11256/* ------------------------------ */ 11257.L_OP_UNUSED_E1FF: /* 0x1e1 */ 11258/* File: x86/OP_UNUSED_E1FF.S */ 11259/* File: x86/unused.S */ 11260 jmp common_abort 11261 11262 11263/* ------------------------------ */ 11264.L_OP_UNUSED_E2FF: /* 0x1e2 */ 11265/* File: x86/OP_UNUSED_E2FF.S */ 11266/* File: x86/unused.S */ 11267 jmp common_abort 11268 11269 11270/* ------------------------------ */ 11271.L_OP_UNUSED_E3FF: /* 0x1e3 */ 11272/* File: x86/OP_UNUSED_E3FF.S */ 11273/* File: x86/unused.S */ 11274 jmp common_abort 11275 11276 11277/* ------------------------------ */ 11278.L_OP_UNUSED_E4FF: /* 0x1e4 */ 11279/* File: x86/OP_UNUSED_E4FF.S */ 11280/* File: x86/unused.S */ 11281 jmp common_abort 11282 11283 11284/* ------------------------------ */ 11285.L_OP_UNUSED_E5FF: /* 0x1e5 */ 11286/* File: x86/OP_UNUSED_E5FF.S */ 11287/* File: x86/unused.S */ 11288 jmp common_abort 11289 11290 11291/* ------------------------------ */ 11292.L_OP_UNUSED_E6FF: /* 0x1e6 */ 11293/* File: x86/OP_UNUSED_E6FF.S */ 11294/* File: x86/unused.S */ 11295 jmp common_abort 11296 11297 11298/* ------------------------------ */ 11299.L_OP_UNUSED_E7FF: /* 0x1e7 */ 11300/* File: x86/OP_UNUSED_E7FF.S */ 11301/* File: x86/unused.S */ 11302 jmp common_abort 11303 11304 11305/* ------------------------------ */ 11306.L_OP_UNUSED_E8FF: /* 0x1e8 */ 11307/* File: x86/OP_UNUSED_E8FF.S */ 11308/* File: x86/unused.S */ 11309 jmp common_abort 11310 11311 11312/* ------------------------------ */ 11313.L_OP_UNUSED_E9FF: /* 0x1e9 */ 11314/* File: x86/OP_UNUSED_E9FF.S */ 11315/* File: x86/unused.S */ 11316 jmp common_abort 11317 11318 11319/* ------------------------------ */ 11320.L_OP_UNUSED_EAFF: /* 0x1ea */ 11321/* File: x86/OP_UNUSED_EAFF.S */ 11322/* File: x86/unused.S */ 11323 jmp common_abort 11324 11325 11326/* ------------------------------ */ 11327.L_OP_UNUSED_EBFF: /* 0x1eb */ 11328/* File: x86/OP_UNUSED_EBFF.S */ 11329/* File: x86/unused.S */ 11330 jmp common_abort 11331 11332 11333/* ------------------------------ */ 11334.L_OP_UNUSED_ECFF: /* 0x1ec */ 11335/* File: x86/OP_UNUSED_ECFF.S */ 11336/* File: x86/unused.S */ 11337 jmp common_abort 11338 11339 11340/* ------------------------------ */ 11341.L_OP_UNUSED_EDFF: /* 0x1ed */ 11342/* File: x86/OP_UNUSED_EDFF.S */ 11343/* File: x86/unused.S */ 11344 jmp common_abort 11345 11346 11347/* ------------------------------ */ 11348.L_OP_UNUSED_EEFF: /* 0x1ee */ 11349/* File: x86/OP_UNUSED_EEFF.S */ 11350/* File: x86/unused.S */ 11351 jmp common_abort 11352 11353 11354/* ------------------------------ */ 11355.L_OP_UNUSED_EFFF: /* 0x1ef */ 11356/* File: x86/OP_UNUSED_EFFF.S */ 11357/* File: x86/unused.S */ 11358 jmp common_abort 11359 11360 11361/* ------------------------------ */ 11362.L_OP_UNUSED_F0FF: /* 0x1f0 */ 11363/* File: x86/OP_UNUSED_F0FF.S */ 11364/* File: x86/unused.S */ 11365 jmp common_abort 11366 11367 11368/* ------------------------------ */ 11369.L_OP_UNUSED_F1FF: /* 0x1f1 */ 11370/* File: x86/OP_UNUSED_F1FF.S */ 11371/* File: x86/unused.S */ 11372 jmp common_abort 11373 11374 11375/* ------------------------------ */ 11376.L_OP_UNUSED_F2FF: /* 0x1f2 */ 11377/* File: x86/OP_UNUSED_F2FF.S */ 11378/* File: x86/unused.S */ 11379 jmp common_abort 11380 11381 11382/* ------------------------------ */ 11383.L_OP_UNUSED_F3FF: /* 0x1f3 */ 11384/* File: x86/OP_UNUSED_F3FF.S */ 11385/* File: x86/unused.S */ 11386 jmp common_abort 11387 11388 11389/* ------------------------------ */ 11390.L_OP_UNUSED_F4FF: /* 0x1f4 */ 11391/* File: x86/OP_UNUSED_F4FF.S */ 11392/* File: x86/unused.S */ 11393 jmp common_abort 11394 11395 11396/* ------------------------------ */ 11397.L_OP_UNUSED_F5FF: /* 0x1f5 */ 11398/* File: x86/OP_UNUSED_F5FF.S */ 11399/* File: x86/unused.S */ 11400 jmp common_abort 11401 11402 11403/* ------------------------------ */ 11404.L_OP_UNUSED_F6FF: /* 0x1f6 */ 11405/* File: x86/OP_UNUSED_F6FF.S */ 11406/* File: x86/unused.S */ 11407 jmp common_abort 11408 11409 11410/* ------------------------------ */ 11411.L_OP_UNUSED_F7FF: /* 0x1f7 */ 11412/* File: x86/OP_UNUSED_F7FF.S */ 11413/* File: x86/unused.S */ 11414 jmp common_abort 11415 11416 11417/* ------------------------------ */ 11418.L_OP_UNUSED_F8FF: /* 0x1f8 */ 11419/* File: x86/OP_UNUSED_F8FF.S */ 11420/* File: x86/unused.S */ 11421 jmp common_abort 11422 11423 11424/* ------------------------------ */ 11425.L_OP_UNUSED_F9FF: /* 0x1f9 */ 11426/* File: x86/OP_UNUSED_F9FF.S */ 11427/* File: x86/unused.S */ 11428 jmp common_abort 11429 11430 11431/* ------------------------------ */ 11432.L_OP_UNUSED_FAFF: /* 0x1fa */ 11433/* File: x86/OP_UNUSED_FAFF.S */ 11434/* File: x86/unused.S */ 11435 jmp common_abort 11436 11437 11438/* ------------------------------ */ 11439.L_OP_UNUSED_FBFF: /* 0x1fb */ 11440/* File: x86/OP_UNUSED_FBFF.S */ 11441/* File: x86/unused.S */ 11442 jmp common_abort 11443 11444 11445/* ------------------------------ */ 11446.L_OP_UNUSED_FCFF: /* 0x1fc */ 11447/* File: x86/OP_UNUSED_FCFF.S */ 11448/* File: x86/unused.S */ 11449 jmp common_abort 11450 11451 11452/* ------------------------------ */ 11453.L_OP_UNUSED_FDFF: /* 0x1fd */ 11454/* File: x86/OP_UNUSED_FDFF.S */ 11455/* File: x86/unused.S */ 11456 jmp common_abort 11457 11458 11459/* ------------------------------ */ 11460.L_OP_UNUSED_FEFF: /* 0x1fe */ 11461/* File: x86/OP_UNUSED_FEFF.S */ 11462/* File: x86/unused.S */ 11463 jmp common_abort 11464 11465 11466/* ------------------------------ */ 11467.L_OP_THROW_VERIFICATION_ERROR_JUMBO: /* 0x1ff */ 11468/* File: x86/OP_THROW_VERIFICATION_ERROR_JUMBO.S */ 11469 /* 11470 * Handle a jumbo throw-verification-error instruction. This throws an 11471 * exception for an error discovered during verification. The 11472 * exception is indicated by BBBB, with some detail provided by AAAAAAAA. 11473 */ 11474 /* exop BBBB, ref@AAAAAAAA */ 11475 movl rSELF,%ecx 11476 movl 2(rPC),%eax # eax<- AAAAAAAA 11477 movl offThread_method(%ecx),%ecx # ecx<- self->method 11478 EXPORT_PC 11479 movl %eax,OUT_ARG2(%esp) # arg2<- AAAAAAAA 11480 movl rINST,OUT_ARG1(%esp) # arg1<- BBBB 11481 movl %ecx,OUT_ARG0(%esp) # arg0<- method 11482 call dvmThrowVerificationError # call(method, kind, ref) 11483 jmp common_exceptionThrown # handle exception 11484 11485 .size dvmAsmInstructionStartCode, .-dvmAsmInstructionStartCode 11486 .global dvmAsmInstructionEndCode 11487dvmAsmInstructionEndCode: 11488 11489 .global dvmAsmAltInstructionStartCode 11490 .type dvmAsmAltInstructionStartCode, %function 11491dvmAsmAltInstructionStartCode: 11492 .text 11493 11494/* ------------------------------ */ 11495.L_ALT_OP_NOP: /* 0x00 */ 11496/* File: x86/ALT_STUB.S */ 11497/* 11498 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11499 * any interesting requests and then jump to the real instruction 11500 * handler. Unlike the Arm handler, we can't do this as a tail call 11501 * because rIBASE is caller save and we need to reload it. 11502 */ 11503 movl rSELF, %eax 11504 movl rPC, OUT_ARG0(%esp) 11505 movl %eax, OUT_ARG1(%esp) 11506 call dvmCheckInst # (dPC, self) 11507 movl rSELF, %ecx 11508 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11509 jmp *dvmAsmInstructionStart+(0*4) 11510 11511/* ------------------------------ */ 11512.L_ALT_OP_MOVE: /* 0x01 */ 11513/* File: x86/ALT_STUB.S */ 11514/* 11515 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11516 * any interesting requests and then jump to the real instruction 11517 * handler. Unlike the Arm handler, we can't do this as a tail call 11518 * because rIBASE is caller save and we need to reload it. 11519 */ 11520 movl rSELF, %eax 11521 movl rPC, OUT_ARG0(%esp) 11522 movl %eax, OUT_ARG1(%esp) 11523 call dvmCheckInst # (dPC, self) 11524 movl rSELF, %ecx 11525 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11526 jmp *dvmAsmInstructionStart+(1*4) 11527 11528/* ------------------------------ */ 11529.L_ALT_OP_MOVE_FROM16: /* 0x02 */ 11530/* File: x86/ALT_STUB.S */ 11531/* 11532 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11533 * any interesting requests and then jump to the real instruction 11534 * handler. Unlike the Arm handler, we can't do this as a tail call 11535 * because rIBASE is caller save and we need to reload it. 11536 */ 11537 movl rSELF, %eax 11538 movl rPC, OUT_ARG0(%esp) 11539 movl %eax, OUT_ARG1(%esp) 11540 call dvmCheckInst # (dPC, self) 11541 movl rSELF, %ecx 11542 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11543 jmp *dvmAsmInstructionStart+(2*4) 11544 11545/* ------------------------------ */ 11546.L_ALT_OP_MOVE_16: /* 0x03 */ 11547/* File: x86/ALT_STUB.S */ 11548/* 11549 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11550 * any interesting requests and then jump to the real instruction 11551 * handler. Unlike the Arm handler, we can't do this as a tail call 11552 * because rIBASE is caller save and we need to reload it. 11553 */ 11554 movl rSELF, %eax 11555 movl rPC, OUT_ARG0(%esp) 11556 movl %eax, OUT_ARG1(%esp) 11557 call dvmCheckInst # (dPC, self) 11558 movl rSELF, %ecx 11559 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11560 jmp *dvmAsmInstructionStart+(3*4) 11561 11562/* ------------------------------ */ 11563.L_ALT_OP_MOVE_WIDE: /* 0x04 */ 11564/* File: x86/ALT_STUB.S */ 11565/* 11566 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11567 * any interesting requests and then jump to the real instruction 11568 * handler. Unlike the Arm handler, we can't do this as a tail call 11569 * because rIBASE is caller save and we need to reload it. 11570 */ 11571 movl rSELF, %eax 11572 movl rPC, OUT_ARG0(%esp) 11573 movl %eax, OUT_ARG1(%esp) 11574 call dvmCheckInst # (dPC, self) 11575 movl rSELF, %ecx 11576 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11577 jmp *dvmAsmInstructionStart+(4*4) 11578 11579/* ------------------------------ */ 11580.L_ALT_OP_MOVE_WIDE_FROM16: /* 0x05 */ 11581/* File: x86/ALT_STUB.S */ 11582/* 11583 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11584 * any interesting requests and then jump to the real instruction 11585 * handler. Unlike the Arm handler, we can't do this as a tail call 11586 * because rIBASE is caller save and we need to reload it. 11587 */ 11588 movl rSELF, %eax 11589 movl rPC, OUT_ARG0(%esp) 11590 movl %eax, OUT_ARG1(%esp) 11591 call dvmCheckInst # (dPC, self) 11592 movl rSELF, %ecx 11593 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11594 jmp *dvmAsmInstructionStart+(5*4) 11595 11596/* ------------------------------ */ 11597.L_ALT_OP_MOVE_WIDE_16: /* 0x06 */ 11598/* File: x86/ALT_STUB.S */ 11599/* 11600 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11601 * any interesting requests and then jump to the real instruction 11602 * handler. Unlike the Arm handler, we can't do this as a tail call 11603 * because rIBASE is caller save and we need to reload it. 11604 */ 11605 movl rSELF, %eax 11606 movl rPC, OUT_ARG0(%esp) 11607 movl %eax, OUT_ARG1(%esp) 11608 call dvmCheckInst # (dPC, self) 11609 movl rSELF, %ecx 11610 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11611 jmp *dvmAsmInstructionStart+(6*4) 11612 11613/* ------------------------------ */ 11614.L_ALT_OP_MOVE_OBJECT: /* 0x07 */ 11615/* File: x86/ALT_STUB.S */ 11616/* 11617 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11618 * any interesting requests and then jump to the real instruction 11619 * handler. Unlike the Arm handler, we can't do this as a tail call 11620 * because rIBASE is caller save and we need to reload it. 11621 */ 11622 movl rSELF, %eax 11623 movl rPC, OUT_ARG0(%esp) 11624 movl %eax, OUT_ARG1(%esp) 11625 call dvmCheckInst # (dPC, self) 11626 movl rSELF, %ecx 11627 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11628 jmp *dvmAsmInstructionStart+(7*4) 11629 11630/* ------------------------------ */ 11631.L_ALT_OP_MOVE_OBJECT_FROM16: /* 0x08 */ 11632/* File: x86/ALT_STUB.S */ 11633/* 11634 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11635 * any interesting requests and then jump to the real instruction 11636 * handler. Unlike the Arm handler, we can't do this as a tail call 11637 * because rIBASE is caller save and we need to reload it. 11638 */ 11639 movl rSELF, %eax 11640 movl rPC, OUT_ARG0(%esp) 11641 movl %eax, OUT_ARG1(%esp) 11642 call dvmCheckInst # (dPC, self) 11643 movl rSELF, %ecx 11644 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11645 jmp *dvmAsmInstructionStart+(8*4) 11646 11647/* ------------------------------ */ 11648.L_ALT_OP_MOVE_OBJECT_16: /* 0x09 */ 11649/* File: x86/ALT_STUB.S */ 11650/* 11651 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11652 * any interesting requests and then jump to the real instruction 11653 * handler. Unlike the Arm handler, we can't do this as a tail call 11654 * because rIBASE is caller save and we need to reload it. 11655 */ 11656 movl rSELF, %eax 11657 movl rPC, OUT_ARG0(%esp) 11658 movl %eax, OUT_ARG1(%esp) 11659 call dvmCheckInst # (dPC, self) 11660 movl rSELF, %ecx 11661 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11662 jmp *dvmAsmInstructionStart+(9*4) 11663 11664/* ------------------------------ */ 11665.L_ALT_OP_MOVE_RESULT: /* 0x0a */ 11666/* File: x86/ALT_STUB.S */ 11667/* 11668 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11669 * any interesting requests and then jump to the real instruction 11670 * handler. Unlike the Arm handler, we can't do this as a tail call 11671 * because rIBASE is caller save and we need to reload it. 11672 */ 11673 movl rSELF, %eax 11674 movl rPC, OUT_ARG0(%esp) 11675 movl %eax, OUT_ARG1(%esp) 11676 call dvmCheckInst # (dPC, self) 11677 movl rSELF, %ecx 11678 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11679 jmp *dvmAsmInstructionStart+(10*4) 11680 11681/* ------------------------------ */ 11682.L_ALT_OP_MOVE_RESULT_WIDE: /* 0x0b */ 11683/* File: x86/ALT_STUB.S */ 11684/* 11685 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11686 * any interesting requests and then jump to the real instruction 11687 * handler. Unlike the Arm handler, we can't do this as a tail call 11688 * because rIBASE is caller save and we need to reload it. 11689 */ 11690 movl rSELF, %eax 11691 movl rPC, OUT_ARG0(%esp) 11692 movl %eax, OUT_ARG1(%esp) 11693 call dvmCheckInst # (dPC, self) 11694 movl rSELF, %ecx 11695 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11696 jmp *dvmAsmInstructionStart+(11*4) 11697 11698/* ------------------------------ */ 11699.L_ALT_OP_MOVE_RESULT_OBJECT: /* 0x0c */ 11700/* File: x86/ALT_STUB.S */ 11701/* 11702 * Inter-instruction transfer stub. Call out to dvmCheckInst 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 movl rSELF, %eax 11708 movl rPC, OUT_ARG0(%esp) 11709 movl %eax, OUT_ARG1(%esp) 11710 call dvmCheckInst # (dPC, self) 11711 movl rSELF, %ecx 11712 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11713 jmp *dvmAsmInstructionStart+(12*4) 11714 11715/* ------------------------------ */ 11716.L_ALT_OP_MOVE_EXCEPTION: /* 0x0d */ 11717/* File: x86/ALT_STUB.S */ 11718/* 11719 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11720 * any interesting requests and then jump to the real instruction 11721 * handler. Unlike the Arm handler, we can't do this as a tail call 11722 * because rIBASE is caller save and we need to reload it. 11723 */ 11724 movl rSELF, %eax 11725 movl rPC, OUT_ARG0(%esp) 11726 movl %eax, OUT_ARG1(%esp) 11727 call dvmCheckInst # (dPC, self) 11728 movl rSELF, %ecx 11729 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11730 jmp *dvmAsmInstructionStart+(13*4) 11731 11732/* ------------------------------ */ 11733.L_ALT_OP_RETURN_VOID: /* 0x0e */ 11734/* File: x86/ALT_STUB.S */ 11735/* 11736 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11737 * any interesting requests and then jump to the real instruction 11738 * handler. Unlike the Arm handler, we can't do this as a tail call 11739 * because rIBASE is caller save and we need to reload it. 11740 */ 11741 movl rSELF, %eax 11742 movl rPC, OUT_ARG0(%esp) 11743 movl %eax, OUT_ARG1(%esp) 11744 call dvmCheckInst # (dPC, self) 11745 movl rSELF, %ecx 11746 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11747 jmp *dvmAsmInstructionStart+(14*4) 11748 11749/* ------------------------------ */ 11750.L_ALT_OP_RETURN: /* 0x0f */ 11751/* File: x86/ALT_STUB.S */ 11752/* 11753 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11754 * any interesting requests and then jump to the real instruction 11755 * handler. Unlike the Arm handler, we can't do this as a tail call 11756 * because rIBASE is caller save and we need to reload it. 11757 */ 11758 movl rSELF, %eax 11759 movl rPC, OUT_ARG0(%esp) 11760 movl %eax, OUT_ARG1(%esp) 11761 call dvmCheckInst # (dPC, self) 11762 movl rSELF, %ecx 11763 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11764 jmp *dvmAsmInstructionStart+(15*4) 11765 11766/* ------------------------------ */ 11767.L_ALT_OP_RETURN_WIDE: /* 0x10 */ 11768/* File: x86/ALT_STUB.S */ 11769/* 11770 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11771 * any interesting requests and then jump to the real instruction 11772 * handler. Unlike the Arm handler, we can't do this as a tail call 11773 * because rIBASE is caller save and we need to reload it. 11774 */ 11775 movl rSELF, %eax 11776 movl rPC, OUT_ARG0(%esp) 11777 movl %eax, OUT_ARG1(%esp) 11778 call dvmCheckInst # (dPC, self) 11779 movl rSELF, %ecx 11780 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11781 jmp *dvmAsmInstructionStart+(16*4) 11782 11783/* ------------------------------ */ 11784.L_ALT_OP_RETURN_OBJECT: /* 0x11 */ 11785/* File: x86/ALT_STUB.S */ 11786/* 11787 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11788 * any interesting requests and then jump to the real instruction 11789 * handler. Unlike the Arm handler, we can't do this as a tail call 11790 * because rIBASE is caller save and we need to reload it. 11791 */ 11792 movl rSELF, %eax 11793 movl rPC, OUT_ARG0(%esp) 11794 movl %eax, OUT_ARG1(%esp) 11795 call dvmCheckInst # (dPC, self) 11796 movl rSELF, %ecx 11797 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11798 jmp *dvmAsmInstructionStart+(17*4) 11799 11800/* ------------------------------ */ 11801.L_ALT_OP_CONST_4: /* 0x12 */ 11802/* File: x86/ALT_STUB.S */ 11803/* 11804 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11805 * any interesting requests and then jump to the real instruction 11806 * handler. Unlike the Arm handler, we can't do this as a tail call 11807 * because rIBASE is caller save and we need to reload it. 11808 */ 11809 movl rSELF, %eax 11810 movl rPC, OUT_ARG0(%esp) 11811 movl %eax, OUT_ARG1(%esp) 11812 call dvmCheckInst # (dPC, self) 11813 movl rSELF, %ecx 11814 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11815 jmp *dvmAsmInstructionStart+(18*4) 11816 11817/* ------------------------------ */ 11818.L_ALT_OP_CONST_16: /* 0x13 */ 11819/* File: x86/ALT_STUB.S */ 11820/* 11821 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11822 * any interesting requests and then jump to the real instruction 11823 * handler. Unlike the Arm handler, we can't do this as a tail call 11824 * because rIBASE is caller save and we need to reload it. 11825 */ 11826 movl rSELF, %eax 11827 movl rPC, OUT_ARG0(%esp) 11828 movl %eax, OUT_ARG1(%esp) 11829 call dvmCheckInst # (dPC, self) 11830 movl rSELF, %ecx 11831 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11832 jmp *dvmAsmInstructionStart+(19*4) 11833 11834/* ------------------------------ */ 11835.L_ALT_OP_CONST: /* 0x14 */ 11836/* File: x86/ALT_STUB.S */ 11837/* 11838 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11839 * any interesting requests and then jump to the real instruction 11840 * handler. Unlike the Arm handler, we can't do this as a tail call 11841 * because rIBASE is caller save and we need to reload it. 11842 */ 11843 movl rSELF, %eax 11844 movl rPC, OUT_ARG0(%esp) 11845 movl %eax, OUT_ARG1(%esp) 11846 call dvmCheckInst # (dPC, self) 11847 movl rSELF, %ecx 11848 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11849 jmp *dvmAsmInstructionStart+(20*4) 11850 11851/* ------------------------------ */ 11852.L_ALT_OP_CONST_HIGH16: /* 0x15 */ 11853/* File: x86/ALT_STUB.S */ 11854/* 11855 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11856 * any interesting requests and then jump to the real instruction 11857 * handler. Unlike the Arm handler, we can't do this as a tail call 11858 * because rIBASE is caller save and we need to reload it. 11859 */ 11860 movl rSELF, %eax 11861 movl rPC, OUT_ARG0(%esp) 11862 movl %eax, OUT_ARG1(%esp) 11863 call dvmCheckInst # (dPC, self) 11864 movl rSELF, %ecx 11865 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11866 jmp *dvmAsmInstructionStart+(21*4) 11867 11868/* ------------------------------ */ 11869.L_ALT_OP_CONST_WIDE_16: /* 0x16 */ 11870/* File: x86/ALT_STUB.S */ 11871/* 11872 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11873 * any interesting requests and then jump to the real instruction 11874 * handler. Unlike the Arm handler, we can't do this as a tail call 11875 * because rIBASE is caller save and we need to reload it. 11876 */ 11877 movl rSELF, %eax 11878 movl rPC, OUT_ARG0(%esp) 11879 movl %eax, OUT_ARG1(%esp) 11880 call dvmCheckInst # (dPC, self) 11881 movl rSELF, %ecx 11882 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11883 jmp *dvmAsmInstructionStart+(22*4) 11884 11885/* ------------------------------ */ 11886.L_ALT_OP_CONST_WIDE_32: /* 0x17 */ 11887/* File: x86/ALT_STUB.S */ 11888/* 11889 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11890 * any interesting requests and then jump to the real instruction 11891 * handler. Unlike the Arm handler, we can't do this as a tail call 11892 * because rIBASE is caller save and we need to reload it. 11893 */ 11894 movl rSELF, %eax 11895 movl rPC, OUT_ARG0(%esp) 11896 movl %eax, OUT_ARG1(%esp) 11897 call dvmCheckInst # (dPC, self) 11898 movl rSELF, %ecx 11899 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11900 jmp *dvmAsmInstructionStart+(23*4) 11901 11902/* ------------------------------ */ 11903.L_ALT_OP_CONST_WIDE: /* 0x18 */ 11904/* File: x86/ALT_STUB.S */ 11905/* 11906 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11907 * any interesting requests and then jump to the real instruction 11908 * handler. Unlike the Arm handler, we can't do this as a tail call 11909 * because rIBASE is caller save and we need to reload it. 11910 */ 11911 movl rSELF, %eax 11912 movl rPC, OUT_ARG0(%esp) 11913 movl %eax, OUT_ARG1(%esp) 11914 call dvmCheckInst # (dPC, self) 11915 movl rSELF, %ecx 11916 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11917 jmp *dvmAsmInstructionStart+(24*4) 11918 11919/* ------------------------------ */ 11920.L_ALT_OP_CONST_WIDE_HIGH16: /* 0x19 */ 11921/* File: x86/ALT_STUB.S */ 11922/* 11923 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11924 * any interesting requests and then jump to the real instruction 11925 * handler. Unlike the Arm handler, we can't do this as a tail call 11926 * because rIBASE is caller save and we need to reload it. 11927 */ 11928 movl rSELF, %eax 11929 movl rPC, OUT_ARG0(%esp) 11930 movl %eax, OUT_ARG1(%esp) 11931 call dvmCheckInst # (dPC, self) 11932 movl rSELF, %ecx 11933 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11934 jmp *dvmAsmInstructionStart+(25*4) 11935 11936/* ------------------------------ */ 11937.L_ALT_OP_CONST_STRING: /* 0x1a */ 11938/* File: x86/ALT_STUB.S */ 11939/* 11940 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11941 * any interesting requests and then jump to the real instruction 11942 * handler. Unlike the Arm handler, we can't do this as a tail call 11943 * because rIBASE is caller save and we need to reload it. 11944 */ 11945 movl rSELF, %eax 11946 movl rPC, OUT_ARG0(%esp) 11947 movl %eax, OUT_ARG1(%esp) 11948 call dvmCheckInst # (dPC, self) 11949 movl rSELF, %ecx 11950 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11951 jmp *dvmAsmInstructionStart+(26*4) 11952 11953/* ------------------------------ */ 11954.L_ALT_OP_CONST_STRING_JUMBO: /* 0x1b */ 11955/* File: x86/ALT_STUB.S */ 11956/* 11957 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11958 * any interesting requests and then jump to the real instruction 11959 * handler. Unlike the Arm handler, we can't do this as a tail call 11960 * because rIBASE is caller save and we need to reload it. 11961 */ 11962 movl rSELF, %eax 11963 movl rPC, OUT_ARG0(%esp) 11964 movl %eax, OUT_ARG1(%esp) 11965 call dvmCheckInst # (dPC, self) 11966 movl rSELF, %ecx 11967 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11968 jmp *dvmAsmInstructionStart+(27*4) 11969 11970/* ------------------------------ */ 11971.L_ALT_OP_CONST_CLASS: /* 0x1c */ 11972/* File: x86/ALT_STUB.S */ 11973/* 11974 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11975 * any interesting requests and then jump to the real instruction 11976 * handler. Unlike the Arm handler, we can't do this as a tail call 11977 * because rIBASE is caller save and we need to reload it. 11978 */ 11979 movl rSELF, %eax 11980 movl rPC, OUT_ARG0(%esp) 11981 movl %eax, OUT_ARG1(%esp) 11982 call dvmCheckInst # (dPC, self) 11983 movl rSELF, %ecx 11984 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 11985 jmp *dvmAsmInstructionStart+(28*4) 11986 11987/* ------------------------------ */ 11988.L_ALT_OP_MONITOR_ENTER: /* 0x1d */ 11989/* File: x86/ALT_STUB.S */ 11990/* 11991 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 11992 * any interesting requests and then jump to the real instruction 11993 * handler. Unlike the Arm handler, we can't do this as a tail call 11994 * because rIBASE is caller save and we need to reload it. 11995 */ 11996 movl rSELF, %eax 11997 movl rPC, OUT_ARG0(%esp) 11998 movl %eax, OUT_ARG1(%esp) 11999 call dvmCheckInst # (dPC, self) 12000 movl rSELF, %ecx 12001 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12002 jmp *dvmAsmInstructionStart+(29*4) 12003 12004/* ------------------------------ */ 12005.L_ALT_OP_MONITOR_EXIT: /* 0x1e */ 12006/* File: x86/ALT_STUB.S */ 12007/* 12008 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12009 * any interesting requests and then jump to the real instruction 12010 * handler. Unlike the Arm handler, we can't do this as a tail call 12011 * because rIBASE is caller save and we need to reload it. 12012 */ 12013 movl rSELF, %eax 12014 movl rPC, OUT_ARG0(%esp) 12015 movl %eax, OUT_ARG1(%esp) 12016 call dvmCheckInst # (dPC, self) 12017 movl rSELF, %ecx 12018 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12019 jmp *dvmAsmInstructionStart+(30*4) 12020 12021/* ------------------------------ */ 12022.L_ALT_OP_CHECK_CAST: /* 0x1f */ 12023/* File: x86/ALT_STUB.S */ 12024/* 12025 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12026 * any interesting requests and then jump to the real instruction 12027 * handler. Unlike the Arm handler, we can't do this as a tail call 12028 * because rIBASE is caller save and we need to reload it. 12029 */ 12030 movl rSELF, %eax 12031 movl rPC, OUT_ARG0(%esp) 12032 movl %eax, OUT_ARG1(%esp) 12033 call dvmCheckInst # (dPC, self) 12034 movl rSELF, %ecx 12035 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12036 jmp *dvmAsmInstructionStart+(31*4) 12037 12038/* ------------------------------ */ 12039.L_ALT_OP_INSTANCE_OF: /* 0x20 */ 12040/* File: x86/ALT_STUB.S */ 12041/* 12042 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12043 * any interesting requests and then jump to the real instruction 12044 * handler. Unlike the Arm handler, we can't do this as a tail call 12045 * because rIBASE is caller save and we need to reload it. 12046 */ 12047 movl rSELF, %eax 12048 movl rPC, OUT_ARG0(%esp) 12049 movl %eax, OUT_ARG1(%esp) 12050 call dvmCheckInst # (dPC, self) 12051 movl rSELF, %ecx 12052 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12053 jmp *dvmAsmInstructionStart+(32*4) 12054 12055/* ------------------------------ */ 12056.L_ALT_OP_ARRAY_LENGTH: /* 0x21 */ 12057/* File: x86/ALT_STUB.S */ 12058/* 12059 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12060 * any interesting requests and then jump to the real instruction 12061 * handler. Unlike the Arm handler, we can't do this as a tail call 12062 * because rIBASE is caller save and we need to reload it. 12063 */ 12064 movl rSELF, %eax 12065 movl rPC, OUT_ARG0(%esp) 12066 movl %eax, OUT_ARG1(%esp) 12067 call dvmCheckInst # (dPC, self) 12068 movl rSELF, %ecx 12069 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12070 jmp *dvmAsmInstructionStart+(33*4) 12071 12072/* ------------------------------ */ 12073.L_ALT_OP_NEW_INSTANCE: /* 0x22 */ 12074/* File: x86/ALT_STUB.S */ 12075/* 12076 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12077 * any interesting requests and then jump to the real instruction 12078 * handler. Unlike the Arm handler, we can't do this as a tail call 12079 * because rIBASE is caller save and we need to reload it. 12080 */ 12081 movl rSELF, %eax 12082 movl rPC, OUT_ARG0(%esp) 12083 movl %eax, OUT_ARG1(%esp) 12084 call dvmCheckInst # (dPC, self) 12085 movl rSELF, %ecx 12086 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12087 jmp *dvmAsmInstructionStart+(34*4) 12088 12089/* ------------------------------ */ 12090.L_ALT_OP_NEW_ARRAY: /* 0x23 */ 12091/* File: x86/ALT_STUB.S */ 12092/* 12093 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12094 * any interesting requests and then jump to the real instruction 12095 * handler. Unlike the Arm handler, we can't do this as a tail call 12096 * because rIBASE is caller save and we need to reload it. 12097 */ 12098 movl rSELF, %eax 12099 movl rPC, OUT_ARG0(%esp) 12100 movl %eax, OUT_ARG1(%esp) 12101 call dvmCheckInst # (dPC, self) 12102 movl rSELF, %ecx 12103 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12104 jmp *dvmAsmInstructionStart+(35*4) 12105 12106/* ------------------------------ */ 12107.L_ALT_OP_FILLED_NEW_ARRAY: /* 0x24 */ 12108/* File: x86/ALT_STUB.S */ 12109/* 12110 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12111 * any interesting requests and then jump to the real instruction 12112 * handler. Unlike the Arm handler, we can't do this as a tail call 12113 * because rIBASE is caller save and we need to reload it. 12114 */ 12115 movl rSELF, %eax 12116 movl rPC, OUT_ARG0(%esp) 12117 movl %eax, OUT_ARG1(%esp) 12118 call dvmCheckInst # (dPC, self) 12119 movl rSELF, %ecx 12120 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12121 jmp *dvmAsmInstructionStart+(36*4) 12122 12123/* ------------------------------ */ 12124.L_ALT_OP_FILLED_NEW_ARRAY_RANGE: /* 0x25 */ 12125/* File: x86/ALT_STUB.S */ 12126/* 12127 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12128 * any interesting requests and then jump to the real instruction 12129 * handler. Unlike the Arm handler, we can't do this as a tail call 12130 * because rIBASE is caller save and we need to reload it. 12131 */ 12132 movl rSELF, %eax 12133 movl rPC, OUT_ARG0(%esp) 12134 movl %eax, OUT_ARG1(%esp) 12135 call dvmCheckInst # (dPC, self) 12136 movl rSELF, %ecx 12137 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12138 jmp *dvmAsmInstructionStart+(37*4) 12139 12140/* ------------------------------ */ 12141.L_ALT_OP_FILL_ARRAY_DATA: /* 0x26 */ 12142/* File: x86/ALT_STUB.S */ 12143/* 12144 * Inter-instruction transfer stub. Call out to dvmCheckInst 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 movl rSELF, %eax 12150 movl rPC, OUT_ARG0(%esp) 12151 movl %eax, OUT_ARG1(%esp) 12152 call dvmCheckInst # (dPC, self) 12153 movl rSELF, %ecx 12154 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12155 jmp *dvmAsmInstructionStart+(38*4) 12156 12157/* ------------------------------ */ 12158.L_ALT_OP_THROW: /* 0x27 */ 12159/* File: x86/ALT_STUB.S */ 12160/* 12161 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12162 * any interesting requests and then jump to the real instruction 12163 * handler. Unlike the Arm handler, we can't do this as a tail call 12164 * because rIBASE is caller save and we need to reload it. 12165 */ 12166 movl rSELF, %eax 12167 movl rPC, OUT_ARG0(%esp) 12168 movl %eax, OUT_ARG1(%esp) 12169 call dvmCheckInst # (dPC, self) 12170 movl rSELF, %ecx 12171 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12172 jmp *dvmAsmInstructionStart+(39*4) 12173 12174/* ------------------------------ */ 12175.L_ALT_OP_GOTO: /* 0x28 */ 12176/* File: x86/ALT_STUB.S */ 12177/* 12178 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12179 * any interesting requests and then jump to the real instruction 12180 * handler. Unlike the Arm handler, we can't do this as a tail call 12181 * because rIBASE is caller save and we need to reload it. 12182 */ 12183 movl rSELF, %eax 12184 movl rPC, OUT_ARG0(%esp) 12185 movl %eax, OUT_ARG1(%esp) 12186 call dvmCheckInst # (dPC, self) 12187 movl rSELF, %ecx 12188 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12189 jmp *dvmAsmInstructionStart+(40*4) 12190 12191/* ------------------------------ */ 12192.L_ALT_OP_GOTO_16: /* 0x29 */ 12193/* File: x86/ALT_STUB.S */ 12194/* 12195 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12196 * any interesting requests and then jump to the real instruction 12197 * handler. Unlike the Arm handler, we can't do this as a tail call 12198 * because rIBASE is caller save and we need to reload it. 12199 */ 12200 movl rSELF, %eax 12201 movl rPC, OUT_ARG0(%esp) 12202 movl %eax, OUT_ARG1(%esp) 12203 call dvmCheckInst # (dPC, self) 12204 movl rSELF, %ecx 12205 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12206 jmp *dvmAsmInstructionStart+(41*4) 12207 12208/* ------------------------------ */ 12209.L_ALT_OP_GOTO_32: /* 0x2a */ 12210/* File: x86/ALT_STUB.S */ 12211/* 12212 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12213 * any interesting requests and then jump to the real instruction 12214 * handler. Unlike the Arm handler, we can't do this as a tail call 12215 * because rIBASE is caller save and we need to reload it. 12216 */ 12217 movl rSELF, %eax 12218 movl rPC, OUT_ARG0(%esp) 12219 movl %eax, OUT_ARG1(%esp) 12220 call dvmCheckInst # (dPC, self) 12221 movl rSELF, %ecx 12222 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12223 jmp *dvmAsmInstructionStart+(42*4) 12224 12225/* ------------------------------ */ 12226.L_ALT_OP_PACKED_SWITCH: /* 0x2b */ 12227/* File: x86/ALT_STUB.S */ 12228/* 12229 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12230 * any interesting requests and then jump to the real instruction 12231 * handler. Unlike the Arm handler, we can't do this as a tail call 12232 * because rIBASE is caller save and we need to reload it. 12233 */ 12234 movl rSELF, %eax 12235 movl rPC, OUT_ARG0(%esp) 12236 movl %eax, OUT_ARG1(%esp) 12237 call dvmCheckInst # (dPC, self) 12238 movl rSELF, %ecx 12239 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12240 jmp *dvmAsmInstructionStart+(43*4) 12241 12242/* ------------------------------ */ 12243.L_ALT_OP_SPARSE_SWITCH: /* 0x2c */ 12244/* File: x86/ALT_STUB.S */ 12245/* 12246 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12247 * any interesting requests and then jump to the real instruction 12248 * handler. Unlike the Arm handler, we can't do this as a tail call 12249 * because rIBASE is caller save and we need to reload it. 12250 */ 12251 movl rSELF, %eax 12252 movl rPC, OUT_ARG0(%esp) 12253 movl %eax, OUT_ARG1(%esp) 12254 call dvmCheckInst # (dPC, self) 12255 movl rSELF, %ecx 12256 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12257 jmp *dvmAsmInstructionStart+(44*4) 12258 12259/* ------------------------------ */ 12260.L_ALT_OP_CMPL_FLOAT: /* 0x2d */ 12261/* File: x86/ALT_STUB.S */ 12262/* 12263 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12264 * any interesting requests and then jump to the real instruction 12265 * handler. Unlike the Arm handler, we can't do this as a tail call 12266 * because rIBASE is caller save and we need to reload it. 12267 */ 12268 movl rSELF, %eax 12269 movl rPC, OUT_ARG0(%esp) 12270 movl %eax, OUT_ARG1(%esp) 12271 call dvmCheckInst # (dPC, self) 12272 movl rSELF, %ecx 12273 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12274 jmp *dvmAsmInstructionStart+(45*4) 12275 12276/* ------------------------------ */ 12277.L_ALT_OP_CMPG_FLOAT: /* 0x2e */ 12278/* File: x86/ALT_STUB.S */ 12279/* 12280 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12281 * any interesting requests and then jump to the real instruction 12282 * handler. Unlike the Arm handler, we can't do this as a tail call 12283 * because rIBASE is caller save and we need to reload it. 12284 */ 12285 movl rSELF, %eax 12286 movl rPC, OUT_ARG0(%esp) 12287 movl %eax, OUT_ARG1(%esp) 12288 call dvmCheckInst # (dPC, self) 12289 movl rSELF, %ecx 12290 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12291 jmp *dvmAsmInstructionStart+(46*4) 12292 12293/* ------------------------------ */ 12294.L_ALT_OP_CMPL_DOUBLE: /* 0x2f */ 12295/* File: x86/ALT_STUB.S */ 12296/* 12297 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12298 * any interesting requests and then jump to the real instruction 12299 * handler. Unlike the Arm handler, we can't do this as a tail call 12300 * because rIBASE is caller save and we need to reload it. 12301 */ 12302 movl rSELF, %eax 12303 movl rPC, OUT_ARG0(%esp) 12304 movl %eax, OUT_ARG1(%esp) 12305 call dvmCheckInst # (dPC, self) 12306 movl rSELF, %ecx 12307 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12308 jmp *dvmAsmInstructionStart+(47*4) 12309 12310/* ------------------------------ */ 12311.L_ALT_OP_CMPG_DOUBLE: /* 0x30 */ 12312/* File: x86/ALT_STUB.S */ 12313/* 12314 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12315 * any interesting requests and then jump to the real instruction 12316 * handler. Unlike the Arm handler, we can't do this as a tail call 12317 * because rIBASE is caller save and we need to reload it. 12318 */ 12319 movl rSELF, %eax 12320 movl rPC, OUT_ARG0(%esp) 12321 movl %eax, OUT_ARG1(%esp) 12322 call dvmCheckInst # (dPC, self) 12323 movl rSELF, %ecx 12324 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12325 jmp *dvmAsmInstructionStart+(48*4) 12326 12327/* ------------------------------ */ 12328.L_ALT_OP_CMP_LONG: /* 0x31 */ 12329/* File: x86/ALT_STUB.S */ 12330/* 12331 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12332 * any interesting requests and then jump to the real instruction 12333 * handler. Unlike the Arm handler, we can't do this as a tail call 12334 * because rIBASE is caller save and we need to reload it. 12335 */ 12336 movl rSELF, %eax 12337 movl rPC, OUT_ARG0(%esp) 12338 movl %eax, OUT_ARG1(%esp) 12339 call dvmCheckInst # (dPC, self) 12340 movl rSELF, %ecx 12341 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12342 jmp *dvmAsmInstructionStart+(49*4) 12343 12344/* ------------------------------ */ 12345.L_ALT_OP_IF_EQ: /* 0x32 */ 12346/* File: x86/ALT_STUB.S */ 12347/* 12348 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12349 * any interesting requests and then jump to the real instruction 12350 * handler. Unlike the Arm handler, we can't do this as a tail call 12351 * because rIBASE is caller save and we need to reload it. 12352 */ 12353 movl rSELF, %eax 12354 movl rPC, OUT_ARG0(%esp) 12355 movl %eax, OUT_ARG1(%esp) 12356 call dvmCheckInst # (dPC, self) 12357 movl rSELF, %ecx 12358 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12359 jmp *dvmAsmInstructionStart+(50*4) 12360 12361/* ------------------------------ */ 12362.L_ALT_OP_IF_NE: /* 0x33 */ 12363/* File: x86/ALT_STUB.S */ 12364/* 12365 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12366 * any interesting requests and then jump to the real instruction 12367 * handler. Unlike the Arm handler, we can't do this as a tail call 12368 * because rIBASE is caller save and we need to reload it. 12369 */ 12370 movl rSELF, %eax 12371 movl rPC, OUT_ARG0(%esp) 12372 movl %eax, OUT_ARG1(%esp) 12373 call dvmCheckInst # (dPC, self) 12374 movl rSELF, %ecx 12375 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12376 jmp *dvmAsmInstructionStart+(51*4) 12377 12378/* ------------------------------ */ 12379.L_ALT_OP_IF_LT: /* 0x34 */ 12380/* File: x86/ALT_STUB.S */ 12381/* 12382 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12383 * any interesting requests and then jump to the real instruction 12384 * handler. Unlike the Arm handler, we can't do this as a tail call 12385 * because rIBASE is caller save and we need to reload it. 12386 */ 12387 movl rSELF, %eax 12388 movl rPC, OUT_ARG0(%esp) 12389 movl %eax, OUT_ARG1(%esp) 12390 call dvmCheckInst # (dPC, self) 12391 movl rSELF, %ecx 12392 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12393 jmp *dvmAsmInstructionStart+(52*4) 12394 12395/* ------------------------------ */ 12396.L_ALT_OP_IF_GE: /* 0x35 */ 12397/* File: x86/ALT_STUB.S */ 12398/* 12399 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12400 * any interesting requests and then jump to the real instruction 12401 * handler. Unlike the Arm handler, we can't do this as a tail call 12402 * because rIBASE is caller save and we need to reload it. 12403 */ 12404 movl rSELF, %eax 12405 movl rPC, OUT_ARG0(%esp) 12406 movl %eax, OUT_ARG1(%esp) 12407 call dvmCheckInst # (dPC, self) 12408 movl rSELF, %ecx 12409 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12410 jmp *dvmAsmInstructionStart+(53*4) 12411 12412/* ------------------------------ */ 12413.L_ALT_OP_IF_GT: /* 0x36 */ 12414/* File: x86/ALT_STUB.S */ 12415/* 12416 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12417 * any interesting requests and then jump to the real instruction 12418 * handler. Unlike the Arm handler, we can't do this as a tail call 12419 * because rIBASE is caller save and we need to reload it. 12420 */ 12421 movl rSELF, %eax 12422 movl rPC, OUT_ARG0(%esp) 12423 movl %eax, OUT_ARG1(%esp) 12424 call dvmCheckInst # (dPC, self) 12425 movl rSELF, %ecx 12426 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12427 jmp *dvmAsmInstructionStart+(54*4) 12428 12429/* ------------------------------ */ 12430.L_ALT_OP_IF_LE: /* 0x37 */ 12431/* File: x86/ALT_STUB.S */ 12432/* 12433 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12434 * any interesting requests and then jump to the real instruction 12435 * handler. Unlike the Arm handler, we can't do this as a tail call 12436 * because rIBASE is caller save and we need to reload it. 12437 */ 12438 movl rSELF, %eax 12439 movl rPC, OUT_ARG0(%esp) 12440 movl %eax, OUT_ARG1(%esp) 12441 call dvmCheckInst # (dPC, self) 12442 movl rSELF, %ecx 12443 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12444 jmp *dvmAsmInstructionStart+(55*4) 12445 12446/* ------------------------------ */ 12447.L_ALT_OP_IF_EQZ: /* 0x38 */ 12448/* File: x86/ALT_STUB.S */ 12449/* 12450 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12451 * any interesting requests and then jump to the real instruction 12452 * handler. Unlike the Arm handler, we can't do this as a tail call 12453 * because rIBASE is caller save and we need to reload it. 12454 */ 12455 movl rSELF, %eax 12456 movl rPC, OUT_ARG0(%esp) 12457 movl %eax, OUT_ARG1(%esp) 12458 call dvmCheckInst # (dPC, self) 12459 movl rSELF, %ecx 12460 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12461 jmp *dvmAsmInstructionStart+(56*4) 12462 12463/* ------------------------------ */ 12464.L_ALT_OP_IF_NEZ: /* 0x39 */ 12465/* File: x86/ALT_STUB.S */ 12466/* 12467 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12468 * any interesting requests and then jump to the real instruction 12469 * handler. Unlike the Arm handler, we can't do this as a tail call 12470 * because rIBASE is caller save and we need to reload it. 12471 */ 12472 movl rSELF, %eax 12473 movl rPC, OUT_ARG0(%esp) 12474 movl %eax, OUT_ARG1(%esp) 12475 call dvmCheckInst # (dPC, self) 12476 movl rSELF, %ecx 12477 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12478 jmp *dvmAsmInstructionStart+(57*4) 12479 12480/* ------------------------------ */ 12481.L_ALT_OP_IF_LTZ: /* 0x3a */ 12482/* File: x86/ALT_STUB.S */ 12483/* 12484 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12485 * any interesting requests and then jump to the real instruction 12486 * handler. Unlike the Arm handler, we can't do this as a tail call 12487 * because rIBASE is caller save and we need to reload it. 12488 */ 12489 movl rSELF, %eax 12490 movl rPC, OUT_ARG0(%esp) 12491 movl %eax, OUT_ARG1(%esp) 12492 call dvmCheckInst # (dPC, self) 12493 movl rSELF, %ecx 12494 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12495 jmp *dvmAsmInstructionStart+(58*4) 12496 12497/* ------------------------------ */ 12498.L_ALT_OP_IF_GEZ: /* 0x3b */ 12499/* File: x86/ALT_STUB.S */ 12500/* 12501 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12502 * any interesting requests and then jump to the real instruction 12503 * handler. Unlike the Arm handler, we can't do this as a tail call 12504 * because rIBASE is caller save and we need to reload it. 12505 */ 12506 movl rSELF, %eax 12507 movl rPC, OUT_ARG0(%esp) 12508 movl %eax, OUT_ARG1(%esp) 12509 call dvmCheckInst # (dPC, self) 12510 movl rSELF, %ecx 12511 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12512 jmp *dvmAsmInstructionStart+(59*4) 12513 12514/* ------------------------------ */ 12515.L_ALT_OP_IF_GTZ: /* 0x3c */ 12516/* File: x86/ALT_STUB.S */ 12517/* 12518 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12519 * any interesting requests and then jump to the real instruction 12520 * handler. Unlike the Arm handler, we can't do this as a tail call 12521 * because rIBASE is caller save and we need to reload it. 12522 */ 12523 movl rSELF, %eax 12524 movl rPC, OUT_ARG0(%esp) 12525 movl %eax, OUT_ARG1(%esp) 12526 call dvmCheckInst # (dPC, self) 12527 movl rSELF, %ecx 12528 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12529 jmp *dvmAsmInstructionStart+(60*4) 12530 12531/* ------------------------------ */ 12532.L_ALT_OP_IF_LEZ: /* 0x3d */ 12533/* File: x86/ALT_STUB.S */ 12534/* 12535 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12536 * any interesting requests and then jump to the real instruction 12537 * handler. Unlike the Arm handler, we can't do this as a tail call 12538 * because rIBASE is caller save and we need to reload it. 12539 */ 12540 movl rSELF, %eax 12541 movl rPC, OUT_ARG0(%esp) 12542 movl %eax, OUT_ARG1(%esp) 12543 call dvmCheckInst # (dPC, self) 12544 movl rSELF, %ecx 12545 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12546 jmp *dvmAsmInstructionStart+(61*4) 12547 12548/* ------------------------------ */ 12549.L_ALT_OP_UNUSED_3E: /* 0x3e */ 12550/* File: x86/ALT_STUB.S */ 12551/* 12552 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12553 * any interesting requests and then jump to the real instruction 12554 * handler. Unlike the Arm handler, we can't do this as a tail call 12555 * because rIBASE is caller save and we need to reload it. 12556 */ 12557 movl rSELF, %eax 12558 movl rPC, OUT_ARG0(%esp) 12559 movl %eax, OUT_ARG1(%esp) 12560 call dvmCheckInst # (dPC, self) 12561 movl rSELF, %ecx 12562 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12563 jmp *dvmAsmInstructionStart+(62*4) 12564 12565/* ------------------------------ */ 12566.L_ALT_OP_UNUSED_3F: /* 0x3f */ 12567/* File: x86/ALT_STUB.S */ 12568/* 12569 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12570 * any interesting requests and then jump to the real instruction 12571 * handler. Unlike the Arm handler, we can't do this as a tail call 12572 * because rIBASE is caller save and we need to reload it. 12573 */ 12574 movl rSELF, %eax 12575 movl rPC, OUT_ARG0(%esp) 12576 movl %eax, OUT_ARG1(%esp) 12577 call dvmCheckInst # (dPC, self) 12578 movl rSELF, %ecx 12579 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12580 jmp *dvmAsmInstructionStart+(63*4) 12581 12582/* ------------------------------ */ 12583.L_ALT_OP_UNUSED_40: /* 0x40 */ 12584/* File: x86/ALT_STUB.S */ 12585/* 12586 * Inter-instruction transfer stub. Call out to dvmCheckInst 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 movl rSELF, %eax 12592 movl rPC, OUT_ARG0(%esp) 12593 movl %eax, OUT_ARG1(%esp) 12594 call dvmCheckInst # (dPC, self) 12595 movl rSELF, %ecx 12596 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12597 jmp *dvmAsmInstructionStart+(64*4) 12598 12599/* ------------------------------ */ 12600.L_ALT_OP_UNUSED_41: /* 0x41 */ 12601/* File: x86/ALT_STUB.S */ 12602/* 12603 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12604 * any interesting requests and then jump to the real instruction 12605 * handler. Unlike the Arm handler, we can't do this as a tail call 12606 * because rIBASE is caller save and we need to reload it. 12607 */ 12608 movl rSELF, %eax 12609 movl rPC, OUT_ARG0(%esp) 12610 movl %eax, OUT_ARG1(%esp) 12611 call dvmCheckInst # (dPC, self) 12612 movl rSELF, %ecx 12613 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12614 jmp *dvmAsmInstructionStart+(65*4) 12615 12616/* ------------------------------ */ 12617.L_ALT_OP_UNUSED_42: /* 0x42 */ 12618/* File: x86/ALT_STUB.S */ 12619/* 12620 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12621 * any interesting requests and then jump to the real instruction 12622 * handler. Unlike the Arm handler, we can't do this as a tail call 12623 * because rIBASE is caller save and we need to reload it. 12624 */ 12625 movl rSELF, %eax 12626 movl rPC, OUT_ARG0(%esp) 12627 movl %eax, OUT_ARG1(%esp) 12628 call dvmCheckInst # (dPC, self) 12629 movl rSELF, %ecx 12630 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12631 jmp *dvmAsmInstructionStart+(66*4) 12632 12633/* ------------------------------ */ 12634.L_ALT_OP_UNUSED_43: /* 0x43 */ 12635/* File: x86/ALT_STUB.S */ 12636/* 12637 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12638 * any interesting requests and then jump to the real instruction 12639 * handler. Unlike the Arm handler, we can't do this as a tail call 12640 * because rIBASE is caller save and we need to reload it. 12641 */ 12642 movl rSELF, %eax 12643 movl rPC, OUT_ARG0(%esp) 12644 movl %eax, OUT_ARG1(%esp) 12645 call dvmCheckInst # (dPC, self) 12646 movl rSELF, %ecx 12647 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12648 jmp *dvmAsmInstructionStart+(67*4) 12649 12650/* ------------------------------ */ 12651.L_ALT_OP_AGET: /* 0x44 */ 12652/* File: x86/ALT_STUB.S */ 12653/* 12654 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12655 * any interesting requests and then jump to the real instruction 12656 * handler. Unlike the Arm handler, we can't do this as a tail call 12657 * because rIBASE is caller save and we need to reload it. 12658 */ 12659 movl rSELF, %eax 12660 movl rPC, OUT_ARG0(%esp) 12661 movl %eax, OUT_ARG1(%esp) 12662 call dvmCheckInst # (dPC, self) 12663 movl rSELF, %ecx 12664 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12665 jmp *dvmAsmInstructionStart+(68*4) 12666 12667/* ------------------------------ */ 12668.L_ALT_OP_AGET_WIDE: /* 0x45 */ 12669/* File: x86/ALT_STUB.S */ 12670/* 12671 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12672 * any interesting requests and then jump to the real instruction 12673 * handler. Unlike the Arm handler, we can't do this as a tail call 12674 * because rIBASE is caller save and we need to reload it. 12675 */ 12676 movl rSELF, %eax 12677 movl rPC, OUT_ARG0(%esp) 12678 movl %eax, OUT_ARG1(%esp) 12679 call dvmCheckInst # (dPC, self) 12680 movl rSELF, %ecx 12681 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12682 jmp *dvmAsmInstructionStart+(69*4) 12683 12684/* ------------------------------ */ 12685.L_ALT_OP_AGET_OBJECT: /* 0x46 */ 12686/* File: x86/ALT_STUB.S */ 12687/* 12688 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12689 * any interesting requests and then jump to the real instruction 12690 * handler. Unlike the Arm handler, we can't do this as a tail call 12691 * because rIBASE is caller save and we need to reload it. 12692 */ 12693 movl rSELF, %eax 12694 movl rPC, OUT_ARG0(%esp) 12695 movl %eax, OUT_ARG1(%esp) 12696 call dvmCheckInst # (dPC, self) 12697 movl rSELF, %ecx 12698 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12699 jmp *dvmAsmInstructionStart+(70*4) 12700 12701/* ------------------------------ */ 12702.L_ALT_OP_AGET_BOOLEAN: /* 0x47 */ 12703/* File: x86/ALT_STUB.S */ 12704/* 12705 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12706 * any interesting requests and then jump to the real instruction 12707 * handler. Unlike the Arm handler, we can't do this as a tail call 12708 * because rIBASE is caller save and we need to reload it. 12709 */ 12710 movl rSELF, %eax 12711 movl rPC, OUT_ARG0(%esp) 12712 movl %eax, OUT_ARG1(%esp) 12713 call dvmCheckInst # (dPC, self) 12714 movl rSELF, %ecx 12715 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12716 jmp *dvmAsmInstructionStart+(71*4) 12717 12718/* ------------------------------ */ 12719.L_ALT_OP_AGET_BYTE: /* 0x48 */ 12720/* File: x86/ALT_STUB.S */ 12721/* 12722 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12723 * any interesting requests and then jump to the real instruction 12724 * handler. Unlike the Arm handler, we can't do this as a tail call 12725 * because rIBASE is caller save and we need to reload it. 12726 */ 12727 movl rSELF, %eax 12728 movl rPC, OUT_ARG0(%esp) 12729 movl %eax, OUT_ARG1(%esp) 12730 call dvmCheckInst # (dPC, self) 12731 movl rSELF, %ecx 12732 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12733 jmp *dvmAsmInstructionStart+(72*4) 12734 12735/* ------------------------------ */ 12736.L_ALT_OP_AGET_CHAR: /* 0x49 */ 12737/* File: x86/ALT_STUB.S */ 12738/* 12739 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12740 * any interesting requests and then jump to the real instruction 12741 * handler. Unlike the Arm handler, we can't do this as a tail call 12742 * because rIBASE is caller save and we need to reload it. 12743 */ 12744 movl rSELF, %eax 12745 movl rPC, OUT_ARG0(%esp) 12746 movl %eax, OUT_ARG1(%esp) 12747 call dvmCheckInst # (dPC, self) 12748 movl rSELF, %ecx 12749 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12750 jmp *dvmAsmInstructionStart+(73*4) 12751 12752/* ------------------------------ */ 12753.L_ALT_OP_AGET_SHORT: /* 0x4a */ 12754/* File: x86/ALT_STUB.S */ 12755/* 12756 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12757 * any interesting requests and then jump to the real instruction 12758 * handler. Unlike the Arm handler, we can't do this as a tail call 12759 * because rIBASE is caller save and we need to reload it. 12760 */ 12761 movl rSELF, %eax 12762 movl rPC, OUT_ARG0(%esp) 12763 movl %eax, OUT_ARG1(%esp) 12764 call dvmCheckInst # (dPC, self) 12765 movl rSELF, %ecx 12766 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12767 jmp *dvmAsmInstructionStart+(74*4) 12768 12769/* ------------------------------ */ 12770.L_ALT_OP_APUT: /* 0x4b */ 12771/* File: x86/ALT_STUB.S */ 12772/* 12773 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12774 * any interesting requests and then jump to the real instruction 12775 * handler. Unlike the Arm handler, we can't do this as a tail call 12776 * because rIBASE is caller save and we need to reload it. 12777 */ 12778 movl rSELF, %eax 12779 movl rPC, OUT_ARG0(%esp) 12780 movl %eax, OUT_ARG1(%esp) 12781 call dvmCheckInst # (dPC, self) 12782 movl rSELF, %ecx 12783 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12784 jmp *dvmAsmInstructionStart+(75*4) 12785 12786/* ------------------------------ */ 12787.L_ALT_OP_APUT_WIDE: /* 0x4c */ 12788/* File: x86/ALT_STUB.S */ 12789/* 12790 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12791 * any interesting requests and then jump to the real instruction 12792 * handler. Unlike the Arm handler, we can't do this as a tail call 12793 * because rIBASE is caller save and we need to reload it. 12794 */ 12795 movl rSELF, %eax 12796 movl rPC, OUT_ARG0(%esp) 12797 movl %eax, OUT_ARG1(%esp) 12798 call dvmCheckInst # (dPC, self) 12799 movl rSELF, %ecx 12800 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12801 jmp *dvmAsmInstructionStart+(76*4) 12802 12803/* ------------------------------ */ 12804.L_ALT_OP_APUT_OBJECT: /* 0x4d */ 12805/* File: x86/ALT_STUB.S */ 12806/* 12807 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12808 * any interesting requests and then jump to the real instruction 12809 * handler. Unlike the Arm handler, we can't do this as a tail call 12810 * because rIBASE is caller save and we need to reload it. 12811 */ 12812 movl rSELF, %eax 12813 movl rPC, OUT_ARG0(%esp) 12814 movl %eax, OUT_ARG1(%esp) 12815 call dvmCheckInst # (dPC, self) 12816 movl rSELF, %ecx 12817 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12818 jmp *dvmAsmInstructionStart+(77*4) 12819 12820/* ------------------------------ */ 12821.L_ALT_OP_APUT_BOOLEAN: /* 0x4e */ 12822/* File: x86/ALT_STUB.S */ 12823/* 12824 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12825 * any interesting requests and then jump to the real instruction 12826 * handler. Unlike the Arm handler, we can't do this as a tail call 12827 * because rIBASE is caller save and we need to reload it. 12828 */ 12829 movl rSELF, %eax 12830 movl rPC, OUT_ARG0(%esp) 12831 movl %eax, OUT_ARG1(%esp) 12832 call dvmCheckInst # (dPC, self) 12833 movl rSELF, %ecx 12834 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12835 jmp *dvmAsmInstructionStart+(78*4) 12836 12837/* ------------------------------ */ 12838.L_ALT_OP_APUT_BYTE: /* 0x4f */ 12839/* File: x86/ALT_STUB.S */ 12840/* 12841 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12842 * any interesting requests and then jump to the real instruction 12843 * handler. Unlike the Arm handler, we can't do this as a tail call 12844 * because rIBASE is caller save and we need to reload it. 12845 */ 12846 movl rSELF, %eax 12847 movl rPC, OUT_ARG0(%esp) 12848 movl %eax, OUT_ARG1(%esp) 12849 call dvmCheckInst # (dPC, self) 12850 movl rSELF, %ecx 12851 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12852 jmp *dvmAsmInstructionStart+(79*4) 12853 12854/* ------------------------------ */ 12855.L_ALT_OP_APUT_CHAR: /* 0x50 */ 12856/* File: x86/ALT_STUB.S */ 12857/* 12858 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12859 * any interesting requests and then jump to the real instruction 12860 * handler. Unlike the Arm handler, we can't do this as a tail call 12861 * because rIBASE is caller save and we need to reload it. 12862 */ 12863 movl rSELF, %eax 12864 movl rPC, OUT_ARG0(%esp) 12865 movl %eax, OUT_ARG1(%esp) 12866 call dvmCheckInst # (dPC, self) 12867 movl rSELF, %ecx 12868 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12869 jmp *dvmAsmInstructionStart+(80*4) 12870 12871/* ------------------------------ */ 12872.L_ALT_OP_APUT_SHORT: /* 0x51 */ 12873/* File: x86/ALT_STUB.S */ 12874/* 12875 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12876 * any interesting requests and then jump to the real instruction 12877 * handler. Unlike the Arm handler, we can't do this as a tail call 12878 * because rIBASE is caller save and we need to reload it. 12879 */ 12880 movl rSELF, %eax 12881 movl rPC, OUT_ARG0(%esp) 12882 movl %eax, OUT_ARG1(%esp) 12883 call dvmCheckInst # (dPC, self) 12884 movl rSELF, %ecx 12885 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12886 jmp *dvmAsmInstructionStart+(81*4) 12887 12888/* ------------------------------ */ 12889.L_ALT_OP_IGET: /* 0x52 */ 12890/* File: x86/ALT_STUB.S */ 12891/* 12892 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12893 * any interesting requests and then jump to the real instruction 12894 * handler. Unlike the Arm handler, we can't do this as a tail call 12895 * because rIBASE is caller save and we need to reload it. 12896 */ 12897 movl rSELF, %eax 12898 movl rPC, OUT_ARG0(%esp) 12899 movl %eax, OUT_ARG1(%esp) 12900 call dvmCheckInst # (dPC, self) 12901 movl rSELF, %ecx 12902 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12903 jmp *dvmAsmInstructionStart+(82*4) 12904 12905/* ------------------------------ */ 12906.L_ALT_OP_IGET_WIDE: /* 0x53 */ 12907/* File: x86/ALT_STUB.S */ 12908/* 12909 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12910 * any interesting requests and then jump to the real instruction 12911 * handler. Unlike the Arm handler, we can't do this as a tail call 12912 * because rIBASE is caller save and we need to reload it. 12913 */ 12914 movl rSELF, %eax 12915 movl rPC, OUT_ARG0(%esp) 12916 movl %eax, OUT_ARG1(%esp) 12917 call dvmCheckInst # (dPC, self) 12918 movl rSELF, %ecx 12919 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12920 jmp *dvmAsmInstructionStart+(83*4) 12921 12922/* ------------------------------ */ 12923.L_ALT_OP_IGET_OBJECT: /* 0x54 */ 12924/* File: x86/ALT_STUB.S */ 12925/* 12926 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12927 * any interesting requests and then jump to the real instruction 12928 * handler. Unlike the Arm handler, we can't do this as a tail call 12929 * because rIBASE is caller save and we need to reload it. 12930 */ 12931 movl rSELF, %eax 12932 movl rPC, OUT_ARG0(%esp) 12933 movl %eax, OUT_ARG1(%esp) 12934 call dvmCheckInst # (dPC, self) 12935 movl rSELF, %ecx 12936 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12937 jmp *dvmAsmInstructionStart+(84*4) 12938 12939/* ------------------------------ */ 12940.L_ALT_OP_IGET_BOOLEAN: /* 0x55 */ 12941/* File: x86/ALT_STUB.S */ 12942/* 12943 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12944 * any interesting requests and then jump to the real instruction 12945 * handler. Unlike the Arm handler, we can't do this as a tail call 12946 * because rIBASE is caller save and we need to reload it. 12947 */ 12948 movl rSELF, %eax 12949 movl rPC, OUT_ARG0(%esp) 12950 movl %eax, OUT_ARG1(%esp) 12951 call dvmCheckInst # (dPC, self) 12952 movl rSELF, %ecx 12953 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12954 jmp *dvmAsmInstructionStart+(85*4) 12955 12956/* ------------------------------ */ 12957.L_ALT_OP_IGET_BYTE: /* 0x56 */ 12958/* File: x86/ALT_STUB.S */ 12959/* 12960 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12961 * any interesting requests and then jump to the real instruction 12962 * handler. Unlike the Arm handler, we can't do this as a tail call 12963 * because rIBASE is caller save and we need to reload it. 12964 */ 12965 movl rSELF, %eax 12966 movl rPC, OUT_ARG0(%esp) 12967 movl %eax, OUT_ARG1(%esp) 12968 call dvmCheckInst # (dPC, self) 12969 movl rSELF, %ecx 12970 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12971 jmp *dvmAsmInstructionStart+(86*4) 12972 12973/* ------------------------------ */ 12974.L_ALT_OP_IGET_CHAR: /* 0x57 */ 12975/* File: x86/ALT_STUB.S */ 12976/* 12977 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12978 * any interesting requests and then jump to the real instruction 12979 * handler. Unlike the Arm handler, we can't do this as a tail call 12980 * because rIBASE is caller save and we need to reload it. 12981 */ 12982 movl rSELF, %eax 12983 movl rPC, OUT_ARG0(%esp) 12984 movl %eax, OUT_ARG1(%esp) 12985 call dvmCheckInst # (dPC, self) 12986 movl rSELF, %ecx 12987 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 12988 jmp *dvmAsmInstructionStart+(87*4) 12989 12990/* ------------------------------ */ 12991.L_ALT_OP_IGET_SHORT: /* 0x58 */ 12992/* File: x86/ALT_STUB.S */ 12993/* 12994 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 12995 * any interesting requests and then jump to the real instruction 12996 * handler. Unlike the Arm handler, we can't do this as a tail call 12997 * because rIBASE is caller save and we need to reload it. 12998 */ 12999 movl rSELF, %eax 13000 movl rPC, OUT_ARG0(%esp) 13001 movl %eax, OUT_ARG1(%esp) 13002 call dvmCheckInst # (dPC, self) 13003 movl rSELF, %ecx 13004 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13005 jmp *dvmAsmInstructionStart+(88*4) 13006 13007/* ------------------------------ */ 13008.L_ALT_OP_IPUT: /* 0x59 */ 13009/* File: x86/ALT_STUB.S */ 13010/* 13011 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13012 * any interesting requests and then jump to the real instruction 13013 * handler. Unlike the Arm handler, we can't do this as a tail call 13014 * because rIBASE is caller save and we need to reload it. 13015 */ 13016 movl rSELF, %eax 13017 movl rPC, OUT_ARG0(%esp) 13018 movl %eax, OUT_ARG1(%esp) 13019 call dvmCheckInst # (dPC, self) 13020 movl rSELF, %ecx 13021 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13022 jmp *dvmAsmInstructionStart+(89*4) 13023 13024/* ------------------------------ */ 13025.L_ALT_OP_IPUT_WIDE: /* 0x5a */ 13026/* File: x86/ALT_STUB.S */ 13027/* 13028 * Inter-instruction transfer stub. Call out to dvmCheckInst 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 movl rSELF, %eax 13034 movl rPC, OUT_ARG0(%esp) 13035 movl %eax, OUT_ARG1(%esp) 13036 call dvmCheckInst # (dPC, self) 13037 movl rSELF, %ecx 13038 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13039 jmp *dvmAsmInstructionStart+(90*4) 13040 13041/* ------------------------------ */ 13042.L_ALT_OP_IPUT_OBJECT: /* 0x5b */ 13043/* File: x86/ALT_STUB.S */ 13044/* 13045 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13046 * any interesting requests and then jump to the real instruction 13047 * handler. Unlike the Arm handler, we can't do this as a tail call 13048 * because rIBASE is caller save and we need to reload it. 13049 */ 13050 movl rSELF, %eax 13051 movl rPC, OUT_ARG0(%esp) 13052 movl %eax, OUT_ARG1(%esp) 13053 call dvmCheckInst # (dPC, self) 13054 movl rSELF, %ecx 13055 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13056 jmp *dvmAsmInstructionStart+(91*4) 13057 13058/* ------------------------------ */ 13059.L_ALT_OP_IPUT_BOOLEAN: /* 0x5c */ 13060/* File: x86/ALT_STUB.S */ 13061/* 13062 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13063 * any interesting requests and then jump to the real instruction 13064 * handler. Unlike the Arm handler, we can't do this as a tail call 13065 * because rIBASE is caller save and we need to reload it. 13066 */ 13067 movl rSELF, %eax 13068 movl rPC, OUT_ARG0(%esp) 13069 movl %eax, OUT_ARG1(%esp) 13070 call dvmCheckInst # (dPC, self) 13071 movl rSELF, %ecx 13072 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13073 jmp *dvmAsmInstructionStart+(92*4) 13074 13075/* ------------------------------ */ 13076.L_ALT_OP_IPUT_BYTE: /* 0x5d */ 13077/* File: x86/ALT_STUB.S */ 13078/* 13079 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13080 * any interesting requests and then jump to the real instruction 13081 * handler. Unlike the Arm handler, we can't do this as a tail call 13082 * because rIBASE is caller save and we need to reload it. 13083 */ 13084 movl rSELF, %eax 13085 movl rPC, OUT_ARG0(%esp) 13086 movl %eax, OUT_ARG1(%esp) 13087 call dvmCheckInst # (dPC, self) 13088 movl rSELF, %ecx 13089 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13090 jmp *dvmAsmInstructionStart+(93*4) 13091 13092/* ------------------------------ */ 13093.L_ALT_OP_IPUT_CHAR: /* 0x5e */ 13094/* File: x86/ALT_STUB.S */ 13095/* 13096 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13097 * any interesting requests and then jump to the real instruction 13098 * handler. Unlike the Arm handler, we can't do this as a tail call 13099 * because rIBASE is caller save and we need to reload it. 13100 */ 13101 movl rSELF, %eax 13102 movl rPC, OUT_ARG0(%esp) 13103 movl %eax, OUT_ARG1(%esp) 13104 call dvmCheckInst # (dPC, self) 13105 movl rSELF, %ecx 13106 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13107 jmp *dvmAsmInstructionStart+(94*4) 13108 13109/* ------------------------------ */ 13110.L_ALT_OP_IPUT_SHORT: /* 0x5f */ 13111/* File: x86/ALT_STUB.S */ 13112/* 13113 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13114 * any interesting requests and then jump to the real instruction 13115 * handler. Unlike the Arm handler, we can't do this as a tail call 13116 * because rIBASE is caller save and we need to reload it. 13117 */ 13118 movl rSELF, %eax 13119 movl rPC, OUT_ARG0(%esp) 13120 movl %eax, OUT_ARG1(%esp) 13121 call dvmCheckInst # (dPC, self) 13122 movl rSELF, %ecx 13123 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13124 jmp *dvmAsmInstructionStart+(95*4) 13125 13126/* ------------------------------ */ 13127.L_ALT_OP_SGET: /* 0x60 */ 13128/* File: x86/ALT_STUB.S */ 13129/* 13130 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13131 * any interesting requests and then jump to the real instruction 13132 * handler. Unlike the Arm handler, we can't do this as a tail call 13133 * because rIBASE is caller save and we need to reload it. 13134 */ 13135 movl rSELF, %eax 13136 movl rPC, OUT_ARG0(%esp) 13137 movl %eax, OUT_ARG1(%esp) 13138 call dvmCheckInst # (dPC, self) 13139 movl rSELF, %ecx 13140 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13141 jmp *dvmAsmInstructionStart+(96*4) 13142 13143/* ------------------------------ */ 13144.L_ALT_OP_SGET_WIDE: /* 0x61 */ 13145/* File: x86/ALT_STUB.S */ 13146/* 13147 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13148 * any interesting requests and then jump to the real instruction 13149 * handler. Unlike the Arm handler, we can't do this as a tail call 13150 * because rIBASE is caller save and we need to reload it. 13151 */ 13152 movl rSELF, %eax 13153 movl rPC, OUT_ARG0(%esp) 13154 movl %eax, OUT_ARG1(%esp) 13155 call dvmCheckInst # (dPC, self) 13156 movl rSELF, %ecx 13157 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13158 jmp *dvmAsmInstructionStart+(97*4) 13159 13160/* ------------------------------ */ 13161.L_ALT_OP_SGET_OBJECT: /* 0x62 */ 13162/* File: x86/ALT_STUB.S */ 13163/* 13164 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13165 * any interesting requests and then jump to the real instruction 13166 * handler. Unlike the Arm handler, we can't do this as a tail call 13167 * because rIBASE is caller save and we need to reload it. 13168 */ 13169 movl rSELF, %eax 13170 movl rPC, OUT_ARG0(%esp) 13171 movl %eax, OUT_ARG1(%esp) 13172 call dvmCheckInst # (dPC, self) 13173 movl rSELF, %ecx 13174 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13175 jmp *dvmAsmInstructionStart+(98*4) 13176 13177/* ------------------------------ */ 13178.L_ALT_OP_SGET_BOOLEAN: /* 0x63 */ 13179/* File: x86/ALT_STUB.S */ 13180/* 13181 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13182 * any interesting requests and then jump to the real instruction 13183 * handler. Unlike the Arm handler, we can't do this as a tail call 13184 * because rIBASE is caller save and we need to reload it. 13185 */ 13186 movl rSELF, %eax 13187 movl rPC, OUT_ARG0(%esp) 13188 movl %eax, OUT_ARG1(%esp) 13189 call dvmCheckInst # (dPC, self) 13190 movl rSELF, %ecx 13191 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13192 jmp *dvmAsmInstructionStart+(99*4) 13193 13194/* ------------------------------ */ 13195.L_ALT_OP_SGET_BYTE: /* 0x64 */ 13196/* File: x86/ALT_STUB.S */ 13197/* 13198 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13199 * any interesting requests and then jump to the real instruction 13200 * handler. Unlike the Arm handler, we can't do this as a tail call 13201 * because rIBASE is caller save and we need to reload it. 13202 */ 13203 movl rSELF, %eax 13204 movl rPC, OUT_ARG0(%esp) 13205 movl %eax, OUT_ARG1(%esp) 13206 call dvmCheckInst # (dPC, self) 13207 movl rSELF, %ecx 13208 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13209 jmp *dvmAsmInstructionStart+(100*4) 13210 13211/* ------------------------------ */ 13212.L_ALT_OP_SGET_CHAR: /* 0x65 */ 13213/* File: x86/ALT_STUB.S */ 13214/* 13215 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13216 * any interesting requests and then jump to the real instruction 13217 * handler. Unlike the Arm handler, we can't do this as a tail call 13218 * because rIBASE is caller save and we need to reload it. 13219 */ 13220 movl rSELF, %eax 13221 movl rPC, OUT_ARG0(%esp) 13222 movl %eax, OUT_ARG1(%esp) 13223 call dvmCheckInst # (dPC, self) 13224 movl rSELF, %ecx 13225 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13226 jmp *dvmAsmInstructionStart+(101*4) 13227 13228/* ------------------------------ */ 13229.L_ALT_OP_SGET_SHORT: /* 0x66 */ 13230/* File: x86/ALT_STUB.S */ 13231/* 13232 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13233 * any interesting requests and then jump to the real instruction 13234 * handler. Unlike the Arm handler, we can't do this as a tail call 13235 * because rIBASE is caller save and we need to reload it. 13236 */ 13237 movl rSELF, %eax 13238 movl rPC, OUT_ARG0(%esp) 13239 movl %eax, OUT_ARG1(%esp) 13240 call dvmCheckInst # (dPC, self) 13241 movl rSELF, %ecx 13242 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13243 jmp *dvmAsmInstructionStart+(102*4) 13244 13245/* ------------------------------ */ 13246.L_ALT_OP_SPUT: /* 0x67 */ 13247/* File: x86/ALT_STUB.S */ 13248/* 13249 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13250 * any interesting requests and then jump to the real instruction 13251 * handler. Unlike the Arm handler, we can't do this as a tail call 13252 * because rIBASE is caller save and we need to reload it. 13253 */ 13254 movl rSELF, %eax 13255 movl rPC, OUT_ARG0(%esp) 13256 movl %eax, OUT_ARG1(%esp) 13257 call dvmCheckInst # (dPC, self) 13258 movl rSELF, %ecx 13259 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13260 jmp *dvmAsmInstructionStart+(103*4) 13261 13262/* ------------------------------ */ 13263.L_ALT_OP_SPUT_WIDE: /* 0x68 */ 13264/* File: x86/ALT_STUB.S */ 13265/* 13266 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13267 * any interesting requests and then jump to the real instruction 13268 * handler. Unlike the Arm handler, we can't do this as a tail call 13269 * because rIBASE is caller save and we need to reload it. 13270 */ 13271 movl rSELF, %eax 13272 movl rPC, OUT_ARG0(%esp) 13273 movl %eax, OUT_ARG1(%esp) 13274 call dvmCheckInst # (dPC, self) 13275 movl rSELF, %ecx 13276 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13277 jmp *dvmAsmInstructionStart+(104*4) 13278 13279/* ------------------------------ */ 13280.L_ALT_OP_SPUT_OBJECT: /* 0x69 */ 13281/* File: x86/ALT_STUB.S */ 13282/* 13283 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13284 * any interesting requests and then jump to the real instruction 13285 * handler. Unlike the Arm handler, we can't do this as a tail call 13286 * because rIBASE is caller save and we need to reload it. 13287 */ 13288 movl rSELF, %eax 13289 movl rPC, OUT_ARG0(%esp) 13290 movl %eax, OUT_ARG1(%esp) 13291 call dvmCheckInst # (dPC, self) 13292 movl rSELF, %ecx 13293 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13294 jmp *dvmAsmInstructionStart+(105*4) 13295 13296/* ------------------------------ */ 13297.L_ALT_OP_SPUT_BOOLEAN: /* 0x6a */ 13298/* File: x86/ALT_STUB.S */ 13299/* 13300 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13301 * any interesting requests and then jump to the real instruction 13302 * handler. Unlike the Arm handler, we can't do this as a tail call 13303 * because rIBASE is caller save and we need to reload it. 13304 */ 13305 movl rSELF, %eax 13306 movl rPC, OUT_ARG0(%esp) 13307 movl %eax, OUT_ARG1(%esp) 13308 call dvmCheckInst # (dPC, self) 13309 movl rSELF, %ecx 13310 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13311 jmp *dvmAsmInstructionStart+(106*4) 13312 13313/* ------------------------------ */ 13314.L_ALT_OP_SPUT_BYTE: /* 0x6b */ 13315/* File: x86/ALT_STUB.S */ 13316/* 13317 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13318 * any interesting requests and then jump to the real instruction 13319 * handler. Unlike the Arm handler, we can't do this as a tail call 13320 * because rIBASE is caller save and we need to reload it. 13321 */ 13322 movl rSELF, %eax 13323 movl rPC, OUT_ARG0(%esp) 13324 movl %eax, OUT_ARG1(%esp) 13325 call dvmCheckInst # (dPC, self) 13326 movl rSELF, %ecx 13327 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13328 jmp *dvmAsmInstructionStart+(107*4) 13329 13330/* ------------------------------ */ 13331.L_ALT_OP_SPUT_CHAR: /* 0x6c */ 13332/* File: x86/ALT_STUB.S */ 13333/* 13334 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13335 * any interesting requests and then jump to the real instruction 13336 * handler. Unlike the Arm handler, we can't do this as a tail call 13337 * because rIBASE is caller save and we need to reload it. 13338 */ 13339 movl rSELF, %eax 13340 movl rPC, OUT_ARG0(%esp) 13341 movl %eax, OUT_ARG1(%esp) 13342 call dvmCheckInst # (dPC, self) 13343 movl rSELF, %ecx 13344 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13345 jmp *dvmAsmInstructionStart+(108*4) 13346 13347/* ------------------------------ */ 13348.L_ALT_OP_SPUT_SHORT: /* 0x6d */ 13349/* File: x86/ALT_STUB.S */ 13350/* 13351 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13352 * any interesting requests and then jump to the real instruction 13353 * handler. Unlike the Arm handler, we can't do this as a tail call 13354 * because rIBASE is caller save and we need to reload it. 13355 */ 13356 movl rSELF, %eax 13357 movl rPC, OUT_ARG0(%esp) 13358 movl %eax, OUT_ARG1(%esp) 13359 call dvmCheckInst # (dPC, self) 13360 movl rSELF, %ecx 13361 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13362 jmp *dvmAsmInstructionStart+(109*4) 13363 13364/* ------------------------------ */ 13365.L_ALT_OP_INVOKE_VIRTUAL: /* 0x6e */ 13366/* File: x86/ALT_STUB.S */ 13367/* 13368 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13369 * any interesting requests and then jump to the real instruction 13370 * handler. Unlike the Arm handler, we can't do this as a tail call 13371 * because rIBASE is caller save and we need to reload it. 13372 */ 13373 movl rSELF, %eax 13374 movl rPC, OUT_ARG0(%esp) 13375 movl %eax, OUT_ARG1(%esp) 13376 call dvmCheckInst # (dPC, self) 13377 movl rSELF, %ecx 13378 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13379 jmp *dvmAsmInstructionStart+(110*4) 13380 13381/* ------------------------------ */ 13382.L_ALT_OP_INVOKE_SUPER: /* 0x6f */ 13383/* File: x86/ALT_STUB.S */ 13384/* 13385 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13386 * any interesting requests and then jump to the real instruction 13387 * handler. Unlike the Arm handler, we can't do this as a tail call 13388 * because rIBASE is caller save and we need to reload it. 13389 */ 13390 movl rSELF, %eax 13391 movl rPC, OUT_ARG0(%esp) 13392 movl %eax, OUT_ARG1(%esp) 13393 call dvmCheckInst # (dPC, self) 13394 movl rSELF, %ecx 13395 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13396 jmp *dvmAsmInstructionStart+(111*4) 13397 13398/* ------------------------------ */ 13399.L_ALT_OP_INVOKE_DIRECT: /* 0x70 */ 13400/* File: x86/ALT_STUB.S */ 13401/* 13402 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13403 * any interesting requests and then jump to the real instruction 13404 * handler. Unlike the Arm handler, we can't do this as a tail call 13405 * because rIBASE is caller save and we need to reload it. 13406 */ 13407 movl rSELF, %eax 13408 movl rPC, OUT_ARG0(%esp) 13409 movl %eax, OUT_ARG1(%esp) 13410 call dvmCheckInst # (dPC, self) 13411 movl rSELF, %ecx 13412 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13413 jmp *dvmAsmInstructionStart+(112*4) 13414 13415/* ------------------------------ */ 13416.L_ALT_OP_INVOKE_STATIC: /* 0x71 */ 13417/* File: x86/ALT_STUB.S */ 13418/* 13419 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13420 * any interesting requests and then jump to the real instruction 13421 * handler. Unlike the Arm handler, we can't do this as a tail call 13422 * because rIBASE is caller save and we need to reload it. 13423 */ 13424 movl rSELF, %eax 13425 movl rPC, OUT_ARG0(%esp) 13426 movl %eax, OUT_ARG1(%esp) 13427 call dvmCheckInst # (dPC, self) 13428 movl rSELF, %ecx 13429 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13430 jmp *dvmAsmInstructionStart+(113*4) 13431 13432/* ------------------------------ */ 13433.L_ALT_OP_INVOKE_INTERFACE: /* 0x72 */ 13434/* File: x86/ALT_STUB.S */ 13435/* 13436 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13437 * any interesting requests and then jump to the real instruction 13438 * handler. Unlike the Arm handler, we can't do this as a tail call 13439 * because rIBASE is caller save and we need to reload it. 13440 */ 13441 movl rSELF, %eax 13442 movl rPC, OUT_ARG0(%esp) 13443 movl %eax, OUT_ARG1(%esp) 13444 call dvmCheckInst # (dPC, self) 13445 movl rSELF, %ecx 13446 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13447 jmp *dvmAsmInstructionStart+(114*4) 13448 13449/* ------------------------------ */ 13450.L_ALT_OP_UNUSED_73: /* 0x73 */ 13451/* File: x86/ALT_STUB.S */ 13452/* 13453 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13454 * any interesting requests and then jump to the real instruction 13455 * handler. Unlike the Arm handler, we can't do this as a tail call 13456 * because rIBASE is caller save and we need to reload it. 13457 */ 13458 movl rSELF, %eax 13459 movl rPC, OUT_ARG0(%esp) 13460 movl %eax, OUT_ARG1(%esp) 13461 call dvmCheckInst # (dPC, self) 13462 movl rSELF, %ecx 13463 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13464 jmp *dvmAsmInstructionStart+(115*4) 13465 13466/* ------------------------------ */ 13467.L_ALT_OP_INVOKE_VIRTUAL_RANGE: /* 0x74 */ 13468/* File: x86/ALT_STUB.S */ 13469/* 13470 * Inter-instruction transfer stub. Call out to dvmCheckInst 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 movl rSELF, %eax 13476 movl rPC, OUT_ARG0(%esp) 13477 movl %eax, OUT_ARG1(%esp) 13478 call dvmCheckInst # (dPC, self) 13479 movl rSELF, %ecx 13480 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13481 jmp *dvmAsmInstructionStart+(116*4) 13482 13483/* ------------------------------ */ 13484.L_ALT_OP_INVOKE_SUPER_RANGE: /* 0x75 */ 13485/* File: x86/ALT_STUB.S */ 13486/* 13487 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13488 * any interesting requests and then jump to the real instruction 13489 * handler. Unlike the Arm handler, we can't do this as a tail call 13490 * because rIBASE is caller save and we need to reload it. 13491 */ 13492 movl rSELF, %eax 13493 movl rPC, OUT_ARG0(%esp) 13494 movl %eax, OUT_ARG1(%esp) 13495 call dvmCheckInst # (dPC, self) 13496 movl rSELF, %ecx 13497 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13498 jmp *dvmAsmInstructionStart+(117*4) 13499 13500/* ------------------------------ */ 13501.L_ALT_OP_INVOKE_DIRECT_RANGE: /* 0x76 */ 13502/* File: x86/ALT_STUB.S */ 13503/* 13504 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13505 * any interesting requests and then jump to the real instruction 13506 * handler. Unlike the Arm handler, we can't do this as a tail call 13507 * because rIBASE is caller save and we need to reload it. 13508 */ 13509 movl rSELF, %eax 13510 movl rPC, OUT_ARG0(%esp) 13511 movl %eax, OUT_ARG1(%esp) 13512 call dvmCheckInst # (dPC, self) 13513 movl rSELF, %ecx 13514 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13515 jmp *dvmAsmInstructionStart+(118*4) 13516 13517/* ------------------------------ */ 13518.L_ALT_OP_INVOKE_STATIC_RANGE: /* 0x77 */ 13519/* File: x86/ALT_STUB.S */ 13520/* 13521 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13522 * any interesting requests and then jump to the real instruction 13523 * handler. Unlike the Arm handler, we can't do this as a tail call 13524 * because rIBASE is caller save and we need to reload it. 13525 */ 13526 movl rSELF, %eax 13527 movl rPC, OUT_ARG0(%esp) 13528 movl %eax, OUT_ARG1(%esp) 13529 call dvmCheckInst # (dPC, self) 13530 movl rSELF, %ecx 13531 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13532 jmp *dvmAsmInstructionStart+(119*4) 13533 13534/* ------------------------------ */ 13535.L_ALT_OP_INVOKE_INTERFACE_RANGE: /* 0x78 */ 13536/* File: x86/ALT_STUB.S */ 13537/* 13538 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13539 * any interesting requests and then jump to the real instruction 13540 * handler. Unlike the Arm handler, we can't do this as a tail call 13541 * because rIBASE is caller save and we need to reload it. 13542 */ 13543 movl rSELF, %eax 13544 movl rPC, OUT_ARG0(%esp) 13545 movl %eax, OUT_ARG1(%esp) 13546 call dvmCheckInst # (dPC, self) 13547 movl rSELF, %ecx 13548 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13549 jmp *dvmAsmInstructionStart+(120*4) 13550 13551/* ------------------------------ */ 13552.L_ALT_OP_UNUSED_79: /* 0x79 */ 13553/* File: x86/ALT_STUB.S */ 13554/* 13555 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13556 * any interesting requests and then jump to the real instruction 13557 * handler. Unlike the Arm handler, we can't do this as a tail call 13558 * because rIBASE is caller save and we need to reload it. 13559 */ 13560 movl rSELF, %eax 13561 movl rPC, OUT_ARG0(%esp) 13562 movl %eax, OUT_ARG1(%esp) 13563 call dvmCheckInst # (dPC, self) 13564 movl rSELF, %ecx 13565 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13566 jmp *dvmAsmInstructionStart+(121*4) 13567 13568/* ------------------------------ */ 13569.L_ALT_OP_UNUSED_7A: /* 0x7a */ 13570/* File: x86/ALT_STUB.S */ 13571/* 13572 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13573 * any interesting requests and then jump to the real instruction 13574 * handler. Unlike the Arm handler, we can't do this as a tail call 13575 * because rIBASE is caller save and we need to reload it. 13576 */ 13577 movl rSELF, %eax 13578 movl rPC, OUT_ARG0(%esp) 13579 movl %eax, OUT_ARG1(%esp) 13580 call dvmCheckInst # (dPC, self) 13581 movl rSELF, %ecx 13582 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13583 jmp *dvmAsmInstructionStart+(122*4) 13584 13585/* ------------------------------ */ 13586.L_ALT_OP_NEG_INT: /* 0x7b */ 13587/* File: x86/ALT_STUB.S */ 13588/* 13589 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13590 * any interesting requests and then jump to the real instruction 13591 * handler. Unlike the Arm handler, we can't do this as a tail call 13592 * because rIBASE is caller save and we need to reload it. 13593 */ 13594 movl rSELF, %eax 13595 movl rPC, OUT_ARG0(%esp) 13596 movl %eax, OUT_ARG1(%esp) 13597 call dvmCheckInst # (dPC, self) 13598 movl rSELF, %ecx 13599 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13600 jmp *dvmAsmInstructionStart+(123*4) 13601 13602/* ------------------------------ */ 13603.L_ALT_OP_NOT_INT: /* 0x7c */ 13604/* File: x86/ALT_STUB.S */ 13605/* 13606 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13607 * any interesting requests and then jump to the real instruction 13608 * handler. Unlike the Arm handler, we can't do this as a tail call 13609 * because rIBASE is caller save and we need to reload it. 13610 */ 13611 movl rSELF, %eax 13612 movl rPC, OUT_ARG0(%esp) 13613 movl %eax, OUT_ARG1(%esp) 13614 call dvmCheckInst # (dPC, self) 13615 movl rSELF, %ecx 13616 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13617 jmp *dvmAsmInstructionStart+(124*4) 13618 13619/* ------------------------------ */ 13620.L_ALT_OP_NEG_LONG: /* 0x7d */ 13621/* File: x86/ALT_STUB.S */ 13622/* 13623 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13624 * any interesting requests and then jump to the real instruction 13625 * handler. Unlike the Arm handler, we can't do this as a tail call 13626 * because rIBASE is caller save and we need to reload it. 13627 */ 13628 movl rSELF, %eax 13629 movl rPC, OUT_ARG0(%esp) 13630 movl %eax, OUT_ARG1(%esp) 13631 call dvmCheckInst # (dPC, self) 13632 movl rSELF, %ecx 13633 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13634 jmp *dvmAsmInstructionStart+(125*4) 13635 13636/* ------------------------------ */ 13637.L_ALT_OP_NOT_LONG: /* 0x7e */ 13638/* File: x86/ALT_STUB.S */ 13639/* 13640 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13641 * any interesting requests and then jump to the real instruction 13642 * handler. Unlike the Arm handler, we can't do this as a tail call 13643 * because rIBASE is caller save and we need to reload it. 13644 */ 13645 movl rSELF, %eax 13646 movl rPC, OUT_ARG0(%esp) 13647 movl %eax, OUT_ARG1(%esp) 13648 call dvmCheckInst # (dPC, self) 13649 movl rSELF, %ecx 13650 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13651 jmp *dvmAsmInstructionStart+(126*4) 13652 13653/* ------------------------------ */ 13654.L_ALT_OP_NEG_FLOAT: /* 0x7f */ 13655/* File: x86/ALT_STUB.S */ 13656/* 13657 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13658 * any interesting requests and then jump to the real instruction 13659 * handler. Unlike the Arm handler, we can't do this as a tail call 13660 * because rIBASE is caller save and we need to reload it. 13661 */ 13662 movl rSELF, %eax 13663 movl rPC, OUT_ARG0(%esp) 13664 movl %eax, OUT_ARG1(%esp) 13665 call dvmCheckInst # (dPC, self) 13666 movl rSELF, %ecx 13667 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13668 jmp *dvmAsmInstructionStart+(127*4) 13669 13670/* ------------------------------ */ 13671.L_ALT_OP_NEG_DOUBLE: /* 0x80 */ 13672/* File: x86/ALT_STUB.S */ 13673/* 13674 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13675 * any interesting requests and then jump to the real instruction 13676 * handler. Unlike the Arm handler, we can't do this as a tail call 13677 * because rIBASE is caller save and we need to reload it. 13678 */ 13679 movl rSELF, %eax 13680 movl rPC, OUT_ARG0(%esp) 13681 movl %eax, OUT_ARG1(%esp) 13682 call dvmCheckInst # (dPC, self) 13683 movl rSELF, %ecx 13684 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13685 jmp *dvmAsmInstructionStart+(128*4) 13686 13687/* ------------------------------ */ 13688.L_ALT_OP_INT_TO_LONG: /* 0x81 */ 13689/* File: x86/ALT_STUB.S */ 13690/* 13691 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13692 * any interesting requests and then jump to the real instruction 13693 * handler. Unlike the Arm handler, we can't do this as a tail call 13694 * because rIBASE is caller save and we need to reload it. 13695 */ 13696 movl rSELF, %eax 13697 movl rPC, OUT_ARG0(%esp) 13698 movl %eax, OUT_ARG1(%esp) 13699 call dvmCheckInst # (dPC, self) 13700 movl rSELF, %ecx 13701 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13702 jmp *dvmAsmInstructionStart+(129*4) 13703 13704/* ------------------------------ */ 13705.L_ALT_OP_INT_TO_FLOAT: /* 0x82 */ 13706/* File: x86/ALT_STUB.S */ 13707/* 13708 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13709 * any interesting requests and then jump to the real instruction 13710 * handler. Unlike the Arm handler, we can't do this as a tail call 13711 * because rIBASE is caller save and we need to reload it. 13712 */ 13713 movl rSELF, %eax 13714 movl rPC, OUT_ARG0(%esp) 13715 movl %eax, OUT_ARG1(%esp) 13716 call dvmCheckInst # (dPC, self) 13717 movl rSELF, %ecx 13718 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13719 jmp *dvmAsmInstructionStart+(130*4) 13720 13721/* ------------------------------ */ 13722.L_ALT_OP_INT_TO_DOUBLE: /* 0x83 */ 13723/* File: x86/ALT_STUB.S */ 13724/* 13725 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13726 * any interesting requests and then jump to the real instruction 13727 * handler. Unlike the Arm handler, we can't do this as a tail call 13728 * because rIBASE is caller save and we need to reload it. 13729 */ 13730 movl rSELF, %eax 13731 movl rPC, OUT_ARG0(%esp) 13732 movl %eax, OUT_ARG1(%esp) 13733 call dvmCheckInst # (dPC, self) 13734 movl rSELF, %ecx 13735 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13736 jmp *dvmAsmInstructionStart+(131*4) 13737 13738/* ------------------------------ */ 13739.L_ALT_OP_LONG_TO_INT: /* 0x84 */ 13740/* File: x86/ALT_STUB.S */ 13741/* 13742 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13743 * any interesting requests and then jump to the real instruction 13744 * handler. Unlike the Arm handler, we can't do this as a tail call 13745 * because rIBASE is caller save and we need to reload it. 13746 */ 13747 movl rSELF, %eax 13748 movl rPC, OUT_ARG0(%esp) 13749 movl %eax, OUT_ARG1(%esp) 13750 call dvmCheckInst # (dPC, self) 13751 movl rSELF, %ecx 13752 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13753 jmp *dvmAsmInstructionStart+(132*4) 13754 13755/* ------------------------------ */ 13756.L_ALT_OP_LONG_TO_FLOAT: /* 0x85 */ 13757/* File: x86/ALT_STUB.S */ 13758/* 13759 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13760 * any interesting requests and then jump to the real instruction 13761 * handler. Unlike the Arm handler, we can't do this as a tail call 13762 * because rIBASE is caller save and we need to reload it. 13763 */ 13764 movl rSELF, %eax 13765 movl rPC, OUT_ARG0(%esp) 13766 movl %eax, OUT_ARG1(%esp) 13767 call dvmCheckInst # (dPC, self) 13768 movl rSELF, %ecx 13769 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13770 jmp *dvmAsmInstructionStart+(133*4) 13771 13772/* ------------------------------ */ 13773.L_ALT_OP_LONG_TO_DOUBLE: /* 0x86 */ 13774/* File: x86/ALT_STUB.S */ 13775/* 13776 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13777 * any interesting requests and then jump to the real instruction 13778 * handler. Unlike the Arm handler, we can't do this as a tail call 13779 * because rIBASE is caller save and we need to reload it. 13780 */ 13781 movl rSELF, %eax 13782 movl rPC, OUT_ARG0(%esp) 13783 movl %eax, OUT_ARG1(%esp) 13784 call dvmCheckInst # (dPC, self) 13785 movl rSELF, %ecx 13786 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13787 jmp *dvmAsmInstructionStart+(134*4) 13788 13789/* ------------------------------ */ 13790.L_ALT_OP_FLOAT_TO_INT: /* 0x87 */ 13791/* File: x86/ALT_STUB.S */ 13792/* 13793 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13794 * any interesting requests and then jump to the real instruction 13795 * handler. Unlike the Arm handler, we can't do this as a tail call 13796 * because rIBASE is caller save and we need to reload it. 13797 */ 13798 movl rSELF, %eax 13799 movl rPC, OUT_ARG0(%esp) 13800 movl %eax, OUT_ARG1(%esp) 13801 call dvmCheckInst # (dPC, self) 13802 movl rSELF, %ecx 13803 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13804 jmp *dvmAsmInstructionStart+(135*4) 13805 13806/* ------------------------------ */ 13807.L_ALT_OP_FLOAT_TO_LONG: /* 0x88 */ 13808/* File: x86/ALT_STUB.S */ 13809/* 13810 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13811 * any interesting requests and then jump to the real instruction 13812 * handler. Unlike the Arm handler, we can't do this as a tail call 13813 * because rIBASE is caller save and we need to reload it. 13814 */ 13815 movl rSELF, %eax 13816 movl rPC, OUT_ARG0(%esp) 13817 movl %eax, OUT_ARG1(%esp) 13818 call dvmCheckInst # (dPC, self) 13819 movl rSELF, %ecx 13820 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13821 jmp *dvmAsmInstructionStart+(136*4) 13822 13823/* ------------------------------ */ 13824.L_ALT_OP_FLOAT_TO_DOUBLE: /* 0x89 */ 13825/* File: x86/ALT_STUB.S */ 13826/* 13827 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13828 * any interesting requests and then jump to the real instruction 13829 * handler. Unlike the Arm handler, we can't do this as a tail call 13830 * because rIBASE is caller save and we need to reload it. 13831 */ 13832 movl rSELF, %eax 13833 movl rPC, OUT_ARG0(%esp) 13834 movl %eax, OUT_ARG1(%esp) 13835 call dvmCheckInst # (dPC, self) 13836 movl rSELF, %ecx 13837 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13838 jmp *dvmAsmInstructionStart+(137*4) 13839 13840/* ------------------------------ */ 13841.L_ALT_OP_DOUBLE_TO_INT: /* 0x8a */ 13842/* File: x86/ALT_STUB.S */ 13843/* 13844 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13845 * any interesting requests and then jump to the real instruction 13846 * handler. Unlike the Arm handler, we can't do this as a tail call 13847 * because rIBASE is caller save and we need to reload it. 13848 */ 13849 movl rSELF, %eax 13850 movl rPC, OUT_ARG0(%esp) 13851 movl %eax, OUT_ARG1(%esp) 13852 call dvmCheckInst # (dPC, self) 13853 movl rSELF, %ecx 13854 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13855 jmp *dvmAsmInstructionStart+(138*4) 13856 13857/* ------------------------------ */ 13858.L_ALT_OP_DOUBLE_TO_LONG: /* 0x8b */ 13859/* File: x86/ALT_STUB.S */ 13860/* 13861 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13862 * any interesting requests and then jump to the real instruction 13863 * handler. Unlike the Arm handler, we can't do this as a tail call 13864 * because rIBASE is caller save and we need to reload it. 13865 */ 13866 movl rSELF, %eax 13867 movl rPC, OUT_ARG0(%esp) 13868 movl %eax, OUT_ARG1(%esp) 13869 call dvmCheckInst # (dPC, self) 13870 movl rSELF, %ecx 13871 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13872 jmp *dvmAsmInstructionStart+(139*4) 13873 13874/* ------------------------------ */ 13875.L_ALT_OP_DOUBLE_TO_FLOAT: /* 0x8c */ 13876/* File: x86/ALT_STUB.S */ 13877/* 13878 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13879 * any interesting requests and then jump to the real instruction 13880 * handler. Unlike the Arm handler, we can't do this as a tail call 13881 * because rIBASE is caller save and we need to reload it. 13882 */ 13883 movl rSELF, %eax 13884 movl rPC, OUT_ARG0(%esp) 13885 movl %eax, OUT_ARG1(%esp) 13886 call dvmCheckInst # (dPC, self) 13887 movl rSELF, %ecx 13888 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13889 jmp *dvmAsmInstructionStart+(140*4) 13890 13891/* ------------------------------ */ 13892.L_ALT_OP_INT_TO_BYTE: /* 0x8d */ 13893/* File: x86/ALT_STUB.S */ 13894/* 13895 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13896 * any interesting requests and then jump to the real instruction 13897 * handler. Unlike the Arm handler, we can't do this as a tail call 13898 * because rIBASE is caller save and we need to reload it. 13899 */ 13900 movl rSELF, %eax 13901 movl rPC, OUT_ARG0(%esp) 13902 movl %eax, OUT_ARG1(%esp) 13903 call dvmCheckInst # (dPC, self) 13904 movl rSELF, %ecx 13905 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13906 jmp *dvmAsmInstructionStart+(141*4) 13907 13908/* ------------------------------ */ 13909.L_ALT_OP_INT_TO_CHAR: /* 0x8e */ 13910/* File: x86/ALT_STUB.S */ 13911/* 13912 * Inter-instruction transfer stub. Call out to dvmCheckInst 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 movl rSELF, %eax 13918 movl rPC, OUT_ARG0(%esp) 13919 movl %eax, OUT_ARG1(%esp) 13920 call dvmCheckInst # (dPC, self) 13921 movl rSELF, %ecx 13922 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13923 jmp *dvmAsmInstructionStart+(142*4) 13924 13925/* ------------------------------ */ 13926.L_ALT_OP_INT_TO_SHORT: /* 0x8f */ 13927/* File: x86/ALT_STUB.S */ 13928/* 13929 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13930 * any interesting requests and then jump to the real instruction 13931 * handler. Unlike the Arm handler, we can't do this as a tail call 13932 * because rIBASE is caller save and we need to reload it. 13933 */ 13934 movl rSELF, %eax 13935 movl rPC, OUT_ARG0(%esp) 13936 movl %eax, OUT_ARG1(%esp) 13937 call dvmCheckInst # (dPC, self) 13938 movl rSELF, %ecx 13939 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13940 jmp *dvmAsmInstructionStart+(143*4) 13941 13942/* ------------------------------ */ 13943.L_ALT_OP_ADD_INT: /* 0x90 */ 13944/* File: x86/ALT_STUB.S */ 13945/* 13946 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13947 * any interesting requests and then jump to the real instruction 13948 * handler. Unlike the Arm handler, we can't do this as a tail call 13949 * because rIBASE is caller save and we need to reload it. 13950 */ 13951 movl rSELF, %eax 13952 movl rPC, OUT_ARG0(%esp) 13953 movl %eax, OUT_ARG1(%esp) 13954 call dvmCheckInst # (dPC, self) 13955 movl rSELF, %ecx 13956 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13957 jmp *dvmAsmInstructionStart+(144*4) 13958 13959/* ------------------------------ */ 13960.L_ALT_OP_SUB_INT: /* 0x91 */ 13961/* File: x86/ALT_STUB.S */ 13962/* 13963 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13964 * any interesting requests and then jump to the real instruction 13965 * handler. Unlike the Arm handler, we can't do this as a tail call 13966 * because rIBASE is caller save and we need to reload it. 13967 */ 13968 movl rSELF, %eax 13969 movl rPC, OUT_ARG0(%esp) 13970 movl %eax, OUT_ARG1(%esp) 13971 call dvmCheckInst # (dPC, self) 13972 movl rSELF, %ecx 13973 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13974 jmp *dvmAsmInstructionStart+(145*4) 13975 13976/* ------------------------------ */ 13977.L_ALT_OP_MUL_INT: /* 0x92 */ 13978/* File: x86/ALT_STUB.S */ 13979/* 13980 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13981 * any interesting requests and then jump to the real instruction 13982 * handler. Unlike the Arm handler, we can't do this as a tail call 13983 * because rIBASE is caller save and we need to reload it. 13984 */ 13985 movl rSELF, %eax 13986 movl rPC, OUT_ARG0(%esp) 13987 movl %eax, OUT_ARG1(%esp) 13988 call dvmCheckInst # (dPC, self) 13989 movl rSELF, %ecx 13990 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 13991 jmp *dvmAsmInstructionStart+(146*4) 13992 13993/* ------------------------------ */ 13994.L_ALT_OP_DIV_INT: /* 0x93 */ 13995/* File: x86/ALT_STUB.S */ 13996/* 13997 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 13998 * any interesting requests and then jump to the real instruction 13999 * handler. Unlike the Arm handler, we can't do this as a tail call 14000 * because rIBASE is caller save and we need to reload it. 14001 */ 14002 movl rSELF, %eax 14003 movl rPC, OUT_ARG0(%esp) 14004 movl %eax, OUT_ARG1(%esp) 14005 call dvmCheckInst # (dPC, self) 14006 movl rSELF, %ecx 14007 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14008 jmp *dvmAsmInstructionStart+(147*4) 14009 14010/* ------------------------------ */ 14011.L_ALT_OP_REM_INT: /* 0x94 */ 14012/* File: x86/ALT_STUB.S */ 14013/* 14014 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14015 * any interesting requests and then jump to the real instruction 14016 * handler. Unlike the Arm handler, we can't do this as a tail call 14017 * because rIBASE is caller save and we need to reload it. 14018 */ 14019 movl rSELF, %eax 14020 movl rPC, OUT_ARG0(%esp) 14021 movl %eax, OUT_ARG1(%esp) 14022 call dvmCheckInst # (dPC, self) 14023 movl rSELF, %ecx 14024 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14025 jmp *dvmAsmInstructionStart+(148*4) 14026 14027/* ------------------------------ */ 14028.L_ALT_OP_AND_INT: /* 0x95 */ 14029/* File: x86/ALT_STUB.S */ 14030/* 14031 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14032 * any interesting requests and then jump to the real instruction 14033 * handler. Unlike the Arm handler, we can't do this as a tail call 14034 * because rIBASE is caller save and we need to reload it. 14035 */ 14036 movl rSELF, %eax 14037 movl rPC, OUT_ARG0(%esp) 14038 movl %eax, OUT_ARG1(%esp) 14039 call dvmCheckInst # (dPC, self) 14040 movl rSELF, %ecx 14041 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14042 jmp *dvmAsmInstructionStart+(149*4) 14043 14044/* ------------------------------ */ 14045.L_ALT_OP_OR_INT: /* 0x96 */ 14046/* File: x86/ALT_STUB.S */ 14047/* 14048 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14049 * any interesting requests and then jump to the real instruction 14050 * handler. Unlike the Arm handler, we can't do this as a tail call 14051 * because rIBASE is caller save and we need to reload it. 14052 */ 14053 movl rSELF, %eax 14054 movl rPC, OUT_ARG0(%esp) 14055 movl %eax, OUT_ARG1(%esp) 14056 call dvmCheckInst # (dPC, self) 14057 movl rSELF, %ecx 14058 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14059 jmp *dvmAsmInstructionStart+(150*4) 14060 14061/* ------------------------------ */ 14062.L_ALT_OP_XOR_INT: /* 0x97 */ 14063/* File: x86/ALT_STUB.S */ 14064/* 14065 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14066 * any interesting requests and then jump to the real instruction 14067 * handler. Unlike the Arm handler, we can't do this as a tail call 14068 * because rIBASE is caller save and we need to reload it. 14069 */ 14070 movl rSELF, %eax 14071 movl rPC, OUT_ARG0(%esp) 14072 movl %eax, OUT_ARG1(%esp) 14073 call dvmCheckInst # (dPC, self) 14074 movl rSELF, %ecx 14075 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14076 jmp *dvmAsmInstructionStart+(151*4) 14077 14078/* ------------------------------ */ 14079.L_ALT_OP_SHL_INT: /* 0x98 */ 14080/* File: x86/ALT_STUB.S */ 14081/* 14082 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14083 * any interesting requests and then jump to the real instruction 14084 * handler. Unlike the Arm handler, we can't do this as a tail call 14085 * because rIBASE is caller save and we need to reload it. 14086 */ 14087 movl rSELF, %eax 14088 movl rPC, OUT_ARG0(%esp) 14089 movl %eax, OUT_ARG1(%esp) 14090 call dvmCheckInst # (dPC, self) 14091 movl rSELF, %ecx 14092 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14093 jmp *dvmAsmInstructionStart+(152*4) 14094 14095/* ------------------------------ */ 14096.L_ALT_OP_SHR_INT: /* 0x99 */ 14097/* File: x86/ALT_STUB.S */ 14098/* 14099 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14100 * any interesting requests and then jump to the real instruction 14101 * handler. Unlike the Arm handler, we can't do this as a tail call 14102 * because rIBASE is caller save and we need to reload it. 14103 */ 14104 movl rSELF, %eax 14105 movl rPC, OUT_ARG0(%esp) 14106 movl %eax, OUT_ARG1(%esp) 14107 call dvmCheckInst # (dPC, self) 14108 movl rSELF, %ecx 14109 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14110 jmp *dvmAsmInstructionStart+(153*4) 14111 14112/* ------------------------------ */ 14113.L_ALT_OP_USHR_INT: /* 0x9a */ 14114/* File: x86/ALT_STUB.S */ 14115/* 14116 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14117 * any interesting requests and then jump to the real instruction 14118 * handler. Unlike the Arm handler, we can't do this as a tail call 14119 * because rIBASE is caller save and we need to reload it. 14120 */ 14121 movl rSELF, %eax 14122 movl rPC, OUT_ARG0(%esp) 14123 movl %eax, OUT_ARG1(%esp) 14124 call dvmCheckInst # (dPC, self) 14125 movl rSELF, %ecx 14126 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14127 jmp *dvmAsmInstructionStart+(154*4) 14128 14129/* ------------------------------ */ 14130.L_ALT_OP_ADD_LONG: /* 0x9b */ 14131/* File: x86/ALT_STUB.S */ 14132/* 14133 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14134 * any interesting requests and then jump to the real instruction 14135 * handler. Unlike the Arm handler, we can't do this as a tail call 14136 * because rIBASE is caller save and we need to reload it. 14137 */ 14138 movl rSELF, %eax 14139 movl rPC, OUT_ARG0(%esp) 14140 movl %eax, OUT_ARG1(%esp) 14141 call dvmCheckInst # (dPC, self) 14142 movl rSELF, %ecx 14143 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14144 jmp *dvmAsmInstructionStart+(155*4) 14145 14146/* ------------------------------ */ 14147.L_ALT_OP_SUB_LONG: /* 0x9c */ 14148/* File: x86/ALT_STUB.S */ 14149/* 14150 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14151 * any interesting requests and then jump to the real instruction 14152 * handler. Unlike the Arm handler, we can't do this as a tail call 14153 * because rIBASE is caller save and we need to reload it. 14154 */ 14155 movl rSELF, %eax 14156 movl rPC, OUT_ARG0(%esp) 14157 movl %eax, OUT_ARG1(%esp) 14158 call dvmCheckInst # (dPC, self) 14159 movl rSELF, %ecx 14160 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14161 jmp *dvmAsmInstructionStart+(156*4) 14162 14163/* ------------------------------ */ 14164.L_ALT_OP_MUL_LONG: /* 0x9d */ 14165/* File: x86/ALT_STUB.S */ 14166/* 14167 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14168 * any interesting requests and then jump to the real instruction 14169 * handler. Unlike the Arm handler, we can't do this as a tail call 14170 * because rIBASE is caller save and we need to reload it. 14171 */ 14172 movl rSELF, %eax 14173 movl rPC, OUT_ARG0(%esp) 14174 movl %eax, OUT_ARG1(%esp) 14175 call dvmCheckInst # (dPC, self) 14176 movl rSELF, %ecx 14177 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14178 jmp *dvmAsmInstructionStart+(157*4) 14179 14180/* ------------------------------ */ 14181.L_ALT_OP_DIV_LONG: /* 0x9e */ 14182/* File: x86/ALT_STUB.S */ 14183/* 14184 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14185 * any interesting requests and then jump to the real instruction 14186 * handler. Unlike the Arm handler, we can't do this as a tail call 14187 * because rIBASE is caller save and we need to reload it. 14188 */ 14189 movl rSELF, %eax 14190 movl rPC, OUT_ARG0(%esp) 14191 movl %eax, OUT_ARG1(%esp) 14192 call dvmCheckInst # (dPC, self) 14193 movl rSELF, %ecx 14194 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14195 jmp *dvmAsmInstructionStart+(158*4) 14196 14197/* ------------------------------ */ 14198.L_ALT_OP_REM_LONG: /* 0x9f */ 14199/* File: x86/ALT_STUB.S */ 14200/* 14201 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14202 * any interesting requests and then jump to the real instruction 14203 * handler. Unlike the Arm handler, we can't do this as a tail call 14204 * because rIBASE is caller save and we need to reload it. 14205 */ 14206 movl rSELF, %eax 14207 movl rPC, OUT_ARG0(%esp) 14208 movl %eax, OUT_ARG1(%esp) 14209 call dvmCheckInst # (dPC, self) 14210 movl rSELF, %ecx 14211 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14212 jmp *dvmAsmInstructionStart+(159*4) 14213 14214/* ------------------------------ */ 14215.L_ALT_OP_AND_LONG: /* 0xa0 */ 14216/* File: x86/ALT_STUB.S */ 14217/* 14218 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14219 * any interesting requests and then jump to the real instruction 14220 * handler. Unlike the Arm handler, we can't do this as a tail call 14221 * because rIBASE is caller save and we need to reload it. 14222 */ 14223 movl rSELF, %eax 14224 movl rPC, OUT_ARG0(%esp) 14225 movl %eax, OUT_ARG1(%esp) 14226 call dvmCheckInst # (dPC, self) 14227 movl rSELF, %ecx 14228 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14229 jmp *dvmAsmInstructionStart+(160*4) 14230 14231/* ------------------------------ */ 14232.L_ALT_OP_OR_LONG: /* 0xa1 */ 14233/* File: x86/ALT_STUB.S */ 14234/* 14235 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14236 * any interesting requests and then jump to the real instruction 14237 * handler. Unlike the Arm handler, we can't do this as a tail call 14238 * because rIBASE is caller save and we need to reload it. 14239 */ 14240 movl rSELF, %eax 14241 movl rPC, OUT_ARG0(%esp) 14242 movl %eax, OUT_ARG1(%esp) 14243 call dvmCheckInst # (dPC, self) 14244 movl rSELF, %ecx 14245 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14246 jmp *dvmAsmInstructionStart+(161*4) 14247 14248/* ------------------------------ */ 14249.L_ALT_OP_XOR_LONG: /* 0xa2 */ 14250/* File: x86/ALT_STUB.S */ 14251/* 14252 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14253 * any interesting requests and then jump to the real instruction 14254 * handler. Unlike the Arm handler, we can't do this as a tail call 14255 * because rIBASE is caller save and we need to reload it. 14256 */ 14257 movl rSELF, %eax 14258 movl rPC, OUT_ARG0(%esp) 14259 movl %eax, OUT_ARG1(%esp) 14260 call dvmCheckInst # (dPC, self) 14261 movl rSELF, %ecx 14262 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14263 jmp *dvmAsmInstructionStart+(162*4) 14264 14265/* ------------------------------ */ 14266.L_ALT_OP_SHL_LONG: /* 0xa3 */ 14267/* File: x86/ALT_STUB.S */ 14268/* 14269 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14270 * any interesting requests and then jump to the real instruction 14271 * handler. Unlike the Arm handler, we can't do this as a tail call 14272 * because rIBASE is caller save and we need to reload it. 14273 */ 14274 movl rSELF, %eax 14275 movl rPC, OUT_ARG0(%esp) 14276 movl %eax, OUT_ARG1(%esp) 14277 call dvmCheckInst # (dPC, self) 14278 movl rSELF, %ecx 14279 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14280 jmp *dvmAsmInstructionStart+(163*4) 14281 14282/* ------------------------------ */ 14283.L_ALT_OP_SHR_LONG: /* 0xa4 */ 14284/* File: x86/ALT_STUB.S */ 14285/* 14286 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14287 * any interesting requests and then jump to the real instruction 14288 * handler. Unlike the Arm handler, we can't do this as a tail call 14289 * because rIBASE is caller save and we need to reload it. 14290 */ 14291 movl rSELF, %eax 14292 movl rPC, OUT_ARG0(%esp) 14293 movl %eax, OUT_ARG1(%esp) 14294 call dvmCheckInst # (dPC, self) 14295 movl rSELF, %ecx 14296 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14297 jmp *dvmAsmInstructionStart+(164*4) 14298 14299/* ------------------------------ */ 14300.L_ALT_OP_USHR_LONG: /* 0xa5 */ 14301/* File: x86/ALT_STUB.S */ 14302/* 14303 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14304 * any interesting requests and then jump to the real instruction 14305 * handler. Unlike the Arm handler, we can't do this as a tail call 14306 * because rIBASE is caller save and we need to reload it. 14307 */ 14308 movl rSELF, %eax 14309 movl rPC, OUT_ARG0(%esp) 14310 movl %eax, OUT_ARG1(%esp) 14311 call dvmCheckInst # (dPC, self) 14312 movl rSELF, %ecx 14313 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14314 jmp *dvmAsmInstructionStart+(165*4) 14315 14316/* ------------------------------ */ 14317.L_ALT_OP_ADD_FLOAT: /* 0xa6 */ 14318/* File: x86/ALT_STUB.S */ 14319/* 14320 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14321 * any interesting requests and then jump to the real instruction 14322 * handler. Unlike the Arm handler, we can't do this as a tail call 14323 * because rIBASE is caller save and we need to reload it. 14324 */ 14325 movl rSELF, %eax 14326 movl rPC, OUT_ARG0(%esp) 14327 movl %eax, OUT_ARG1(%esp) 14328 call dvmCheckInst # (dPC, self) 14329 movl rSELF, %ecx 14330 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14331 jmp *dvmAsmInstructionStart+(166*4) 14332 14333/* ------------------------------ */ 14334.L_ALT_OP_SUB_FLOAT: /* 0xa7 */ 14335/* File: x86/ALT_STUB.S */ 14336/* 14337 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14338 * any interesting requests and then jump to the real instruction 14339 * handler. Unlike the Arm handler, we can't do this as a tail call 14340 * because rIBASE is caller save and we need to reload it. 14341 */ 14342 movl rSELF, %eax 14343 movl rPC, OUT_ARG0(%esp) 14344 movl %eax, OUT_ARG1(%esp) 14345 call dvmCheckInst # (dPC, self) 14346 movl rSELF, %ecx 14347 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14348 jmp *dvmAsmInstructionStart+(167*4) 14349 14350/* ------------------------------ */ 14351.L_ALT_OP_MUL_FLOAT: /* 0xa8 */ 14352/* File: x86/ALT_STUB.S */ 14353/* 14354 * Inter-instruction transfer stub. Call out to dvmCheckInst 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 movl rSELF, %eax 14360 movl rPC, OUT_ARG0(%esp) 14361 movl %eax, OUT_ARG1(%esp) 14362 call dvmCheckInst # (dPC, self) 14363 movl rSELF, %ecx 14364 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14365 jmp *dvmAsmInstructionStart+(168*4) 14366 14367/* ------------------------------ */ 14368.L_ALT_OP_DIV_FLOAT: /* 0xa9 */ 14369/* File: x86/ALT_STUB.S */ 14370/* 14371 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14372 * any interesting requests and then jump to the real instruction 14373 * handler. Unlike the Arm handler, we can't do this as a tail call 14374 * because rIBASE is caller save and we need to reload it. 14375 */ 14376 movl rSELF, %eax 14377 movl rPC, OUT_ARG0(%esp) 14378 movl %eax, OUT_ARG1(%esp) 14379 call dvmCheckInst # (dPC, self) 14380 movl rSELF, %ecx 14381 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14382 jmp *dvmAsmInstructionStart+(169*4) 14383 14384/* ------------------------------ */ 14385.L_ALT_OP_REM_FLOAT: /* 0xaa */ 14386/* File: x86/ALT_STUB.S */ 14387/* 14388 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14389 * any interesting requests and then jump to the real instruction 14390 * handler. Unlike the Arm handler, we can't do this as a tail call 14391 * because rIBASE is caller save and we need to reload it. 14392 */ 14393 movl rSELF, %eax 14394 movl rPC, OUT_ARG0(%esp) 14395 movl %eax, OUT_ARG1(%esp) 14396 call dvmCheckInst # (dPC, self) 14397 movl rSELF, %ecx 14398 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14399 jmp *dvmAsmInstructionStart+(170*4) 14400 14401/* ------------------------------ */ 14402.L_ALT_OP_ADD_DOUBLE: /* 0xab */ 14403/* File: x86/ALT_STUB.S */ 14404/* 14405 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14406 * any interesting requests and then jump to the real instruction 14407 * handler. Unlike the Arm handler, we can't do this as a tail call 14408 * because rIBASE is caller save and we need to reload it. 14409 */ 14410 movl rSELF, %eax 14411 movl rPC, OUT_ARG0(%esp) 14412 movl %eax, OUT_ARG1(%esp) 14413 call dvmCheckInst # (dPC, self) 14414 movl rSELF, %ecx 14415 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14416 jmp *dvmAsmInstructionStart+(171*4) 14417 14418/* ------------------------------ */ 14419.L_ALT_OP_SUB_DOUBLE: /* 0xac */ 14420/* File: x86/ALT_STUB.S */ 14421/* 14422 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14423 * any interesting requests and then jump to the real instruction 14424 * handler. Unlike the Arm handler, we can't do this as a tail call 14425 * because rIBASE is caller save and we need to reload it. 14426 */ 14427 movl rSELF, %eax 14428 movl rPC, OUT_ARG0(%esp) 14429 movl %eax, OUT_ARG1(%esp) 14430 call dvmCheckInst # (dPC, self) 14431 movl rSELF, %ecx 14432 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14433 jmp *dvmAsmInstructionStart+(172*4) 14434 14435/* ------------------------------ */ 14436.L_ALT_OP_MUL_DOUBLE: /* 0xad */ 14437/* File: x86/ALT_STUB.S */ 14438/* 14439 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14440 * any interesting requests and then jump to the real instruction 14441 * handler. Unlike the Arm handler, we can't do this as a tail call 14442 * because rIBASE is caller save and we need to reload it. 14443 */ 14444 movl rSELF, %eax 14445 movl rPC, OUT_ARG0(%esp) 14446 movl %eax, OUT_ARG1(%esp) 14447 call dvmCheckInst # (dPC, self) 14448 movl rSELF, %ecx 14449 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14450 jmp *dvmAsmInstructionStart+(173*4) 14451 14452/* ------------------------------ */ 14453.L_ALT_OP_DIV_DOUBLE: /* 0xae */ 14454/* File: x86/ALT_STUB.S */ 14455/* 14456 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14457 * any interesting requests and then jump to the real instruction 14458 * handler. Unlike the Arm handler, we can't do this as a tail call 14459 * because rIBASE is caller save and we need to reload it. 14460 */ 14461 movl rSELF, %eax 14462 movl rPC, OUT_ARG0(%esp) 14463 movl %eax, OUT_ARG1(%esp) 14464 call dvmCheckInst # (dPC, self) 14465 movl rSELF, %ecx 14466 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14467 jmp *dvmAsmInstructionStart+(174*4) 14468 14469/* ------------------------------ */ 14470.L_ALT_OP_REM_DOUBLE: /* 0xaf */ 14471/* File: x86/ALT_STUB.S */ 14472/* 14473 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14474 * any interesting requests and then jump to the real instruction 14475 * handler. Unlike the Arm handler, we can't do this as a tail call 14476 * because rIBASE is caller save and we need to reload it. 14477 */ 14478 movl rSELF, %eax 14479 movl rPC, OUT_ARG0(%esp) 14480 movl %eax, OUT_ARG1(%esp) 14481 call dvmCheckInst # (dPC, self) 14482 movl rSELF, %ecx 14483 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14484 jmp *dvmAsmInstructionStart+(175*4) 14485 14486/* ------------------------------ */ 14487.L_ALT_OP_ADD_INT_2ADDR: /* 0xb0 */ 14488/* File: x86/ALT_STUB.S */ 14489/* 14490 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14491 * any interesting requests and then jump to the real instruction 14492 * handler. Unlike the Arm handler, we can't do this as a tail call 14493 * because rIBASE is caller save and we need to reload it. 14494 */ 14495 movl rSELF, %eax 14496 movl rPC, OUT_ARG0(%esp) 14497 movl %eax, OUT_ARG1(%esp) 14498 call dvmCheckInst # (dPC, self) 14499 movl rSELF, %ecx 14500 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14501 jmp *dvmAsmInstructionStart+(176*4) 14502 14503/* ------------------------------ */ 14504.L_ALT_OP_SUB_INT_2ADDR: /* 0xb1 */ 14505/* File: x86/ALT_STUB.S */ 14506/* 14507 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14508 * any interesting requests and then jump to the real instruction 14509 * handler. Unlike the Arm handler, we can't do this as a tail call 14510 * because rIBASE is caller save and we need to reload it. 14511 */ 14512 movl rSELF, %eax 14513 movl rPC, OUT_ARG0(%esp) 14514 movl %eax, OUT_ARG1(%esp) 14515 call dvmCheckInst # (dPC, self) 14516 movl rSELF, %ecx 14517 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14518 jmp *dvmAsmInstructionStart+(177*4) 14519 14520/* ------------------------------ */ 14521.L_ALT_OP_MUL_INT_2ADDR: /* 0xb2 */ 14522/* File: x86/ALT_STUB.S */ 14523/* 14524 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14525 * any interesting requests and then jump to the real instruction 14526 * handler. Unlike the Arm handler, we can't do this as a tail call 14527 * because rIBASE is caller save and we need to reload it. 14528 */ 14529 movl rSELF, %eax 14530 movl rPC, OUT_ARG0(%esp) 14531 movl %eax, OUT_ARG1(%esp) 14532 call dvmCheckInst # (dPC, self) 14533 movl rSELF, %ecx 14534 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14535 jmp *dvmAsmInstructionStart+(178*4) 14536 14537/* ------------------------------ */ 14538.L_ALT_OP_DIV_INT_2ADDR: /* 0xb3 */ 14539/* File: x86/ALT_STUB.S */ 14540/* 14541 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14542 * any interesting requests and then jump to the real instruction 14543 * handler. Unlike the Arm handler, we can't do this as a tail call 14544 * because rIBASE is caller save and we need to reload it. 14545 */ 14546 movl rSELF, %eax 14547 movl rPC, OUT_ARG0(%esp) 14548 movl %eax, OUT_ARG1(%esp) 14549 call dvmCheckInst # (dPC, self) 14550 movl rSELF, %ecx 14551 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14552 jmp *dvmAsmInstructionStart+(179*4) 14553 14554/* ------------------------------ */ 14555.L_ALT_OP_REM_INT_2ADDR: /* 0xb4 */ 14556/* File: x86/ALT_STUB.S */ 14557/* 14558 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14559 * any interesting requests and then jump to the real instruction 14560 * handler. Unlike the Arm handler, we can't do this as a tail call 14561 * because rIBASE is caller save and we need to reload it. 14562 */ 14563 movl rSELF, %eax 14564 movl rPC, OUT_ARG0(%esp) 14565 movl %eax, OUT_ARG1(%esp) 14566 call dvmCheckInst # (dPC, self) 14567 movl rSELF, %ecx 14568 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14569 jmp *dvmAsmInstructionStart+(180*4) 14570 14571/* ------------------------------ */ 14572.L_ALT_OP_AND_INT_2ADDR: /* 0xb5 */ 14573/* File: x86/ALT_STUB.S */ 14574/* 14575 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14576 * any interesting requests and then jump to the real instruction 14577 * handler. Unlike the Arm handler, we can't do this as a tail call 14578 * because rIBASE is caller save and we need to reload it. 14579 */ 14580 movl rSELF, %eax 14581 movl rPC, OUT_ARG0(%esp) 14582 movl %eax, OUT_ARG1(%esp) 14583 call dvmCheckInst # (dPC, self) 14584 movl rSELF, %ecx 14585 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14586 jmp *dvmAsmInstructionStart+(181*4) 14587 14588/* ------------------------------ */ 14589.L_ALT_OP_OR_INT_2ADDR: /* 0xb6 */ 14590/* File: x86/ALT_STUB.S */ 14591/* 14592 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14593 * any interesting requests and then jump to the real instruction 14594 * handler. Unlike the Arm handler, we can't do this as a tail call 14595 * because rIBASE is caller save and we need to reload it. 14596 */ 14597 movl rSELF, %eax 14598 movl rPC, OUT_ARG0(%esp) 14599 movl %eax, OUT_ARG1(%esp) 14600 call dvmCheckInst # (dPC, self) 14601 movl rSELF, %ecx 14602 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14603 jmp *dvmAsmInstructionStart+(182*4) 14604 14605/* ------------------------------ */ 14606.L_ALT_OP_XOR_INT_2ADDR: /* 0xb7 */ 14607/* File: x86/ALT_STUB.S */ 14608/* 14609 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14610 * any interesting requests and then jump to the real instruction 14611 * handler. Unlike the Arm handler, we can't do this as a tail call 14612 * because rIBASE is caller save and we need to reload it. 14613 */ 14614 movl rSELF, %eax 14615 movl rPC, OUT_ARG0(%esp) 14616 movl %eax, OUT_ARG1(%esp) 14617 call dvmCheckInst # (dPC, self) 14618 movl rSELF, %ecx 14619 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14620 jmp *dvmAsmInstructionStart+(183*4) 14621 14622/* ------------------------------ */ 14623.L_ALT_OP_SHL_INT_2ADDR: /* 0xb8 */ 14624/* File: x86/ALT_STUB.S */ 14625/* 14626 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14627 * any interesting requests and then jump to the real instruction 14628 * handler. Unlike the Arm handler, we can't do this as a tail call 14629 * because rIBASE is caller save and we need to reload it. 14630 */ 14631 movl rSELF, %eax 14632 movl rPC, OUT_ARG0(%esp) 14633 movl %eax, OUT_ARG1(%esp) 14634 call dvmCheckInst # (dPC, self) 14635 movl rSELF, %ecx 14636 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14637 jmp *dvmAsmInstructionStart+(184*4) 14638 14639/* ------------------------------ */ 14640.L_ALT_OP_SHR_INT_2ADDR: /* 0xb9 */ 14641/* File: x86/ALT_STUB.S */ 14642/* 14643 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14644 * any interesting requests and then jump to the real instruction 14645 * handler. Unlike the Arm handler, we can't do this as a tail call 14646 * because rIBASE is caller save and we need to reload it. 14647 */ 14648 movl rSELF, %eax 14649 movl rPC, OUT_ARG0(%esp) 14650 movl %eax, OUT_ARG1(%esp) 14651 call dvmCheckInst # (dPC, self) 14652 movl rSELF, %ecx 14653 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14654 jmp *dvmAsmInstructionStart+(185*4) 14655 14656/* ------------------------------ */ 14657.L_ALT_OP_USHR_INT_2ADDR: /* 0xba */ 14658/* File: x86/ALT_STUB.S */ 14659/* 14660 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14661 * any interesting requests and then jump to the real instruction 14662 * handler. Unlike the Arm handler, we can't do this as a tail call 14663 * because rIBASE is caller save and we need to reload it. 14664 */ 14665 movl rSELF, %eax 14666 movl rPC, OUT_ARG0(%esp) 14667 movl %eax, OUT_ARG1(%esp) 14668 call dvmCheckInst # (dPC, self) 14669 movl rSELF, %ecx 14670 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14671 jmp *dvmAsmInstructionStart+(186*4) 14672 14673/* ------------------------------ */ 14674.L_ALT_OP_ADD_LONG_2ADDR: /* 0xbb */ 14675/* File: x86/ALT_STUB.S */ 14676/* 14677 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14678 * any interesting requests and then jump to the real instruction 14679 * handler. Unlike the Arm handler, we can't do this as a tail call 14680 * because rIBASE is caller save and we need to reload it. 14681 */ 14682 movl rSELF, %eax 14683 movl rPC, OUT_ARG0(%esp) 14684 movl %eax, OUT_ARG1(%esp) 14685 call dvmCheckInst # (dPC, self) 14686 movl rSELF, %ecx 14687 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14688 jmp *dvmAsmInstructionStart+(187*4) 14689 14690/* ------------------------------ */ 14691.L_ALT_OP_SUB_LONG_2ADDR: /* 0xbc */ 14692/* File: x86/ALT_STUB.S */ 14693/* 14694 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14695 * any interesting requests and then jump to the real instruction 14696 * handler. Unlike the Arm handler, we can't do this as a tail call 14697 * because rIBASE is caller save and we need to reload it. 14698 */ 14699 movl rSELF, %eax 14700 movl rPC, OUT_ARG0(%esp) 14701 movl %eax, OUT_ARG1(%esp) 14702 call dvmCheckInst # (dPC, self) 14703 movl rSELF, %ecx 14704 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14705 jmp *dvmAsmInstructionStart+(188*4) 14706 14707/* ------------------------------ */ 14708.L_ALT_OP_MUL_LONG_2ADDR: /* 0xbd */ 14709/* File: x86/ALT_STUB.S */ 14710/* 14711 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14712 * any interesting requests and then jump to the real instruction 14713 * handler. Unlike the Arm handler, we can't do this as a tail call 14714 * because rIBASE is caller save and we need to reload it. 14715 */ 14716 movl rSELF, %eax 14717 movl rPC, OUT_ARG0(%esp) 14718 movl %eax, OUT_ARG1(%esp) 14719 call dvmCheckInst # (dPC, self) 14720 movl rSELF, %ecx 14721 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14722 jmp *dvmAsmInstructionStart+(189*4) 14723 14724/* ------------------------------ */ 14725.L_ALT_OP_DIV_LONG_2ADDR: /* 0xbe */ 14726/* File: x86/ALT_STUB.S */ 14727/* 14728 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14729 * any interesting requests and then jump to the real instruction 14730 * handler. Unlike the Arm handler, we can't do this as a tail call 14731 * because rIBASE is caller save and we need to reload it. 14732 */ 14733 movl rSELF, %eax 14734 movl rPC, OUT_ARG0(%esp) 14735 movl %eax, OUT_ARG1(%esp) 14736 call dvmCheckInst # (dPC, self) 14737 movl rSELF, %ecx 14738 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14739 jmp *dvmAsmInstructionStart+(190*4) 14740 14741/* ------------------------------ */ 14742.L_ALT_OP_REM_LONG_2ADDR: /* 0xbf */ 14743/* File: x86/ALT_STUB.S */ 14744/* 14745 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14746 * any interesting requests and then jump to the real instruction 14747 * handler. Unlike the Arm handler, we can't do this as a tail call 14748 * because rIBASE is caller save and we need to reload it. 14749 */ 14750 movl rSELF, %eax 14751 movl rPC, OUT_ARG0(%esp) 14752 movl %eax, OUT_ARG1(%esp) 14753 call dvmCheckInst # (dPC, self) 14754 movl rSELF, %ecx 14755 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14756 jmp *dvmAsmInstructionStart+(191*4) 14757 14758/* ------------------------------ */ 14759.L_ALT_OP_AND_LONG_2ADDR: /* 0xc0 */ 14760/* File: x86/ALT_STUB.S */ 14761/* 14762 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14763 * any interesting requests and then jump to the real instruction 14764 * handler. Unlike the Arm handler, we can't do this as a tail call 14765 * because rIBASE is caller save and we need to reload it. 14766 */ 14767 movl rSELF, %eax 14768 movl rPC, OUT_ARG0(%esp) 14769 movl %eax, OUT_ARG1(%esp) 14770 call dvmCheckInst # (dPC, self) 14771 movl rSELF, %ecx 14772 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14773 jmp *dvmAsmInstructionStart+(192*4) 14774 14775/* ------------------------------ */ 14776.L_ALT_OP_OR_LONG_2ADDR: /* 0xc1 */ 14777/* File: x86/ALT_STUB.S */ 14778/* 14779 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14780 * any interesting requests and then jump to the real instruction 14781 * handler. Unlike the Arm handler, we can't do this as a tail call 14782 * because rIBASE is caller save and we need to reload it. 14783 */ 14784 movl rSELF, %eax 14785 movl rPC, OUT_ARG0(%esp) 14786 movl %eax, OUT_ARG1(%esp) 14787 call dvmCheckInst # (dPC, self) 14788 movl rSELF, %ecx 14789 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14790 jmp *dvmAsmInstructionStart+(193*4) 14791 14792/* ------------------------------ */ 14793.L_ALT_OP_XOR_LONG_2ADDR: /* 0xc2 */ 14794/* File: x86/ALT_STUB.S */ 14795/* 14796 * Inter-instruction transfer stub. Call out to dvmCheckInst 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 movl rSELF, %eax 14802 movl rPC, OUT_ARG0(%esp) 14803 movl %eax, OUT_ARG1(%esp) 14804 call dvmCheckInst # (dPC, self) 14805 movl rSELF, %ecx 14806 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14807 jmp *dvmAsmInstructionStart+(194*4) 14808 14809/* ------------------------------ */ 14810.L_ALT_OP_SHL_LONG_2ADDR: /* 0xc3 */ 14811/* File: x86/ALT_STUB.S */ 14812/* 14813 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14814 * any interesting requests and then jump to the real instruction 14815 * handler. Unlike the Arm handler, we can't do this as a tail call 14816 * because rIBASE is caller save and we need to reload it. 14817 */ 14818 movl rSELF, %eax 14819 movl rPC, OUT_ARG0(%esp) 14820 movl %eax, OUT_ARG1(%esp) 14821 call dvmCheckInst # (dPC, self) 14822 movl rSELF, %ecx 14823 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14824 jmp *dvmAsmInstructionStart+(195*4) 14825 14826/* ------------------------------ */ 14827.L_ALT_OP_SHR_LONG_2ADDR: /* 0xc4 */ 14828/* File: x86/ALT_STUB.S */ 14829/* 14830 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14831 * any interesting requests and then jump to the real instruction 14832 * handler. Unlike the Arm handler, we can't do this as a tail call 14833 * because rIBASE is caller save and we need to reload it. 14834 */ 14835 movl rSELF, %eax 14836 movl rPC, OUT_ARG0(%esp) 14837 movl %eax, OUT_ARG1(%esp) 14838 call dvmCheckInst # (dPC, self) 14839 movl rSELF, %ecx 14840 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14841 jmp *dvmAsmInstructionStart+(196*4) 14842 14843/* ------------------------------ */ 14844.L_ALT_OP_USHR_LONG_2ADDR: /* 0xc5 */ 14845/* File: x86/ALT_STUB.S */ 14846/* 14847 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14848 * any interesting requests and then jump to the real instruction 14849 * handler. Unlike the Arm handler, we can't do this as a tail call 14850 * because rIBASE is caller save and we need to reload it. 14851 */ 14852 movl rSELF, %eax 14853 movl rPC, OUT_ARG0(%esp) 14854 movl %eax, OUT_ARG1(%esp) 14855 call dvmCheckInst # (dPC, self) 14856 movl rSELF, %ecx 14857 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14858 jmp *dvmAsmInstructionStart+(197*4) 14859 14860/* ------------------------------ */ 14861.L_ALT_OP_ADD_FLOAT_2ADDR: /* 0xc6 */ 14862/* File: x86/ALT_STUB.S */ 14863/* 14864 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14865 * any interesting requests and then jump to the real instruction 14866 * handler. Unlike the Arm handler, we can't do this as a tail call 14867 * because rIBASE is caller save and we need to reload it. 14868 */ 14869 movl rSELF, %eax 14870 movl rPC, OUT_ARG0(%esp) 14871 movl %eax, OUT_ARG1(%esp) 14872 call dvmCheckInst # (dPC, self) 14873 movl rSELF, %ecx 14874 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14875 jmp *dvmAsmInstructionStart+(198*4) 14876 14877/* ------------------------------ */ 14878.L_ALT_OP_SUB_FLOAT_2ADDR: /* 0xc7 */ 14879/* File: x86/ALT_STUB.S */ 14880/* 14881 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14882 * any interesting requests and then jump to the real instruction 14883 * handler. Unlike the Arm handler, we can't do this as a tail call 14884 * because rIBASE is caller save and we need to reload it. 14885 */ 14886 movl rSELF, %eax 14887 movl rPC, OUT_ARG0(%esp) 14888 movl %eax, OUT_ARG1(%esp) 14889 call dvmCheckInst # (dPC, self) 14890 movl rSELF, %ecx 14891 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14892 jmp *dvmAsmInstructionStart+(199*4) 14893 14894/* ------------------------------ */ 14895.L_ALT_OP_MUL_FLOAT_2ADDR: /* 0xc8 */ 14896/* File: x86/ALT_STUB.S */ 14897/* 14898 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14899 * any interesting requests and then jump to the real instruction 14900 * handler. Unlike the Arm handler, we can't do this as a tail call 14901 * because rIBASE is caller save and we need to reload it. 14902 */ 14903 movl rSELF, %eax 14904 movl rPC, OUT_ARG0(%esp) 14905 movl %eax, OUT_ARG1(%esp) 14906 call dvmCheckInst # (dPC, self) 14907 movl rSELF, %ecx 14908 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14909 jmp *dvmAsmInstructionStart+(200*4) 14910 14911/* ------------------------------ */ 14912.L_ALT_OP_DIV_FLOAT_2ADDR: /* 0xc9 */ 14913/* File: x86/ALT_STUB.S */ 14914/* 14915 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14916 * any interesting requests and then jump to the real instruction 14917 * handler. Unlike the Arm handler, we can't do this as a tail call 14918 * because rIBASE is caller save and we need to reload it. 14919 */ 14920 movl rSELF, %eax 14921 movl rPC, OUT_ARG0(%esp) 14922 movl %eax, OUT_ARG1(%esp) 14923 call dvmCheckInst # (dPC, self) 14924 movl rSELF, %ecx 14925 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14926 jmp *dvmAsmInstructionStart+(201*4) 14927 14928/* ------------------------------ */ 14929.L_ALT_OP_REM_FLOAT_2ADDR: /* 0xca */ 14930/* File: x86/ALT_STUB.S */ 14931/* 14932 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14933 * any interesting requests and then jump to the real instruction 14934 * handler. Unlike the Arm handler, we can't do this as a tail call 14935 * because rIBASE is caller save and we need to reload it. 14936 */ 14937 movl rSELF, %eax 14938 movl rPC, OUT_ARG0(%esp) 14939 movl %eax, OUT_ARG1(%esp) 14940 call dvmCheckInst # (dPC, self) 14941 movl rSELF, %ecx 14942 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14943 jmp *dvmAsmInstructionStart+(202*4) 14944 14945/* ------------------------------ */ 14946.L_ALT_OP_ADD_DOUBLE_2ADDR: /* 0xcb */ 14947/* File: x86/ALT_STUB.S */ 14948/* 14949 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14950 * any interesting requests and then jump to the real instruction 14951 * handler. Unlike the Arm handler, we can't do this as a tail call 14952 * because rIBASE is caller save and we need to reload it. 14953 */ 14954 movl rSELF, %eax 14955 movl rPC, OUT_ARG0(%esp) 14956 movl %eax, OUT_ARG1(%esp) 14957 call dvmCheckInst # (dPC, self) 14958 movl rSELF, %ecx 14959 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14960 jmp *dvmAsmInstructionStart+(203*4) 14961 14962/* ------------------------------ */ 14963.L_ALT_OP_SUB_DOUBLE_2ADDR: /* 0xcc */ 14964/* File: x86/ALT_STUB.S */ 14965/* 14966 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14967 * any interesting requests and then jump to the real instruction 14968 * handler. Unlike the Arm handler, we can't do this as a tail call 14969 * because rIBASE is caller save and we need to reload it. 14970 */ 14971 movl rSELF, %eax 14972 movl rPC, OUT_ARG0(%esp) 14973 movl %eax, OUT_ARG1(%esp) 14974 call dvmCheckInst # (dPC, self) 14975 movl rSELF, %ecx 14976 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14977 jmp *dvmAsmInstructionStart+(204*4) 14978 14979/* ------------------------------ */ 14980.L_ALT_OP_MUL_DOUBLE_2ADDR: /* 0xcd */ 14981/* File: x86/ALT_STUB.S */ 14982/* 14983 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 14984 * any interesting requests and then jump to the real instruction 14985 * handler. Unlike the Arm handler, we can't do this as a tail call 14986 * because rIBASE is caller save and we need to reload it. 14987 */ 14988 movl rSELF, %eax 14989 movl rPC, OUT_ARG0(%esp) 14990 movl %eax, OUT_ARG1(%esp) 14991 call dvmCheckInst # (dPC, self) 14992 movl rSELF, %ecx 14993 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 14994 jmp *dvmAsmInstructionStart+(205*4) 14995 14996/* ------------------------------ */ 14997.L_ALT_OP_DIV_DOUBLE_2ADDR: /* 0xce */ 14998/* File: x86/ALT_STUB.S */ 14999/* 15000 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15001 * any interesting requests and then jump to the real instruction 15002 * handler. Unlike the Arm handler, we can't do this as a tail call 15003 * because rIBASE is caller save and we need to reload it. 15004 */ 15005 movl rSELF, %eax 15006 movl rPC, OUT_ARG0(%esp) 15007 movl %eax, OUT_ARG1(%esp) 15008 call dvmCheckInst # (dPC, self) 15009 movl rSELF, %ecx 15010 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15011 jmp *dvmAsmInstructionStart+(206*4) 15012 15013/* ------------------------------ */ 15014.L_ALT_OP_REM_DOUBLE_2ADDR: /* 0xcf */ 15015/* File: x86/ALT_STUB.S */ 15016/* 15017 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15018 * any interesting requests and then jump to the real instruction 15019 * handler. Unlike the Arm handler, we can't do this as a tail call 15020 * because rIBASE is caller save and we need to reload it. 15021 */ 15022 movl rSELF, %eax 15023 movl rPC, OUT_ARG0(%esp) 15024 movl %eax, OUT_ARG1(%esp) 15025 call dvmCheckInst # (dPC, self) 15026 movl rSELF, %ecx 15027 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15028 jmp *dvmAsmInstructionStart+(207*4) 15029 15030/* ------------------------------ */ 15031.L_ALT_OP_ADD_INT_LIT16: /* 0xd0 */ 15032/* File: x86/ALT_STUB.S */ 15033/* 15034 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15035 * any interesting requests and then jump to the real instruction 15036 * handler. Unlike the Arm handler, we can't do this as a tail call 15037 * because rIBASE is caller save and we need to reload it. 15038 */ 15039 movl rSELF, %eax 15040 movl rPC, OUT_ARG0(%esp) 15041 movl %eax, OUT_ARG1(%esp) 15042 call dvmCheckInst # (dPC, self) 15043 movl rSELF, %ecx 15044 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15045 jmp *dvmAsmInstructionStart+(208*4) 15046 15047/* ------------------------------ */ 15048.L_ALT_OP_RSUB_INT: /* 0xd1 */ 15049/* File: x86/ALT_STUB.S */ 15050/* 15051 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15052 * any interesting requests and then jump to the real instruction 15053 * handler. Unlike the Arm handler, we can't do this as a tail call 15054 * because rIBASE is caller save and we need to reload it. 15055 */ 15056 movl rSELF, %eax 15057 movl rPC, OUT_ARG0(%esp) 15058 movl %eax, OUT_ARG1(%esp) 15059 call dvmCheckInst # (dPC, self) 15060 movl rSELF, %ecx 15061 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15062 jmp *dvmAsmInstructionStart+(209*4) 15063 15064/* ------------------------------ */ 15065.L_ALT_OP_MUL_INT_LIT16: /* 0xd2 */ 15066/* File: x86/ALT_STUB.S */ 15067/* 15068 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15069 * any interesting requests and then jump to the real instruction 15070 * handler. Unlike the Arm handler, we can't do this as a tail call 15071 * because rIBASE is caller save and we need to reload it. 15072 */ 15073 movl rSELF, %eax 15074 movl rPC, OUT_ARG0(%esp) 15075 movl %eax, OUT_ARG1(%esp) 15076 call dvmCheckInst # (dPC, self) 15077 movl rSELF, %ecx 15078 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15079 jmp *dvmAsmInstructionStart+(210*4) 15080 15081/* ------------------------------ */ 15082.L_ALT_OP_DIV_INT_LIT16: /* 0xd3 */ 15083/* File: x86/ALT_STUB.S */ 15084/* 15085 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15086 * any interesting requests and then jump to the real instruction 15087 * handler. Unlike the Arm handler, we can't do this as a tail call 15088 * because rIBASE is caller save and we need to reload it. 15089 */ 15090 movl rSELF, %eax 15091 movl rPC, OUT_ARG0(%esp) 15092 movl %eax, OUT_ARG1(%esp) 15093 call dvmCheckInst # (dPC, self) 15094 movl rSELF, %ecx 15095 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15096 jmp *dvmAsmInstructionStart+(211*4) 15097 15098/* ------------------------------ */ 15099.L_ALT_OP_REM_INT_LIT16: /* 0xd4 */ 15100/* File: x86/ALT_STUB.S */ 15101/* 15102 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15103 * any interesting requests and then jump to the real instruction 15104 * handler. Unlike the Arm handler, we can't do this as a tail call 15105 * because rIBASE is caller save and we need to reload it. 15106 */ 15107 movl rSELF, %eax 15108 movl rPC, OUT_ARG0(%esp) 15109 movl %eax, OUT_ARG1(%esp) 15110 call dvmCheckInst # (dPC, self) 15111 movl rSELF, %ecx 15112 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15113 jmp *dvmAsmInstructionStart+(212*4) 15114 15115/* ------------------------------ */ 15116.L_ALT_OP_AND_INT_LIT16: /* 0xd5 */ 15117/* File: x86/ALT_STUB.S */ 15118/* 15119 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15120 * any interesting requests and then jump to the real instruction 15121 * handler. Unlike the Arm handler, we can't do this as a tail call 15122 * because rIBASE is caller save and we need to reload it. 15123 */ 15124 movl rSELF, %eax 15125 movl rPC, OUT_ARG0(%esp) 15126 movl %eax, OUT_ARG1(%esp) 15127 call dvmCheckInst # (dPC, self) 15128 movl rSELF, %ecx 15129 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15130 jmp *dvmAsmInstructionStart+(213*4) 15131 15132/* ------------------------------ */ 15133.L_ALT_OP_OR_INT_LIT16: /* 0xd6 */ 15134/* File: x86/ALT_STUB.S */ 15135/* 15136 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15137 * any interesting requests and then jump to the real instruction 15138 * handler. Unlike the Arm handler, we can't do this as a tail call 15139 * because rIBASE is caller save and we need to reload it. 15140 */ 15141 movl rSELF, %eax 15142 movl rPC, OUT_ARG0(%esp) 15143 movl %eax, OUT_ARG1(%esp) 15144 call dvmCheckInst # (dPC, self) 15145 movl rSELF, %ecx 15146 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15147 jmp *dvmAsmInstructionStart+(214*4) 15148 15149/* ------------------------------ */ 15150.L_ALT_OP_XOR_INT_LIT16: /* 0xd7 */ 15151/* File: x86/ALT_STUB.S */ 15152/* 15153 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15154 * any interesting requests and then jump to the real instruction 15155 * handler. Unlike the Arm handler, we can't do this as a tail call 15156 * because rIBASE is caller save and we need to reload it. 15157 */ 15158 movl rSELF, %eax 15159 movl rPC, OUT_ARG0(%esp) 15160 movl %eax, OUT_ARG1(%esp) 15161 call dvmCheckInst # (dPC, self) 15162 movl rSELF, %ecx 15163 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15164 jmp *dvmAsmInstructionStart+(215*4) 15165 15166/* ------------------------------ */ 15167.L_ALT_OP_ADD_INT_LIT8: /* 0xd8 */ 15168/* File: x86/ALT_STUB.S */ 15169/* 15170 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15171 * any interesting requests and then jump to the real instruction 15172 * handler. Unlike the Arm handler, we can't do this as a tail call 15173 * because rIBASE is caller save and we need to reload it. 15174 */ 15175 movl rSELF, %eax 15176 movl rPC, OUT_ARG0(%esp) 15177 movl %eax, OUT_ARG1(%esp) 15178 call dvmCheckInst # (dPC, self) 15179 movl rSELF, %ecx 15180 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15181 jmp *dvmAsmInstructionStart+(216*4) 15182 15183/* ------------------------------ */ 15184.L_ALT_OP_RSUB_INT_LIT8: /* 0xd9 */ 15185/* File: x86/ALT_STUB.S */ 15186/* 15187 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15188 * any interesting requests and then jump to the real instruction 15189 * handler. Unlike the Arm handler, we can't do this as a tail call 15190 * because rIBASE is caller save and we need to reload it. 15191 */ 15192 movl rSELF, %eax 15193 movl rPC, OUT_ARG0(%esp) 15194 movl %eax, OUT_ARG1(%esp) 15195 call dvmCheckInst # (dPC, self) 15196 movl rSELF, %ecx 15197 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15198 jmp *dvmAsmInstructionStart+(217*4) 15199 15200/* ------------------------------ */ 15201.L_ALT_OP_MUL_INT_LIT8: /* 0xda */ 15202/* File: x86/ALT_STUB.S */ 15203/* 15204 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15205 * any interesting requests and then jump to the real instruction 15206 * handler. Unlike the Arm handler, we can't do this as a tail call 15207 * because rIBASE is caller save and we need to reload it. 15208 */ 15209 movl rSELF, %eax 15210 movl rPC, OUT_ARG0(%esp) 15211 movl %eax, OUT_ARG1(%esp) 15212 call dvmCheckInst # (dPC, self) 15213 movl rSELF, %ecx 15214 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15215 jmp *dvmAsmInstructionStart+(218*4) 15216 15217/* ------------------------------ */ 15218.L_ALT_OP_DIV_INT_LIT8: /* 0xdb */ 15219/* File: x86/ALT_STUB.S */ 15220/* 15221 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15222 * any interesting requests and then jump to the real instruction 15223 * handler. Unlike the Arm handler, we can't do this as a tail call 15224 * because rIBASE is caller save and we need to reload it. 15225 */ 15226 movl rSELF, %eax 15227 movl rPC, OUT_ARG0(%esp) 15228 movl %eax, OUT_ARG1(%esp) 15229 call dvmCheckInst # (dPC, self) 15230 movl rSELF, %ecx 15231 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15232 jmp *dvmAsmInstructionStart+(219*4) 15233 15234/* ------------------------------ */ 15235.L_ALT_OP_REM_INT_LIT8: /* 0xdc */ 15236/* File: x86/ALT_STUB.S */ 15237/* 15238 * Inter-instruction transfer stub. Call out to dvmCheckInst 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 movl rSELF, %eax 15244 movl rPC, OUT_ARG0(%esp) 15245 movl %eax, OUT_ARG1(%esp) 15246 call dvmCheckInst # (dPC, self) 15247 movl rSELF, %ecx 15248 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15249 jmp *dvmAsmInstructionStart+(220*4) 15250 15251/* ------------------------------ */ 15252.L_ALT_OP_AND_INT_LIT8: /* 0xdd */ 15253/* File: x86/ALT_STUB.S */ 15254/* 15255 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15256 * any interesting requests and then jump to the real instruction 15257 * handler. Unlike the Arm handler, we can't do this as a tail call 15258 * because rIBASE is caller save and we need to reload it. 15259 */ 15260 movl rSELF, %eax 15261 movl rPC, OUT_ARG0(%esp) 15262 movl %eax, OUT_ARG1(%esp) 15263 call dvmCheckInst # (dPC, self) 15264 movl rSELF, %ecx 15265 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15266 jmp *dvmAsmInstructionStart+(221*4) 15267 15268/* ------------------------------ */ 15269.L_ALT_OP_OR_INT_LIT8: /* 0xde */ 15270/* File: x86/ALT_STUB.S */ 15271/* 15272 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15273 * any interesting requests and then jump to the real instruction 15274 * handler. Unlike the Arm handler, we can't do this as a tail call 15275 * because rIBASE is caller save and we need to reload it. 15276 */ 15277 movl rSELF, %eax 15278 movl rPC, OUT_ARG0(%esp) 15279 movl %eax, OUT_ARG1(%esp) 15280 call dvmCheckInst # (dPC, self) 15281 movl rSELF, %ecx 15282 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15283 jmp *dvmAsmInstructionStart+(222*4) 15284 15285/* ------------------------------ */ 15286.L_ALT_OP_XOR_INT_LIT8: /* 0xdf */ 15287/* File: x86/ALT_STUB.S */ 15288/* 15289 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15290 * any interesting requests and then jump to the real instruction 15291 * handler. Unlike the Arm handler, we can't do this as a tail call 15292 * because rIBASE is caller save and we need to reload it. 15293 */ 15294 movl rSELF, %eax 15295 movl rPC, OUT_ARG0(%esp) 15296 movl %eax, OUT_ARG1(%esp) 15297 call dvmCheckInst # (dPC, self) 15298 movl rSELF, %ecx 15299 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15300 jmp *dvmAsmInstructionStart+(223*4) 15301 15302/* ------------------------------ */ 15303.L_ALT_OP_SHL_INT_LIT8: /* 0xe0 */ 15304/* File: x86/ALT_STUB.S */ 15305/* 15306 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15307 * any interesting requests and then jump to the real instruction 15308 * handler. Unlike the Arm handler, we can't do this as a tail call 15309 * because rIBASE is caller save and we need to reload it. 15310 */ 15311 movl rSELF, %eax 15312 movl rPC, OUT_ARG0(%esp) 15313 movl %eax, OUT_ARG1(%esp) 15314 call dvmCheckInst # (dPC, self) 15315 movl rSELF, %ecx 15316 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15317 jmp *dvmAsmInstructionStart+(224*4) 15318 15319/* ------------------------------ */ 15320.L_ALT_OP_SHR_INT_LIT8: /* 0xe1 */ 15321/* File: x86/ALT_STUB.S */ 15322/* 15323 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15324 * any interesting requests and then jump to the real instruction 15325 * handler. Unlike the Arm handler, we can't do this as a tail call 15326 * because rIBASE is caller save and we need to reload it. 15327 */ 15328 movl rSELF, %eax 15329 movl rPC, OUT_ARG0(%esp) 15330 movl %eax, OUT_ARG1(%esp) 15331 call dvmCheckInst # (dPC, self) 15332 movl rSELF, %ecx 15333 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15334 jmp *dvmAsmInstructionStart+(225*4) 15335 15336/* ------------------------------ */ 15337.L_ALT_OP_USHR_INT_LIT8: /* 0xe2 */ 15338/* File: x86/ALT_STUB.S */ 15339/* 15340 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15341 * any interesting requests and then jump to the real instruction 15342 * handler. Unlike the Arm handler, we can't do this as a tail call 15343 * because rIBASE is caller save and we need to reload it. 15344 */ 15345 movl rSELF, %eax 15346 movl rPC, OUT_ARG0(%esp) 15347 movl %eax, OUT_ARG1(%esp) 15348 call dvmCheckInst # (dPC, self) 15349 movl rSELF, %ecx 15350 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15351 jmp *dvmAsmInstructionStart+(226*4) 15352 15353/* ------------------------------ */ 15354.L_ALT_OP_IGET_VOLATILE: /* 0xe3 */ 15355/* File: x86/ALT_STUB.S */ 15356/* 15357 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15358 * any interesting requests and then jump to the real instruction 15359 * handler. Unlike the Arm handler, we can't do this as a tail call 15360 * because rIBASE is caller save and we need to reload it. 15361 */ 15362 movl rSELF, %eax 15363 movl rPC, OUT_ARG0(%esp) 15364 movl %eax, OUT_ARG1(%esp) 15365 call dvmCheckInst # (dPC, self) 15366 movl rSELF, %ecx 15367 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15368 jmp *dvmAsmInstructionStart+(227*4) 15369 15370/* ------------------------------ */ 15371.L_ALT_OP_IPUT_VOLATILE: /* 0xe4 */ 15372/* File: x86/ALT_STUB.S */ 15373/* 15374 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15375 * any interesting requests and then jump to the real instruction 15376 * handler. Unlike the Arm handler, we can't do this as a tail call 15377 * because rIBASE is caller save and we need to reload it. 15378 */ 15379 movl rSELF, %eax 15380 movl rPC, OUT_ARG0(%esp) 15381 movl %eax, OUT_ARG1(%esp) 15382 call dvmCheckInst # (dPC, self) 15383 movl rSELF, %ecx 15384 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15385 jmp *dvmAsmInstructionStart+(228*4) 15386 15387/* ------------------------------ */ 15388.L_ALT_OP_SGET_VOLATILE: /* 0xe5 */ 15389/* File: x86/ALT_STUB.S */ 15390/* 15391 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15392 * any interesting requests and then jump to the real instruction 15393 * handler. Unlike the Arm handler, we can't do this as a tail call 15394 * because rIBASE is caller save and we need to reload it. 15395 */ 15396 movl rSELF, %eax 15397 movl rPC, OUT_ARG0(%esp) 15398 movl %eax, OUT_ARG1(%esp) 15399 call dvmCheckInst # (dPC, self) 15400 movl rSELF, %ecx 15401 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15402 jmp *dvmAsmInstructionStart+(229*4) 15403 15404/* ------------------------------ */ 15405.L_ALT_OP_SPUT_VOLATILE: /* 0xe6 */ 15406/* File: x86/ALT_STUB.S */ 15407/* 15408 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15409 * any interesting requests and then jump to the real instruction 15410 * handler. Unlike the Arm handler, we can't do this as a tail call 15411 * because rIBASE is caller save and we need to reload it. 15412 */ 15413 movl rSELF, %eax 15414 movl rPC, OUT_ARG0(%esp) 15415 movl %eax, OUT_ARG1(%esp) 15416 call dvmCheckInst # (dPC, self) 15417 movl rSELF, %ecx 15418 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15419 jmp *dvmAsmInstructionStart+(230*4) 15420 15421/* ------------------------------ */ 15422.L_ALT_OP_IGET_OBJECT_VOLATILE: /* 0xe7 */ 15423/* File: x86/ALT_STUB.S */ 15424/* 15425 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15426 * any interesting requests and then jump to the real instruction 15427 * handler. Unlike the Arm handler, we can't do this as a tail call 15428 * because rIBASE is caller save and we need to reload it. 15429 */ 15430 movl rSELF, %eax 15431 movl rPC, OUT_ARG0(%esp) 15432 movl %eax, OUT_ARG1(%esp) 15433 call dvmCheckInst # (dPC, self) 15434 movl rSELF, %ecx 15435 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15436 jmp *dvmAsmInstructionStart+(231*4) 15437 15438/* ------------------------------ */ 15439.L_ALT_OP_IGET_WIDE_VOLATILE: /* 0xe8 */ 15440/* File: x86/ALT_STUB.S */ 15441/* 15442 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15443 * any interesting requests and then jump to the real instruction 15444 * handler. Unlike the Arm handler, we can't do this as a tail call 15445 * because rIBASE is caller save and we need to reload it. 15446 */ 15447 movl rSELF, %eax 15448 movl rPC, OUT_ARG0(%esp) 15449 movl %eax, OUT_ARG1(%esp) 15450 call dvmCheckInst # (dPC, self) 15451 movl rSELF, %ecx 15452 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15453 jmp *dvmAsmInstructionStart+(232*4) 15454 15455/* ------------------------------ */ 15456.L_ALT_OP_IPUT_WIDE_VOLATILE: /* 0xe9 */ 15457/* File: x86/ALT_STUB.S */ 15458/* 15459 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15460 * any interesting requests and then jump to the real instruction 15461 * handler. Unlike the Arm handler, we can't do this as a tail call 15462 * because rIBASE is caller save and we need to reload it. 15463 */ 15464 movl rSELF, %eax 15465 movl rPC, OUT_ARG0(%esp) 15466 movl %eax, OUT_ARG1(%esp) 15467 call dvmCheckInst # (dPC, self) 15468 movl rSELF, %ecx 15469 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15470 jmp *dvmAsmInstructionStart+(233*4) 15471 15472/* ------------------------------ */ 15473.L_ALT_OP_SGET_WIDE_VOLATILE: /* 0xea */ 15474/* File: x86/ALT_STUB.S */ 15475/* 15476 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15477 * any interesting requests and then jump to the real instruction 15478 * handler. Unlike the Arm handler, we can't do this as a tail call 15479 * because rIBASE is caller save and we need to reload it. 15480 */ 15481 movl rSELF, %eax 15482 movl rPC, OUT_ARG0(%esp) 15483 movl %eax, OUT_ARG1(%esp) 15484 call dvmCheckInst # (dPC, self) 15485 movl rSELF, %ecx 15486 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15487 jmp *dvmAsmInstructionStart+(234*4) 15488 15489/* ------------------------------ */ 15490.L_ALT_OP_SPUT_WIDE_VOLATILE: /* 0xeb */ 15491/* File: x86/ALT_STUB.S */ 15492/* 15493 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15494 * any interesting requests and then jump to the real instruction 15495 * handler. Unlike the Arm handler, we can't do this as a tail call 15496 * because rIBASE is caller save and we need to reload it. 15497 */ 15498 movl rSELF, %eax 15499 movl rPC, OUT_ARG0(%esp) 15500 movl %eax, OUT_ARG1(%esp) 15501 call dvmCheckInst # (dPC, self) 15502 movl rSELF, %ecx 15503 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15504 jmp *dvmAsmInstructionStart+(235*4) 15505 15506/* ------------------------------ */ 15507.L_ALT_OP_BREAKPOINT: /* 0xec */ 15508/* File: x86/ALT_STUB.S */ 15509/* 15510 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15511 * any interesting requests and then jump to the real instruction 15512 * handler. Unlike the Arm handler, we can't do this as a tail call 15513 * because rIBASE is caller save and we need to reload it. 15514 */ 15515 movl rSELF, %eax 15516 movl rPC, OUT_ARG0(%esp) 15517 movl %eax, OUT_ARG1(%esp) 15518 call dvmCheckInst # (dPC, self) 15519 movl rSELF, %ecx 15520 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15521 jmp *dvmAsmInstructionStart+(236*4) 15522 15523/* ------------------------------ */ 15524.L_ALT_OP_THROW_VERIFICATION_ERROR: /* 0xed */ 15525/* File: x86/ALT_STUB.S */ 15526/* 15527 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15528 * any interesting requests and then jump to the real instruction 15529 * handler. Unlike the Arm handler, we can't do this as a tail call 15530 * because rIBASE is caller save and we need to reload it. 15531 */ 15532 movl rSELF, %eax 15533 movl rPC, OUT_ARG0(%esp) 15534 movl %eax, OUT_ARG1(%esp) 15535 call dvmCheckInst # (dPC, self) 15536 movl rSELF, %ecx 15537 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15538 jmp *dvmAsmInstructionStart+(237*4) 15539 15540/* ------------------------------ */ 15541.L_ALT_OP_EXECUTE_INLINE: /* 0xee */ 15542/* File: x86/ALT_STUB.S */ 15543/* 15544 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15545 * any interesting requests and then jump to the real instruction 15546 * handler. Unlike the Arm handler, we can't do this as a tail call 15547 * because rIBASE is caller save and we need to reload it. 15548 */ 15549 movl rSELF, %eax 15550 movl rPC, OUT_ARG0(%esp) 15551 movl %eax, OUT_ARG1(%esp) 15552 call dvmCheckInst # (dPC, self) 15553 movl rSELF, %ecx 15554 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15555 jmp *dvmAsmInstructionStart+(238*4) 15556 15557/* ------------------------------ */ 15558.L_ALT_OP_EXECUTE_INLINE_RANGE: /* 0xef */ 15559/* File: x86/ALT_STUB.S */ 15560/* 15561 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15562 * any interesting requests and then jump to the real instruction 15563 * handler. Unlike the Arm handler, we can't do this as a tail call 15564 * because rIBASE is caller save and we need to reload it. 15565 */ 15566 movl rSELF, %eax 15567 movl rPC, OUT_ARG0(%esp) 15568 movl %eax, OUT_ARG1(%esp) 15569 call dvmCheckInst # (dPC, self) 15570 movl rSELF, %ecx 15571 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15572 jmp *dvmAsmInstructionStart+(239*4) 15573 15574/* ------------------------------ */ 15575.L_ALT_OP_INVOKE_OBJECT_INIT: /* 0xf0 */ 15576/* File: x86/ALT_STUB.S */ 15577/* 15578 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15579 * any interesting requests and then jump to the real instruction 15580 * handler. Unlike the Arm handler, we can't do this as a tail call 15581 * because rIBASE is caller save and we need to reload it. 15582 */ 15583 movl rSELF, %eax 15584 movl rPC, OUT_ARG0(%esp) 15585 movl %eax, OUT_ARG1(%esp) 15586 call dvmCheckInst # (dPC, self) 15587 movl rSELF, %ecx 15588 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15589 jmp *dvmAsmInstructionStart+(240*4) 15590 15591/* ------------------------------ */ 15592.L_ALT_OP_RETURN_VOID_BARRIER: /* 0xf1 */ 15593/* File: x86/ALT_STUB.S */ 15594/* 15595 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15596 * any interesting requests and then jump to the real instruction 15597 * handler. Unlike the Arm handler, we can't do this as a tail call 15598 * because rIBASE is caller save and we need to reload it. 15599 */ 15600 movl rSELF, %eax 15601 movl rPC, OUT_ARG0(%esp) 15602 movl %eax, OUT_ARG1(%esp) 15603 call dvmCheckInst # (dPC, self) 15604 movl rSELF, %ecx 15605 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15606 jmp *dvmAsmInstructionStart+(241*4) 15607 15608/* ------------------------------ */ 15609.L_ALT_OP_IGET_QUICK: /* 0xf2 */ 15610/* File: x86/ALT_STUB.S */ 15611/* 15612 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15613 * any interesting requests and then jump to the real instruction 15614 * handler. Unlike the Arm handler, we can't do this as a tail call 15615 * because rIBASE is caller save and we need to reload it. 15616 */ 15617 movl rSELF, %eax 15618 movl rPC, OUT_ARG0(%esp) 15619 movl %eax, OUT_ARG1(%esp) 15620 call dvmCheckInst # (dPC, self) 15621 movl rSELF, %ecx 15622 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15623 jmp *dvmAsmInstructionStart+(242*4) 15624 15625/* ------------------------------ */ 15626.L_ALT_OP_IGET_WIDE_QUICK: /* 0xf3 */ 15627/* File: x86/ALT_STUB.S */ 15628/* 15629 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15630 * any interesting requests and then jump to the real instruction 15631 * handler. Unlike the Arm handler, we can't do this as a tail call 15632 * because rIBASE is caller save and we need to reload it. 15633 */ 15634 movl rSELF, %eax 15635 movl rPC, OUT_ARG0(%esp) 15636 movl %eax, OUT_ARG1(%esp) 15637 call dvmCheckInst # (dPC, self) 15638 movl rSELF, %ecx 15639 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15640 jmp *dvmAsmInstructionStart+(243*4) 15641 15642/* ------------------------------ */ 15643.L_ALT_OP_IGET_OBJECT_QUICK: /* 0xf4 */ 15644/* File: x86/ALT_STUB.S */ 15645/* 15646 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15647 * any interesting requests and then jump to the real instruction 15648 * handler. Unlike the Arm handler, we can't do this as a tail call 15649 * because rIBASE is caller save and we need to reload it. 15650 */ 15651 movl rSELF, %eax 15652 movl rPC, OUT_ARG0(%esp) 15653 movl %eax, OUT_ARG1(%esp) 15654 call dvmCheckInst # (dPC, self) 15655 movl rSELF, %ecx 15656 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15657 jmp *dvmAsmInstructionStart+(244*4) 15658 15659/* ------------------------------ */ 15660.L_ALT_OP_IPUT_QUICK: /* 0xf5 */ 15661/* File: x86/ALT_STUB.S */ 15662/* 15663 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15664 * any interesting requests and then jump to the real instruction 15665 * handler. Unlike the Arm handler, we can't do this as a tail call 15666 * because rIBASE is caller save and we need to reload it. 15667 */ 15668 movl rSELF, %eax 15669 movl rPC, OUT_ARG0(%esp) 15670 movl %eax, OUT_ARG1(%esp) 15671 call dvmCheckInst # (dPC, self) 15672 movl rSELF, %ecx 15673 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15674 jmp *dvmAsmInstructionStart+(245*4) 15675 15676/* ------------------------------ */ 15677.L_ALT_OP_IPUT_WIDE_QUICK: /* 0xf6 */ 15678/* File: x86/ALT_STUB.S */ 15679/* 15680 * Inter-instruction transfer stub. Call out to dvmCheckInst 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 movl rSELF, %eax 15686 movl rPC, OUT_ARG0(%esp) 15687 movl %eax, OUT_ARG1(%esp) 15688 call dvmCheckInst # (dPC, self) 15689 movl rSELF, %ecx 15690 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15691 jmp *dvmAsmInstructionStart+(246*4) 15692 15693/* ------------------------------ */ 15694.L_ALT_OP_IPUT_OBJECT_QUICK: /* 0xf7 */ 15695/* File: x86/ALT_STUB.S */ 15696/* 15697 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15698 * any interesting requests and then jump to the real instruction 15699 * handler. Unlike the Arm handler, we can't do this as a tail call 15700 * because rIBASE is caller save and we need to reload it. 15701 */ 15702 movl rSELF, %eax 15703 movl rPC, OUT_ARG0(%esp) 15704 movl %eax, OUT_ARG1(%esp) 15705 call dvmCheckInst # (dPC, self) 15706 movl rSELF, %ecx 15707 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15708 jmp *dvmAsmInstructionStart+(247*4) 15709 15710/* ------------------------------ */ 15711.L_ALT_OP_INVOKE_VIRTUAL_QUICK: /* 0xf8 */ 15712/* File: x86/ALT_STUB.S */ 15713/* 15714 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15715 * any interesting requests and then jump to the real instruction 15716 * handler. Unlike the Arm handler, we can't do this as a tail call 15717 * because rIBASE is caller save and we need to reload it. 15718 */ 15719 movl rSELF, %eax 15720 movl rPC, OUT_ARG0(%esp) 15721 movl %eax, OUT_ARG1(%esp) 15722 call dvmCheckInst # (dPC, self) 15723 movl rSELF, %ecx 15724 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15725 jmp *dvmAsmInstructionStart+(248*4) 15726 15727/* ------------------------------ */ 15728.L_ALT_OP_INVOKE_VIRTUAL_QUICK_RANGE: /* 0xf9 */ 15729/* File: x86/ALT_STUB.S */ 15730/* 15731 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15732 * any interesting requests and then jump to the real instruction 15733 * handler. Unlike the Arm handler, we can't do this as a tail call 15734 * because rIBASE is caller save and we need to reload it. 15735 */ 15736 movl rSELF, %eax 15737 movl rPC, OUT_ARG0(%esp) 15738 movl %eax, OUT_ARG1(%esp) 15739 call dvmCheckInst # (dPC, self) 15740 movl rSELF, %ecx 15741 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15742 jmp *dvmAsmInstructionStart+(249*4) 15743 15744/* ------------------------------ */ 15745.L_ALT_OP_INVOKE_SUPER_QUICK: /* 0xfa */ 15746/* File: x86/ALT_STUB.S */ 15747/* 15748 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15749 * any interesting requests and then jump to the real instruction 15750 * handler. Unlike the Arm handler, we can't do this as a tail call 15751 * because rIBASE is caller save and we need to reload it. 15752 */ 15753 movl rSELF, %eax 15754 movl rPC, OUT_ARG0(%esp) 15755 movl %eax, OUT_ARG1(%esp) 15756 call dvmCheckInst # (dPC, self) 15757 movl rSELF, %ecx 15758 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15759 jmp *dvmAsmInstructionStart+(250*4) 15760 15761/* ------------------------------ */ 15762.L_ALT_OP_INVOKE_SUPER_QUICK_RANGE: /* 0xfb */ 15763/* File: x86/ALT_STUB.S */ 15764/* 15765 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15766 * any interesting requests and then jump to the real instruction 15767 * handler. Unlike the Arm handler, we can't do this as a tail call 15768 * because rIBASE is caller save and we need to reload it. 15769 */ 15770 movl rSELF, %eax 15771 movl rPC, OUT_ARG0(%esp) 15772 movl %eax, OUT_ARG1(%esp) 15773 call dvmCheckInst # (dPC, self) 15774 movl rSELF, %ecx 15775 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15776 jmp *dvmAsmInstructionStart+(251*4) 15777 15778/* ------------------------------ */ 15779.L_ALT_OP_IPUT_OBJECT_VOLATILE: /* 0xfc */ 15780/* File: x86/ALT_STUB.S */ 15781/* 15782 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15783 * any interesting requests and then jump to the real instruction 15784 * handler. Unlike the Arm handler, we can't do this as a tail call 15785 * because rIBASE is caller save and we need to reload it. 15786 */ 15787 movl rSELF, %eax 15788 movl rPC, OUT_ARG0(%esp) 15789 movl %eax, OUT_ARG1(%esp) 15790 call dvmCheckInst # (dPC, self) 15791 movl rSELF, %ecx 15792 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15793 jmp *dvmAsmInstructionStart+(252*4) 15794 15795/* ------------------------------ */ 15796.L_ALT_OP_SGET_OBJECT_VOLATILE: /* 0xfd */ 15797/* File: x86/ALT_STUB.S */ 15798/* 15799 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15800 * any interesting requests and then jump to the real instruction 15801 * handler. Unlike the Arm handler, we can't do this as a tail call 15802 * because rIBASE is caller save and we need to reload it. 15803 */ 15804 movl rSELF, %eax 15805 movl rPC, OUT_ARG0(%esp) 15806 movl %eax, OUT_ARG1(%esp) 15807 call dvmCheckInst # (dPC, self) 15808 movl rSELF, %ecx 15809 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15810 jmp *dvmAsmInstructionStart+(253*4) 15811 15812/* ------------------------------ */ 15813.L_ALT_OP_SPUT_OBJECT_VOLATILE: /* 0xfe */ 15814/* File: x86/ALT_STUB.S */ 15815/* 15816 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15817 * any interesting requests and then jump to the real instruction 15818 * handler. Unlike the Arm handler, we can't do this as a tail call 15819 * because rIBASE is caller save and we need to reload it. 15820 */ 15821 movl rSELF, %eax 15822 movl rPC, OUT_ARG0(%esp) 15823 movl %eax, OUT_ARG1(%esp) 15824 call dvmCheckInst # (dPC, self) 15825 movl rSELF, %ecx 15826 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15827 jmp *dvmAsmInstructionStart+(254*4) 15828 15829/* ------------------------------ */ 15830.L_ALT_OP_DISPATCH_FF: /* 0xff */ 15831/* File: x86/ALT_OP_DISPATCH_FF.S */ 15832 leal 256(rINST),%ecx 15833 GOTO_NEXT_JUMBO_R %ecx 15834 15835/* ------------------------------ */ 15836.L_ALT_OP_CONST_CLASS_JUMBO: /* 0x100 */ 15837/* File: x86/ALT_STUB.S */ 15838/* 15839 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15840 * any interesting requests and then jump to the real instruction 15841 * handler. Unlike the Arm handler, we can't do this as a tail call 15842 * because rIBASE is caller save and we need to reload it. 15843 */ 15844 movl rSELF, %eax 15845 movl rPC, OUT_ARG0(%esp) 15846 movl %eax, OUT_ARG1(%esp) 15847 call dvmCheckInst # (dPC, self) 15848 movl rSELF, %ecx 15849 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15850 jmp *dvmAsmInstructionStart+(256*4) 15851 15852/* ------------------------------ */ 15853.L_ALT_OP_CHECK_CAST_JUMBO: /* 0x101 */ 15854/* File: x86/ALT_STUB.S */ 15855/* 15856 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15857 * any interesting requests and then jump to the real instruction 15858 * handler. Unlike the Arm handler, we can't do this as a tail call 15859 * because rIBASE is caller save and we need to reload it. 15860 */ 15861 movl rSELF, %eax 15862 movl rPC, OUT_ARG0(%esp) 15863 movl %eax, OUT_ARG1(%esp) 15864 call dvmCheckInst # (dPC, self) 15865 movl rSELF, %ecx 15866 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15867 jmp *dvmAsmInstructionStart+(257*4) 15868 15869/* ------------------------------ */ 15870.L_ALT_OP_INSTANCE_OF_JUMBO: /* 0x102 */ 15871/* File: x86/ALT_STUB.S */ 15872/* 15873 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15874 * any interesting requests and then jump to the real instruction 15875 * handler. Unlike the Arm handler, we can't do this as a tail call 15876 * because rIBASE is caller save and we need to reload it. 15877 */ 15878 movl rSELF, %eax 15879 movl rPC, OUT_ARG0(%esp) 15880 movl %eax, OUT_ARG1(%esp) 15881 call dvmCheckInst # (dPC, self) 15882 movl rSELF, %ecx 15883 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15884 jmp *dvmAsmInstructionStart+(258*4) 15885 15886/* ------------------------------ */ 15887.L_ALT_OP_NEW_INSTANCE_JUMBO: /* 0x103 */ 15888/* File: x86/ALT_STUB.S */ 15889/* 15890 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15891 * any interesting requests and then jump to the real instruction 15892 * handler. Unlike the Arm handler, we can't do this as a tail call 15893 * because rIBASE is caller save and we need to reload it. 15894 */ 15895 movl rSELF, %eax 15896 movl rPC, OUT_ARG0(%esp) 15897 movl %eax, OUT_ARG1(%esp) 15898 call dvmCheckInst # (dPC, self) 15899 movl rSELF, %ecx 15900 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15901 jmp *dvmAsmInstructionStart+(259*4) 15902 15903/* ------------------------------ */ 15904.L_ALT_OP_NEW_ARRAY_JUMBO: /* 0x104 */ 15905/* File: x86/ALT_STUB.S */ 15906/* 15907 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15908 * any interesting requests and then jump to the real instruction 15909 * handler. Unlike the Arm handler, we can't do this as a tail call 15910 * because rIBASE is caller save and we need to reload it. 15911 */ 15912 movl rSELF, %eax 15913 movl rPC, OUT_ARG0(%esp) 15914 movl %eax, OUT_ARG1(%esp) 15915 call dvmCheckInst # (dPC, self) 15916 movl rSELF, %ecx 15917 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15918 jmp *dvmAsmInstructionStart+(260*4) 15919 15920/* ------------------------------ */ 15921.L_ALT_OP_FILLED_NEW_ARRAY_JUMBO: /* 0x105 */ 15922/* File: x86/ALT_STUB.S */ 15923/* 15924 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15925 * any interesting requests and then jump to the real instruction 15926 * handler. Unlike the Arm handler, we can't do this as a tail call 15927 * because rIBASE is caller save and we need to reload it. 15928 */ 15929 movl rSELF, %eax 15930 movl rPC, OUT_ARG0(%esp) 15931 movl %eax, OUT_ARG1(%esp) 15932 call dvmCheckInst # (dPC, self) 15933 movl rSELF, %ecx 15934 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15935 jmp *dvmAsmInstructionStart+(261*4) 15936 15937/* ------------------------------ */ 15938.L_ALT_OP_IGET_JUMBO: /* 0x106 */ 15939/* File: x86/ALT_STUB.S */ 15940/* 15941 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15942 * any interesting requests and then jump to the real instruction 15943 * handler. Unlike the Arm handler, we can't do this as a tail call 15944 * because rIBASE is caller save and we need to reload it. 15945 */ 15946 movl rSELF, %eax 15947 movl rPC, OUT_ARG0(%esp) 15948 movl %eax, OUT_ARG1(%esp) 15949 call dvmCheckInst # (dPC, self) 15950 movl rSELF, %ecx 15951 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15952 jmp *dvmAsmInstructionStart+(262*4) 15953 15954/* ------------------------------ */ 15955.L_ALT_OP_IGET_WIDE_JUMBO: /* 0x107 */ 15956/* File: x86/ALT_STUB.S */ 15957/* 15958 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15959 * any interesting requests and then jump to the real instruction 15960 * handler. Unlike the Arm handler, we can't do this as a tail call 15961 * because rIBASE is caller save and we need to reload it. 15962 */ 15963 movl rSELF, %eax 15964 movl rPC, OUT_ARG0(%esp) 15965 movl %eax, OUT_ARG1(%esp) 15966 call dvmCheckInst # (dPC, self) 15967 movl rSELF, %ecx 15968 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15969 jmp *dvmAsmInstructionStart+(263*4) 15970 15971/* ------------------------------ */ 15972.L_ALT_OP_IGET_OBJECT_JUMBO: /* 0x108 */ 15973/* File: x86/ALT_STUB.S */ 15974/* 15975 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15976 * any interesting requests and then jump to the real instruction 15977 * handler. Unlike the Arm handler, we can't do this as a tail call 15978 * because rIBASE is caller save and we need to reload it. 15979 */ 15980 movl rSELF, %eax 15981 movl rPC, OUT_ARG0(%esp) 15982 movl %eax, OUT_ARG1(%esp) 15983 call dvmCheckInst # (dPC, self) 15984 movl rSELF, %ecx 15985 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 15986 jmp *dvmAsmInstructionStart+(264*4) 15987 15988/* ------------------------------ */ 15989.L_ALT_OP_IGET_BOOLEAN_JUMBO: /* 0x109 */ 15990/* File: x86/ALT_STUB.S */ 15991/* 15992 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 15993 * any interesting requests and then jump to the real instruction 15994 * handler. Unlike the Arm handler, we can't do this as a tail call 15995 * because rIBASE is caller save and we need to reload it. 15996 */ 15997 movl rSELF, %eax 15998 movl rPC, OUT_ARG0(%esp) 15999 movl %eax, OUT_ARG1(%esp) 16000 call dvmCheckInst # (dPC, self) 16001 movl rSELF, %ecx 16002 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16003 jmp *dvmAsmInstructionStart+(265*4) 16004 16005/* ------------------------------ */ 16006.L_ALT_OP_IGET_BYTE_JUMBO: /* 0x10a */ 16007/* File: x86/ALT_STUB.S */ 16008/* 16009 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16010 * any interesting requests and then jump to the real instruction 16011 * handler. Unlike the Arm handler, we can't do this as a tail call 16012 * because rIBASE is caller save and we need to reload it. 16013 */ 16014 movl rSELF, %eax 16015 movl rPC, OUT_ARG0(%esp) 16016 movl %eax, OUT_ARG1(%esp) 16017 call dvmCheckInst # (dPC, self) 16018 movl rSELF, %ecx 16019 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16020 jmp *dvmAsmInstructionStart+(266*4) 16021 16022/* ------------------------------ */ 16023.L_ALT_OP_IGET_CHAR_JUMBO: /* 0x10b */ 16024/* File: x86/ALT_STUB.S */ 16025/* 16026 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16027 * any interesting requests and then jump to the real instruction 16028 * handler. Unlike the Arm handler, we can't do this as a tail call 16029 * because rIBASE is caller save and we need to reload it. 16030 */ 16031 movl rSELF, %eax 16032 movl rPC, OUT_ARG0(%esp) 16033 movl %eax, OUT_ARG1(%esp) 16034 call dvmCheckInst # (dPC, self) 16035 movl rSELF, %ecx 16036 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16037 jmp *dvmAsmInstructionStart+(267*4) 16038 16039/* ------------------------------ */ 16040.L_ALT_OP_IGET_SHORT_JUMBO: /* 0x10c */ 16041/* File: x86/ALT_STUB.S */ 16042/* 16043 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16044 * any interesting requests and then jump to the real instruction 16045 * handler. Unlike the Arm handler, we can't do this as a tail call 16046 * because rIBASE is caller save and we need to reload it. 16047 */ 16048 movl rSELF, %eax 16049 movl rPC, OUT_ARG0(%esp) 16050 movl %eax, OUT_ARG1(%esp) 16051 call dvmCheckInst # (dPC, self) 16052 movl rSELF, %ecx 16053 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16054 jmp *dvmAsmInstructionStart+(268*4) 16055 16056/* ------------------------------ */ 16057.L_ALT_OP_IPUT_JUMBO: /* 0x10d */ 16058/* File: x86/ALT_STUB.S */ 16059/* 16060 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16061 * any interesting requests and then jump to the real instruction 16062 * handler. Unlike the Arm handler, we can't do this as a tail call 16063 * because rIBASE is caller save and we need to reload it. 16064 */ 16065 movl rSELF, %eax 16066 movl rPC, OUT_ARG0(%esp) 16067 movl %eax, OUT_ARG1(%esp) 16068 call dvmCheckInst # (dPC, self) 16069 movl rSELF, %ecx 16070 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16071 jmp *dvmAsmInstructionStart+(269*4) 16072 16073/* ------------------------------ */ 16074.L_ALT_OP_IPUT_WIDE_JUMBO: /* 0x10e */ 16075/* File: x86/ALT_STUB.S */ 16076/* 16077 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16078 * any interesting requests and then jump to the real instruction 16079 * handler. Unlike the Arm handler, we can't do this as a tail call 16080 * because rIBASE is caller save and we need to reload it. 16081 */ 16082 movl rSELF, %eax 16083 movl rPC, OUT_ARG0(%esp) 16084 movl %eax, OUT_ARG1(%esp) 16085 call dvmCheckInst # (dPC, self) 16086 movl rSELF, %ecx 16087 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16088 jmp *dvmAsmInstructionStart+(270*4) 16089 16090/* ------------------------------ */ 16091.L_ALT_OP_IPUT_OBJECT_JUMBO: /* 0x10f */ 16092/* File: x86/ALT_STUB.S */ 16093/* 16094 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16095 * any interesting requests and then jump to the real instruction 16096 * handler. Unlike the Arm handler, we can't do this as a tail call 16097 * because rIBASE is caller save and we need to reload it. 16098 */ 16099 movl rSELF, %eax 16100 movl rPC, OUT_ARG0(%esp) 16101 movl %eax, OUT_ARG1(%esp) 16102 call dvmCheckInst # (dPC, self) 16103 movl rSELF, %ecx 16104 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16105 jmp *dvmAsmInstructionStart+(271*4) 16106 16107/* ------------------------------ */ 16108.L_ALT_OP_IPUT_BOOLEAN_JUMBO: /* 0x110 */ 16109/* File: x86/ALT_STUB.S */ 16110/* 16111 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16112 * any interesting requests and then jump to the real instruction 16113 * handler. Unlike the Arm handler, we can't do this as a tail call 16114 * because rIBASE is caller save and we need to reload it. 16115 */ 16116 movl rSELF, %eax 16117 movl rPC, OUT_ARG0(%esp) 16118 movl %eax, OUT_ARG1(%esp) 16119 call dvmCheckInst # (dPC, self) 16120 movl rSELF, %ecx 16121 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16122 jmp *dvmAsmInstructionStart+(272*4) 16123 16124/* ------------------------------ */ 16125.L_ALT_OP_IPUT_BYTE_JUMBO: /* 0x111 */ 16126/* File: x86/ALT_STUB.S */ 16127/* 16128 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16129 * any interesting requests and then jump to the real instruction 16130 * handler. Unlike the Arm handler, we can't do this as a tail call 16131 * because rIBASE is caller save and we need to reload it. 16132 */ 16133 movl rSELF, %eax 16134 movl rPC, OUT_ARG0(%esp) 16135 movl %eax, OUT_ARG1(%esp) 16136 call dvmCheckInst # (dPC, self) 16137 movl rSELF, %ecx 16138 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16139 jmp *dvmAsmInstructionStart+(273*4) 16140 16141/* ------------------------------ */ 16142.L_ALT_OP_IPUT_CHAR_JUMBO: /* 0x112 */ 16143/* File: x86/ALT_STUB.S */ 16144/* 16145 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16146 * any interesting requests and then jump to the real instruction 16147 * handler. Unlike the Arm handler, we can't do this as a tail call 16148 * because rIBASE is caller save and we need to reload it. 16149 */ 16150 movl rSELF, %eax 16151 movl rPC, OUT_ARG0(%esp) 16152 movl %eax, OUT_ARG1(%esp) 16153 call dvmCheckInst # (dPC, self) 16154 movl rSELF, %ecx 16155 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16156 jmp *dvmAsmInstructionStart+(274*4) 16157 16158/* ------------------------------ */ 16159.L_ALT_OP_IPUT_SHORT_JUMBO: /* 0x113 */ 16160/* File: x86/ALT_STUB.S */ 16161/* 16162 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16163 * any interesting requests and then jump to the real instruction 16164 * handler. Unlike the Arm handler, we can't do this as a tail call 16165 * because rIBASE is caller save and we need to reload it. 16166 */ 16167 movl rSELF, %eax 16168 movl rPC, OUT_ARG0(%esp) 16169 movl %eax, OUT_ARG1(%esp) 16170 call dvmCheckInst # (dPC, self) 16171 movl rSELF, %ecx 16172 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16173 jmp *dvmAsmInstructionStart+(275*4) 16174 16175/* ------------------------------ */ 16176.L_ALT_OP_SGET_JUMBO: /* 0x114 */ 16177/* File: x86/ALT_STUB.S */ 16178/* 16179 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16180 * any interesting requests and then jump to the real instruction 16181 * handler. Unlike the Arm handler, we can't do this as a tail call 16182 * because rIBASE is caller save and we need to reload it. 16183 */ 16184 movl rSELF, %eax 16185 movl rPC, OUT_ARG0(%esp) 16186 movl %eax, OUT_ARG1(%esp) 16187 call dvmCheckInst # (dPC, self) 16188 movl rSELF, %ecx 16189 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16190 jmp *dvmAsmInstructionStart+(276*4) 16191 16192/* ------------------------------ */ 16193.L_ALT_OP_SGET_WIDE_JUMBO: /* 0x115 */ 16194/* File: x86/ALT_STUB.S */ 16195/* 16196 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16197 * any interesting requests and then jump to the real instruction 16198 * handler. Unlike the Arm handler, we can't do this as a tail call 16199 * because rIBASE is caller save and we need to reload it. 16200 */ 16201 movl rSELF, %eax 16202 movl rPC, OUT_ARG0(%esp) 16203 movl %eax, OUT_ARG1(%esp) 16204 call dvmCheckInst # (dPC, self) 16205 movl rSELF, %ecx 16206 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16207 jmp *dvmAsmInstructionStart+(277*4) 16208 16209/* ------------------------------ */ 16210.L_ALT_OP_SGET_OBJECT_JUMBO: /* 0x116 */ 16211/* File: x86/ALT_STUB.S */ 16212/* 16213 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16214 * any interesting requests and then jump to the real instruction 16215 * handler. Unlike the Arm handler, we can't do this as a tail call 16216 * because rIBASE is caller save and we need to reload it. 16217 */ 16218 movl rSELF, %eax 16219 movl rPC, OUT_ARG0(%esp) 16220 movl %eax, OUT_ARG1(%esp) 16221 call dvmCheckInst # (dPC, self) 16222 movl rSELF, %ecx 16223 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16224 jmp *dvmAsmInstructionStart+(278*4) 16225 16226/* ------------------------------ */ 16227.L_ALT_OP_SGET_BOOLEAN_JUMBO: /* 0x117 */ 16228/* File: x86/ALT_STUB.S */ 16229/* 16230 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16231 * any interesting requests and then jump to the real instruction 16232 * handler. Unlike the Arm handler, we can't do this as a tail call 16233 * because rIBASE is caller save and we need to reload it. 16234 */ 16235 movl rSELF, %eax 16236 movl rPC, OUT_ARG0(%esp) 16237 movl %eax, OUT_ARG1(%esp) 16238 call dvmCheckInst # (dPC, self) 16239 movl rSELF, %ecx 16240 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16241 jmp *dvmAsmInstructionStart+(279*4) 16242 16243/* ------------------------------ */ 16244.L_ALT_OP_SGET_BYTE_JUMBO: /* 0x118 */ 16245/* File: x86/ALT_STUB.S */ 16246/* 16247 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16248 * any interesting requests and then jump to the real instruction 16249 * handler. Unlike the Arm handler, we can't do this as a tail call 16250 * because rIBASE is caller save and we need to reload it. 16251 */ 16252 movl rSELF, %eax 16253 movl rPC, OUT_ARG0(%esp) 16254 movl %eax, OUT_ARG1(%esp) 16255 call dvmCheckInst # (dPC, self) 16256 movl rSELF, %ecx 16257 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16258 jmp *dvmAsmInstructionStart+(280*4) 16259 16260/* ------------------------------ */ 16261.L_ALT_OP_SGET_CHAR_JUMBO: /* 0x119 */ 16262/* File: x86/ALT_STUB.S */ 16263/* 16264 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16265 * any interesting requests and then jump to the real instruction 16266 * handler. Unlike the Arm handler, we can't do this as a tail call 16267 * because rIBASE is caller save and we need to reload it. 16268 */ 16269 movl rSELF, %eax 16270 movl rPC, OUT_ARG0(%esp) 16271 movl %eax, OUT_ARG1(%esp) 16272 call dvmCheckInst # (dPC, self) 16273 movl rSELF, %ecx 16274 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16275 jmp *dvmAsmInstructionStart+(281*4) 16276 16277/* ------------------------------ */ 16278.L_ALT_OP_SGET_SHORT_JUMBO: /* 0x11a */ 16279/* File: x86/ALT_STUB.S */ 16280/* 16281 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16282 * any interesting requests and then jump to the real instruction 16283 * handler. Unlike the Arm handler, we can't do this as a tail call 16284 * because rIBASE is caller save and we need to reload it. 16285 */ 16286 movl rSELF, %eax 16287 movl rPC, OUT_ARG0(%esp) 16288 movl %eax, OUT_ARG1(%esp) 16289 call dvmCheckInst # (dPC, self) 16290 movl rSELF, %ecx 16291 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16292 jmp *dvmAsmInstructionStart+(282*4) 16293 16294/* ------------------------------ */ 16295.L_ALT_OP_SPUT_JUMBO: /* 0x11b */ 16296/* File: x86/ALT_STUB.S */ 16297/* 16298 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16299 * any interesting requests and then jump to the real instruction 16300 * handler. Unlike the Arm handler, we can't do this as a tail call 16301 * because rIBASE is caller save and we need to reload it. 16302 */ 16303 movl rSELF, %eax 16304 movl rPC, OUT_ARG0(%esp) 16305 movl %eax, OUT_ARG1(%esp) 16306 call dvmCheckInst # (dPC, self) 16307 movl rSELF, %ecx 16308 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16309 jmp *dvmAsmInstructionStart+(283*4) 16310 16311/* ------------------------------ */ 16312.L_ALT_OP_SPUT_WIDE_JUMBO: /* 0x11c */ 16313/* File: x86/ALT_STUB.S */ 16314/* 16315 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16316 * any interesting requests and then jump to the real instruction 16317 * handler. Unlike the Arm handler, we can't do this as a tail call 16318 * because rIBASE is caller save and we need to reload it. 16319 */ 16320 movl rSELF, %eax 16321 movl rPC, OUT_ARG0(%esp) 16322 movl %eax, OUT_ARG1(%esp) 16323 call dvmCheckInst # (dPC, self) 16324 movl rSELF, %ecx 16325 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16326 jmp *dvmAsmInstructionStart+(284*4) 16327 16328/* ------------------------------ */ 16329.L_ALT_OP_SPUT_OBJECT_JUMBO: /* 0x11d */ 16330/* File: x86/ALT_STUB.S */ 16331/* 16332 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16333 * any interesting requests and then jump to the real instruction 16334 * handler. Unlike the Arm handler, we can't do this as a tail call 16335 * because rIBASE is caller save and we need to reload it. 16336 */ 16337 movl rSELF, %eax 16338 movl rPC, OUT_ARG0(%esp) 16339 movl %eax, OUT_ARG1(%esp) 16340 call dvmCheckInst # (dPC, self) 16341 movl rSELF, %ecx 16342 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16343 jmp *dvmAsmInstructionStart+(285*4) 16344 16345/* ------------------------------ */ 16346.L_ALT_OP_SPUT_BOOLEAN_JUMBO: /* 0x11e */ 16347/* File: x86/ALT_STUB.S */ 16348/* 16349 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16350 * any interesting requests and then jump to the real instruction 16351 * handler. Unlike the Arm handler, we can't do this as a tail call 16352 * because rIBASE is caller save and we need to reload it. 16353 */ 16354 movl rSELF, %eax 16355 movl rPC, OUT_ARG0(%esp) 16356 movl %eax, OUT_ARG1(%esp) 16357 call dvmCheckInst # (dPC, self) 16358 movl rSELF, %ecx 16359 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16360 jmp *dvmAsmInstructionStart+(286*4) 16361 16362/* ------------------------------ */ 16363.L_ALT_OP_SPUT_BYTE_JUMBO: /* 0x11f */ 16364/* File: x86/ALT_STUB.S */ 16365/* 16366 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16367 * any interesting requests and then jump to the real instruction 16368 * handler. Unlike the Arm handler, we can't do this as a tail call 16369 * because rIBASE is caller save and we need to reload it. 16370 */ 16371 movl rSELF, %eax 16372 movl rPC, OUT_ARG0(%esp) 16373 movl %eax, OUT_ARG1(%esp) 16374 call dvmCheckInst # (dPC, self) 16375 movl rSELF, %ecx 16376 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16377 jmp *dvmAsmInstructionStart+(287*4) 16378 16379/* ------------------------------ */ 16380.L_ALT_OP_SPUT_CHAR_JUMBO: /* 0x120 */ 16381/* File: x86/ALT_STUB.S */ 16382/* 16383 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16384 * any interesting requests and then jump to the real instruction 16385 * handler. Unlike the Arm handler, we can't do this as a tail call 16386 * because rIBASE is caller save and we need to reload it. 16387 */ 16388 movl rSELF, %eax 16389 movl rPC, OUT_ARG0(%esp) 16390 movl %eax, OUT_ARG1(%esp) 16391 call dvmCheckInst # (dPC, self) 16392 movl rSELF, %ecx 16393 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16394 jmp *dvmAsmInstructionStart+(288*4) 16395 16396/* ------------------------------ */ 16397.L_ALT_OP_SPUT_SHORT_JUMBO: /* 0x121 */ 16398/* File: x86/ALT_STUB.S */ 16399/* 16400 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16401 * any interesting requests and then jump to the real instruction 16402 * handler. Unlike the Arm handler, we can't do this as a tail call 16403 * because rIBASE is caller save and we need to reload it. 16404 */ 16405 movl rSELF, %eax 16406 movl rPC, OUT_ARG0(%esp) 16407 movl %eax, OUT_ARG1(%esp) 16408 call dvmCheckInst # (dPC, self) 16409 movl rSELF, %ecx 16410 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16411 jmp *dvmAsmInstructionStart+(289*4) 16412 16413/* ------------------------------ */ 16414.L_ALT_OP_INVOKE_VIRTUAL_JUMBO: /* 0x122 */ 16415/* File: x86/ALT_STUB.S */ 16416/* 16417 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16418 * any interesting requests and then jump to the real instruction 16419 * handler. Unlike the Arm handler, we can't do this as a tail call 16420 * because rIBASE is caller save and we need to reload it. 16421 */ 16422 movl rSELF, %eax 16423 movl rPC, OUT_ARG0(%esp) 16424 movl %eax, OUT_ARG1(%esp) 16425 call dvmCheckInst # (dPC, self) 16426 movl rSELF, %ecx 16427 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16428 jmp *dvmAsmInstructionStart+(290*4) 16429 16430/* ------------------------------ */ 16431.L_ALT_OP_INVOKE_SUPER_JUMBO: /* 0x123 */ 16432/* File: x86/ALT_STUB.S */ 16433/* 16434 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16435 * any interesting requests and then jump to the real instruction 16436 * handler. Unlike the Arm handler, we can't do this as a tail call 16437 * because rIBASE is caller save and we need to reload it. 16438 */ 16439 movl rSELF, %eax 16440 movl rPC, OUT_ARG0(%esp) 16441 movl %eax, OUT_ARG1(%esp) 16442 call dvmCheckInst # (dPC, self) 16443 movl rSELF, %ecx 16444 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16445 jmp *dvmAsmInstructionStart+(291*4) 16446 16447/* ------------------------------ */ 16448.L_ALT_OP_INVOKE_DIRECT_JUMBO: /* 0x124 */ 16449/* File: x86/ALT_STUB.S */ 16450/* 16451 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16452 * any interesting requests and then jump to the real instruction 16453 * handler. Unlike the Arm handler, we can't do this as a tail call 16454 * because rIBASE is caller save and we need to reload it. 16455 */ 16456 movl rSELF, %eax 16457 movl rPC, OUT_ARG0(%esp) 16458 movl %eax, OUT_ARG1(%esp) 16459 call dvmCheckInst # (dPC, self) 16460 movl rSELF, %ecx 16461 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16462 jmp *dvmAsmInstructionStart+(292*4) 16463 16464/* ------------------------------ */ 16465.L_ALT_OP_INVOKE_STATIC_JUMBO: /* 0x125 */ 16466/* File: x86/ALT_STUB.S */ 16467/* 16468 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16469 * any interesting requests and then jump to the real instruction 16470 * handler. Unlike the Arm handler, we can't do this as a tail call 16471 * because rIBASE is caller save and we need to reload it. 16472 */ 16473 movl rSELF, %eax 16474 movl rPC, OUT_ARG0(%esp) 16475 movl %eax, OUT_ARG1(%esp) 16476 call dvmCheckInst # (dPC, self) 16477 movl rSELF, %ecx 16478 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16479 jmp *dvmAsmInstructionStart+(293*4) 16480 16481/* ------------------------------ */ 16482.L_ALT_OP_INVOKE_INTERFACE_JUMBO: /* 0x126 */ 16483/* File: x86/ALT_STUB.S */ 16484/* 16485 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16486 * any interesting requests and then jump to the real instruction 16487 * handler. Unlike the Arm handler, we can't do this as a tail call 16488 * because rIBASE is caller save and we need to reload it. 16489 */ 16490 movl rSELF, %eax 16491 movl rPC, OUT_ARG0(%esp) 16492 movl %eax, OUT_ARG1(%esp) 16493 call dvmCheckInst # (dPC, self) 16494 movl rSELF, %ecx 16495 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16496 jmp *dvmAsmInstructionStart+(294*4) 16497 16498/* ------------------------------ */ 16499.L_ALT_OP_UNUSED_27FF: /* 0x127 */ 16500/* File: x86/ALT_STUB.S */ 16501/* 16502 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16503 * any interesting requests and then jump to the real instruction 16504 * handler. Unlike the Arm handler, we can't do this as a tail call 16505 * because rIBASE is caller save and we need to reload it. 16506 */ 16507 movl rSELF, %eax 16508 movl rPC, OUT_ARG0(%esp) 16509 movl %eax, OUT_ARG1(%esp) 16510 call dvmCheckInst # (dPC, self) 16511 movl rSELF, %ecx 16512 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16513 jmp *dvmAsmInstructionStart+(295*4) 16514 16515/* ------------------------------ */ 16516.L_ALT_OP_UNUSED_28FF: /* 0x128 */ 16517/* File: x86/ALT_STUB.S */ 16518/* 16519 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16520 * any interesting requests and then jump to the real instruction 16521 * handler. Unlike the Arm handler, we can't do this as a tail call 16522 * because rIBASE is caller save and we need to reload it. 16523 */ 16524 movl rSELF, %eax 16525 movl rPC, OUT_ARG0(%esp) 16526 movl %eax, OUT_ARG1(%esp) 16527 call dvmCheckInst # (dPC, self) 16528 movl rSELF, %ecx 16529 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16530 jmp *dvmAsmInstructionStart+(296*4) 16531 16532/* ------------------------------ */ 16533.L_ALT_OP_UNUSED_29FF: /* 0x129 */ 16534/* File: x86/ALT_STUB.S */ 16535/* 16536 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16537 * any interesting requests and then jump to the real instruction 16538 * handler. Unlike the Arm handler, we can't do this as a tail call 16539 * because rIBASE is caller save and we need to reload it. 16540 */ 16541 movl rSELF, %eax 16542 movl rPC, OUT_ARG0(%esp) 16543 movl %eax, OUT_ARG1(%esp) 16544 call dvmCheckInst # (dPC, self) 16545 movl rSELF, %ecx 16546 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16547 jmp *dvmAsmInstructionStart+(297*4) 16548 16549/* ------------------------------ */ 16550.L_ALT_OP_UNUSED_2AFF: /* 0x12a */ 16551/* File: x86/ALT_STUB.S */ 16552/* 16553 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16554 * any interesting requests and then jump to the real instruction 16555 * handler. Unlike the Arm handler, we can't do this as a tail call 16556 * because rIBASE is caller save and we need to reload it. 16557 */ 16558 movl rSELF, %eax 16559 movl rPC, OUT_ARG0(%esp) 16560 movl %eax, OUT_ARG1(%esp) 16561 call dvmCheckInst # (dPC, self) 16562 movl rSELF, %ecx 16563 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16564 jmp *dvmAsmInstructionStart+(298*4) 16565 16566/* ------------------------------ */ 16567.L_ALT_OP_UNUSED_2BFF: /* 0x12b */ 16568/* File: x86/ALT_STUB.S */ 16569/* 16570 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16571 * any interesting requests and then jump to the real instruction 16572 * handler. Unlike the Arm handler, we can't do this as a tail call 16573 * because rIBASE is caller save and we need to reload it. 16574 */ 16575 movl rSELF, %eax 16576 movl rPC, OUT_ARG0(%esp) 16577 movl %eax, OUT_ARG1(%esp) 16578 call dvmCheckInst # (dPC, self) 16579 movl rSELF, %ecx 16580 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16581 jmp *dvmAsmInstructionStart+(299*4) 16582 16583/* ------------------------------ */ 16584.L_ALT_OP_UNUSED_2CFF: /* 0x12c */ 16585/* File: x86/ALT_STUB.S */ 16586/* 16587 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16588 * any interesting requests and then jump to the real instruction 16589 * handler. Unlike the Arm handler, we can't do this as a tail call 16590 * because rIBASE is caller save and we need to reload it. 16591 */ 16592 movl rSELF, %eax 16593 movl rPC, OUT_ARG0(%esp) 16594 movl %eax, OUT_ARG1(%esp) 16595 call dvmCheckInst # (dPC, self) 16596 movl rSELF, %ecx 16597 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16598 jmp *dvmAsmInstructionStart+(300*4) 16599 16600/* ------------------------------ */ 16601.L_ALT_OP_UNUSED_2DFF: /* 0x12d */ 16602/* File: x86/ALT_STUB.S */ 16603/* 16604 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16605 * any interesting requests and then jump to the real instruction 16606 * handler. Unlike the Arm handler, we can't do this as a tail call 16607 * because rIBASE is caller save and we need to reload it. 16608 */ 16609 movl rSELF, %eax 16610 movl rPC, OUT_ARG0(%esp) 16611 movl %eax, OUT_ARG1(%esp) 16612 call dvmCheckInst # (dPC, self) 16613 movl rSELF, %ecx 16614 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16615 jmp *dvmAsmInstructionStart+(301*4) 16616 16617/* ------------------------------ */ 16618.L_ALT_OP_UNUSED_2EFF: /* 0x12e */ 16619/* File: x86/ALT_STUB.S */ 16620/* 16621 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16622 * any interesting requests and then jump to the real instruction 16623 * handler. Unlike the Arm handler, we can't do this as a tail call 16624 * because rIBASE is caller save and we need to reload it. 16625 */ 16626 movl rSELF, %eax 16627 movl rPC, OUT_ARG0(%esp) 16628 movl %eax, OUT_ARG1(%esp) 16629 call dvmCheckInst # (dPC, self) 16630 movl rSELF, %ecx 16631 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16632 jmp *dvmAsmInstructionStart+(302*4) 16633 16634/* ------------------------------ */ 16635.L_ALT_OP_UNUSED_2FFF: /* 0x12f */ 16636/* File: x86/ALT_STUB.S */ 16637/* 16638 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16639 * any interesting requests and then jump to the real instruction 16640 * handler. Unlike the Arm handler, we can't do this as a tail call 16641 * because rIBASE is caller save and we need to reload it. 16642 */ 16643 movl rSELF, %eax 16644 movl rPC, OUT_ARG0(%esp) 16645 movl %eax, OUT_ARG1(%esp) 16646 call dvmCheckInst # (dPC, self) 16647 movl rSELF, %ecx 16648 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16649 jmp *dvmAsmInstructionStart+(303*4) 16650 16651/* ------------------------------ */ 16652.L_ALT_OP_UNUSED_30FF: /* 0x130 */ 16653/* File: x86/ALT_STUB.S */ 16654/* 16655 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16656 * any interesting requests and then jump to the real instruction 16657 * handler. Unlike the Arm handler, we can't do this as a tail call 16658 * because rIBASE is caller save and we need to reload it. 16659 */ 16660 movl rSELF, %eax 16661 movl rPC, OUT_ARG0(%esp) 16662 movl %eax, OUT_ARG1(%esp) 16663 call dvmCheckInst # (dPC, self) 16664 movl rSELF, %ecx 16665 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16666 jmp *dvmAsmInstructionStart+(304*4) 16667 16668/* ------------------------------ */ 16669.L_ALT_OP_UNUSED_31FF: /* 0x131 */ 16670/* File: x86/ALT_STUB.S */ 16671/* 16672 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16673 * any interesting requests and then jump to the real instruction 16674 * handler. Unlike the Arm handler, we can't do this as a tail call 16675 * because rIBASE is caller save and we need to reload it. 16676 */ 16677 movl rSELF, %eax 16678 movl rPC, OUT_ARG0(%esp) 16679 movl %eax, OUT_ARG1(%esp) 16680 call dvmCheckInst # (dPC, self) 16681 movl rSELF, %ecx 16682 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16683 jmp *dvmAsmInstructionStart+(305*4) 16684 16685/* ------------------------------ */ 16686.L_ALT_OP_UNUSED_32FF: /* 0x132 */ 16687/* File: x86/ALT_STUB.S */ 16688/* 16689 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16690 * any interesting requests and then jump to the real instruction 16691 * handler. Unlike the Arm handler, we can't do this as a tail call 16692 * because rIBASE is caller save and we need to reload it. 16693 */ 16694 movl rSELF, %eax 16695 movl rPC, OUT_ARG0(%esp) 16696 movl %eax, OUT_ARG1(%esp) 16697 call dvmCheckInst # (dPC, self) 16698 movl rSELF, %ecx 16699 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16700 jmp *dvmAsmInstructionStart+(306*4) 16701 16702/* ------------------------------ */ 16703.L_ALT_OP_UNUSED_33FF: /* 0x133 */ 16704/* File: x86/ALT_STUB.S */ 16705/* 16706 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16707 * any interesting requests and then jump to the real instruction 16708 * handler. Unlike the Arm handler, we can't do this as a tail call 16709 * because rIBASE is caller save and we need to reload it. 16710 */ 16711 movl rSELF, %eax 16712 movl rPC, OUT_ARG0(%esp) 16713 movl %eax, OUT_ARG1(%esp) 16714 call dvmCheckInst # (dPC, self) 16715 movl rSELF, %ecx 16716 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16717 jmp *dvmAsmInstructionStart+(307*4) 16718 16719/* ------------------------------ */ 16720.L_ALT_OP_UNUSED_34FF: /* 0x134 */ 16721/* File: x86/ALT_STUB.S */ 16722/* 16723 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16724 * any interesting requests and then jump to the real instruction 16725 * handler. Unlike the Arm handler, we can't do this as a tail call 16726 * because rIBASE is caller save and we need to reload it. 16727 */ 16728 movl rSELF, %eax 16729 movl rPC, OUT_ARG0(%esp) 16730 movl %eax, OUT_ARG1(%esp) 16731 call dvmCheckInst # (dPC, self) 16732 movl rSELF, %ecx 16733 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16734 jmp *dvmAsmInstructionStart+(308*4) 16735 16736/* ------------------------------ */ 16737.L_ALT_OP_UNUSED_35FF: /* 0x135 */ 16738/* File: x86/ALT_STUB.S */ 16739/* 16740 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16741 * any interesting requests and then jump to the real instruction 16742 * handler. Unlike the Arm handler, we can't do this as a tail call 16743 * because rIBASE is caller save and we need to reload it. 16744 */ 16745 movl rSELF, %eax 16746 movl rPC, OUT_ARG0(%esp) 16747 movl %eax, OUT_ARG1(%esp) 16748 call dvmCheckInst # (dPC, self) 16749 movl rSELF, %ecx 16750 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16751 jmp *dvmAsmInstructionStart+(309*4) 16752 16753/* ------------------------------ */ 16754.L_ALT_OP_UNUSED_36FF: /* 0x136 */ 16755/* File: x86/ALT_STUB.S */ 16756/* 16757 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16758 * any interesting requests and then jump to the real instruction 16759 * handler. Unlike the Arm handler, we can't do this as a tail call 16760 * because rIBASE is caller save and we need to reload it. 16761 */ 16762 movl rSELF, %eax 16763 movl rPC, OUT_ARG0(%esp) 16764 movl %eax, OUT_ARG1(%esp) 16765 call dvmCheckInst # (dPC, self) 16766 movl rSELF, %ecx 16767 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16768 jmp *dvmAsmInstructionStart+(310*4) 16769 16770/* ------------------------------ */ 16771.L_ALT_OP_UNUSED_37FF: /* 0x137 */ 16772/* File: x86/ALT_STUB.S */ 16773/* 16774 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16775 * any interesting requests and then jump to the real instruction 16776 * handler. Unlike the Arm handler, we can't do this as a tail call 16777 * because rIBASE is caller save and we need to reload it. 16778 */ 16779 movl rSELF, %eax 16780 movl rPC, OUT_ARG0(%esp) 16781 movl %eax, OUT_ARG1(%esp) 16782 call dvmCheckInst # (dPC, self) 16783 movl rSELF, %ecx 16784 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16785 jmp *dvmAsmInstructionStart+(311*4) 16786 16787/* ------------------------------ */ 16788.L_ALT_OP_UNUSED_38FF: /* 0x138 */ 16789/* File: x86/ALT_STUB.S */ 16790/* 16791 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16792 * any interesting requests and then jump to the real instruction 16793 * handler. Unlike the Arm handler, we can't do this as a tail call 16794 * because rIBASE is caller save and we need to reload it. 16795 */ 16796 movl rSELF, %eax 16797 movl rPC, OUT_ARG0(%esp) 16798 movl %eax, OUT_ARG1(%esp) 16799 call dvmCheckInst # (dPC, self) 16800 movl rSELF, %ecx 16801 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16802 jmp *dvmAsmInstructionStart+(312*4) 16803 16804/* ------------------------------ */ 16805.L_ALT_OP_UNUSED_39FF: /* 0x139 */ 16806/* File: x86/ALT_STUB.S */ 16807/* 16808 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16809 * any interesting requests and then jump to the real instruction 16810 * handler. Unlike the Arm handler, we can't do this as a tail call 16811 * because rIBASE is caller save and we need to reload it. 16812 */ 16813 movl rSELF, %eax 16814 movl rPC, OUT_ARG0(%esp) 16815 movl %eax, OUT_ARG1(%esp) 16816 call dvmCheckInst # (dPC, self) 16817 movl rSELF, %ecx 16818 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16819 jmp *dvmAsmInstructionStart+(313*4) 16820 16821/* ------------------------------ */ 16822.L_ALT_OP_UNUSED_3AFF: /* 0x13a */ 16823/* File: x86/ALT_STUB.S */ 16824/* 16825 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16826 * any interesting requests and then jump to the real instruction 16827 * handler. Unlike the Arm handler, we can't do this as a tail call 16828 * because rIBASE is caller save and we need to reload it. 16829 */ 16830 movl rSELF, %eax 16831 movl rPC, OUT_ARG0(%esp) 16832 movl %eax, OUT_ARG1(%esp) 16833 call dvmCheckInst # (dPC, self) 16834 movl rSELF, %ecx 16835 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16836 jmp *dvmAsmInstructionStart+(314*4) 16837 16838/* ------------------------------ */ 16839.L_ALT_OP_UNUSED_3BFF: /* 0x13b */ 16840/* File: x86/ALT_STUB.S */ 16841/* 16842 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16843 * any interesting requests and then jump to the real instruction 16844 * handler. Unlike the Arm handler, we can't do this as a tail call 16845 * because rIBASE is caller save and we need to reload it. 16846 */ 16847 movl rSELF, %eax 16848 movl rPC, OUT_ARG0(%esp) 16849 movl %eax, OUT_ARG1(%esp) 16850 call dvmCheckInst # (dPC, self) 16851 movl rSELF, %ecx 16852 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16853 jmp *dvmAsmInstructionStart+(315*4) 16854 16855/* ------------------------------ */ 16856.L_ALT_OP_UNUSED_3CFF: /* 0x13c */ 16857/* File: x86/ALT_STUB.S */ 16858/* 16859 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16860 * any interesting requests and then jump to the real instruction 16861 * handler. Unlike the Arm handler, we can't do this as a tail call 16862 * because rIBASE is caller save and we need to reload it. 16863 */ 16864 movl rSELF, %eax 16865 movl rPC, OUT_ARG0(%esp) 16866 movl %eax, OUT_ARG1(%esp) 16867 call dvmCheckInst # (dPC, self) 16868 movl rSELF, %ecx 16869 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16870 jmp *dvmAsmInstructionStart+(316*4) 16871 16872/* ------------------------------ */ 16873.L_ALT_OP_UNUSED_3DFF: /* 0x13d */ 16874/* File: x86/ALT_STUB.S */ 16875/* 16876 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16877 * any interesting requests and then jump to the real instruction 16878 * handler. Unlike the Arm handler, we can't do this as a tail call 16879 * because rIBASE is caller save and we need to reload it. 16880 */ 16881 movl rSELF, %eax 16882 movl rPC, OUT_ARG0(%esp) 16883 movl %eax, OUT_ARG1(%esp) 16884 call dvmCheckInst # (dPC, self) 16885 movl rSELF, %ecx 16886 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16887 jmp *dvmAsmInstructionStart+(317*4) 16888 16889/* ------------------------------ */ 16890.L_ALT_OP_UNUSED_3EFF: /* 0x13e */ 16891/* File: x86/ALT_STUB.S */ 16892/* 16893 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16894 * any interesting requests and then jump to the real instruction 16895 * handler. Unlike the Arm handler, we can't do this as a tail call 16896 * because rIBASE is caller save and we need to reload it. 16897 */ 16898 movl rSELF, %eax 16899 movl rPC, OUT_ARG0(%esp) 16900 movl %eax, OUT_ARG1(%esp) 16901 call dvmCheckInst # (dPC, self) 16902 movl rSELF, %ecx 16903 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16904 jmp *dvmAsmInstructionStart+(318*4) 16905 16906/* ------------------------------ */ 16907.L_ALT_OP_UNUSED_3FFF: /* 0x13f */ 16908/* File: x86/ALT_STUB.S */ 16909/* 16910 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16911 * any interesting requests and then jump to the real instruction 16912 * handler. Unlike the Arm handler, we can't do this as a tail call 16913 * because rIBASE is caller save and we need to reload it. 16914 */ 16915 movl rSELF, %eax 16916 movl rPC, OUT_ARG0(%esp) 16917 movl %eax, OUT_ARG1(%esp) 16918 call dvmCheckInst # (dPC, self) 16919 movl rSELF, %ecx 16920 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16921 jmp *dvmAsmInstructionStart+(319*4) 16922 16923/* ------------------------------ */ 16924.L_ALT_OP_UNUSED_40FF: /* 0x140 */ 16925/* File: x86/ALT_STUB.S */ 16926/* 16927 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16928 * any interesting requests and then jump to the real instruction 16929 * handler. Unlike the Arm handler, we can't do this as a tail call 16930 * because rIBASE is caller save and we need to reload it. 16931 */ 16932 movl rSELF, %eax 16933 movl rPC, OUT_ARG0(%esp) 16934 movl %eax, OUT_ARG1(%esp) 16935 call dvmCheckInst # (dPC, self) 16936 movl rSELF, %ecx 16937 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16938 jmp *dvmAsmInstructionStart+(320*4) 16939 16940/* ------------------------------ */ 16941.L_ALT_OP_UNUSED_41FF: /* 0x141 */ 16942/* File: x86/ALT_STUB.S */ 16943/* 16944 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16945 * any interesting requests and then jump to the real instruction 16946 * handler. Unlike the Arm handler, we can't do this as a tail call 16947 * because rIBASE is caller save and we need to reload it. 16948 */ 16949 movl rSELF, %eax 16950 movl rPC, OUT_ARG0(%esp) 16951 movl %eax, OUT_ARG1(%esp) 16952 call dvmCheckInst # (dPC, self) 16953 movl rSELF, %ecx 16954 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16955 jmp *dvmAsmInstructionStart+(321*4) 16956 16957/* ------------------------------ */ 16958.L_ALT_OP_UNUSED_42FF: /* 0x142 */ 16959/* File: x86/ALT_STUB.S */ 16960/* 16961 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16962 * any interesting requests and then jump to the real instruction 16963 * handler. Unlike the Arm handler, we can't do this as a tail call 16964 * because rIBASE is caller save and we need to reload it. 16965 */ 16966 movl rSELF, %eax 16967 movl rPC, OUT_ARG0(%esp) 16968 movl %eax, OUT_ARG1(%esp) 16969 call dvmCheckInst # (dPC, self) 16970 movl rSELF, %ecx 16971 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16972 jmp *dvmAsmInstructionStart+(322*4) 16973 16974/* ------------------------------ */ 16975.L_ALT_OP_UNUSED_43FF: /* 0x143 */ 16976/* File: x86/ALT_STUB.S */ 16977/* 16978 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16979 * any interesting requests and then jump to the real instruction 16980 * handler. Unlike the Arm handler, we can't do this as a tail call 16981 * because rIBASE is caller save and we need to reload it. 16982 */ 16983 movl rSELF, %eax 16984 movl rPC, OUT_ARG0(%esp) 16985 movl %eax, OUT_ARG1(%esp) 16986 call dvmCheckInst # (dPC, self) 16987 movl rSELF, %ecx 16988 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 16989 jmp *dvmAsmInstructionStart+(323*4) 16990 16991/* ------------------------------ */ 16992.L_ALT_OP_UNUSED_44FF: /* 0x144 */ 16993/* File: x86/ALT_STUB.S */ 16994/* 16995 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 16996 * any interesting requests and then jump to the real instruction 16997 * handler. Unlike the Arm handler, we can't do this as a tail call 16998 * because rIBASE is caller save and we need to reload it. 16999 */ 17000 movl rSELF, %eax 17001 movl rPC, OUT_ARG0(%esp) 17002 movl %eax, OUT_ARG1(%esp) 17003 call dvmCheckInst # (dPC, self) 17004 movl rSELF, %ecx 17005 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17006 jmp *dvmAsmInstructionStart+(324*4) 17007 17008/* ------------------------------ */ 17009.L_ALT_OP_UNUSED_45FF: /* 0x145 */ 17010/* File: x86/ALT_STUB.S */ 17011/* 17012 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17013 * any interesting requests and then jump to the real instruction 17014 * handler. Unlike the Arm handler, we can't do this as a tail call 17015 * because rIBASE is caller save and we need to reload it. 17016 */ 17017 movl rSELF, %eax 17018 movl rPC, OUT_ARG0(%esp) 17019 movl %eax, OUT_ARG1(%esp) 17020 call dvmCheckInst # (dPC, self) 17021 movl rSELF, %ecx 17022 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17023 jmp *dvmAsmInstructionStart+(325*4) 17024 17025/* ------------------------------ */ 17026.L_ALT_OP_UNUSED_46FF: /* 0x146 */ 17027/* File: x86/ALT_STUB.S */ 17028/* 17029 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17030 * any interesting requests and then jump to the real instruction 17031 * handler. Unlike the Arm handler, we can't do this as a tail call 17032 * because rIBASE is caller save and we need to reload it. 17033 */ 17034 movl rSELF, %eax 17035 movl rPC, OUT_ARG0(%esp) 17036 movl %eax, OUT_ARG1(%esp) 17037 call dvmCheckInst # (dPC, self) 17038 movl rSELF, %ecx 17039 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17040 jmp *dvmAsmInstructionStart+(326*4) 17041 17042/* ------------------------------ */ 17043.L_ALT_OP_UNUSED_47FF: /* 0x147 */ 17044/* File: x86/ALT_STUB.S */ 17045/* 17046 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17047 * any interesting requests and then jump to the real instruction 17048 * handler. Unlike the Arm handler, we can't do this as a tail call 17049 * because rIBASE is caller save and we need to reload it. 17050 */ 17051 movl rSELF, %eax 17052 movl rPC, OUT_ARG0(%esp) 17053 movl %eax, OUT_ARG1(%esp) 17054 call dvmCheckInst # (dPC, self) 17055 movl rSELF, %ecx 17056 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17057 jmp *dvmAsmInstructionStart+(327*4) 17058 17059/* ------------------------------ */ 17060.L_ALT_OP_UNUSED_48FF: /* 0x148 */ 17061/* File: x86/ALT_STUB.S */ 17062/* 17063 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17064 * any interesting requests and then jump to the real instruction 17065 * handler. Unlike the Arm handler, we can't do this as a tail call 17066 * because rIBASE is caller save and we need to reload it. 17067 */ 17068 movl rSELF, %eax 17069 movl rPC, OUT_ARG0(%esp) 17070 movl %eax, OUT_ARG1(%esp) 17071 call dvmCheckInst # (dPC, self) 17072 movl rSELF, %ecx 17073 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17074 jmp *dvmAsmInstructionStart+(328*4) 17075 17076/* ------------------------------ */ 17077.L_ALT_OP_UNUSED_49FF: /* 0x149 */ 17078/* File: x86/ALT_STUB.S */ 17079/* 17080 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17081 * any interesting requests and then jump to the real instruction 17082 * handler. Unlike the Arm handler, we can't do this as a tail call 17083 * because rIBASE is caller save and we need to reload it. 17084 */ 17085 movl rSELF, %eax 17086 movl rPC, OUT_ARG0(%esp) 17087 movl %eax, OUT_ARG1(%esp) 17088 call dvmCheckInst # (dPC, self) 17089 movl rSELF, %ecx 17090 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17091 jmp *dvmAsmInstructionStart+(329*4) 17092 17093/* ------------------------------ */ 17094.L_ALT_OP_UNUSED_4AFF: /* 0x14a */ 17095/* File: x86/ALT_STUB.S */ 17096/* 17097 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17098 * any interesting requests and then jump to the real instruction 17099 * handler. Unlike the Arm handler, we can't do this as a tail call 17100 * because rIBASE is caller save and we need to reload it. 17101 */ 17102 movl rSELF, %eax 17103 movl rPC, OUT_ARG0(%esp) 17104 movl %eax, OUT_ARG1(%esp) 17105 call dvmCheckInst # (dPC, self) 17106 movl rSELF, %ecx 17107 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17108 jmp *dvmAsmInstructionStart+(330*4) 17109 17110/* ------------------------------ */ 17111.L_ALT_OP_UNUSED_4BFF: /* 0x14b */ 17112/* File: x86/ALT_STUB.S */ 17113/* 17114 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17115 * any interesting requests and then jump to the real instruction 17116 * handler. Unlike the Arm handler, we can't do this as a tail call 17117 * because rIBASE is caller save and we need to reload it. 17118 */ 17119 movl rSELF, %eax 17120 movl rPC, OUT_ARG0(%esp) 17121 movl %eax, OUT_ARG1(%esp) 17122 call dvmCheckInst # (dPC, self) 17123 movl rSELF, %ecx 17124 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17125 jmp *dvmAsmInstructionStart+(331*4) 17126 17127/* ------------------------------ */ 17128.L_ALT_OP_UNUSED_4CFF: /* 0x14c */ 17129/* File: x86/ALT_STUB.S */ 17130/* 17131 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17132 * any interesting requests and then jump to the real instruction 17133 * handler. Unlike the Arm handler, we can't do this as a tail call 17134 * because rIBASE is caller save and we need to reload it. 17135 */ 17136 movl rSELF, %eax 17137 movl rPC, OUT_ARG0(%esp) 17138 movl %eax, OUT_ARG1(%esp) 17139 call dvmCheckInst # (dPC, self) 17140 movl rSELF, %ecx 17141 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17142 jmp *dvmAsmInstructionStart+(332*4) 17143 17144/* ------------------------------ */ 17145.L_ALT_OP_UNUSED_4DFF: /* 0x14d */ 17146/* File: x86/ALT_STUB.S */ 17147/* 17148 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17149 * any interesting requests and then jump to the real instruction 17150 * handler. Unlike the Arm handler, we can't do this as a tail call 17151 * because rIBASE is caller save and we need to reload it. 17152 */ 17153 movl rSELF, %eax 17154 movl rPC, OUT_ARG0(%esp) 17155 movl %eax, OUT_ARG1(%esp) 17156 call dvmCheckInst # (dPC, self) 17157 movl rSELF, %ecx 17158 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17159 jmp *dvmAsmInstructionStart+(333*4) 17160 17161/* ------------------------------ */ 17162.L_ALT_OP_UNUSED_4EFF: /* 0x14e */ 17163/* File: x86/ALT_STUB.S */ 17164/* 17165 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17166 * any interesting requests and then jump to the real instruction 17167 * handler. Unlike the Arm handler, we can't do this as a tail call 17168 * because rIBASE is caller save and we need to reload it. 17169 */ 17170 movl rSELF, %eax 17171 movl rPC, OUT_ARG0(%esp) 17172 movl %eax, OUT_ARG1(%esp) 17173 call dvmCheckInst # (dPC, self) 17174 movl rSELF, %ecx 17175 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17176 jmp *dvmAsmInstructionStart+(334*4) 17177 17178/* ------------------------------ */ 17179.L_ALT_OP_UNUSED_4FFF: /* 0x14f */ 17180/* File: x86/ALT_STUB.S */ 17181/* 17182 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17183 * any interesting requests and then jump to the real instruction 17184 * handler. Unlike the Arm handler, we can't do this as a tail call 17185 * because rIBASE is caller save and we need to reload it. 17186 */ 17187 movl rSELF, %eax 17188 movl rPC, OUT_ARG0(%esp) 17189 movl %eax, OUT_ARG1(%esp) 17190 call dvmCheckInst # (dPC, self) 17191 movl rSELF, %ecx 17192 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17193 jmp *dvmAsmInstructionStart+(335*4) 17194 17195/* ------------------------------ */ 17196.L_ALT_OP_UNUSED_50FF: /* 0x150 */ 17197/* File: x86/ALT_STUB.S */ 17198/* 17199 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17200 * any interesting requests and then jump to the real instruction 17201 * handler. Unlike the Arm handler, we can't do this as a tail call 17202 * because rIBASE is caller save and we need to reload it. 17203 */ 17204 movl rSELF, %eax 17205 movl rPC, OUT_ARG0(%esp) 17206 movl %eax, OUT_ARG1(%esp) 17207 call dvmCheckInst # (dPC, self) 17208 movl rSELF, %ecx 17209 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17210 jmp *dvmAsmInstructionStart+(336*4) 17211 17212/* ------------------------------ */ 17213.L_ALT_OP_UNUSED_51FF: /* 0x151 */ 17214/* File: x86/ALT_STUB.S */ 17215/* 17216 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17217 * any interesting requests and then jump to the real instruction 17218 * handler. Unlike the Arm handler, we can't do this as a tail call 17219 * because rIBASE is caller save and we need to reload it. 17220 */ 17221 movl rSELF, %eax 17222 movl rPC, OUT_ARG0(%esp) 17223 movl %eax, OUT_ARG1(%esp) 17224 call dvmCheckInst # (dPC, self) 17225 movl rSELF, %ecx 17226 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17227 jmp *dvmAsmInstructionStart+(337*4) 17228 17229/* ------------------------------ */ 17230.L_ALT_OP_UNUSED_52FF: /* 0x152 */ 17231/* File: x86/ALT_STUB.S */ 17232/* 17233 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17234 * any interesting requests and then jump to the real instruction 17235 * handler. Unlike the Arm handler, we can't do this as a tail call 17236 * because rIBASE is caller save and we need to reload it. 17237 */ 17238 movl rSELF, %eax 17239 movl rPC, OUT_ARG0(%esp) 17240 movl %eax, OUT_ARG1(%esp) 17241 call dvmCheckInst # (dPC, self) 17242 movl rSELF, %ecx 17243 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17244 jmp *dvmAsmInstructionStart+(338*4) 17245 17246/* ------------------------------ */ 17247.L_ALT_OP_UNUSED_53FF: /* 0x153 */ 17248/* File: x86/ALT_STUB.S */ 17249/* 17250 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17251 * any interesting requests and then jump to the real instruction 17252 * handler. Unlike the Arm handler, we can't do this as a tail call 17253 * because rIBASE is caller save and we need to reload it. 17254 */ 17255 movl rSELF, %eax 17256 movl rPC, OUT_ARG0(%esp) 17257 movl %eax, OUT_ARG1(%esp) 17258 call dvmCheckInst # (dPC, self) 17259 movl rSELF, %ecx 17260 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17261 jmp *dvmAsmInstructionStart+(339*4) 17262 17263/* ------------------------------ */ 17264.L_ALT_OP_UNUSED_54FF: /* 0x154 */ 17265/* File: x86/ALT_STUB.S */ 17266/* 17267 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17268 * any interesting requests and then jump to the real instruction 17269 * handler. Unlike the Arm handler, we can't do this as a tail call 17270 * because rIBASE is caller save and we need to reload it. 17271 */ 17272 movl rSELF, %eax 17273 movl rPC, OUT_ARG0(%esp) 17274 movl %eax, OUT_ARG1(%esp) 17275 call dvmCheckInst # (dPC, self) 17276 movl rSELF, %ecx 17277 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17278 jmp *dvmAsmInstructionStart+(340*4) 17279 17280/* ------------------------------ */ 17281.L_ALT_OP_UNUSED_55FF: /* 0x155 */ 17282/* File: x86/ALT_STUB.S */ 17283/* 17284 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17285 * any interesting requests and then jump to the real instruction 17286 * handler. Unlike the Arm handler, we can't do this as a tail call 17287 * because rIBASE is caller save and we need to reload it. 17288 */ 17289 movl rSELF, %eax 17290 movl rPC, OUT_ARG0(%esp) 17291 movl %eax, OUT_ARG1(%esp) 17292 call dvmCheckInst # (dPC, self) 17293 movl rSELF, %ecx 17294 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17295 jmp *dvmAsmInstructionStart+(341*4) 17296 17297/* ------------------------------ */ 17298.L_ALT_OP_UNUSED_56FF: /* 0x156 */ 17299/* File: x86/ALT_STUB.S */ 17300/* 17301 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17302 * any interesting requests and then jump to the real instruction 17303 * handler. Unlike the Arm handler, we can't do this as a tail call 17304 * because rIBASE is caller save and we need to reload it. 17305 */ 17306 movl rSELF, %eax 17307 movl rPC, OUT_ARG0(%esp) 17308 movl %eax, OUT_ARG1(%esp) 17309 call dvmCheckInst # (dPC, self) 17310 movl rSELF, %ecx 17311 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17312 jmp *dvmAsmInstructionStart+(342*4) 17313 17314/* ------------------------------ */ 17315.L_ALT_OP_UNUSED_57FF: /* 0x157 */ 17316/* File: x86/ALT_STUB.S */ 17317/* 17318 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17319 * any interesting requests and then jump to the real instruction 17320 * handler. Unlike the Arm handler, we can't do this as a tail call 17321 * because rIBASE is caller save and we need to reload it. 17322 */ 17323 movl rSELF, %eax 17324 movl rPC, OUT_ARG0(%esp) 17325 movl %eax, OUT_ARG1(%esp) 17326 call dvmCheckInst # (dPC, self) 17327 movl rSELF, %ecx 17328 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17329 jmp *dvmAsmInstructionStart+(343*4) 17330 17331/* ------------------------------ */ 17332.L_ALT_OP_UNUSED_58FF: /* 0x158 */ 17333/* File: x86/ALT_STUB.S */ 17334/* 17335 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17336 * any interesting requests and then jump to the real instruction 17337 * handler. Unlike the Arm handler, we can't do this as a tail call 17338 * because rIBASE is caller save and we need to reload it. 17339 */ 17340 movl rSELF, %eax 17341 movl rPC, OUT_ARG0(%esp) 17342 movl %eax, OUT_ARG1(%esp) 17343 call dvmCheckInst # (dPC, self) 17344 movl rSELF, %ecx 17345 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17346 jmp *dvmAsmInstructionStart+(344*4) 17347 17348/* ------------------------------ */ 17349.L_ALT_OP_UNUSED_59FF: /* 0x159 */ 17350/* File: x86/ALT_STUB.S */ 17351/* 17352 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17353 * any interesting requests and then jump to the real instruction 17354 * handler. Unlike the Arm handler, we can't do this as a tail call 17355 * because rIBASE is caller save and we need to reload it. 17356 */ 17357 movl rSELF, %eax 17358 movl rPC, OUT_ARG0(%esp) 17359 movl %eax, OUT_ARG1(%esp) 17360 call dvmCheckInst # (dPC, self) 17361 movl rSELF, %ecx 17362 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17363 jmp *dvmAsmInstructionStart+(345*4) 17364 17365/* ------------------------------ */ 17366.L_ALT_OP_UNUSED_5AFF: /* 0x15a */ 17367/* File: x86/ALT_STUB.S */ 17368/* 17369 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17370 * any interesting requests and then jump to the real instruction 17371 * handler. Unlike the Arm handler, we can't do this as a tail call 17372 * because rIBASE is caller save and we need to reload it. 17373 */ 17374 movl rSELF, %eax 17375 movl rPC, OUT_ARG0(%esp) 17376 movl %eax, OUT_ARG1(%esp) 17377 call dvmCheckInst # (dPC, self) 17378 movl rSELF, %ecx 17379 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17380 jmp *dvmAsmInstructionStart+(346*4) 17381 17382/* ------------------------------ */ 17383.L_ALT_OP_UNUSED_5BFF: /* 0x15b */ 17384/* File: x86/ALT_STUB.S */ 17385/* 17386 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17387 * any interesting requests and then jump to the real instruction 17388 * handler. Unlike the Arm handler, we can't do this as a tail call 17389 * because rIBASE is caller save and we need to reload it. 17390 */ 17391 movl rSELF, %eax 17392 movl rPC, OUT_ARG0(%esp) 17393 movl %eax, OUT_ARG1(%esp) 17394 call dvmCheckInst # (dPC, self) 17395 movl rSELF, %ecx 17396 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17397 jmp *dvmAsmInstructionStart+(347*4) 17398 17399/* ------------------------------ */ 17400.L_ALT_OP_UNUSED_5CFF: /* 0x15c */ 17401/* File: x86/ALT_STUB.S */ 17402/* 17403 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17404 * any interesting requests and then jump to the real instruction 17405 * handler. Unlike the Arm handler, we can't do this as a tail call 17406 * because rIBASE is caller save and we need to reload it. 17407 */ 17408 movl rSELF, %eax 17409 movl rPC, OUT_ARG0(%esp) 17410 movl %eax, OUT_ARG1(%esp) 17411 call dvmCheckInst # (dPC, self) 17412 movl rSELF, %ecx 17413 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17414 jmp *dvmAsmInstructionStart+(348*4) 17415 17416/* ------------------------------ */ 17417.L_ALT_OP_UNUSED_5DFF: /* 0x15d */ 17418/* File: x86/ALT_STUB.S */ 17419/* 17420 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17421 * any interesting requests and then jump to the real instruction 17422 * handler. Unlike the Arm handler, we can't do this as a tail call 17423 * because rIBASE is caller save and we need to reload it. 17424 */ 17425 movl rSELF, %eax 17426 movl rPC, OUT_ARG0(%esp) 17427 movl %eax, OUT_ARG1(%esp) 17428 call dvmCheckInst # (dPC, self) 17429 movl rSELF, %ecx 17430 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17431 jmp *dvmAsmInstructionStart+(349*4) 17432 17433/* ------------------------------ */ 17434.L_ALT_OP_UNUSED_5EFF: /* 0x15e */ 17435/* File: x86/ALT_STUB.S */ 17436/* 17437 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17438 * any interesting requests and then jump to the real instruction 17439 * handler. Unlike the Arm handler, we can't do this as a tail call 17440 * because rIBASE is caller save and we need to reload it. 17441 */ 17442 movl rSELF, %eax 17443 movl rPC, OUT_ARG0(%esp) 17444 movl %eax, OUT_ARG1(%esp) 17445 call dvmCheckInst # (dPC, self) 17446 movl rSELF, %ecx 17447 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17448 jmp *dvmAsmInstructionStart+(350*4) 17449 17450/* ------------------------------ */ 17451.L_ALT_OP_UNUSED_5FFF: /* 0x15f */ 17452/* File: x86/ALT_STUB.S */ 17453/* 17454 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17455 * any interesting requests and then jump to the real instruction 17456 * handler. Unlike the Arm handler, we can't do this as a tail call 17457 * because rIBASE is caller save and we need to reload it. 17458 */ 17459 movl rSELF, %eax 17460 movl rPC, OUT_ARG0(%esp) 17461 movl %eax, OUT_ARG1(%esp) 17462 call dvmCheckInst # (dPC, self) 17463 movl rSELF, %ecx 17464 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17465 jmp *dvmAsmInstructionStart+(351*4) 17466 17467/* ------------------------------ */ 17468.L_ALT_OP_UNUSED_60FF: /* 0x160 */ 17469/* File: x86/ALT_STUB.S */ 17470/* 17471 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17472 * any interesting requests and then jump to the real instruction 17473 * handler. Unlike the Arm handler, we can't do this as a tail call 17474 * because rIBASE is caller save and we need to reload it. 17475 */ 17476 movl rSELF, %eax 17477 movl rPC, OUT_ARG0(%esp) 17478 movl %eax, OUT_ARG1(%esp) 17479 call dvmCheckInst # (dPC, self) 17480 movl rSELF, %ecx 17481 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17482 jmp *dvmAsmInstructionStart+(352*4) 17483 17484/* ------------------------------ */ 17485.L_ALT_OP_UNUSED_61FF: /* 0x161 */ 17486/* File: x86/ALT_STUB.S */ 17487/* 17488 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17489 * any interesting requests and then jump to the real instruction 17490 * handler. Unlike the Arm handler, we can't do this as a tail call 17491 * because rIBASE is caller save and we need to reload it. 17492 */ 17493 movl rSELF, %eax 17494 movl rPC, OUT_ARG0(%esp) 17495 movl %eax, OUT_ARG1(%esp) 17496 call dvmCheckInst # (dPC, self) 17497 movl rSELF, %ecx 17498 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17499 jmp *dvmAsmInstructionStart+(353*4) 17500 17501/* ------------------------------ */ 17502.L_ALT_OP_UNUSED_62FF: /* 0x162 */ 17503/* File: x86/ALT_STUB.S */ 17504/* 17505 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17506 * any interesting requests and then jump to the real instruction 17507 * handler. Unlike the Arm handler, we can't do this as a tail call 17508 * because rIBASE is caller save and we need to reload it. 17509 */ 17510 movl rSELF, %eax 17511 movl rPC, OUT_ARG0(%esp) 17512 movl %eax, OUT_ARG1(%esp) 17513 call dvmCheckInst # (dPC, self) 17514 movl rSELF, %ecx 17515 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17516 jmp *dvmAsmInstructionStart+(354*4) 17517 17518/* ------------------------------ */ 17519.L_ALT_OP_UNUSED_63FF: /* 0x163 */ 17520/* File: x86/ALT_STUB.S */ 17521/* 17522 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17523 * any interesting requests and then jump to the real instruction 17524 * handler. Unlike the Arm handler, we can't do this as a tail call 17525 * because rIBASE is caller save and we need to reload it. 17526 */ 17527 movl rSELF, %eax 17528 movl rPC, OUT_ARG0(%esp) 17529 movl %eax, OUT_ARG1(%esp) 17530 call dvmCheckInst # (dPC, self) 17531 movl rSELF, %ecx 17532 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17533 jmp *dvmAsmInstructionStart+(355*4) 17534 17535/* ------------------------------ */ 17536.L_ALT_OP_UNUSED_64FF: /* 0x164 */ 17537/* File: x86/ALT_STUB.S */ 17538/* 17539 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17540 * any interesting requests and then jump to the real instruction 17541 * handler. Unlike the Arm handler, we can't do this as a tail call 17542 * because rIBASE is caller save and we need to reload it. 17543 */ 17544 movl rSELF, %eax 17545 movl rPC, OUT_ARG0(%esp) 17546 movl %eax, OUT_ARG1(%esp) 17547 call dvmCheckInst # (dPC, self) 17548 movl rSELF, %ecx 17549 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17550 jmp *dvmAsmInstructionStart+(356*4) 17551 17552/* ------------------------------ */ 17553.L_ALT_OP_UNUSED_65FF: /* 0x165 */ 17554/* File: x86/ALT_STUB.S */ 17555/* 17556 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17557 * any interesting requests and then jump to the real instruction 17558 * handler. Unlike the Arm handler, we can't do this as a tail call 17559 * because rIBASE is caller save and we need to reload it. 17560 */ 17561 movl rSELF, %eax 17562 movl rPC, OUT_ARG0(%esp) 17563 movl %eax, OUT_ARG1(%esp) 17564 call dvmCheckInst # (dPC, self) 17565 movl rSELF, %ecx 17566 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17567 jmp *dvmAsmInstructionStart+(357*4) 17568 17569/* ------------------------------ */ 17570.L_ALT_OP_UNUSED_66FF: /* 0x166 */ 17571/* File: x86/ALT_STUB.S */ 17572/* 17573 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17574 * any interesting requests and then jump to the real instruction 17575 * handler. Unlike the Arm handler, we can't do this as a tail call 17576 * because rIBASE is caller save and we need to reload it. 17577 */ 17578 movl rSELF, %eax 17579 movl rPC, OUT_ARG0(%esp) 17580 movl %eax, OUT_ARG1(%esp) 17581 call dvmCheckInst # (dPC, self) 17582 movl rSELF, %ecx 17583 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17584 jmp *dvmAsmInstructionStart+(358*4) 17585 17586/* ------------------------------ */ 17587.L_ALT_OP_UNUSED_67FF: /* 0x167 */ 17588/* File: x86/ALT_STUB.S */ 17589/* 17590 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17591 * any interesting requests and then jump to the real instruction 17592 * handler. Unlike the Arm handler, we can't do this as a tail call 17593 * because rIBASE is caller save and we need to reload it. 17594 */ 17595 movl rSELF, %eax 17596 movl rPC, OUT_ARG0(%esp) 17597 movl %eax, OUT_ARG1(%esp) 17598 call dvmCheckInst # (dPC, self) 17599 movl rSELF, %ecx 17600 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17601 jmp *dvmAsmInstructionStart+(359*4) 17602 17603/* ------------------------------ */ 17604.L_ALT_OP_UNUSED_68FF: /* 0x168 */ 17605/* File: x86/ALT_STUB.S */ 17606/* 17607 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17608 * any interesting requests and then jump to the real instruction 17609 * handler. Unlike the Arm handler, we can't do this as a tail call 17610 * because rIBASE is caller save and we need to reload it. 17611 */ 17612 movl rSELF, %eax 17613 movl rPC, OUT_ARG0(%esp) 17614 movl %eax, OUT_ARG1(%esp) 17615 call dvmCheckInst # (dPC, self) 17616 movl rSELF, %ecx 17617 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17618 jmp *dvmAsmInstructionStart+(360*4) 17619 17620/* ------------------------------ */ 17621.L_ALT_OP_UNUSED_69FF: /* 0x169 */ 17622/* File: x86/ALT_STUB.S */ 17623/* 17624 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17625 * any interesting requests and then jump to the real instruction 17626 * handler. Unlike the Arm handler, we can't do this as a tail call 17627 * because rIBASE is caller save and we need to reload it. 17628 */ 17629 movl rSELF, %eax 17630 movl rPC, OUT_ARG0(%esp) 17631 movl %eax, OUT_ARG1(%esp) 17632 call dvmCheckInst # (dPC, self) 17633 movl rSELF, %ecx 17634 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17635 jmp *dvmAsmInstructionStart+(361*4) 17636 17637/* ------------------------------ */ 17638.L_ALT_OP_UNUSED_6AFF: /* 0x16a */ 17639/* File: x86/ALT_STUB.S */ 17640/* 17641 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17642 * any interesting requests and then jump to the real instruction 17643 * handler. Unlike the Arm handler, we can't do this as a tail call 17644 * because rIBASE is caller save and we need to reload it. 17645 */ 17646 movl rSELF, %eax 17647 movl rPC, OUT_ARG0(%esp) 17648 movl %eax, OUT_ARG1(%esp) 17649 call dvmCheckInst # (dPC, self) 17650 movl rSELF, %ecx 17651 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17652 jmp *dvmAsmInstructionStart+(362*4) 17653 17654/* ------------------------------ */ 17655.L_ALT_OP_UNUSED_6BFF: /* 0x16b */ 17656/* File: x86/ALT_STUB.S */ 17657/* 17658 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17659 * any interesting requests and then jump to the real instruction 17660 * handler. Unlike the Arm handler, we can't do this as a tail call 17661 * because rIBASE is caller save and we need to reload it. 17662 */ 17663 movl rSELF, %eax 17664 movl rPC, OUT_ARG0(%esp) 17665 movl %eax, OUT_ARG1(%esp) 17666 call dvmCheckInst # (dPC, self) 17667 movl rSELF, %ecx 17668 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17669 jmp *dvmAsmInstructionStart+(363*4) 17670 17671/* ------------------------------ */ 17672.L_ALT_OP_UNUSED_6CFF: /* 0x16c */ 17673/* File: x86/ALT_STUB.S */ 17674/* 17675 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17676 * any interesting requests and then jump to the real instruction 17677 * handler. Unlike the Arm handler, we can't do this as a tail call 17678 * because rIBASE is caller save and we need to reload it. 17679 */ 17680 movl rSELF, %eax 17681 movl rPC, OUT_ARG0(%esp) 17682 movl %eax, OUT_ARG1(%esp) 17683 call dvmCheckInst # (dPC, self) 17684 movl rSELF, %ecx 17685 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17686 jmp *dvmAsmInstructionStart+(364*4) 17687 17688/* ------------------------------ */ 17689.L_ALT_OP_UNUSED_6DFF: /* 0x16d */ 17690/* File: x86/ALT_STUB.S */ 17691/* 17692 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17693 * any interesting requests and then jump to the real instruction 17694 * handler. Unlike the Arm handler, we can't do this as a tail call 17695 * because rIBASE is caller save and we need to reload it. 17696 */ 17697 movl rSELF, %eax 17698 movl rPC, OUT_ARG0(%esp) 17699 movl %eax, OUT_ARG1(%esp) 17700 call dvmCheckInst # (dPC, self) 17701 movl rSELF, %ecx 17702 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17703 jmp *dvmAsmInstructionStart+(365*4) 17704 17705/* ------------------------------ */ 17706.L_ALT_OP_UNUSED_6EFF: /* 0x16e */ 17707/* File: x86/ALT_STUB.S */ 17708/* 17709 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17710 * any interesting requests and then jump to the real instruction 17711 * handler. Unlike the Arm handler, we can't do this as a tail call 17712 * because rIBASE is caller save and we need to reload it. 17713 */ 17714 movl rSELF, %eax 17715 movl rPC, OUT_ARG0(%esp) 17716 movl %eax, OUT_ARG1(%esp) 17717 call dvmCheckInst # (dPC, self) 17718 movl rSELF, %ecx 17719 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17720 jmp *dvmAsmInstructionStart+(366*4) 17721 17722/* ------------------------------ */ 17723.L_ALT_OP_UNUSED_6FFF: /* 0x16f */ 17724/* File: x86/ALT_STUB.S */ 17725/* 17726 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17727 * any interesting requests and then jump to the real instruction 17728 * handler. Unlike the Arm handler, we can't do this as a tail call 17729 * because rIBASE is caller save and we need to reload it. 17730 */ 17731 movl rSELF, %eax 17732 movl rPC, OUT_ARG0(%esp) 17733 movl %eax, OUT_ARG1(%esp) 17734 call dvmCheckInst # (dPC, self) 17735 movl rSELF, %ecx 17736 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17737 jmp *dvmAsmInstructionStart+(367*4) 17738 17739/* ------------------------------ */ 17740.L_ALT_OP_UNUSED_70FF: /* 0x170 */ 17741/* File: x86/ALT_STUB.S */ 17742/* 17743 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17744 * any interesting requests and then jump to the real instruction 17745 * handler. Unlike the Arm handler, we can't do this as a tail call 17746 * because rIBASE is caller save and we need to reload it. 17747 */ 17748 movl rSELF, %eax 17749 movl rPC, OUT_ARG0(%esp) 17750 movl %eax, OUT_ARG1(%esp) 17751 call dvmCheckInst # (dPC, self) 17752 movl rSELF, %ecx 17753 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17754 jmp *dvmAsmInstructionStart+(368*4) 17755 17756/* ------------------------------ */ 17757.L_ALT_OP_UNUSED_71FF: /* 0x171 */ 17758/* File: x86/ALT_STUB.S */ 17759/* 17760 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17761 * any interesting requests and then jump to the real instruction 17762 * handler. Unlike the Arm handler, we can't do this as a tail call 17763 * because rIBASE is caller save and we need to reload it. 17764 */ 17765 movl rSELF, %eax 17766 movl rPC, OUT_ARG0(%esp) 17767 movl %eax, OUT_ARG1(%esp) 17768 call dvmCheckInst # (dPC, self) 17769 movl rSELF, %ecx 17770 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17771 jmp *dvmAsmInstructionStart+(369*4) 17772 17773/* ------------------------------ */ 17774.L_ALT_OP_UNUSED_72FF: /* 0x172 */ 17775/* File: x86/ALT_STUB.S */ 17776/* 17777 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17778 * any interesting requests and then jump to the real instruction 17779 * handler. Unlike the Arm handler, we can't do this as a tail call 17780 * because rIBASE is caller save and we need to reload it. 17781 */ 17782 movl rSELF, %eax 17783 movl rPC, OUT_ARG0(%esp) 17784 movl %eax, OUT_ARG1(%esp) 17785 call dvmCheckInst # (dPC, self) 17786 movl rSELF, %ecx 17787 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17788 jmp *dvmAsmInstructionStart+(370*4) 17789 17790/* ------------------------------ */ 17791.L_ALT_OP_UNUSED_73FF: /* 0x173 */ 17792/* File: x86/ALT_STUB.S */ 17793/* 17794 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17795 * any interesting requests and then jump to the real instruction 17796 * handler. Unlike the Arm handler, we can't do this as a tail call 17797 * because rIBASE is caller save and we need to reload it. 17798 */ 17799 movl rSELF, %eax 17800 movl rPC, OUT_ARG0(%esp) 17801 movl %eax, OUT_ARG1(%esp) 17802 call dvmCheckInst # (dPC, self) 17803 movl rSELF, %ecx 17804 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17805 jmp *dvmAsmInstructionStart+(371*4) 17806 17807/* ------------------------------ */ 17808.L_ALT_OP_UNUSED_74FF: /* 0x174 */ 17809/* File: x86/ALT_STUB.S */ 17810/* 17811 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17812 * any interesting requests and then jump to the real instruction 17813 * handler. Unlike the Arm handler, we can't do this as a tail call 17814 * because rIBASE is caller save and we need to reload it. 17815 */ 17816 movl rSELF, %eax 17817 movl rPC, OUT_ARG0(%esp) 17818 movl %eax, OUT_ARG1(%esp) 17819 call dvmCheckInst # (dPC, self) 17820 movl rSELF, %ecx 17821 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17822 jmp *dvmAsmInstructionStart+(372*4) 17823 17824/* ------------------------------ */ 17825.L_ALT_OP_UNUSED_75FF: /* 0x175 */ 17826/* File: x86/ALT_STUB.S */ 17827/* 17828 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17829 * any interesting requests and then jump to the real instruction 17830 * handler. Unlike the Arm handler, we can't do this as a tail call 17831 * because rIBASE is caller save and we need to reload it. 17832 */ 17833 movl rSELF, %eax 17834 movl rPC, OUT_ARG0(%esp) 17835 movl %eax, OUT_ARG1(%esp) 17836 call dvmCheckInst # (dPC, self) 17837 movl rSELF, %ecx 17838 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17839 jmp *dvmAsmInstructionStart+(373*4) 17840 17841/* ------------------------------ */ 17842.L_ALT_OP_UNUSED_76FF: /* 0x176 */ 17843/* File: x86/ALT_STUB.S */ 17844/* 17845 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17846 * any interesting requests and then jump to the real instruction 17847 * handler. Unlike the Arm handler, we can't do this as a tail call 17848 * because rIBASE is caller save and we need to reload it. 17849 */ 17850 movl rSELF, %eax 17851 movl rPC, OUT_ARG0(%esp) 17852 movl %eax, OUT_ARG1(%esp) 17853 call dvmCheckInst # (dPC, self) 17854 movl rSELF, %ecx 17855 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17856 jmp *dvmAsmInstructionStart+(374*4) 17857 17858/* ------------------------------ */ 17859.L_ALT_OP_UNUSED_77FF: /* 0x177 */ 17860/* File: x86/ALT_STUB.S */ 17861/* 17862 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17863 * any interesting requests and then jump to the real instruction 17864 * handler. Unlike the Arm handler, we can't do this as a tail call 17865 * because rIBASE is caller save and we need to reload it. 17866 */ 17867 movl rSELF, %eax 17868 movl rPC, OUT_ARG0(%esp) 17869 movl %eax, OUT_ARG1(%esp) 17870 call dvmCheckInst # (dPC, self) 17871 movl rSELF, %ecx 17872 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17873 jmp *dvmAsmInstructionStart+(375*4) 17874 17875/* ------------------------------ */ 17876.L_ALT_OP_UNUSED_78FF: /* 0x178 */ 17877/* File: x86/ALT_STUB.S */ 17878/* 17879 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17880 * any interesting requests and then jump to the real instruction 17881 * handler. Unlike the Arm handler, we can't do this as a tail call 17882 * because rIBASE is caller save and we need to reload it. 17883 */ 17884 movl rSELF, %eax 17885 movl rPC, OUT_ARG0(%esp) 17886 movl %eax, OUT_ARG1(%esp) 17887 call dvmCheckInst # (dPC, self) 17888 movl rSELF, %ecx 17889 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17890 jmp *dvmAsmInstructionStart+(376*4) 17891 17892/* ------------------------------ */ 17893.L_ALT_OP_UNUSED_79FF: /* 0x179 */ 17894/* File: x86/ALT_STUB.S */ 17895/* 17896 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17897 * any interesting requests and then jump to the real instruction 17898 * handler. Unlike the Arm handler, we can't do this as a tail call 17899 * because rIBASE is caller save and we need to reload it. 17900 */ 17901 movl rSELF, %eax 17902 movl rPC, OUT_ARG0(%esp) 17903 movl %eax, OUT_ARG1(%esp) 17904 call dvmCheckInst # (dPC, self) 17905 movl rSELF, %ecx 17906 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17907 jmp *dvmAsmInstructionStart+(377*4) 17908 17909/* ------------------------------ */ 17910.L_ALT_OP_UNUSED_7AFF: /* 0x17a */ 17911/* File: x86/ALT_STUB.S */ 17912/* 17913 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17914 * any interesting requests and then jump to the real instruction 17915 * handler. Unlike the Arm handler, we can't do this as a tail call 17916 * because rIBASE is caller save and we need to reload it. 17917 */ 17918 movl rSELF, %eax 17919 movl rPC, OUT_ARG0(%esp) 17920 movl %eax, OUT_ARG1(%esp) 17921 call dvmCheckInst # (dPC, self) 17922 movl rSELF, %ecx 17923 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17924 jmp *dvmAsmInstructionStart+(378*4) 17925 17926/* ------------------------------ */ 17927.L_ALT_OP_UNUSED_7BFF: /* 0x17b */ 17928/* File: x86/ALT_STUB.S */ 17929/* 17930 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17931 * any interesting requests and then jump to the real instruction 17932 * handler. Unlike the Arm handler, we can't do this as a tail call 17933 * because rIBASE is caller save and we need to reload it. 17934 */ 17935 movl rSELF, %eax 17936 movl rPC, OUT_ARG0(%esp) 17937 movl %eax, OUT_ARG1(%esp) 17938 call dvmCheckInst # (dPC, self) 17939 movl rSELF, %ecx 17940 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17941 jmp *dvmAsmInstructionStart+(379*4) 17942 17943/* ------------------------------ */ 17944.L_ALT_OP_UNUSED_7CFF: /* 0x17c */ 17945/* File: x86/ALT_STUB.S */ 17946/* 17947 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17948 * any interesting requests and then jump to the real instruction 17949 * handler. Unlike the Arm handler, we can't do this as a tail call 17950 * because rIBASE is caller save and we need to reload it. 17951 */ 17952 movl rSELF, %eax 17953 movl rPC, OUT_ARG0(%esp) 17954 movl %eax, OUT_ARG1(%esp) 17955 call dvmCheckInst # (dPC, self) 17956 movl rSELF, %ecx 17957 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17958 jmp *dvmAsmInstructionStart+(380*4) 17959 17960/* ------------------------------ */ 17961.L_ALT_OP_UNUSED_7DFF: /* 0x17d */ 17962/* File: x86/ALT_STUB.S */ 17963/* 17964 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17965 * any interesting requests and then jump to the real instruction 17966 * handler. Unlike the Arm handler, we can't do this as a tail call 17967 * because rIBASE is caller save and we need to reload it. 17968 */ 17969 movl rSELF, %eax 17970 movl rPC, OUT_ARG0(%esp) 17971 movl %eax, OUT_ARG1(%esp) 17972 call dvmCheckInst # (dPC, self) 17973 movl rSELF, %ecx 17974 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17975 jmp *dvmAsmInstructionStart+(381*4) 17976 17977/* ------------------------------ */ 17978.L_ALT_OP_UNUSED_7EFF: /* 0x17e */ 17979/* File: x86/ALT_STUB.S */ 17980/* 17981 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17982 * any interesting requests and then jump to the real instruction 17983 * handler. Unlike the Arm handler, we can't do this as a tail call 17984 * because rIBASE is caller save and we need to reload it. 17985 */ 17986 movl rSELF, %eax 17987 movl rPC, OUT_ARG0(%esp) 17988 movl %eax, OUT_ARG1(%esp) 17989 call dvmCheckInst # (dPC, self) 17990 movl rSELF, %ecx 17991 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 17992 jmp *dvmAsmInstructionStart+(382*4) 17993 17994/* ------------------------------ */ 17995.L_ALT_OP_UNUSED_7FFF: /* 0x17f */ 17996/* File: x86/ALT_STUB.S */ 17997/* 17998 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 17999 * any interesting requests and then jump to the real instruction 18000 * handler. Unlike the Arm handler, we can't do this as a tail call 18001 * because rIBASE is caller save and we need to reload it. 18002 */ 18003 movl rSELF, %eax 18004 movl rPC, OUT_ARG0(%esp) 18005 movl %eax, OUT_ARG1(%esp) 18006 call dvmCheckInst # (dPC, self) 18007 movl rSELF, %ecx 18008 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18009 jmp *dvmAsmInstructionStart+(383*4) 18010 18011/* ------------------------------ */ 18012.L_ALT_OP_UNUSED_80FF: /* 0x180 */ 18013/* File: x86/ALT_STUB.S */ 18014/* 18015 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18016 * any interesting requests and then jump to the real instruction 18017 * handler. Unlike the Arm handler, we can't do this as a tail call 18018 * because rIBASE is caller save and we need to reload it. 18019 */ 18020 movl rSELF, %eax 18021 movl rPC, OUT_ARG0(%esp) 18022 movl %eax, OUT_ARG1(%esp) 18023 call dvmCheckInst # (dPC, self) 18024 movl rSELF, %ecx 18025 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18026 jmp *dvmAsmInstructionStart+(384*4) 18027 18028/* ------------------------------ */ 18029.L_ALT_OP_UNUSED_81FF: /* 0x181 */ 18030/* File: x86/ALT_STUB.S */ 18031/* 18032 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18033 * any interesting requests and then jump to the real instruction 18034 * handler. Unlike the Arm handler, we can't do this as a tail call 18035 * because rIBASE is caller save and we need to reload it. 18036 */ 18037 movl rSELF, %eax 18038 movl rPC, OUT_ARG0(%esp) 18039 movl %eax, OUT_ARG1(%esp) 18040 call dvmCheckInst # (dPC, self) 18041 movl rSELF, %ecx 18042 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18043 jmp *dvmAsmInstructionStart+(385*4) 18044 18045/* ------------------------------ */ 18046.L_ALT_OP_UNUSED_82FF: /* 0x182 */ 18047/* File: x86/ALT_STUB.S */ 18048/* 18049 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18050 * any interesting requests and then jump to the real instruction 18051 * handler. Unlike the Arm handler, we can't do this as a tail call 18052 * because rIBASE is caller save and we need to reload it. 18053 */ 18054 movl rSELF, %eax 18055 movl rPC, OUT_ARG0(%esp) 18056 movl %eax, OUT_ARG1(%esp) 18057 call dvmCheckInst # (dPC, self) 18058 movl rSELF, %ecx 18059 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18060 jmp *dvmAsmInstructionStart+(386*4) 18061 18062/* ------------------------------ */ 18063.L_ALT_OP_UNUSED_83FF: /* 0x183 */ 18064/* File: x86/ALT_STUB.S */ 18065/* 18066 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18067 * any interesting requests and then jump to the real instruction 18068 * handler. Unlike the Arm handler, we can't do this as a tail call 18069 * because rIBASE is caller save and we need to reload it. 18070 */ 18071 movl rSELF, %eax 18072 movl rPC, OUT_ARG0(%esp) 18073 movl %eax, OUT_ARG1(%esp) 18074 call dvmCheckInst # (dPC, self) 18075 movl rSELF, %ecx 18076 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18077 jmp *dvmAsmInstructionStart+(387*4) 18078 18079/* ------------------------------ */ 18080.L_ALT_OP_UNUSED_84FF: /* 0x184 */ 18081/* File: x86/ALT_STUB.S */ 18082/* 18083 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18084 * any interesting requests and then jump to the real instruction 18085 * handler. Unlike the Arm handler, we can't do this as a tail call 18086 * because rIBASE is caller save and we need to reload it. 18087 */ 18088 movl rSELF, %eax 18089 movl rPC, OUT_ARG0(%esp) 18090 movl %eax, OUT_ARG1(%esp) 18091 call dvmCheckInst # (dPC, self) 18092 movl rSELF, %ecx 18093 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18094 jmp *dvmAsmInstructionStart+(388*4) 18095 18096/* ------------------------------ */ 18097.L_ALT_OP_UNUSED_85FF: /* 0x185 */ 18098/* File: x86/ALT_STUB.S */ 18099/* 18100 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18101 * any interesting requests and then jump to the real instruction 18102 * handler. Unlike the Arm handler, we can't do this as a tail call 18103 * because rIBASE is caller save and we need to reload it. 18104 */ 18105 movl rSELF, %eax 18106 movl rPC, OUT_ARG0(%esp) 18107 movl %eax, OUT_ARG1(%esp) 18108 call dvmCheckInst # (dPC, self) 18109 movl rSELF, %ecx 18110 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18111 jmp *dvmAsmInstructionStart+(389*4) 18112 18113/* ------------------------------ */ 18114.L_ALT_OP_UNUSED_86FF: /* 0x186 */ 18115/* File: x86/ALT_STUB.S */ 18116/* 18117 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18118 * any interesting requests and then jump to the real instruction 18119 * handler. Unlike the Arm handler, we can't do this as a tail call 18120 * because rIBASE is caller save and we need to reload it. 18121 */ 18122 movl rSELF, %eax 18123 movl rPC, OUT_ARG0(%esp) 18124 movl %eax, OUT_ARG1(%esp) 18125 call dvmCheckInst # (dPC, self) 18126 movl rSELF, %ecx 18127 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18128 jmp *dvmAsmInstructionStart+(390*4) 18129 18130/* ------------------------------ */ 18131.L_ALT_OP_UNUSED_87FF: /* 0x187 */ 18132/* File: x86/ALT_STUB.S */ 18133/* 18134 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18135 * any interesting requests and then jump to the real instruction 18136 * handler. Unlike the Arm handler, we can't do this as a tail call 18137 * because rIBASE is caller save and we need to reload it. 18138 */ 18139 movl rSELF, %eax 18140 movl rPC, OUT_ARG0(%esp) 18141 movl %eax, OUT_ARG1(%esp) 18142 call dvmCheckInst # (dPC, self) 18143 movl rSELF, %ecx 18144 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18145 jmp *dvmAsmInstructionStart+(391*4) 18146 18147/* ------------------------------ */ 18148.L_ALT_OP_UNUSED_88FF: /* 0x188 */ 18149/* File: x86/ALT_STUB.S */ 18150/* 18151 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18152 * any interesting requests and then jump to the real instruction 18153 * handler. Unlike the Arm handler, we can't do this as a tail call 18154 * because rIBASE is caller save and we need to reload it. 18155 */ 18156 movl rSELF, %eax 18157 movl rPC, OUT_ARG0(%esp) 18158 movl %eax, OUT_ARG1(%esp) 18159 call dvmCheckInst # (dPC, self) 18160 movl rSELF, %ecx 18161 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18162 jmp *dvmAsmInstructionStart+(392*4) 18163 18164/* ------------------------------ */ 18165.L_ALT_OP_UNUSED_89FF: /* 0x189 */ 18166/* File: x86/ALT_STUB.S */ 18167/* 18168 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18169 * any interesting requests and then jump to the real instruction 18170 * handler. Unlike the Arm handler, we can't do this as a tail call 18171 * because rIBASE is caller save and we need to reload it. 18172 */ 18173 movl rSELF, %eax 18174 movl rPC, OUT_ARG0(%esp) 18175 movl %eax, OUT_ARG1(%esp) 18176 call dvmCheckInst # (dPC, self) 18177 movl rSELF, %ecx 18178 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18179 jmp *dvmAsmInstructionStart+(393*4) 18180 18181/* ------------------------------ */ 18182.L_ALT_OP_UNUSED_8AFF: /* 0x18a */ 18183/* File: x86/ALT_STUB.S */ 18184/* 18185 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18186 * any interesting requests and then jump to the real instruction 18187 * handler. Unlike the Arm handler, we can't do this as a tail call 18188 * because rIBASE is caller save and we need to reload it. 18189 */ 18190 movl rSELF, %eax 18191 movl rPC, OUT_ARG0(%esp) 18192 movl %eax, OUT_ARG1(%esp) 18193 call dvmCheckInst # (dPC, self) 18194 movl rSELF, %ecx 18195 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18196 jmp *dvmAsmInstructionStart+(394*4) 18197 18198/* ------------------------------ */ 18199.L_ALT_OP_UNUSED_8BFF: /* 0x18b */ 18200/* File: x86/ALT_STUB.S */ 18201/* 18202 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18203 * any interesting requests and then jump to the real instruction 18204 * handler. Unlike the Arm handler, we can't do this as a tail call 18205 * because rIBASE is caller save and we need to reload it. 18206 */ 18207 movl rSELF, %eax 18208 movl rPC, OUT_ARG0(%esp) 18209 movl %eax, OUT_ARG1(%esp) 18210 call dvmCheckInst # (dPC, self) 18211 movl rSELF, %ecx 18212 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18213 jmp *dvmAsmInstructionStart+(395*4) 18214 18215/* ------------------------------ */ 18216.L_ALT_OP_UNUSED_8CFF: /* 0x18c */ 18217/* File: x86/ALT_STUB.S */ 18218/* 18219 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18220 * any interesting requests and then jump to the real instruction 18221 * handler. Unlike the Arm handler, we can't do this as a tail call 18222 * because rIBASE is caller save and we need to reload it. 18223 */ 18224 movl rSELF, %eax 18225 movl rPC, OUT_ARG0(%esp) 18226 movl %eax, OUT_ARG1(%esp) 18227 call dvmCheckInst # (dPC, self) 18228 movl rSELF, %ecx 18229 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18230 jmp *dvmAsmInstructionStart+(396*4) 18231 18232/* ------------------------------ */ 18233.L_ALT_OP_UNUSED_8DFF: /* 0x18d */ 18234/* File: x86/ALT_STUB.S */ 18235/* 18236 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18237 * any interesting requests and then jump to the real instruction 18238 * handler. Unlike the Arm handler, we can't do this as a tail call 18239 * because rIBASE is caller save and we need to reload it. 18240 */ 18241 movl rSELF, %eax 18242 movl rPC, OUT_ARG0(%esp) 18243 movl %eax, OUT_ARG1(%esp) 18244 call dvmCheckInst # (dPC, self) 18245 movl rSELF, %ecx 18246 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18247 jmp *dvmAsmInstructionStart+(397*4) 18248 18249/* ------------------------------ */ 18250.L_ALT_OP_UNUSED_8EFF: /* 0x18e */ 18251/* File: x86/ALT_STUB.S */ 18252/* 18253 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18254 * any interesting requests and then jump to the real instruction 18255 * handler. Unlike the Arm handler, we can't do this as a tail call 18256 * because rIBASE is caller save and we need to reload it. 18257 */ 18258 movl rSELF, %eax 18259 movl rPC, OUT_ARG0(%esp) 18260 movl %eax, OUT_ARG1(%esp) 18261 call dvmCheckInst # (dPC, self) 18262 movl rSELF, %ecx 18263 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18264 jmp *dvmAsmInstructionStart+(398*4) 18265 18266/* ------------------------------ */ 18267.L_ALT_OP_UNUSED_8FFF: /* 0x18f */ 18268/* File: x86/ALT_STUB.S */ 18269/* 18270 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18271 * any interesting requests and then jump to the real instruction 18272 * handler. Unlike the Arm handler, we can't do this as a tail call 18273 * because rIBASE is caller save and we need to reload it. 18274 */ 18275 movl rSELF, %eax 18276 movl rPC, OUT_ARG0(%esp) 18277 movl %eax, OUT_ARG1(%esp) 18278 call dvmCheckInst # (dPC, self) 18279 movl rSELF, %ecx 18280 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18281 jmp *dvmAsmInstructionStart+(399*4) 18282 18283/* ------------------------------ */ 18284.L_ALT_OP_UNUSED_90FF: /* 0x190 */ 18285/* File: x86/ALT_STUB.S */ 18286/* 18287 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18288 * any interesting requests and then jump to the real instruction 18289 * handler. Unlike the Arm handler, we can't do this as a tail call 18290 * because rIBASE is caller save and we need to reload it. 18291 */ 18292 movl rSELF, %eax 18293 movl rPC, OUT_ARG0(%esp) 18294 movl %eax, OUT_ARG1(%esp) 18295 call dvmCheckInst # (dPC, self) 18296 movl rSELF, %ecx 18297 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18298 jmp *dvmAsmInstructionStart+(400*4) 18299 18300/* ------------------------------ */ 18301.L_ALT_OP_UNUSED_91FF: /* 0x191 */ 18302/* File: x86/ALT_STUB.S */ 18303/* 18304 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18305 * any interesting requests and then jump to the real instruction 18306 * handler. Unlike the Arm handler, we can't do this as a tail call 18307 * because rIBASE is caller save and we need to reload it. 18308 */ 18309 movl rSELF, %eax 18310 movl rPC, OUT_ARG0(%esp) 18311 movl %eax, OUT_ARG1(%esp) 18312 call dvmCheckInst # (dPC, self) 18313 movl rSELF, %ecx 18314 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18315 jmp *dvmAsmInstructionStart+(401*4) 18316 18317/* ------------------------------ */ 18318.L_ALT_OP_UNUSED_92FF: /* 0x192 */ 18319/* File: x86/ALT_STUB.S */ 18320/* 18321 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18322 * any interesting requests and then jump to the real instruction 18323 * handler. Unlike the Arm handler, we can't do this as a tail call 18324 * because rIBASE is caller save and we need to reload it. 18325 */ 18326 movl rSELF, %eax 18327 movl rPC, OUT_ARG0(%esp) 18328 movl %eax, OUT_ARG1(%esp) 18329 call dvmCheckInst # (dPC, self) 18330 movl rSELF, %ecx 18331 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18332 jmp *dvmAsmInstructionStart+(402*4) 18333 18334/* ------------------------------ */ 18335.L_ALT_OP_UNUSED_93FF: /* 0x193 */ 18336/* File: x86/ALT_STUB.S */ 18337/* 18338 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18339 * any interesting requests and then jump to the real instruction 18340 * handler. Unlike the Arm handler, we can't do this as a tail call 18341 * because rIBASE is caller save and we need to reload it. 18342 */ 18343 movl rSELF, %eax 18344 movl rPC, OUT_ARG0(%esp) 18345 movl %eax, OUT_ARG1(%esp) 18346 call dvmCheckInst # (dPC, self) 18347 movl rSELF, %ecx 18348 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18349 jmp *dvmAsmInstructionStart+(403*4) 18350 18351/* ------------------------------ */ 18352.L_ALT_OP_UNUSED_94FF: /* 0x194 */ 18353/* File: x86/ALT_STUB.S */ 18354/* 18355 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18356 * any interesting requests and then jump to the real instruction 18357 * handler. Unlike the Arm handler, we can't do this as a tail call 18358 * because rIBASE is caller save and we need to reload it. 18359 */ 18360 movl rSELF, %eax 18361 movl rPC, OUT_ARG0(%esp) 18362 movl %eax, OUT_ARG1(%esp) 18363 call dvmCheckInst # (dPC, self) 18364 movl rSELF, %ecx 18365 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18366 jmp *dvmAsmInstructionStart+(404*4) 18367 18368/* ------------------------------ */ 18369.L_ALT_OP_UNUSED_95FF: /* 0x195 */ 18370/* File: x86/ALT_STUB.S */ 18371/* 18372 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18373 * any interesting requests and then jump to the real instruction 18374 * handler. Unlike the Arm handler, we can't do this as a tail call 18375 * because rIBASE is caller save and we need to reload it. 18376 */ 18377 movl rSELF, %eax 18378 movl rPC, OUT_ARG0(%esp) 18379 movl %eax, OUT_ARG1(%esp) 18380 call dvmCheckInst # (dPC, self) 18381 movl rSELF, %ecx 18382 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18383 jmp *dvmAsmInstructionStart+(405*4) 18384 18385/* ------------------------------ */ 18386.L_ALT_OP_UNUSED_96FF: /* 0x196 */ 18387/* File: x86/ALT_STUB.S */ 18388/* 18389 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18390 * any interesting requests and then jump to the real instruction 18391 * handler. Unlike the Arm handler, we can't do this as a tail call 18392 * because rIBASE is caller save and we need to reload it. 18393 */ 18394 movl rSELF, %eax 18395 movl rPC, OUT_ARG0(%esp) 18396 movl %eax, OUT_ARG1(%esp) 18397 call dvmCheckInst # (dPC, self) 18398 movl rSELF, %ecx 18399 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18400 jmp *dvmAsmInstructionStart+(406*4) 18401 18402/* ------------------------------ */ 18403.L_ALT_OP_UNUSED_97FF: /* 0x197 */ 18404/* File: x86/ALT_STUB.S */ 18405/* 18406 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18407 * any interesting requests and then jump to the real instruction 18408 * handler. Unlike the Arm handler, we can't do this as a tail call 18409 * because rIBASE is caller save and we need to reload it. 18410 */ 18411 movl rSELF, %eax 18412 movl rPC, OUT_ARG0(%esp) 18413 movl %eax, OUT_ARG1(%esp) 18414 call dvmCheckInst # (dPC, self) 18415 movl rSELF, %ecx 18416 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18417 jmp *dvmAsmInstructionStart+(407*4) 18418 18419/* ------------------------------ */ 18420.L_ALT_OP_UNUSED_98FF: /* 0x198 */ 18421/* File: x86/ALT_STUB.S */ 18422/* 18423 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18424 * any interesting requests and then jump to the real instruction 18425 * handler. Unlike the Arm handler, we can't do this as a tail call 18426 * because rIBASE is caller save and we need to reload it. 18427 */ 18428 movl rSELF, %eax 18429 movl rPC, OUT_ARG0(%esp) 18430 movl %eax, OUT_ARG1(%esp) 18431 call dvmCheckInst # (dPC, self) 18432 movl rSELF, %ecx 18433 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18434 jmp *dvmAsmInstructionStart+(408*4) 18435 18436/* ------------------------------ */ 18437.L_ALT_OP_UNUSED_99FF: /* 0x199 */ 18438/* File: x86/ALT_STUB.S */ 18439/* 18440 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18441 * any interesting requests and then jump to the real instruction 18442 * handler. Unlike the Arm handler, we can't do this as a tail call 18443 * because rIBASE is caller save and we need to reload it. 18444 */ 18445 movl rSELF, %eax 18446 movl rPC, OUT_ARG0(%esp) 18447 movl %eax, OUT_ARG1(%esp) 18448 call dvmCheckInst # (dPC, self) 18449 movl rSELF, %ecx 18450 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18451 jmp *dvmAsmInstructionStart+(409*4) 18452 18453/* ------------------------------ */ 18454.L_ALT_OP_UNUSED_9AFF: /* 0x19a */ 18455/* File: x86/ALT_STUB.S */ 18456/* 18457 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18458 * any interesting requests and then jump to the real instruction 18459 * handler. Unlike the Arm handler, we can't do this as a tail call 18460 * because rIBASE is caller save and we need to reload it. 18461 */ 18462 movl rSELF, %eax 18463 movl rPC, OUT_ARG0(%esp) 18464 movl %eax, OUT_ARG1(%esp) 18465 call dvmCheckInst # (dPC, self) 18466 movl rSELF, %ecx 18467 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18468 jmp *dvmAsmInstructionStart+(410*4) 18469 18470/* ------------------------------ */ 18471.L_ALT_OP_UNUSED_9BFF: /* 0x19b */ 18472/* File: x86/ALT_STUB.S */ 18473/* 18474 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18475 * any interesting requests and then jump to the real instruction 18476 * handler. Unlike the Arm handler, we can't do this as a tail call 18477 * because rIBASE is caller save and we need to reload it. 18478 */ 18479 movl rSELF, %eax 18480 movl rPC, OUT_ARG0(%esp) 18481 movl %eax, OUT_ARG1(%esp) 18482 call dvmCheckInst # (dPC, self) 18483 movl rSELF, %ecx 18484 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18485 jmp *dvmAsmInstructionStart+(411*4) 18486 18487/* ------------------------------ */ 18488.L_ALT_OP_UNUSED_9CFF: /* 0x19c */ 18489/* File: x86/ALT_STUB.S */ 18490/* 18491 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18492 * any interesting requests and then jump to the real instruction 18493 * handler. Unlike the Arm handler, we can't do this as a tail call 18494 * because rIBASE is caller save and we need to reload it. 18495 */ 18496 movl rSELF, %eax 18497 movl rPC, OUT_ARG0(%esp) 18498 movl %eax, OUT_ARG1(%esp) 18499 call dvmCheckInst # (dPC, self) 18500 movl rSELF, %ecx 18501 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18502 jmp *dvmAsmInstructionStart+(412*4) 18503 18504/* ------------------------------ */ 18505.L_ALT_OP_UNUSED_9DFF: /* 0x19d */ 18506/* File: x86/ALT_STUB.S */ 18507/* 18508 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18509 * any interesting requests and then jump to the real instruction 18510 * handler. Unlike the Arm handler, we can't do this as a tail call 18511 * because rIBASE is caller save and we need to reload it. 18512 */ 18513 movl rSELF, %eax 18514 movl rPC, OUT_ARG0(%esp) 18515 movl %eax, OUT_ARG1(%esp) 18516 call dvmCheckInst # (dPC, self) 18517 movl rSELF, %ecx 18518 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18519 jmp *dvmAsmInstructionStart+(413*4) 18520 18521/* ------------------------------ */ 18522.L_ALT_OP_UNUSED_9EFF: /* 0x19e */ 18523/* File: x86/ALT_STUB.S */ 18524/* 18525 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18526 * any interesting requests and then jump to the real instruction 18527 * handler. Unlike the Arm handler, we can't do this as a tail call 18528 * because rIBASE is caller save and we need to reload it. 18529 */ 18530 movl rSELF, %eax 18531 movl rPC, OUT_ARG0(%esp) 18532 movl %eax, OUT_ARG1(%esp) 18533 call dvmCheckInst # (dPC, self) 18534 movl rSELF, %ecx 18535 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18536 jmp *dvmAsmInstructionStart+(414*4) 18537 18538/* ------------------------------ */ 18539.L_ALT_OP_UNUSED_9FFF: /* 0x19f */ 18540/* File: x86/ALT_STUB.S */ 18541/* 18542 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18543 * any interesting requests and then jump to the real instruction 18544 * handler. Unlike the Arm handler, we can't do this as a tail call 18545 * because rIBASE is caller save and we need to reload it. 18546 */ 18547 movl rSELF, %eax 18548 movl rPC, OUT_ARG0(%esp) 18549 movl %eax, OUT_ARG1(%esp) 18550 call dvmCheckInst # (dPC, self) 18551 movl rSELF, %ecx 18552 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18553 jmp *dvmAsmInstructionStart+(415*4) 18554 18555/* ------------------------------ */ 18556.L_ALT_OP_UNUSED_A0FF: /* 0x1a0 */ 18557/* File: x86/ALT_STUB.S */ 18558/* 18559 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18560 * any interesting requests and then jump to the real instruction 18561 * handler. Unlike the Arm handler, we can't do this as a tail call 18562 * because rIBASE is caller save and we need to reload it. 18563 */ 18564 movl rSELF, %eax 18565 movl rPC, OUT_ARG0(%esp) 18566 movl %eax, OUT_ARG1(%esp) 18567 call dvmCheckInst # (dPC, self) 18568 movl rSELF, %ecx 18569 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18570 jmp *dvmAsmInstructionStart+(416*4) 18571 18572/* ------------------------------ */ 18573.L_ALT_OP_UNUSED_A1FF: /* 0x1a1 */ 18574/* File: x86/ALT_STUB.S */ 18575/* 18576 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18577 * any interesting requests and then jump to the real instruction 18578 * handler. Unlike the Arm handler, we can't do this as a tail call 18579 * because rIBASE is caller save and we need to reload it. 18580 */ 18581 movl rSELF, %eax 18582 movl rPC, OUT_ARG0(%esp) 18583 movl %eax, OUT_ARG1(%esp) 18584 call dvmCheckInst # (dPC, self) 18585 movl rSELF, %ecx 18586 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18587 jmp *dvmAsmInstructionStart+(417*4) 18588 18589/* ------------------------------ */ 18590.L_ALT_OP_UNUSED_A2FF: /* 0x1a2 */ 18591/* File: x86/ALT_STUB.S */ 18592/* 18593 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18594 * any interesting requests and then jump to the real instruction 18595 * handler. Unlike the Arm handler, we can't do this as a tail call 18596 * because rIBASE is caller save and we need to reload it. 18597 */ 18598 movl rSELF, %eax 18599 movl rPC, OUT_ARG0(%esp) 18600 movl %eax, OUT_ARG1(%esp) 18601 call dvmCheckInst # (dPC, self) 18602 movl rSELF, %ecx 18603 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18604 jmp *dvmAsmInstructionStart+(418*4) 18605 18606/* ------------------------------ */ 18607.L_ALT_OP_UNUSED_A3FF: /* 0x1a3 */ 18608/* File: x86/ALT_STUB.S */ 18609/* 18610 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18611 * any interesting requests and then jump to the real instruction 18612 * handler. Unlike the Arm handler, we can't do this as a tail call 18613 * because rIBASE is caller save and we need to reload it. 18614 */ 18615 movl rSELF, %eax 18616 movl rPC, OUT_ARG0(%esp) 18617 movl %eax, OUT_ARG1(%esp) 18618 call dvmCheckInst # (dPC, self) 18619 movl rSELF, %ecx 18620 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18621 jmp *dvmAsmInstructionStart+(419*4) 18622 18623/* ------------------------------ */ 18624.L_ALT_OP_UNUSED_A4FF: /* 0x1a4 */ 18625/* File: x86/ALT_STUB.S */ 18626/* 18627 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18628 * any interesting requests and then jump to the real instruction 18629 * handler. Unlike the Arm handler, we can't do this as a tail call 18630 * because rIBASE is caller save and we need to reload it. 18631 */ 18632 movl rSELF, %eax 18633 movl rPC, OUT_ARG0(%esp) 18634 movl %eax, OUT_ARG1(%esp) 18635 call dvmCheckInst # (dPC, self) 18636 movl rSELF, %ecx 18637 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18638 jmp *dvmAsmInstructionStart+(420*4) 18639 18640/* ------------------------------ */ 18641.L_ALT_OP_UNUSED_A5FF: /* 0x1a5 */ 18642/* File: x86/ALT_STUB.S */ 18643/* 18644 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18645 * any interesting requests and then jump to the real instruction 18646 * handler. Unlike the Arm handler, we can't do this as a tail call 18647 * because rIBASE is caller save and we need to reload it. 18648 */ 18649 movl rSELF, %eax 18650 movl rPC, OUT_ARG0(%esp) 18651 movl %eax, OUT_ARG1(%esp) 18652 call dvmCheckInst # (dPC, self) 18653 movl rSELF, %ecx 18654 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18655 jmp *dvmAsmInstructionStart+(421*4) 18656 18657/* ------------------------------ */ 18658.L_ALT_OP_UNUSED_A6FF: /* 0x1a6 */ 18659/* File: x86/ALT_STUB.S */ 18660/* 18661 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18662 * any interesting requests and then jump to the real instruction 18663 * handler. Unlike the Arm handler, we can't do this as a tail call 18664 * because rIBASE is caller save and we need to reload it. 18665 */ 18666 movl rSELF, %eax 18667 movl rPC, OUT_ARG0(%esp) 18668 movl %eax, OUT_ARG1(%esp) 18669 call dvmCheckInst # (dPC, self) 18670 movl rSELF, %ecx 18671 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18672 jmp *dvmAsmInstructionStart+(422*4) 18673 18674/* ------------------------------ */ 18675.L_ALT_OP_UNUSED_A7FF: /* 0x1a7 */ 18676/* File: x86/ALT_STUB.S */ 18677/* 18678 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18679 * any interesting requests and then jump to the real instruction 18680 * handler. Unlike the Arm handler, we can't do this as a tail call 18681 * because rIBASE is caller save and we need to reload it. 18682 */ 18683 movl rSELF, %eax 18684 movl rPC, OUT_ARG0(%esp) 18685 movl %eax, OUT_ARG1(%esp) 18686 call dvmCheckInst # (dPC, self) 18687 movl rSELF, %ecx 18688 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18689 jmp *dvmAsmInstructionStart+(423*4) 18690 18691/* ------------------------------ */ 18692.L_ALT_OP_UNUSED_A8FF: /* 0x1a8 */ 18693/* File: x86/ALT_STUB.S */ 18694/* 18695 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18696 * any interesting requests and then jump to the real instruction 18697 * handler. Unlike the Arm handler, we can't do this as a tail call 18698 * because rIBASE is caller save and we need to reload it. 18699 */ 18700 movl rSELF, %eax 18701 movl rPC, OUT_ARG0(%esp) 18702 movl %eax, OUT_ARG1(%esp) 18703 call dvmCheckInst # (dPC, self) 18704 movl rSELF, %ecx 18705 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18706 jmp *dvmAsmInstructionStart+(424*4) 18707 18708/* ------------------------------ */ 18709.L_ALT_OP_UNUSED_A9FF: /* 0x1a9 */ 18710/* File: x86/ALT_STUB.S */ 18711/* 18712 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18713 * any interesting requests and then jump to the real instruction 18714 * handler. Unlike the Arm handler, we can't do this as a tail call 18715 * because rIBASE is caller save and we need to reload it. 18716 */ 18717 movl rSELF, %eax 18718 movl rPC, OUT_ARG0(%esp) 18719 movl %eax, OUT_ARG1(%esp) 18720 call dvmCheckInst # (dPC, self) 18721 movl rSELF, %ecx 18722 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18723 jmp *dvmAsmInstructionStart+(425*4) 18724 18725/* ------------------------------ */ 18726.L_ALT_OP_UNUSED_AAFF: /* 0x1aa */ 18727/* File: x86/ALT_STUB.S */ 18728/* 18729 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18730 * any interesting requests and then jump to the real instruction 18731 * handler. Unlike the Arm handler, we can't do this as a tail call 18732 * because rIBASE is caller save and we need to reload it. 18733 */ 18734 movl rSELF, %eax 18735 movl rPC, OUT_ARG0(%esp) 18736 movl %eax, OUT_ARG1(%esp) 18737 call dvmCheckInst # (dPC, self) 18738 movl rSELF, %ecx 18739 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18740 jmp *dvmAsmInstructionStart+(426*4) 18741 18742/* ------------------------------ */ 18743.L_ALT_OP_UNUSED_ABFF: /* 0x1ab */ 18744/* File: x86/ALT_STUB.S */ 18745/* 18746 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18747 * any interesting requests and then jump to the real instruction 18748 * handler. Unlike the Arm handler, we can't do this as a tail call 18749 * because rIBASE is caller save and we need to reload it. 18750 */ 18751 movl rSELF, %eax 18752 movl rPC, OUT_ARG0(%esp) 18753 movl %eax, OUT_ARG1(%esp) 18754 call dvmCheckInst # (dPC, self) 18755 movl rSELF, %ecx 18756 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18757 jmp *dvmAsmInstructionStart+(427*4) 18758 18759/* ------------------------------ */ 18760.L_ALT_OP_UNUSED_ACFF: /* 0x1ac */ 18761/* File: x86/ALT_STUB.S */ 18762/* 18763 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18764 * any interesting requests and then jump to the real instruction 18765 * handler. Unlike the Arm handler, we can't do this as a tail call 18766 * because rIBASE is caller save and we need to reload it. 18767 */ 18768 movl rSELF, %eax 18769 movl rPC, OUT_ARG0(%esp) 18770 movl %eax, OUT_ARG1(%esp) 18771 call dvmCheckInst # (dPC, self) 18772 movl rSELF, %ecx 18773 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18774 jmp *dvmAsmInstructionStart+(428*4) 18775 18776/* ------------------------------ */ 18777.L_ALT_OP_UNUSED_ADFF: /* 0x1ad */ 18778/* File: x86/ALT_STUB.S */ 18779/* 18780 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18781 * any interesting requests and then jump to the real instruction 18782 * handler. Unlike the Arm handler, we can't do this as a tail call 18783 * because rIBASE is caller save and we need to reload it. 18784 */ 18785 movl rSELF, %eax 18786 movl rPC, OUT_ARG0(%esp) 18787 movl %eax, OUT_ARG1(%esp) 18788 call dvmCheckInst # (dPC, self) 18789 movl rSELF, %ecx 18790 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18791 jmp *dvmAsmInstructionStart+(429*4) 18792 18793/* ------------------------------ */ 18794.L_ALT_OP_UNUSED_AEFF: /* 0x1ae */ 18795/* File: x86/ALT_STUB.S */ 18796/* 18797 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18798 * any interesting requests and then jump to the real instruction 18799 * handler. Unlike the Arm handler, we can't do this as a tail call 18800 * because rIBASE is caller save and we need to reload it. 18801 */ 18802 movl rSELF, %eax 18803 movl rPC, OUT_ARG0(%esp) 18804 movl %eax, OUT_ARG1(%esp) 18805 call dvmCheckInst # (dPC, self) 18806 movl rSELF, %ecx 18807 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18808 jmp *dvmAsmInstructionStart+(430*4) 18809 18810/* ------------------------------ */ 18811.L_ALT_OP_UNUSED_AFFF: /* 0x1af */ 18812/* File: x86/ALT_STUB.S */ 18813/* 18814 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18815 * any interesting requests and then jump to the real instruction 18816 * handler. Unlike the Arm handler, we can't do this as a tail call 18817 * because rIBASE is caller save and we need to reload it. 18818 */ 18819 movl rSELF, %eax 18820 movl rPC, OUT_ARG0(%esp) 18821 movl %eax, OUT_ARG1(%esp) 18822 call dvmCheckInst # (dPC, self) 18823 movl rSELF, %ecx 18824 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18825 jmp *dvmAsmInstructionStart+(431*4) 18826 18827/* ------------------------------ */ 18828.L_ALT_OP_UNUSED_B0FF: /* 0x1b0 */ 18829/* File: x86/ALT_STUB.S */ 18830/* 18831 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18832 * any interesting requests and then jump to the real instruction 18833 * handler. Unlike the Arm handler, we can't do this as a tail call 18834 * because rIBASE is caller save and we need to reload it. 18835 */ 18836 movl rSELF, %eax 18837 movl rPC, OUT_ARG0(%esp) 18838 movl %eax, OUT_ARG1(%esp) 18839 call dvmCheckInst # (dPC, self) 18840 movl rSELF, %ecx 18841 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18842 jmp *dvmAsmInstructionStart+(432*4) 18843 18844/* ------------------------------ */ 18845.L_ALT_OP_UNUSED_B1FF: /* 0x1b1 */ 18846/* File: x86/ALT_STUB.S */ 18847/* 18848 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18849 * any interesting requests and then jump to the real instruction 18850 * handler. Unlike the Arm handler, we can't do this as a tail call 18851 * because rIBASE is caller save and we need to reload it. 18852 */ 18853 movl rSELF, %eax 18854 movl rPC, OUT_ARG0(%esp) 18855 movl %eax, OUT_ARG1(%esp) 18856 call dvmCheckInst # (dPC, self) 18857 movl rSELF, %ecx 18858 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18859 jmp *dvmAsmInstructionStart+(433*4) 18860 18861/* ------------------------------ */ 18862.L_ALT_OP_UNUSED_B2FF: /* 0x1b2 */ 18863/* File: x86/ALT_STUB.S */ 18864/* 18865 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18866 * any interesting requests and then jump to the real instruction 18867 * handler. Unlike the Arm handler, we can't do this as a tail call 18868 * because rIBASE is caller save and we need to reload it. 18869 */ 18870 movl rSELF, %eax 18871 movl rPC, OUT_ARG0(%esp) 18872 movl %eax, OUT_ARG1(%esp) 18873 call dvmCheckInst # (dPC, self) 18874 movl rSELF, %ecx 18875 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18876 jmp *dvmAsmInstructionStart+(434*4) 18877 18878/* ------------------------------ */ 18879.L_ALT_OP_UNUSED_B3FF: /* 0x1b3 */ 18880/* File: x86/ALT_STUB.S */ 18881/* 18882 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18883 * any interesting requests and then jump to the real instruction 18884 * handler. Unlike the Arm handler, we can't do this as a tail call 18885 * because rIBASE is caller save and we need to reload it. 18886 */ 18887 movl rSELF, %eax 18888 movl rPC, OUT_ARG0(%esp) 18889 movl %eax, OUT_ARG1(%esp) 18890 call dvmCheckInst # (dPC, self) 18891 movl rSELF, %ecx 18892 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18893 jmp *dvmAsmInstructionStart+(435*4) 18894 18895/* ------------------------------ */ 18896.L_ALT_OP_UNUSED_B4FF: /* 0x1b4 */ 18897/* File: x86/ALT_STUB.S */ 18898/* 18899 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18900 * any interesting requests and then jump to the real instruction 18901 * handler. Unlike the Arm handler, we can't do this as a tail call 18902 * because rIBASE is caller save and we need to reload it. 18903 */ 18904 movl rSELF, %eax 18905 movl rPC, OUT_ARG0(%esp) 18906 movl %eax, OUT_ARG1(%esp) 18907 call dvmCheckInst # (dPC, self) 18908 movl rSELF, %ecx 18909 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18910 jmp *dvmAsmInstructionStart+(436*4) 18911 18912/* ------------------------------ */ 18913.L_ALT_OP_UNUSED_B5FF: /* 0x1b5 */ 18914/* File: x86/ALT_STUB.S */ 18915/* 18916 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18917 * any interesting requests and then jump to the real instruction 18918 * handler. Unlike the Arm handler, we can't do this as a tail call 18919 * because rIBASE is caller save and we need to reload it. 18920 */ 18921 movl rSELF, %eax 18922 movl rPC, OUT_ARG0(%esp) 18923 movl %eax, OUT_ARG1(%esp) 18924 call dvmCheckInst # (dPC, self) 18925 movl rSELF, %ecx 18926 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18927 jmp *dvmAsmInstructionStart+(437*4) 18928 18929/* ------------------------------ */ 18930.L_ALT_OP_UNUSED_B6FF: /* 0x1b6 */ 18931/* File: x86/ALT_STUB.S */ 18932/* 18933 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18934 * any interesting requests and then jump to the real instruction 18935 * handler. Unlike the Arm handler, we can't do this as a tail call 18936 * because rIBASE is caller save and we need to reload it. 18937 */ 18938 movl rSELF, %eax 18939 movl rPC, OUT_ARG0(%esp) 18940 movl %eax, OUT_ARG1(%esp) 18941 call dvmCheckInst # (dPC, self) 18942 movl rSELF, %ecx 18943 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18944 jmp *dvmAsmInstructionStart+(438*4) 18945 18946/* ------------------------------ */ 18947.L_ALT_OP_UNUSED_B7FF: /* 0x1b7 */ 18948/* File: x86/ALT_STUB.S */ 18949/* 18950 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18951 * any interesting requests and then jump to the real instruction 18952 * handler. Unlike the Arm handler, we can't do this as a tail call 18953 * because rIBASE is caller save and we need to reload it. 18954 */ 18955 movl rSELF, %eax 18956 movl rPC, OUT_ARG0(%esp) 18957 movl %eax, OUT_ARG1(%esp) 18958 call dvmCheckInst # (dPC, self) 18959 movl rSELF, %ecx 18960 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18961 jmp *dvmAsmInstructionStart+(439*4) 18962 18963/* ------------------------------ */ 18964.L_ALT_OP_UNUSED_B8FF: /* 0x1b8 */ 18965/* File: x86/ALT_STUB.S */ 18966/* 18967 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18968 * any interesting requests and then jump to the real instruction 18969 * handler. Unlike the Arm handler, we can't do this as a tail call 18970 * because rIBASE is caller save and we need to reload it. 18971 */ 18972 movl rSELF, %eax 18973 movl rPC, OUT_ARG0(%esp) 18974 movl %eax, OUT_ARG1(%esp) 18975 call dvmCheckInst # (dPC, self) 18976 movl rSELF, %ecx 18977 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18978 jmp *dvmAsmInstructionStart+(440*4) 18979 18980/* ------------------------------ */ 18981.L_ALT_OP_UNUSED_B9FF: /* 0x1b9 */ 18982/* File: x86/ALT_STUB.S */ 18983/* 18984 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 18985 * any interesting requests and then jump to the real instruction 18986 * handler. Unlike the Arm handler, we can't do this as a tail call 18987 * because rIBASE is caller save and we need to reload it. 18988 */ 18989 movl rSELF, %eax 18990 movl rPC, OUT_ARG0(%esp) 18991 movl %eax, OUT_ARG1(%esp) 18992 call dvmCheckInst # (dPC, self) 18993 movl rSELF, %ecx 18994 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 18995 jmp *dvmAsmInstructionStart+(441*4) 18996 18997/* ------------------------------ */ 18998.L_ALT_OP_UNUSED_BAFF: /* 0x1ba */ 18999/* File: x86/ALT_STUB.S */ 19000/* 19001 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19002 * any interesting requests and then jump to the real instruction 19003 * handler. Unlike the Arm handler, we can't do this as a tail call 19004 * because rIBASE is caller save and we need to reload it. 19005 */ 19006 movl rSELF, %eax 19007 movl rPC, OUT_ARG0(%esp) 19008 movl %eax, OUT_ARG1(%esp) 19009 call dvmCheckInst # (dPC, self) 19010 movl rSELF, %ecx 19011 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19012 jmp *dvmAsmInstructionStart+(442*4) 19013 19014/* ------------------------------ */ 19015.L_ALT_OP_UNUSED_BBFF: /* 0x1bb */ 19016/* File: x86/ALT_STUB.S */ 19017/* 19018 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19019 * any interesting requests and then jump to the real instruction 19020 * handler. Unlike the Arm handler, we can't do this as a tail call 19021 * because rIBASE is caller save and we need to reload it. 19022 */ 19023 movl rSELF, %eax 19024 movl rPC, OUT_ARG0(%esp) 19025 movl %eax, OUT_ARG1(%esp) 19026 call dvmCheckInst # (dPC, self) 19027 movl rSELF, %ecx 19028 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19029 jmp *dvmAsmInstructionStart+(443*4) 19030 19031/* ------------------------------ */ 19032.L_ALT_OP_UNUSED_BCFF: /* 0x1bc */ 19033/* File: x86/ALT_STUB.S */ 19034/* 19035 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19036 * any interesting requests and then jump to the real instruction 19037 * handler. Unlike the Arm handler, we can't do this as a tail call 19038 * because rIBASE is caller save and we need to reload it. 19039 */ 19040 movl rSELF, %eax 19041 movl rPC, OUT_ARG0(%esp) 19042 movl %eax, OUT_ARG1(%esp) 19043 call dvmCheckInst # (dPC, self) 19044 movl rSELF, %ecx 19045 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19046 jmp *dvmAsmInstructionStart+(444*4) 19047 19048/* ------------------------------ */ 19049.L_ALT_OP_UNUSED_BDFF: /* 0x1bd */ 19050/* File: x86/ALT_STUB.S */ 19051/* 19052 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19053 * any interesting requests and then jump to the real instruction 19054 * handler. Unlike the Arm handler, we can't do this as a tail call 19055 * because rIBASE is caller save and we need to reload it. 19056 */ 19057 movl rSELF, %eax 19058 movl rPC, OUT_ARG0(%esp) 19059 movl %eax, OUT_ARG1(%esp) 19060 call dvmCheckInst # (dPC, self) 19061 movl rSELF, %ecx 19062 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19063 jmp *dvmAsmInstructionStart+(445*4) 19064 19065/* ------------------------------ */ 19066.L_ALT_OP_UNUSED_BEFF: /* 0x1be */ 19067/* File: x86/ALT_STUB.S */ 19068/* 19069 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19070 * any interesting requests and then jump to the real instruction 19071 * handler. Unlike the Arm handler, we can't do this as a tail call 19072 * because rIBASE is caller save and we need to reload it. 19073 */ 19074 movl rSELF, %eax 19075 movl rPC, OUT_ARG0(%esp) 19076 movl %eax, OUT_ARG1(%esp) 19077 call dvmCheckInst # (dPC, self) 19078 movl rSELF, %ecx 19079 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19080 jmp *dvmAsmInstructionStart+(446*4) 19081 19082/* ------------------------------ */ 19083.L_ALT_OP_UNUSED_BFFF: /* 0x1bf */ 19084/* File: x86/ALT_STUB.S */ 19085/* 19086 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19087 * any interesting requests and then jump to the real instruction 19088 * handler. Unlike the Arm handler, we can't do this as a tail call 19089 * because rIBASE is caller save and we need to reload it. 19090 */ 19091 movl rSELF, %eax 19092 movl rPC, OUT_ARG0(%esp) 19093 movl %eax, OUT_ARG1(%esp) 19094 call dvmCheckInst # (dPC, self) 19095 movl rSELF, %ecx 19096 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19097 jmp *dvmAsmInstructionStart+(447*4) 19098 19099/* ------------------------------ */ 19100.L_ALT_OP_UNUSED_C0FF: /* 0x1c0 */ 19101/* File: x86/ALT_STUB.S */ 19102/* 19103 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19104 * any interesting requests and then jump to the real instruction 19105 * handler. Unlike the Arm handler, we can't do this as a tail call 19106 * because rIBASE is caller save and we need to reload it. 19107 */ 19108 movl rSELF, %eax 19109 movl rPC, OUT_ARG0(%esp) 19110 movl %eax, OUT_ARG1(%esp) 19111 call dvmCheckInst # (dPC, self) 19112 movl rSELF, %ecx 19113 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19114 jmp *dvmAsmInstructionStart+(448*4) 19115 19116/* ------------------------------ */ 19117.L_ALT_OP_UNUSED_C1FF: /* 0x1c1 */ 19118/* File: x86/ALT_STUB.S */ 19119/* 19120 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19121 * any interesting requests and then jump to the real instruction 19122 * handler. Unlike the Arm handler, we can't do this as a tail call 19123 * because rIBASE is caller save and we need to reload it. 19124 */ 19125 movl rSELF, %eax 19126 movl rPC, OUT_ARG0(%esp) 19127 movl %eax, OUT_ARG1(%esp) 19128 call dvmCheckInst # (dPC, self) 19129 movl rSELF, %ecx 19130 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19131 jmp *dvmAsmInstructionStart+(449*4) 19132 19133/* ------------------------------ */ 19134.L_ALT_OP_UNUSED_C2FF: /* 0x1c2 */ 19135/* File: x86/ALT_STUB.S */ 19136/* 19137 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19138 * any interesting requests and then jump to the real instruction 19139 * handler. Unlike the Arm handler, we can't do this as a tail call 19140 * because rIBASE is caller save and we need to reload it. 19141 */ 19142 movl rSELF, %eax 19143 movl rPC, OUT_ARG0(%esp) 19144 movl %eax, OUT_ARG1(%esp) 19145 call dvmCheckInst # (dPC, self) 19146 movl rSELF, %ecx 19147 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19148 jmp *dvmAsmInstructionStart+(450*4) 19149 19150/* ------------------------------ */ 19151.L_ALT_OP_UNUSED_C3FF: /* 0x1c3 */ 19152/* File: x86/ALT_STUB.S */ 19153/* 19154 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19155 * any interesting requests and then jump to the real instruction 19156 * handler. Unlike the Arm handler, we can't do this as a tail call 19157 * because rIBASE is caller save and we need to reload it. 19158 */ 19159 movl rSELF, %eax 19160 movl rPC, OUT_ARG0(%esp) 19161 movl %eax, OUT_ARG1(%esp) 19162 call dvmCheckInst # (dPC, self) 19163 movl rSELF, %ecx 19164 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19165 jmp *dvmAsmInstructionStart+(451*4) 19166 19167/* ------------------------------ */ 19168.L_ALT_OP_UNUSED_C4FF: /* 0x1c4 */ 19169/* File: x86/ALT_STUB.S */ 19170/* 19171 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19172 * any interesting requests and then jump to the real instruction 19173 * handler. Unlike the Arm handler, we can't do this as a tail call 19174 * because rIBASE is caller save and we need to reload it. 19175 */ 19176 movl rSELF, %eax 19177 movl rPC, OUT_ARG0(%esp) 19178 movl %eax, OUT_ARG1(%esp) 19179 call dvmCheckInst # (dPC, self) 19180 movl rSELF, %ecx 19181 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19182 jmp *dvmAsmInstructionStart+(452*4) 19183 19184/* ------------------------------ */ 19185.L_ALT_OP_UNUSED_C5FF: /* 0x1c5 */ 19186/* File: x86/ALT_STUB.S */ 19187/* 19188 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19189 * any interesting requests and then jump to the real instruction 19190 * handler. Unlike the Arm handler, we can't do this as a tail call 19191 * because rIBASE is caller save and we need to reload it. 19192 */ 19193 movl rSELF, %eax 19194 movl rPC, OUT_ARG0(%esp) 19195 movl %eax, OUT_ARG1(%esp) 19196 call dvmCheckInst # (dPC, self) 19197 movl rSELF, %ecx 19198 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19199 jmp *dvmAsmInstructionStart+(453*4) 19200 19201/* ------------------------------ */ 19202.L_ALT_OP_UNUSED_C6FF: /* 0x1c6 */ 19203/* File: x86/ALT_STUB.S */ 19204/* 19205 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19206 * any interesting requests and then jump to the real instruction 19207 * handler. Unlike the Arm handler, we can't do this as a tail call 19208 * because rIBASE is caller save and we need to reload it. 19209 */ 19210 movl rSELF, %eax 19211 movl rPC, OUT_ARG0(%esp) 19212 movl %eax, OUT_ARG1(%esp) 19213 call dvmCheckInst # (dPC, self) 19214 movl rSELF, %ecx 19215 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19216 jmp *dvmAsmInstructionStart+(454*4) 19217 19218/* ------------------------------ */ 19219.L_ALT_OP_UNUSED_C7FF: /* 0x1c7 */ 19220/* File: x86/ALT_STUB.S */ 19221/* 19222 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19223 * any interesting requests and then jump to the real instruction 19224 * handler. Unlike the Arm handler, we can't do this as a tail call 19225 * because rIBASE is caller save and we need to reload it. 19226 */ 19227 movl rSELF, %eax 19228 movl rPC, OUT_ARG0(%esp) 19229 movl %eax, OUT_ARG1(%esp) 19230 call dvmCheckInst # (dPC, self) 19231 movl rSELF, %ecx 19232 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19233 jmp *dvmAsmInstructionStart+(455*4) 19234 19235/* ------------------------------ */ 19236.L_ALT_OP_UNUSED_C8FF: /* 0x1c8 */ 19237/* File: x86/ALT_STUB.S */ 19238/* 19239 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19240 * any interesting requests and then jump to the real instruction 19241 * handler. Unlike the Arm handler, we can't do this as a tail call 19242 * because rIBASE is caller save and we need to reload it. 19243 */ 19244 movl rSELF, %eax 19245 movl rPC, OUT_ARG0(%esp) 19246 movl %eax, OUT_ARG1(%esp) 19247 call dvmCheckInst # (dPC, self) 19248 movl rSELF, %ecx 19249 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19250 jmp *dvmAsmInstructionStart+(456*4) 19251 19252/* ------------------------------ */ 19253.L_ALT_OP_UNUSED_C9FF: /* 0x1c9 */ 19254/* File: x86/ALT_STUB.S */ 19255/* 19256 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19257 * any interesting requests and then jump to the real instruction 19258 * handler. Unlike the Arm handler, we can't do this as a tail call 19259 * because rIBASE is caller save and we need to reload it. 19260 */ 19261 movl rSELF, %eax 19262 movl rPC, OUT_ARG0(%esp) 19263 movl %eax, OUT_ARG1(%esp) 19264 call dvmCheckInst # (dPC, self) 19265 movl rSELF, %ecx 19266 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19267 jmp *dvmAsmInstructionStart+(457*4) 19268 19269/* ------------------------------ */ 19270.L_ALT_OP_UNUSED_CAFF: /* 0x1ca */ 19271/* File: x86/ALT_STUB.S */ 19272/* 19273 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19274 * any interesting requests and then jump to the real instruction 19275 * handler. Unlike the Arm handler, we can't do this as a tail call 19276 * because rIBASE is caller save and we need to reload it. 19277 */ 19278 movl rSELF, %eax 19279 movl rPC, OUT_ARG0(%esp) 19280 movl %eax, OUT_ARG1(%esp) 19281 call dvmCheckInst # (dPC, self) 19282 movl rSELF, %ecx 19283 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19284 jmp *dvmAsmInstructionStart+(458*4) 19285 19286/* ------------------------------ */ 19287.L_ALT_OP_UNUSED_CBFF: /* 0x1cb */ 19288/* File: x86/ALT_STUB.S */ 19289/* 19290 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19291 * any interesting requests and then jump to the real instruction 19292 * handler. Unlike the Arm handler, we can't do this as a tail call 19293 * because rIBASE is caller save and we need to reload it. 19294 */ 19295 movl rSELF, %eax 19296 movl rPC, OUT_ARG0(%esp) 19297 movl %eax, OUT_ARG1(%esp) 19298 call dvmCheckInst # (dPC, self) 19299 movl rSELF, %ecx 19300 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19301 jmp *dvmAsmInstructionStart+(459*4) 19302 19303/* ------------------------------ */ 19304.L_ALT_OP_UNUSED_CCFF: /* 0x1cc */ 19305/* File: x86/ALT_STUB.S */ 19306/* 19307 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19308 * any interesting requests and then jump to the real instruction 19309 * handler. Unlike the Arm handler, we can't do this as a tail call 19310 * because rIBASE is caller save and we need to reload it. 19311 */ 19312 movl rSELF, %eax 19313 movl rPC, OUT_ARG0(%esp) 19314 movl %eax, OUT_ARG1(%esp) 19315 call dvmCheckInst # (dPC, self) 19316 movl rSELF, %ecx 19317 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19318 jmp *dvmAsmInstructionStart+(460*4) 19319 19320/* ------------------------------ */ 19321.L_ALT_OP_UNUSED_CDFF: /* 0x1cd */ 19322/* File: x86/ALT_STUB.S */ 19323/* 19324 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19325 * any interesting requests and then jump to the real instruction 19326 * handler. Unlike the Arm handler, we can't do this as a tail call 19327 * because rIBASE is caller save and we need to reload it. 19328 */ 19329 movl rSELF, %eax 19330 movl rPC, OUT_ARG0(%esp) 19331 movl %eax, OUT_ARG1(%esp) 19332 call dvmCheckInst # (dPC, self) 19333 movl rSELF, %ecx 19334 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19335 jmp *dvmAsmInstructionStart+(461*4) 19336 19337/* ------------------------------ */ 19338.L_ALT_OP_UNUSED_CEFF: /* 0x1ce */ 19339/* File: x86/ALT_STUB.S */ 19340/* 19341 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19342 * any interesting requests and then jump to the real instruction 19343 * handler. Unlike the Arm handler, we can't do this as a tail call 19344 * because rIBASE is caller save and we need to reload it. 19345 */ 19346 movl rSELF, %eax 19347 movl rPC, OUT_ARG0(%esp) 19348 movl %eax, OUT_ARG1(%esp) 19349 call dvmCheckInst # (dPC, self) 19350 movl rSELF, %ecx 19351 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19352 jmp *dvmAsmInstructionStart+(462*4) 19353 19354/* ------------------------------ */ 19355.L_ALT_OP_UNUSED_CFFF: /* 0x1cf */ 19356/* File: x86/ALT_STUB.S */ 19357/* 19358 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19359 * any interesting requests and then jump to the real instruction 19360 * handler. Unlike the Arm handler, we can't do this as a tail call 19361 * because rIBASE is caller save and we need to reload it. 19362 */ 19363 movl rSELF, %eax 19364 movl rPC, OUT_ARG0(%esp) 19365 movl %eax, OUT_ARG1(%esp) 19366 call dvmCheckInst # (dPC, self) 19367 movl rSELF, %ecx 19368 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19369 jmp *dvmAsmInstructionStart+(463*4) 19370 19371/* ------------------------------ */ 19372.L_ALT_OP_UNUSED_D0FF: /* 0x1d0 */ 19373/* File: x86/ALT_STUB.S */ 19374/* 19375 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19376 * any interesting requests and then jump to the real instruction 19377 * handler. Unlike the Arm handler, we can't do this as a tail call 19378 * because rIBASE is caller save and we need to reload it. 19379 */ 19380 movl rSELF, %eax 19381 movl rPC, OUT_ARG0(%esp) 19382 movl %eax, OUT_ARG1(%esp) 19383 call dvmCheckInst # (dPC, self) 19384 movl rSELF, %ecx 19385 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19386 jmp *dvmAsmInstructionStart+(464*4) 19387 19388/* ------------------------------ */ 19389.L_ALT_OP_UNUSED_D1FF: /* 0x1d1 */ 19390/* File: x86/ALT_STUB.S */ 19391/* 19392 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19393 * any interesting requests and then jump to the real instruction 19394 * handler. Unlike the Arm handler, we can't do this as a tail call 19395 * because rIBASE is caller save and we need to reload it. 19396 */ 19397 movl rSELF, %eax 19398 movl rPC, OUT_ARG0(%esp) 19399 movl %eax, OUT_ARG1(%esp) 19400 call dvmCheckInst # (dPC, self) 19401 movl rSELF, %ecx 19402 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19403 jmp *dvmAsmInstructionStart+(465*4) 19404 19405/* ------------------------------ */ 19406.L_ALT_OP_UNUSED_D2FF: /* 0x1d2 */ 19407/* File: x86/ALT_STUB.S */ 19408/* 19409 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19410 * any interesting requests and then jump to the real instruction 19411 * handler. Unlike the Arm handler, we can't do this as a tail call 19412 * because rIBASE is caller save and we need to reload it. 19413 */ 19414 movl rSELF, %eax 19415 movl rPC, OUT_ARG0(%esp) 19416 movl %eax, OUT_ARG1(%esp) 19417 call dvmCheckInst # (dPC, self) 19418 movl rSELF, %ecx 19419 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19420 jmp *dvmAsmInstructionStart+(466*4) 19421 19422/* ------------------------------ */ 19423.L_ALT_OP_UNUSED_D3FF: /* 0x1d3 */ 19424/* File: x86/ALT_STUB.S */ 19425/* 19426 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19427 * any interesting requests and then jump to the real instruction 19428 * handler. Unlike the Arm handler, we can't do this as a tail call 19429 * because rIBASE is caller save and we need to reload it. 19430 */ 19431 movl rSELF, %eax 19432 movl rPC, OUT_ARG0(%esp) 19433 movl %eax, OUT_ARG1(%esp) 19434 call dvmCheckInst # (dPC, self) 19435 movl rSELF, %ecx 19436 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19437 jmp *dvmAsmInstructionStart+(467*4) 19438 19439/* ------------------------------ */ 19440.L_ALT_OP_UNUSED_D4FF: /* 0x1d4 */ 19441/* File: x86/ALT_STUB.S */ 19442/* 19443 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19444 * any interesting requests and then jump to the real instruction 19445 * handler. Unlike the Arm handler, we can't do this as a tail call 19446 * because rIBASE is caller save and we need to reload it. 19447 */ 19448 movl rSELF, %eax 19449 movl rPC, OUT_ARG0(%esp) 19450 movl %eax, OUT_ARG1(%esp) 19451 call dvmCheckInst # (dPC, self) 19452 movl rSELF, %ecx 19453 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19454 jmp *dvmAsmInstructionStart+(468*4) 19455 19456/* ------------------------------ */ 19457.L_ALT_OP_UNUSED_D5FF: /* 0x1d5 */ 19458/* File: x86/ALT_STUB.S */ 19459/* 19460 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19461 * any interesting requests and then jump to the real instruction 19462 * handler. Unlike the Arm handler, we can't do this as a tail call 19463 * because rIBASE is caller save and we need to reload it. 19464 */ 19465 movl rSELF, %eax 19466 movl rPC, OUT_ARG0(%esp) 19467 movl %eax, OUT_ARG1(%esp) 19468 call dvmCheckInst # (dPC, self) 19469 movl rSELF, %ecx 19470 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19471 jmp *dvmAsmInstructionStart+(469*4) 19472 19473/* ------------------------------ */ 19474.L_ALT_OP_UNUSED_D6FF: /* 0x1d6 */ 19475/* File: x86/ALT_STUB.S */ 19476/* 19477 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19478 * any interesting requests and then jump to the real instruction 19479 * handler. Unlike the Arm handler, we can't do this as a tail call 19480 * because rIBASE is caller save and we need to reload it. 19481 */ 19482 movl rSELF, %eax 19483 movl rPC, OUT_ARG0(%esp) 19484 movl %eax, OUT_ARG1(%esp) 19485 call dvmCheckInst # (dPC, self) 19486 movl rSELF, %ecx 19487 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19488 jmp *dvmAsmInstructionStart+(470*4) 19489 19490/* ------------------------------ */ 19491.L_ALT_OP_UNUSED_D7FF: /* 0x1d7 */ 19492/* File: x86/ALT_STUB.S */ 19493/* 19494 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19495 * any interesting requests and then jump to the real instruction 19496 * handler. Unlike the Arm handler, we can't do this as a tail call 19497 * because rIBASE is caller save and we need to reload it. 19498 */ 19499 movl rSELF, %eax 19500 movl rPC, OUT_ARG0(%esp) 19501 movl %eax, OUT_ARG1(%esp) 19502 call dvmCheckInst # (dPC, self) 19503 movl rSELF, %ecx 19504 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19505 jmp *dvmAsmInstructionStart+(471*4) 19506 19507/* ------------------------------ */ 19508.L_ALT_OP_UNUSED_D8FF: /* 0x1d8 */ 19509/* File: x86/ALT_STUB.S */ 19510/* 19511 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19512 * any interesting requests and then jump to the real instruction 19513 * handler. Unlike the Arm handler, we can't do this as a tail call 19514 * because rIBASE is caller save and we need to reload it. 19515 */ 19516 movl rSELF, %eax 19517 movl rPC, OUT_ARG0(%esp) 19518 movl %eax, OUT_ARG1(%esp) 19519 call dvmCheckInst # (dPC, self) 19520 movl rSELF, %ecx 19521 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19522 jmp *dvmAsmInstructionStart+(472*4) 19523 19524/* ------------------------------ */ 19525.L_ALT_OP_UNUSED_D9FF: /* 0x1d9 */ 19526/* File: x86/ALT_STUB.S */ 19527/* 19528 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19529 * any interesting requests and then jump to the real instruction 19530 * handler. Unlike the Arm handler, we can't do this as a tail call 19531 * because rIBASE is caller save and we need to reload it. 19532 */ 19533 movl rSELF, %eax 19534 movl rPC, OUT_ARG0(%esp) 19535 movl %eax, OUT_ARG1(%esp) 19536 call dvmCheckInst # (dPC, self) 19537 movl rSELF, %ecx 19538 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19539 jmp *dvmAsmInstructionStart+(473*4) 19540 19541/* ------------------------------ */ 19542.L_ALT_OP_UNUSED_DAFF: /* 0x1da */ 19543/* File: x86/ALT_STUB.S */ 19544/* 19545 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19546 * any interesting requests and then jump to the real instruction 19547 * handler. Unlike the Arm handler, we can't do this as a tail call 19548 * because rIBASE is caller save and we need to reload it. 19549 */ 19550 movl rSELF, %eax 19551 movl rPC, OUT_ARG0(%esp) 19552 movl %eax, OUT_ARG1(%esp) 19553 call dvmCheckInst # (dPC, self) 19554 movl rSELF, %ecx 19555 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19556 jmp *dvmAsmInstructionStart+(474*4) 19557 19558/* ------------------------------ */ 19559.L_ALT_OP_UNUSED_DBFF: /* 0x1db */ 19560/* File: x86/ALT_STUB.S */ 19561/* 19562 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19563 * any interesting requests and then jump to the real instruction 19564 * handler. Unlike the Arm handler, we can't do this as a tail call 19565 * because rIBASE is caller save and we need to reload it. 19566 */ 19567 movl rSELF, %eax 19568 movl rPC, OUT_ARG0(%esp) 19569 movl %eax, OUT_ARG1(%esp) 19570 call dvmCheckInst # (dPC, self) 19571 movl rSELF, %ecx 19572 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19573 jmp *dvmAsmInstructionStart+(475*4) 19574 19575/* ------------------------------ */ 19576.L_ALT_OP_UNUSED_DCFF: /* 0x1dc */ 19577/* File: x86/ALT_STUB.S */ 19578/* 19579 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19580 * any interesting requests and then jump to the real instruction 19581 * handler. Unlike the Arm handler, we can't do this as a tail call 19582 * because rIBASE is caller save and we need to reload it. 19583 */ 19584 movl rSELF, %eax 19585 movl rPC, OUT_ARG0(%esp) 19586 movl %eax, OUT_ARG1(%esp) 19587 call dvmCheckInst # (dPC, self) 19588 movl rSELF, %ecx 19589 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19590 jmp *dvmAsmInstructionStart+(476*4) 19591 19592/* ------------------------------ */ 19593.L_ALT_OP_UNUSED_DDFF: /* 0x1dd */ 19594/* File: x86/ALT_STUB.S */ 19595/* 19596 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19597 * any interesting requests and then jump to the real instruction 19598 * handler. Unlike the Arm handler, we can't do this as a tail call 19599 * because rIBASE is caller save and we need to reload it. 19600 */ 19601 movl rSELF, %eax 19602 movl rPC, OUT_ARG0(%esp) 19603 movl %eax, OUT_ARG1(%esp) 19604 call dvmCheckInst # (dPC, self) 19605 movl rSELF, %ecx 19606 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19607 jmp *dvmAsmInstructionStart+(477*4) 19608 19609/* ------------------------------ */ 19610.L_ALT_OP_UNUSED_DEFF: /* 0x1de */ 19611/* File: x86/ALT_STUB.S */ 19612/* 19613 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19614 * any interesting requests and then jump to the real instruction 19615 * handler. Unlike the Arm handler, we can't do this as a tail call 19616 * because rIBASE is caller save and we need to reload it. 19617 */ 19618 movl rSELF, %eax 19619 movl rPC, OUT_ARG0(%esp) 19620 movl %eax, OUT_ARG1(%esp) 19621 call dvmCheckInst # (dPC, self) 19622 movl rSELF, %ecx 19623 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19624 jmp *dvmAsmInstructionStart+(478*4) 19625 19626/* ------------------------------ */ 19627.L_ALT_OP_UNUSED_DFFF: /* 0x1df */ 19628/* File: x86/ALT_STUB.S */ 19629/* 19630 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19631 * any interesting requests and then jump to the real instruction 19632 * handler. Unlike the Arm handler, we can't do this as a tail call 19633 * because rIBASE is caller save and we need to reload it. 19634 */ 19635 movl rSELF, %eax 19636 movl rPC, OUT_ARG0(%esp) 19637 movl %eax, OUT_ARG1(%esp) 19638 call dvmCheckInst # (dPC, self) 19639 movl rSELF, %ecx 19640 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19641 jmp *dvmAsmInstructionStart+(479*4) 19642 19643/* ------------------------------ */ 19644.L_ALT_OP_UNUSED_E0FF: /* 0x1e0 */ 19645/* File: x86/ALT_STUB.S */ 19646/* 19647 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19648 * any interesting requests and then jump to the real instruction 19649 * handler. Unlike the Arm handler, we can't do this as a tail call 19650 * because rIBASE is caller save and we need to reload it. 19651 */ 19652 movl rSELF, %eax 19653 movl rPC, OUT_ARG0(%esp) 19654 movl %eax, OUT_ARG1(%esp) 19655 call dvmCheckInst # (dPC, self) 19656 movl rSELF, %ecx 19657 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19658 jmp *dvmAsmInstructionStart+(480*4) 19659 19660/* ------------------------------ */ 19661.L_ALT_OP_UNUSED_E1FF: /* 0x1e1 */ 19662/* File: x86/ALT_STUB.S */ 19663/* 19664 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19665 * any interesting requests and then jump to the real instruction 19666 * handler. Unlike the Arm handler, we can't do this as a tail call 19667 * because rIBASE is caller save and we need to reload it. 19668 */ 19669 movl rSELF, %eax 19670 movl rPC, OUT_ARG0(%esp) 19671 movl %eax, OUT_ARG1(%esp) 19672 call dvmCheckInst # (dPC, self) 19673 movl rSELF, %ecx 19674 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19675 jmp *dvmAsmInstructionStart+(481*4) 19676 19677/* ------------------------------ */ 19678.L_ALT_OP_UNUSED_E2FF: /* 0x1e2 */ 19679/* File: x86/ALT_STUB.S */ 19680/* 19681 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19682 * any interesting requests and then jump to the real instruction 19683 * handler. Unlike the Arm handler, we can't do this as a tail call 19684 * because rIBASE is caller save and we need to reload it. 19685 */ 19686 movl rSELF, %eax 19687 movl rPC, OUT_ARG0(%esp) 19688 movl %eax, OUT_ARG1(%esp) 19689 call dvmCheckInst # (dPC, self) 19690 movl rSELF, %ecx 19691 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19692 jmp *dvmAsmInstructionStart+(482*4) 19693 19694/* ------------------------------ */ 19695.L_ALT_OP_UNUSED_E3FF: /* 0x1e3 */ 19696/* File: x86/ALT_STUB.S */ 19697/* 19698 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19699 * any interesting requests and then jump to the real instruction 19700 * handler. Unlike the Arm handler, we can't do this as a tail call 19701 * because rIBASE is caller save and we need to reload it. 19702 */ 19703 movl rSELF, %eax 19704 movl rPC, OUT_ARG0(%esp) 19705 movl %eax, OUT_ARG1(%esp) 19706 call dvmCheckInst # (dPC, self) 19707 movl rSELF, %ecx 19708 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19709 jmp *dvmAsmInstructionStart+(483*4) 19710 19711/* ------------------------------ */ 19712.L_ALT_OP_UNUSED_E4FF: /* 0x1e4 */ 19713/* File: x86/ALT_STUB.S */ 19714/* 19715 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19716 * any interesting requests and then jump to the real instruction 19717 * handler. Unlike the Arm handler, we can't do this as a tail call 19718 * because rIBASE is caller save and we need to reload it. 19719 */ 19720 movl rSELF, %eax 19721 movl rPC, OUT_ARG0(%esp) 19722 movl %eax, OUT_ARG1(%esp) 19723 call dvmCheckInst # (dPC, self) 19724 movl rSELF, %ecx 19725 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19726 jmp *dvmAsmInstructionStart+(484*4) 19727 19728/* ------------------------------ */ 19729.L_ALT_OP_UNUSED_E5FF: /* 0x1e5 */ 19730/* File: x86/ALT_STUB.S */ 19731/* 19732 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19733 * any interesting requests and then jump to the real instruction 19734 * handler. Unlike the Arm handler, we can't do this as a tail call 19735 * because rIBASE is caller save and we need to reload it. 19736 */ 19737 movl rSELF, %eax 19738 movl rPC, OUT_ARG0(%esp) 19739 movl %eax, OUT_ARG1(%esp) 19740 call dvmCheckInst # (dPC, self) 19741 movl rSELF, %ecx 19742 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19743 jmp *dvmAsmInstructionStart+(485*4) 19744 19745/* ------------------------------ */ 19746.L_ALT_OP_UNUSED_E6FF: /* 0x1e6 */ 19747/* File: x86/ALT_STUB.S */ 19748/* 19749 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19750 * any interesting requests and then jump to the real instruction 19751 * handler. Unlike the Arm handler, we can't do this as a tail call 19752 * because rIBASE is caller save and we need to reload it. 19753 */ 19754 movl rSELF, %eax 19755 movl rPC, OUT_ARG0(%esp) 19756 movl %eax, OUT_ARG1(%esp) 19757 call dvmCheckInst # (dPC, self) 19758 movl rSELF, %ecx 19759 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19760 jmp *dvmAsmInstructionStart+(486*4) 19761 19762/* ------------------------------ */ 19763.L_ALT_OP_UNUSED_E7FF: /* 0x1e7 */ 19764/* File: x86/ALT_STUB.S */ 19765/* 19766 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19767 * any interesting requests and then jump to the real instruction 19768 * handler. Unlike the Arm handler, we can't do this as a tail call 19769 * because rIBASE is caller save and we need to reload it. 19770 */ 19771 movl rSELF, %eax 19772 movl rPC, OUT_ARG0(%esp) 19773 movl %eax, OUT_ARG1(%esp) 19774 call dvmCheckInst # (dPC, self) 19775 movl rSELF, %ecx 19776 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19777 jmp *dvmAsmInstructionStart+(487*4) 19778 19779/* ------------------------------ */ 19780.L_ALT_OP_UNUSED_E8FF: /* 0x1e8 */ 19781/* File: x86/ALT_STUB.S */ 19782/* 19783 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19784 * any interesting requests and then jump to the real instruction 19785 * handler. Unlike the Arm handler, we can't do this as a tail call 19786 * because rIBASE is caller save and we need to reload it. 19787 */ 19788 movl rSELF, %eax 19789 movl rPC, OUT_ARG0(%esp) 19790 movl %eax, OUT_ARG1(%esp) 19791 call dvmCheckInst # (dPC, self) 19792 movl rSELF, %ecx 19793 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19794 jmp *dvmAsmInstructionStart+(488*4) 19795 19796/* ------------------------------ */ 19797.L_ALT_OP_UNUSED_E9FF: /* 0x1e9 */ 19798/* File: x86/ALT_STUB.S */ 19799/* 19800 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19801 * any interesting requests and then jump to the real instruction 19802 * handler. Unlike the Arm handler, we can't do this as a tail call 19803 * because rIBASE is caller save and we need to reload it. 19804 */ 19805 movl rSELF, %eax 19806 movl rPC, OUT_ARG0(%esp) 19807 movl %eax, OUT_ARG1(%esp) 19808 call dvmCheckInst # (dPC, self) 19809 movl rSELF, %ecx 19810 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19811 jmp *dvmAsmInstructionStart+(489*4) 19812 19813/* ------------------------------ */ 19814.L_ALT_OP_UNUSED_EAFF: /* 0x1ea */ 19815/* File: x86/ALT_STUB.S */ 19816/* 19817 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19818 * any interesting requests and then jump to the real instruction 19819 * handler. Unlike the Arm handler, we can't do this as a tail call 19820 * because rIBASE is caller save and we need to reload it. 19821 */ 19822 movl rSELF, %eax 19823 movl rPC, OUT_ARG0(%esp) 19824 movl %eax, OUT_ARG1(%esp) 19825 call dvmCheckInst # (dPC, self) 19826 movl rSELF, %ecx 19827 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19828 jmp *dvmAsmInstructionStart+(490*4) 19829 19830/* ------------------------------ */ 19831.L_ALT_OP_UNUSED_EBFF: /* 0x1eb */ 19832/* File: x86/ALT_STUB.S */ 19833/* 19834 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19835 * any interesting requests and then jump to the real instruction 19836 * handler. Unlike the Arm handler, we can't do this as a tail call 19837 * because rIBASE is caller save and we need to reload it. 19838 */ 19839 movl rSELF, %eax 19840 movl rPC, OUT_ARG0(%esp) 19841 movl %eax, OUT_ARG1(%esp) 19842 call dvmCheckInst # (dPC, self) 19843 movl rSELF, %ecx 19844 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19845 jmp *dvmAsmInstructionStart+(491*4) 19846 19847/* ------------------------------ */ 19848.L_ALT_OP_UNUSED_ECFF: /* 0x1ec */ 19849/* File: x86/ALT_STUB.S */ 19850/* 19851 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19852 * any interesting requests and then jump to the real instruction 19853 * handler. Unlike the Arm handler, we can't do this as a tail call 19854 * because rIBASE is caller save and we need to reload it. 19855 */ 19856 movl rSELF, %eax 19857 movl rPC, OUT_ARG0(%esp) 19858 movl %eax, OUT_ARG1(%esp) 19859 call dvmCheckInst # (dPC, self) 19860 movl rSELF, %ecx 19861 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19862 jmp *dvmAsmInstructionStart+(492*4) 19863 19864/* ------------------------------ */ 19865.L_ALT_OP_UNUSED_EDFF: /* 0x1ed */ 19866/* File: x86/ALT_STUB.S */ 19867/* 19868 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19869 * any interesting requests and then jump to the real instruction 19870 * handler. Unlike the Arm handler, we can't do this as a tail call 19871 * because rIBASE is caller save and we need to reload it. 19872 */ 19873 movl rSELF, %eax 19874 movl rPC, OUT_ARG0(%esp) 19875 movl %eax, OUT_ARG1(%esp) 19876 call dvmCheckInst # (dPC, self) 19877 movl rSELF, %ecx 19878 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19879 jmp *dvmAsmInstructionStart+(493*4) 19880 19881/* ------------------------------ */ 19882.L_ALT_OP_UNUSED_EEFF: /* 0x1ee */ 19883/* File: x86/ALT_STUB.S */ 19884/* 19885 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19886 * any interesting requests and then jump to the real instruction 19887 * handler. Unlike the Arm handler, we can't do this as a tail call 19888 * because rIBASE is caller save and we need to reload it. 19889 */ 19890 movl rSELF, %eax 19891 movl rPC, OUT_ARG0(%esp) 19892 movl %eax, OUT_ARG1(%esp) 19893 call dvmCheckInst # (dPC, self) 19894 movl rSELF, %ecx 19895 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19896 jmp *dvmAsmInstructionStart+(494*4) 19897 19898/* ------------------------------ */ 19899.L_ALT_OP_UNUSED_EFFF: /* 0x1ef */ 19900/* File: x86/ALT_STUB.S */ 19901/* 19902 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19903 * any interesting requests and then jump to the real instruction 19904 * handler. Unlike the Arm handler, we can't do this as a tail call 19905 * because rIBASE is caller save and we need to reload it. 19906 */ 19907 movl rSELF, %eax 19908 movl rPC, OUT_ARG0(%esp) 19909 movl %eax, OUT_ARG1(%esp) 19910 call dvmCheckInst # (dPC, self) 19911 movl rSELF, %ecx 19912 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19913 jmp *dvmAsmInstructionStart+(495*4) 19914 19915/* ------------------------------ */ 19916.L_ALT_OP_UNUSED_F0FF: /* 0x1f0 */ 19917/* File: x86/ALT_STUB.S */ 19918/* 19919 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19920 * any interesting requests and then jump to the real instruction 19921 * handler. Unlike the Arm handler, we can't do this as a tail call 19922 * because rIBASE is caller save and we need to reload it. 19923 */ 19924 movl rSELF, %eax 19925 movl rPC, OUT_ARG0(%esp) 19926 movl %eax, OUT_ARG1(%esp) 19927 call dvmCheckInst # (dPC, self) 19928 movl rSELF, %ecx 19929 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19930 jmp *dvmAsmInstructionStart+(496*4) 19931 19932/* ------------------------------ */ 19933.L_ALT_OP_UNUSED_F1FF: /* 0x1f1 */ 19934/* File: x86/ALT_STUB.S */ 19935/* 19936 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19937 * any interesting requests and then jump to the real instruction 19938 * handler. Unlike the Arm handler, we can't do this as a tail call 19939 * because rIBASE is caller save and we need to reload it. 19940 */ 19941 movl rSELF, %eax 19942 movl rPC, OUT_ARG0(%esp) 19943 movl %eax, OUT_ARG1(%esp) 19944 call dvmCheckInst # (dPC, self) 19945 movl rSELF, %ecx 19946 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19947 jmp *dvmAsmInstructionStart+(497*4) 19948 19949/* ------------------------------ */ 19950.L_ALT_OP_UNUSED_F2FF: /* 0x1f2 */ 19951/* File: x86/ALT_STUB.S */ 19952/* 19953 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19954 * any interesting requests and then jump to the real instruction 19955 * handler. Unlike the Arm handler, we can't do this as a tail call 19956 * because rIBASE is caller save and we need to reload it. 19957 */ 19958 movl rSELF, %eax 19959 movl rPC, OUT_ARG0(%esp) 19960 movl %eax, OUT_ARG1(%esp) 19961 call dvmCheckInst # (dPC, self) 19962 movl rSELF, %ecx 19963 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19964 jmp *dvmAsmInstructionStart+(498*4) 19965 19966/* ------------------------------ */ 19967.L_ALT_OP_UNUSED_F3FF: /* 0x1f3 */ 19968/* File: x86/ALT_STUB.S */ 19969/* 19970 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19971 * any interesting requests and then jump to the real instruction 19972 * handler. Unlike the Arm handler, we can't do this as a tail call 19973 * because rIBASE is caller save and we need to reload it. 19974 */ 19975 movl rSELF, %eax 19976 movl rPC, OUT_ARG0(%esp) 19977 movl %eax, OUT_ARG1(%esp) 19978 call dvmCheckInst # (dPC, self) 19979 movl rSELF, %ecx 19980 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19981 jmp *dvmAsmInstructionStart+(499*4) 19982 19983/* ------------------------------ */ 19984.L_ALT_OP_UNUSED_F4FF: /* 0x1f4 */ 19985/* File: x86/ALT_STUB.S */ 19986/* 19987 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 19988 * any interesting requests and then jump to the real instruction 19989 * handler. Unlike the Arm handler, we can't do this as a tail call 19990 * because rIBASE is caller save and we need to reload it. 19991 */ 19992 movl rSELF, %eax 19993 movl rPC, OUT_ARG0(%esp) 19994 movl %eax, OUT_ARG1(%esp) 19995 call dvmCheckInst # (dPC, self) 19996 movl rSELF, %ecx 19997 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 19998 jmp *dvmAsmInstructionStart+(500*4) 19999 20000/* ------------------------------ */ 20001.L_ALT_OP_UNUSED_F5FF: /* 0x1f5 */ 20002/* File: x86/ALT_STUB.S */ 20003/* 20004 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 20005 * any interesting requests and then jump to the real instruction 20006 * handler. Unlike the Arm handler, we can't do this as a tail call 20007 * because rIBASE is caller save and we need to reload it. 20008 */ 20009 movl rSELF, %eax 20010 movl rPC, OUT_ARG0(%esp) 20011 movl %eax, OUT_ARG1(%esp) 20012 call dvmCheckInst # (dPC, self) 20013 movl rSELF, %ecx 20014 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 20015 jmp *dvmAsmInstructionStart+(501*4) 20016 20017/* ------------------------------ */ 20018.L_ALT_OP_UNUSED_F6FF: /* 0x1f6 */ 20019/* File: x86/ALT_STUB.S */ 20020/* 20021 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 20022 * any interesting requests and then jump to the real instruction 20023 * handler. Unlike the Arm handler, we can't do this as a tail call 20024 * because rIBASE is caller save and we need to reload it. 20025 */ 20026 movl rSELF, %eax 20027 movl rPC, OUT_ARG0(%esp) 20028 movl %eax, OUT_ARG1(%esp) 20029 call dvmCheckInst # (dPC, self) 20030 movl rSELF, %ecx 20031 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 20032 jmp *dvmAsmInstructionStart+(502*4) 20033 20034/* ------------------------------ */ 20035.L_ALT_OP_UNUSED_F7FF: /* 0x1f7 */ 20036/* File: x86/ALT_STUB.S */ 20037/* 20038 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 20039 * any interesting requests and then jump to the real instruction 20040 * handler. Unlike the Arm handler, we can't do this as a tail call 20041 * because rIBASE is caller save and we need to reload it. 20042 */ 20043 movl rSELF, %eax 20044 movl rPC, OUT_ARG0(%esp) 20045 movl %eax, OUT_ARG1(%esp) 20046 call dvmCheckInst # (dPC, self) 20047 movl rSELF, %ecx 20048 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 20049 jmp *dvmAsmInstructionStart+(503*4) 20050 20051/* ------------------------------ */ 20052.L_ALT_OP_UNUSED_F8FF: /* 0x1f8 */ 20053/* File: x86/ALT_STUB.S */ 20054/* 20055 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 20056 * any interesting requests and then jump to the real instruction 20057 * handler. Unlike the Arm handler, we can't do this as a tail call 20058 * because rIBASE is caller save and we need to reload it. 20059 */ 20060 movl rSELF, %eax 20061 movl rPC, OUT_ARG0(%esp) 20062 movl %eax, OUT_ARG1(%esp) 20063 call dvmCheckInst # (dPC, self) 20064 movl rSELF, %ecx 20065 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 20066 jmp *dvmAsmInstructionStart+(504*4) 20067 20068/* ------------------------------ */ 20069.L_ALT_OP_UNUSED_F9FF: /* 0x1f9 */ 20070/* File: x86/ALT_STUB.S */ 20071/* 20072 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 20073 * any interesting requests and then jump to the real instruction 20074 * handler. Unlike the Arm handler, we can't do this as a tail call 20075 * because rIBASE is caller save and we need to reload it. 20076 */ 20077 movl rSELF, %eax 20078 movl rPC, OUT_ARG0(%esp) 20079 movl %eax, OUT_ARG1(%esp) 20080 call dvmCheckInst # (dPC, self) 20081 movl rSELF, %ecx 20082 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 20083 jmp *dvmAsmInstructionStart+(505*4) 20084 20085/* ------------------------------ */ 20086.L_ALT_OP_UNUSED_FAFF: /* 0x1fa */ 20087/* File: x86/ALT_STUB.S */ 20088/* 20089 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 20090 * any interesting requests and then jump to the real instruction 20091 * handler. Unlike the Arm handler, we can't do this as a tail call 20092 * because rIBASE is caller save and we need to reload it. 20093 */ 20094 movl rSELF, %eax 20095 movl rPC, OUT_ARG0(%esp) 20096 movl %eax, OUT_ARG1(%esp) 20097 call dvmCheckInst # (dPC, self) 20098 movl rSELF, %ecx 20099 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 20100 jmp *dvmAsmInstructionStart+(506*4) 20101 20102/* ------------------------------ */ 20103.L_ALT_OP_UNUSED_FBFF: /* 0x1fb */ 20104/* File: x86/ALT_STUB.S */ 20105/* 20106 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 20107 * any interesting requests and then jump to the real instruction 20108 * handler. Unlike the Arm handler, we can't do this as a tail call 20109 * because rIBASE is caller save and we need to reload it. 20110 */ 20111 movl rSELF, %eax 20112 movl rPC, OUT_ARG0(%esp) 20113 movl %eax, OUT_ARG1(%esp) 20114 call dvmCheckInst # (dPC, self) 20115 movl rSELF, %ecx 20116 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 20117 jmp *dvmAsmInstructionStart+(507*4) 20118 20119/* ------------------------------ */ 20120.L_ALT_OP_UNUSED_FCFF: /* 0x1fc */ 20121/* File: x86/ALT_STUB.S */ 20122/* 20123 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 20124 * any interesting requests and then jump to the real instruction 20125 * handler. Unlike the Arm handler, we can't do this as a tail call 20126 * because rIBASE is caller save and we need to reload it. 20127 */ 20128 movl rSELF, %eax 20129 movl rPC, OUT_ARG0(%esp) 20130 movl %eax, OUT_ARG1(%esp) 20131 call dvmCheckInst # (dPC, self) 20132 movl rSELF, %ecx 20133 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 20134 jmp *dvmAsmInstructionStart+(508*4) 20135 20136/* ------------------------------ */ 20137.L_ALT_OP_UNUSED_FDFF: /* 0x1fd */ 20138/* File: x86/ALT_STUB.S */ 20139/* 20140 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 20141 * any interesting requests and then jump to the real instruction 20142 * handler. Unlike the Arm handler, we can't do this as a tail call 20143 * because rIBASE is caller save and we need to reload it. 20144 */ 20145 movl rSELF, %eax 20146 movl rPC, OUT_ARG0(%esp) 20147 movl %eax, OUT_ARG1(%esp) 20148 call dvmCheckInst # (dPC, self) 20149 movl rSELF, %ecx 20150 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 20151 jmp *dvmAsmInstructionStart+(509*4) 20152 20153/* ------------------------------ */ 20154.L_ALT_OP_UNUSED_FEFF: /* 0x1fe */ 20155/* File: x86/ALT_STUB.S */ 20156/* 20157 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 20158 * any interesting requests and then jump to the real instruction 20159 * handler. Unlike the Arm handler, we can't do this as a tail call 20160 * because rIBASE is caller save and we need to reload it. 20161 */ 20162 movl rSELF, %eax 20163 movl rPC, OUT_ARG0(%esp) 20164 movl %eax, OUT_ARG1(%esp) 20165 call dvmCheckInst # (dPC, self) 20166 movl rSELF, %ecx 20167 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 20168 jmp *dvmAsmInstructionStart+(510*4) 20169 20170/* ------------------------------ */ 20171.L_ALT_OP_THROW_VERIFICATION_ERROR_JUMBO: /* 0x1ff */ 20172/* File: x86/ALT_STUB.S */ 20173/* 20174 * Inter-instruction transfer stub. Call out to dvmCheckInst to handle 20175 * any interesting requests and then jump to the real instruction 20176 * handler. Unlike the Arm handler, we can't do this as a tail call 20177 * because rIBASE is caller save and we need to reload it. 20178 */ 20179 movl rSELF, %eax 20180 movl rPC, OUT_ARG0(%esp) 20181 movl %eax, OUT_ARG1(%esp) 20182 call dvmCheckInst # (dPC, self) 20183 movl rSELF, %ecx 20184 movl offThread_curHandlerTable(%ecx), rIBASE # reload rIBASE 20185 jmp *dvmAsmInstructionStart+(511*4) 20186 20187 .size dvmAsmAltInstructionStartCode, .-dvmAsmAltInstructionStartCode 20188 .global dvmAsmAltInstructionEndCode 20189dvmAsmAltInstructionEndCode: 20190 20191 .global dvmAsmInstructionStart 20192 .text 20193dvmAsmInstructionStart: 20194 .long .L_OP_NOP /* 0x00 */ 20195 .long .L_OP_MOVE /* 0x01 */ 20196 .long .L_OP_MOVE_FROM16 /* 0x02 */ 20197 .long .L_OP_MOVE_16 /* 0x03 */ 20198 .long .L_OP_MOVE_WIDE /* 0x04 */ 20199 .long .L_OP_MOVE_WIDE_FROM16 /* 0x05 */ 20200 .long .L_OP_MOVE_WIDE_16 /* 0x06 */ 20201 .long .L_OP_MOVE_OBJECT /* 0x07 */ 20202 .long .L_OP_MOVE_OBJECT_FROM16 /* 0x08 */ 20203 .long .L_OP_MOVE_OBJECT_16 /* 0x09 */ 20204 .long .L_OP_MOVE_RESULT /* 0x0a */ 20205 .long .L_OP_MOVE_RESULT_WIDE /* 0x0b */ 20206 .long .L_OP_MOVE_RESULT_OBJECT /* 0x0c */ 20207 .long .L_OP_MOVE_EXCEPTION /* 0x0d */ 20208 .long .L_OP_RETURN_VOID /* 0x0e */ 20209 .long .L_OP_RETURN /* 0x0f */ 20210 .long .L_OP_RETURN_WIDE /* 0x10 */ 20211 .long .L_OP_RETURN_OBJECT /* 0x11 */ 20212 .long .L_OP_CONST_4 /* 0x12 */ 20213 .long .L_OP_CONST_16 /* 0x13 */ 20214 .long .L_OP_CONST /* 0x14 */ 20215 .long .L_OP_CONST_HIGH16 /* 0x15 */ 20216 .long .L_OP_CONST_WIDE_16 /* 0x16 */ 20217 .long .L_OP_CONST_WIDE_32 /* 0x17 */ 20218 .long .L_OP_CONST_WIDE /* 0x18 */ 20219 .long .L_OP_CONST_WIDE_HIGH16 /* 0x19 */ 20220 .long .L_OP_CONST_STRING /* 0x1a */ 20221 .long .L_OP_CONST_STRING_JUMBO /* 0x1b */ 20222 .long .L_OP_CONST_CLASS /* 0x1c */ 20223 .long .L_OP_MONITOR_ENTER /* 0x1d */ 20224 .long .L_OP_MONITOR_EXIT /* 0x1e */ 20225 .long .L_OP_CHECK_CAST /* 0x1f */ 20226 .long .L_OP_INSTANCE_OF /* 0x20 */ 20227 .long .L_OP_ARRAY_LENGTH /* 0x21 */ 20228 .long .L_OP_NEW_INSTANCE /* 0x22 */ 20229 .long .L_OP_NEW_ARRAY /* 0x23 */ 20230 .long .L_OP_FILLED_NEW_ARRAY /* 0x24 */ 20231 .long .L_OP_FILLED_NEW_ARRAY_RANGE /* 0x25 */ 20232 .long .L_OP_FILL_ARRAY_DATA /* 0x26 */ 20233 .long .L_OP_THROW /* 0x27 */ 20234 .long .L_OP_GOTO /* 0x28 */ 20235 .long .L_OP_GOTO_16 /* 0x29 */ 20236 .long .L_OP_GOTO_32 /* 0x2a */ 20237 .long .L_OP_PACKED_SWITCH /* 0x2b */ 20238 .long .L_OP_SPARSE_SWITCH /* 0x2c */ 20239 .long .L_OP_CMPL_FLOAT /* 0x2d */ 20240 .long .L_OP_CMPG_FLOAT /* 0x2e */ 20241 .long .L_OP_CMPL_DOUBLE /* 0x2f */ 20242 .long .L_OP_CMPG_DOUBLE /* 0x30 */ 20243 .long .L_OP_CMP_LONG /* 0x31 */ 20244 .long .L_OP_IF_EQ /* 0x32 */ 20245 .long .L_OP_IF_NE /* 0x33 */ 20246 .long .L_OP_IF_LT /* 0x34 */ 20247 .long .L_OP_IF_GE /* 0x35 */ 20248 .long .L_OP_IF_GT /* 0x36 */ 20249 .long .L_OP_IF_LE /* 0x37 */ 20250 .long .L_OP_IF_EQZ /* 0x38 */ 20251 .long .L_OP_IF_NEZ /* 0x39 */ 20252 .long .L_OP_IF_LTZ /* 0x3a */ 20253 .long .L_OP_IF_GEZ /* 0x3b */ 20254 .long .L_OP_IF_GTZ /* 0x3c */ 20255 .long .L_OP_IF_LEZ /* 0x3d */ 20256 .long .L_OP_UNUSED_3E /* 0x3e */ 20257 .long .L_OP_UNUSED_3F /* 0x3f */ 20258 .long .L_OP_UNUSED_40 /* 0x40 */ 20259 .long .L_OP_UNUSED_41 /* 0x41 */ 20260 .long .L_OP_UNUSED_42 /* 0x42 */ 20261 .long .L_OP_UNUSED_43 /* 0x43 */ 20262 .long .L_OP_AGET /* 0x44 */ 20263 .long .L_OP_AGET_WIDE /* 0x45 */ 20264 .long .L_OP_AGET_OBJECT /* 0x46 */ 20265 .long .L_OP_AGET_BOOLEAN /* 0x47 */ 20266 .long .L_OP_AGET_BYTE /* 0x48 */ 20267 .long .L_OP_AGET_CHAR /* 0x49 */ 20268 .long .L_OP_AGET_SHORT /* 0x4a */ 20269 .long .L_OP_APUT /* 0x4b */ 20270 .long .L_OP_APUT_WIDE /* 0x4c */ 20271 .long .L_OP_APUT_OBJECT /* 0x4d */ 20272 .long .L_OP_APUT_BOOLEAN /* 0x4e */ 20273 .long .L_OP_APUT_BYTE /* 0x4f */ 20274 .long .L_OP_APUT_CHAR /* 0x50 */ 20275 .long .L_OP_APUT_SHORT /* 0x51 */ 20276 .long .L_OP_IGET /* 0x52 */ 20277 .long .L_OP_IGET_WIDE /* 0x53 */ 20278 .long .L_OP_IGET_OBJECT /* 0x54 */ 20279 .long .L_OP_IGET_BOOLEAN /* 0x55 */ 20280 .long .L_OP_IGET_BYTE /* 0x56 */ 20281 .long .L_OP_IGET_CHAR /* 0x57 */ 20282 .long .L_OP_IGET_SHORT /* 0x58 */ 20283 .long .L_OP_IPUT /* 0x59 */ 20284 .long .L_OP_IPUT_WIDE /* 0x5a */ 20285 .long .L_OP_IPUT_OBJECT /* 0x5b */ 20286 .long .L_OP_IPUT_BOOLEAN /* 0x5c */ 20287 .long .L_OP_IPUT_BYTE /* 0x5d */ 20288 .long .L_OP_IPUT_CHAR /* 0x5e */ 20289 .long .L_OP_IPUT_SHORT /* 0x5f */ 20290 .long .L_OP_SGET /* 0x60 */ 20291 .long .L_OP_SGET_WIDE /* 0x61 */ 20292 .long .L_OP_SGET_OBJECT /* 0x62 */ 20293 .long .L_OP_SGET_BOOLEAN /* 0x63 */ 20294 .long .L_OP_SGET_BYTE /* 0x64 */ 20295 .long .L_OP_SGET_CHAR /* 0x65 */ 20296 .long .L_OP_SGET_SHORT /* 0x66 */ 20297 .long .L_OP_SPUT /* 0x67 */ 20298 .long .L_OP_SPUT_WIDE /* 0x68 */ 20299 .long .L_OP_SPUT_OBJECT /* 0x69 */ 20300 .long .L_OP_SPUT_BOOLEAN /* 0x6a */ 20301 .long .L_OP_SPUT_BYTE /* 0x6b */ 20302 .long .L_OP_SPUT_CHAR /* 0x6c */ 20303 .long .L_OP_SPUT_SHORT /* 0x6d */ 20304 .long .L_OP_INVOKE_VIRTUAL /* 0x6e */ 20305 .long .L_OP_INVOKE_SUPER /* 0x6f */ 20306 .long .L_OP_INVOKE_DIRECT /* 0x70 */ 20307 .long .L_OP_INVOKE_STATIC /* 0x71 */ 20308 .long .L_OP_INVOKE_INTERFACE /* 0x72 */ 20309 .long .L_OP_UNUSED_73 /* 0x73 */ 20310 .long .L_OP_INVOKE_VIRTUAL_RANGE /* 0x74 */ 20311 .long .L_OP_INVOKE_SUPER_RANGE /* 0x75 */ 20312 .long .L_OP_INVOKE_DIRECT_RANGE /* 0x76 */ 20313 .long .L_OP_INVOKE_STATIC_RANGE /* 0x77 */ 20314 .long .L_OP_INVOKE_INTERFACE_RANGE /* 0x78 */ 20315 .long .L_OP_UNUSED_79 /* 0x79 */ 20316 .long .L_OP_UNUSED_7A /* 0x7a */ 20317 .long .L_OP_NEG_INT /* 0x7b */ 20318 .long .L_OP_NOT_INT /* 0x7c */ 20319 .long .L_OP_NEG_LONG /* 0x7d */ 20320 .long .L_OP_NOT_LONG /* 0x7e */ 20321 .long .L_OP_NEG_FLOAT /* 0x7f */ 20322 .long .L_OP_NEG_DOUBLE /* 0x80 */ 20323 .long .L_OP_INT_TO_LONG /* 0x81 */ 20324 .long .L_OP_INT_TO_FLOAT /* 0x82 */ 20325 .long .L_OP_INT_TO_DOUBLE /* 0x83 */ 20326 .long .L_OP_LONG_TO_INT /* 0x84 */ 20327 .long .L_OP_LONG_TO_FLOAT /* 0x85 */ 20328 .long .L_OP_LONG_TO_DOUBLE /* 0x86 */ 20329 .long .L_OP_FLOAT_TO_INT /* 0x87 */ 20330 .long .L_OP_FLOAT_TO_LONG /* 0x88 */ 20331 .long .L_OP_FLOAT_TO_DOUBLE /* 0x89 */ 20332 .long .L_OP_DOUBLE_TO_INT /* 0x8a */ 20333 .long .L_OP_DOUBLE_TO_LONG /* 0x8b */ 20334 .long .L_OP_DOUBLE_TO_FLOAT /* 0x8c */ 20335 .long .L_OP_INT_TO_BYTE /* 0x8d */ 20336 .long .L_OP_INT_TO_CHAR /* 0x8e */ 20337 .long .L_OP_INT_TO_SHORT /* 0x8f */ 20338 .long .L_OP_ADD_INT /* 0x90 */ 20339 .long .L_OP_SUB_INT /* 0x91 */ 20340 .long .L_OP_MUL_INT /* 0x92 */ 20341 .long .L_OP_DIV_INT /* 0x93 */ 20342 .long .L_OP_REM_INT /* 0x94 */ 20343 .long .L_OP_AND_INT /* 0x95 */ 20344 .long .L_OP_OR_INT /* 0x96 */ 20345 .long .L_OP_XOR_INT /* 0x97 */ 20346 .long .L_OP_SHL_INT /* 0x98 */ 20347 .long .L_OP_SHR_INT /* 0x99 */ 20348 .long .L_OP_USHR_INT /* 0x9a */ 20349 .long .L_OP_ADD_LONG /* 0x9b */ 20350 .long .L_OP_SUB_LONG /* 0x9c */ 20351 .long .L_OP_MUL_LONG /* 0x9d */ 20352 .long .L_OP_DIV_LONG /* 0x9e */ 20353 .long .L_OP_REM_LONG /* 0x9f */ 20354 .long .L_OP_AND_LONG /* 0xa0 */ 20355 .long .L_OP_OR_LONG /* 0xa1 */ 20356 .long .L_OP_XOR_LONG /* 0xa2 */ 20357 .long .L_OP_SHL_LONG /* 0xa3 */ 20358 .long .L_OP_SHR_LONG /* 0xa4 */ 20359 .long .L_OP_USHR_LONG /* 0xa5 */ 20360 .long .L_OP_ADD_FLOAT /* 0xa6 */ 20361 .long .L_OP_SUB_FLOAT /* 0xa7 */ 20362 .long .L_OP_MUL_FLOAT /* 0xa8 */ 20363 .long .L_OP_DIV_FLOAT /* 0xa9 */ 20364 .long .L_OP_REM_FLOAT /* 0xaa */ 20365 .long .L_OP_ADD_DOUBLE /* 0xab */ 20366 .long .L_OP_SUB_DOUBLE /* 0xac */ 20367 .long .L_OP_MUL_DOUBLE /* 0xad */ 20368 .long .L_OP_DIV_DOUBLE /* 0xae */ 20369 .long .L_OP_REM_DOUBLE /* 0xaf */ 20370 .long .L_OP_ADD_INT_2ADDR /* 0xb0 */ 20371 .long .L_OP_SUB_INT_2ADDR /* 0xb1 */ 20372 .long .L_OP_MUL_INT_2ADDR /* 0xb2 */ 20373 .long .L_OP_DIV_INT_2ADDR /* 0xb3 */ 20374 .long .L_OP_REM_INT_2ADDR /* 0xb4 */ 20375 .long .L_OP_AND_INT_2ADDR /* 0xb5 */ 20376 .long .L_OP_OR_INT_2ADDR /* 0xb6 */ 20377 .long .L_OP_XOR_INT_2ADDR /* 0xb7 */ 20378 .long .L_OP_SHL_INT_2ADDR /* 0xb8 */ 20379 .long .L_OP_SHR_INT_2ADDR /* 0xb9 */ 20380 .long .L_OP_USHR_INT_2ADDR /* 0xba */ 20381 .long .L_OP_ADD_LONG_2ADDR /* 0xbb */ 20382 .long .L_OP_SUB_LONG_2ADDR /* 0xbc */ 20383 .long .L_OP_MUL_LONG_2ADDR /* 0xbd */ 20384 .long .L_OP_DIV_LONG_2ADDR /* 0xbe */ 20385 .long .L_OP_REM_LONG_2ADDR /* 0xbf */ 20386 .long .L_OP_AND_LONG_2ADDR /* 0xc0 */ 20387 .long .L_OP_OR_LONG_2ADDR /* 0xc1 */ 20388 .long .L_OP_XOR_LONG_2ADDR /* 0xc2 */ 20389 .long .L_OP_SHL_LONG_2ADDR /* 0xc3 */ 20390 .long .L_OP_SHR_LONG_2ADDR /* 0xc4 */ 20391 .long .L_OP_USHR_LONG_2ADDR /* 0xc5 */ 20392 .long .L_OP_ADD_FLOAT_2ADDR /* 0xc6 */ 20393 .long .L_OP_SUB_FLOAT_2ADDR /* 0xc7 */ 20394 .long .L_OP_MUL_FLOAT_2ADDR /* 0xc8 */ 20395 .long .L_OP_DIV_FLOAT_2ADDR /* 0xc9 */ 20396 .long .L_OP_REM_FLOAT_2ADDR /* 0xca */ 20397 .long .L_OP_ADD_DOUBLE_2ADDR /* 0xcb */ 20398 .long .L_OP_SUB_DOUBLE_2ADDR /* 0xcc */ 20399 .long .L_OP_MUL_DOUBLE_2ADDR /* 0xcd */ 20400 .long .L_OP_DIV_DOUBLE_2ADDR /* 0xce */ 20401 .long .L_OP_REM_DOUBLE_2ADDR /* 0xcf */ 20402 .long .L_OP_ADD_INT_LIT16 /* 0xd0 */ 20403 .long .L_OP_RSUB_INT /* 0xd1 */ 20404 .long .L_OP_MUL_INT_LIT16 /* 0xd2 */ 20405 .long .L_OP_DIV_INT_LIT16 /* 0xd3 */ 20406 .long .L_OP_REM_INT_LIT16 /* 0xd4 */ 20407 .long .L_OP_AND_INT_LIT16 /* 0xd5 */ 20408 .long .L_OP_OR_INT_LIT16 /* 0xd6 */ 20409 .long .L_OP_XOR_INT_LIT16 /* 0xd7 */ 20410 .long .L_OP_ADD_INT_LIT8 /* 0xd8 */ 20411 .long .L_OP_RSUB_INT_LIT8 /* 0xd9 */ 20412 .long .L_OP_MUL_INT_LIT8 /* 0xda */ 20413 .long .L_OP_DIV_INT_LIT8 /* 0xdb */ 20414 .long .L_OP_REM_INT_LIT8 /* 0xdc */ 20415 .long .L_OP_AND_INT_LIT8 /* 0xdd */ 20416 .long .L_OP_OR_INT_LIT8 /* 0xde */ 20417 .long .L_OP_XOR_INT_LIT8 /* 0xdf */ 20418 .long .L_OP_SHL_INT_LIT8 /* 0xe0 */ 20419 .long .L_OP_SHR_INT_LIT8 /* 0xe1 */ 20420 .long .L_OP_USHR_INT_LIT8 /* 0xe2 */ 20421 .long .L_OP_IGET_VOLATILE /* 0xe3 */ 20422 .long .L_OP_IPUT_VOLATILE /* 0xe4 */ 20423 .long .L_OP_SGET_VOLATILE /* 0xe5 */ 20424 .long .L_OP_SPUT_VOLATILE /* 0xe6 */ 20425 .long .L_OP_IGET_OBJECT_VOLATILE /* 0xe7 */ 20426 .long .L_OP_IGET_WIDE_VOLATILE /* 0xe8 */ 20427 .long .L_OP_IPUT_WIDE_VOLATILE /* 0xe9 */ 20428 .long .L_OP_SGET_WIDE_VOLATILE /* 0xea */ 20429 .long .L_OP_SPUT_WIDE_VOLATILE /* 0xeb */ 20430 .long .L_OP_BREAKPOINT /* 0xec */ 20431 .long .L_OP_THROW_VERIFICATION_ERROR /* 0xed */ 20432 .long .L_OP_EXECUTE_INLINE /* 0xee */ 20433 .long .L_OP_EXECUTE_INLINE_RANGE /* 0xef */ 20434 .long .L_OP_INVOKE_OBJECT_INIT /* 0xf0 */ 20435 .long .L_OP_RETURN_VOID_BARRIER /* 0xf1 */ 20436 .long .L_OP_IGET_QUICK /* 0xf2 */ 20437 .long .L_OP_IGET_WIDE_QUICK /* 0xf3 */ 20438 .long .L_OP_IGET_OBJECT_QUICK /* 0xf4 */ 20439 .long .L_OP_IPUT_QUICK /* 0xf5 */ 20440 .long .L_OP_IPUT_WIDE_QUICK /* 0xf6 */ 20441 .long .L_OP_IPUT_OBJECT_QUICK /* 0xf7 */ 20442 .long .L_OP_INVOKE_VIRTUAL_QUICK /* 0xf8 */ 20443 .long .L_OP_INVOKE_VIRTUAL_QUICK_RANGE /* 0xf9 */ 20444 .long .L_OP_INVOKE_SUPER_QUICK /* 0xfa */ 20445 .long .L_OP_INVOKE_SUPER_QUICK_RANGE /* 0xfb */ 20446 .long .L_OP_IPUT_OBJECT_VOLATILE /* 0xfc */ 20447 .long .L_OP_SGET_OBJECT_VOLATILE /* 0xfd */ 20448 .long .L_OP_SPUT_OBJECT_VOLATILE /* 0xfe */ 20449 .long .L_OP_DISPATCH_FF /* 0xff */ 20450 .long .L_OP_CONST_CLASS_JUMBO /* 0x100 */ 20451 .long .L_OP_CHECK_CAST_JUMBO /* 0x101 */ 20452 .long .L_OP_INSTANCE_OF_JUMBO /* 0x102 */ 20453 .long .L_OP_NEW_INSTANCE_JUMBO /* 0x103 */ 20454 .long .L_OP_NEW_ARRAY_JUMBO /* 0x104 */ 20455 .long .L_OP_FILLED_NEW_ARRAY_JUMBO /* 0x105 */ 20456 .long .L_OP_IGET_JUMBO /* 0x106 */ 20457 .long .L_OP_IGET_WIDE_JUMBO /* 0x107 */ 20458 .long .L_OP_IGET_OBJECT_JUMBO /* 0x108 */ 20459 .long .L_OP_IGET_BOOLEAN_JUMBO /* 0x109 */ 20460 .long .L_OP_IGET_BYTE_JUMBO /* 0x10a */ 20461 .long .L_OP_IGET_CHAR_JUMBO /* 0x10b */ 20462 .long .L_OP_IGET_SHORT_JUMBO /* 0x10c */ 20463 .long .L_OP_IPUT_JUMBO /* 0x10d */ 20464 .long .L_OP_IPUT_WIDE_JUMBO /* 0x10e */ 20465 .long .L_OP_IPUT_OBJECT_JUMBO /* 0x10f */ 20466 .long .L_OP_IPUT_BOOLEAN_JUMBO /* 0x110 */ 20467 .long .L_OP_IPUT_BYTE_JUMBO /* 0x111 */ 20468 .long .L_OP_IPUT_CHAR_JUMBO /* 0x112 */ 20469 .long .L_OP_IPUT_SHORT_JUMBO /* 0x113 */ 20470 .long .L_OP_SGET_JUMBO /* 0x114 */ 20471 .long .L_OP_SGET_WIDE_JUMBO /* 0x115 */ 20472 .long .L_OP_SGET_OBJECT_JUMBO /* 0x116 */ 20473 .long .L_OP_SGET_BOOLEAN_JUMBO /* 0x117 */ 20474 .long .L_OP_SGET_BYTE_JUMBO /* 0x118 */ 20475 .long .L_OP_SGET_CHAR_JUMBO /* 0x119 */ 20476 .long .L_OP_SGET_SHORT_JUMBO /* 0x11a */ 20477 .long .L_OP_SPUT_JUMBO /* 0x11b */ 20478 .long .L_OP_SPUT_WIDE_JUMBO /* 0x11c */ 20479 .long .L_OP_SPUT_OBJECT_JUMBO /* 0x11d */ 20480 .long .L_OP_SPUT_BOOLEAN_JUMBO /* 0x11e */ 20481 .long .L_OP_SPUT_BYTE_JUMBO /* 0x11f */ 20482 .long .L_OP_SPUT_CHAR_JUMBO /* 0x120 */ 20483 .long .L_OP_SPUT_SHORT_JUMBO /* 0x121 */ 20484 .long .L_OP_INVOKE_VIRTUAL_JUMBO /* 0x122 */ 20485 .long .L_OP_INVOKE_SUPER_JUMBO /* 0x123 */ 20486 .long .L_OP_INVOKE_DIRECT_JUMBO /* 0x124 */ 20487 .long .L_OP_INVOKE_STATIC_JUMBO /* 0x125 */ 20488 .long .L_OP_INVOKE_INTERFACE_JUMBO /* 0x126 */ 20489 .long .L_OP_UNUSED_27FF /* 0x127 */ 20490 .long .L_OP_UNUSED_28FF /* 0x128 */ 20491 .long .L_OP_UNUSED_29FF /* 0x129 */ 20492 .long .L_OP_UNUSED_2AFF /* 0x12a */ 20493 .long .L_OP_UNUSED_2BFF /* 0x12b */ 20494 .long .L_OP_UNUSED_2CFF /* 0x12c */ 20495 .long .L_OP_UNUSED_2DFF /* 0x12d */ 20496 .long .L_OP_UNUSED_2EFF /* 0x12e */ 20497 .long .L_OP_UNUSED_2FFF /* 0x12f */ 20498 .long .L_OP_UNUSED_30FF /* 0x130 */ 20499 .long .L_OP_UNUSED_31FF /* 0x131 */ 20500 .long .L_OP_UNUSED_32FF /* 0x132 */ 20501 .long .L_OP_UNUSED_33FF /* 0x133 */ 20502 .long .L_OP_UNUSED_34FF /* 0x134 */ 20503 .long .L_OP_UNUSED_35FF /* 0x135 */ 20504 .long .L_OP_UNUSED_36FF /* 0x136 */ 20505 .long .L_OP_UNUSED_37FF /* 0x137 */ 20506 .long .L_OP_UNUSED_38FF /* 0x138 */ 20507 .long .L_OP_UNUSED_39FF /* 0x139 */ 20508 .long .L_OP_UNUSED_3AFF /* 0x13a */ 20509 .long .L_OP_UNUSED_3BFF /* 0x13b */ 20510 .long .L_OP_UNUSED_3CFF /* 0x13c */ 20511 .long .L_OP_UNUSED_3DFF /* 0x13d */ 20512 .long .L_OP_UNUSED_3EFF /* 0x13e */ 20513 .long .L_OP_UNUSED_3FFF /* 0x13f */ 20514 .long .L_OP_UNUSED_40FF /* 0x140 */ 20515 .long .L_OP_UNUSED_41FF /* 0x141 */ 20516 .long .L_OP_UNUSED_42FF /* 0x142 */ 20517 .long .L_OP_UNUSED_43FF /* 0x143 */ 20518 .long .L_OP_UNUSED_44FF /* 0x144 */ 20519 .long .L_OP_UNUSED_45FF /* 0x145 */ 20520 .long .L_OP_UNUSED_46FF /* 0x146 */ 20521 .long .L_OP_UNUSED_47FF /* 0x147 */ 20522 .long .L_OP_UNUSED_48FF /* 0x148 */ 20523 .long .L_OP_UNUSED_49FF /* 0x149 */ 20524 .long .L_OP_UNUSED_4AFF /* 0x14a */ 20525 .long .L_OP_UNUSED_4BFF /* 0x14b */ 20526 .long .L_OP_UNUSED_4CFF /* 0x14c */ 20527 .long .L_OP_UNUSED_4DFF /* 0x14d */ 20528 .long .L_OP_UNUSED_4EFF /* 0x14e */ 20529 .long .L_OP_UNUSED_4FFF /* 0x14f */ 20530 .long .L_OP_UNUSED_50FF /* 0x150 */ 20531 .long .L_OP_UNUSED_51FF /* 0x151 */ 20532 .long .L_OP_UNUSED_52FF /* 0x152 */ 20533 .long .L_OP_UNUSED_53FF /* 0x153 */ 20534 .long .L_OP_UNUSED_54FF /* 0x154 */ 20535 .long .L_OP_UNUSED_55FF /* 0x155 */ 20536 .long .L_OP_UNUSED_56FF /* 0x156 */ 20537 .long .L_OP_UNUSED_57FF /* 0x157 */ 20538 .long .L_OP_UNUSED_58FF /* 0x158 */ 20539 .long .L_OP_UNUSED_59FF /* 0x159 */ 20540 .long .L_OP_UNUSED_5AFF /* 0x15a */ 20541 .long .L_OP_UNUSED_5BFF /* 0x15b */ 20542 .long .L_OP_UNUSED_5CFF /* 0x15c */ 20543 .long .L_OP_UNUSED_5DFF /* 0x15d */ 20544 .long .L_OP_UNUSED_5EFF /* 0x15e */ 20545 .long .L_OP_UNUSED_5FFF /* 0x15f */ 20546 .long .L_OP_UNUSED_60FF /* 0x160 */ 20547 .long .L_OP_UNUSED_61FF /* 0x161 */ 20548 .long .L_OP_UNUSED_62FF /* 0x162 */ 20549 .long .L_OP_UNUSED_63FF /* 0x163 */ 20550 .long .L_OP_UNUSED_64FF /* 0x164 */ 20551 .long .L_OP_UNUSED_65FF /* 0x165 */ 20552 .long .L_OP_UNUSED_66FF /* 0x166 */ 20553 .long .L_OP_UNUSED_67FF /* 0x167 */ 20554 .long .L_OP_UNUSED_68FF /* 0x168 */ 20555 .long .L_OP_UNUSED_69FF /* 0x169 */ 20556 .long .L_OP_UNUSED_6AFF /* 0x16a */ 20557 .long .L_OP_UNUSED_6BFF /* 0x16b */ 20558 .long .L_OP_UNUSED_6CFF /* 0x16c */ 20559 .long .L_OP_UNUSED_6DFF /* 0x16d */ 20560 .long .L_OP_UNUSED_6EFF /* 0x16e */ 20561 .long .L_OP_UNUSED_6FFF /* 0x16f */ 20562 .long .L_OP_UNUSED_70FF /* 0x170 */ 20563 .long .L_OP_UNUSED_71FF /* 0x171 */ 20564 .long .L_OP_UNUSED_72FF /* 0x172 */ 20565 .long .L_OP_UNUSED_73FF /* 0x173 */ 20566 .long .L_OP_UNUSED_74FF /* 0x174 */ 20567 .long .L_OP_UNUSED_75FF /* 0x175 */ 20568 .long .L_OP_UNUSED_76FF /* 0x176 */ 20569 .long .L_OP_UNUSED_77FF /* 0x177 */ 20570 .long .L_OP_UNUSED_78FF /* 0x178 */ 20571 .long .L_OP_UNUSED_79FF /* 0x179 */ 20572 .long .L_OP_UNUSED_7AFF /* 0x17a */ 20573 .long .L_OP_UNUSED_7BFF /* 0x17b */ 20574 .long .L_OP_UNUSED_7CFF /* 0x17c */ 20575 .long .L_OP_UNUSED_7DFF /* 0x17d */ 20576 .long .L_OP_UNUSED_7EFF /* 0x17e */ 20577 .long .L_OP_UNUSED_7FFF /* 0x17f */ 20578 .long .L_OP_UNUSED_80FF /* 0x180 */ 20579 .long .L_OP_UNUSED_81FF /* 0x181 */ 20580 .long .L_OP_UNUSED_82FF /* 0x182 */ 20581 .long .L_OP_UNUSED_83FF /* 0x183 */ 20582 .long .L_OP_UNUSED_84FF /* 0x184 */ 20583 .long .L_OP_UNUSED_85FF /* 0x185 */ 20584 .long .L_OP_UNUSED_86FF /* 0x186 */ 20585 .long .L_OP_UNUSED_87FF /* 0x187 */ 20586 .long .L_OP_UNUSED_88FF /* 0x188 */ 20587 .long .L_OP_UNUSED_89FF /* 0x189 */ 20588 .long .L_OP_UNUSED_8AFF /* 0x18a */ 20589 .long .L_OP_UNUSED_8BFF /* 0x18b */ 20590 .long .L_OP_UNUSED_8CFF /* 0x18c */ 20591 .long .L_OP_UNUSED_8DFF /* 0x18d */ 20592 .long .L_OP_UNUSED_8EFF /* 0x18e */ 20593 .long .L_OP_UNUSED_8FFF /* 0x18f */ 20594 .long .L_OP_UNUSED_90FF /* 0x190 */ 20595 .long .L_OP_UNUSED_91FF /* 0x191 */ 20596 .long .L_OP_UNUSED_92FF /* 0x192 */ 20597 .long .L_OP_UNUSED_93FF /* 0x193 */ 20598 .long .L_OP_UNUSED_94FF /* 0x194 */ 20599 .long .L_OP_UNUSED_95FF /* 0x195 */ 20600 .long .L_OP_UNUSED_96FF /* 0x196 */ 20601 .long .L_OP_UNUSED_97FF /* 0x197 */ 20602 .long .L_OP_UNUSED_98FF /* 0x198 */ 20603 .long .L_OP_UNUSED_99FF /* 0x199 */ 20604 .long .L_OP_UNUSED_9AFF /* 0x19a */ 20605 .long .L_OP_UNUSED_9BFF /* 0x19b */ 20606 .long .L_OP_UNUSED_9CFF /* 0x19c */ 20607 .long .L_OP_UNUSED_9DFF /* 0x19d */ 20608 .long .L_OP_UNUSED_9EFF /* 0x19e */ 20609 .long .L_OP_UNUSED_9FFF /* 0x19f */ 20610 .long .L_OP_UNUSED_A0FF /* 0x1a0 */ 20611 .long .L_OP_UNUSED_A1FF /* 0x1a1 */ 20612 .long .L_OP_UNUSED_A2FF /* 0x1a2 */ 20613 .long .L_OP_UNUSED_A3FF /* 0x1a3 */ 20614 .long .L_OP_UNUSED_A4FF /* 0x1a4 */ 20615 .long .L_OP_UNUSED_A5FF /* 0x1a5 */ 20616 .long .L_OP_UNUSED_A6FF /* 0x1a6 */ 20617 .long .L_OP_UNUSED_A7FF /* 0x1a7 */ 20618 .long .L_OP_UNUSED_A8FF /* 0x1a8 */ 20619 .long .L_OP_UNUSED_A9FF /* 0x1a9 */ 20620 .long .L_OP_UNUSED_AAFF /* 0x1aa */ 20621 .long .L_OP_UNUSED_ABFF /* 0x1ab */ 20622 .long .L_OP_UNUSED_ACFF /* 0x1ac */ 20623 .long .L_OP_UNUSED_ADFF /* 0x1ad */ 20624 .long .L_OP_UNUSED_AEFF /* 0x1ae */ 20625 .long .L_OP_UNUSED_AFFF /* 0x1af */ 20626 .long .L_OP_UNUSED_B0FF /* 0x1b0 */ 20627 .long .L_OP_UNUSED_B1FF /* 0x1b1 */ 20628 .long .L_OP_UNUSED_B2FF /* 0x1b2 */ 20629 .long .L_OP_UNUSED_B3FF /* 0x1b3 */ 20630 .long .L_OP_UNUSED_B4FF /* 0x1b4 */ 20631 .long .L_OP_UNUSED_B5FF /* 0x1b5 */ 20632 .long .L_OP_UNUSED_B6FF /* 0x1b6 */ 20633 .long .L_OP_UNUSED_B7FF /* 0x1b7 */ 20634 .long .L_OP_UNUSED_B8FF /* 0x1b8 */ 20635 .long .L_OP_UNUSED_B9FF /* 0x1b9 */ 20636 .long .L_OP_UNUSED_BAFF /* 0x1ba */ 20637 .long .L_OP_UNUSED_BBFF /* 0x1bb */ 20638 .long .L_OP_UNUSED_BCFF /* 0x1bc */ 20639 .long .L_OP_UNUSED_BDFF /* 0x1bd */ 20640 .long .L_OP_UNUSED_BEFF /* 0x1be */ 20641 .long .L_OP_UNUSED_BFFF /* 0x1bf */ 20642 .long .L_OP_UNUSED_C0FF /* 0x1c0 */ 20643 .long .L_OP_UNUSED_C1FF /* 0x1c1 */ 20644 .long .L_OP_UNUSED_C2FF /* 0x1c2 */ 20645 .long .L_OP_UNUSED_C3FF /* 0x1c3 */ 20646 .long .L_OP_UNUSED_C4FF /* 0x1c4 */ 20647 .long .L_OP_UNUSED_C5FF /* 0x1c5 */ 20648 .long .L_OP_UNUSED_C6FF /* 0x1c6 */ 20649 .long .L_OP_UNUSED_C7FF /* 0x1c7 */ 20650 .long .L_OP_UNUSED_C8FF /* 0x1c8 */ 20651 .long .L_OP_UNUSED_C9FF /* 0x1c9 */ 20652 .long .L_OP_UNUSED_CAFF /* 0x1ca */ 20653 .long .L_OP_UNUSED_CBFF /* 0x1cb */ 20654 .long .L_OP_UNUSED_CCFF /* 0x1cc */ 20655 .long .L_OP_UNUSED_CDFF /* 0x1cd */ 20656 .long .L_OP_UNUSED_CEFF /* 0x1ce */ 20657 .long .L_OP_UNUSED_CFFF /* 0x1cf */ 20658 .long .L_OP_UNUSED_D0FF /* 0x1d0 */ 20659 .long .L_OP_UNUSED_D1FF /* 0x1d1 */ 20660 .long .L_OP_UNUSED_D2FF /* 0x1d2 */ 20661 .long .L_OP_UNUSED_D3FF /* 0x1d3 */ 20662 .long .L_OP_UNUSED_D4FF /* 0x1d4 */ 20663 .long .L_OP_UNUSED_D5FF /* 0x1d5 */ 20664 .long .L_OP_UNUSED_D6FF /* 0x1d6 */ 20665 .long .L_OP_UNUSED_D7FF /* 0x1d7 */ 20666 .long .L_OP_UNUSED_D8FF /* 0x1d8 */ 20667 .long .L_OP_UNUSED_D9FF /* 0x1d9 */ 20668 .long .L_OP_UNUSED_DAFF /* 0x1da */ 20669 .long .L_OP_UNUSED_DBFF /* 0x1db */ 20670 .long .L_OP_UNUSED_DCFF /* 0x1dc */ 20671 .long .L_OP_UNUSED_DDFF /* 0x1dd */ 20672 .long .L_OP_UNUSED_DEFF /* 0x1de */ 20673 .long .L_OP_UNUSED_DFFF /* 0x1df */ 20674 .long .L_OP_UNUSED_E0FF /* 0x1e0 */ 20675 .long .L_OP_UNUSED_E1FF /* 0x1e1 */ 20676 .long .L_OP_UNUSED_E2FF /* 0x1e2 */ 20677 .long .L_OP_UNUSED_E3FF /* 0x1e3 */ 20678 .long .L_OP_UNUSED_E4FF /* 0x1e4 */ 20679 .long .L_OP_UNUSED_E5FF /* 0x1e5 */ 20680 .long .L_OP_UNUSED_E6FF /* 0x1e6 */ 20681 .long .L_OP_UNUSED_E7FF /* 0x1e7 */ 20682 .long .L_OP_UNUSED_E8FF /* 0x1e8 */ 20683 .long .L_OP_UNUSED_E9FF /* 0x1e9 */ 20684 .long .L_OP_UNUSED_EAFF /* 0x1ea */ 20685 .long .L_OP_UNUSED_EBFF /* 0x1eb */ 20686 .long .L_OP_UNUSED_ECFF /* 0x1ec */ 20687 .long .L_OP_UNUSED_EDFF /* 0x1ed */ 20688 .long .L_OP_UNUSED_EEFF /* 0x1ee */ 20689 .long .L_OP_UNUSED_EFFF /* 0x1ef */ 20690 .long .L_OP_UNUSED_F0FF /* 0x1f0 */ 20691 .long .L_OP_UNUSED_F1FF /* 0x1f1 */ 20692 .long .L_OP_UNUSED_F2FF /* 0x1f2 */ 20693 .long .L_OP_UNUSED_F3FF /* 0x1f3 */ 20694 .long .L_OP_UNUSED_F4FF /* 0x1f4 */ 20695 .long .L_OP_UNUSED_F5FF /* 0x1f5 */ 20696 .long .L_OP_UNUSED_F6FF /* 0x1f6 */ 20697 .long .L_OP_UNUSED_F7FF /* 0x1f7 */ 20698 .long .L_OP_UNUSED_F8FF /* 0x1f8 */ 20699 .long .L_OP_UNUSED_F9FF /* 0x1f9 */ 20700 .long .L_OP_UNUSED_FAFF /* 0x1fa */ 20701 .long .L_OP_UNUSED_FBFF /* 0x1fb */ 20702 .long .L_OP_UNUSED_FCFF /* 0x1fc */ 20703 .long .L_OP_UNUSED_FDFF /* 0x1fd */ 20704 .long .L_OP_UNUSED_FEFF /* 0x1fe */ 20705 .long .L_OP_THROW_VERIFICATION_ERROR_JUMBO /* 0x1ff */ 20706 20707 .global dvmAsmAltInstructionStart 20708 .text 20709dvmAsmAltInstructionStart: 20710 .long .L_ALT_OP_NOP /* 0x00 */ 20711 .long .L_ALT_OP_MOVE /* 0x01 */ 20712 .long .L_ALT_OP_MOVE_FROM16 /* 0x02 */ 20713 .long .L_ALT_OP_MOVE_16 /* 0x03 */ 20714 .long .L_ALT_OP_MOVE_WIDE /* 0x04 */ 20715 .long .L_ALT_OP_MOVE_WIDE_FROM16 /* 0x05 */ 20716 .long .L_ALT_OP_MOVE_WIDE_16 /* 0x06 */ 20717 .long .L_ALT_OP_MOVE_OBJECT /* 0x07 */ 20718 .long .L_ALT_OP_MOVE_OBJECT_FROM16 /* 0x08 */ 20719 .long .L_ALT_OP_MOVE_OBJECT_16 /* 0x09 */ 20720 .long .L_ALT_OP_MOVE_RESULT /* 0x0a */ 20721 .long .L_ALT_OP_MOVE_RESULT_WIDE /* 0x0b */ 20722 .long .L_ALT_OP_MOVE_RESULT_OBJECT /* 0x0c */ 20723 .long .L_ALT_OP_MOVE_EXCEPTION /* 0x0d */ 20724 .long .L_ALT_OP_RETURN_VOID /* 0x0e */ 20725 .long .L_ALT_OP_RETURN /* 0x0f */ 20726 .long .L_ALT_OP_RETURN_WIDE /* 0x10 */ 20727 .long .L_ALT_OP_RETURN_OBJECT /* 0x11 */ 20728 .long .L_ALT_OP_CONST_4 /* 0x12 */ 20729 .long .L_ALT_OP_CONST_16 /* 0x13 */ 20730 .long .L_ALT_OP_CONST /* 0x14 */ 20731 .long .L_ALT_OP_CONST_HIGH16 /* 0x15 */ 20732 .long .L_ALT_OP_CONST_WIDE_16 /* 0x16 */ 20733 .long .L_ALT_OP_CONST_WIDE_32 /* 0x17 */ 20734 .long .L_ALT_OP_CONST_WIDE /* 0x18 */ 20735 .long .L_ALT_OP_CONST_WIDE_HIGH16 /* 0x19 */ 20736 .long .L_ALT_OP_CONST_STRING /* 0x1a */ 20737 .long .L_ALT_OP_CONST_STRING_JUMBO /* 0x1b */ 20738 .long .L_ALT_OP_CONST_CLASS /* 0x1c */ 20739 .long .L_ALT_OP_MONITOR_ENTER /* 0x1d */ 20740 .long .L_ALT_OP_MONITOR_EXIT /* 0x1e */ 20741 .long .L_ALT_OP_CHECK_CAST /* 0x1f */ 20742 .long .L_ALT_OP_INSTANCE_OF /* 0x20 */ 20743 .long .L_ALT_OP_ARRAY_LENGTH /* 0x21 */ 20744 .long .L_ALT_OP_NEW_INSTANCE /* 0x22 */ 20745 .long .L_ALT_OP_NEW_ARRAY /* 0x23 */ 20746 .long .L_ALT_OP_FILLED_NEW_ARRAY /* 0x24 */ 20747 .long .L_ALT_OP_FILLED_NEW_ARRAY_RANGE /* 0x25 */ 20748 .long .L_ALT_OP_FILL_ARRAY_DATA /* 0x26 */ 20749 .long .L_ALT_OP_THROW /* 0x27 */ 20750 .long .L_ALT_OP_GOTO /* 0x28 */ 20751 .long .L_ALT_OP_GOTO_16 /* 0x29 */ 20752 .long .L_ALT_OP_GOTO_32 /* 0x2a */ 20753 .long .L_ALT_OP_PACKED_SWITCH /* 0x2b */ 20754 .long .L_ALT_OP_SPARSE_SWITCH /* 0x2c */ 20755 .long .L_ALT_OP_CMPL_FLOAT /* 0x2d */ 20756 .long .L_ALT_OP_CMPG_FLOAT /* 0x2e */ 20757 .long .L_ALT_OP_CMPL_DOUBLE /* 0x2f */ 20758 .long .L_ALT_OP_CMPG_DOUBLE /* 0x30 */ 20759 .long .L_ALT_OP_CMP_LONG /* 0x31 */ 20760 .long .L_ALT_OP_IF_EQ /* 0x32 */ 20761 .long .L_ALT_OP_IF_NE /* 0x33 */ 20762 .long .L_ALT_OP_IF_LT /* 0x34 */ 20763 .long .L_ALT_OP_IF_GE /* 0x35 */ 20764 .long .L_ALT_OP_IF_GT /* 0x36 */ 20765 .long .L_ALT_OP_IF_LE /* 0x37 */ 20766 .long .L_ALT_OP_IF_EQZ /* 0x38 */ 20767 .long .L_ALT_OP_IF_NEZ /* 0x39 */ 20768 .long .L_ALT_OP_IF_LTZ /* 0x3a */ 20769 .long .L_ALT_OP_IF_GEZ /* 0x3b */ 20770 .long .L_ALT_OP_IF_GTZ /* 0x3c */ 20771 .long .L_ALT_OP_IF_LEZ /* 0x3d */ 20772 .long .L_ALT_OP_UNUSED_3E /* 0x3e */ 20773 .long .L_ALT_OP_UNUSED_3F /* 0x3f */ 20774 .long .L_ALT_OP_UNUSED_40 /* 0x40 */ 20775 .long .L_ALT_OP_UNUSED_41 /* 0x41 */ 20776 .long .L_ALT_OP_UNUSED_42 /* 0x42 */ 20777 .long .L_ALT_OP_UNUSED_43 /* 0x43 */ 20778 .long .L_ALT_OP_AGET /* 0x44 */ 20779 .long .L_ALT_OP_AGET_WIDE /* 0x45 */ 20780 .long .L_ALT_OP_AGET_OBJECT /* 0x46 */ 20781 .long .L_ALT_OP_AGET_BOOLEAN /* 0x47 */ 20782 .long .L_ALT_OP_AGET_BYTE /* 0x48 */ 20783 .long .L_ALT_OP_AGET_CHAR /* 0x49 */ 20784 .long .L_ALT_OP_AGET_SHORT /* 0x4a */ 20785 .long .L_ALT_OP_APUT /* 0x4b */ 20786 .long .L_ALT_OP_APUT_WIDE /* 0x4c */ 20787 .long .L_ALT_OP_APUT_OBJECT /* 0x4d */ 20788 .long .L_ALT_OP_APUT_BOOLEAN /* 0x4e */ 20789 .long .L_ALT_OP_APUT_BYTE /* 0x4f */ 20790 .long .L_ALT_OP_APUT_CHAR /* 0x50 */ 20791 .long .L_ALT_OP_APUT_SHORT /* 0x51 */ 20792 .long .L_ALT_OP_IGET /* 0x52 */ 20793 .long .L_ALT_OP_IGET_WIDE /* 0x53 */ 20794 .long .L_ALT_OP_IGET_OBJECT /* 0x54 */ 20795 .long .L_ALT_OP_IGET_BOOLEAN /* 0x55 */ 20796 .long .L_ALT_OP_IGET_BYTE /* 0x56 */ 20797 .long .L_ALT_OP_IGET_CHAR /* 0x57 */ 20798 .long .L_ALT_OP_IGET_SHORT /* 0x58 */ 20799 .long .L_ALT_OP_IPUT /* 0x59 */ 20800 .long .L_ALT_OP_IPUT_WIDE /* 0x5a */ 20801 .long .L_ALT_OP_IPUT_OBJECT /* 0x5b */ 20802 .long .L_ALT_OP_IPUT_BOOLEAN /* 0x5c */ 20803 .long .L_ALT_OP_IPUT_BYTE /* 0x5d */ 20804 .long .L_ALT_OP_IPUT_CHAR /* 0x5e */ 20805 .long .L_ALT_OP_IPUT_SHORT /* 0x5f */ 20806 .long .L_ALT_OP_SGET /* 0x60 */ 20807 .long .L_ALT_OP_SGET_WIDE /* 0x61 */ 20808 .long .L_ALT_OP_SGET_OBJECT /* 0x62 */ 20809 .long .L_ALT_OP_SGET_BOOLEAN /* 0x63 */ 20810 .long .L_ALT_OP_SGET_BYTE /* 0x64 */ 20811 .long .L_ALT_OP_SGET_CHAR /* 0x65 */ 20812 .long .L_ALT_OP_SGET_SHORT /* 0x66 */ 20813 .long .L_ALT_OP_SPUT /* 0x67 */ 20814 .long .L_ALT_OP_SPUT_WIDE /* 0x68 */ 20815 .long .L_ALT_OP_SPUT_OBJECT /* 0x69 */ 20816 .long .L_ALT_OP_SPUT_BOOLEAN /* 0x6a */ 20817 .long .L_ALT_OP_SPUT_BYTE /* 0x6b */ 20818 .long .L_ALT_OP_SPUT_CHAR /* 0x6c */ 20819 .long .L_ALT_OP_SPUT_SHORT /* 0x6d */ 20820 .long .L_ALT_OP_INVOKE_VIRTUAL /* 0x6e */ 20821 .long .L_ALT_OP_INVOKE_SUPER /* 0x6f */ 20822 .long .L_ALT_OP_INVOKE_DIRECT /* 0x70 */ 20823 .long .L_ALT_OP_INVOKE_STATIC /* 0x71 */ 20824 .long .L_ALT_OP_INVOKE_INTERFACE /* 0x72 */ 20825 .long .L_ALT_OP_UNUSED_73 /* 0x73 */ 20826 .long .L_ALT_OP_INVOKE_VIRTUAL_RANGE /* 0x74 */ 20827 .long .L_ALT_OP_INVOKE_SUPER_RANGE /* 0x75 */ 20828 .long .L_ALT_OP_INVOKE_DIRECT_RANGE /* 0x76 */ 20829 .long .L_ALT_OP_INVOKE_STATIC_RANGE /* 0x77 */ 20830 .long .L_ALT_OP_INVOKE_INTERFACE_RANGE /* 0x78 */ 20831 .long .L_ALT_OP_UNUSED_79 /* 0x79 */ 20832 .long .L_ALT_OP_UNUSED_7A /* 0x7a */ 20833 .long .L_ALT_OP_NEG_INT /* 0x7b */ 20834 .long .L_ALT_OP_NOT_INT /* 0x7c */ 20835 .long .L_ALT_OP_NEG_LONG /* 0x7d */ 20836 .long .L_ALT_OP_NOT_LONG /* 0x7e */ 20837 .long .L_ALT_OP_NEG_FLOAT /* 0x7f */ 20838 .long .L_ALT_OP_NEG_DOUBLE /* 0x80 */ 20839 .long .L_ALT_OP_INT_TO_LONG /* 0x81 */ 20840 .long .L_ALT_OP_INT_TO_FLOAT /* 0x82 */ 20841 .long .L_ALT_OP_INT_TO_DOUBLE /* 0x83 */ 20842 .long .L_ALT_OP_LONG_TO_INT /* 0x84 */ 20843 .long .L_ALT_OP_LONG_TO_FLOAT /* 0x85 */ 20844 .long .L_ALT_OP_LONG_TO_DOUBLE /* 0x86 */ 20845 .long .L_ALT_OP_FLOAT_TO_INT /* 0x87 */ 20846 .long .L_ALT_OP_FLOAT_TO_LONG /* 0x88 */ 20847 .long .L_ALT_OP_FLOAT_TO_DOUBLE /* 0x89 */ 20848 .long .L_ALT_OP_DOUBLE_TO_INT /* 0x8a */ 20849 .long .L_ALT_OP_DOUBLE_TO_LONG /* 0x8b */ 20850 .long .L_ALT_OP_DOUBLE_TO_FLOAT /* 0x8c */ 20851 .long .L_ALT_OP_INT_TO_BYTE /* 0x8d */ 20852 .long .L_ALT_OP_INT_TO_CHAR /* 0x8e */ 20853 .long .L_ALT_OP_INT_TO_SHORT /* 0x8f */ 20854 .long .L_ALT_OP_ADD_INT /* 0x90 */ 20855 .long .L_ALT_OP_SUB_INT /* 0x91 */ 20856 .long .L_ALT_OP_MUL_INT /* 0x92 */ 20857 .long .L_ALT_OP_DIV_INT /* 0x93 */ 20858 .long .L_ALT_OP_REM_INT /* 0x94 */ 20859 .long .L_ALT_OP_AND_INT /* 0x95 */ 20860 .long .L_ALT_OP_OR_INT /* 0x96 */ 20861 .long .L_ALT_OP_XOR_INT /* 0x97 */ 20862 .long .L_ALT_OP_SHL_INT /* 0x98 */ 20863 .long .L_ALT_OP_SHR_INT /* 0x99 */ 20864 .long .L_ALT_OP_USHR_INT /* 0x9a */ 20865 .long .L_ALT_OP_ADD_LONG /* 0x9b */ 20866 .long .L_ALT_OP_SUB_LONG /* 0x9c */ 20867 .long .L_ALT_OP_MUL_LONG /* 0x9d */ 20868 .long .L_ALT_OP_DIV_LONG /* 0x9e */ 20869 .long .L_ALT_OP_REM_LONG /* 0x9f */ 20870 .long .L_ALT_OP_AND_LONG /* 0xa0 */ 20871 .long .L_ALT_OP_OR_LONG /* 0xa1 */ 20872 .long .L_ALT_OP_XOR_LONG /* 0xa2 */ 20873 .long .L_ALT_OP_SHL_LONG /* 0xa3 */ 20874 .long .L_ALT_OP_SHR_LONG /* 0xa4 */ 20875 .long .L_ALT_OP_USHR_LONG /* 0xa5 */ 20876 .long .L_ALT_OP_ADD_FLOAT /* 0xa6 */ 20877 .long .L_ALT_OP_SUB_FLOAT /* 0xa7 */ 20878 .long .L_ALT_OP_MUL_FLOAT /* 0xa8 */ 20879 .long .L_ALT_OP_DIV_FLOAT /* 0xa9 */ 20880 .long .L_ALT_OP_REM_FLOAT /* 0xaa */ 20881 .long .L_ALT_OP_ADD_DOUBLE /* 0xab */ 20882 .long .L_ALT_OP_SUB_DOUBLE /* 0xac */ 20883 .long .L_ALT_OP_MUL_DOUBLE /* 0xad */ 20884 .long .L_ALT_OP_DIV_DOUBLE /* 0xae */ 20885 .long .L_ALT_OP_REM_DOUBLE /* 0xaf */ 20886 .long .L_ALT_OP_ADD_INT_2ADDR /* 0xb0 */ 20887 .long .L_ALT_OP_SUB_INT_2ADDR /* 0xb1 */ 20888 .long .L_ALT_OP_MUL_INT_2ADDR /* 0xb2 */ 20889 .long .L_ALT_OP_DIV_INT_2ADDR /* 0xb3 */ 20890 .long .L_ALT_OP_REM_INT_2ADDR /* 0xb4 */ 20891 .long .L_ALT_OP_AND_INT_2ADDR /* 0xb5 */ 20892 .long .L_ALT_OP_OR_INT_2ADDR /* 0xb6 */ 20893 .long .L_ALT_OP_XOR_INT_2ADDR /* 0xb7 */ 20894 .long .L_ALT_OP_SHL_INT_2ADDR /* 0xb8 */ 20895 .long .L_ALT_OP_SHR_INT_2ADDR /* 0xb9 */ 20896 .long .L_ALT_OP_USHR_INT_2ADDR /* 0xba */ 20897 .long .L_ALT_OP_ADD_LONG_2ADDR /* 0xbb */ 20898 .long .L_ALT_OP_SUB_LONG_2ADDR /* 0xbc */ 20899 .long .L_ALT_OP_MUL_LONG_2ADDR /* 0xbd */ 20900 .long .L_ALT_OP_DIV_LONG_2ADDR /* 0xbe */ 20901 .long .L_ALT_OP_REM_LONG_2ADDR /* 0xbf */ 20902 .long .L_ALT_OP_AND_LONG_2ADDR /* 0xc0 */ 20903 .long .L_ALT_OP_OR_LONG_2ADDR /* 0xc1 */ 20904 .long .L_ALT_OP_XOR_LONG_2ADDR /* 0xc2 */ 20905 .long .L_ALT_OP_SHL_LONG_2ADDR /* 0xc3 */ 20906 .long .L_ALT_OP_SHR_LONG_2ADDR /* 0xc4 */ 20907 .long .L_ALT_OP_USHR_LONG_2ADDR /* 0xc5 */ 20908 .long .L_ALT_OP_ADD_FLOAT_2ADDR /* 0xc6 */ 20909 .long .L_ALT_OP_SUB_FLOAT_2ADDR /* 0xc7 */ 20910 .long .L_ALT_OP_MUL_FLOAT_2ADDR /* 0xc8 */ 20911 .long .L_ALT_OP_DIV_FLOAT_2ADDR /* 0xc9 */ 20912 .long .L_ALT_OP_REM_FLOAT_2ADDR /* 0xca */ 20913 .long .L_ALT_OP_ADD_DOUBLE_2ADDR /* 0xcb */ 20914 .long .L_ALT_OP_SUB_DOUBLE_2ADDR /* 0xcc */ 20915 .long .L_ALT_OP_MUL_DOUBLE_2ADDR /* 0xcd */ 20916 .long .L_ALT_OP_DIV_DOUBLE_2ADDR /* 0xce */ 20917 .long .L_ALT_OP_REM_DOUBLE_2ADDR /* 0xcf */ 20918 .long .L_ALT_OP_ADD_INT_LIT16 /* 0xd0 */ 20919 .long .L_ALT_OP_RSUB_INT /* 0xd1 */ 20920 .long .L_ALT_OP_MUL_INT_LIT16 /* 0xd2 */ 20921 .long .L_ALT_OP_DIV_INT_LIT16 /* 0xd3 */ 20922 .long .L_ALT_OP_REM_INT_LIT16 /* 0xd4 */ 20923 .long .L_ALT_OP_AND_INT_LIT16 /* 0xd5 */ 20924 .long .L_ALT_OP_OR_INT_LIT16 /* 0xd6 */ 20925 .long .L_ALT_OP_XOR_INT_LIT16 /* 0xd7 */ 20926 .long .L_ALT_OP_ADD_INT_LIT8 /* 0xd8 */ 20927 .long .L_ALT_OP_RSUB_INT_LIT8 /* 0xd9 */ 20928 .long .L_ALT_OP_MUL_INT_LIT8 /* 0xda */ 20929 .long .L_ALT_OP_DIV_INT_LIT8 /* 0xdb */ 20930 .long .L_ALT_OP_REM_INT_LIT8 /* 0xdc */ 20931 .long .L_ALT_OP_AND_INT_LIT8 /* 0xdd */ 20932 .long .L_ALT_OP_OR_INT_LIT8 /* 0xde */ 20933 .long .L_ALT_OP_XOR_INT_LIT8 /* 0xdf */ 20934 .long .L_ALT_OP_SHL_INT_LIT8 /* 0xe0 */ 20935 .long .L_ALT_OP_SHR_INT_LIT8 /* 0xe1 */ 20936 .long .L_ALT_OP_USHR_INT_LIT8 /* 0xe2 */ 20937 .long .L_ALT_OP_IGET_VOLATILE /* 0xe3 */ 20938 .long .L_ALT_OP_IPUT_VOLATILE /* 0xe4 */ 20939 .long .L_ALT_OP_SGET_VOLATILE /* 0xe5 */ 20940 .long .L_ALT_OP_SPUT_VOLATILE /* 0xe6 */ 20941 .long .L_ALT_OP_IGET_OBJECT_VOLATILE /* 0xe7 */ 20942 .long .L_ALT_OP_IGET_WIDE_VOLATILE /* 0xe8 */ 20943 .long .L_ALT_OP_IPUT_WIDE_VOLATILE /* 0xe9 */ 20944 .long .L_ALT_OP_SGET_WIDE_VOLATILE /* 0xea */ 20945 .long .L_ALT_OP_SPUT_WIDE_VOLATILE /* 0xeb */ 20946 .long .L_ALT_OP_BREAKPOINT /* 0xec */ 20947 .long .L_ALT_OP_THROW_VERIFICATION_ERROR /* 0xed */ 20948 .long .L_ALT_OP_EXECUTE_INLINE /* 0xee */ 20949 .long .L_ALT_OP_EXECUTE_INLINE_RANGE /* 0xef */ 20950 .long .L_ALT_OP_INVOKE_OBJECT_INIT /* 0xf0 */ 20951 .long .L_ALT_OP_RETURN_VOID_BARRIER /* 0xf1 */ 20952 .long .L_ALT_OP_IGET_QUICK /* 0xf2 */ 20953 .long .L_ALT_OP_IGET_WIDE_QUICK /* 0xf3 */ 20954 .long .L_ALT_OP_IGET_OBJECT_QUICK /* 0xf4 */ 20955 .long .L_ALT_OP_IPUT_QUICK /* 0xf5 */ 20956 .long .L_ALT_OP_IPUT_WIDE_QUICK /* 0xf6 */ 20957 .long .L_ALT_OP_IPUT_OBJECT_QUICK /* 0xf7 */ 20958 .long .L_ALT_OP_INVOKE_VIRTUAL_QUICK /* 0xf8 */ 20959 .long .L_ALT_OP_INVOKE_VIRTUAL_QUICK_RANGE /* 0xf9 */ 20960 .long .L_ALT_OP_INVOKE_SUPER_QUICK /* 0xfa */ 20961 .long .L_ALT_OP_INVOKE_SUPER_QUICK_RANGE /* 0xfb */ 20962 .long .L_ALT_OP_IPUT_OBJECT_VOLATILE /* 0xfc */ 20963 .long .L_ALT_OP_SGET_OBJECT_VOLATILE /* 0xfd */ 20964 .long .L_ALT_OP_SPUT_OBJECT_VOLATILE /* 0xfe */ 20965 .long .L_ALT_OP_DISPATCH_FF /* 0xff */ 20966 .long .L_ALT_OP_CONST_CLASS_JUMBO /* 0x100 */ 20967 .long .L_ALT_OP_CHECK_CAST_JUMBO /* 0x101 */ 20968 .long .L_ALT_OP_INSTANCE_OF_JUMBO /* 0x102 */ 20969 .long .L_ALT_OP_NEW_INSTANCE_JUMBO /* 0x103 */ 20970 .long .L_ALT_OP_NEW_ARRAY_JUMBO /* 0x104 */ 20971 .long .L_ALT_OP_FILLED_NEW_ARRAY_JUMBO /* 0x105 */ 20972 .long .L_ALT_OP_IGET_JUMBO /* 0x106 */ 20973 .long .L_ALT_OP_IGET_WIDE_JUMBO /* 0x107 */ 20974 .long .L_ALT_OP_IGET_OBJECT_JUMBO /* 0x108 */ 20975 .long .L_ALT_OP_IGET_BOOLEAN_JUMBO /* 0x109 */ 20976 .long .L_ALT_OP_IGET_BYTE_JUMBO /* 0x10a */ 20977 .long .L_ALT_OP_IGET_CHAR_JUMBO /* 0x10b */ 20978 .long .L_ALT_OP_IGET_SHORT_JUMBO /* 0x10c */ 20979 .long .L_ALT_OP_IPUT_JUMBO /* 0x10d */ 20980 .long .L_ALT_OP_IPUT_WIDE_JUMBO /* 0x10e */ 20981 .long .L_ALT_OP_IPUT_OBJECT_JUMBO /* 0x10f */ 20982 .long .L_ALT_OP_IPUT_BOOLEAN_JUMBO /* 0x110 */ 20983 .long .L_ALT_OP_IPUT_BYTE_JUMBO /* 0x111 */ 20984 .long .L_ALT_OP_IPUT_CHAR_JUMBO /* 0x112 */ 20985 .long .L_ALT_OP_IPUT_SHORT_JUMBO /* 0x113 */ 20986 .long .L_ALT_OP_SGET_JUMBO /* 0x114 */ 20987 .long .L_ALT_OP_SGET_WIDE_JUMBO /* 0x115 */ 20988 .long .L_ALT_OP_SGET_OBJECT_JUMBO /* 0x116 */ 20989 .long .L_ALT_OP_SGET_BOOLEAN_JUMBO /* 0x117 */ 20990 .long .L_ALT_OP_SGET_BYTE_JUMBO /* 0x118 */ 20991 .long .L_ALT_OP_SGET_CHAR_JUMBO /* 0x119 */ 20992 .long .L_ALT_OP_SGET_SHORT_JUMBO /* 0x11a */ 20993 .long .L_ALT_OP_SPUT_JUMBO /* 0x11b */ 20994 .long .L_ALT_OP_SPUT_WIDE_JUMBO /* 0x11c */ 20995 .long .L_ALT_OP_SPUT_OBJECT_JUMBO /* 0x11d */ 20996 .long .L_ALT_OP_SPUT_BOOLEAN_JUMBO /* 0x11e */ 20997 .long .L_ALT_OP_SPUT_BYTE_JUMBO /* 0x11f */ 20998 .long .L_ALT_OP_SPUT_CHAR_JUMBO /* 0x120 */ 20999 .long .L_ALT_OP_SPUT_SHORT_JUMBO /* 0x121 */ 21000 .long .L_ALT_OP_INVOKE_VIRTUAL_JUMBO /* 0x122 */ 21001 .long .L_ALT_OP_INVOKE_SUPER_JUMBO /* 0x123 */ 21002 .long .L_ALT_OP_INVOKE_DIRECT_JUMBO /* 0x124 */ 21003 .long .L_ALT_OP_INVOKE_STATIC_JUMBO /* 0x125 */ 21004 .long .L_ALT_OP_INVOKE_INTERFACE_JUMBO /* 0x126 */ 21005 .long .L_ALT_OP_UNUSED_27FF /* 0x127 */ 21006 .long .L_ALT_OP_UNUSED_28FF /* 0x128 */ 21007 .long .L_ALT_OP_UNUSED_29FF /* 0x129 */ 21008 .long .L_ALT_OP_UNUSED_2AFF /* 0x12a */ 21009 .long .L_ALT_OP_UNUSED_2BFF /* 0x12b */ 21010 .long .L_ALT_OP_UNUSED_2CFF /* 0x12c */ 21011 .long .L_ALT_OP_UNUSED_2DFF /* 0x12d */ 21012 .long .L_ALT_OP_UNUSED_2EFF /* 0x12e */ 21013 .long .L_ALT_OP_UNUSED_2FFF /* 0x12f */ 21014 .long .L_ALT_OP_UNUSED_30FF /* 0x130 */ 21015 .long .L_ALT_OP_UNUSED_31FF /* 0x131 */ 21016 .long .L_ALT_OP_UNUSED_32FF /* 0x132 */ 21017 .long .L_ALT_OP_UNUSED_33FF /* 0x133 */ 21018 .long .L_ALT_OP_UNUSED_34FF /* 0x134 */ 21019 .long .L_ALT_OP_UNUSED_35FF /* 0x135 */ 21020 .long .L_ALT_OP_UNUSED_36FF /* 0x136 */ 21021 .long .L_ALT_OP_UNUSED_37FF /* 0x137 */ 21022 .long .L_ALT_OP_UNUSED_38FF /* 0x138 */ 21023 .long .L_ALT_OP_UNUSED_39FF /* 0x139 */ 21024 .long .L_ALT_OP_UNUSED_3AFF /* 0x13a */ 21025 .long .L_ALT_OP_UNUSED_3BFF /* 0x13b */ 21026 .long .L_ALT_OP_UNUSED_3CFF /* 0x13c */ 21027 .long .L_ALT_OP_UNUSED_3DFF /* 0x13d */ 21028 .long .L_ALT_OP_UNUSED_3EFF /* 0x13e */ 21029 .long .L_ALT_OP_UNUSED_3FFF /* 0x13f */ 21030 .long .L_ALT_OP_UNUSED_40FF /* 0x140 */ 21031 .long .L_ALT_OP_UNUSED_41FF /* 0x141 */ 21032 .long .L_ALT_OP_UNUSED_42FF /* 0x142 */ 21033 .long .L_ALT_OP_UNUSED_43FF /* 0x143 */ 21034 .long .L_ALT_OP_UNUSED_44FF /* 0x144 */ 21035 .long .L_ALT_OP_UNUSED_45FF /* 0x145 */ 21036 .long .L_ALT_OP_UNUSED_46FF /* 0x146 */ 21037 .long .L_ALT_OP_UNUSED_47FF /* 0x147 */ 21038 .long .L_ALT_OP_UNUSED_48FF /* 0x148 */ 21039 .long .L_ALT_OP_UNUSED_49FF /* 0x149 */ 21040 .long .L_ALT_OP_UNUSED_4AFF /* 0x14a */ 21041 .long .L_ALT_OP_UNUSED_4BFF /* 0x14b */ 21042 .long .L_ALT_OP_UNUSED_4CFF /* 0x14c */ 21043 .long .L_ALT_OP_UNUSED_4DFF /* 0x14d */ 21044 .long .L_ALT_OP_UNUSED_4EFF /* 0x14e */ 21045 .long .L_ALT_OP_UNUSED_4FFF /* 0x14f */ 21046 .long .L_ALT_OP_UNUSED_50FF /* 0x150 */ 21047 .long .L_ALT_OP_UNUSED_51FF /* 0x151 */ 21048 .long .L_ALT_OP_UNUSED_52FF /* 0x152 */ 21049 .long .L_ALT_OP_UNUSED_53FF /* 0x153 */ 21050 .long .L_ALT_OP_UNUSED_54FF /* 0x154 */ 21051 .long .L_ALT_OP_UNUSED_55FF /* 0x155 */ 21052 .long .L_ALT_OP_UNUSED_56FF /* 0x156 */ 21053 .long .L_ALT_OP_UNUSED_57FF /* 0x157 */ 21054 .long .L_ALT_OP_UNUSED_58FF /* 0x158 */ 21055 .long .L_ALT_OP_UNUSED_59FF /* 0x159 */ 21056 .long .L_ALT_OP_UNUSED_5AFF /* 0x15a */ 21057 .long .L_ALT_OP_UNUSED_5BFF /* 0x15b */ 21058 .long .L_ALT_OP_UNUSED_5CFF /* 0x15c */ 21059 .long .L_ALT_OP_UNUSED_5DFF /* 0x15d */ 21060 .long .L_ALT_OP_UNUSED_5EFF /* 0x15e */ 21061 .long .L_ALT_OP_UNUSED_5FFF /* 0x15f */ 21062 .long .L_ALT_OP_UNUSED_60FF /* 0x160 */ 21063 .long .L_ALT_OP_UNUSED_61FF /* 0x161 */ 21064 .long .L_ALT_OP_UNUSED_62FF /* 0x162 */ 21065 .long .L_ALT_OP_UNUSED_63FF /* 0x163 */ 21066 .long .L_ALT_OP_UNUSED_64FF /* 0x164 */ 21067 .long .L_ALT_OP_UNUSED_65FF /* 0x165 */ 21068 .long .L_ALT_OP_UNUSED_66FF /* 0x166 */ 21069 .long .L_ALT_OP_UNUSED_67FF /* 0x167 */ 21070 .long .L_ALT_OP_UNUSED_68FF /* 0x168 */ 21071 .long .L_ALT_OP_UNUSED_69FF /* 0x169 */ 21072 .long .L_ALT_OP_UNUSED_6AFF /* 0x16a */ 21073 .long .L_ALT_OP_UNUSED_6BFF /* 0x16b */ 21074 .long .L_ALT_OP_UNUSED_6CFF /* 0x16c */ 21075 .long .L_ALT_OP_UNUSED_6DFF /* 0x16d */ 21076 .long .L_ALT_OP_UNUSED_6EFF /* 0x16e */ 21077 .long .L_ALT_OP_UNUSED_6FFF /* 0x16f */ 21078 .long .L_ALT_OP_UNUSED_70FF /* 0x170 */ 21079 .long .L_ALT_OP_UNUSED_71FF /* 0x171 */ 21080 .long .L_ALT_OP_UNUSED_72FF /* 0x172 */ 21081 .long .L_ALT_OP_UNUSED_73FF /* 0x173 */ 21082 .long .L_ALT_OP_UNUSED_74FF /* 0x174 */ 21083 .long .L_ALT_OP_UNUSED_75FF /* 0x175 */ 21084 .long .L_ALT_OP_UNUSED_76FF /* 0x176 */ 21085 .long .L_ALT_OP_UNUSED_77FF /* 0x177 */ 21086 .long .L_ALT_OP_UNUSED_78FF /* 0x178 */ 21087 .long .L_ALT_OP_UNUSED_79FF /* 0x179 */ 21088 .long .L_ALT_OP_UNUSED_7AFF /* 0x17a */ 21089 .long .L_ALT_OP_UNUSED_7BFF /* 0x17b */ 21090 .long .L_ALT_OP_UNUSED_7CFF /* 0x17c */ 21091 .long .L_ALT_OP_UNUSED_7DFF /* 0x17d */ 21092 .long .L_ALT_OP_UNUSED_7EFF /* 0x17e */ 21093 .long .L_ALT_OP_UNUSED_7FFF /* 0x17f */ 21094 .long .L_ALT_OP_UNUSED_80FF /* 0x180 */ 21095 .long .L_ALT_OP_UNUSED_81FF /* 0x181 */ 21096 .long .L_ALT_OP_UNUSED_82FF /* 0x182 */ 21097 .long .L_ALT_OP_UNUSED_83FF /* 0x183 */ 21098 .long .L_ALT_OP_UNUSED_84FF /* 0x184 */ 21099 .long .L_ALT_OP_UNUSED_85FF /* 0x185 */ 21100 .long .L_ALT_OP_UNUSED_86FF /* 0x186 */ 21101 .long .L_ALT_OP_UNUSED_87FF /* 0x187 */ 21102 .long .L_ALT_OP_UNUSED_88FF /* 0x188 */ 21103 .long .L_ALT_OP_UNUSED_89FF /* 0x189 */ 21104 .long .L_ALT_OP_UNUSED_8AFF /* 0x18a */ 21105 .long .L_ALT_OP_UNUSED_8BFF /* 0x18b */ 21106 .long .L_ALT_OP_UNUSED_8CFF /* 0x18c */ 21107 .long .L_ALT_OP_UNUSED_8DFF /* 0x18d */ 21108 .long .L_ALT_OP_UNUSED_8EFF /* 0x18e */ 21109 .long .L_ALT_OP_UNUSED_8FFF /* 0x18f */ 21110 .long .L_ALT_OP_UNUSED_90FF /* 0x190 */ 21111 .long .L_ALT_OP_UNUSED_91FF /* 0x191 */ 21112 .long .L_ALT_OP_UNUSED_92FF /* 0x192 */ 21113 .long .L_ALT_OP_UNUSED_93FF /* 0x193 */ 21114 .long .L_ALT_OP_UNUSED_94FF /* 0x194 */ 21115 .long .L_ALT_OP_UNUSED_95FF /* 0x195 */ 21116 .long .L_ALT_OP_UNUSED_96FF /* 0x196 */ 21117 .long .L_ALT_OP_UNUSED_97FF /* 0x197 */ 21118 .long .L_ALT_OP_UNUSED_98FF /* 0x198 */ 21119 .long .L_ALT_OP_UNUSED_99FF /* 0x199 */ 21120 .long .L_ALT_OP_UNUSED_9AFF /* 0x19a */ 21121 .long .L_ALT_OP_UNUSED_9BFF /* 0x19b */ 21122 .long .L_ALT_OP_UNUSED_9CFF /* 0x19c */ 21123 .long .L_ALT_OP_UNUSED_9DFF /* 0x19d */ 21124 .long .L_ALT_OP_UNUSED_9EFF /* 0x19e */ 21125 .long .L_ALT_OP_UNUSED_9FFF /* 0x19f */ 21126 .long .L_ALT_OP_UNUSED_A0FF /* 0x1a0 */ 21127 .long .L_ALT_OP_UNUSED_A1FF /* 0x1a1 */ 21128 .long .L_ALT_OP_UNUSED_A2FF /* 0x1a2 */ 21129 .long .L_ALT_OP_UNUSED_A3FF /* 0x1a3 */ 21130 .long .L_ALT_OP_UNUSED_A4FF /* 0x1a4 */ 21131 .long .L_ALT_OP_UNUSED_A5FF /* 0x1a5 */ 21132 .long .L_ALT_OP_UNUSED_A6FF /* 0x1a6 */ 21133 .long .L_ALT_OP_UNUSED_A7FF /* 0x1a7 */ 21134 .long .L_ALT_OP_UNUSED_A8FF /* 0x1a8 */ 21135 .long .L_ALT_OP_UNUSED_A9FF /* 0x1a9 */ 21136 .long .L_ALT_OP_UNUSED_AAFF /* 0x1aa */ 21137 .long .L_ALT_OP_UNUSED_ABFF /* 0x1ab */ 21138 .long .L_ALT_OP_UNUSED_ACFF /* 0x1ac */ 21139 .long .L_ALT_OP_UNUSED_ADFF /* 0x1ad */ 21140 .long .L_ALT_OP_UNUSED_AEFF /* 0x1ae */ 21141 .long .L_ALT_OP_UNUSED_AFFF /* 0x1af */ 21142 .long .L_ALT_OP_UNUSED_B0FF /* 0x1b0 */ 21143 .long .L_ALT_OP_UNUSED_B1FF /* 0x1b1 */ 21144 .long .L_ALT_OP_UNUSED_B2FF /* 0x1b2 */ 21145 .long .L_ALT_OP_UNUSED_B3FF /* 0x1b3 */ 21146 .long .L_ALT_OP_UNUSED_B4FF /* 0x1b4 */ 21147 .long .L_ALT_OP_UNUSED_B5FF /* 0x1b5 */ 21148 .long .L_ALT_OP_UNUSED_B6FF /* 0x1b6 */ 21149 .long .L_ALT_OP_UNUSED_B7FF /* 0x1b7 */ 21150 .long .L_ALT_OP_UNUSED_B8FF /* 0x1b8 */ 21151 .long .L_ALT_OP_UNUSED_B9FF /* 0x1b9 */ 21152 .long .L_ALT_OP_UNUSED_BAFF /* 0x1ba */ 21153 .long .L_ALT_OP_UNUSED_BBFF /* 0x1bb */ 21154 .long .L_ALT_OP_UNUSED_BCFF /* 0x1bc */ 21155 .long .L_ALT_OP_UNUSED_BDFF /* 0x1bd */ 21156 .long .L_ALT_OP_UNUSED_BEFF /* 0x1be */ 21157 .long .L_ALT_OP_UNUSED_BFFF /* 0x1bf */ 21158 .long .L_ALT_OP_UNUSED_C0FF /* 0x1c0 */ 21159 .long .L_ALT_OP_UNUSED_C1FF /* 0x1c1 */ 21160 .long .L_ALT_OP_UNUSED_C2FF /* 0x1c2 */ 21161 .long .L_ALT_OP_UNUSED_C3FF /* 0x1c3 */ 21162 .long .L_ALT_OP_UNUSED_C4FF /* 0x1c4 */ 21163 .long .L_ALT_OP_UNUSED_C5FF /* 0x1c5 */ 21164 .long .L_ALT_OP_UNUSED_C6FF /* 0x1c6 */ 21165 .long .L_ALT_OP_UNUSED_C7FF /* 0x1c7 */ 21166 .long .L_ALT_OP_UNUSED_C8FF /* 0x1c8 */ 21167 .long .L_ALT_OP_UNUSED_C9FF /* 0x1c9 */ 21168 .long .L_ALT_OP_UNUSED_CAFF /* 0x1ca */ 21169 .long .L_ALT_OP_UNUSED_CBFF /* 0x1cb */ 21170 .long .L_ALT_OP_UNUSED_CCFF /* 0x1cc */ 21171 .long .L_ALT_OP_UNUSED_CDFF /* 0x1cd */ 21172 .long .L_ALT_OP_UNUSED_CEFF /* 0x1ce */ 21173 .long .L_ALT_OP_UNUSED_CFFF /* 0x1cf */ 21174 .long .L_ALT_OP_UNUSED_D0FF /* 0x1d0 */ 21175 .long .L_ALT_OP_UNUSED_D1FF /* 0x1d1 */ 21176 .long .L_ALT_OP_UNUSED_D2FF /* 0x1d2 */ 21177 .long .L_ALT_OP_UNUSED_D3FF /* 0x1d3 */ 21178 .long .L_ALT_OP_UNUSED_D4FF /* 0x1d4 */ 21179 .long .L_ALT_OP_UNUSED_D5FF /* 0x1d5 */ 21180 .long .L_ALT_OP_UNUSED_D6FF /* 0x1d6 */ 21181 .long .L_ALT_OP_UNUSED_D7FF /* 0x1d7 */ 21182 .long .L_ALT_OP_UNUSED_D8FF /* 0x1d8 */ 21183 .long .L_ALT_OP_UNUSED_D9FF /* 0x1d9 */ 21184 .long .L_ALT_OP_UNUSED_DAFF /* 0x1da */ 21185 .long .L_ALT_OP_UNUSED_DBFF /* 0x1db */ 21186 .long .L_ALT_OP_UNUSED_DCFF /* 0x1dc */ 21187 .long .L_ALT_OP_UNUSED_DDFF /* 0x1dd */ 21188 .long .L_ALT_OP_UNUSED_DEFF /* 0x1de */ 21189 .long .L_ALT_OP_UNUSED_DFFF /* 0x1df */ 21190 .long .L_ALT_OP_UNUSED_E0FF /* 0x1e0 */ 21191 .long .L_ALT_OP_UNUSED_E1FF /* 0x1e1 */ 21192 .long .L_ALT_OP_UNUSED_E2FF /* 0x1e2 */ 21193 .long .L_ALT_OP_UNUSED_E3FF /* 0x1e3 */ 21194 .long .L_ALT_OP_UNUSED_E4FF /* 0x1e4 */ 21195 .long .L_ALT_OP_UNUSED_E5FF /* 0x1e5 */ 21196 .long .L_ALT_OP_UNUSED_E6FF /* 0x1e6 */ 21197 .long .L_ALT_OP_UNUSED_E7FF /* 0x1e7 */ 21198 .long .L_ALT_OP_UNUSED_E8FF /* 0x1e8 */ 21199 .long .L_ALT_OP_UNUSED_E9FF /* 0x1e9 */ 21200 .long .L_ALT_OP_UNUSED_EAFF /* 0x1ea */ 21201 .long .L_ALT_OP_UNUSED_EBFF /* 0x1eb */ 21202 .long .L_ALT_OP_UNUSED_ECFF /* 0x1ec */ 21203 .long .L_ALT_OP_UNUSED_EDFF /* 0x1ed */ 21204 .long .L_ALT_OP_UNUSED_EEFF /* 0x1ee */ 21205 .long .L_ALT_OP_UNUSED_EFFF /* 0x1ef */ 21206 .long .L_ALT_OP_UNUSED_F0FF /* 0x1f0 */ 21207 .long .L_ALT_OP_UNUSED_F1FF /* 0x1f1 */ 21208 .long .L_ALT_OP_UNUSED_F2FF /* 0x1f2 */ 21209 .long .L_ALT_OP_UNUSED_F3FF /* 0x1f3 */ 21210 .long .L_ALT_OP_UNUSED_F4FF /* 0x1f4 */ 21211 .long .L_ALT_OP_UNUSED_F5FF /* 0x1f5 */ 21212 .long .L_ALT_OP_UNUSED_F6FF /* 0x1f6 */ 21213 .long .L_ALT_OP_UNUSED_F7FF /* 0x1f7 */ 21214 .long .L_ALT_OP_UNUSED_F8FF /* 0x1f8 */ 21215 .long .L_ALT_OP_UNUSED_F9FF /* 0x1f9 */ 21216 .long .L_ALT_OP_UNUSED_FAFF /* 0x1fa */ 21217 .long .L_ALT_OP_UNUSED_FBFF /* 0x1fb */ 21218 .long .L_ALT_OP_UNUSED_FCFF /* 0x1fc */ 21219 .long .L_ALT_OP_UNUSED_FDFF /* 0x1fd */ 21220 .long .L_ALT_OP_UNUSED_FEFF /* 0x1fe */ 21221 .long .L_ALT_OP_THROW_VERIFICATION_ERROR_JUMBO /* 0x1ff */ 21222/* File: x86/entry.S */ 21223/* 21224 * Copyright (C) 2008 The Android Open Source Project 21225 * 21226 * Licensed under the Apache License, Version 2.0 (the "License"); 21227 * you may not use this file except in compliance with the License. 21228 * You may obtain a copy of the License at 21229 * 21230 * http://www.apache.org/licenses/LICENSE-2.0 21231 * 21232 * Unless required by applicable law or agreed to in writing, software 21233 * distributed under the License is distributed on an "AS IS" BASIS, 21234 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 21235 * See the License for the specific language governing permissions and 21236 * limitations under the License. 21237 */ 21238 21239 21240 .text 21241 .global dvmMterpStdRun 21242 .type dvmMterpStdRun, %function 21243/* 21244 * bool dvmMterpStdRun(Thread* self) 21245 * 21246 * Interpreter entry point. Returns changeInterp. 21247 * 21248 */ 21249dvmMterpStdRun: 21250 movl 4(%esp), %ecx # get incoming rSELF 21251 push %ebp # save caller base pointer 21252 push %ecx # save rSELF at (%ebp) 21253 movl %esp, %ebp # set our %ebp 21254/* 21255 * At this point we've allocated two slots on the stack 21256 * via push and stack is 8-byte aligned. Allocate space 21257 * for 8 spill slots, 3 local slots, 5 arg slots + 2 slots for 21258 * padding to bring us to 16-byte alignment 21259 */ 21260 subl $(FRAME_SIZE-8), %esp 21261 21262/* Spill callee save regs */ 21263 movl %edi,EDI_SPILL(%ebp) 21264 movl %esi,ESI_SPILL(%ebp) 21265 movl %ebx,EBX_SPILL(%ebp) 21266 21267/* Set up "named" registers */ 21268 movl offThread_pc(%ecx),rPC 21269 movl offThread_fp(%ecx),rFP 21270 movl offThread_curHandlerTable(%ecx),rIBASE 21271 21272/* Remember %esp for future "longjmp" */ 21273 movl %esp,offThread_bailPtr(%ecx) 21274 21275/* How to start? */ 21276 movb offThread_entryPoint(%ecx),%al 21277 21278/* Normal start? */ 21279 cmpb $kInterpEntryInstr,%al 21280 jne .Lnot_instr 21281 21282 /* Normal case: start executing the instruction at rPC */ 21283 FETCH_INST 21284 GOTO_NEXT 21285 21286.Lnot_instr: 21287 /* Reset to normal case */ 21288 movb $kInterpEntryInstr,offThread_entryPoint(%ecx) 21289 cmpb $kInterpEntryReturn,%al 21290 je common_returnFromMethod 21291 cmpb $kInterpEntryThrow,%al 21292 je common_exceptionThrown 21293 movzx %al,%eax 21294 movl %eax,OUT_ARG1(%esp) 21295 movl $.LstrBadEntryPoint,OUT_ARG0(%esp) 21296 call printf 21297 call dvmAbort 21298 /* Not reached */ 21299 21300 21301 .global dvmMterpStdBail 21302 .type dvmMterpStdBail, %function 21303/* 21304 * void dvmMterpStdBail(Thread* self, bool changeInterp) 21305 * 21306 * Restore the stack pointer and PC from the save point established on entry. 21307 * This is essentially the same as a longjmp, but should be cheaper. The 21308 * last instruction causes us to return to whoever called dvmMterpStdRun. 21309 * 21310 * We're not going to build a standard frame here, so the arg accesses will 21311 * look a little strange. 21312 * 21313 * On entry: 21314 * esp+4 (arg0) Thread* self 21315 * esp+8 (arg1) bool changeInterp 21316 */ 21317dvmMterpStdBail: 21318 movl 4(%esp),%ecx # grab self 21319 movl 8(%esp),%eax # changeInterp to return reg 21320 movl offThread_bailPtr(%ecx),%esp # Restore "setjmp" esp 21321 movl %esp,%ebp 21322 addl $(FRAME_SIZE-8), %ebp # Restore %ebp at point of setjmp 21323 movl EDI_SPILL(%ebp),%edi 21324 movl ESI_SPILL(%ebp),%esi 21325 movl EBX_SPILL(%ebp),%ebx 21326 movl PREV_FP(%ebp),%ebp # restore caller's ebp 21327 addl $FRAME_SIZE,%esp # strip frame 21328 ret # return to dvmMterpStdRun's caller 21329 21330 21331/* 21332 * Strings 21333 */ 21334 .section .rodata 21335.LstrBadEntryPoint: 21336 .asciz "Bad entry point %d\n" 21337 21338 21339/* File: x86/footer.S */ 21340/* 21341 * Copyright (C) 2008 The Android Open Source Project 21342 * 21343 * Licensed under the Apache License, Version 2.0 (the "License"); 21344 * you may not use this file except in compliance with the License. 21345 * You may obtain a copy of the License at 21346 * 21347 * http://www.apache.org/licenses/LICENSE-2.0 21348 * 21349 * Unless required by applicable law or agreed to in writing, software 21350 * distributed under the License is distributed on an "AS IS" BASIS, 21351 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 21352 * See the License for the specific language governing permissions and 21353 * limitations under the License. 21354 */ 21355/* 21356 * Common subroutines and data. 21357 */ 21358 21359#if defined(WITH_JIT) 21360/* 21361 * JIT-related re-entries into the interpreter. In general, if the 21362 * exit from a translation can at some point be chained, the entry 21363 * here requires that control arrived via a call, and that the "rp" 21364 * on TOS is actually a pointer to a 32-bit cell containing the Dalvik PC 21365 * of the next insn to handle. If no chaining will happen, the entry 21366 * should be reached via a direct jump and rPC set beforehand. 21367 */ 21368 21369 .global dvmJitToInterpPunt 21370/* 21371 * The compiler will generate a jump to this entry point when it is 21372 * having difficulty translating a Dalvik instruction. We must skip 21373 * the code cache lookup & prevent chaining to avoid bouncing between 21374 * the interpreter and code cache. rPC must be set on entry. 21375 */ 21376dvmJitToInterpPunt: 21377#if defined(WITH_JIT_TUNING) 21378 movl rPC, OUT_ARG0(%esp) 21379 call dvmBumpPunt 21380#endif 21381 movl rSELF, %ecx 21382 movl offThread_curHandlerTable(%ecx),rIBASE 21383 FETCH_INST_R %ecx 21384 GOTO_NEXT_R %ecx 21385 21386 .global dvmJitToInterpSingleStep 21387/* 21388 * Return to the interpreter to handle a single instruction. 21389 * Should be reached via a call. 21390 * On entry: 21391 * 0(%esp) <= native return address within trace 21392 * rPC <= Dalvik PC of this instruction 21393 * OUT_ARG0+4(%esp) <= Dalvik PC of next instruction 21394 */ 21395dvmJitToInterpSingleStep: 21396 pop %eax 21397 movl rSELF, %ecx 21398 movl OUT_ARG0(%esp), %edx 21399 movl %eax,offThread_jitResumeNPC(%ecx) 21400 movl %edx,offThread_jitResumeDPC(%ecx) 21401 movl $kInterpEntryInstr,offThread_entryPoint(%ecx) 21402 movl $1,rINST # changeInterp <= true 21403 jmp common_gotoBail 21404 21405 .global dvmJitToInterpNoChainNoProfile 21406/* 21407 * Return from the translation cache to the interpreter to do method 21408 * invocation. Check if the translation exists for the callee, but don't 21409 * chain to it. rPC must be set on entry. 21410 */ 21411dvmJitToInterpNoChainNoProfile: 21412#if defined(WITH_JIT_TUNING) 21413 call dvmBumpNoChain 21414#endif 21415 movl rPC,OUT_ARG0(%esp) 21416 call dvmJitGetTraceAddr # is there a translation? 21417 movl rSELF,%ecx # ecx <- self 21418 movl %eax,offThread_inJitCodeCache(%ecx) # set inJitCodeCache flag 21419 cmpl $0, %eax 21420 jz 1f 21421 call *%eax # exec translation if we've got one 21422 # won't return 214231: 21424 movl rSELF, %ecx 21425 movl offThread_curHandlerTable(%ecx),rIBASE 21426 FETCH_INST_R %ecx 21427 GOTO_NEXT_R %ecx 21428 21429/* 21430 * Return from the translation cache and immediately request a 21431 * translation fro the exit target, but don't attempt to chain. 21432 * rPC set on entry. 21433 */ 21434 .global dvmJitToInterpTraceSelectNoChain 21435dvmJitToInterpTraceSelectNoChain: 21436#if defined(WITH_JIT_TUNING) 21437 call dvmBumpNoChain 21438#endif 21439 movl rPC,OUT_ARG0(%esp) 21440 call dvmJitGetTraceAddr # is there a translation? 21441 movl rSELF,%ecx 21442 cmpl $0,%eax 21443 movl %eax,offThread_inJitCodeCache(%ecx) # set inJitCodeCache flag 21444 jz 1f 21445 call *%eax # jump to tranlation 21446 # won't return 21447 21448/* No Translation - request one */ 214491: 21450 GET_JIT_PROF_TABLE %ecx %eax 21451 cmpl $0, %eax # JIT enabled? 21452 jnz 2f # Request one if so 21453 movl rSELF, %ecx 21454 movl offThread_curHandlerTable(%ecx),rIBASE 21455 FETCH_INST_R %ecx # Continue interpreting if not 21456 GOTO_NEXT_R %ecx 214572: 21458 movl $kJitTSelectRequestHot,rINST # ask for trace select 21459 jmp common_selectTrace 21460 21461/* 21462 * Return from the translation cache and immediately request a 21463 * translation for the exit target. Reached via a call, and 21464 * (TOS)->rPC. 21465 */ 21466 .global dvmJitToInterpTraceSelect 21467dvmJitToInterpTraceSelect: 21468 pop rINST # save chain cell address in callee save reg 21469 movl (rINST),rPC 21470 movl rPC,OUT_ARG0(%esp) 21471 call dvmJitGetTraceAddr # is there a translation? 21472 cmpl $0,%eax 21473 jz 1b # no - ask for one 21474 movl %eax,OUT_ARG0(%esp) 21475# FIXME - need to adjust rINST to beginning of sequence 21476 movl rINST,OUT_ARG1(%esp) 21477 call dvmJitChain # Attempt dvmJitChain(codeAddr,chainAddr) 21478 cmpl $0,%eax # Success? 21479 jz toInterpreter # didn't chain - interpret 21480 call *%eax 21481 # won't return 21482 21483/* 21484 * Placeholder entries for x86 JIT 21485 */ 21486 .global dvmJitToInterpBackwardBranch 21487dvmJitToInterpBackwardBranch: 21488 .global dvmJitToInterpNormal 21489dvmJitToInterpNormal: 21490 .global dvmJitToInterpNoChain 21491dvmJitToInterpNoChain: 21492toInterpreter: 21493 jmp common_abort 21494#endif 21495 21496/* 21497 * Common code when a backwards branch is taken 21498 * 21499 * On entry: 21500 * ebx (a.k.a. rINST) -> PC adjustment in 16-bit words 21501 */ 21502common_backwardBranch: 21503 movl rSELF,%ecx 21504 call common_periodicChecks # rPC and ecx/rSELF preserved 21505#if defined(WITH_JIT) 21506 GET_JIT_PROF_TABLE %ecx rIBASE 21507 ADVANCE_PC_INDEXED rINST 21508 cmpl $0,rIBASE 21509 movl offThread_curHandlerTable(%ecx),rIBASE 21510 FETCH_INST 21511 jz 1f # Profiling off - continue 21512 .global updateProfile 21513updateProfile: 21514common_updateProfile: 21515 # quick & dirty hash 21516 movl rPC, %eax 21517 shrl $12, %eax 21518 xorl rPC, %eax 21519 andl $((1<<JIT_PROF_SIZE_LOG_2)-1),%eax 21520 decb (%edx,%eax) 21521 jz 2f 215221: 21523 GOTO_NEXT 215242: 21525/* 21526 * Here, we switch to the debug interpreter to request 21527 * trace selection. First, though, check to see if there 21528 * is already a native translation in place (and, if so, 21529 * jump to it now. 21530 */ 21531 GET_JIT_THRESHOLD %ecx rINST # leaves rSELF in %ecx 21532 EXPORT_PC 21533 movb rINSTbl,(%edx,%eax) # reset counter 21534 movl %ecx,rINST # preserve rSELF 21535 movl rPC,OUT_ARG0(%esp) 21536 call dvmJitGetTraceAddr # already have one? 21537 movl %eax,offThread_inJitCodeCache(rINST) # set the inJitCodeCache flag 21538 cmpl $0,%eax 21539 jz 1f 21540 call *%eax # FIXME: decide call vs/ jmp!. No return either way 215411: 21542 movl $kJitTSelectRequest,%eax 21543 # On entry, eax<- jitState, rPC valid 21544common_selectTrace: 21545 21546 movl rSELF,%ecx 21547 movl %eax,offThread_jitState(%ecx) 21548 movl $kInterpEntryInstr,offThread_entryPoint(%ecx) 21549 movl $1,rINST 21550 jmp common_gotoBail 21551#else 21552 movl offThread_curHandlerTable(%ecx),rIBASE 21553 ADVANCE_PC_INDEXED rINST 21554 FETCH_INST 21555 GOTO_NEXT 21556#endif 21557 21558 21559 21560/* 21561 * Common code for jumbo method invocation. 21562 * 21563 * On entry: 21564 * eax = Method* methodToCall 21565 * rINSTw trashed, must reload 21566 * rIBASE trashed, must reload before resuming interpreter 21567 */ 21568 21569common_invokeMethodJumbo: 21570.LinvokeNewJumbo: 21571 21572 /* 21573 * prepare to copy args to "outs" area of current frame 21574 */ 21575 movzwl 6(rPC),rINST # rINST<- BBBB 21576 movzwl 8(rPC), %ecx # %ecx<- CCCC 21577 ADVANCE_PC 2 # adjust pc to make return similar 21578 SAVEAREA_FROM_FP %edx # %edx<- &StackSaveArea 21579 test rINST, rINST 21580 movl rINST, LOCAL0_OFFSET(%ebp) # LOCAL0_OFFSET(%ebp)<- BBBB 21581 jz .LinvokeArgsDone # no args; jump to args done 21582 jmp .LinvokeRangeArgs # handle args like invoke range 21583 21584/* 21585 * Common code for method invocation with range. 21586 * 21587 * On entry: 21588 * eax = Method* methodToCall 21589 * rINSTw trashed, must reload 21590 * rIBASE trashed, must reload before resuming interpreter 21591 */ 21592 21593common_invokeMethodRange: 21594.LinvokeNewRange: 21595 21596 /* 21597 * prepare to copy args to "outs" area of current frame 21598 */ 21599 21600 movzbl 1(rPC),rINST # rINST<- AA 21601 movzwl 4(rPC), %ecx # %ecx<- CCCC 21602 SAVEAREA_FROM_FP %edx # %edx<- &StackSaveArea 21603 test rINST, rINST 21604 movl rINST, LOCAL0_OFFSET(%ebp) # LOCAL0_OFFSET(%ebp)<- AA 21605 jz .LinvokeArgsDone # no args; jump to args done 21606 21607 21608 /* 21609 * %eax=methodToCall, %ecx=CCCC, LOCAL0_OFFSET(%ebp)=count, %edx=&outs (&stackSaveArea) 21610 * (very few methods have > 10 args; could unroll for common cases) 21611 */ 21612 21613.LinvokeRangeArgs: 21614 movl %ebx, LOCAL1_OFFSET(%ebp) # LOCAL1_OFFSET(%ebp)<- save %ebx 21615 lea (rFP, %ecx, 4), %ecx # %ecx<- &vCCCC 21616 shll $2, LOCAL0_OFFSET(%ebp) # LOCAL0_OFFSET(%ebp)<- offset 21617 subl LOCAL0_OFFSET(%ebp), %edx # %edx<- update &outs 21618 shrl $2, LOCAL0_OFFSET(%ebp) # LOCAL0_OFFSET(%ebp)<- offset 216191: 21620 movl (%ecx), %ebx # %ebx<- vCCCC 21621 lea 4(%ecx), %ecx # %ecx<- &vCCCC++ 21622 subl $1, LOCAL0_OFFSET(%ebp) # LOCAL0_OFFSET<- LOCAL0_OFFSET-- 21623 movl %ebx, (%edx) # *outs<- vCCCC 21624 lea 4(%edx), %edx # outs++ 21625 jne 1b # loop if count (LOCAL0_OFFSET(%ebp)) not zero 21626 movl LOCAL1_OFFSET(%ebp), %ebx # %ebx<- restore %ebx 21627 jmp .LinvokeArgsDone # continue 21628 21629 /* 21630 * %eax is "Method* methodToCall", the method we're trying to call 21631 * prepare to copy args to "outs" area of current frame 21632 * rIBASE trashed, must reload before resuming interpreter 21633 */ 21634 21635common_invokeMethodNoRange: 21636.LinvokeNewNoRange: 21637 movzbl 1(rPC),rINST # rINST<- BA 21638 movl rINST, LOCAL0_OFFSET(%ebp) # LOCAL0_OFFSET(%ebp)<- BA 21639 shrl $4, LOCAL0_OFFSET(%ebp) # LOCAL0_OFFSET(%ebp)<- B 21640 je .LinvokeArgsDone # no args; jump to args done 21641 movzwl 4(rPC), %ecx # %ecx<- GFED 21642 SAVEAREA_FROM_FP %edx # %edx<- &StackSaveArea 21643 21644 /* 21645 * %eax=methodToCall, %ecx=GFED, LOCAL0_OFFSET(%ebp)=count, %edx=outs 21646 */ 21647 21648.LinvokeNonRange: 21649 cmp $2, LOCAL0_OFFSET(%ebp) # compare LOCAL0_OFFSET(%ebp) to 2 21650 movl %ecx, LOCAL1_OFFSET(%ebp) # LOCAL1_OFFSET(%ebp)<- GFED 21651 jl 1f # handle 1 arg 21652 je 2f # handle 2 args 21653 cmp $4, LOCAL0_OFFSET(%ebp) # compare LOCAL0_OFFSET(%ebp) to 4 21654 jl 3f # handle 3 args 21655 je 4f # handle 4 args 216565: 21657 andl $15, rINST # rINSTw<- A 21658 lea -4(%edx), %edx # %edx<- update &outs; &outs-- 21659 movl (rFP, rINST, 4), %ecx # %ecx<- vA 21660 movl %ecx, (%edx) # *outs<- vA 21661 movl LOCAL1_OFFSET(%ebp), %ecx # %ecx<- GFED 216624: 21663 shr $12, %ecx # %ecx<- G 21664 lea -4(%edx), %edx # %edx<- update &outs; &outs-- 21665 movl (rFP, %ecx, 4), %ecx # %ecx<- vG 21666 movl %ecx, (%edx) # *outs<- vG 21667 movl LOCAL1_OFFSET(%ebp), %ecx # %ecx<- GFED 216683: 21669 and $0x0f00, %ecx # %ecx<- 0F00 21670 shr $8, %ecx # %ecx<- F 21671 lea -4(%edx), %edx # %edx<- update &outs; &outs-- 21672 movl (rFP, %ecx, 4), %ecx # %ecx<- vF 21673 movl %ecx, (%edx) # *outs<- vF 21674 movl LOCAL1_OFFSET(%ebp), %ecx # %ecx<- GFED 216752: 21676 and $0x00f0, %ecx # %ecx<- 00E0 21677 shr $4, %ecx # %ecx<- E 21678 lea -4(%edx), %edx # %edx<- update &outs; &outs-- 21679 movl (rFP, %ecx, 4), %ecx # %ecx<- vE 21680 movl %ecx, (%edx) # *outs<- vE 21681 movl LOCAL1_OFFSET(%ebp), %ecx # %ecx<- GFED 216821: 21683 and $0x000f, %ecx # %ecx<- 000D 21684 movl (rFP, %ecx, 4), %ecx # %ecx<- vD 21685 movl %ecx, -4(%edx) # *--outs<- vD 216860: 21687 21688 /* 21689 * %eax is "Method* methodToCall", the method we're trying to call 21690 * find space for the new stack frame, check for overflow 21691 */ 21692 21693.LinvokeArgsDone: 21694 movzwl offMethod_registersSize(%eax), %edx # %edx<- methodToCall->regsSize 21695 movzwl offMethod_outsSize(%eax), %ecx # %ecx<- methodToCall->outsSize 21696 movl %eax, LOCAL0_OFFSET(%ebp) # LOCAL0_OFFSET<- methodToCall 21697 shl $2, %edx # %edx<- update offset 21698 SAVEAREA_FROM_FP %eax # %eax<- &StackSaveArea 21699 subl %edx, %eax # %eax<- newFP; (old savearea - regsSize) 21700 movl rSELF,%edx # %edx<- pthread 21701 movl %eax, LOCAL1_OFFSET(%ebp) # LOCAL1_OFFSET(%ebp)<- &outs 21702 subl $sizeofStackSaveArea, %eax # %eax<- newSaveArea (stack save area using newFP) 21703 movl offThread_interpStackEnd(%edx), %edx # %edx<- self->interpStackEnd 21704 movl %edx, LOCAL2_OFFSET(%ebp) # LOCAL2_OFFSET<- self->interpStackEnd 21705 shl $2, %ecx # %ecx<- update offset for outsSize 21706 movl %eax, %edx # %edx<- newSaveArea 21707 sub %ecx, %eax # %eax<- bottom; (newSaveArea - outsSize) 21708 cmp LOCAL2_OFFSET(%ebp), %eax # compare interpStackEnd and bottom 21709 movl LOCAL0_OFFSET(%ebp), %eax # %eax<- restore methodToCall 21710 jl .LstackOverflow # handle frame overflow 21711 21712 /* 21713 * set up newSaveArea 21714 */ 21715 21716#ifdef EASY_GDB 21717 SAVEAREA_FROM_FP %ecx # %ecx<- &StackSaveArea 21718 movl %ecx, offStackSaveArea_prevSave(%edx) # newSaveArea->prevSave<- &outs 21719#endif 21720 movl rFP, offStackSaveArea_prevFrame(%edx) # newSaveArea->prevFrame<- rFP 21721 movl rPC, offStackSaveArea_savedPc(%edx) # newSaveArea->savedPc<- rPC 21722 testl $ACC_NATIVE, offMethod_accessFlags(%eax) # check for native call 21723 movl %eax, offStackSaveArea_method(%edx) # newSaveArea->method<- method to call 21724 jne .LinvokeNative # handle native call 21725 21726 /* 21727 * Update "self" values for the new method 21728 * %eax=methodToCall, LOCAL1_OFFSET(%ebp)=newFp 21729 */ 21730 21731 movl offMethod_clazz(%eax), %edx # %edx<- method->clazz 21732 movl rSELF,%ecx # %ecx<- pthread 21733 movl offClassObject_pDvmDex(%edx), %edx # %edx<- method->clazz->pDvmDex 21734 movl %eax, offThread_method(%ecx) # self->method<- methodToCall 21735 movl %edx, offThread_methodClassDex(%ecx) # self->methodClassDex<- method->clazz->pDvmDex 21736 movl offMethod_insns(%eax), rPC # rPC<- methodToCall->insns 21737 movl LOCAL1_OFFSET(%ebp), rFP # rFP<- newFP 21738 movl rFP, offThread_curFrame(%ecx) # self->curFrame<- newFP 21739 movl offThread_curHandlerTable(%ecx),rIBASE 21740 FETCH_INST 21741 GOTO_NEXT # jump to methodToCall->insns 21742 21743 /* 21744 * Prep for the native call 21745 * %eax=methodToCall, LOCAL1_OFFSET(%ebp)=newFP, %edx=newSaveArea 21746 */ 21747 21748.LinvokeNative: 21749 movl rSELF,%ecx # %ecx<- pthread 21750 movl %eax, OUT_ARG1(%esp) # push parameter methodToCall 21751 movl offThread_jniLocal_topCookie(%ecx), %eax # %eax<- self->localRef->... 21752 movl %eax, offStackSaveArea_localRefCookie(%edx) # newSaveArea->localRefCookie<- top 21753 movl %edx, OUT_ARG4(%esp) # save newSaveArea 21754 movl LOCAL1_OFFSET(%ebp), %edx # %edx<- newFP 21755 movl %edx, offThread_curFrame(%ecx) # self->curFrame<- newFP 21756 movl %ecx, OUT_ARG3(%esp) # save self 21757 movl %ecx, OUT_ARG2(%esp) # push parameter self 21758 movl rSELF,%ecx # %ecx<- pthread 21759 movl OUT_ARG1(%esp), %eax # %eax<- methodToCall 21760 lea offThread_retval(%ecx), %ecx # %ecx<- &retval 21761 movl %ecx, OUT_ARG0(%esp) # push parameter pthread 21762 push %edx # push parameter newFP 21763 21764 call *offMethod_nativeFunc(%eax) # call methodToCall->nativeFunc 21765 lea 4(%esp), %esp 21766 movl OUT_ARG4(%esp), %ecx # %ecx<- newSaveArea 21767 movl OUT_ARG3(%esp), %eax # %eax<- self 21768 movl offStackSaveArea_localRefCookie(%ecx), %edx # %edx<- old top 21769 cmp $0, offThread_exception(%eax) # check for exception 21770 movl rFP, offThread_curFrame(%eax) # self->curFrame<- rFP 21771 movl %edx, offThread_jniLocal_topCookie(%eax) # new top <- old top 21772 jne common_exceptionThrown # handle exception 21773 movl offThread_curHandlerTable(%eax),rIBASE 21774 FETCH_INST_OPCODE 3 %ecx 21775 ADVANCE_PC 3 21776 GOTO_NEXT_R %ecx # jump to next instruction 21777 21778.LstackOverflow: # eax=methodToCall 21779 movl %eax, OUT_ARG1(%esp) # push parameter methodToCall 21780 movl rSELF,%eax # %eax<- self 21781 movl %eax, OUT_ARG0(%esp) # push parameter self 21782 call dvmHandleStackOverflow # call: (Thread* self, Method* meth) 21783 jmp common_exceptionThrown # handle exception 21784 21785 21786/* 21787 * Do we need the thread to be suspended or have debugger/profiling activity? 21788 * 21789 * On entry: 21790 * ebx -> PC adjustment in 16-bit words (must be preserved) 21791 * ecx -> SELF pointer 21792 * reentry type, e.g. kInterpEntryInstr stored in rSELF->entryPoint 21793 * 21794 * Note: A call will normally kill %eax and %ecx. To 21795 * streamline the normal case, this routine will preserve 21796 * %ecx in addition to the normal caller save regs. The save/restore 21797 * is a bit ugly, but will happen in the relatively uncommon path. 21798 * TODO: Basic-block style Jit will need a hook here as well. Fold it into 21799 * the suspendCount check so we can get both in 1 shot. 21800 * TUNING: Improve scheduling here & do initial single test for all. 21801 */ 21802common_periodicChecks: 21803 cmpl $0,offThread_suspendCount(%ecx) # non-zero suspendCount? 21804 jne 1f 21805 218066: 21807 movl offThread_pInterpBreak(%ecx),%eax # eax <- &interpBreak 21808 cmpl $0,(%eax) # something interesting happening? 21809 jne 3f # yes - switch interpreters 21810 ret 21811 21812 /* Check for suspend */ 218131: 21814 /* At this point, the return pointer to the caller of 21815 * common_periodicChecks is on the top of stack. We need to preserve 21816 * SELF(ecx). 21817 * The outgoing profile is: 21818 * bool dvmCheckSuspendPending(Thread* self) 21819 * Because we reached here via a call, go ahead and build a new frame. 21820 */ 21821 EXPORT_PC # need for precise GC 21822 movl %ecx,%eax # eax<- self 21823 push %ebp 21824 movl %esp,%ebp 21825 subl $24,%esp 21826 movl %eax,OUT_ARG0(%esp) 21827 call dvmCheckSuspendPending 21828 addl $24,%esp 21829 pop %ebp 21830 movl rSELF,%ecx 21831 21832 /* 21833 * Need to check to see if debugger or profiler flags got set 21834 * while we were suspended. 21835 */ 21836 jmp 6b 21837 21838 /* Switch interpreters */ 21839 /* Note: %ebx contains the 16-bit word offset to be applied to rPC to 21840 * "complete" the interpretation of backwards branches. In effect, we 21841 * are completing the interpretation of the branch instruction here, 21842 * and the new interpreter will resume interpretation at the branch 21843 * target. However, a switch request recognized during the handling 21844 * of a return from method instruction results in an immediate abort, 21845 * and the new interpreter will resume by re-interpreting the return 21846 * instruction. 21847 */ 218483: 21849 leal (rPC,%ebx,2),rPC # adjust pc to show target 21850 movl rSELF,%ecx # bail expect SELF already loaded 21851 movl $1,rINST # set changeInterp to true 21852 jmp common_gotoBail 21853 21854 21855/* 21856 * Common code for handling a return instruction 21857 */ 21858common_returnFromMethod: 21859 movl rSELF,%ecx 21860 /* Set entry mode in case we bail */ 21861 movb $kInterpEntryReturn,offThread_entryPoint(%ecx) 21862 xorl rINST,rINST # zero offset in case we switch interps 21863 call common_periodicChecks # Note: expects %ecx to be preserved 21864 21865 SAVEAREA_FROM_FP %eax # eax<- saveArea (old) 21866 movl offStackSaveArea_prevFrame(%eax),rFP # rFP<- prevFrame 21867 movl (offStackSaveArea_method-sizeofStackSaveArea)(rFP),rINST 21868 cmpl $0,rINST # break? 21869 je common_gotoBail # break frame, bail out completely 21870 21871 movl offStackSaveArea_savedPc(%eax),rPC # pc<- saveArea->savedPC 21872 movl rINST,offThread_method(%ecx) # self->method = newSave->meethod 21873 movl rFP,offThread_curFrame(%ecx) # self->curFrame = fp 21874 movl offMethod_clazz(rINST),%eax # eax<- method->clazz 21875 movl offThread_curHandlerTable(%ecx),rIBASE 21876 movl offClassObject_pDvmDex(%eax),rINST # rINST<- method->clazz->pDvmDex 21877 FETCH_INST_OPCODE 3 %eax 21878 movl rINST,offThread_methodClassDex(%ecx) 21879 ADVANCE_PC 3 21880 /* not bailing - restore entry mode to default */ 21881 movb $kInterpEntryInstr,offThread_entryPoint(%ecx) 21882 GOTO_NEXT_R %eax 21883 21884/* 21885 * Prepare to strip the current frame and "longjump" back to caller of 21886 * dvmMterpStdRun. 21887 * 21888 * on entry: 21889 * rINST holds changeInterp 21890 * ecx holds self pointer 21891 * 21892 * expected profile: dvmMterpStdBail(Thread *self, bool changeInterp) 21893 */ 21894common_gotoBail: 21895 movl rPC,offThread_pc(%ecx) # export state to self 21896 movl rFP,offThread_fp(%ecx) 21897 movl %ecx,OUT_ARG0(%esp) # self in arg0 21898 movl rINST,OUT_ARG1(%esp) # changeInterp in arg1 21899 call dvmMterpStdBail # bail out.... 21900 21901 21902/* 21903 * After returning from a "selfd" function, pull out the updated values 21904 * and start executing at the next instruction. 21905 */ 21906 common_resumeAfterGlueCall: 21907 movl rSELF, %eax 21908 movl offThread_pc(%eax),rPC 21909 movl offThread_fp(%eax),rFP 21910 movl offThread_curHandlerTable(%eax),rIBASE 21911 FETCH_INST 21912 GOTO_NEXT 21913 21914/* 21915 * Integer divide or mod by zero 21916 */ 21917common_errDivideByZero: 21918 EXPORT_PC 21919 movl $.LstrArithmeticException,%eax 21920 movl %eax,OUT_ARG0(%esp) 21921 movl $.LstrDivideByZero,%eax 21922 movl %eax,OUT_ARG1(%esp) 21923 call dvmThrowException 21924 jmp common_exceptionThrown 21925 21926/* 21927 * Attempt to allocate an array with a negative size. 21928 * On entry, len in eax 21929 */ 21930common_errNegativeArraySize: 21931 EXPORT_PC 21932 movl %eax,OUT_ARG0(%esp) # arg0<- len 21933 call dvmThrowNegativeArraySizeException # (len) 21934 jmp common_exceptionThrown 21935 21936/* 21937 * Attempt to allocate an array with a negative size. 21938 */ 21939common_errNoSuchMethod: 21940 21941 EXPORT_PC 21942 movl $.LstrNoSuchMethodError,%eax 21943 movl %eax,OUT_ARG0(%esp) 21944 xorl %eax,%eax 21945 movl %eax,OUT_ARG1(%esp) 21946 call dvmThrowException 21947 jmp common_exceptionThrown 21948 21949/* 21950 * Hit a null object when we weren't expecting one. Export the PC, throw a 21951 * NullPointerException and goto the exception processing code. 21952 */ 21953common_errNullObject: 21954 EXPORT_PC 21955 movl $.LstrNullPointerException,%eax 21956 movl %eax,OUT_ARG0(%esp) 21957 xorl %eax,%eax 21958 movl %eax,OUT_ARG1(%esp) 21959 call dvmThrowException 21960 jmp common_exceptionThrown 21961 21962/* 21963 * Array index exceeds max. 21964 * On entry: 21965 * eax <- array object 21966 * ecx <- index 21967 */ 21968common_errArrayIndex: 21969 EXPORT_PC 21970 movl offArrayObject_length(%eax), %eax 21971 movl %ecx,OUT_ARG0(%esp) 21972 movl %eax,OUT_ARG1(%esp) 21973 call dvmThrowArrayIndexOutOfBoundsException # args (index, length) 21974 jmp common_exceptionThrown 21975 21976/* 21977 * Somebody has thrown an exception. Handle it. 21978 * 21979 * If the exception processing code returns to us (instead of falling 21980 * out of the interpreter), continue with whatever the next instruction 21981 * now happens to be. 21982 * 21983 * This does not return. 21984 */ 21985common_exceptionThrown: 21986 movl rSELF,%ecx 21987 movl rPC,offThread_pc(%ecx) 21988 movl rFP,offThread_fp(%ecx) 21989 movl %ecx,OUT_ARG0(%esp) 21990 call dvmMterp_exceptionThrown 21991 jmp common_resumeAfterGlueCall 21992 21993common_abort: 21994 movl $0xdeadf00d,%eax 21995 call *%eax 21996 21997 21998/* 21999 * Strings 22000 */ 22001 22002 .section .rodata 22003.LstrNullPointerException: 22004 .asciz "Ljava/lang/NullPointerException;" 22005.LstrArithmeticException: 22006 .asciz "Ljava/lang/ArithmeticException;" 22007.LstrDivideByZero: 22008 .asciz "divide by zero" 22009.LstrInstantiationError: 22010 .asciz "Ljava/lang/InstantiationError;" 22011.LstrNoSuchMethodError: 22012 .asciz "Ljava/lang/NoSuchMethodError;" 22013.LstrInternalErrorA: 22014 .asciz "Ljava/lang/InternalError;" 22015.LstrFilledNewArrayNotImplA: 22016 .asciz "filled-new-array only implemented for 'int'" 22017 22018