1 /* 2 * This file was generated automatically by gen-mterp.py for 'portable'. 3 * 4 * --> DO NOT EDIT <-- 5 */ 6 7 /* File: c/header.cpp */ 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 /* common includes */ 25 #include "Dalvik.h" 26 #include "interp/InterpDefs.h" 27 #include "mterp/Mterp.h" 28 #include <math.h> // needed for fmod, fmodf 29 #include "mterp/common/FindInterface.h" 30 31 /* 32 * Configuration defines. These affect the C implementations, i.e. the 33 * portable interpreter(s) and C stubs. 34 * 35 * Some defines are controlled by the Makefile, e.g.: 36 * WITH_INSTR_CHECKS 37 * WITH_TRACKREF_CHECKS 38 * EASY_GDB 39 * NDEBUG 40 */ 41 42 #ifdef WITH_INSTR_CHECKS /* instruction-level paranoia (slow!) */ 43 # define CHECK_BRANCH_OFFSETS 44 # define CHECK_REGISTER_INDICES 45 #endif 46 47 /* 48 * Some architectures require 64-bit alignment for access to 64-bit data 49 * types. We can't just use pointers to copy 64-bit values out of our 50 * interpreted register set, because gcc may assume the pointer target is 51 * aligned and generate invalid code. 52 * 53 * There are two common approaches: 54 * (1) Use a union that defines a 32-bit pair and a 64-bit value. 55 * (2) Call memcpy(). 56 * 57 * Depending upon what compiler you're using and what options are specified, 58 * one may be faster than the other. For example, the compiler might 59 * convert a memcpy() of 8 bytes into a series of instructions and omit 60 * the call. The union version could cause some strange side-effects, 61 * e.g. for a while ARM gcc thought it needed separate storage for each 62 * inlined instance, and generated instructions to zero out ~700 bytes of 63 * stack space at the top of the interpreter. 64 * 65 * The default is to use memcpy(). The current gcc for ARM seems to do 66 * better with the union. 67 */ 68 #if defined(__ARM_EABI__) 69 # define NO_UNALIGN_64__UNION 70 #endif 71 /* 72 * MIPS ABI requires 64-bit alignment for access to 64-bit data types. 73 * 74 * Use memcpy() to do the transfer 75 */ 76 #if defined(__mips__) 77 /* # define NO_UNALIGN_64__UNION */ 78 #endif 79 80 81 //#define LOG_INSTR /* verbose debugging */ 82 /* set and adjust ANDROID_LOG_TAGS='*:i jdwp:i dalvikvm:i dalvikvmi:i' */ 83 84 /* 85 * Export another copy of the PC on every instruction; this is largely 86 * redundant with EXPORT_PC and the debugger code. This value can be 87 * compared against what we have stored on the stack with EXPORT_PC to 88 * help ensure that we aren't missing any export calls. 89 */ 90 #if WITH_EXTRA_GC_CHECKS > 1 91 # define EXPORT_EXTRA_PC() (self->currentPc2 = pc) 92 #else 93 # define EXPORT_EXTRA_PC() 94 #endif 95 96 /* 97 * Adjust the program counter. "_offset" is a signed int, in 16-bit units. 98 * 99 * Assumes the existence of "const u2* pc" and "const u2* curMethod->insns". 100 * 101 * We don't advance the program counter until we finish an instruction or 102 * branch, because we do want to have to unroll the PC if there's an 103 * exception. 104 */ 105 #ifdef CHECK_BRANCH_OFFSETS 106 # define ADJUST_PC(_offset) do { \ 107 int myoff = _offset; /* deref only once */ \ 108 if (pc + myoff < curMethod->insns || \ 109 pc + myoff >= curMethod->insns + dvmGetMethodInsnsSize(curMethod)) \ 110 { \ 111 char* desc; \ 112 desc = dexProtoCopyMethodDescriptor(&curMethod->prototype); \ 113 ALOGE("Invalid branch %d at 0x%04x in %s.%s %s", \ 114 myoff, (int) (pc - curMethod->insns), \ 115 curMethod->clazz->descriptor, curMethod->name, desc); \ 116 free(desc); \ 117 dvmAbort(); \ 118 } \ 119 pc += myoff; \ 120 EXPORT_EXTRA_PC(); \ 121 } while (false) 122 #else 123 # define ADJUST_PC(_offset) do { \ 124 pc += _offset; \ 125 EXPORT_EXTRA_PC(); \ 126 } while (false) 127 #endif 128 129 /* 130 * If enabled, log instructions as we execute them. 131 */ 132 #ifdef LOG_INSTR 133 # define ILOGD(...) ILOG(LOG_DEBUG, __VA_ARGS__) 134 # define ILOGV(...) ILOG(LOG_VERBOSE, __VA_ARGS__) 135 # define ILOG(_level, ...) do { \ 136 char debugStrBuf[128]; \ 137 snprintf(debugStrBuf, sizeof(debugStrBuf), __VA_ARGS__); \ 138 if (curMethod != NULL) \ 139 ALOG(_level, LOG_TAG"i", "%-2d|%04x%s", \ 140 self->threadId, (int)(pc - curMethod->insns), debugStrBuf); \ 141 else \ 142 ALOG(_level, LOG_TAG"i", "%-2d|####%s", \ 143 self->threadId, debugStrBuf); \ 144 } while(false) 145 void dvmDumpRegs(const Method* method, const u4* framePtr, bool inOnly); 146 # define DUMP_REGS(_meth, _frame, _inOnly) dvmDumpRegs(_meth, _frame, _inOnly) 147 static const char kSpacing[] = " "; 148 #else 149 # define ILOGD(...) ((void)0) 150 # define ILOGV(...) ((void)0) 151 # define DUMP_REGS(_meth, _frame, _inOnly) ((void)0) 152 #endif 153 154 /* get a long from an array of u4 */ 155 static inline s8 getLongFromArray(const u4* ptr, int idx) 156 { 157 #if defined(NO_UNALIGN_64__UNION) 158 union { s8 ll; u4 parts[2]; } conv; 159 160 ptr += idx; 161 conv.parts[0] = ptr[0]; 162 conv.parts[1] = ptr[1]; 163 return conv.ll; 164 #else 165 s8 val; 166 memcpy(&val, &ptr[idx], 8); 167 return val; 168 #endif 169 } 170 171 /* store a long into an array of u4 */ 172 static inline void putLongToArray(u4* ptr, int idx, s8 val) 173 { 174 #if defined(NO_UNALIGN_64__UNION) 175 union { s8 ll; u4 parts[2]; } conv; 176 177 ptr += idx; 178 conv.ll = val; 179 ptr[0] = conv.parts[0]; 180 ptr[1] = conv.parts[1]; 181 #else 182 memcpy(&ptr[idx], &val, 8); 183 #endif 184 } 185 186 /* get a double from an array of u4 */ 187 static inline double getDoubleFromArray(const u4* ptr, int idx) 188 { 189 #if defined(NO_UNALIGN_64__UNION) 190 union { double d; u4 parts[2]; } conv; 191 192 ptr += idx; 193 conv.parts[0] = ptr[0]; 194 conv.parts[1] = ptr[1]; 195 return conv.d; 196 #else 197 double dval; 198 memcpy(&dval, &ptr[idx], 8); 199 return dval; 200 #endif 201 } 202 203 /* store a double into an array of u4 */ 204 static inline void putDoubleToArray(u4* ptr, int idx, double dval) 205 { 206 #if defined(NO_UNALIGN_64__UNION) 207 union { double d; u4 parts[2]; } conv; 208 209 ptr += idx; 210 conv.d = dval; 211 ptr[0] = conv.parts[0]; 212 ptr[1] = conv.parts[1]; 213 #else 214 memcpy(&ptr[idx], &dval, 8); 215 #endif 216 } 217 218 /* 219 * If enabled, validate the register number on every access. Otherwise, 220 * just do an array access. 221 * 222 * Assumes the existence of "u4* fp". 223 * 224 * "_idx" may be referenced more than once. 225 */ 226 #ifdef CHECK_REGISTER_INDICES 227 # define GET_REGISTER(_idx) \ 228 ( (_idx) < curMethod->registersSize ? \ 229 (fp[(_idx)]) : (assert(!"bad reg"),1969) ) 230 # define SET_REGISTER(_idx, _val) \ 231 ( (_idx) < curMethod->registersSize ? \ 232 (fp[(_idx)] = (u4)(_val)) : (assert(!"bad reg"),1969) ) 233 # define GET_REGISTER_AS_OBJECT(_idx) ((Object *)GET_REGISTER(_idx)) 234 # define SET_REGISTER_AS_OBJECT(_idx, _val) SET_REGISTER(_idx, (s4)_val) 235 # define GET_REGISTER_INT(_idx) ((s4) GET_REGISTER(_idx)) 236 # define SET_REGISTER_INT(_idx, _val) SET_REGISTER(_idx, (s4)_val) 237 # define GET_REGISTER_WIDE(_idx) \ 238 ( (_idx) < curMethod->registersSize-1 ? \ 239 getLongFromArray(fp, (_idx)) : (assert(!"bad reg"),1969) ) 240 # define SET_REGISTER_WIDE(_idx, _val) \ 241 ( (_idx) < curMethod->registersSize-1 ? \ 242 (void)putLongToArray(fp, (_idx), (_val)) : assert(!"bad reg") ) 243 # define GET_REGISTER_FLOAT(_idx) \ 244 ( (_idx) < curMethod->registersSize ? \ 245 (*((float*) &fp[(_idx)])) : (assert(!"bad reg"),1969.0f) ) 246 # define SET_REGISTER_FLOAT(_idx, _val) \ 247 ( (_idx) < curMethod->registersSize ? \ 248 (*((float*) &fp[(_idx)]) = (_val)) : (assert(!"bad reg"),1969.0f) ) 249 # define GET_REGISTER_DOUBLE(_idx) \ 250 ( (_idx) < curMethod->registersSize-1 ? \ 251 getDoubleFromArray(fp, (_idx)) : (assert(!"bad reg"),1969.0) ) 252 # define SET_REGISTER_DOUBLE(_idx, _val) \ 253 ( (_idx) < curMethod->registersSize-1 ? \ 254 (void)putDoubleToArray(fp, (_idx), (_val)) : assert(!"bad reg") ) 255 #else 256 # define GET_REGISTER(_idx) (fp[(_idx)]) 257 # define SET_REGISTER(_idx, _val) (fp[(_idx)] = (_val)) 258 # define GET_REGISTER_AS_OBJECT(_idx) ((Object*) fp[(_idx)]) 259 # define SET_REGISTER_AS_OBJECT(_idx, _val) (fp[(_idx)] = (u4)(_val)) 260 # define GET_REGISTER_INT(_idx) ((s4)GET_REGISTER(_idx)) 261 # define SET_REGISTER_INT(_idx, _val) SET_REGISTER(_idx, (s4)_val) 262 # define GET_REGISTER_WIDE(_idx) getLongFromArray(fp, (_idx)) 263 # define SET_REGISTER_WIDE(_idx, _val) putLongToArray(fp, (_idx), (_val)) 264 # define GET_REGISTER_FLOAT(_idx) (*((float*) &fp[(_idx)])) 265 # define SET_REGISTER_FLOAT(_idx, _val) (*((float*) &fp[(_idx)]) = (_val)) 266 # define GET_REGISTER_DOUBLE(_idx) getDoubleFromArray(fp, (_idx)) 267 # define SET_REGISTER_DOUBLE(_idx, _val) putDoubleToArray(fp, (_idx), (_val)) 268 #endif 269 270 /* 271 * Get 16 bits from the specified offset of the program counter. We always 272 * want to load 16 bits at a time from the instruction stream -- it's more 273 * efficient than 8 and won't have the alignment problems that 32 might. 274 * 275 * Assumes existence of "const u2* pc". 276 */ 277 #define FETCH(_offset) (pc[(_offset)]) 278 279 /* 280 * Extract instruction byte from 16-bit fetch (_inst is a u2). 281 */ 282 #define INST_INST(_inst) ((_inst) & 0xff) 283 284 /* 285 * Replace the opcode (used when handling breakpoints). _opcode is a u1. 286 */ 287 #define INST_REPLACE_OP(_inst, _opcode) (((_inst) & 0xff00) | _opcode) 288 289 /* 290 * Extract the "vA, vB" 4-bit registers from the instruction word (_inst is u2). 291 */ 292 #define INST_A(_inst) (((_inst) >> 8) & 0x0f) 293 #define INST_B(_inst) ((_inst) >> 12) 294 295 /* 296 * Get the 8-bit "vAA" 8-bit register index from the instruction word. 297 * (_inst is u2) 298 */ 299 #define INST_AA(_inst) ((_inst) >> 8) 300 301 /* 302 * The current PC must be available to Throwable constructors, e.g. 303 * those created by the various exception throw routines, so that the 304 * exception stack trace can be generated correctly. If we don't do this, 305 * the offset within the current method won't be shown correctly. See the 306 * notes in Exception.c. 307 * 308 * This is also used to determine the address for precise GC. 309 * 310 * Assumes existence of "u4* fp" and "const u2* pc". 311 */ 312 #define EXPORT_PC() (SAVEAREA_FROM_FP(fp)->xtra.currentPc = pc) 313 314 /* 315 * Check to see if "obj" is NULL. If so, throw an exception. Assumes the 316 * pc has already been exported to the stack. 317 * 318 * Perform additional checks on debug builds. 319 * 320 * Use this to check for NULL when the instruction handler calls into 321 * something that could throw an exception (so we have already called 322 * EXPORT_PC at the top). 323 */ 324 static inline bool checkForNull(Object* obj) 325 { 326 if (obj == NULL) { 327 dvmThrowNullPointerException(NULL); 328 return false; 329 } 330 #ifdef WITH_EXTRA_OBJECT_VALIDATION 331 if (!dvmIsHeapAddress(obj)) { 332 ALOGE("Invalid object %p", obj); 333 dvmAbort(); 334 } 335 #endif 336 #ifndef NDEBUG 337 if (obj->clazz == NULL || ((u4) obj->clazz) <= 65536) { 338 /* probable heap corruption */ 339 ALOGE("Invalid object class %p (in %p)", obj->clazz, obj); 340 dvmAbort(); 341 } 342 #endif 343 return true; 344 } 345 346 /* 347 * Check to see if "obj" is NULL. If so, export the PC into the stack 348 * frame and throw an exception. 349 * 350 * Perform additional checks on debug builds. 351 * 352 * Use this to check for NULL when the instruction handler doesn't do 353 * anything else that can throw an exception. 354 */ 355 static inline bool checkForNullExportPC(Object* obj, u4* fp, const u2* pc) 356 { 357 if (obj == NULL) { 358 EXPORT_PC(); 359 dvmThrowNullPointerException(NULL); 360 return false; 361 } 362 #ifdef WITH_EXTRA_OBJECT_VALIDATION 363 if (!dvmIsHeapAddress(obj)) { 364 ALOGE("Invalid object %p", obj); 365 dvmAbort(); 366 } 367 #endif 368 #ifndef NDEBUG 369 if (obj->clazz == NULL || ((u4) obj->clazz) <= 65536) { 370 /* probable heap corruption */ 371 ALOGE("Invalid object class %p (in %p)", obj->clazz, obj); 372 dvmAbort(); 373 } 374 #endif 375 return true; 376 } 377 378 /* File: portable/stubdefs.cpp */ 379 /* 380 * In the C mterp stubs, "goto" is a function call followed immediately 381 * by a return. 382 */ 383 384 #define GOTO_TARGET_DECL(_target, ...) 385 386 #define GOTO_TARGET(_target, ...) _target: 387 388 #define GOTO_TARGET_END 389 390 /* ugh */ 391 #define STUB_HACK(x) 392 #define JIT_STUB_HACK(x) 393 394 /* 395 * InterpSave's pc and fp must be valid when breaking out to a 396 * "Reportxxx" routine. Because the portable interpreter uses local 397 * variables for these, we must flush prior. Stubs, however, use 398 * the interpSave vars directly, so this is a nop for stubs. 399 */ 400 #define PC_FP_TO_SELF() \ 401 self->interpSave.pc = pc; \ 402 self->interpSave.curFrame = fp; 403 #define PC_TO_SELF() self->interpSave.pc = pc; 404 405 /* 406 * Instruction framing. For a switch-oriented implementation this is 407 * case/break, for a threaded implementation it's a goto label and an 408 * instruction fetch/computed goto. 409 * 410 * Assumes the existence of "const u2* pc" and (for threaded operation) 411 * "u2 inst". 412 */ 413 # define H(_op) &&op_##_op 414 # define HANDLE_OPCODE(_op) op_##_op: 415 # define FINISH(_offset) { \ 416 ADJUST_PC(_offset); \ 417 inst = FETCH(0); \ 418 if (self->interpBreak.ctl.subMode) { \ 419 dvmCheckBefore(pc, fp, self); \ 420 } \ 421 goto *handlerTable[INST_INST(inst)]; \ 422 } 423 # define FINISH_BKPT(_opcode) { \ 424 goto *handlerTable[_opcode]; \ 425 } 426 427 #define OP_END 428 429 /* 430 * The "goto" targets just turn into goto statements. The "arguments" are 431 * passed through local variables. 432 */ 433 434 #define GOTO_exceptionThrown() goto exceptionThrown; 435 436 #define GOTO_returnFromMethod() goto returnFromMethod; 437 438 #define GOTO_invoke(_target, _methodCallRange) \ 439 do { \ 440 methodCallRange = _methodCallRange; \ 441 goto _target; \ 442 } while(false) 443 444 /* for this, the "args" are already in the locals */ 445 #define GOTO_invokeMethod(_methodCallRange, _methodToCall, _vsrc1, _vdst) goto invokeMethod; 446 447 #define GOTO_bail() goto bail; 448 449 /* 450 * Periodically check for thread suspension. 451 * 452 * While we're at it, see if a debugger has attached or the profiler has 453 * started. If so, switch to a different "goto" table. 454 */ 455 #define PERIODIC_CHECKS(_pcadj) { \ 456 if (dvmCheckSuspendQuick(self)) { \ 457 EXPORT_PC(); /* need for precise GC */ \ 458 dvmCheckSuspendPending(self); \ 459 } \ 460 } 461 462 /* File: c/opcommon.cpp */ 463 /* forward declarations of goto targets */ 464 GOTO_TARGET_DECL(filledNewArray, bool methodCallRange); 465 GOTO_TARGET_DECL(invokeVirtual, bool methodCallRange); 466 GOTO_TARGET_DECL(invokeSuper, bool methodCallRange); 467 GOTO_TARGET_DECL(invokeInterface, bool methodCallRange); 468 GOTO_TARGET_DECL(invokeDirect, bool methodCallRange); 469 GOTO_TARGET_DECL(invokeStatic, bool methodCallRange); 470 GOTO_TARGET_DECL(invokeVirtualQuick, bool methodCallRange); 471 GOTO_TARGET_DECL(invokeSuperQuick, bool methodCallRange); 472 GOTO_TARGET_DECL(invokeMethod, bool methodCallRange, const Method* methodToCall, 473 u2 count, u2 regs); 474 GOTO_TARGET_DECL(returnFromMethod); 475 GOTO_TARGET_DECL(exceptionThrown); 476 477 /* 478 * =========================================================================== 479 * 480 * What follows are opcode definitions shared between multiple opcodes with 481 * minor substitutions handled by the C pre-processor. These should probably 482 * use the mterp substitution mechanism instead, with the code here moved 483 * into common fragment files (like the asm "binop.S"), although it's hard 484 * to give up the C preprocessor in favor of the much simpler text subst. 485 * 486 * =========================================================================== 487 */ 488 489 #define HANDLE_NUMCONV(_opcode, _opname, _fromtype, _totype) \ 490 HANDLE_OPCODE(_opcode /*vA, vB*/) \ 491 vdst = INST_A(inst); \ 492 vsrc1 = INST_B(inst); \ 493 ILOGV("|%s v%d,v%d", (_opname), vdst, vsrc1); \ 494 SET_REGISTER##_totype(vdst, \ 495 GET_REGISTER##_fromtype(vsrc1)); \ 496 FINISH(1); 497 498 #define HANDLE_FLOAT_TO_INT(_opcode, _opname, _fromvtype, _fromrtype, \ 499 _tovtype, _tortype) \ 500 HANDLE_OPCODE(_opcode /*vA, vB*/) \ 501 { \ 502 /* spec defines specific handling for +/- inf and NaN values */ \ 503 _fromvtype val; \ 504 _tovtype intMin, intMax, result; \ 505 vdst = INST_A(inst); \ 506 vsrc1 = INST_B(inst); \ 507 ILOGV("|%s v%d,v%d", (_opname), vdst, vsrc1); \ 508 val = GET_REGISTER##_fromrtype(vsrc1); \ 509 intMin = (_tovtype) 1 << (sizeof(_tovtype) * 8 -1); \ 510 intMax = ~intMin; \ 511 result = (_tovtype) val; \ 512 if (val >= intMax) /* +inf */ \ 513 result = intMax; \ 514 else if (val <= intMin) /* -inf */ \ 515 result = intMin; \ 516 else if (val != val) /* NaN */ \ 517 result = 0; \ 518 else \ 519 result = (_tovtype) val; \ 520 SET_REGISTER##_tortype(vdst, result); \ 521 } \ 522 FINISH(1); 523 524 #define HANDLE_INT_TO_SMALL(_opcode, _opname, _type) \ 525 HANDLE_OPCODE(_opcode /*vA, vB*/) \ 526 vdst = INST_A(inst); \ 527 vsrc1 = INST_B(inst); \ 528 ILOGV("|int-to-%s v%d,v%d", (_opname), vdst, vsrc1); \ 529 SET_REGISTER(vdst, (_type) GET_REGISTER(vsrc1)); \ 530 FINISH(1); 531 532 /* NOTE: the comparison result is always a signed 4-byte integer */ 533 #define HANDLE_OP_CMPX(_opcode, _opname, _varType, _type, _nanVal) \ 534 HANDLE_OPCODE(_opcode /*vAA, vBB, vCC*/) \ 535 { \ 536 int result; \ 537 u2 regs; \ 538 _varType val1, val2; \ 539 vdst = INST_AA(inst); \ 540 regs = FETCH(1); \ 541 vsrc1 = regs & 0xff; \ 542 vsrc2 = regs >> 8; \ 543 ILOGV("|cmp%s v%d,v%d,v%d", (_opname), vdst, vsrc1, vsrc2); \ 544 val1 = GET_REGISTER##_type(vsrc1); \ 545 val2 = GET_REGISTER##_type(vsrc2); \ 546 if (val1 == val2) \ 547 result = 0; \ 548 else if (val1 < val2) \ 549 result = -1; \ 550 else if (val1 > val2) \ 551 result = 1; \ 552 else \ 553 result = (_nanVal); \ 554 ILOGV("+ result=%d", result); \ 555 SET_REGISTER(vdst, result); \ 556 } \ 557 FINISH(2); 558 559 #define HANDLE_OP_IF_XX(_opcode, _opname, _cmp) \ 560 HANDLE_OPCODE(_opcode /*vA, vB, +CCCC*/) \ 561 vsrc1 = INST_A(inst); \ 562 vsrc2 = INST_B(inst); \ 563 if ((s4) GET_REGISTER(vsrc1) _cmp (s4) GET_REGISTER(vsrc2)) { \ 564 int branchOffset = (s2)FETCH(1); /* sign-extended */ \ 565 ILOGV("|if-%s v%d,v%d,+0x%04x", (_opname), vsrc1, vsrc2, \ 566 branchOffset); \ 567 ILOGV("> branch taken"); \ 568 if (branchOffset < 0) \ 569 PERIODIC_CHECKS(branchOffset); \ 570 FINISH(branchOffset); \ 571 } else { \ 572 ILOGV("|if-%s v%d,v%d,-", (_opname), vsrc1, vsrc2); \ 573 FINISH(2); \ 574 } 575 576 #define HANDLE_OP_IF_XXZ(_opcode, _opname, _cmp) \ 577 HANDLE_OPCODE(_opcode /*vAA, +BBBB*/) \ 578 vsrc1 = INST_AA(inst); \ 579 if ((s4) GET_REGISTER(vsrc1) _cmp 0) { \ 580 int branchOffset = (s2)FETCH(1); /* sign-extended */ \ 581 ILOGV("|if-%s v%d,+0x%04x", (_opname), vsrc1, branchOffset); \ 582 ILOGV("> branch taken"); \ 583 if (branchOffset < 0) \ 584 PERIODIC_CHECKS(branchOffset); \ 585 FINISH(branchOffset); \ 586 } else { \ 587 ILOGV("|if-%s v%d,-", (_opname), vsrc1); \ 588 FINISH(2); \ 589 } 590 591 #define HANDLE_UNOP(_opcode, _opname, _pfx, _sfx, _type) \ 592 HANDLE_OPCODE(_opcode /*vA, vB*/) \ 593 vdst = INST_A(inst); \ 594 vsrc1 = INST_B(inst); \ 595 ILOGV("|%s v%d,v%d", (_opname), vdst, vsrc1); \ 596 SET_REGISTER##_type(vdst, _pfx GET_REGISTER##_type(vsrc1) _sfx); \ 597 FINISH(1); 598 599 #define HANDLE_OP_X_INT(_opcode, _opname, _op, _chkdiv) \ 600 HANDLE_OPCODE(_opcode /*vAA, vBB, vCC*/) \ 601 { \ 602 u2 srcRegs; \ 603 vdst = INST_AA(inst); \ 604 srcRegs = FETCH(1); \ 605 vsrc1 = srcRegs & 0xff; \ 606 vsrc2 = srcRegs >> 8; \ 607 ILOGV("|%s-int v%d,v%d", (_opname), vdst, vsrc1); \ 608 if (_chkdiv != 0) { \ 609 s4 firstVal, secondVal, result; \ 610 firstVal = GET_REGISTER(vsrc1); \ 611 secondVal = GET_REGISTER(vsrc2); \ 612 if (secondVal == 0) { \ 613 EXPORT_PC(); \ 614 dvmThrowArithmeticException("divide by zero"); \ 615 GOTO_exceptionThrown(); \ 616 } \ 617 if ((u4)firstVal == 0x80000000 && secondVal == -1) { \ 618 if (_chkdiv == 1) \ 619 result = firstVal; /* division */ \ 620 else \ 621 result = 0; /* remainder */ \ 622 } else { \ 623 result = firstVal _op secondVal; \ 624 } \ 625 SET_REGISTER(vdst, result); \ 626 } else { \ 627 /* non-div/rem case */ \ 628 SET_REGISTER(vdst, \ 629 (s4) GET_REGISTER(vsrc1) _op (s4) GET_REGISTER(vsrc2)); \ 630 } \ 631 } \ 632 FINISH(2); 633 634 #define HANDLE_OP_SHX_INT(_opcode, _opname, _cast, _op) \ 635 HANDLE_OPCODE(_opcode /*vAA, vBB, vCC*/) \ 636 { \ 637 u2 srcRegs; \ 638 vdst = INST_AA(inst); \ 639 srcRegs = FETCH(1); \ 640 vsrc1 = srcRegs & 0xff; \ 641 vsrc2 = srcRegs >> 8; \ 642 ILOGV("|%s-int v%d,v%d", (_opname), vdst, vsrc1); \ 643 SET_REGISTER(vdst, \ 644 _cast GET_REGISTER(vsrc1) _op (GET_REGISTER(vsrc2) & 0x1f)); \ 645 } \ 646 FINISH(2); 647 648 #define HANDLE_OP_X_INT_LIT16(_opcode, _opname, _op, _chkdiv) \ 649 HANDLE_OPCODE(_opcode /*vA, vB, #+CCCC*/) \ 650 vdst = INST_A(inst); \ 651 vsrc1 = INST_B(inst); \ 652 vsrc2 = FETCH(1); \ 653 ILOGV("|%s-int/lit16 v%d,v%d,#+0x%04x", \ 654 (_opname), vdst, vsrc1, vsrc2); \ 655 if (_chkdiv != 0) { \ 656 s4 firstVal, result; \ 657 firstVal = GET_REGISTER(vsrc1); \ 658 if ((s2) vsrc2 == 0) { \ 659 EXPORT_PC(); \ 660 dvmThrowArithmeticException("divide by zero"); \ 661 GOTO_exceptionThrown(); \ 662 } \ 663 if ((u4)firstVal == 0x80000000 && ((s2) vsrc2) == -1) { \ 664 /* won't generate /lit16 instr for this; check anyway */ \ 665 if (_chkdiv == 1) \ 666 result = firstVal; /* division */ \ 667 else \ 668 result = 0; /* remainder */ \ 669 } else { \ 670 result = firstVal _op (s2) vsrc2; \ 671 } \ 672 SET_REGISTER(vdst, result); \ 673 } else { \ 674 /* non-div/rem case */ \ 675 SET_REGISTER(vdst, GET_REGISTER(vsrc1) _op (s2) vsrc2); \ 676 } \ 677 FINISH(2); 678 679 #define HANDLE_OP_X_INT_LIT8(_opcode, _opname, _op, _chkdiv) \ 680 HANDLE_OPCODE(_opcode /*vAA, vBB, #+CC*/) \ 681 { \ 682 u2 litInfo; \ 683 vdst = INST_AA(inst); \ 684 litInfo = FETCH(1); \ 685 vsrc1 = litInfo & 0xff; \ 686 vsrc2 = litInfo >> 8; /* constant */ \ 687 ILOGV("|%s-int/lit8 v%d,v%d,#+0x%02x", \ 688 (_opname), vdst, vsrc1, vsrc2); \ 689 if (_chkdiv != 0) { \ 690 s4 firstVal, result; \ 691 firstVal = GET_REGISTER(vsrc1); \ 692 if ((s1) vsrc2 == 0) { \ 693 EXPORT_PC(); \ 694 dvmThrowArithmeticException("divide by zero"); \ 695 GOTO_exceptionThrown(); \ 696 } \ 697 if ((u4)firstVal == 0x80000000 && ((s1) vsrc2) == -1) { \ 698 if (_chkdiv == 1) \ 699 result = firstVal; /* division */ \ 700 else \ 701 result = 0; /* remainder */ \ 702 } else { \ 703 result = firstVal _op ((s1) vsrc2); \ 704 } \ 705 SET_REGISTER(vdst, result); \ 706 } else { \ 707 SET_REGISTER(vdst, \ 708 (s4) GET_REGISTER(vsrc1) _op (s1) vsrc2); \ 709 } \ 710 } \ 711 FINISH(2); 712 713 #define HANDLE_OP_SHX_INT_LIT8(_opcode, _opname, _cast, _op) \ 714 HANDLE_OPCODE(_opcode /*vAA, vBB, #+CC*/) \ 715 { \ 716 u2 litInfo; \ 717 vdst = INST_AA(inst); \ 718 litInfo = FETCH(1); \ 719 vsrc1 = litInfo & 0xff; \ 720 vsrc2 = litInfo >> 8; /* constant */ \ 721 ILOGV("|%s-int/lit8 v%d,v%d,#+0x%02x", \ 722 (_opname), vdst, vsrc1, vsrc2); \ 723 SET_REGISTER(vdst, \ 724 _cast GET_REGISTER(vsrc1) _op (vsrc2 & 0x1f)); \ 725 } \ 726 FINISH(2); 727 728 #define HANDLE_OP_X_INT_2ADDR(_opcode, _opname, _op, _chkdiv) \ 729 HANDLE_OPCODE(_opcode /*vA, vB*/) \ 730 vdst = INST_A(inst); \ 731 vsrc1 = INST_B(inst); \ 732 ILOGV("|%s-int-2addr v%d,v%d", (_opname), vdst, vsrc1); \ 733 if (_chkdiv != 0) { \ 734 s4 firstVal, secondVal, result; \ 735 firstVal = GET_REGISTER(vdst); \ 736 secondVal = GET_REGISTER(vsrc1); \ 737 if (secondVal == 0) { \ 738 EXPORT_PC(); \ 739 dvmThrowArithmeticException("divide by zero"); \ 740 GOTO_exceptionThrown(); \ 741 } \ 742 if ((u4)firstVal == 0x80000000 && secondVal == -1) { \ 743 if (_chkdiv == 1) \ 744 result = firstVal; /* division */ \ 745 else \ 746 result = 0; /* remainder */ \ 747 } else { \ 748 result = firstVal _op secondVal; \ 749 } \ 750 SET_REGISTER(vdst, result); \ 751 } else { \ 752 SET_REGISTER(vdst, \ 753 (s4) GET_REGISTER(vdst) _op (s4) GET_REGISTER(vsrc1)); \ 754 } \ 755 FINISH(1); 756 757 #define HANDLE_OP_SHX_INT_2ADDR(_opcode, _opname, _cast, _op) \ 758 HANDLE_OPCODE(_opcode /*vA, vB*/) \ 759 vdst = INST_A(inst); \ 760 vsrc1 = INST_B(inst); \ 761 ILOGV("|%s-int-2addr v%d,v%d", (_opname), vdst, vsrc1); \ 762 SET_REGISTER(vdst, \ 763 _cast GET_REGISTER(vdst) _op (GET_REGISTER(vsrc1) & 0x1f)); \ 764 FINISH(1); 765 766 #define HANDLE_OP_X_LONG(_opcode, _opname, _op, _chkdiv) \ 767 HANDLE_OPCODE(_opcode /*vAA, vBB, vCC*/) \ 768 { \ 769 u2 srcRegs; \ 770 vdst = INST_AA(inst); \ 771 srcRegs = FETCH(1); \ 772 vsrc1 = srcRegs & 0xff; \ 773 vsrc2 = srcRegs >> 8; \ 774 ILOGV("|%s-long v%d,v%d,v%d", (_opname), vdst, vsrc1, vsrc2); \ 775 if (_chkdiv != 0) { \ 776 s8 firstVal, secondVal, result; \ 777 firstVal = GET_REGISTER_WIDE(vsrc1); \ 778 secondVal = GET_REGISTER_WIDE(vsrc2); \ 779 if (secondVal == 0LL) { \ 780 EXPORT_PC(); \ 781 dvmThrowArithmeticException("divide by zero"); \ 782 GOTO_exceptionThrown(); \ 783 } \ 784 if ((u8)firstVal == 0x8000000000000000ULL && \ 785 secondVal == -1LL) \ 786 { \ 787 if (_chkdiv == 1) \ 788 result = firstVal; /* division */ \ 789 else \ 790 result = 0; /* remainder */ \ 791 } else { \ 792 result = firstVal _op secondVal; \ 793 } \ 794 SET_REGISTER_WIDE(vdst, result); \ 795 } else { \ 796 SET_REGISTER_WIDE(vdst, \ 797 (s8) GET_REGISTER_WIDE(vsrc1) _op (s8) GET_REGISTER_WIDE(vsrc2)); \ 798 } \ 799 } \ 800 FINISH(2); 801 802 #define HANDLE_OP_SHX_LONG(_opcode, _opname, _cast, _op) \ 803 HANDLE_OPCODE(_opcode /*vAA, vBB, vCC*/) \ 804 { \ 805 u2 srcRegs; \ 806 vdst = INST_AA(inst); \ 807 srcRegs = FETCH(1); \ 808 vsrc1 = srcRegs & 0xff; \ 809 vsrc2 = srcRegs >> 8; \ 810 ILOGV("|%s-long v%d,v%d,v%d", (_opname), vdst, vsrc1, vsrc2); \ 811 SET_REGISTER_WIDE(vdst, \ 812 _cast GET_REGISTER_WIDE(vsrc1) _op (GET_REGISTER(vsrc2) & 0x3f)); \ 813 } \ 814 FINISH(2); 815 816 #define HANDLE_OP_X_LONG_2ADDR(_opcode, _opname, _op, _chkdiv) \ 817 HANDLE_OPCODE(_opcode /*vA, vB*/) \ 818 vdst = INST_A(inst); \ 819 vsrc1 = INST_B(inst); \ 820 ILOGV("|%s-long-2addr v%d,v%d", (_opname), vdst, vsrc1); \ 821 if (_chkdiv != 0) { \ 822 s8 firstVal, secondVal, result; \ 823 firstVal = GET_REGISTER_WIDE(vdst); \ 824 secondVal = GET_REGISTER_WIDE(vsrc1); \ 825 if (secondVal == 0LL) { \ 826 EXPORT_PC(); \ 827 dvmThrowArithmeticException("divide by zero"); \ 828 GOTO_exceptionThrown(); \ 829 } \ 830 if ((u8)firstVal == 0x8000000000000000ULL && \ 831 secondVal == -1LL) \ 832 { \ 833 if (_chkdiv == 1) \ 834 result = firstVal; /* division */ \ 835 else \ 836 result = 0; /* remainder */ \ 837 } else { \ 838 result = firstVal _op secondVal; \ 839 } \ 840 SET_REGISTER_WIDE(vdst, result); \ 841 } else { \ 842 SET_REGISTER_WIDE(vdst, \ 843 (s8) GET_REGISTER_WIDE(vdst) _op (s8)GET_REGISTER_WIDE(vsrc1));\ 844 } \ 845 FINISH(1); 846 847 #define HANDLE_OP_SHX_LONG_2ADDR(_opcode, _opname, _cast, _op) \ 848 HANDLE_OPCODE(_opcode /*vA, vB*/) \ 849 vdst = INST_A(inst); \ 850 vsrc1 = INST_B(inst); \ 851 ILOGV("|%s-long-2addr v%d,v%d", (_opname), vdst, vsrc1); \ 852 SET_REGISTER_WIDE(vdst, \ 853 _cast GET_REGISTER_WIDE(vdst) _op (GET_REGISTER(vsrc1) & 0x3f)); \ 854 FINISH(1); 855 856 #define HANDLE_OP_X_FLOAT(_opcode, _opname, _op) \ 857 HANDLE_OPCODE(_opcode /*vAA, vBB, vCC*/) \ 858 { \ 859 u2 srcRegs; \ 860 vdst = INST_AA(inst); \ 861 srcRegs = FETCH(1); \ 862 vsrc1 = srcRegs & 0xff; \ 863 vsrc2 = srcRegs >> 8; \ 864 ILOGV("|%s-float v%d,v%d,v%d", (_opname), vdst, vsrc1, vsrc2); \ 865 SET_REGISTER_FLOAT(vdst, \ 866 GET_REGISTER_FLOAT(vsrc1) _op GET_REGISTER_FLOAT(vsrc2)); \ 867 } \ 868 FINISH(2); 869 870 #define HANDLE_OP_X_DOUBLE(_opcode, _opname, _op) \ 871 HANDLE_OPCODE(_opcode /*vAA, vBB, vCC*/) \ 872 { \ 873 u2 srcRegs; \ 874 vdst = INST_AA(inst); \ 875 srcRegs = FETCH(1); \ 876 vsrc1 = srcRegs & 0xff; \ 877 vsrc2 = srcRegs >> 8; \ 878 ILOGV("|%s-double v%d,v%d,v%d", (_opname), vdst, vsrc1, vsrc2); \ 879 SET_REGISTER_DOUBLE(vdst, \ 880 GET_REGISTER_DOUBLE(vsrc1) _op GET_REGISTER_DOUBLE(vsrc2)); \ 881 } \ 882 FINISH(2); 883 884 #define HANDLE_OP_X_FLOAT_2ADDR(_opcode, _opname, _op) \ 885 HANDLE_OPCODE(_opcode /*vA, vB*/) \ 886 vdst = INST_A(inst); \ 887 vsrc1 = INST_B(inst); \ 888 ILOGV("|%s-float-2addr v%d,v%d", (_opname), vdst, vsrc1); \ 889 SET_REGISTER_FLOAT(vdst, \ 890 GET_REGISTER_FLOAT(vdst) _op GET_REGISTER_FLOAT(vsrc1)); \ 891 FINISH(1); 892 893 #define HANDLE_OP_X_DOUBLE_2ADDR(_opcode, _opname, _op) \ 894 HANDLE_OPCODE(_opcode /*vA, vB*/) \ 895 vdst = INST_A(inst); \ 896 vsrc1 = INST_B(inst); \ 897 ILOGV("|%s-double-2addr v%d,v%d", (_opname), vdst, vsrc1); \ 898 SET_REGISTER_DOUBLE(vdst, \ 899 GET_REGISTER_DOUBLE(vdst) _op GET_REGISTER_DOUBLE(vsrc1)); \ 900 FINISH(1); 901 902 #define HANDLE_OP_AGET(_opcode, _opname, _type, _regsize) \ 903 HANDLE_OPCODE(_opcode /*vAA, vBB, vCC*/) \ 904 { \ 905 ArrayObject* arrayObj; \ 906 u2 arrayInfo; \ 907 EXPORT_PC(); \ 908 vdst = INST_AA(inst); \ 909 arrayInfo = FETCH(1); \ 910 vsrc1 = arrayInfo & 0xff; /* array ptr */ \ 911 vsrc2 = arrayInfo >> 8; /* index */ \ 912 ILOGV("|aget%s v%d,v%d,v%d", (_opname), vdst, vsrc1, vsrc2); \ 913 arrayObj = (ArrayObject*) GET_REGISTER(vsrc1); \ 914 if (!checkForNull((Object*) arrayObj)) \ 915 GOTO_exceptionThrown(); \ 916 if (GET_REGISTER(vsrc2) >= arrayObj->length) { \ 917 dvmThrowArrayIndexOutOfBoundsException( \ 918 arrayObj->length, GET_REGISTER(vsrc2)); \ 919 GOTO_exceptionThrown(); \ 920 } \ 921 SET_REGISTER##_regsize(vdst, \ 922 ((_type*)(void*)arrayObj->contents)[GET_REGISTER(vsrc2)]); \ 923 ILOGV("+ AGET[%d]=%#x", GET_REGISTER(vsrc2), GET_REGISTER(vdst)); \ 924 } \ 925 FINISH(2); 926 927 #define HANDLE_OP_APUT(_opcode, _opname, _type, _regsize) \ 928 HANDLE_OPCODE(_opcode /*vAA, vBB, vCC*/) \ 929 { \ 930 ArrayObject* arrayObj; \ 931 u2 arrayInfo; \ 932 EXPORT_PC(); \ 933 vdst = INST_AA(inst); /* AA: source value */ \ 934 arrayInfo = FETCH(1); \ 935 vsrc1 = arrayInfo & 0xff; /* BB: array ptr */ \ 936 vsrc2 = arrayInfo >> 8; /* CC: index */ \ 937 ILOGV("|aput%s v%d,v%d,v%d", (_opname), vdst, vsrc1, vsrc2); \ 938 arrayObj = (ArrayObject*) GET_REGISTER(vsrc1); \ 939 if (!checkForNull((Object*) arrayObj)) \ 940 GOTO_exceptionThrown(); \ 941 if (GET_REGISTER(vsrc2) >= arrayObj->length) { \ 942 dvmThrowArrayIndexOutOfBoundsException( \ 943 arrayObj->length, GET_REGISTER(vsrc2)); \ 944 GOTO_exceptionThrown(); \ 945 } \ 946 ILOGV("+ APUT[%d]=0x%08x", GET_REGISTER(vsrc2), GET_REGISTER(vdst));\ 947 ((_type*)(void*)arrayObj->contents)[GET_REGISTER(vsrc2)] = \ 948 GET_REGISTER##_regsize(vdst); \ 949 } \ 950 FINISH(2); 951 952 /* 953 * It's possible to get a bad value out of a field with sub-32-bit stores 954 * because the -quick versions always operate on 32 bits. Consider: 955 * short foo = -1 (sets a 32-bit register to 0xffffffff) 956 * iput-quick foo (writes all 32 bits to the field) 957 * short bar = 1 (sets a 32-bit register to 0x00000001) 958 * iput-short (writes the low 16 bits to the field) 959 * iget-quick foo (reads all 32 bits from the field, yielding 0xffff0001) 960 * This can only happen when optimized and non-optimized code has interleaved 961 * access to the same field. This is unlikely but possible. 962 * 963 * The easiest way to fix this is to always read/write 32 bits at a time. On 964 * a device with a 16-bit data bus this is sub-optimal. (The alternative 965 * approach is to have sub-int versions of iget-quick, but now we're wasting 966 * Dalvik instruction space and making it less likely that handler code will 967 * already be in the CPU i-cache.) 968 */ 969 #define HANDLE_IGET_X(_opcode, _opname, _ftype, _regsize) \ 970 HANDLE_OPCODE(_opcode /*vA, vB, field@CCCC*/) \ 971 { \ 972 InstField* ifield; \ 973 Object* obj; \ 974 EXPORT_PC(); \ 975 vdst = INST_A(inst); \ 976 vsrc1 = INST_B(inst); /* object ptr */ \ 977 ref = FETCH(1); /* field ref */ \ 978 ILOGV("|iget%s v%d,v%d,field@0x%04x", (_opname), vdst, vsrc1, ref); \ 979 obj = (Object*) GET_REGISTER(vsrc1); \ 980 if (!checkForNull(obj)) \ 981 GOTO_exceptionThrown(); \ 982 ifield = (InstField*) dvmDexGetResolvedField(methodClassDex, ref); \ 983 if (ifield == NULL) { \ 984 ifield = dvmResolveInstField(curMethod->clazz, ref); \ 985 if (ifield == NULL) \ 986 GOTO_exceptionThrown(); \ 987 } \ 988 SET_REGISTER##_regsize(vdst, \ 989 dvmGetField##_ftype(obj, ifield->byteOffset)); \ 990 ILOGV("+ IGET '%s'=0x%08llx", ifield->name, \ 991 (u8) GET_REGISTER##_regsize(vdst)); \ 992 } \ 993 FINISH(2); 994 995 #define HANDLE_IGET_X_QUICK(_opcode, _opname, _ftype, _regsize) \ 996 HANDLE_OPCODE(_opcode /*vA, vB, field@CCCC*/) \ 997 { \ 998 Object* obj; \ 999 vdst = INST_A(inst); \ 1000 vsrc1 = INST_B(inst); /* object ptr */ \ 1001 ref = FETCH(1); /* field offset */ \ 1002 ILOGV("|iget%s-quick v%d,v%d,field@+%u", \ 1003 (_opname), vdst, vsrc1, ref); \ 1004 obj = (Object*) GET_REGISTER(vsrc1); \ 1005 if (!checkForNullExportPC(obj, fp, pc)) \ 1006 GOTO_exceptionThrown(); \ 1007 SET_REGISTER##_regsize(vdst, dvmGetField##_ftype(obj, ref)); \ 1008 ILOGV("+ IGETQ %d=0x%08llx", ref, \ 1009 (u8) GET_REGISTER##_regsize(vdst)); \ 1010 } \ 1011 FINISH(2); 1012 1013 #define HANDLE_IPUT_X(_opcode, _opname, _ftype, _regsize) \ 1014 HANDLE_OPCODE(_opcode /*vA, vB, field@CCCC*/) \ 1015 { \ 1016 InstField* ifield; \ 1017 Object* obj; \ 1018 EXPORT_PC(); \ 1019 vdst = INST_A(inst); \ 1020 vsrc1 = INST_B(inst); /* object ptr */ \ 1021 ref = FETCH(1); /* field ref */ \ 1022 ILOGV("|iput%s v%d,v%d,field@0x%04x", (_opname), vdst, vsrc1, ref); \ 1023 obj = (Object*) GET_REGISTER(vsrc1); \ 1024 if (!checkForNull(obj)) \ 1025 GOTO_exceptionThrown(); \ 1026 ifield = (InstField*) dvmDexGetResolvedField(methodClassDex, ref); \ 1027 if (ifield == NULL) { \ 1028 ifield = dvmResolveInstField(curMethod->clazz, ref); \ 1029 if (ifield == NULL) \ 1030 GOTO_exceptionThrown(); \ 1031 } \ 1032 dvmSetField##_ftype(obj, ifield->byteOffset, \ 1033 GET_REGISTER##_regsize(vdst)); \ 1034 ILOGV("+ IPUT '%s'=0x%08llx", ifield->name, \ 1035 (u8) GET_REGISTER##_regsize(vdst)); \ 1036 } \ 1037 FINISH(2); 1038 1039 #define HANDLE_IPUT_X_QUICK(_opcode, _opname, _ftype, _regsize) \ 1040 HANDLE_OPCODE(_opcode /*vA, vB, field@CCCC*/) \ 1041 { \ 1042 Object* obj; \ 1043 vdst = INST_A(inst); \ 1044 vsrc1 = INST_B(inst); /* object ptr */ \ 1045 ref = FETCH(1); /* field offset */ \ 1046 ILOGV("|iput%s-quick v%d,v%d,field@0x%04x", \ 1047 (_opname), vdst, vsrc1, ref); \ 1048 obj = (Object*) GET_REGISTER(vsrc1); \ 1049 if (!checkForNullExportPC(obj, fp, pc)) \ 1050 GOTO_exceptionThrown(); \ 1051 dvmSetField##_ftype(obj, ref, GET_REGISTER##_regsize(vdst)); \ 1052 ILOGV("+ IPUTQ %d=0x%08llx", ref, \ 1053 (u8) GET_REGISTER##_regsize(vdst)); \ 1054 } \ 1055 FINISH(2); 1056 1057 /* 1058 * The JIT needs dvmDexGetResolvedField() to return non-null. 1059 * Because the portable interpreter is not involved with the JIT 1060 * and trace building, we only need the extra check here when this 1061 * code is massaged into a stub called from an assembly interpreter. 1062 * This is controlled by the JIT_STUB_HACK maco. 1063 */ 1064 1065 #define HANDLE_SGET_X(_opcode, _opname, _ftype, _regsize) \ 1066 HANDLE_OPCODE(_opcode /*vAA, field@BBBB*/) \ 1067 { \ 1068 StaticField* sfield; \ 1069 vdst = INST_AA(inst); \ 1070 ref = FETCH(1); /* field ref */ \ 1071 ILOGV("|sget%s v%d,sfield@0x%04x", (_opname), vdst, ref); \ 1072 sfield = (StaticField*)dvmDexGetResolvedField(methodClassDex, ref); \ 1073 if (sfield == NULL) { \ 1074 EXPORT_PC(); \ 1075 sfield = dvmResolveStaticField(curMethod->clazz, ref); \ 1076 if (sfield == NULL) \ 1077 GOTO_exceptionThrown(); \ 1078 if (dvmDexGetResolvedField(methodClassDex, ref) == NULL) { \ 1079 JIT_STUB_HACK(dvmJitEndTraceSelect(self,pc)); \ 1080 } \ 1081 } \ 1082 SET_REGISTER##_regsize(vdst, dvmGetStaticField##_ftype(sfield)); \ 1083 ILOGV("+ SGET '%s'=0x%08llx", \ 1084 sfield->name, (u8)GET_REGISTER##_regsize(vdst)); \ 1085 } \ 1086 FINISH(2); 1087 1088 #define HANDLE_SPUT_X(_opcode, _opname, _ftype, _regsize) \ 1089 HANDLE_OPCODE(_opcode /*vAA, field@BBBB*/) \ 1090 { \ 1091 StaticField* sfield; \ 1092 vdst = INST_AA(inst); \ 1093 ref = FETCH(1); /* field ref */ \ 1094 ILOGV("|sput%s v%d,sfield@0x%04x", (_opname), vdst, ref); \ 1095 sfield = (StaticField*)dvmDexGetResolvedField(methodClassDex, ref); \ 1096 if (sfield == NULL) { \ 1097 EXPORT_PC(); \ 1098 sfield = dvmResolveStaticField(curMethod->clazz, ref); \ 1099 if (sfield == NULL) \ 1100 GOTO_exceptionThrown(); \ 1101 if (dvmDexGetResolvedField(methodClassDex, ref) == NULL) { \ 1102 JIT_STUB_HACK(dvmJitEndTraceSelect(self,pc)); \ 1103 } \ 1104 } \ 1105 dvmSetStaticField##_ftype(sfield, GET_REGISTER##_regsize(vdst)); \ 1106 ILOGV("+ SPUT '%s'=0x%08llx", \ 1107 sfield->name, (u8)GET_REGISTER##_regsize(vdst)); \ 1108 } \ 1109 FINISH(2); 1110 1111 /* File: portable/entry.cpp */ 1112 /* 1113 * Main interpreter loop. 1114 * 1115 * This was written with an ARM implementation in mind. 1116 */ 1117 void dvmInterpretPortable(Thread* self) 1118 { 1119 #if defined(EASY_GDB) 1120 StackSaveArea* debugSaveArea = SAVEAREA_FROM_FP(self->interpSave.curFrame); 1121 #endif 1122 DvmDex* methodClassDex; // curMethod->clazz->pDvmDex 1123 JValue retval; 1124 1125 /* core state */ 1126 const Method* curMethod; // method we're interpreting 1127 const u2* pc; // program counter 1128 u4* fp; // frame pointer 1129 u2 inst; // current instruction 1130 /* instruction decoding */ 1131 u4 ref; // 16 or 32-bit quantity fetched directly 1132 u2 vsrc1, vsrc2, vdst; // usually used for register indexes 1133 /* method call setup */ 1134 const Method* methodToCall; 1135 bool methodCallRange; 1136 1137 /* static computed goto table */ 1138 DEFINE_GOTO_TABLE(handlerTable); 1139 1140 /* copy state in */ 1141 curMethod = self->interpSave.method; 1142 pc = self->interpSave.pc; 1143 fp = self->interpSave.curFrame; 1144 retval = self->interpSave.retval; /* only need for kInterpEntryReturn? */ 1145 1146 methodClassDex = curMethod->clazz->pDvmDex; 1147 1148 LOGVV("threadid=%d: %s.%s pc=%#x fp=%p", 1149 self->threadId, curMethod->clazz->descriptor, curMethod->name, 1150 pc - curMethod->insns, fp); 1151 1152 /* 1153 * Handle any ongoing profiling and prep for debugging. 1154 */ 1155 if (self->interpBreak.ctl.subMode != 0) { 1156 TRACE_METHOD_ENTER(self, curMethod); 1157 self->debugIsMethodEntry = true; // Always true on startup 1158 } 1159 /* 1160 * DEBUG: scramble this to ensure we're not relying on it. 1161 */ 1162 methodToCall = (const Method*) -1; 1163 1164 #if 0 1165 if (self->debugIsMethodEntry) { 1166 ILOGD("|-- Now interpreting %s.%s", curMethod->clazz->descriptor, 1167 curMethod->name); 1168 DUMP_REGS(curMethod, self->interpSave.curFrame, false); 1169 } 1170 #endif 1171 1172 FINISH(0); /* fetch and execute first instruction */ 1173 1174 /*--- start of opcodes ---*/ 1175 1176 /* File: c/OP_NOP.cpp */ 1177 HANDLE_OPCODE(OP_NOP) 1178 FINISH(1); 1179 OP_END 1180 1181 /* File: c/OP_MOVE.cpp */ 1182 HANDLE_OPCODE(OP_MOVE /*vA, vB*/) 1183 vdst = INST_A(inst); 1184 vsrc1 = INST_B(inst); 1185 ILOGV("|move%s v%d,v%d %s(v%d=0x%08x)", 1186 (INST_INST(inst) == OP_MOVE) ? "" : "-object", vdst, vsrc1, 1187 kSpacing, vdst, GET_REGISTER(vsrc1)); 1188 SET_REGISTER(vdst, GET_REGISTER(vsrc1)); 1189 FINISH(1); 1190 OP_END 1191 1192 /* File: c/OP_MOVE_FROM16.cpp */ 1193 HANDLE_OPCODE(OP_MOVE_FROM16 /*vAA, vBBBB*/) 1194 vdst = INST_AA(inst); 1195 vsrc1 = FETCH(1); 1196 ILOGV("|move%s/from16 v%d,v%d %s(v%d=0x%08x)", 1197 (INST_INST(inst) == OP_MOVE_FROM16) ? "" : "-object", vdst, vsrc1, 1198 kSpacing, vdst, GET_REGISTER(vsrc1)); 1199 SET_REGISTER(vdst, GET_REGISTER(vsrc1)); 1200 FINISH(2); 1201 OP_END 1202 1203 /* File: c/OP_MOVE_16.cpp */ 1204 HANDLE_OPCODE(OP_MOVE_16 /*vAAAA, vBBBB*/) 1205 vdst = FETCH(1); 1206 vsrc1 = FETCH(2); 1207 ILOGV("|move%s/16 v%d,v%d %s(v%d=0x%08x)", 1208 (INST_INST(inst) == OP_MOVE_16) ? "" : "-object", vdst, vsrc1, 1209 kSpacing, vdst, GET_REGISTER(vsrc1)); 1210 SET_REGISTER(vdst, GET_REGISTER(vsrc1)); 1211 FINISH(3); 1212 OP_END 1213 1214 /* File: c/OP_MOVE_WIDE.cpp */ 1215 HANDLE_OPCODE(OP_MOVE_WIDE /*vA, vB*/) 1216 /* IMPORTANT: must correctly handle overlapping registers, e.g. both 1217 * "move-wide v6, v7" and "move-wide v7, v6" */ 1218 vdst = INST_A(inst); 1219 vsrc1 = INST_B(inst); 1220 ILOGV("|move-wide v%d,v%d %s(v%d=0x%08llx)", vdst, vsrc1, 1221 kSpacing+5, vdst, GET_REGISTER_WIDE(vsrc1)); 1222 SET_REGISTER_WIDE(vdst, GET_REGISTER_WIDE(vsrc1)); 1223 FINISH(1); 1224 OP_END 1225 1226 /* File: c/OP_MOVE_WIDE_FROM16.cpp */ 1227 HANDLE_OPCODE(OP_MOVE_WIDE_FROM16 /*vAA, vBBBB*/) 1228 vdst = INST_AA(inst); 1229 vsrc1 = FETCH(1); 1230 ILOGV("|move-wide/from16 v%d,v%d (v%d=0x%08llx)", vdst, vsrc1, 1231 vdst, GET_REGISTER_WIDE(vsrc1)); 1232 SET_REGISTER_WIDE(vdst, GET_REGISTER_WIDE(vsrc1)); 1233 FINISH(2); 1234 OP_END 1235 1236 /* File: c/OP_MOVE_WIDE_16.cpp */ 1237 HANDLE_OPCODE(OP_MOVE_WIDE_16 /*vAAAA, vBBBB*/) 1238 vdst = FETCH(1); 1239 vsrc1 = FETCH(2); 1240 ILOGV("|move-wide/16 v%d,v%d %s(v%d=0x%08llx)", vdst, vsrc1, 1241 kSpacing+8, vdst, GET_REGISTER_WIDE(vsrc1)); 1242 SET_REGISTER_WIDE(vdst, GET_REGISTER_WIDE(vsrc1)); 1243 FINISH(3); 1244 OP_END 1245 1246 /* File: c/OP_MOVE_OBJECT.cpp */ 1247 /* File: c/OP_MOVE.cpp */ 1248 HANDLE_OPCODE(OP_MOVE_OBJECT /*vA, vB*/) 1249 vdst = INST_A(inst); 1250 vsrc1 = INST_B(inst); 1251 ILOGV("|move%s v%d,v%d %s(v%d=0x%08x)", 1252 (INST_INST(inst) == OP_MOVE) ? "" : "-object", vdst, vsrc1, 1253 kSpacing, vdst, GET_REGISTER(vsrc1)); 1254 SET_REGISTER(vdst, GET_REGISTER(vsrc1)); 1255 FINISH(1); 1256 OP_END 1257 1258 1259 /* File: c/OP_MOVE_OBJECT_FROM16.cpp */ 1260 /* File: c/OP_MOVE_FROM16.cpp */ 1261 HANDLE_OPCODE(OP_MOVE_OBJECT_FROM16 /*vAA, vBBBB*/) 1262 vdst = INST_AA(inst); 1263 vsrc1 = FETCH(1); 1264 ILOGV("|move%s/from16 v%d,v%d %s(v%d=0x%08x)", 1265 (INST_INST(inst) == OP_MOVE_FROM16) ? "" : "-object", vdst, vsrc1, 1266 kSpacing, vdst, GET_REGISTER(vsrc1)); 1267 SET_REGISTER(vdst, GET_REGISTER(vsrc1)); 1268 FINISH(2); 1269 OP_END 1270 1271 1272 /* File: c/OP_MOVE_OBJECT_16.cpp */ 1273 /* File: c/OP_MOVE_16.cpp */ 1274 HANDLE_OPCODE(OP_MOVE_OBJECT_16 /*vAAAA, vBBBB*/) 1275 vdst = FETCH(1); 1276 vsrc1 = FETCH(2); 1277 ILOGV("|move%s/16 v%d,v%d %s(v%d=0x%08x)", 1278 (INST_INST(inst) == OP_MOVE_16) ? "" : "-object", vdst, vsrc1, 1279 kSpacing, vdst, GET_REGISTER(vsrc1)); 1280 SET_REGISTER(vdst, GET_REGISTER(vsrc1)); 1281 FINISH(3); 1282 OP_END 1283 1284 1285 /* File: c/OP_MOVE_RESULT.cpp */ 1286 HANDLE_OPCODE(OP_MOVE_RESULT /*vAA*/) 1287 vdst = INST_AA(inst); 1288 ILOGV("|move-result%s v%d %s(v%d=0x%08x)", 1289 (INST_INST(inst) == OP_MOVE_RESULT) ? "" : "-object", 1290 vdst, kSpacing+4, vdst,retval.i); 1291 SET_REGISTER(vdst, retval.i); 1292 FINISH(1); 1293 OP_END 1294 1295 /* File: c/OP_MOVE_RESULT_WIDE.cpp */ 1296 HANDLE_OPCODE(OP_MOVE_RESULT_WIDE /*vAA*/) 1297 vdst = INST_AA(inst); 1298 ILOGV("|move-result-wide v%d %s(0x%08llx)", vdst, kSpacing, retval.j); 1299 SET_REGISTER_WIDE(vdst, retval.j); 1300 FINISH(1); 1301 OP_END 1302 1303 /* File: c/OP_MOVE_RESULT_OBJECT.cpp */ 1304 /* File: c/OP_MOVE_RESULT.cpp */ 1305 HANDLE_OPCODE(OP_MOVE_RESULT_OBJECT /*vAA*/) 1306 vdst = INST_AA(inst); 1307 ILOGV("|move-result%s v%d %s(v%d=0x%08x)", 1308 (INST_INST(inst) == OP_MOVE_RESULT) ? "" : "-object", 1309 vdst, kSpacing+4, vdst,retval.i); 1310 SET_REGISTER(vdst, retval.i); 1311 FINISH(1); 1312 OP_END 1313 1314 1315 /* File: c/OP_MOVE_EXCEPTION.cpp */ 1316 HANDLE_OPCODE(OP_MOVE_EXCEPTION /*vAA*/) 1317 vdst = INST_AA(inst); 1318 ILOGV("|move-exception v%d", vdst); 1319 assert(self->exception != NULL); 1320 SET_REGISTER(vdst, (u4)self->exception); 1321 dvmClearException(self); 1322 FINISH(1); 1323 OP_END 1324 1325 /* File: c/OP_RETURN_VOID.cpp */ 1326 HANDLE_OPCODE(OP_RETURN_VOID /**/) 1327 ILOGV("|return-void"); 1328 #ifndef NDEBUG 1329 retval.j = 0xababababULL; // placate valgrind 1330 #endif 1331 GOTO_returnFromMethod(); 1332 OP_END 1333 1334 /* File: c/OP_RETURN.cpp */ 1335 HANDLE_OPCODE(OP_RETURN /*vAA*/) 1336 vsrc1 = INST_AA(inst); 1337 ILOGV("|return%s v%d", 1338 (INST_INST(inst) == OP_RETURN) ? "" : "-object", vsrc1); 1339 retval.i = GET_REGISTER(vsrc1); 1340 GOTO_returnFromMethod(); 1341 OP_END 1342 1343 /* File: c/OP_RETURN_WIDE.cpp */ 1344 HANDLE_OPCODE(OP_RETURN_WIDE /*vAA*/) 1345 vsrc1 = INST_AA(inst); 1346 ILOGV("|return-wide v%d", vsrc1); 1347 retval.j = GET_REGISTER_WIDE(vsrc1); 1348 GOTO_returnFromMethod(); 1349 OP_END 1350 1351 /* File: c/OP_RETURN_OBJECT.cpp */ 1352 /* File: c/OP_RETURN.cpp */ 1353 HANDLE_OPCODE(OP_RETURN_OBJECT /*vAA*/) 1354 vsrc1 = INST_AA(inst); 1355 ILOGV("|return%s v%d", 1356 (INST_INST(inst) == OP_RETURN) ? "" : "-object", vsrc1); 1357 retval.i = GET_REGISTER(vsrc1); 1358 GOTO_returnFromMethod(); 1359 OP_END 1360 1361 1362 /* File: c/OP_CONST_4.cpp */ 1363 HANDLE_OPCODE(OP_CONST_4 /*vA, #+B*/) 1364 { 1365 s4 tmp; 1366 1367 vdst = INST_A(inst); 1368 tmp = (s4) (INST_B(inst) << 28) >> 28; // sign extend 4-bit value 1369 ILOGV("|const/4 v%d,#0x%02x", vdst, (s4)tmp); 1370 SET_REGISTER(vdst, tmp); 1371 } 1372 FINISH(1); 1373 OP_END 1374 1375 /* File: c/OP_CONST_16.cpp */ 1376 HANDLE_OPCODE(OP_CONST_16 /*vAA, #+BBBB*/) 1377 vdst = INST_AA(inst); 1378 vsrc1 = FETCH(1); 1379 ILOGV("|const/16 v%d,#0x%04x", vdst, (s2)vsrc1); 1380 SET_REGISTER(vdst, (s2) vsrc1); 1381 FINISH(2); 1382 OP_END 1383 1384 /* File: c/OP_CONST.cpp */ 1385 HANDLE_OPCODE(OP_CONST /*vAA, #+BBBBBBBB*/) 1386 { 1387 u4 tmp; 1388 1389 vdst = INST_AA(inst); 1390 tmp = FETCH(1); 1391 tmp |= (u4)FETCH(2) << 16; 1392 ILOGV("|const v%d,#0x%08x", vdst, tmp); 1393 SET_REGISTER(vdst, tmp); 1394 } 1395 FINISH(3); 1396 OP_END 1397 1398 /* File: c/OP_CONST_HIGH16.cpp */ 1399 HANDLE_OPCODE(OP_CONST_HIGH16 /*vAA, #+BBBB0000*/) 1400 vdst = INST_AA(inst); 1401 vsrc1 = FETCH(1); 1402 ILOGV("|const/high16 v%d,#0x%04x0000", vdst, vsrc1); 1403 SET_REGISTER(vdst, vsrc1 << 16); 1404 FINISH(2); 1405 OP_END 1406 1407 /* File: c/OP_CONST_WIDE_16.cpp */ 1408 HANDLE_OPCODE(OP_CONST_WIDE_16 /*vAA, #+BBBB*/) 1409 vdst = INST_AA(inst); 1410 vsrc1 = FETCH(1); 1411 ILOGV("|const-wide/16 v%d,#0x%04x", vdst, (s2)vsrc1); 1412 SET_REGISTER_WIDE(vdst, (s2)vsrc1); 1413 FINISH(2); 1414 OP_END 1415 1416 /* File: c/OP_CONST_WIDE_32.cpp */ 1417 HANDLE_OPCODE(OP_CONST_WIDE_32 /*vAA, #+BBBBBBBB*/) 1418 { 1419 u4 tmp; 1420 1421 vdst = INST_AA(inst); 1422 tmp = FETCH(1); 1423 tmp |= (u4)FETCH(2) << 16; 1424 ILOGV("|const-wide/32 v%d,#0x%08x", vdst, tmp); 1425 SET_REGISTER_WIDE(vdst, (s4) tmp); 1426 } 1427 FINISH(3); 1428 OP_END 1429 1430 /* File: c/OP_CONST_WIDE.cpp */ 1431 HANDLE_OPCODE(OP_CONST_WIDE /*vAA, #+BBBBBBBBBBBBBBBB*/) 1432 { 1433 u8 tmp; 1434 1435 vdst = INST_AA(inst); 1436 tmp = FETCH(1); 1437 tmp |= (u8)FETCH(2) << 16; 1438 tmp |= (u8)FETCH(3) << 32; 1439 tmp |= (u8)FETCH(4) << 48; 1440 ILOGV("|const-wide v%d,#0x%08llx", vdst, tmp); 1441 SET_REGISTER_WIDE(vdst, tmp); 1442 } 1443 FINISH(5); 1444 OP_END 1445 1446 /* File: c/OP_CONST_WIDE_HIGH16.cpp */ 1447 HANDLE_OPCODE(OP_CONST_WIDE_HIGH16 /*vAA, #+BBBB000000000000*/) 1448 vdst = INST_AA(inst); 1449 vsrc1 = FETCH(1); 1450 ILOGV("|const-wide/high16 v%d,#0x%04x000000000000", vdst, vsrc1); 1451 SET_REGISTER_WIDE(vdst, ((u8) vsrc1) << 48); 1452 FINISH(2); 1453 OP_END 1454 1455 /* File: c/OP_CONST_STRING.cpp */ 1456 HANDLE_OPCODE(OP_CONST_STRING /*vAA, string@BBBB*/) 1457 { 1458 StringObject* strObj; 1459 1460 vdst = INST_AA(inst); 1461 ref = FETCH(1); 1462 ILOGV("|const-string v%d string@0x%04x", vdst, ref); 1463 strObj = dvmDexGetResolvedString(methodClassDex, ref); 1464 if (strObj == NULL) { 1465 EXPORT_PC(); 1466 strObj = dvmResolveString(curMethod->clazz, ref); 1467 if (strObj == NULL) 1468 GOTO_exceptionThrown(); 1469 } 1470 SET_REGISTER(vdst, (u4) strObj); 1471 } 1472 FINISH(2); 1473 OP_END 1474 1475 /* File: c/OP_CONST_STRING_JUMBO.cpp */ 1476 HANDLE_OPCODE(OP_CONST_STRING_JUMBO /*vAA, string@BBBBBBBB*/) 1477 { 1478 StringObject* strObj; 1479 u4 tmp; 1480 1481 vdst = INST_AA(inst); 1482 tmp = FETCH(1); 1483 tmp |= (u4)FETCH(2) << 16; 1484 ILOGV("|const-string/jumbo v%d string@0x%08x", vdst, tmp); 1485 strObj = dvmDexGetResolvedString(methodClassDex, tmp); 1486 if (strObj == NULL) { 1487 EXPORT_PC(); 1488 strObj = dvmResolveString(curMethod->clazz, tmp); 1489 if (strObj == NULL) 1490 GOTO_exceptionThrown(); 1491 } 1492 SET_REGISTER(vdst, (u4) strObj); 1493 } 1494 FINISH(3); 1495 OP_END 1496 1497 /* File: c/OP_CONST_CLASS.cpp */ 1498 HANDLE_OPCODE(OP_CONST_CLASS /*vAA, class@BBBB*/) 1499 { 1500 ClassObject* clazz; 1501 1502 vdst = INST_AA(inst); 1503 ref = FETCH(1); 1504 ILOGV("|const-class v%d class@0x%04x", vdst, ref); 1505 clazz = dvmDexGetResolvedClass(methodClassDex, ref); 1506 if (clazz == NULL) { 1507 EXPORT_PC(); 1508 clazz = dvmResolveClass(curMethod->clazz, ref, true); 1509 if (clazz == NULL) 1510 GOTO_exceptionThrown(); 1511 } 1512 SET_REGISTER(vdst, (u4) clazz); 1513 } 1514 FINISH(2); 1515 OP_END 1516 1517 /* File: c/OP_MONITOR_ENTER.cpp */ 1518 HANDLE_OPCODE(OP_MONITOR_ENTER /*vAA*/) 1519 { 1520 Object* obj; 1521 1522 vsrc1 = INST_AA(inst); 1523 ILOGV("|monitor-enter v%d %s(0x%08x)", 1524 vsrc1, kSpacing+6, GET_REGISTER(vsrc1)); 1525 obj = (Object*)GET_REGISTER(vsrc1); 1526 if (!checkForNullExportPC(obj, fp, pc)) 1527 GOTO_exceptionThrown(); 1528 ILOGV("+ locking %p %s", obj, obj->clazz->descriptor); 1529 EXPORT_PC(); /* need for precise GC */ 1530 dvmLockObject(self, obj); 1531 } 1532 FINISH(1); 1533 OP_END 1534 1535 /* File: c/OP_MONITOR_EXIT.cpp */ 1536 HANDLE_OPCODE(OP_MONITOR_EXIT /*vAA*/) 1537 { 1538 Object* obj; 1539 1540 EXPORT_PC(); 1541 1542 vsrc1 = INST_AA(inst); 1543 ILOGV("|monitor-exit v%d %s(0x%08x)", 1544 vsrc1, kSpacing+5, GET_REGISTER(vsrc1)); 1545 obj = (Object*)GET_REGISTER(vsrc1); 1546 if (!checkForNull(obj)) { 1547 /* 1548 * The exception needs to be processed at the *following* 1549 * instruction, not the current instruction (see the Dalvik 1550 * spec). Because we're jumping to an exception handler, 1551 * we're not actually at risk of skipping an instruction 1552 * by doing so. 1553 */ 1554 ADJUST_PC(1); /* monitor-exit width is 1 */ 1555 GOTO_exceptionThrown(); 1556 } 1557 ILOGV("+ unlocking %p %s", obj, obj->clazz->descriptor); 1558 if (!dvmUnlockObject(self, obj)) { 1559 assert(dvmCheckException(self)); 1560 ADJUST_PC(1); 1561 GOTO_exceptionThrown(); 1562 } 1563 } 1564 FINISH(1); 1565 OP_END 1566 1567 /* File: c/OP_CHECK_CAST.cpp */ 1568 HANDLE_OPCODE(OP_CHECK_CAST /*vAA, class@BBBB*/) 1569 { 1570 ClassObject* clazz; 1571 Object* obj; 1572 1573 EXPORT_PC(); 1574 1575 vsrc1 = INST_AA(inst); 1576 ref = FETCH(1); /* class to check against */ 1577 ILOGV("|check-cast v%d,class@0x%04x", vsrc1, ref); 1578 1579 obj = (Object*)GET_REGISTER(vsrc1); 1580 if (obj != NULL) { 1581 #if defined(WITH_EXTRA_OBJECT_VALIDATION) 1582 if (!checkForNull(obj)) 1583 GOTO_exceptionThrown(); 1584 #endif 1585 clazz = dvmDexGetResolvedClass(methodClassDex, ref); 1586 if (clazz == NULL) { 1587 clazz = dvmResolveClass(curMethod->clazz, ref, false); 1588 if (clazz == NULL) 1589 GOTO_exceptionThrown(); 1590 } 1591 if (!dvmInstanceof(obj->clazz, clazz)) { 1592 dvmThrowClassCastException(obj->clazz, clazz); 1593 GOTO_exceptionThrown(); 1594 } 1595 } 1596 } 1597 FINISH(2); 1598 OP_END 1599 1600 /* File: c/OP_INSTANCE_OF.cpp */ 1601 HANDLE_OPCODE(OP_INSTANCE_OF /*vA, vB, class@CCCC*/) 1602 { 1603 ClassObject* clazz; 1604 Object* obj; 1605 1606 vdst = INST_A(inst); 1607 vsrc1 = INST_B(inst); /* object to check */ 1608 ref = FETCH(1); /* class to check against */ 1609 ILOGV("|instance-of v%d,v%d,class@0x%04x", vdst, vsrc1, ref); 1610 1611 obj = (Object*)GET_REGISTER(vsrc1); 1612 if (obj == NULL) { 1613 SET_REGISTER(vdst, 0); 1614 } else { 1615 #if defined(WITH_EXTRA_OBJECT_VALIDATION) 1616 if (!checkForNullExportPC(obj, fp, pc)) 1617 GOTO_exceptionThrown(); 1618 #endif 1619 clazz = dvmDexGetResolvedClass(methodClassDex, ref); 1620 if (clazz == NULL) { 1621 EXPORT_PC(); 1622 clazz = dvmResolveClass(curMethod->clazz, ref, true); 1623 if (clazz == NULL) 1624 GOTO_exceptionThrown(); 1625 } 1626 SET_REGISTER(vdst, dvmInstanceof(obj->clazz, clazz)); 1627 } 1628 } 1629 FINISH(2); 1630 OP_END 1631 1632 /* File: c/OP_ARRAY_LENGTH.cpp */ 1633 HANDLE_OPCODE(OP_ARRAY_LENGTH /*vA, vB*/) 1634 { 1635 ArrayObject* arrayObj; 1636 1637 vdst = INST_A(inst); 1638 vsrc1 = INST_B(inst); 1639 arrayObj = (ArrayObject*) GET_REGISTER(vsrc1); 1640 ILOGV("|array-length v%d,v%d (%p)", vdst, vsrc1, arrayObj); 1641 if (!checkForNullExportPC((Object*) arrayObj, fp, pc)) 1642 GOTO_exceptionThrown(); 1643 /* verifier guarantees this is an array reference */ 1644 SET_REGISTER(vdst, arrayObj->length); 1645 } 1646 FINISH(1); 1647 OP_END 1648 1649 /* File: c/OP_NEW_INSTANCE.cpp */ 1650 HANDLE_OPCODE(OP_NEW_INSTANCE /*vAA, class@BBBB*/) 1651 { 1652 ClassObject* clazz; 1653 Object* newObj; 1654 1655 EXPORT_PC(); 1656 1657 vdst = INST_AA(inst); 1658 ref = FETCH(1); 1659 ILOGV("|new-instance v%d,class@0x%04x", vdst, ref); 1660 clazz = dvmDexGetResolvedClass(methodClassDex, ref); 1661 if (clazz == NULL) { 1662 clazz = dvmResolveClass(curMethod->clazz, ref, false); 1663 if (clazz == NULL) 1664 GOTO_exceptionThrown(); 1665 } 1666 1667 if (!dvmIsClassInitialized(clazz) && !dvmInitClass(clazz)) 1668 GOTO_exceptionThrown(); 1669 1670 #if defined(WITH_JIT) 1671 /* 1672 * The JIT needs dvmDexGetResolvedClass() to return non-null. 1673 * Since we use the portable interpreter to build the trace, this extra 1674 * check is not needed for mterp. 1675 */ 1676 if ((self->interpBreak.ctl.subMode & kSubModeJitTraceBuild) && 1677 (!dvmDexGetResolvedClass(methodClassDex, ref))) { 1678 /* Class initialization is still ongoing - end the trace */ 1679 dvmJitEndTraceSelect(self,pc); 1680 } 1681 #endif 1682 1683 /* 1684 * Verifier now tests for interface/abstract class. 1685 */ 1686 //if (dvmIsInterfaceClass(clazz) || dvmIsAbstractClass(clazz)) { 1687 // dvmThrowExceptionWithClassMessage(gDvm.exInstantiationError, 1688 // clazz->descriptor); 1689 // GOTO_exceptionThrown(); 1690 //} 1691 newObj = dvmAllocObject(clazz, ALLOC_DONT_TRACK); 1692 if (newObj == NULL) 1693 GOTO_exceptionThrown(); 1694 SET_REGISTER(vdst, (u4) newObj); 1695 } 1696 FINISH(2); 1697 OP_END 1698 1699 /* File: c/OP_NEW_ARRAY.cpp */ 1700 HANDLE_OPCODE(OP_NEW_ARRAY /*vA, vB, class@CCCC*/) 1701 { 1702 ClassObject* arrayClass; 1703 ArrayObject* newArray; 1704 s4 length; 1705 1706 EXPORT_PC(); 1707 1708 vdst = INST_A(inst); 1709 vsrc1 = INST_B(inst); /* length reg */ 1710 ref = FETCH(1); 1711 ILOGV("|new-array v%d,v%d,class@0x%04x (%d elements)", 1712 vdst, vsrc1, ref, (s4) GET_REGISTER(vsrc1)); 1713 length = (s4) GET_REGISTER(vsrc1); 1714 if (length < 0) { 1715 dvmThrowNegativeArraySizeException(length); 1716 GOTO_exceptionThrown(); 1717 } 1718 arrayClass = dvmDexGetResolvedClass(methodClassDex, ref); 1719 if (arrayClass == NULL) { 1720 arrayClass = dvmResolveClass(curMethod->clazz, ref, false); 1721 if (arrayClass == NULL) 1722 GOTO_exceptionThrown(); 1723 } 1724 /* verifier guarantees this is an array class */ 1725 assert(dvmIsArrayClass(arrayClass)); 1726 assert(dvmIsClassInitialized(arrayClass)); 1727 1728 newArray = dvmAllocArrayByClass(arrayClass, length, ALLOC_DONT_TRACK); 1729 if (newArray == NULL) 1730 GOTO_exceptionThrown(); 1731 SET_REGISTER(vdst, (u4) newArray); 1732 } 1733 FINISH(2); 1734 OP_END 1735 1736 /* File: c/OP_FILLED_NEW_ARRAY.cpp */ 1737 HANDLE_OPCODE(OP_FILLED_NEW_ARRAY /*vB, {vD, vE, vF, vG, vA}, class@CCCC*/) 1738 GOTO_invoke(filledNewArray, false); 1739 OP_END 1740 1741 /* File: c/OP_FILLED_NEW_ARRAY_RANGE.cpp */ 1742 HANDLE_OPCODE(OP_FILLED_NEW_ARRAY_RANGE /*{vCCCC..v(CCCC+AA-1)}, class@BBBB*/) 1743 GOTO_invoke(filledNewArray, true); 1744 OP_END 1745 1746 /* File: c/OP_FILL_ARRAY_DATA.cpp */ 1747 HANDLE_OPCODE(OP_FILL_ARRAY_DATA) /*vAA, +BBBBBBBB*/ 1748 { 1749 const u2* arrayData; 1750 s4 offset; 1751 ArrayObject* arrayObj; 1752 1753 EXPORT_PC(); 1754 vsrc1 = INST_AA(inst); 1755 offset = FETCH(1) | (((s4) FETCH(2)) << 16); 1756 ILOGV("|fill-array-data v%d +0x%04x", vsrc1, offset); 1757 arrayData = pc + offset; // offset in 16-bit units 1758 #ifndef NDEBUG 1759 if (arrayData < curMethod->insns || 1760 arrayData >= curMethod->insns + dvmGetMethodInsnsSize(curMethod)) 1761 { 1762 /* should have been caught in verifier */ 1763 dvmThrowInternalError("bad fill array data"); 1764 GOTO_exceptionThrown(); 1765 } 1766 #endif 1767 arrayObj = (ArrayObject*) GET_REGISTER(vsrc1); 1768 if (!dvmInterpHandleFillArrayData(arrayObj, arrayData)) { 1769 GOTO_exceptionThrown(); 1770 } 1771 FINISH(3); 1772 } 1773 OP_END 1774 1775 /* File: c/OP_THROW.cpp */ 1776 HANDLE_OPCODE(OP_THROW /*vAA*/) 1777 { 1778 Object* obj; 1779 1780 /* 1781 * We don't create an exception here, but the process of searching 1782 * for a catch block can do class lookups and throw exceptions. 1783 * We need to update the saved PC. 1784 */ 1785 EXPORT_PC(); 1786 1787 vsrc1 = INST_AA(inst); 1788 ILOGV("|throw v%d (%p)", vsrc1, (void*)GET_REGISTER(vsrc1)); 1789 obj = (Object*) GET_REGISTER(vsrc1); 1790 if (!checkForNull(obj)) { 1791 /* will throw a null pointer exception */ 1792 LOGVV("Bad exception"); 1793 } else { 1794 /* use the requested exception */ 1795 dvmSetException(self, obj); 1796 } 1797 GOTO_exceptionThrown(); 1798 } 1799 OP_END 1800 1801 /* File: c/OP_GOTO.cpp */ 1802 HANDLE_OPCODE(OP_GOTO /*+AA*/) 1803 vdst = INST_AA(inst); 1804 if ((s1)vdst < 0) 1805 ILOGV("|goto -0x%02x", -((s1)vdst)); 1806 else 1807 ILOGV("|goto +0x%02x", ((s1)vdst)); 1808 ILOGV("> branch taken"); 1809 if ((s1)vdst < 0) 1810 PERIODIC_CHECKS((s1)vdst); 1811 FINISH((s1)vdst); 1812 OP_END 1813 1814 /* File: c/OP_GOTO_16.cpp */ 1815 HANDLE_OPCODE(OP_GOTO_16 /*+AAAA*/) 1816 { 1817 s4 offset = (s2) FETCH(1); /* sign-extend next code unit */ 1818 1819 if (offset < 0) 1820 ILOGV("|goto/16 -0x%04x", -offset); 1821 else 1822 ILOGV("|goto/16 +0x%04x", offset); 1823 ILOGV("> branch taken"); 1824 if (offset < 0) 1825 PERIODIC_CHECKS(offset); 1826 FINISH(offset); 1827 } 1828 OP_END 1829 1830 /* File: c/OP_GOTO_32.cpp */ 1831 HANDLE_OPCODE(OP_GOTO_32 /*+AAAAAAAA*/) 1832 { 1833 s4 offset = FETCH(1); /* low-order 16 bits */ 1834 offset |= ((s4) FETCH(2)) << 16; /* high-order 16 bits */ 1835 1836 if (offset < 0) 1837 ILOGV("|goto/32 -0x%08x", -offset); 1838 else 1839 ILOGV("|goto/32 +0x%08x", offset); 1840 ILOGV("> branch taken"); 1841 if (offset <= 0) /* allowed to branch to self */ 1842 PERIODIC_CHECKS(offset); 1843 FINISH(offset); 1844 } 1845 OP_END 1846 1847 /* File: c/OP_PACKED_SWITCH.cpp */ 1848 HANDLE_OPCODE(OP_PACKED_SWITCH /*vAA, +BBBB*/) 1849 { 1850 const u2* switchData; 1851 u4 testVal; 1852 s4 offset; 1853 1854 vsrc1 = INST_AA(inst); 1855 offset = FETCH(1) | (((s4) FETCH(2)) << 16); 1856 ILOGV("|packed-switch v%d +0x%04x", vsrc1, offset); 1857 switchData = pc + offset; // offset in 16-bit units 1858 #ifndef NDEBUG 1859 if (switchData < curMethod->insns || 1860 switchData >= curMethod->insns + dvmGetMethodInsnsSize(curMethod)) 1861 { 1862 /* should have been caught in verifier */ 1863 EXPORT_PC(); 1864 dvmThrowInternalError("bad packed switch"); 1865 GOTO_exceptionThrown(); 1866 } 1867 #endif 1868 testVal = GET_REGISTER(vsrc1); 1869 1870 offset = dvmInterpHandlePackedSwitch(switchData, testVal); 1871 ILOGV("> branch taken (0x%04x)", offset); 1872 if (offset <= 0) /* uncommon */ 1873 PERIODIC_CHECKS(offset); 1874 FINISH(offset); 1875 } 1876 OP_END 1877 1878 /* File: c/OP_SPARSE_SWITCH.cpp */ 1879 HANDLE_OPCODE(OP_SPARSE_SWITCH /*vAA, +BBBB*/) 1880 { 1881 const u2* switchData; 1882 u4 testVal; 1883 s4 offset; 1884 1885 vsrc1 = INST_AA(inst); 1886 offset = FETCH(1) | (((s4) FETCH(2)) << 16); 1887 ILOGV("|sparse-switch v%d +0x%04x", vsrc1, offset); 1888 switchData = pc + offset; // offset in 16-bit units 1889 #ifndef NDEBUG 1890 if (switchData < curMethod->insns || 1891 switchData >= curMethod->insns + dvmGetMethodInsnsSize(curMethod)) 1892 { 1893 /* should have been caught in verifier */ 1894 EXPORT_PC(); 1895 dvmThrowInternalError("bad sparse switch"); 1896 GOTO_exceptionThrown(); 1897 } 1898 #endif 1899 testVal = GET_REGISTER(vsrc1); 1900 1901 offset = dvmInterpHandleSparseSwitch(switchData, testVal); 1902 ILOGV("> branch taken (0x%04x)", offset); 1903 if (offset <= 0) /* uncommon */ 1904 PERIODIC_CHECKS(offset); 1905 FINISH(offset); 1906 } 1907 OP_END 1908 1909 /* File: c/OP_CMPL_FLOAT.cpp */ 1910 HANDLE_OP_CMPX(OP_CMPL_FLOAT, "l-float", float, _FLOAT, -1) 1911 OP_END 1912 1913 /* File: c/OP_CMPG_FLOAT.cpp */ 1914 HANDLE_OP_CMPX(OP_CMPG_FLOAT, "g-float", float, _FLOAT, 1) 1915 OP_END 1916 1917 /* File: c/OP_CMPL_DOUBLE.cpp */ 1918 HANDLE_OP_CMPX(OP_CMPL_DOUBLE, "l-double", double, _DOUBLE, -1) 1919 OP_END 1920 1921 /* File: c/OP_CMPG_DOUBLE.cpp */ 1922 HANDLE_OP_CMPX(OP_CMPG_DOUBLE, "g-double", double, _DOUBLE, 1) 1923 OP_END 1924 1925 /* File: c/OP_CMP_LONG.cpp */ 1926 HANDLE_OP_CMPX(OP_CMP_LONG, "-long", s8, _WIDE, 0) 1927 OP_END 1928 1929 /* File: c/OP_IF_EQ.cpp */ 1930 HANDLE_OP_IF_XX(OP_IF_EQ, "eq", ==) 1931 OP_END 1932 1933 /* File: c/OP_IF_NE.cpp */ 1934 HANDLE_OP_IF_XX(OP_IF_NE, "ne", !=) 1935 OP_END 1936 1937 /* File: c/OP_IF_LT.cpp */ 1938 HANDLE_OP_IF_XX(OP_IF_LT, "lt", <) 1939 OP_END 1940 1941 /* File: c/OP_IF_GE.cpp */ 1942 HANDLE_OP_IF_XX(OP_IF_GE, "ge", >=) 1943 OP_END 1944 1945 /* File: c/OP_IF_GT.cpp */ 1946 HANDLE_OP_IF_XX(OP_IF_GT, "gt", >) 1947 OP_END 1948 1949 /* File: c/OP_IF_LE.cpp */ 1950 HANDLE_OP_IF_XX(OP_IF_LE, "le", <=) 1951 OP_END 1952 1953 /* File: c/OP_IF_EQZ.cpp */ 1954 HANDLE_OP_IF_XXZ(OP_IF_EQZ, "eqz", ==) 1955 OP_END 1956 1957 /* File: c/OP_IF_NEZ.cpp */ 1958 HANDLE_OP_IF_XXZ(OP_IF_NEZ, "nez", !=) 1959 OP_END 1960 1961 /* File: c/OP_IF_LTZ.cpp */ 1962 HANDLE_OP_IF_XXZ(OP_IF_LTZ, "ltz", <) 1963 OP_END 1964 1965 /* File: c/OP_IF_GEZ.cpp */ 1966 HANDLE_OP_IF_XXZ(OP_IF_GEZ, "gez", >=) 1967 OP_END 1968 1969 /* File: c/OP_IF_GTZ.cpp */ 1970 HANDLE_OP_IF_XXZ(OP_IF_GTZ, "gtz", >) 1971 OP_END 1972 1973 /* File: c/OP_IF_LEZ.cpp */ 1974 HANDLE_OP_IF_XXZ(OP_IF_LEZ, "lez", <=) 1975 OP_END 1976 1977 /* File: c/OP_UNUSED_3E.cpp */ 1978 HANDLE_OPCODE(OP_UNUSED_3E) 1979 OP_END 1980 1981 /* File: c/OP_UNUSED_3F.cpp */ 1982 HANDLE_OPCODE(OP_UNUSED_3F) 1983 OP_END 1984 1985 /* File: c/OP_UNUSED_40.cpp */ 1986 HANDLE_OPCODE(OP_UNUSED_40) 1987 OP_END 1988 1989 /* File: c/OP_UNUSED_41.cpp */ 1990 HANDLE_OPCODE(OP_UNUSED_41) 1991 OP_END 1992 1993 /* File: c/OP_UNUSED_42.cpp */ 1994 HANDLE_OPCODE(OP_UNUSED_42) 1995 OP_END 1996 1997 /* File: c/OP_UNUSED_43.cpp */ 1998 HANDLE_OPCODE(OP_UNUSED_43) 1999 OP_END 2000 2001 /* File: c/OP_AGET.cpp */ 2002 HANDLE_OP_AGET(OP_AGET, "", u4, ) 2003 OP_END 2004 2005 /* File: c/OP_AGET_WIDE.cpp */ 2006 HANDLE_OP_AGET(OP_AGET_WIDE, "-wide", s8, _WIDE) 2007 OP_END 2008 2009 /* File: c/OP_AGET_OBJECT.cpp */ 2010 HANDLE_OP_AGET(OP_AGET_OBJECT, "-object", u4, ) 2011 OP_END 2012 2013 /* File: c/OP_AGET_BOOLEAN.cpp */ 2014 HANDLE_OP_AGET(OP_AGET_BOOLEAN, "-boolean", u1, ) 2015 OP_END 2016 2017 /* File: c/OP_AGET_BYTE.cpp */ 2018 HANDLE_OP_AGET(OP_AGET_BYTE, "-byte", s1, ) 2019 OP_END 2020 2021 /* File: c/OP_AGET_CHAR.cpp */ 2022 HANDLE_OP_AGET(OP_AGET_CHAR, "-char", u2, ) 2023 OP_END 2024 2025 /* File: c/OP_AGET_SHORT.cpp */ 2026 HANDLE_OP_AGET(OP_AGET_SHORT, "-short", s2, ) 2027 OP_END 2028 2029 /* File: c/OP_APUT.cpp */ 2030 HANDLE_OP_APUT(OP_APUT, "", u4, ) 2031 OP_END 2032 2033 /* File: c/OP_APUT_WIDE.cpp */ 2034 HANDLE_OP_APUT(OP_APUT_WIDE, "-wide", s8, _WIDE) 2035 OP_END 2036 2037 /* File: c/OP_APUT_OBJECT.cpp */ 2038 HANDLE_OPCODE(OP_APUT_OBJECT /*vAA, vBB, vCC*/) 2039 { 2040 ArrayObject* arrayObj; 2041 Object* obj; 2042 u2 arrayInfo; 2043 EXPORT_PC(); 2044 vdst = INST_AA(inst); /* AA: source value */ 2045 arrayInfo = FETCH(1); 2046 vsrc1 = arrayInfo & 0xff; /* BB: array ptr */ 2047 vsrc2 = arrayInfo >> 8; /* CC: index */ 2048 ILOGV("|aput%s v%d,v%d,v%d", "-object", vdst, vsrc1, vsrc2); 2049 arrayObj = (ArrayObject*) GET_REGISTER(vsrc1); 2050 if (!checkForNull((Object*) arrayObj)) 2051 GOTO_exceptionThrown(); 2052 if (GET_REGISTER(vsrc2) >= arrayObj->length) { 2053 dvmThrowArrayIndexOutOfBoundsException( 2054 arrayObj->length, GET_REGISTER(vsrc2)); 2055 GOTO_exceptionThrown(); 2056 } 2057 obj = (Object*) GET_REGISTER(vdst); 2058 if (obj != NULL) { 2059 if (!checkForNull(obj)) 2060 GOTO_exceptionThrown(); 2061 if (!dvmCanPutArrayElement(obj->clazz, arrayObj->clazz)) { 2062 ALOGV("Can't put a '%s'(%p) into array type='%s'(%p)", 2063 obj->clazz->descriptor, obj, 2064 arrayObj->clazz->descriptor, arrayObj); 2065 dvmThrowArrayStoreExceptionIncompatibleElement(obj->clazz, arrayObj->clazz); 2066 GOTO_exceptionThrown(); 2067 } 2068 } 2069 ILOGV("+ APUT[%d]=0x%08x", GET_REGISTER(vsrc2), GET_REGISTER(vdst)); 2070 dvmSetObjectArrayElement(arrayObj, 2071 GET_REGISTER(vsrc2), 2072 (Object *)GET_REGISTER(vdst)); 2073 } 2074 FINISH(2); 2075 OP_END 2076 2077 /* File: c/OP_APUT_BOOLEAN.cpp */ 2078 HANDLE_OP_APUT(OP_APUT_BOOLEAN, "-boolean", u1, ) 2079 OP_END 2080 2081 /* File: c/OP_APUT_BYTE.cpp */ 2082 HANDLE_OP_APUT(OP_APUT_BYTE, "-byte", s1, ) 2083 OP_END 2084 2085 /* File: c/OP_APUT_CHAR.cpp */ 2086 HANDLE_OP_APUT(OP_APUT_CHAR, "-char", u2, ) 2087 OP_END 2088 2089 /* File: c/OP_APUT_SHORT.cpp */ 2090 HANDLE_OP_APUT(OP_APUT_SHORT, "-short", s2, ) 2091 OP_END 2092 2093 /* File: c/OP_IGET.cpp */ 2094 HANDLE_IGET_X(OP_IGET, "", Int, ) 2095 OP_END 2096 2097 /* File: c/OP_IGET_WIDE.cpp */ 2098 HANDLE_IGET_X(OP_IGET_WIDE, "-wide", Long, _WIDE) 2099 OP_END 2100 2101 /* File: c/OP_IGET_OBJECT.cpp */ 2102 HANDLE_IGET_X(OP_IGET_OBJECT, "-object", Object, _AS_OBJECT) 2103 OP_END 2104 2105 /* File: c/OP_IGET_BOOLEAN.cpp */ 2106 HANDLE_IGET_X(OP_IGET_BOOLEAN, "", Int, ) 2107 OP_END 2108 2109 /* File: c/OP_IGET_BYTE.cpp */ 2110 HANDLE_IGET_X(OP_IGET_BYTE, "", Int, ) 2111 OP_END 2112 2113 /* File: c/OP_IGET_CHAR.cpp */ 2114 HANDLE_IGET_X(OP_IGET_CHAR, "", Int, ) 2115 OP_END 2116 2117 /* File: c/OP_IGET_SHORT.cpp */ 2118 HANDLE_IGET_X(OP_IGET_SHORT, "", Int, ) 2119 OP_END 2120 2121 /* File: c/OP_IPUT.cpp */ 2122 HANDLE_IPUT_X(OP_IPUT, "", Int, ) 2123 OP_END 2124 2125 /* File: c/OP_IPUT_WIDE.cpp */ 2126 HANDLE_IPUT_X(OP_IPUT_WIDE, "-wide", Long, _WIDE) 2127 OP_END 2128 2129 /* File: c/OP_IPUT_OBJECT.cpp */ 2130 /* 2131 * The VM spec says we should verify that the reference being stored into 2132 * the field is assignment compatible. In practice, many popular VMs don't 2133 * do this because it slows down a very common operation. It's not so bad 2134 * for us, since "dexopt" quickens it whenever possible, but it's still an 2135 * issue. 2136 * 2137 * To make this spec-complaint, we'd need to add a ClassObject pointer to 2138 * the Field struct, resolve the field's type descriptor at link or class 2139 * init time, and then verify the type here. 2140 */ 2141 HANDLE_IPUT_X(OP_IPUT_OBJECT, "-object", Object, _AS_OBJECT) 2142 OP_END 2143 2144 /* File: c/OP_IPUT_BOOLEAN.cpp */ 2145 HANDLE_IPUT_X(OP_IPUT_BOOLEAN, "", Int, ) 2146 OP_END 2147 2148 /* File: c/OP_IPUT_BYTE.cpp */ 2149 HANDLE_IPUT_X(OP_IPUT_BYTE, "", Int, ) 2150 OP_END 2151 2152 /* File: c/OP_IPUT_CHAR.cpp */ 2153 HANDLE_IPUT_X(OP_IPUT_CHAR, "", Int, ) 2154 OP_END 2155 2156 /* File: c/OP_IPUT_SHORT.cpp */ 2157 HANDLE_IPUT_X(OP_IPUT_SHORT, "", Int, ) 2158 OP_END 2159 2160 /* File: c/OP_SGET.cpp */ 2161 HANDLE_SGET_X(OP_SGET, "", Int, ) 2162 OP_END 2163 2164 /* File: c/OP_SGET_WIDE.cpp */ 2165 HANDLE_SGET_X(OP_SGET_WIDE, "-wide", Long, _WIDE) 2166 OP_END 2167 2168 /* File: c/OP_SGET_OBJECT.cpp */ 2169 HANDLE_SGET_X(OP_SGET_OBJECT, "-object", Object, _AS_OBJECT) 2170 OP_END 2171 2172 /* File: c/OP_SGET_BOOLEAN.cpp */ 2173 HANDLE_SGET_X(OP_SGET_BOOLEAN, "", Int, ) 2174 OP_END 2175 2176 /* File: c/OP_SGET_BYTE.cpp */ 2177 HANDLE_SGET_X(OP_SGET_BYTE, "", Int, ) 2178 OP_END 2179 2180 /* File: c/OP_SGET_CHAR.cpp */ 2181 HANDLE_SGET_X(OP_SGET_CHAR, "", Int, ) 2182 OP_END 2183 2184 /* File: c/OP_SGET_SHORT.cpp */ 2185 HANDLE_SGET_X(OP_SGET_SHORT, "", Int, ) 2186 OP_END 2187 2188 /* File: c/OP_SPUT.cpp */ 2189 HANDLE_SPUT_X(OP_SPUT, "", Int, ) 2190 OP_END 2191 2192 /* File: c/OP_SPUT_WIDE.cpp */ 2193 HANDLE_SPUT_X(OP_SPUT_WIDE, "-wide", Long, _WIDE) 2194 OP_END 2195 2196 /* File: c/OP_SPUT_OBJECT.cpp */ 2197 HANDLE_SPUT_X(OP_SPUT_OBJECT, "-object", Object, _AS_OBJECT) 2198 OP_END 2199 2200 /* File: c/OP_SPUT_BOOLEAN.cpp */ 2201 HANDLE_SPUT_X(OP_SPUT_BOOLEAN, "", Int, ) 2202 OP_END 2203 2204 /* File: c/OP_SPUT_BYTE.cpp */ 2205 HANDLE_SPUT_X(OP_SPUT_BYTE, "", Int, ) 2206 OP_END 2207 2208 /* File: c/OP_SPUT_CHAR.cpp */ 2209 HANDLE_SPUT_X(OP_SPUT_CHAR, "", Int, ) 2210 OP_END 2211 2212 /* File: c/OP_SPUT_SHORT.cpp */ 2213 HANDLE_SPUT_X(OP_SPUT_SHORT, "", Int, ) 2214 OP_END 2215 2216 /* File: c/OP_INVOKE_VIRTUAL.cpp */ 2217 HANDLE_OPCODE(OP_INVOKE_VIRTUAL /*vB, {vD, vE, vF, vG, vA}, meth@CCCC*/) 2218 GOTO_invoke(invokeVirtual, false); 2219 OP_END 2220 2221 /* File: c/OP_INVOKE_SUPER.cpp */ 2222 HANDLE_OPCODE(OP_INVOKE_SUPER /*vB, {vD, vE, vF, vG, vA}, meth@CCCC*/) 2223 GOTO_invoke(invokeSuper, false); 2224 OP_END 2225 2226 /* File: c/OP_INVOKE_DIRECT.cpp */ 2227 HANDLE_OPCODE(OP_INVOKE_DIRECT /*vB, {vD, vE, vF, vG, vA}, meth@CCCC*/) 2228 GOTO_invoke(invokeDirect, false); 2229 OP_END 2230 2231 /* File: c/OP_INVOKE_STATIC.cpp */ 2232 HANDLE_OPCODE(OP_INVOKE_STATIC /*vB, {vD, vE, vF, vG, vA}, meth@CCCC*/) 2233 GOTO_invoke(invokeStatic, false); 2234 OP_END 2235 2236 /* File: c/OP_INVOKE_INTERFACE.cpp */ 2237 HANDLE_OPCODE(OP_INVOKE_INTERFACE /*vB, {vD, vE, vF, vG, vA}, meth@CCCC*/) 2238 GOTO_invoke(invokeInterface, false); 2239 OP_END 2240 2241 /* File: c/OP_UNUSED_73.cpp */ 2242 HANDLE_OPCODE(OP_UNUSED_73) 2243 OP_END 2244 2245 /* File: c/OP_INVOKE_VIRTUAL_RANGE.cpp */ 2246 HANDLE_OPCODE(OP_INVOKE_VIRTUAL_RANGE /*{vCCCC..v(CCCC+AA-1)}, meth@BBBB*/) 2247 GOTO_invoke(invokeVirtual, true); 2248 OP_END 2249 2250 /* File: c/OP_INVOKE_SUPER_RANGE.cpp */ 2251 HANDLE_OPCODE(OP_INVOKE_SUPER_RANGE /*{vCCCC..v(CCCC+AA-1)}, meth@BBBB*/) 2252 GOTO_invoke(invokeSuper, true); 2253 OP_END 2254 2255 /* File: c/OP_INVOKE_DIRECT_RANGE.cpp */ 2256 HANDLE_OPCODE(OP_INVOKE_DIRECT_RANGE /*{vCCCC..v(CCCC+AA-1)}, meth@BBBB*/) 2257 GOTO_invoke(invokeDirect, true); 2258 OP_END 2259 2260 /* File: c/OP_INVOKE_STATIC_RANGE.cpp */ 2261 HANDLE_OPCODE(OP_INVOKE_STATIC_RANGE /*{vCCCC..v(CCCC+AA-1)}, meth@BBBB*/) 2262 GOTO_invoke(invokeStatic, true); 2263 OP_END 2264 2265 /* File: c/OP_INVOKE_INTERFACE_RANGE.cpp */ 2266 HANDLE_OPCODE(OP_INVOKE_INTERFACE_RANGE /*{vCCCC..v(CCCC+AA-1)}, meth@BBBB*/) 2267 GOTO_invoke(invokeInterface, true); 2268 OP_END 2269 2270 /* File: c/OP_UNUSED_79.cpp */ 2271 HANDLE_OPCODE(OP_UNUSED_79) 2272 OP_END 2273 2274 /* File: c/OP_UNUSED_7A.cpp */ 2275 HANDLE_OPCODE(OP_UNUSED_7A) 2276 OP_END 2277 2278 /* File: c/OP_NEG_INT.cpp */ 2279 HANDLE_UNOP(OP_NEG_INT, "neg-int", -, , ) 2280 OP_END 2281 2282 /* File: c/OP_NOT_INT.cpp */ 2283 HANDLE_UNOP(OP_NOT_INT, "not-int", , ^ 0xffffffff, ) 2284 OP_END 2285 2286 /* File: c/OP_NEG_LONG.cpp */ 2287 HANDLE_UNOP(OP_NEG_LONG, "neg-long", -, , _WIDE) 2288 OP_END 2289 2290 /* File: c/OP_NOT_LONG.cpp */ 2291 HANDLE_UNOP(OP_NOT_LONG, "not-long", , ^ 0xffffffffffffffffULL, _WIDE) 2292 OP_END 2293 2294 /* File: c/OP_NEG_FLOAT.cpp */ 2295 HANDLE_UNOP(OP_NEG_FLOAT, "neg-float", -, , _FLOAT) 2296 OP_END 2297 2298 /* File: c/OP_NEG_DOUBLE.cpp */ 2299 HANDLE_UNOP(OP_NEG_DOUBLE, "neg-double", -, , _DOUBLE) 2300 OP_END 2301 2302 /* File: c/OP_INT_TO_LONG.cpp */ 2303 HANDLE_NUMCONV(OP_INT_TO_LONG, "int-to-long", _INT, _WIDE) 2304 OP_END 2305 2306 /* File: c/OP_INT_TO_FLOAT.cpp */ 2307 HANDLE_NUMCONV(OP_INT_TO_FLOAT, "int-to-float", _INT, _FLOAT) 2308 OP_END 2309 2310 /* File: c/OP_INT_TO_DOUBLE.cpp */ 2311 HANDLE_NUMCONV(OP_INT_TO_DOUBLE, "int-to-double", _INT, _DOUBLE) 2312 OP_END 2313 2314 /* File: c/OP_LONG_TO_INT.cpp */ 2315 HANDLE_NUMCONV(OP_LONG_TO_INT, "long-to-int", _WIDE, _INT) 2316 OP_END 2317 2318 /* File: c/OP_LONG_TO_FLOAT.cpp */ 2319 HANDLE_NUMCONV(OP_LONG_TO_FLOAT, "long-to-float", _WIDE, _FLOAT) 2320 OP_END 2321 2322 /* File: c/OP_LONG_TO_DOUBLE.cpp */ 2323 HANDLE_NUMCONV(OP_LONG_TO_DOUBLE, "long-to-double", _WIDE, _DOUBLE) 2324 OP_END 2325 2326 /* File: c/OP_FLOAT_TO_INT.cpp */ 2327 HANDLE_FLOAT_TO_INT(OP_FLOAT_TO_INT, "float-to-int", 2328 float, _FLOAT, s4, _INT) 2329 OP_END 2330 2331 /* File: c/OP_FLOAT_TO_LONG.cpp */ 2332 HANDLE_FLOAT_TO_INT(OP_FLOAT_TO_LONG, "float-to-long", 2333 float, _FLOAT, s8, _WIDE) 2334 OP_END 2335 2336 /* File: c/OP_FLOAT_TO_DOUBLE.cpp */ 2337 HANDLE_NUMCONV(OP_FLOAT_TO_DOUBLE, "float-to-double", _FLOAT, _DOUBLE) 2338 OP_END 2339 2340 /* File: c/OP_DOUBLE_TO_INT.cpp */ 2341 HANDLE_FLOAT_TO_INT(OP_DOUBLE_TO_INT, "double-to-int", 2342 double, _DOUBLE, s4, _INT) 2343 OP_END 2344 2345 /* File: c/OP_DOUBLE_TO_LONG.cpp */ 2346 HANDLE_FLOAT_TO_INT(OP_DOUBLE_TO_LONG, "double-to-long", 2347 double, _DOUBLE, s8, _WIDE) 2348 OP_END 2349 2350 /* File: c/OP_DOUBLE_TO_FLOAT.cpp */ 2351 HANDLE_NUMCONV(OP_DOUBLE_TO_FLOAT, "double-to-float", _DOUBLE, _FLOAT) 2352 OP_END 2353 2354 /* File: c/OP_INT_TO_BYTE.cpp */ 2355 HANDLE_INT_TO_SMALL(OP_INT_TO_BYTE, "byte", s1) 2356 OP_END 2357 2358 /* File: c/OP_INT_TO_CHAR.cpp */ 2359 HANDLE_INT_TO_SMALL(OP_INT_TO_CHAR, "char", u2) 2360 OP_END 2361 2362 /* File: c/OP_INT_TO_SHORT.cpp */ 2363 HANDLE_INT_TO_SMALL(OP_INT_TO_SHORT, "short", s2) /* want sign bit */ 2364 OP_END 2365 2366 /* File: c/OP_ADD_INT.cpp */ 2367 HANDLE_OP_X_INT(OP_ADD_INT, "add", +, 0) 2368 OP_END 2369 2370 /* File: c/OP_SUB_INT.cpp */ 2371 HANDLE_OP_X_INT(OP_SUB_INT, "sub", -, 0) 2372 OP_END 2373 2374 /* File: c/OP_MUL_INT.cpp */ 2375 HANDLE_OP_X_INT(OP_MUL_INT, "mul", *, 0) 2376 OP_END 2377 2378 /* File: c/OP_DIV_INT.cpp */ 2379 HANDLE_OP_X_INT(OP_DIV_INT, "div", /, 1) 2380 OP_END 2381 2382 /* File: c/OP_REM_INT.cpp */ 2383 HANDLE_OP_X_INT(OP_REM_INT, "rem", %, 2) 2384 OP_END 2385 2386 /* File: c/OP_AND_INT.cpp */ 2387 HANDLE_OP_X_INT(OP_AND_INT, "and", &, 0) 2388 OP_END 2389 2390 /* File: c/OP_OR_INT.cpp */ 2391 HANDLE_OP_X_INT(OP_OR_INT, "or", |, 0) 2392 OP_END 2393 2394 /* File: c/OP_XOR_INT.cpp */ 2395 HANDLE_OP_X_INT(OP_XOR_INT, "xor", ^, 0) 2396 OP_END 2397 2398 /* File: c/OP_SHL_INT.cpp */ 2399 HANDLE_OP_SHX_INT(OP_SHL_INT, "shl", (s4), <<) 2400 OP_END 2401 2402 /* File: c/OP_SHR_INT.cpp */ 2403 HANDLE_OP_SHX_INT(OP_SHR_INT, "shr", (s4), >>) 2404 OP_END 2405 2406 /* File: c/OP_USHR_INT.cpp */ 2407 HANDLE_OP_SHX_INT(OP_USHR_INT, "ushr", (u4), >>) 2408 OP_END 2409 2410 /* File: c/OP_ADD_LONG.cpp */ 2411 HANDLE_OP_X_LONG(OP_ADD_LONG, "add", +, 0) 2412 OP_END 2413 2414 /* File: c/OP_SUB_LONG.cpp */ 2415 HANDLE_OP_X_LONG(OP_SUB_LONG, "sub", -, 0) 2416 OP_END 2417 2418 /* File: c/OP_MUL_LONG.cpp */ 2419 HANDLE_OP_X_LONG(OP_MUL_LONG, "mul", *, 0) 2420 OP_END 2421 2422 /* File: c/OP_DIV_LONG.cpp */ 2423 HANDLE_OP_X_LONG(OP_DIV_LONG, "div", /, 1) 2424 OP_END 2425 2426 /* File: c/OP_REM_LONG.cpp */ 2427 HANDLE_OP_X_LONG(OP_REM_LONG, "rem", %, 2) 2428 OP_END 2429 2430 /* File: c/OP_AND_LONG.cpp */ 2431 HANDLE_OP_X_LONG(OP_AND_LONG, "and", &, 0) 2432 OP_END 2433 2434 /* File: c/OP_OR_LONG.cpp */ 2435 HANDLE_OP_X_LONG(OP_OR_LONG, "or", |, 0) 2436 OP_END 2437 2438 /* File: c/OP_XOR_LONG.cpp */ 2439 HANDLE_OP_X_LONG(OP_XOR_LONG, "xor", ^, 0) 2440 OP_END 2441 2442 /* File: c/OP_SHL_LONG.cpp */ 2443 HANDLE_OP_SHX_LONG(OP_SHL_LONG, "shl", (s8), <<) 2444 OP_END 2445 2446 /* File: c/OP_SHR_LONG.cpp */ 2447 HANDLE_OP_SHX_LONG(OP_SHR_LONG, "shr", (s8), >>) 2448 OP_END 2449 2450 /* File: c/OP_USHR_LONG.cpp */ 2451 HANDLE_OP_SHX_LONG(OP_USHR_LONG, "ushr", (u8), >>) 2452 OP_END 2453 2454 /* File: c/OP_ADD_FLOAT.cpp */ 2455 HANDLE_OP_X_FLOAT(OP_ADD_FLOAT, "add", +) 2456 OP_END 2457 2458 /* File: c/OP_SUB_FLOAT.cpp */ 2459 HANDLE_OP_X_FLOAT(OP_SUB_FLOAT, "sub", -) 2460 OP_END 2461 2462 /* File: c/OP_MUL_FLOAT.cpp */ 2463 HANDLE_OP_X_FLOAT(OP_MUL_FLOAT, "mul", *) 2464 OP_END 2465 2466 /* File: c/OP_DIV_FLOAT.cpp */ 2467 HANDLE_OP_X_FLOAT(OP_DIV_FLOAT, "div", /) 2468 OP_END 2469 2470 /* File: c/OP_REM_FLOAT.cpp */ 2471 HANDLE_OPCODE(OP_REM_FLOAT /*vAA, vBB, vCC*/) 2472 { 2473 u2 srcRegs; 2474 vdst = INST_AA(inst); 2475 srcRegs = FETCH(1); 2476 vsrc1 = srcRegs & 0xff; 2477 vsrc2 = srcRegs >> 8; 2478 ILOGV("|%s-float v%d,v%d,v%d", "mod", vdst, vsrc1, vsrc2); 2479 SET_REGISTER_FLOAT(vdst, 2480 fmodf(GET_REGISTER_FLOAT(vsrc1), GET_REGISTER_FLOAT(vsrc2))); 2481 } 2482 FINISH(2); 2483 OP_END 2484 2485 /* File: c/OP_ADD_DOUBLE.cpp */ 2486 HANDLE_OP_X_DOUBLE(OP_ADD_DOUBLE, "add", +) 2487 OP_END 2488 2489 /* File: c/OP_SUB_DOUBLE.cpp */ 2490 HANDLE_OP_X_DOUBLE(OP_SUB_DOUBLE, "sub", -) 2491 OP_END 2492 2493 /* File: c/OP_MUL_DOUBLE.cpp */ 2494 HANDLE_OP_X_DOUBLE(OP_MUL_DOUBLE, "mul", *) 2495 OP_END 2496 2497 /* File: c/OP_DIV_DOUBLE.cpp */ 2498 HANDLE_OP_X_DOUBLE(OP_DIV_DOUBLE, "div", /) 2499 OP_END 2500 2501 /* File: c/OP_REM_DOUBLE.cpp */ 2502 HANDLE_OPCODE(OP_REM_DOUBLE /*vAA, vBB, vCC*/) 2503 { 2504 u2 srcRegs; 2505 vdst = INST_AA(inst); 2506 srcRegs = FETCH(1); 2507 vsrc1 = srcRegs & 0xff; 2508 vsrc2 = srcRegs >> 8; 2509 ILOGV("|%s-double v%d,v%d,v%d", "mod", vdst, vsrc1, vsrc2); 2510 SET_REGISTER_DOUBLE(vdst, 2511 fmod(GET_REGISTER_DOUBLE(vsrc1), GET_REGISTER_DOUBLE(vsrc2))); 2512 } 2513 FINISH(2); 2514 OP_END 2515 2516 /* File: c/OP_ADD_INT_2ADDR.cpp */ 2517 HANDLE_OP_X_INT_2ADDR(OP_ADD_INT_2ADDR, "add", +, 0) 2518 OP_END 2519 2520 /* File: c/OP_SUB_INT_2ADDR.cpp */ 2521 HANDLE_OP_X_INT_2ADDR(OP_SUB_INT_2ADDR, "sub", -, 0) 2522 OP_END 2523 2524 /* File: c/OP_MUL_INT_2ADDR.cpp */ 2525 HANDLE_OP_X_INT_2ADDR(OP_MUL_INT_2ADDR, "mul", *, 0) 2526 OP_END 2527 2528 /* File: c/OP_DIV_INT_2ADDR.cpp */ 2529 HANDLE_OP_X_INT_2ADDR(OP_DIV_INT_2ADDR, "div", /, 1) 2530 OP_END 2531 2532 /* File: c/OP_REM_INT_2ADDR.cpp */ 2533 HANDLE_OP_X_INT_2ADDR(OP_REM_INT_2ADDR, "rem", %, 2) 2534 OP_END 2535 2536 /* File: c/OP_AND_INT_2ADDR.cpp */ 2537 HANDLE_OP_X_INT_2ADDR(OP_AND_INT_2ADDR, "and", &, 0) 2538 OP_END 2539 2540 /* File: c/OP_OR_INT_2ADDR.cpp */ 2541 HANDLE_OP_X_INT_2ADDR(OP_OR_INT_2ADDR, "or", |, 0) 2542 OP_END 2543 2544 /* File: c/OP_XOR_INT_2ADDR.cpp */ 2545 HANDLE_OP_X_INT_2ADDR(OP_XOR_INT_2ADDR, "xor", ^, 0) 2546 OP_END 2547 2548 /* File: c/OP_SHL_INT_2ADDR.cpp */ 2549 HANDLE_OP_SHX_INT_2ADDR(OP_SHL_INT_2ADDR, "shl", (s4), <<) 2550 OP_END 2551 2552 /* File: c/OP_SHR_INT_2ADDR.cpp */ 2553 HANDLE_OP_SHX_INT_2ADDR(OP_SHR_INT_2ADDR, "shr", (s4), >>) 2554 OP_END 2555 2556 /* File: c/OP_USHR_INT_2ADDR.cpp */ 2557 HANDLE_OP_SHX_INT_2ADDR(OP_USHR_INT_2ADDR, "ushr", (u4), >>) 2558 OP_END 2559 2560 /* File: c/OP_ADD_LONG_2ADDR.cpp */ 2561 HANDLE_OP_X_LONG_2ADDR(OP_ADD_LONG_2ADDR, "add", +, 0) 2562 OP_END 2563 2564 /* File: c/OP_SUB_LONG_2ADDR.cpp */ 2565 HANDLE_OP_X_LONG_2ADDR(OP_SUB_LONG_2ADDR, "sub", -, 0) 2566 OP_END 2567 2568 /* File: c/OP_MUL_LONG_2ADDR.cpp */ 2569 HANDLE_OP_X_LONG_2ADDR(OP_MUL_LONG_2ADDR, "mul", *, 0) 2570 OP_END 2571 2572 /* File: c/OP_DIV_LONG_2ADDR.cpp */ 2573 HANDLE_OP_X_LONG_2ADDR(OP_DIV_LONG_2ADDR, "div", /, 1) 2574 OP_END 2575 2576 /* File: c/OP_REM_LONG_2ADDR.cpp */ 2577 HANDLE_OP_X_LONG_2ADDR(OP_REM_LONG_2ADDR, "rem", %, 2) 2578 OP_END 2579 2580 /* File: c/OP_AND_LONG_2ADDR.cpp */ 2581 HANDLE_OP_X_LONG_2ADDR(OP_AND_LONG_2ADDR, "and", &, 0) 2582 OP_END 2583 2584 /* File: c/OP_OR_LONG_2ADDR.cpp */ 2585 HANDLE_OP_X_LONG_2ADDR(OP_OR_LONG_2ADDR, "or", |, 0) 2586 OP_END 2587 2588 /* File: c/OP_XOR_LONG_2ADDR.cpp */ 2589 HANDLE_OP_X_LONG_2ADDR(OP_XOR_LONG_2ADDR, "xor", ^, 0) 2590 OP_END 2591 2592 /* File: c/OP_SHL_LONG_2ADDR.cpp */ 2593 HANDLE_OP_SHX_LONG_2ADDR(OP_SHL_LONG_2ADDR, "shl", (s8), <<) 2594 OP_END 2595 2596 /* File: c/OP_SHR_LONG_2ADDR.cpp */ 2597 HANDLE_OP_SHX_LONG_2ADDR(OP_SHR_LONG_2ADDR, "shr", (s8), >>) 2598 OP_END 2599 2600 /* File: c/OP_USHR_LONG_2ADDR.cpp */ 2601 HANDLE_OP_SHX_LONG_2ADDR(OP_USHR_LONG_2ADDR, "ushr", (u8), >>) 2602 OP_END 2603 2604 /* File: c/OP_ADD_FLOAT_2ADDR.cpp */ 2605 HANDLE_OP_X_FLOAT_2ADDR(OP_ADD_FLOAT_2ADDR, "add", +) 2606 OP_END 2607 2608 /* File: c/OP_SUB_FLOAT_2ADDR.cpp */ 2609 HANDLE_OP_X_FLOAT_2ADDR(OP_SUB_FLOAT_2ADDR, "sub", -) 2610 OP_END 2611 2612 /* File: c/OP_MUL_FLOAT_2ADDR.cpp */ 2613 HANDLE_OP_X_FLOAT_2ADDR(OP_MUL_FLOAT_2ADDR, "mul", *) 2614 OP_END 2615 2616 /* File: c/OP_DIV_FLOAT_2ADDR.cpp */ 2617 HANDLE_OP_X_FLOAT_2ADDR(OP_DIV_FLOAT_2ADDR, "div", /) 2618 OP_END 2619 2620 /* File: c/OP_REM_FLOAT_2ADDR.cpp */ 2621 HANDLE_OPCODE(OP_REM_FLOAT_2ADDR /*vA, vB*/) 2622 vdst = INST_A(inst); 2623 vsrc1 = INST_B(inst); 2624 ILOGV("|%s-float-2addr v%d,v%d", "mod", vdst, vsrc1); 2625 SET_REGISTER_FLOAT(vdst, 2626 fmodf(GET_REGISTER_FLOAT(vdst), GET_REGISTER_FLOAT(vsrc1))); 2627 FINISH(1); 2628 OP_END 2629 2630 /* File: c/OP_ADD_DOUBLE_2ADDR.cpp */ 2631 HANDLE_OP_X_DOUBLE_2ADDR(OP_ADD_DOUBLE_2ADDR, "add", +) 2632 OP_END 2633 2634 /* File: c/OP_SUB_DOUBLE_2ADDR.cpp */ 2635 HANDLE_OP_X_DOUBLE_2ADDR(OP_SUB_DOUBLE_2ADDR, "sub", -) 2636 OP_END 2637 2638 /* File: c/OP_MUL_DOUBLE_2ADDR.cpp */ 2639 HANDLE_OP_X_DOUBLE_2ADDR(OP_MUL_DOUBLE_2ADDR, "mul", *) 2640 OP_END 2641 2642 /* File: c/OP_DIV_DOUBLE_2ADDR.cpp */ 2643 HANDLE_OP_X_DOUBLE_2ADDR(OP_DIV_DOUBLE_2ADDR, "div", /) 2644 OP_END 2645 2646 /* File: c/OP_REM_DOUBLE_2ADDR.cpp */ 2647 HANDLE_OPCODE(OP_REM_DOUBLE_2ADDR /*vA, vB*/) 2648 vdst = INST_A(inst); 2649 vsrc1 = INST_B(inst); 2650 ILOGV("|%s-double-2addr v%d,v%d", "mod", vdst, vsrc1); 2651 SET_REGISTER_DOUBLE(vdst, 2652 fmod(GET_REGISTER_DOUBLE(vdst), GET_REGISTER_DOUBLE(vsrc1))); 2653 FINISH(1); 2654 OP_END 2655 2656 /* File: c/OP_ADD_INT_LIT16.cpp */ 2657 HANDLE_OP_X_INT_LIT16(OP_ADD_INT_LIT16, "add", +, 0) 2658 OP_END 2659 2660 /* File: c/OP_RSUB_INT.cpp */ 2661 HANDLE_OPCODE(OP_RSUB_INT /*vA, vB, #+CCCC*/) 2662 { 2663 vdst = INST_A(inst); 2664 vsrc1 = INST_B(inst); 2665 vsrc2 = FETCH(1); 2666 ILOGV("|rsub-int v%d,v%d,#+0x%04x", vdst, vsrc1, vsrc2); 2667 SET_REGISTER(vdst, (s2) vsrc2 - (s4) GET_REGISTER(vsrc1)); 2668 } 2669 FINISH(2); 2670 OP_END 2671 2672 /* File: c/OP_MUL_INT_LIT16.cpp */ 2673 HANDLE_OP_X_INT_LIT16(OP_MUL_INT_LIT16, "mul", *, 0) 2674 OP_END 2675 2676 /* File: c/OP_DIV_INT_LIT16.cpp */ 2677 HANDLE_OP_X_INT_LIT16(OP_DIV_INT_LIT16, "div", /, 1) 2678 OP_END 2679 2680 /* File: c/OP_REM_INT_LIT16.cpp */ 2681 HANDLE_OP_X_INT_LIT16(OP_REM_INT_LIT16, "rem", %, 2) 2682 OP_END 2683 2684 /* File: c/OP_AND_INT_LIT16.cpp */ 2685 HANDLE_OP_X_INT_LIT16(OP_AND_INT_LIT16, "and", &, 0) 2686 OP_END 2687 2688 /* File: c/OP_OR_INT_LIT16.cpp */ 2689 HANDLE_OP_X_INT_LIT16(OP_OR_INT_LIT16, "or", |, 0) 2690 OP_END 2691 2692 /* File: c/OP_XOR_INT_LIT16.cpp */ 2693 HANDLE_OP_X_INT_LIT16(OP_XOR_INT_LIT16, "xor", ^, 0) 2694 OP_END 2695 2696 /* File: c/OP_ADD_INT_LIT8.cpp */ 2697 HANDLE_OP_X_INT_LIT8(OP_ADD_INT_LIT8, "add", +, 0) 2698 OP_END 2699 2700 /* File: c/OP_RSUB_INT_LIT8.cpp */ 2701 HANDLE_OPCODE(OP_RSUB_INT_LIT8 /*vAA, vBB, #+CC*/) 2702 { 2703 u2 litInfo; 2704 vdst = INST_AA(inst); 2705 litInfo = FETCH(1); 2706 vsrc1 = litInfo & 0xff; 2707 vsrc2 = litInfo >> 8; 2708 ILOGV("|%s-int/lit8 v%d,v%d,#+0x%02x", "rsub", vdst, vsrc1, vsrc2); 2709 SET_REGISTER(vdst, (s1) vsrc2 - (s4) GET_REGISTER(vsrc1)); 2710 } 2711 FINISH(2); 2712 OP_END 2713 2714 /* File: c/OP_MUL_INT_LIT8.cpp */ 2715 HANDLE_OP_X_INT_LIT8(OP_MUL_INT_LIT8, "mul", *, 0) 2716 OP_END 2717 2718 /* File: c/OP_DIV_INT_LIT8.cpp */ 2719 HANDLE_OP_X_INT_LIT8(OP_DIV_INT_LIT8, "div", /, 1) 2720 OP_END 2721 2722 /* File: c/OP_REM_INT_LIT8.cpp */ 2723 HANDLE_OP_X_INT_LIT8(OP_REM_INT_LIT8, "rem", %, 2) 2724 OP_END 2725 2726 /* File: c/OP_AND_INT_LIT8.cpp */ 2727 HANDLE_OP_X_INT_LIT8(OP_AND_INT_LIT8, "and", &, 0) 2728 OP_END 2729 2730 /* File: c/OP_OR_INT_LIT8.cpp */ 2731 HANDLE_OP_X_INT_LIT8(OP_OR_INT_LIT8, "or", |, 0) 2732 OP_END 2733 2734 /* File: c/OP_XOR_INT_LIT8.cpp */ 2735 HANDLE_OP_X_INT_LIT8(OP_XOR_INT_LIT8, "xor", ^, 0) 2736 OP_END 2737 2738 /* File: c/OP_SHL_INT_LIT8.cpp */ 2739 HANDLE_OP_SHX_INT_LIT8(OP_SHL_INT_LIT8, "shl", (s4), <<) 2740 OP_END 2741 2742 /* File: c/OP_SHR_INT_LIT8.cpp */ 2743 HANDLE_OP_SHX_INT_LIT8(OP_SHR_INT_LIT8, "shr", (s4), >>) 2744 OP_END 2745 2746 /* File: c/OP_USHR_INT_LIT8.cpp */ 2747 HANDLE_OP_SHX_INT_LIT8(OP_USHR_INT_LIT8, "ushr", (u4), >>) 2748 OP_END 2749 2750 /* File: c/OP_IGET_VOLATILE.cpp */ 2751 HANDLE_IGET_X(OP_IGET_VOLATILE, "-volatile", IntVolatile, ) 2752 OP_END 2753 2754 /* File: c/OP_IPUT_VOLATILE.cpp */ 2755 HANDLE_IPUT_X(OP_IPUT_VOLATILE, "-volatile", IntVolatile, ) 2756 OP_END 2757 2758 /* File: c/OP_SGET_VOLATILE.cpp */ 2759 HANDLE_SGET_X(OP_SGET_VOLATILE, "-volatile", IntVolatile, ) 2760 OP_END 2761 2762 /* File: c/OP_SPUT_VOLATILE.cpp */ 2763 HANDLE_SPUT_X(OP_SPUT_VOLATILE, "-volatile", IntVolatile, ) 2764 OP_END 2765 2766 /* File: c/OP_IGET_OBJECT_VOLATILE.cpp */ 2767 HANDLE_IGET_X(OP_IGET_OBJECT_VOLATILE, "-object-volatile", ObjectVolatile, _AS_OBJECT) 2768 OP_END 2769 2770 /* File: c/OP_IGET_WIDE_VOLATILE.cpp */ 2771 HANDLE_IGET_X(OP_IGET_WIDE_VOLATILE, "-wide-volatile", LongVolatile, _WIDE) 2772 OP_END 2773 2774 /* File: c/OP_IPUT_WIDE_VOLATILE.cpp */ 2775 HANDLE_IPUT_X(OP_IPUT_WIDE_VOLATILE, "-wide-volatile", LongVolatile, _WIDE) 2776 OP_END 2777 2778 /* File: c/OP_SGET_WIDE_VOLATILE.cpp */ 2779 HANDLE_SGET_X(OP_SGET_WIDE_VOLATILE, "-wide-volatile", LongVolatile, _WIDE) 2780 OP_END 2781 2782 /* File: c/OP_SPUT_WIDE_VOLATILE.cpp */ 2783 HANDLE_SPUT_X(OP_SPUT_WIDE_VOLATILE, "-wide-volatile", LongVolatile, _WIDE) 2784 OP_END 2785 2786 /* File: c/OP_BREAKPOINT.cpp */ 2787 HANDLE_OPCODE(OP_BREAKPOINT) 2788 { 2789 /* 2790 * Restart this instruction with the original opcode. We do 2791 * this by simply jumping to the handler. 2792 * 2793 * It's probably not necessary to update "inst", but we do it 2794 * for the sake of anything that needs to do disambiguation in a 2795 * common handler with INST_INST. 2796 * 2797 * The breakpoint itself is handled over in updateDebugger(), 2798 * because we need to detect other events (method entry, single 2799 * step) and report them in the same event packet, and we're not 2800 * yet handling those through breakpoint instructions. By the 2801 * time we get here, the breakpoint has already been handled and 2802 * the thread resumed. 2803 */ 2804 u1 originalOpcode = dvmGetOriginalOpcode(pc); 2805 ALOGV("+++ break 0x%02x (0x%04x -> 0x%04x)", originalOpcode, inst, 2806 INST_REPLACE_OP(inst, originalOpcode)); 2807 inst = INST_REPLACE_OP(inst, originalOpcode); 2808 FINISH_BKPT(originalOpcode); 2809 } 2810 OP_END 2811 2812 /* File: c/OP_THROW_VERIFICATION_ERROR.cpp */ 2813 HANDLE_OPCODE(OP_THROW_VERIFICATION_ERROR) 2814 EXPORT_PC(); 2815 vsrc1 = INST_AA(inst); 2816 ref = FETCH(1); /* class/field/method ref */ 2817 dvmThrowVerificationError(curMethod, vsrc1, ref); 2818 GOTO_exceptionThrown(); 2819 OP_END 2820 2821 /* File: c/OP_EXECUTE_INLINE.cpp */ 2822 HANDLE_OPCODE(OP_EXECUTE_INLINE /*vB, {vD, vE, vF, vG}, inline@CCCC*/) 2823 { 2824 /* 2825 * This has the same form as other method calls, but we ignore 2826 * the 5th argument (vA). This is chiefly because the first four 2827 * arguments to a function on ARM are in registers. 2828 * 2829 * We only set the arguments that are actually used, leaving 2830 * the rest uninitialized. We're assuming that, if the method 2831 * needs them, they'll be specified in the call. 2832 * 2833 * However, this annoys gcc when optimizations are enabled, 2834 * causing a "may be used uninitialized" warning. Quieting 2835 * the warnings incurs a slight penalty (5%: 373ns vs. 393ns 2836 * on empty method). Note that valgrind is perfectly happy 2837 * either way as the uninitialiezd values are never actually 2838 * used. 2839 */ 2840 u4 arg0, arg1, arg2, arg3; 2841 arg0 = arg1 = arg2 = arg3 = 0; 2842 2843 EXPORT_PC(); 2844 2845 vsrc1 = INST_B(inst); /* #of args */ 2846 ref = FETCH(1); /* inline call "ref" */ 2847 vdst = FETCH(2); /* 0-4 register indices */ 2848 ILOGV("|execute-inline args=%d @%d {regs=0x%04x}", 2849 vsrc1, ref, vdst); 2850 2851 assert((vdst >> 16) == 0); // 16-bit type -or- high 16 bits clear 2852 assert(vsrc1 <= 4); 2853 2854 switch (vsrc1) { 2855 case 4: 2856 arg3 = GET_REGISTER(vdst >> 12); 2857 /* fall through */ 2858 case 3: 2859 arg2 = GET_REGISTER((vdst & 0x0f00) >> 8); 2860 /* fall through */ 2861 case 2: 2862 arg1 = GET_REGISTER((vdst & 0x00f0) >> 4); 2863 /* fall through */ 2864 case 1: 2865 arg0 = GET_REGISTER(vdst & 0x0f); 2866 /* fall through */ 2867 default: // case 0 2868 ; 2869 } 2870 2871 if (self->interpBreak.ctl.subMode & kSubModeDebugProfile) { 2872 if (!dvmPerformInlineOp4Dbg(arg0, arg1, arg2, arg3, &retval, ref)) 2873 GOTO_exceptionThrown(); 2874 } else { 2875 if (!dvmPerformInlineOp4Std(arg0, arg1, arg2, arg3, &retval, ref)) 2876 GOTO_exceptionThrown(); 2877 } 2878 } 2879 FINISH(3); 2880 OP_END 2881 2882 /* File: c/OP_EXECUTE_INLINE_RANGE.cpp */ 2883 HANDLE_OPCODE(OP_EXECUTE_INLINE_RANGE /*{vCCCC..v(CCCC+AA-1)}, inline@BBBB*/) 2884 { 2885 u4 arg0, arg1, arg2, arg3; 2886 arg0 = arg1 = arg2 = arg3 = 0; /* placate gcc */ 2887 2888 EXPORT_PC(); 2889 2890 vsrc1 = INST_AA(inst); /* #of args */ 2891 ref = FETCH(1); /* inline call "ref" */ 2892 vdst = FETCH(2); /* range base */ 2893 ILOGV("|execute-inline-range args=%d @%d {regs=v%d-v%d}", 2894 vsrc1, ref, vdst, vdst+vsrc1-1); 2895 2896 assert((vdst >> 16) == 0); // 16-bit type -or- high 16 bits clear 2897 assert(vsrc1 <= 4); 2898 2899 switch (vsrc1) { 2900 case 4: 2901 arg3 = GET_REGISTER(vdst+3); 2902 /* fall through */ 2903 case 3: 2904 arg2 = GET_REGISTER(vdst+2); 2905 /* fall through */ 2906 case 2: 2907 arg1 = GET_REGISTER(vdst+1); 2908 /* fall through */ 2909 case 1: 2910 arg0 = GET_REGISTER(vdst+0); 2911 /* fall through */ 2912 default: // case 0 2913 ; 2914 } 2915 2916 if (self->interpBreak.ctl.subMode & kSubModeDebugProfile) { 2917 if (!dvmPerformInlineOp4Dbg(arg0, arg1, arg2, arg3, &retval, ref)) 2918 GOTO_exceptionThrown(); 2919 } else { 2920 if (!dvmPerformInlineOp4Std(arg0, arg1, arg2, arg3, &retval, ref)) 2921 GOTO_exceptionThrown(); 2922 } 2923 } 2924 FINISH(3); 2925 OP_END 2926 2927 /* File: c/OP_INVOKE_OBJECT_INIT_RANGE.cpp */ 2928 HANDLE_OPCODE(OP_INVOKE_OBJECT_INIT_RANGE /*{vCCCC..v(CCCC+AA-1)}, meth@BBBB*/) 2929 { 2930 Object* obj; 2931 2932 vsrc1 = FETCH(2); /* reg number of "this" pointer */ 2933 obj = GET_REGISTER_AS_OBJECT(vsrc1); 2934 2935 if (!checkForNullExportPC(obj, fp, pc)) 2936 GOTO_exceptionThrown(); 2937 2938 /* 2939 * The object should be marked "finalizable" when Object.<init> 2940 * completes normally. We're going to assume it does complete 2941 * (by virtue of being nothing but a return-void) and set it now. 2942 */ 2943 if (IS_CLASS_FLAG_SET(obj->clazz, CLASS_ISFINALIZABLE)) { 2944 EXPORT_PC(); 2945 dvmSetFinalizable(obj); 2946 if (dvmGetException(self)) 2947 GOTO_exceptionThrown(); 2948 } 2949 2950 if (self->interpBreak.ctl.subMode & kSubModeDebuggerActive) { 2951 /* behave like OP_INVOKE_DIRECT_RANGE */ 2952 GOTO_invoke(invokeDirect, true); 2953 } 2954 FINISH(3); 2955 } 2956 OP_END 2957 2958 /* File: c/OP_RETURN_VOID_BARRIER.cpp */ 2959 HANDLE_OPCODE(OP_RETURN_VOID_BARRIER /**/) 2960 ILOGV("|return-void"); 2961 #ifndef NDEBUG 2962 retval.j = 0xababababULL; /* placate valgrind */ 2963 #endif 2964 ANDROID_MEMBAR_STORE(); 2965 GOTO_returnFromMethod(); 2966 OP_END 2967 2968 /* File: c/OP_IGET_QUICK.cpp */ 2969 HANDLE_IGET_X_QUICK(OP_IGET_QUICK, "", Int, ) 2970 OP_END 2971 2972 /* File: c/OP_IGET_WIDE_QUICK.cpp */ 2973 HANDLE_IGET_X_QUICK(OP_IGET_WIDE_QUICK, "-wide", Long, _WIDE) 2974 OP_END 2975 2976 /* File: c/OP_IGET_OBJECT_QUICK.cpp */ 2977 HANDLE_IGET_X_QUICK(OP_IGET_OBJECT_QUICK, "-object", Object, _AS_OBJECT) 2978 OP_END 2979 2980 /* File: c/OP_IPUT_QUICK.cpp */ 2981 HANDLE_IPUT_X_QUICK(OP_IPUT_QUICK, "", Int, ) 2982 OP_END 2983 2984 /* File: c/OP_IPUT_WIDE_QUICK.cpp */ 2985 HANDLE_IPUT_X_QUICK(OP_IPUT_WIDE_QUICK, "-wide", Long, _WIDE) 2986 OP_END 2987 2988 /* File: c/OP_IPUT_OBJECT_QUICK.cpp */ 2989 HANDLE_IPUT_X_QUICK(OP_IPUT_OBJECT_QUICK, "-object", Object, _AS_OBJECT) 2990 OP_END 2991 2992 /* File: c/OP_INVOKE_VIRTUAL_QUICK.cpp */ 2993 HANDLE_OPCODE(OP_INVOKE_VIRTUAL_QUICK /*vB, {vD, vE, vF, vG, vA}, meth@CCCC*/) 2994 GOTO_invoke(invokeVirtualQuick, false); 2995 OP_END 2996 2997 /* File: c/OP_INVOKE_VIRTUAL_QUICK_RANGE.cpp */ 2998 HANDLE_OPCODE(OP_INVOKE_VIRTUAL_QUICK_RANGE/*{vCCCC..v(CCCC+AA-1)}, meth@BBBB*/) 2999 GOTO_invoke(invokeVirtualQuick, true); 3000 OP_END 3001 3002 /* File: c/OP_INVOKE_SUPER_QUICK.cpp */ 3003 HANDLE_OPCODE(OP_INVOKE_SUPER_QUICK /*vB, {vD, vE, vF, vG, vA}, meth@CCCC*/) 3004 GOTO_invoke(invokeSuperQuick, false); 3005 OP_END 3006 3007 /* File: c/OP_INVOKE_SUPER_QUICK_RANGE.cpp */ 3008 HANDLE_OPCODE(OP_INVOKE_SUPER_QUICK_RANGE /*{vCCCC..v(CCCC+AA-1)}, meth@BBBB*/) 3009 GOTO_invoke(invokeSuperQuick, true); 3010 OP_END 3011 3012 /* File: c/OP_IPUT_OBJECT_VOLATILE.cpp */ 3013 HANDLE_IPUT_X(OP_IPUT_OBJECT_VOLATILE, "-object-volatile", ObjectVolatile, _AS_OBJECT) 3014 OP_END 3015 3016 /* File: c/OP_SGET_OBJECT_VOLATILE.cpp */ 3017 HANDLE_SGET_X(OP_SGET_OBJECT_VOLATILE, "-object-volatile", ObjectVolatile, _AS_OBJECT) 3018 OP_END 3019 3020 /* File: c/OP_SPUT_OBJECT_VOLATILE.cpp */ 3021 HANDLE_SPUT_X(OP_SPUT_OBJECT_VOLATILE, "-object-volatile", ObjectVolatile, _AS_OBJECT) 3022 OP_END 3023 3024 /* File: c/OP_UNUSED_FF.cpp */ 3025 HANDLE_OPCODE(OP_UNUSED_FF) 3026 /* 3027 * In portable interp, most unused opcodes will fall through to here. 3028 */ 3029 ALOGE("unknown opcode 0x%02x\n", INST_INST(inst)); 3030 dvmAbort(); 3031 FINISH(1); 3032 OP_END 3033 3034 /* File: c/gotoTargets.cpp */ 3035 /* 3036 * C footer. This has some common code shared by the various targets. 3037 */ 3038 3039 /* 3040 * Everything from here on is a "goto target". In the basic interpreter 3041 * we jump into these targets and then jump directly to the handler for 3042 * next instruction. Here, these are subroutines that return to the caller. 3043 */ 3044 3045 GOTO_TARGET(filledNewArray, bool methodCallRange, bool) 3046 { 3047 ClassObject* arrayClass; 3048 ArrayObject* newArray; 3049 u4* contents; 3050 char typeCh; 3051 int i; 3052 u4 arg5; 3053 3054 EXPORT_PC(); 3055 3056 ref = FETCH(1); /* class ref */ 3057 vdst = FETCH(2); /* first 4 regs -or- range base */ 3058 3059 if (methodCallRange) { 3060 vsrc1 = INST_AA(inst); /* #of elements */ 3061 arg5 = -1; /* silence compiler warning */ 3062 ILOGV("|filled-new-array-range args=%d @0x%04x {regs=v%d-v%d}", 3063 vsrc1, ref, vdst, vdst+vsrc1-1); 3064 } else { 3065 arg5 = INST_A(inst); 3066 vsrc1 = INST_B(inst); /* #of elements */ 3067 ILOGV("|filled-new-array args=%d @0x%04x {regs=0x%04x %x}", 3068 vsrc1, ref, vdst, arg5); 3069 } 3070 3071 /* 3072 * Resolve the array class. 3073 */ 3074 arrayClass = dvmDexGetResolvedClass(methodClassDex, ref); 3075 if (arrayClass == NULL) { 3076 arrayClass = dvmResolveClass(curMethod->clazz, ref, false); 3077 if (arrayClass == NULL) 3078 GOTO_exceptionThrown(); 3079 } 3080 /* 3081 if (!dvmIsArrayClass(arrayClass)) { 3082 dvmThrowRuntimeException( 3083 "filled-new-array needs array class"); 3084 GOTO_exceptionThrown(); 3085 } 3086 */ 3087 /* verifier guarantees this is an array class */ 3088 assert(dvmIsArrayClass(arrayClass)); 3089 assert(dvmIsClassInitialized(arrayClass)); 3090 3091 /* 3092 * Create an array of the specified type. 3093 */ 3094 LOGVV("+++ filled-new-array type is '%s'", arrayClass->descriptor); 3095 typeCh = arrayClass->descriptor[1]; 3096 if (typeCh == 'D' || typeCh == 'J') { 3097 /* category 2 primitives not allowed */ 3098 dvmThrowRuntimeException("bad filled array req"); 3099 GOTO_exceptionThrown(); 3100 } else if (typeCh != 'L' && typeCh != '[' && typeCh != 'I') { 3101 /* TODO: requires multiple "fill in" loops with different widths */ 3102 ALOGE("non-int primitives not implemented"); 3103 dvmThrowInternalError( 3104 "filled-new-array not implemented for anything but 'int'"); 3105 GOTO_exceptionThrown(); 3106 } 3107 3108 newArray = dvmAllocArrayByClass(arrayClass, vsrc1, ALLOC_DONT_TRACK); 3109 if (newArray == NULL) 3110 GOTO_exceptionThrown(); 3111 3112 /* 3113 * Fill in the elements. It's legal for vsrc1 to be zero. 3114 */ 3115 contents = (u4*)(void*)newArray->contents; 3116 if (methodCallRange) { 3117 for (i = 0; i < vsrc1; i++) 3118 contents[i] = GET_REGISTER(vdst+i); 3119 } else { 3120 assert(vsrc1 <= 5); 3121 if (vsrc1 == 5) { 3122 contents[4] = GET_REGISTER(arg5); 3123 vsrc1--; 3124 } 3125 for (i = 0; i < vsrc1; i++) { 3126 contents[i] = GET_REGISTER(vdst & 0x0f); 3127 vdst >>= 4; 3128 } 3129 } 3130 if (typeCh == 'L' || typeCh == '[') { 3131 dvmWriteBarrierArray(newArray, 0, newArray->length); 3132 } 3133 3134 retval.l = (Object*)newArray; 3135 } 3136 FINISH(3); 3137 GOTO_TARGET_END 3138 3139 3140 GOTO_TARGET(invokeVirtual, bool methodCallRange, bool) 3141 { 3142 Method* baseMethod; 3143 Object* thisPtr; 3144 3145 EXPORT_PC(); 3146 3147 vsrc1 = INST_AA(inst); /* AA (count) or BA (count + arg 5) */ 3148 ref = FETCH(1); /* method ref */ 3149 vdst = FETCH(2); /* 4 regs -or- first reg */ 3150 3151 /* 3152 * The object against which we are executing a method is always 3153 * in the first argument. 3154 */ 3155 if (methodCallRange) { 3156 assert(vsrc1 > 0); 3157 ILOGV("|invoke-virtual-range args=%d @0x%04x {regs=v%d-v%d}", 3158 vsrc1, ref, vdst, vdst+vsrc1-1); 3159 thisPtr = (Object*) GET_REGISTER(vdst); 3160 } else { 3161 assert((vsrc1>>4) > 0); 3162 ILOGV("|invoke-virtual args=%d @0x%04x {regs=0x%04x %x}", 3163 vsrc1 >> 4, ref, vdst, vsrc1 & 0x0f); 3164 thisPtr = (Object*) GET_REGISTER(vdst & 0x0f); 3165 } 3166 3167 if (!checkForNull(thisPtr)) 3168 GOTO_exceptionThrown(); 3169 3170 /* 3171 * Resolve the method. This is the correct method for the static 3172 * type of the object. We also verify access permissions here. 3173 */ 3174 baseMethod = dvmDexGetResolvedMethod(methodClassDex, ref); 3175 if (baseMethod == NULL) { 3176 baseMethod = dvmResolveMethod(curMethod->clazz, ref,METHOD_VIRTUAL); 3177 if (baseMethod == NULL) { 3178 ILOGV("+ unknown method or access denied"); 3179 GOTO_exceptionThrown(); 3180 } 3181 } 3182 3183 /* 3184 * Combine the object we found with the vtable offset in the 3185 * method. 3186 */ 3187 assert(baseMethod->methodIndex < thisPtr->clazz->vtableCount); 3188 methodToCall = thisPtr->clazz->vtable[baseMethod->methodIndex]; 3189 3190 #if defined(WITH_JIT) && defined(MTERP_STUB) 3191 self->methodToCall = methodToCall; 3192 self->callsiteClass = thisPtr->clazz; 3193 #endif 3194 3195 #if 0 3196 if (dvmIsAbstractMethod(methodToCall)) { 3197 /* 3198 * This can happen if you create two classes, Base and Sub, where 3199 * Sub is a sub-class of Base. Declare a protected abstract 3200 * method foo() in Base, and invoke foo() from a method in Base. 3201 * Base is an "abstract base class" and is never instantiated 3202 * directly. Now, Override foo() in Sub, and use Sub. This 3203 * Works fine unless Sub stops providing an implementation of 3204 * the method. 3205 */ 3206 dvmThrowAbstractMethodError("abstract method not implemented"); 3207 GOTO_exceptionThrown(); 3208 } 3209 #else 3210 assert(!dvmIsAbstractMethod(methodToCall) || 3211 methodToCall->nativeFunc != NULL); 3212 #endif 3213 3214 LOGVV("+++ base=%s.%s virtual[%d]=%s.%s", 3215 baseMethod->clazz->descriptor, baseMethod->name, 3216 (u4) baseMethod->methodIndex, 3217 methodToCall->clazz->descriptor, methodToCall->name); 3218 assert(methodToCall != NULL); 3219 3220 #if 0 3221 if (vsrc1 != methodToCall->insSize) { 3222 ALOGW("WRONG METHOD: base=%s.%s virtual[%d]=%s.%s", 3223 baseMethod->clazz->descriptor, baseMethod->name, 3224 (u4) baseMethod->methodIndex, 3225 methodToCall->clazz->descriptor, methodToCall->name); 3226 //dvmDumpClass(baseMethod->clazz); 3227 //dvmDumpClass(methodToCall->clazz); 3228 dvmDumpAllClasses(0); 3229 } 3230 #endif 3231 3232 GOTO_invokeMethod(methodCallRange, methodToCall, vsrc1, vdst); 3233 } 3234 GOTO_TARGET_END 3235 3236 GOTO_TARGET(invokeSuper, bool methodCallRange) 3237 { 3238 Method* baseMethod; 3239 u2 thisReg; 3240 3241 EXPORT_PC(); 3242 3243 vsrc1 = INST_AA(inst); /* AA (count) or BA (count + arg 5) */ 3244 ref = FETCH(1); /* method ref */ 3245 vdst = FETCH(2); /* 4 regs -or- first reg */ 3246 3247 if (methodCallRange) { 3248 ILOGV("|invoke-super-range args=%d @0x%04x {regs=v%d-v%d}", 3249 vsrc1, ref, vdst, vdst+vsrc1-1); 3250 thisReg = vdst; 3251 } else { 3252 ILOGV("|invoke-super args=%d @0x%04x {regs=0x%04x %x}", 3253 vsrc1 >> 4, ref, vdst, vsrc1 & 0x0f); 3254 thisReg = vdst & 0x0f; 3255 } 3256 3257 /* impossible in well-formed code, but we must check nevertheless */ 3258 if (!checkForNull((Object*) GET_REGISTER(thisReg))) 3259 GOTO_exceptionThrown(); 3260 3261 /* 3262 * Resolve the method. This is the correct method for the static 3263 * type of the object. We also verify access permissions here. 3264 * The first arg to dvmResolveMethod() is just the referring class 3265 * (used for class loaders and such), so we don't want to pass 3266 * the superclass into the resolution call. 3267 */ 3268 baseMethod = dvmDexGetResolvedMethod(methodClassDex, ref); 3269 if (baseMethod == NULL) { 3270 baseMethod = dvmResolveMethod(curMethod->clazz, ref,METHOD_VIRTUAL); 3271 if (baseMethod == NULL) { 3272 ILOGV("+ unknown method or access denied"); 3273 GOTO_exceptionThrown(); 3274 } 3275 } 3276 3277 /* 3278 * Combine the object we found with the vtable offset in the 3279 * method's class. 3280 * 3281 * We're using the current method's class' superclass, not the 3282 * superclass of "this". This is because we might be executing 3283 * in a method inherited from a superclass, and we want to run 3284 * in that class' superclass. 3285 */ 3286 if (baseMethod->methodIndex >= curMethod->clazz->super->vtableCount) { 3287 /* 3288 * Method does not exist in the superclass. Could happen if 3289 * superclass gets updated. 3290 */ 3291 dvmThrowNoSuchMethodError(baseMethod->name); 3292 GOTO_exceptionThrown(); 3293 } 3294 methodToCall = curMethod->clazz->super->vtable[baseMethod->methodIndex]; 3295 3296 #if 0 3297 if (dvmIsAbstractMethod(methodToCall)) { 3298 dvmThrowAbstractMethodError("abstract method not implemented"); 3299 GOTO_exceptionThrown(); 3300 } 3301 #else 3302 assert(!dvmIsAbstractMethod(methodToCall) || 3303 methodToCall->nativeFunc != NULL); 3304 #endif 3305 LOGVV("+++ base=%s.%s super-virtual=%s.%s", 3306 baseMethod->clazz->descriptor, baseMethod->name, 3307 methodToCall->clazz->descriptor, methodToCall->name); 3308 assert(methodToCall != NULL); 3309 3310 GOTO_invokeMethod(methodCallRange, methodToCall, vsrc1, vdst); 3311 } 3312 GOTO_TARGET_END 3313 3314 GOTO_TARGET(invokeInterface, bool methodCallRange) 3315 { 3316 Object* thisPtr; 3317 ClassObject* thisClass; 3318 3319 EXPORT_PC(); 3320 3321 vsrc1 = INST_AA(inst); /* AA (count) or BA (count + arg 5) */ 3322 ref = FETCH(1); /* method ref */ 3323 vdst = FETCH(2); /* 4 regs -or- first reg */ 3324 3325 /* 3326 * The object against which we are executing a method is always 3327 * in the first argument. 3328 */ 3329 if (methodCallRange) { 3330 assert(vsrc1 > 0); 3331 ILOGV("|invoke-interface-range args=%d @0x%04x {regs=v%d-v%d}", 3332 vsrc1, ref, vdst, vdst+vsrc1-1); 3333 thisPtr = (Object*) GET_REGISTER(vdst); 3334 } else { 3335 assert((vsrc1>>4) > 0); 3336 ILOGV("|invoke-interface args=%d @0x%04x {regs=0x%04x %x}", 3337 vsrc1 >> 4, ref, vdst, vsrc1 & 0x0f); 3338 thisPtr = (Object*) GET_REGISTER(vdst & 0x0f); 3339 } 3340 3341 if (!checkForNull(thisPtr)) 3342 GOTO_exceptionThrown(); 3343 3344 thisClass = thisPtr->clazz; 3345 3346 /* 3347 * Given a class and a method index, find the Method* with the 3348 * actual code we want to execute. 3349 */ 3350 methodToCall = dvmFindInterfaceMethodInCache(thisClass, ref, curMethod, 3351 methodClassDex); 3352 #if defined(WITH_JIT) && defined(MTERP_STUB) 3353 self->callsiteClass = thisClass; 3354 self->methodToCall = methodToCall; 3355 #endif 3356 if (methodToCall == NULL) { 3357 assert(dvmCheckException(self)); 3358 GOTO_exceptionThrown(); 3359 } 3360 3361 GOTO_invokeMethod(methodCallRange, methodToCall, vsrc1, vdst); 3362 } 3363 GOTO_TARGET_END 3364 3365 GOTO_TARGET(invokeDirect, bool methodCallRange) 3366 { 3367 u2 thisReg; 3368 3369 EXPORT_PC(); 3370 3371 vsrc1 = INST_AA(inst); /* AA (count) or BA (count + arg 5) */ 3372 ref = FETCH(1); /* method ref */ 3373 vdst = FETCH(2); /* 4 regs -or- first reg */ 3374 3375 if (methodCallRange) { 3376 ILOGV("|invoke-direct-range args=%d @0x%04x {regs=v%d-v%d}", 3377 vsrc1, ref, vdst, vdst+vsrc1-1); 3378 thisReg = vdst; 3379 } else { 3380 ILOGV("|invoke-direct args=%d @0x%04x {regs=0x%04x %x}", 3381 vsrc1 >> 4, ref, vdst, vsrc1 & 0x0f); 3382 thisReg = vdst & 0x0f; 3383 } 3384 3385 if (!checkForNull((Object*) GET_REGISTER(thisReg))) 3386 GOTO_exceptionThrown(); 3387 3388 methodToCall = dvmDexGetResolvedMethod(methodClassDex, ref); 3389 if (methodToCall == NULL) { 3390 methodToCall = dvmResolveMethod(curMethod->clazz, ref, 3391 METHOD_DIRECT); 3392 if (methodToCall == NULL) { 3393 ILOGV("+ unknown direct method"); // should be impossible 3394 GOTO_exceptionThrown(); 3395 } 3396 } 3397 GOTO_invokeMethod(methodCallRange, methodToCall, vsrc1, vdst); 3398 } 3399 GOTO_TARGET_END 3400 3401 GOTO_TARGET(invokeStatic, bool methodCallRange) 3402 EXPORT_PC(); 3403 3404 vsrc1 = INST_AA(inst); /* AA (count) or BA (count + arg 5) */ 3405 ref = FETCH(1); /* method ref */ 3406 vdst = FETCH(2); /* 4 regs -or- first reg */ 3407 3408 if (methodCallRange) 3409 ILOGV("|invoke-static-range args=%d @0x%04x {regs=v%d-v%d}", 3410 vsrc1, ref, vdst, vdst+vsrc1-1); 3411 else 3412 ILOGV("|invoke-static args=%d @0x%04x {regs=0x%04x %x}", 3413 vsrc1 >> 4, ref, vdst, vsrc1 & 0x0f); 3414 3415 methodToCall = dvmDexGetResolvedMethod(methodClassDex, ref); 3416 if (methodToCall == NULL) { 3417 methodToCall = dvmResolveMethod(curMethod->clazz, ref, METHOD_STATIC); 3418 if (methodToCall == NULL) { 3419 ILOGV("+ unknown method"); 3420 GOTO_exceptionThrown(); 3421 } 3422 3423 #if defined(WITH_JIT) && defined(MTERP_STUB) 3424 /* 3425 * The JIT needs dvmDexGetResolvedMethod() to return non-null. 3426 * Include the check if this code is being used as a stub 3427 * called from the assembly interpreter. 3428 */ 3429 if ((self->interpBreak.ctl.subMode & kSubModeJitTraceBuild) && 3430 (dvmDexGetResolvedMethod(methodClassDex, ref) == NULL)) { 3431 /* Class initialization is still ongoing */ 3432 dvmJitEndTraceSelect(self,pc); 3433 } 3434 #endif 3435 } 3436 GOTO_invokeMethod(methodCallRange, methodToCall, vsrc1, vdst); 3437 GOTO_TARGET_END 3438 3439 GOTO_TARGET(invokeVirtualQuick, bool methodCallRange) 3440 { 3441 Object* thisPtr; 3442 3443 EXPORT_PC(); 3444 3445 vsrc1 = INST_AA(inst); /* AA (count) or BA (count + arg 5) */ 3446 ref = FETCH(1); /* vtable index */ 3447 vdst = FETCH(2); /* 4 regs -or- first reg */ 3448 3449 /* 3450 * The object against which we are executing a method is always 3451 * in the first argument. 3452 */ 3453 if (methodCallRange) { 3454 assert(vsrc1 > 0); 3455 ILOGV("|invoke-virtual-quick-range args=%d @0x%04x {regs=v%d-v%d}", 3456 vsrc1, ref, vdst, vdst+vsrc1-1); 3457 thisPtr = (Object*) GET_REGISTER(vdst); 3458 } else { 3459 assert((vsrc1>>4) > 0); 3460 ILOGV("|invoke-virtual-quick args=%d @0x%04x {regs=0x%04x %x}", 3461 vsrc1 >> 4, ref, vdst, vsrc1 & 0x0f); 3462 thisPtr = (Object*) GET_REGISTER(vdst & 0x0f); 3463 } 3464 3465 if (!checkForNull(thisPtr)) 3466 GOTO_exceptionThrown(); 3467 3468 3469 /* 3470 * Combine the object we found with the vtable offset in the 3471 * method. 3472 */ 3473 assert(ref < (unsigned int) thisPtr->clazz->vtableCount); 3474 methodToCall = thisPtr->clazz->vtable[ref]; 3475 #if defined(WITH_JIT) && defined(MTERP_STUB) 3476 self->callsiteClass = thisPtr->clazz; 3477 self->methodToCall = methodToCall; 3478 #endif 3479 3480 #if 0 3481 if (dvmIsAbstractMethod(methodToCall)) { 3482 dvmThrowAbstractMethodError("abstract method not implemented"); 3483 GOTO_exceptionThrown(); 3484 } 3485 #else 3486 assert(!dvmIsAbstractMethod(methodToCall) || 3487 methodToCall->nativeFunc != NULL); 3488 #endif 3489 3490 LOGVV("+++ virtual[%d]=%s.%s", 3491 ref, methodToCall->clazz->descriptor, methodToCall->name); 3492 assert(methodToCall != NULL); 3493 3494 GOTO_invokeMethod(methodCallRange, methodToCall, vsrc1, vdst); 3495 } 3496 GOTO_TARGET_END 3497 3498 GOTO_TARGET(invokeSuperQuick, bool methodCallRange) 3499 { 3500 u2 thisReg; 3501 3502 EXPORT_PC(); 3503 3504 vsrc1 = INST_AA(inst); /* AA (count) or BA (count + arg 5) */ 3505 ref = FETCH(1); /* vtable index */ 3506 vdst = FETCH(2); /* 4 regs -or- first reg */ 3507 3508 if (methodCallRange) { 3509 ILOGV("|invoke-super-quick-range args=%d @0x%04x {regs=v%d-v%d}", 3510 vsrc1, ref, vdst, vdst+vsrc1-1); 3511 thisReg = vdst; 3512 } else { 3513 ILOGV("|invoke-super-quick args=%d @0x%04x {regs=0x%04x %x}", 3514 vsrc1 >> 4, ref, vdst, vsrc1 & 0x0f); 3515 thisReg = vdst & 0x0f; 3516 } 3517 /* impossible in well-formed code, but we must check nevertheless */ 3518 if (!checkForNull((Object*) GET_REGISTER(thisReg))) 3519 GOTO_exceptionThrown(); 3520 3521 #if 0 /* impossible in optimized + verified code */ 3522 if (ref >= curMethod->clazz->super->vtableCount) { 3523 dvmThrowNoSuchMethodError(NULL); 3524 GOTO_exceptionThrown(); 3525 } 3526 #else 3527 assert(ref < (unsigned int) curMethod->clazz->super->vtableCount); 3528 #endif 3529 3530 /* 3531 * Combine the object we found with the vtable offset in the 3532 * method's class. 3533 * 3534 * We're using the current method's class' superclass, not the 3535 * superclass of "this". This is because we might be executing 3536 * in a method inherited from a superclass, and we want to run 3537 * in the method's class' superclass. 3538 */ 3539 methodToCall = curMethod->clazz->super->vtable[ref]; 3540 3541 #if 0 3542 if (dvmIsAbstractMethod(methodToCall)) { 3543 dvmThrowAbstractMethodError("abstract method not implemented"); 3544 GOTO_exceptionThrown(); 3545 } 3546 #else 3547 assert(!dvmIsAbstractMethod(methodToCall) || 3548 methodToCall->nativeFunc != NULL); 3549 #endif 3550 LOGVV("+++ super-virtual[%d]=%s.%s", 3551 ref, methodToCall->clazz->descriptor, methodToCall->name); 3552 assert(methodToCall != NULL); 3553 GOTO_invokeMethod(methodCallRange, methodToCall, vsrc1, vdst); 3554 } 3555 GOTO_TARGET_END 3556 3557 3558 /* 3559 * General handling for return-void, return, and return-wide. Put the 3560 * return value in "retval" before jumping here. 3561 */ 3562 GOTO_TARGET(returnFromMethod) 3563 { 3564 StackSaveArea* saveArea; 3565 3566 /* 3567 * We must do this BEFORE we pop the previous stack frame off, so 3568 * that the GC can see the return value (if any) in the local vars. 3569 * 3570 * Since this is now an interpreter switch point, we must do it before 3571 * we do anything at all. 3572 */ 3573 PERIODIC_CHECKS(0); 3574 3575 ILOGV("> retval=0x%llx (leaving %s.%s %s)", 3576 retval.j, curMethod->clazz->descriptor, curMethod->name, 3577 curMethod->shorty); 3578 //DUMP_REGS(curMethod, fp); 3579 3580 saveArea = SAVEAREA_FROM_FP(fp); 3581 3582 #ifdef EASY_GDB 3583 debugSaveArea = saveArea; 3584 #endif 3585 3586 /* back up to previous frame and see if we hit a break */ 3587 fp = (u4*)saveArea->prevFrame; 3588 assert(fp != NULL); 3589 3590 /* Handle any special subMode requirements */ 3591 if (self->interpBreak.ctl.subMode != 0) { 3592 PC_FP_TO_SELF(); 3593 dvmReportReturn(self); 3594 } 3595 3596 if (dvmIsBreakFrame(fp)) { 3597 /* bail without popping the method frame from stack */ 3598 LOGVV("+++ returned into break frame"); 3599 GOTO_bail(); 3600 } 3601 3602 /* update thread FP, and reset local variables */ 3603 self->interpSave.curFrame = fp; 3604 curMethod = SAVEAREA_FROM_FP(fp)->method; 3605 self->interpSave.method = curMethod; 3606 //methodClass = curMethod->clazz; 3607 methodClassDex = curMethod->clazz->pDvmDex; 3608 pc = saveArea->savedPc; 3609 ILOGD("> (return to %s.%s %s)", curMethod->clazz->descriptor, 3610 curMethod->name, curMethod->shorty); 3611 3612 /* use FINISH on the caller's invoke instruction */ 3613 //u2 invokeInstr = INST_INST(FETCH(0)); 3614 if (true /*invokeInstr >= OP_INVOKE_VIRTUAL && 3615 invokeInstr <= OP_INVOKE_INTERFACE*/) 3616 { 3617 FINISH(3); 3618 } else { 3619 //ALOGE("Unknown invoke instr %02x at %d", 3620 // invokeInstr, (int) (pc - curMethod->insns)); 3621 assert(false); 3622 } 3623 } 3624 GOTO_TARGET_END 3625 3626 3627 /* 3628 * Jump here when the code throws an exception. 3629 * 3630 * By the time we get here, the Throwable has been created and the stack 3631 * trace has been saved off. 3632 */ 3633 GOTO_TARGET(exceptionThrown) 3634 { 3635 Object* exception; 3636 int catchRelPc; 3637 3638 PERIODIC_CHECKS(0); 3639 3640 /* 3641 * We save off the exception and clear the exception status. While 3642 * processing the exception we might need to load some Throwable 3643 * classes, and we don't want class loader exceptions to get 3644 * confused with this one. 3645 */ 3646 assert(dvmCheckException(self)); 3647 exception = dvmGetException(self); 3648 dvmAddTrackedAlloc(exception, self); 3649 dvmClearException(self); 3650 3651 ALOGV("Handling exception %s at %s:%d", 3652 exception->clazz->descriptor, curMethod->name, 3653 dvmLineNumFromPC(curMethod, pc - curMethod->insns)); 3654 3655 /* 3656 * Report the exception throw to any "subMode" watchers. 3657 * 3658 * TODO: if the exception was thrown by interpreted code, control 3659 * fell through native, and then back to us, we will report the 3660 * exception at the point of the throw and again here. We can avoid 3661 * this by not reporting exceptions when we jump here directly from 3662 * the native call code above, but then we won't report exceptions 3663 * that were thrown *from* the JNI code (as opposed to *through* it). 3664 * 3665 * The correct solution is probably to ignore from-native exceptions 3666 * here, and have the JNI exception code do the reporting to the 3667 * debugger. 3668 */ 3669 if (self->interpBreak.ctl.subMode != 0) { 3670 PC_FP_TO_SELF(); 3671 dvmReportExceptionThrow(self, exception); 3672 } 3673 3674 /* 3675 * We need to unroll to the catch block or the nearest "break" 3676 * frame. 3677 * 3678 * A break frame could indicate that we have reached an intermediate 3679 * native call, or have gone off the top of the stack and the thread 3680 * needs to exit. Either way, we return from here, leaving the 3681 * exception raised. 3682 * 3683 * If we do find a catch block, we want to transfer execution to 3684 * that point. 3685 * 3686 * Note this can cause an exception while resolving classes in 3687 * the "catch" blocks. 3688 */ 3689 catchRelPc = dvmFindCatchBlock(self, pc - curMethod->insns, 3690 exception, false, (void**)(void*)&fp); 3691 3692 /* 3693 * Restore the stack bounds after an overflow. This isn't going to 3694 * be correct in all circumstances, e.g. if JNI code devours the 3695 * exception this won't happen until some other exception gets 3696 * thrown. If the code keeps pushing the stack bounds we'll end 3697 * up aborting the VM. 3698 * 3699 * Note we want to do this *after* the call to dvmFindCatchBlock, 3700 * because that may need extra stack space to resolve exception 3701 * classes (e.g. through a class loader). 3702 * 3703 * It's possible for the stack overflow handling to cause an 3704 * exception (specifically, class resolution in a "catch" block 3705 * during the call above), so we could see the thread's overflow 3706 * flag raised but actually be running in a "nested" interpreter 3707 * frame. We don't allow doubled-up StackOverflowErrors, so 3708 * we can check for this by just looking at the exception type 3709 * in the cleanup function. Also, we won't unroll past the SOE 3710 * point because the more-recent exception will hit a break frame 3711 * as it unrolls to here. 3712 */ 3713 if (self->stackOverflowed) 3714 dvmCleanupStackOverflow(self, exception); 3715 3716 if (catchRelPc < 0) { 3717 /* falling through to JNI code or off the bottom of the stack */ 3718 #if DVM_SHOW_EXCEPTION >= 2 3719 ALOGD("Exception %s from %s:%d not caught locally", 3720 exception->clazz->descriptor, dvmGetMethodSourceFile(curMethod), 3721 dvmLineNumFromPC(curMethod, pc - curMethod->insns)); 3722 #endif 3723 dvmSetException(self, exception); 3724 dvmReleaseTrackedAlloc(exception, self); 3725 GOTO_bail(); 3726 } 3727 3728 #if DVM_SHOW_EXCEPTION >= 3 3729 { 3730 const Method* catchMethod = SAVEAREA_FROM_FP(fp)->method; 3731 ALOGD("Exception %s thrown from %s:%d to %s:%d", 3732 exception->clazz->descriptor, dvmGetMethodSourceFile(curMethod), 3733 dvmLineNumFromPC(curMethod, pc - curMethod->insns), 3734 dvmGetMethodSourceFile(catchMethod), 3735 dvmLineNumFromPC(catchMethod, catchRelPc)); 3736 } 3737 #endif 3738 3739 /* 3740 * Adjust local variables to match self->interpSave.curFrame and the 3741 * updated PC. 3742 */ 3743 //fp = (u4*) self->interpSave.curFrame; 3744 curMethod = SAVEAREA_FROM_FP(fp)->method; 3745 self->interpSave.method = curMethod; 3746 //methodClass = curMethod->clazz; 3747 methodClassDex = curMethod->clazz->pDvmDex; 3748 pc = curMethod->insns + catchRelPc; 3749 ILOGV("> pc <-- %s.%s %s", curMethod->clazz->descriptor, 3750 curMethod->name, curMethod->shorty); 3751 DUMP_REGS(curMethod, fp, false); // show all regs 3752 3753 /* 3754 * Restore the exception if the handler wants it. 3755 * 3756 * The Dalvik spec mandates that, if an exception handler wants to 3757 * do something with the exception, the first instruction executed 3758 * must be "move-exception". We can pass the exception along 3759 * through the thread struct, and let the move-exception instruction 3760 * clear it for us. 3761 * 3762 * If the handler doesn't call move-exception, we don't want to 3763 * finish here with an exception still pending. 3764 */ 3765 if (INST_INST(FETCH(0)) == OP_MOVE_EXCEPTION) 3766 dvmSetException(self, exception); 3767 3768 dvmReleaseTrackedAlloc(exception, self); 3769 FINISH(0); 3770 } 3771 GOTO_TARGET_END 3772 3773 3774 3775 /* 3776 * General handling for invoke-{virtual,super,direct,static,interface}, 3777 * including "quick" variants. 3778 * 3779 * Set "methodToCall" to the Method we're calling, and "methodCallRange" 3780 * depending on whether this is a "/range" instruction. 3781 * 3782 * For a range call: 3783 * "vsrc1" holds the argument count (8 bits) 3784 * "vdst" holds the first argument in the range 3785 * For a non-range call: 3786 * "vsrc1" holds the argument count (4 bits) and the 5th argument index 3787 * "vdst" holds four 4-bit register indices 3788 * 3789 * The caller must EXPORT_PC before jumping here, because any method 3790 * call can throw a stack overflow exception. 3791 */ 3792 GOTO_TARGET(invokeMethod, bool methodCallRange, const Method* _methodToCall, 3793 u2 count, u2 regs) 3794 { 3795 STUB_HACK(vsrc1 = count; vdst = regs; methodToCall = _methodToCall;); 3796 3797 //printf("range=%d call=%p count=%d regs=0x%04x\n", 3798 // methodCallRange, methodToCall, count, regs); 3799 //printf(" --> %s.%s %s\n", methodToCall->clazz->descriptor, 3800 // methodToCall->name, methodToCall->shorty); 3801 3802 u4* outs; 3803 int i; 3804 3805 /* 3806 * Copy args. This may corrupt vsrc1/vdst. 3807 */ 3808 if (methodCallRange) { 3809 // could use memcpy or a "Duff's device"; most functions have 3810 // so few args it won't matter much 3811 assert(vsrc1 <= curMethod->outsSize); 3812 assert(vsrc1 == methodToCall->insSize); 3813 outs = OUTS_FROM_FP(fp, vsrc1); 3814 for (i = 0; i < vsrc1; i++) 3815 outs[i] = GET_REGISTER(vdst+i); 3816 } else { 3817 u4 count = vsrc1 >> 4; 3818 3819 assert(count <= curMethod->outsSize); 3820 assert(count == methodToCall->insSize); 3821 assert(count <= 5); 3822 3823 outs = OUTS_FROM_FP(fp, count); 3824 #if 0 3825 if (count == 5) { 3826 outs[4] = GET_REGISTER(vsrc1 & 0x0f); 3827 count--; 3828 } 3829 for (i = 0; i < (int) count; i++) { 3830 outs[i] = GET_REGISTER(vdst & 0x0f); 3831 vdst >>= 4; 3832 } 3833 #else 3834 // This version executes fewer instructions but is larger 3835 // overall. Seems to be a teensy bit faster. 3836 assert((vdst >> 16) == 0); // 16 bits -or- high 16 bits clear 3837 switch (count) { 3838 case 5: 3839 outs[4] = GET_REGISTER(vsrc1 & 0x0f); 3840 case 4: 3841 outs[3] = GET_REGISTER(vdst >> 12); 3842 case 3: 3843 outs[2] = GET_REGISTER((vdst & 0x0f00) >> 8); 3844 case 2: 3845 outs[1] = GET_REGISTER((vdst & 0x00f0) >> 4); 3846 case 1: 3847 outs[0] = GET_REGISTER(vdst & 0x0f); 3848 default: 3849 ; 3850 } 3851 #endif 3852 } 3853 } 3854 3855 /* 3856 * (This was originally a "goto" target; I've kept it separate from the 3857 * stuff above in case we want to refactor things again.) 3858 * 3859 * At this point, we have the arguments stored in the "outs" area of 3860 * the current method's stack frame, and the method to call in 3861 * "methodToCall". Push a new stack frame. 3862 */ 3863 { 3864 StackSaveArea* newSaveArea; 3865 u4* newFp; 3866 3867 ILOGV("> %s%s.%s %s", 3868 dvmIsNativeMethod(methodToCall) ? "(NATIVE) " : "", 3869 methodToCall->clazz->descriptor, methodToCall->name, 3870 methodToCall->shorty); 3871 3872 newFp = (u4*) SAVEAREA_FROM_FP(fp) - methodToCall->registersSize; 3873 newSaveArea = SAVEAREA_FROM_FP(newFp); 3874 3875 /* verify that we have enough space */ 3876 if (true) { 3877 u1* bottom; 3878 bottom = (u1*) newSaveArea - methodToCall->outsSize * sizeof(u4); 3879 if (bottom < self->interpStackEnd) { 3880 /* stack overflow */ 3881 ALOGV("Stack overflow on method call (start=%p end=%p newBot=%p(%d) size=%d '%s')", 3882 self->interpStackStart, self->interpStackEnd, bottom, 3883 (u1*) fp - bottom, self->interpStackSize, 3884 methodToCall->name); 3885 dvmHandleStackOverflow(self, methodToCall); 3886 assert(dvmCheckException(self)); 3887 GOTO_exceptionThrown(); 3888 } 3889 //ALOGD("+++ fp=%p newFp=%p newSave=%p bottom=%p", 3890 // fp, newFp, newSaveArea, bottom); 3891 } 3892 3893 #ifdef LOG_INSTR 3894 if (methodToCall->registersSize > methodToCall->insSize) { 3895 /* 3896 * This makes valgrind quiet when we print registers that 3897 * haven't been initialized. Turn it off when the debug 3898 * messages are disabled -- we want valgrind to report any 3899 * used-before-initialized issues. 3900 */ 3901 memset(newFp, 0xcc, 3902 (methodToCall->registersSize - methodToCall->insSize) * 4); 3903 } 3904 #endif 3905 3906 #ifdef EASY_GDB 3907 newSaveArea->prevSave = SAVEAREA_FROM_FP(fp); 3908 #endif 3909 newSaveArea->prevFrame = fp; 3910 newSaveArea->savedPc = pc; 3911 #if defined(WITH_JIT) && defined(MTERP_STUB) 3912 newSaveArea->returnAddr = 0; 3913 #endif 3914 newSaveArea->method = methodToCall; 3915 3916 if (self->interpBreak.ctl.subMode != 0) { 3917 /* 3918 * We mark ENTER here for both native and non-native 3919 * calls. For native calls, we'll mark EXIT on return. 3920 * For non-native calls, EXIT is marked in the RETURN op. 3921 */ 3922 PC_TO_SELF(); 3923 dvmReportInvoke(self, methodToCall); 3924 } 3925 3926 if (!dvmIsNativeMethod(methodToCall)) { 3927 /* 3928 * "Call" interpreted code. Reposition the PC, update the 3929 * frame pointer and other local state, and continue. 3930 */ 3931 curMethod = methodToCall; 3932 self->interpSave.method = curMethod; 3933 methodClassDex = curMethod->clazz->pDvmDex; 3934 pc = methodToCall->insns; 3935 fp = newFp; 3936 self->interpSave.curFrame = fp; 3937 #ifdef EASY_GDB 3938 debugSaveArea = SAVEAREA_FROM_FP(newFp); 3939 #endif 3940 self->debugIsMethodEntry = true; // profiling, debugging 3941 ILOGD("> pc <-- %s.%s %s", curMethod->clazz->descriptor, 3942 curMethod->name, curMethod->shorty); 3943 DUMP_REGS(curMethod, fp, true); // show input args 3944 FINISH(0); // jump to method start 3945 } else { 3946 /* set this up for JNI locals, even if not a JNI native */ 3947 newSaveArea->xtra.localRefCookie = self->jniLocalRefTable.segmentState.all; 3948 3949 self->interpSave.curFrame = newFp; 3950 3951 DUMP_REGS(methodToCall, newFp, true); // show input args 3952 3953 if (self->interpBreak.ctl.subMode != 0) { 3954 dvmReportPreNativeInvoke(methodToCall, self, newSaveArea->prevFrame); 3955 } 3956 3957 ILOGD("> native <-- %s.%s %s", methodToCall->clazz->descriptor, 3958 methodToCall->name, methodToCall->shorty); 3959 3960 /* 3961 * Jump through native call bridge. Because we leave no 3962 * space for locals on native calls, "newFp" points directly 3963 * to the method arguments. 3964 */ 3965 (*methodToCall->nativeFunc)(newFp, &retval, methodToCall, self); 3966 3967 if (self->interpBreak.ctl.subMode != 0) { 3968 dvmReportPostNativeInvoke(methodToCall, self, newSaveArea->prevFrame); 3969 } 3970 3971 /* pop frame off */ 3972 dvmPopJniLocals(self, newSaveArea); 3973 self->interpSave.curFrame = newSaveArea->prevFrame; 3974 fp = newSaveArea->prevFrame; 3975 3976 /* 3977 * If the native code threw an exception, or interpreted code 3978 * invoked by the native call threw one and nobody has cleared 3979 * it, jump to our local exception handling. 3980 */ 3981 if (dvmCheckException(self)) { 3982 ALOGV("Exception thrown by/below native code"); 3983 GOTO_exceptionThrown(); 3984 } 3985 3986 ILOGD("> retval=0x%llx (leaving native)", retval.j); 3987 ILOGD("> (return from native %s.%s to %s.%s %s)", 3988 methodToCall->clazz->descriptor, methodToCall->name, 3989 curMethod->clazz->descriptor, curMethod->name, 3990 curMethod->shorty); 3991 3992 //u2 invokeInstr = INST_INST(FETCH(0)); 3993 if (true /*invokeInstr >= OP_INVOKE_VIRTUAL && 3994 invokeInstr <= OP_INVOKE_INTERFACE*/) 3995 { 3996 FINISH(3); 3997 } else { 3998 //ALOGE("Unknown invoke instr %02x at %d", 3999 // invokeInstr, (int) (pc - curMethod->insns)); 4000 assert(false); 4001 } 4002 } 4003 } 4004 assert(false); // should not get here 4005 GOTO_TARGET_END 4006 4007 /* File: portable/enddefs.cpp */ 4008 /*--- end of opcodes ---*/ 4009 4010 bail: 4011 ILOGD("|-- Leaving interpreter loop"); // note "curMethod" may be NULL 4012 4013 self->interpSave.retval = retval; 4014 } 4015 4016
