1 /* 2 * Copyright (C) 2012 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #include "interpreter_common.h" 18 19 namespace art { 20 namespace interpreter { 21 22 #define HANDLE_PENDING_EXCEPTION() \ 23 do { \ 24 DCHECK(self->IsExceptionPending()); \ 25 if (UNLIKELY(self->TestAllFlags())) { \ 26 CheckSuspend(self); \ 27 } \ 28 uint32_t found_dex_pc = FindNextInstructionFollowingException(self, shadow_frame, \ 29 inst->GetDexPc(insns), \ 30 instrumentation); \ 31 if (found_dex_pc == DexFile::kDexNoIndex) { \ 32 return JValue(); /* Handled in caller. */ \ 33 } else { \ 34 int32_t displacement = static_cast<int32_t>(found_dex_pc) - static_cast<int32_t>(dex_pc); \ 35 inst = inst->RelativeAt(displacement); \ 36 } \ 37 } while (false) 38 39 #define POSSIBLY_HANDLE_PENDING_EXCEPTION(_is_exception_pending, _next_function) \ 40 do { \ 41 if (UNLIKELY(_is_exception_pending)) { \ 42 HANDLE_PENDING_EXCEPTION(); \ 43 } else { \ 44 inst = inst->_next_function(); \ 45 } \ 46 } while (false) 47 48 // Code to run before each dex instruction. 49 #define PREAMBLE() \ 50 do { \ 51 DCHECK(!inst->IsReturn()); \ 52 if (UNLIKELY(notified_method_entry_event)) { \ 53 notified_method_entry_event = false; \ 54 } else if (UNLIKELY(instrumentation->HasDexPcListeners())) { \ 55 instrumentation->DexPcMovedEvent(self, shadow_frame.GetThisObject(code_item->ins_size_), \ 56 shadow_frame.GetMethod(), dex_pc); \ 57 } \ 58 } while (false) 59 60 template<bool do_access_check, bool transaction_active> 61 JValue ExecuteSwitchImpl(Thread* self, MethodHelper& mh, const DexFile::CodeItem* code_item, 62 ShadowFrame& shadow_frame, JValue result_register) { 63 bool do_assignability_check = do_access_check; 64 if (UNLIKELY(!shadow_frame.HasReferenceArray())) { 65 LOG(FATAL) << "Invalid shadow frame for interpreter use"; 66 return JValue(); 67 } 68 self->VerifyStack(); 69 70 uint32_t dex_pc = shadow_frame.GetDexPC(); 71 bool notified_method_entry_event = false; 72 const instrumentation::Instrumentation* const instrumentation = Runtime::Current()->GetInstrumentation(); 73 if (LIKELY(dex_pc == 0)) { // We are entering the method as opposed to deoptimizing. 74 if (kIsDebugBuild) { 75 self->AssertNoPendingException(); 76 } 77 if (UNLIKELY(instrumentation->HasMethodEntryListeners())) { 78 instrumentation->MethodEnterEvent(self, shadow_frame.GetThisObject(code_item->ins_size_), 79 shadow_frame.GetMethod(), 0); 80 notified_method_entry_event = true; 81 } 82 } 83 const uint16_t* const insns = code_item->insns_; 84 const Instruction* inst = Instruction::At(insns + dex_pc); 85 uint16_t inst_data; 86 while (true) { 87 dex_pc = inst->GetDexPc(insns); 88 shadow_frame.SetDexPC(dex_pc); 89 TraceExecution(shadow_frame, inst, dex_pc, mh); 90 inst_data = inst->Fetch16(0); 91 switch (inst->Opcode(inst_data)) { 92 case Instruction::NOP: 93 PREAMBLE(); 94 inst = inst->Next_1xx(); 95 break; 96 case Instruction::MOVE: 97 PREAMBLE(); 98 shadow_frame.SetVReg(inst->VRegA_12x(inst_data), 99 shadow_frame.GetVReg(inst->VRegB_12x(inst_data))); 100 inst = inst->Next_1xx(); 101 break; 102 case Instruction::MOVE_FROM16: 103 PREAMBLE(); 104 shadow_frame.SetVReg(inst->VRegA_22x(inst_data), 105 shadow_frame.GetVReg(inst->VRegB_22x())); 106 inst = inst->Next_2xx(); 107 break; 108 case Instruction::MOVE_16: 109 PREAMBLE(); 110 shadow_frame.SetVReg(inst->VRegA_32x(), 111 shadow_frame.GetVReg(inst->VRegB_32x())); 112 inst = inst->Next_3xx(); 113 break; 114 case Instruction::MOVE_WIDE: 115 PREAMBLE(); 116 shadow_frame.SetVRegLong(inst->VRegA_12x(inst_data), 117 shadow_frame.GetVRegLong(inst->VRegB_12x(inst_data))); 118 inst = inst->Next_1xx(); 119 break; 120 case Instruction::MOVE_WIDE_FROM16: 121 PREAMBLE(); 122 shadow_frame.SetVRegLong(inst->VRegA_22x(inst_data), 123 shadow_frame.GetVRegLong(inst->VRegB_22x())); 124 inst = inst->Next_2xx(); 125 break; 126 case Instruction::MOVE_WIDE_16: 127 PREAMBLE(); 128 shadow_frame.SetVRegLong(inst->VRegA_32x(), 129 shadow_frame.GetVRegLong(inst->VRegB_32x())); 130 inst = inst->Next_3xx(); 131 break; 132 case Instruction::MOVE_OBJECT: 133 PREAMBLE(); 134 shadow_frame.SetVRegReference(inst->VRegA_12x(inst_data), 135 shadow_frame.GetVRegReference(inst->VRegB_12x(inst_data))); 136 inst = inst->Next_1xx(); 137 break; 138 case Instruction::MOVE_OBJECT_FROM16: 139 PREAMBLE(); 140 shadow_frame.SetVRegReference(inst->VRegA_22x(inst_data), 141 shadow_frame.GetVRegReference(inst->VRegB_22x())); 142 inst = inst->Next_2xx(); 143 break; 144 case Instruction::MOVE_OBJECT_16: 145 PREAMBLE(); 146 shadow_frame.SetVRegReference(inst->VRegA_32x(), 147 shadow_frame.GetVRegReference(inst->VRegB_32x())); 148 inst = inst->Next_3xx(); 149 break; 150 case Instruction::MOVE_RESULT: 151 PREAMBLE(); 152 shadow_frame.SetVReg(inst->VRegA_11x(inst_data), result_register.GetI()); 153 inst = inst->Next_1xx(); 154 break; 155 case Instruction::MOVE_RESULT_WIDE: 156 PREAMBLE(); 157 shadow_frame.SetVRegLong(inst->VRegA_11x(inst_data), result_register.GetJ()); 158 inst = inst->Next_1xx(); 159 break; 160 case Instruction::MOVE_RESULT_OBJECT: 161 PREAMBLE(); 162 shadow_frame.SetVRegReference(inst->VRegA_11x(inst_data), result_register.GetL()); 163 inst = inst->Next_1xx(); 164 break; 165 case Instruction::MOVE_EXCEPTION: { 166 PREAMBLE(); 167 Throwable* exception = self->GetException(nullptr); 168 DCHECK(exception != nullptr) << "No pending exception on MOVE_EXCEPTION instruction"; 169 shadow_frame.SetVRegReference(inst->VRegA_11x(inst_data), exception); 170 self->ClearException(); 171 inst = inst->Next_1xx(); 172 break; 173 } 174 case Instruction::RETURN_VOID: { 175 JValue result; 176 if (do_access_check) { 177 // If access checks are required then the dex-to-dex compiler and analysis of 178 // whether the class has final fields hasn't been performed. Conservatively 179 // perform the memory barrier now. 180 QuasiAtomic::ThreadFenceForConstructor(); 181 } 182 if (UNLIKELY(self->TestAllFlags())) { 183 CheckSuspend(self); 184 } 185 if (UNLIKELY(instrumentation->HasMethodExitListeners())) { 186 instrumentation->MethodExitEvent(self, shadow_frame.GetThisObject(code_item->ins_size_), 187 shadow_frame.GetMethod(), inst->GetDexPc(insns), 188 result); 189 } else if (UNLIKELY(instrumentation->HasDexPcListeners())) { 190 instrumentation->DexPcMovedEvent(self, shadow_frame.GetThisObject(code_item->ins_size_), 191 shadow_frame.GetMethod(), dex_pc); 192 } 193 return result; 194 } 195 case Instruction::RETURN_VOID_BARRIER: { 196 QuasiAtomic::ThreadFenceForConstructor(); 197 JValue result; 198 if (UNLIKELY(self->TestAllFlags())) { 199 CheckSuspend(self); 200 } 201 if (UNLIKELY(instrumentation->HasMethodExitListeners())) { 202 instrumentation->MethodExitEvent(self, shadow_frame.GetThisObject(code_item->ins_size_), 203 shadow_frame.GetMethod(), inst->GetDexPc(insns), 204 result); 205 } else if (UNLIKELY(instrumentation->HasDexPcListeners())) { 206 instrumentation->DexPcMovedEvent(self, shadow_frame.GetThisObject(code_item->ins_size_), 207 shadow_frame.GetMethod(), dex_pc); 208 } 209 return result; 210 } 211 case Instruction::RETURN: { 212 JValue result; 213 result.SetJ(0); 214 result.SetI(shadow_frame.GetVReg(inst->VRegA_11x(inst_data))); 215 if (UNLIKELY(self->TestAllFlags())) { 216 CheckSuspend(self); 217 } 218 if (UNLIKELY(instrumentation->HasMethodExitListeners())) { 219 instrumentation->MethodExitEvent(self, shadow_frame.GetThisObject(code_item->ins_size_), 220 shadow_frame.GetMethod(), inst->GetDexPc(insns), 221 result); 222 } else if (UNLIKELY(instrumentation->HasDexPcListeners())) { 223 instrumentation->DexPcMovedEvent(self, shadow_frame.GetThisObject(code_item->ins_size_), 224 shadow_frame.GetMethod(), dex_pc); 225 } 226 return result; 227 } 228 case Instruction::RETURN_WIDE: { 229 JValue result; 230 result.SetJ(shadow_frame.GetVRegLong(inst->VRegA_11x(inst_data))); 231 if (UNLIKELY(self->TestAllFlags())) { 232 CheckSuspend(self); 233 } 234 if (UNLIKELY(instrumentation->HasMethodExitListeners())) { 235 instrumentation->MethodExitEvent(self, shadow_frame.GetThisObject(code_item->ins_size_), 236 shadow_frame.GetMethod(), inst->GetDexPc(insns), 237 result); 238 } else if (UNLIKELY(instrumentation->HasDexPcListeners())) { 239 instrumentation->DexPcMovedEvent(self, shadow_frame.GetThisObject(code_item->ins_size_), 240 shadow_frame.GetMethod(), dex_pc); 241 } 242 return result; 243 } 244 case Instruction::RETURN_OBJECT: { 245 JValue result; 246 if (UNLIKELY(self->TestAllFlags())) { 247 CheckSuspend(self); 248 } 249 const size_t ref_idx = inst->VRegA_11x(inst_data); 250 Object* obj_result = shadow_frame.GetVRegReference(ref_idx); 251 if (do_assignability_check && obj_result != NULL) { 252 StackHandleScope<1> hs(self); 253 MethodHelper mhs(hs.NewHandle(shadow_frame.GetMethod())); 254 Class* return_type = mhs.GetReturnType(); 255 // Re-load since it might have moved. 256 obj_result = shadow_frame.GetVRegReference(ref_idx); 257 if (return_type == NULL) { 258 // Return the pending exception. 259 HANDLE_PENDING_EXCEPTION(); 260 } 261 if (!obj_result->VerifierInstanceOf(return_type)) { 262 // This should never happen. 263 std::string temp1, temp2; 264 self->ThrowNewExceptionF(self->GetCurrentLocationForThrow(), 265 "Ljava/lang/VirtualMachineError;", 266 "Returning '%s' that is not instance of return type '%s'", 267 obj_result->GetClass()->GetDescriptor(&temp1), 268 return_type->GetDescriptor(&temp2)); 269 HANDLE_PENDING_EXCEPTION(); 270 } 271 } 272 result.SetL(obj_result); 273 if (UNLIKELY(instrumentation->HasMethodExitListeners())) { 274 instrumentation->MethodExitEvent(self, shadow_frame.GetThisObject(code_item->ins_size_), 275 shadow_frame.GetMethod(), inst->GetDexPc(insns), 276 result); 277 } else if (UNLIKELY(instrumentation->HasDexPcListeners())) { 278 instrumentation->DexPcMovedEvent(self, shadow_frame.GetThisObject(code_item->ins_size_), 279 shadow_frame.GetMethod(), dex_pc); 280 } 281 return result; 282 } 283 case Instruction::CONST_4: { 284 PREAMBLE(); 285 uint4_t dst = inst->VRegA_11n(inst_data); 286 int4_t val = inst->VRegB_11n(inst_data); 287 shadow_frame.SetVReg(dst, val); 288 if (val == 0) { 289 shadow_frame.SetVRegReference(dst, NULL); 290 } 291 inst = inst->Next_1xx(); 292 break; 293 } 294 case Instruction::CONST_16: { 295 PREAMBLE(); 296 uint8_t dst = inst->VRegA_21s(inst_data); 297 int16_t val = inst->VRegB_21s(); 298 shadow_frame.SetVReg(dst, val); 299 if (val == 0) { 300 shadow_frame.SetVRegReference(dst, NULL); 301 } 302 inst = inst->Next_2xx(); 303 break; 304 } 305 case Instruction::CONST: { 306 PREAMBLE(); 307 uint8_t dst = inst->VRegA_31i(inst_data); 308 int32_t val = inst->VRegB_31i(); 309 shadow_frame.SetVReg(dst, val); 310 if (val == 0) { 311 shadow_frame.SetVRegReference(dst, NULL); 312 } 313 inst = inst->Next_3xx(); 314 break; 315 } 316 case Instruction::CONST_HIGH16: { 317 PREAMBLE(); 318 uint8_t dst = inst->VRegA_21h(inst_data); 319 int32_t val = static_cast<int32_t>(inst->VRegB_21h() << 16); 320 shadow_frame.SetVReg(dst, val); 321 if (val == 0) { 322 shadow_frame.SetVRegReference(dst, NULL); 323 } 324 inst = inst->Next_2xx(); 325 break; 326 } 327 case Instruction::CONST_WIDE_16: 328 PREAMBLE(); 329 shadow_frame.SetVRegLong(inst->VRegA_21s(inst_data), inst->VRegB_21s()); 330 inst = inst->Next_2xx(); 331 break; 332 case Instruction::CONST_WIDE_32: 333 PREAMBLE(); 334 shadow_frame.SetVRegLong(inst->VRegA_31i(inst_data), inst->VRegB_31i()); 335 inst = inst->Next_3xx(); 336 break; 337 case Instruction::CONST_WIDE: 338 PREAMBLE(); 339 shadow_frame.SetVRegLong(inst->VRegA_51l(inst_data), inst->VRegB_51l()); 340 inst = inst->Next_51l(); 341 break; 342 case Instruction::CONST_WIDE_HIGH16: 343 PREAMBLE(); 344 shadow_frame.SetVRegLong(inst->VRegA_21h(inst_data), 345 static_cast<uint64_t>(inst->VRegB_21h()) << 48); 346 inst = inst->Next_2xx(); 347 break; 348 case Instruction::CONST_STRING: { 349 PREAMBLE(); 350 String* s = ResolveString(self, mh, inst->VRegB_21c()); 351 if (UNLIKELY(s == NULL)) { 352 HANDLE_PENDING_EXCEPTION(); 353 } else { 354 shadow_frame.SetVRegReference(inst->VRegA_21c(inst_data), s); 355 inst = inst->Next_2xx(); 356 } 357 break; 358 } 359 case Instruction::CONST_STRING_JUMBO: { 360 PREAMBLE(); 361 String* s = ResolveString(self, mh, inst->VRegB_31c()); 362 if (UNLIKELY(s == NULL)) { 363 HANDLE_PENDING_EXCEPTION(); 364 } else { 365 shadow_frame.SetVRegReference(inst->VRegA_31c(inst_data), s); 366 inst = inst->Next_3xx(); 367 } 368 break; 369 } 370 case Instruction::CONST_CLASS: { 371 PREAMBLE(); 372 Class* c = ResolveVerifyAndClinit(inst->VRegB_21c(), shadow_frame.GetMethod(), 373 self, false, do_access_check); 374 if (UNLIKELY(c == NULL)) { 375 HANDLE_PENDING_EXCEPTION(); 376 } else { 377 shadow_frame.SetVRegReference(inst->VRegA_21c(inst_data), c); 378 inst = inst->Next_2xx(); 379 } 380 break; 381 } 382 case Instruction::MONITOR_ENTER: { 383 PREAMBLE(); 384 Object* obj = shadow_frame.GetVRegReference(inst->VRegA_11x(inst_data)); 385 if (UNLIKELY(obj == NULL)) { 386 ThrowNullPointerExceptionFromInterpreter(shadow_frame); 387 HANDLE_PENDING_EXCEPTION(); 388 } else { 389 DoMonitorEnter(self, obj); 390 POSSIBLY_HANDLE_PENDING_EXCEPTION(self->IsExceptionPending(), Next_1xx); 391 } 392 break; 393 } 394 case Instruction::MONITOR_EXIT: { 395 PREAMBLE(); 396 Object* obj = shadow_frame.GetVRegReference(inst->VRegA_11x(inst_data)); 397 if (UNLIKELY(obj == NULL)) { 398 ThrowNullPointerExceptionFromInterpreter(shadow_frame); 399 HANDLE_PENDING_EXCEPTION(); 400 } else { 401 DoMonitorExit(self, obj); 402 POSSIBLY_HANDLE_PENDING_EXCEPTION(self->IsExceptionPending(), Next_1xx); 403 } 404 break; 405 } 406 case Instruction::CHECK_CAST: { 407 PREAMBLE(); 408 Class* c = ResolveVerifyAndClinit(inst->VRegB_21c(), shadow_frame.GetMethod(), 409 self, false, do_access_check); 410 if (UNLIKELY(c == NULL)) { 411 HANDLE_PENDING_EXCEPTION(); 412 } else { 413 Object* obj = shadow_frame.GetVRegReference(inst->VRegA_21c(inst_data)); 414 if (UNLIKELY(obj != NULL && !obj->InstanceOf(c))) { 415 ThrowClassCastException(c, obj->GetClass()); 416 HANDLE_PENDING_EXCEPTION(); 417 } else { 418 inst = inst->Next_2xx(); 419 } 420 } 421 break; 422 } 423 case Instruction::INSTANCE_OF: { 424 PREAMBLE(); 425 Class* c = ResolveVerifyAndClinit(inst->VRegC_22c(), shadow_frame.GetMethod(), 426 self, false, do_access_check); 427 if (UNLIKELY(c == NULL)) { 428 HANDLE_PENDING_EXCEPTION(); 429 } else { 430 Object* obj = shadow_frame.GetVRegReference(inst->VRegB_22c(inst_data)); 431 shadow_frame.SetVReg(inst->VRegA_22c(inst_data), (obj != NULL && obj->InstanceOf(c)) ? 1 : 0); 432 inst = inst->Next_2xx(); 433 } 434 break; 435 } 436 case Instruction::ARRAY_LENGTH: { 437 PREAMBLE(); 438 Object* array = shadow_frame.GetVRegReference(inst->VRegB_12x(inst_data)); 439 if (UNLIKELY(array == NULL)) { 440 ThrowNullPointerExceptionFromInterpreter(shadow_frame); 441 HANDLE_PENDING_EXCEPTION(); 442 } else { 443 shadow_frame.SetVReg(inst->VRegA_12x(inst_data), array->AsArray()->GetLength()); 444 inst = inst->Next_1xx(); 445 } 446 break; 447 } 448 case Instruction::NEW_INSTANCE: { 449 PREAMBLE(); 450 Runtime* runtime = Runtime::Current(); 451 Object* obj = AllocObjectFromCode<do_access_check, true>( 452 inst->VRegB_21c(), shadow_frame.GetMethod(), self, 453 runtime->GetHeap()->GetCurrentAllocator()); 454 if (UNLIKELY(obj == NULL)) { 455 HANDLE_PENDING_EXCEPTION(); 456 } else { 457 obj->GetClass()->AssertInitializedOrInitializingInThread(self); 458 // Don't allow finalizable objects to be allocated during a transaction since these can't 459 // be finalized without a started runtime. 460 if (transaction_active && obj->GetClass()->IsFinalizable()) { 461 AbortTransaction(self, "Allocating finalizable object in transaction: %s", 462 PrettyTypeOf(obj).c_str()); 463 HANDLE_PENDING_EXCEPTION(); 464 break; 465 } 466 shadow_frame.SetVRegReference(inst->VRegA_21c(inst_data), obj); 467 inst = inst->Next_2xx(); 468 } 469 break; 470 } 471 case Instruction::NEW_ARRAY: { 472 PREAMBLE(); 473 int32_t length = shadow_frame.GetVReg(inst->VRegB_22c(inst_data)); 474 Object* obj = AllocArrayFromCode<do_access_check, true>( 475 inst->VRegC_22c(), shadow_frame.GetMethod(), length, self, 476 Runtime::Current()->GetHeap()->GetCurrentAllocator()); 477 if (UNLIKELY(obj == NULL)) { 478 HANDLE_PENDING_EXCEPTION(); 479 } else { 480 shadow_frame.SetVRegReference(inst->VRegA_22c(inst_data), obj); 481 inst = inst->Next_2xx(); 482 } 483 break; 484 } 485 case Instruction::FILLED_NEW_ARRAY: { 486 PREAMBLE(); 487 bool success = 488 DoFilledNewArray<false, do_access_check, transaction_active>(inst, shadow_frame, self, 489 &result_register); 490 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_3xx); 491 break; 492 } 493 case Instruction::FILLED_NEW_ARRAY_RANGE: { 494 PREAMBLE(); 495 bool success = 496 DoFilledNewArray<true, do_access_check, transaction_active>(inst, shadow_frame, 497 self, &result_register); 498 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_3xx); 499 break; 500 } 501 case Instruction::FILL_ARRAY_DATA: { 502 PREAMBLE(); 503 Object* obj = shadow_frame.GetVRegReference(inst->VRegA_31t(inst_data)); 504 if (UNLIKELY(obj == NULL)) { 505 ThrowNullPointerException(NULL, "null array in FILL_ARRAY_DATA"); 506 HANDLE_PENDING_EXCEPTION(); 507 break; 508 } 509 Array* array = obj->AsArray(); 510 DCHECK(array->IsArrayInstance() && !array->IsObjectArray()); 511 const uint16_t* payload_addr = reinterpret_cast<const uint16_t*>(inst) + inst->VRegB_31t(); 512 const Instruction::ArrayDataPayload* payload = 513 reinterpret_cast<const Instruction::ArrayDataPayload*>(payload_addr); 514 if (UNLIKELY(static_cast<int32_t>(payload->element_count) > array->GetLength())) { 515 self->ThrowNewExceptionF(shadow_frame.GetCurrentLocationForThrow(), 516 "Ljava/lang/ArrayIndexOutOfBoundsException;", 517 "failed FILL_ARRAY_DATA; length=%d, index=%d", 518 array->GetLength(), payload->element_count); 519 HANDLE_PENDING_EXCEPTION(); 520 break; 521 } 522 if (transaction_active) { 523 RecordArrayElementsInTransaction(array, payload->element_count); 524 } 525 uint32_t size_in_bytes = payload->element_count * payload->element_width; 526 memcpy(array->GetRawData(payload->element_width, 0), payload->data, size_in_bytes); 527 inst = inst->Next_3xx(); 528 break; 529 } 530 case Instruction::THROW: { 531 PREAMBLE(); 532 Object* exception = shadow_frame.GetVRegReference(inst->VRegA_11x(inst_data)); 533 if (UNLIKELY(exception == NULL)) { 534 ThrowNullPointerException(NULL, "throw with null exception"); 535 } else if (do_assignability_check && !exception->GetClass()->IsThrowableClass()) { 536 // This should never happen. 537 std::string temp; 538 self->ThrowNewExceptionF(self->GetCurrentLocationForThrow(), 539 "Ljava/lang/VirtualMachineError;", 540 "Throwing '%s' that is not instance of Throwable", 541 exception->GetClass()->GetDescriptor(&temp)); 542 } else { 543 self->SetException(shadow_frame.GetCurrentLocationForThrow(), exception->AsThrowable()); 544 } 545 HANDLE_PENDING_EXCEPTION(); 546 break; 547 } 548 case Instruction::GOTO: { 549 PREAMBLE(); 550 int8_t offset = inst->VRegA_10t(inst_data); 551 if (IsBackwardBranch(offset)) { 552 if (UNLIKELY(self->TestAllFlags())) { 553 CheckSuspend(self); 554 } 555 } 556 inst = inst->RelativeAt(offset); 557 break; 558 } 559 case Instruction::GOTO_16: { 560 PREAMBLE(); 561 int16_t offset = inst->VRegA_20t(); 562 if (IsBackwardBranch(offset)) { 563 if (UNLIKELY(self->TestAllFlags())) { 564 CheckSuspend(self); 565 } 566 } 567 inst = inst->RelativeAt(offset); 568 break; 569 } 570 case Instruction::GOTO_32: { 571 PREAMBLE(); 572 int32_t offset = inst->VRegA_30t(); 573 if (IsBackwardBranch(offset)) { 574 if (UNLIKELY(self->TestAllFlags())) { 575 CheckSuspend(self); 576 } 577 } 578 inst = inst->RelativeAt(offset); 579 break; 580 } 581 case Instruction::PACKED_SWITCH: { 582 PREAMBLE(); 583 int32_t offset = DoPackedSwitch(inst, shadow_frame, inst_data); 584 if (IsBackwardBranch(offset)) { 585 if (UNLIKELY(self->TestAllFlags())) { 586 CheckSuspend(self); 587 } 588 } 589 inst = inst->RelativeAt(offset); 590 break; 591 } 592 case Instruction::SPARSE_SWITCH: { 593 PREAMBLE(); 594 int32_t offset = DoSparseSwitch(inst, shadow_frame, inst_data); 595 if (IsBackwardBranch(offset)) { 596 if (UNLIKELY(self->TestAllFlags())) { 597 CheckSuspend(self); 598 } 599 } 600 inst = inst->RelativeAt(offset); 601 break; 602 } 603 case Instruction::CMPL_FLOAT: { 604 PREAMBLE(); 605 float val1 = shadow_frame.GetVRegFloat(inst->VRegB_23x()); 606 float val2 = shadow_frame.GetVRegFloat(inst->VRegC_23x()); 607 int32_t result; 608 if (val1 > val2) { 609 result = 1; 610 } else if (val1 == val2) { 611 result = 0; 612 } else { 613 result = -1; 614 } 615 shadow_frame.SetVReg(inst->VRegA_23x(inst_data), result); 616 inst = inst->Next_2xx(); 617 break; 618 } 619 case Instruction::CMPG_FLOAT: { 620 PREAMBLE(); 621 float val1 = shadow_frame.GetVRegFloat(inst->VRegB_23x()); 622 float val2 = shadow_frame.GetVRegFloat(inst->VRegC_23x()); 623 int32_t result; 624 if (val1 < val2) { 625 result = -1; 626 } else if (val1 == val2) { 627 result = 0; 628 } else { 629 result = 1; 630 } 631 shadow_frame.SetVReg(inst->VRegA_23x(inst_data), result); 632 inst = inst->Next_2xx(); 633 break; 634 } 635 case Instruction::CMPL_DOUBLE: { 636 PREAMBLE(); 637 double val1 = shadow_frame.GetVRegDouble(inst->VRegB_23x()); 638 double val2 = shadow_frame.GetVRegDouble(inst->VRegC_23x()); 639 int32_t result; 640 if (val1 > val2) { 641 result = 1; 642 } else if (val1 == val2) { 643 result = 0; 644 } else { 645 result = -1; 646 } 647 shadow_frame.SetVReg(inst->VRegA_23x(inst_data), result); 648 inst = inst->Next_2xx(); 649 break; 650 } 651 652 case Instruction::CMPG_DOUBLE: { 653 PREAMBLE(); 654 double val1 = shadow_frame.GetVRegDouble(inst->VRegB_23x()); 655 double val2 = shadow_frame.GetVRegDouble(inst->VRegC_23x()); 656 int32_t result; 657 if (val1 < val2) { 658 result = -1; 659 } else if (val1 == val2) { 660 result = 0; 661 } else { 662 result = 1; 663 } 664 shadow_frame.SetVReg(inst->VRegA_23x(inst_data), result); 665 inst = inst->Next_2xx(); 666 break; 667 } 668 case Instruction::CMP_LONG: { 669 PREAMBLE(); 670 int64_t val1 = shadow_frame.GetVRegLong(inst->VRegB_23x()); 671 int64_t val2 = shadow_frame.GetVRegLong(inst->VRegC_23x()); 672 int32_t result; 673 if (val1 > val2) { 674 result = 1; 675 } else if (val1 == val2) { 676 result = 0; 677 } else { 678 result = -1; 679 } 680 shadow_frame.SetVReg(inst->VRegA_23x(inst_data), result); 681 inst = inst->Next_2xx(); 682 break; 683 } 684 case Instruction::IF_EQ: { 685 PREAMBLE(); 686 if (shadow_frame.GetVReg(inst->VRegA_22t(inst_data)) == shadow_frame.GetVReg(inst->VRegB_22t(inst_data))) { 687 int16_t offset = inst->VRegC_22t(); 688 if (IsBackwardBranch(offset)) { 689 if (UNLIKELY(self->TestAllFlags())) { 690 CheckSuspend(self); 691 } 692 } 693 inst = inst->RelativeAt(offset); 694 } else { 695 inst = inst->Next_2xx(); 696 } 697 break; 698 } 699 case Instruction::IF_NE: { 700 PREAMBLE(); 701 if (shadow_frame.GetVReg(inst->VRegA_22t(inst_data)) != shadow_frame.GetVReg(inst->VRegB_22t(inst_data))) { 702 int16_t offset = inst->VRegC_22t(); 703 if (IsBackwardBranch(offset)) { 704 if (UNLIKELY(self->TestAllFlags())) { 705 CheckSuspend(self); 706 } 707 } 708 inst = inst->RelativeAt(offset); 709 } else { 710 inst = inst->Next_2xx(); 711 } 712 break; 713 } 714 case Instruction::IF_LT: { 715 PREAMBLE(); 716 if (shadow_frame.GetVReg(inst->VRegA_22t(inst_data)) < shadow_frame.GetVReg(inst->VRegB_22t(inst_data))) { 717 int16_t offset = inst->VRegC_22t(); 718 if (IsBackwardBranch(offset)) { 719 if (UNLIKELY(self->TestAllFlags())) { 720 CheckSuspend(self); 721 } 722 } 723 inst = inst->RelativeAt(offset); 724 } else { 725 inst = inst->Next_2xx(); 726 } 727 break; 728 } 729 case Instruction::IF_GE: { 730 PREAMBLE(); 731 if (shadow_frame.GetVReg(inst->VRegA_22t(inst_data)) >= shadow_frame.GetVReg(inst->VRegB_22t(inst_data))) { 732 int16_t offset = inst->VRegC_22t(); 733 if (IsBackwardBranch(offset)) { 734 if (UNLIKELY(self->TestAllFlags())) { 735 CheckSuspend(self); 736 } 737 } 738 inst = inst->RelativeAt(offset); 739 } else { 740 inst = inst->Next_2xx(); 741 } 742 break; 743 } 744 case Instruction::IF_GT: { 745 PREAMBLE(); 746 if (shadow_frame.GetVReg(inst->VRegA_22t(inst_data)) > shadow_frame.GetVReg(inst->VRegB_22t(inst_data))) { 747 int16_t offset = inst->VRegC_22t(); 748 if (IsBackwardBranch(offset)) { 749 if (UNLIKELY(self->TestAllFlags())) { 750 CheckSuspend(self); 751 } 752 } 753 inst = inst->RelativeAt(offset); 754 } else { 755 inst = inst->Next_2xx(); 756 } 757 break; 758 } 759 case Instruction::IF_LE: { 760 PREAMBLE(); 761 if (shadow_frame.GetVReg(inst->VRegA_22t(inst_data)) <= shadow_frame.GetVReg(inst->VRegB_22t(inst_data))) { 762 int16_t offset = inst->VRegC_22t(); 763 if (IsBackwardBranch(offset)) { 764 if (UNLIKELY(self->TestAllFlags())) { 765 CheckSuspend(self); 766 } 767 } 768 inst = inst->RelativeAt(offset); 769 } else { 770 inst = inst->Next_2xx(); 771 } 772 break; 773 } 774 case Instruction::IF_EQZ: { 775 PREAMBLE(); 776 if (shadow_frame.GetVReg(inst->VRegA_21t(inst_data)) == 0) { 777 int16_t offset = inst->VRegB_21t(); 778 if (IsBackwardBranch(offset)) { 779 if (UNLIKELY(self->TestAllFlags())) { 780 CheckSuspend(self); 781 } 782 } 783 inst = inst->RelativeAt(offset); 784 } else { 785 inst = inst->Next_2xx(); 786 } 787 break; 788 } 789 case Instruction::IF_NEZ: { 790 PREAMBLE(); 791 if (shadow_frame.GetVReg(inst->VRegA_21t(inst_data)) != 0) { 792 int16_t offset = inst->VRegB_21t(); 793 if (IsBackwardBranch(offset)) { 794 if (UNLIKELY(self->TestAllFlags())) { 795 CheckSuspend(self); 796 } 797 } 798 inst = inst->RelativeAt(offset); 799 } else { 800 inst = inst->Next_2xx(); 801 } 802 break; 803 } 804 case Instruction::IF_LTZ: { 805 PREAMBLE(); 806 if (shadow_frame.GetVReg(inst->VRegA_21t(inst_data)) < 0) { 807 int16_t offset = inst->VRegB_21t(); 808 if (IsBackwardBranch(offset)) { 809 if (UNLIKELY(self->TestAllFlags())) { 810 CheckSuspend(self); 811 } 812 } 813 inst = inst->RelativeAt(offset); 814 } else { 815 inst = inst->Next_2xx(); 816 } 817 break; 818 } 819 case Instruction::IF_GEZ: { 820 PREAMBLE(); 821 if (shadow_frame.GetVReg(inst->VRegA_21t(inst_data)) >= 0) { 822 int16_t offset = inst->VRegB_21t(); 823 if (IsBackwardBranch(offset)) { 824 if (UNLIKELY(self->TestAllFlags())) { 825 CheckSuspend(self); 826 } 827 } 828 inst = inst->RelativeAt(offset); 829 } else { 830 inst = inst->Next_2xx(); 831 } 832 break; 833 } 834 case Instruction::IF_GTZ: { 835 PREAMBLE(); 836 if (shadow_frame.GetVReg(inst->VRegA_21t(inst_data)) > 0) { 837 int16_t offset = inst->VRegB_21t(); 838 if (IsBackwardBranch(offset)) { 839 if (UNLIKELY(self->TestAllFlags())) { 840 CheckSuspend(self); 841 } 842 } 843 inst = inst->RelativeAt(offset); 844 } else { 845 inst = inst->Next_2xx(); 846 } 847 break; 848 } 849 case Instruction::IF_LEZ: { 850 PREAMBLE(); 851 if (shadow_frame.GetVReg(inst->VRegA_21t(inst_data)) <= 0) { 852 int16_t offset = inst->VRegB_21t(); 853 if (IsBackwardBranch(offset)) { 854 if (UNLIKELY(self->TestAllFlags())) { 855 CheckSuspend(self); 856 } 857 } 858 inst = inst->RelativeAt(offset); 859 } else { 860 inst = inst->Next_2xx(); 861 } 862 break; 863 } 864 case Instruction::AGET_BOOLEAN: { 865 PREAMBLE(); 866 Object* a = shadow_frame.GetVRegReference(inst->VRegB_23x()); 867 if (UNLIKELY(a == NULL)) { 868 ThrowNullPointerExceptionFromInterpreter(shadow_frame); 869 HANDLE_PENDING_EXCEPTION(); 870 break; 871 } 872 int32_t index = shadow_frame.GetVReg(inst->VRegC_23x()); 873 BooleanArray* array = a->AsBooleanArray(); 874 if (array->CheckIsValidIndex(index)) { 875 shadow_frame.SetVReg(inst->VRegA_23x(inst_data), array->GetWithoutChecks(index)); 876 inst = inst->Next_2xx(); 877 } else { 878 HANDLE_PENDING_EXCEPTION(); 879 } 880 break; 881 } 882 case Instruction::AGET_BYTE: { 883 PREAMBLE(); 884 Object* a = shadow_frame.GetVRegReference(inst->VRegB_23x()); 885 if (UNLIKELY(a == NULL)) { 886 ThrowNullPointerExceptionFromInterpreter(shadow_frame); 887 HANDLE_PENDING_EXCEPTION(); 888 break; 889 } 890 int32_t index = shadow_frame.GetVReg(inst->VRegC_23x()); 891 ByteArray* array = a->AsByteArray(); 892 if (array->CheckIsValidIndex(index)) { 893 shadow_frame.SetVReg(inst->VRegA_23x(inst_data), array->GetWithoutChecks(index)); 894 inst = inst->Next_2xx(); 895 } else { 896 HANDLE_PENDING_EXCEPTION(); 897 } 898 break; 899 } 900 case Instruction::AGET_CHAR: { 901 PREAMBLE(); 902 Object* a = shadow_frame.GetVRegReference(inst->VRegB_23x()); 903 if (UNLIKELY(a == NULL)) { 904 ThrowNullPointerExceptionFromInterpreter(shadow_frame); 905 HANDLE_PENDING_EXCEPTION(); 906 break; 907 } 908 int32_t index = shadow_frame.GetVReg(inst->VRegC_23x()); 909 CharArray* array = a->AsCharArray(); 910 if (array->CheckIsValidIndex(index)) { 911 shadow_frame.SetVReg(inst->VRegA_23x(inst_data), array->GetWithoutChecks(index)); 912 inst = inst->Next_2xx(); 913 } else { 914 HANDLE_PENDING_EXCEPTION(); 915 } 916 break; 917 } 918 case Instruction::AGET_SHORT: { 919 PREAMBLE(); 920 Object* a = shadow_frame.GetVRegReference(inst->VRegB_23x()); 921 if (UNLIKELY(a == NULL)) { 922 ThrowNullPointerExceptionFromInterpreter(shadow_frame); 923 HANDLE_PENDING_EXCEPTION(); 924 break; 925 } 926 int32_t index = shadow_frame.GetVReg(inst->VRegC_23x()); 927 ShortArray* array = a->AsShortArray(); 928 if (array->CheckIsValidIndex(index)) { 929 shadow_frame.SetVReg(inst->VRegA_23x(inst_data), array->GetWithoutChecks(index)); 930 inst = inst->Next_2xx(); 931 } else { 932 HANDLE_PENDING_EXCEPTION(); 933 } 934 break; 935 } 936 case Instruction::AGET: { 937 PREAMBLE(); 938 Object* a = shadow_frame.GetVRegReference(inst->VRegB_23x()); 939 if (UNLIKELY(a == NULL)) { 940 ThrowNullPointerExceptionFromInterpreter(shadow_frame); 941 HANDLE_PENDING_EXCEPTION(); 942 break; 943 } 944 int32_t index = shadow_frame.GetVReg(inst->VRegC_23x()); 945 IntArray* array = a->AsIntArray(); 946 if (array->CheckIsValidIndex(index)) { 947 shadow_frame.SetVReg(inst->VRegA_23x(inst_data), array->GetWithoutChecks(index)); 948 inst = inst->Next_2xx(); 949 } else { 950 HANDLE_PENDING_EXCEPTION(); 951 } 952 break; 953 } 954 case Instruction::AGET_WIDE: { 955 PREAMBLE(); 956 Object* a = shadow_frame.GetVRegReference(inst->VRegB_23x()); 957 if (UNLIKELY(a == NULL)) { 958 ThrowNullPointerExceptionFromInterpreter(shadow_frame); 959 HANDLE_PENDING_EXCEPTION(); 960 break; 961 } 962 int32_t index = shadow_frame.GetVReg(inst->VRegC_23x()); 963 LongArray* array = a->AsLongArray(); 964 if (array->CheckIsValidIndex(index)) { 965 shadow_frame.SetVRegLong(inst->VRegA_23x(inst_data), array->GetWithoutChecks(index)); 966 inst = inst->Next_2xx(); 967 } else { 968 HANDLE_PENDING_EXCEPTION(); 969 } 970 break; 971 } 972 case Instruction::AGET_OBJECT: { 973 PREAMBLE(); 974 Object* a = shadow_frame.GetVRegReference(inst->VRegB_23x()); 975 if (UNLIKELY(a == NULL)) { 976 ThrowNullPointerExceptionFromInterpreter(shadow_frame); 977 HANDLE_PENDING_EXCEPTION(); 978 break; 979 } 980 int32_t index = shadow_frame.GetVReg(inst->VRegC_23x()); 981 ObjectArray<Object>* array = a->AsObjectArray<Object>(); 982 if (array->CheckIsValidIndex(index)) { 983 shadow_frame.SetVRegReference(inst->VRegA_23x(inst_data), array->GetWithoutChecks(index)); 984 inst = inst->Next_2xx(); 985 } else { 986 HANDLE_PENDING_EXCEPTION(); 987 } 988 break; 989 } 990 case Instruction::APUT_BOOLEAN: { 991 PREAMBLE(); 992 Object* a = shadow_frame.GetVRegReference(inst->VRegB_23x()); 993 if (UNLIKELY(a == NULL)) { 994 ThrowNullPointerExceptionFromInterpreter(shadow_frame); 995 HANDLE_PENDING_EXCEPTION(); 996 break; 997 } 998 uint8_t val = shadow_frame.GetVReg(inst->VRegA_23x(inst_data)); 999 int32_t index = shadow_frame.GetVReg(inst->VRegC_23x()); 1000 BooleanArray* array = a->AsBooleanArray(); 1001 if (array->CheckIsValidIndex(index)) { 1002 array->SetWithoutChecks<transaction_active>(index, val); 1003 inst = inst->Next_2xx(); 1004 } else { 1005 HANDLE_PENDING_EXCEPTION(); 1006 } 1007 break; 1008 } 1009 case Instruction::APUT_BYTE: { 1010 PREAMBLE(); 1011 Object* a = shadow_frame.GetVRegReference(inst->VRegB_23x()); 1012 if (UNLIKELY(a == NULL)) { 1013 ThrowNullPointerExceptionFromInterpreter(shadow_frame); 1014 HANDLE_PENDING_EXCEPTION(); 1015 break; 1016 } 1017 int8_t val = shadow_frame.GetVReg(inst->VRegA_23x(inst_data)); 1018 int32_t index = shadow_frame.GetVReg(inst->VRegC_23x()); 1019 ByteArray* array = a->AsByteArray(); 1020 if (array->CheckIsValidIndex(index)) { 1021 array->SetWithoutChecks<transaction_active>(index, val); 1022 inst = inst->Next_2xx(); 1023 } else { 1024 HANDLE_PENDING_EXCEPTION(); 1025 } 1026 break; 1027 } 1028 case Instruction::APUT_CHAR: { 1029 PREAMBLE(); 1030 Object* a = shadow_frame.GetVRegReference(inst->VRegB_23x()); 1031 if (UNLIKELY(a == NULL)) { 1032 ThrowNullPointerExceptionFromInterpreter(shadow_frame); 1033 HANDLE_PENDING_EXCEPTION(); 1034 break; 1035 } 1036 uint16_t val = shadow_frame.GetVReg(inst->VRegA_23x(inst_data)); 1037 int32_t index = shadow_frame.GetVReg(inst->VRegC_23x()); 1038 CharArray* array = a->AsCharArray(); 1039 if (array->CheckIsValidIndex(index)) { 1040 array->SetWithoutChecks<transaction_active>(index, val); 1041 inst = inst->Next_2xx(); 1042 } else { 1043 HANDLE_PENDING_EXCEPTION(); 1044 } 1045 break; 1046 } 1047 case Instruction::APUT_SHORT: { 1048 PREAMBLE(); 1049 Object* a = shadow_frame.GetVRegReference(inst->VRegB_23x()); 1050 if (UNLIKELY(a == NULL)) { 1051 ThrowNullPointerExceptionFromInterpreter(shadow_frame); 1052 HANDLE_PENDING_EXCEPTION(); 1053 break; 1054 } 1055 int16_t val = shadow_frame.GetVReg(inst->VRegA_23x(inst_data)); 1056 int32_t index = shadow_frame.GetVReg(inst->VRegC_23x()); 1057 ShortArray* array = a->AsShortArray(); 1058 if (array->CheckIsValidIndex(index)) { 1059 array->SetWithoutChecks<transaction_active>(index, val); 1060 inst = inst->Next_2xx(); 1061 } else { 1062 HANDLE_PENDING_EXCEPTION(); 1063 } 1064 break; 1065 } 1066 case Instruction::APUT: { 1067 PREAMBLE(); 1068 Object* a = shadow_frame.GetVRegReference(inst->VRegB_23x()); 1069 if (UNLIKELY(a == NULL)) { 1070 ThrowNullPointerExceptionFromInterpreter(shadow_frame); 1071 HANDLE_PENDING_EXCEPTION(); 1072 break; 1073 } 1074 int32_t val = shadow_frame.GetVReg(inst->VRegA_23x(inst_data)); 1075 int32_t index = shadow_frame.GetVReg(inst->VRegC_23x()); 1076 IntArray* array = a->AsIntArray(); 1077 if (array->CheckIsValidIndex(index)) { 1078 array->SetWithoutChecks<transaction_active>(index, val); 1079 inst = inst->Next_2xx(); 1080 } else { 1081 HANDLE_PENDING_EXCEPTION(); 1082 } 1083 break; 1084 } 1085 case Instruction::APUT_WIDE: { 1086 PREAMBLE(); 1087 Object* a = shadow_frame.GetVRegReference(inst->VRegB_23x()); 1088 if (UNLIKELY(a == NULL)) { 1089 ThrowNullPointerExceptionFromInterpreter(shadow_frame); 1090 HANDLE_PENDING_EXCEPTION(); 1091 break; 1092 } 1093 int64_t val = shadow_frame.GetVRegLong(inst->VRegA_23x(inst_data)); 1094 int32_t index = shadow_frame.GetVReg(inst->VRegC_23x()); 1095 LongArray* array = a->AsLongArray(); 1096 if (array->CheckIsValidIndex(index)) { 1097 array->SetWithoutChecks<transaction_active>(index, val); 1098 inst = inst->Next_2xx(); 1099 } else { 1100 HANDLE_PENDING_EXCEPTION(); 1101 } 1102 break; 1103 } 1104 case Instruction::APUT_OBJECT: { 1105 PREAMBLE(); 1106 Object* a = shadow_frame.GetVRegReference(inst->VRegB_23x()); 1107 if (UNLIKELY(a == NULL)) { 1108 ThrowNullPointerExceptionFromInterpreter(shadow_frame); 1109 HANDLE_PENDING_EXCEPTION(); 1110 break; 1111 } 1112 int32_t index = shadow_frame.GetVReg(inst->VRegC_23x()); 1113 Object* val = shadow_frame.GetVRegReference(inst->VRegA_23x(inst_data)); 1114 ObjectArray<Object>* array = a->AsObjectArray<Object>(); 1115 if (array->CheckIsValidIndex(index) && array->CheckAssignable(val)) { 1116 array->SetWithoutChecks<transaction_active>(index, val); 1117 inst = inst->Next_2xx(); 1118 } else { 1119 HANDLE_PENDING_EXCEPTION(); 1120 } 1121 break; 1122 } 1123 case Instruction::IGET_BOOLEAN: { 1124 PREAMBLE(); 1125 bool success = DoFieldGet<InstancePrimitiveRead, Primitive::kPrimBoolean, do_access_check>(self, shadow_frame, inst, inst_data); 1126 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); 1127 break; 1128 } 1129 case Instruction::IGET_BYTE: { 1130 PREAMBLE(); 1131 bool success = DoFieldGet<InstancePrimitiveRead, Primitive::kPrimByte, do_access_check>(self, shadow_frame, inst, inst_data); 1132 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); 1133 break; 1134 } 1135 case Instruction::IGET_CHAR: { 1136 PREAMBLE(); 1137 bool success = DoFieldGet<InstancePrimitiveRead, Primitive::kPrimChar, do_access_check>(self, shadow_frame, inst, inst_data); 1138 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); 1139 break; 1140 } 1141 case Instruction::IGET_SHORT: { 1142 PREAMBLE(); 1143 bool success = DoFieldGet<InstancePrimitiveRead, Primitive::kPrimShort, do_access_check>(self, shadow_frame, inst, inst_data); 1144 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); 1145 break; 1146 } 1147 case Instruction::IGET: { 1148 PREAMBLE(); 1149 bool success = DoFieldGet<InstancePrimitiveRead, Primitive::kPrimInt, do_access_check>(self, shadow_frame, inst, inst_data); 1150 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); 1151 break; 1152 } 1153 case Instruction::IGET_WIDE: { 1154 PREAMBLE(); 1155 bool success = DoFieldGet<InstancePrimitiveRead, Primitive::kPrimLong, do_access_check>(self, shadow_frame, inst, inst_data); 1156 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); 1157 break; 1158 } 1159 case Instruction::IGET_OBJECT: { 1160 PREAMBLE(); 1161 bool success = DoFieldGet<InstanceObjectRead, Primitive::kPrimNot, do_access_check>(self, shadow_frame, inst, inst_data); 1162 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); 1163 break; 1164 } 1165 case Instruction::IGET_QUICK: { 1166 PREAMBLE(); 1167 bool success = DoIGetQuick<Primitive::kPrimInt>(shadow_frame, inst, inst_data); 1168 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); 1169 break; 1170 } 1171 case Instruction::IGET_WIDE_QUICK: { 1172 PREAMBLE(); 1173 bool success = DoIGetQuick<Primitive::kPrimLong>(shadow_frame, inst, inst_data); 1174 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); 1175 break; 1176 } 1177 case Instruction::IGET_OBJECT_QUICK: { 1178 PREAMBLE(); 1179 bool success = DoIGetQuick<Primitive::kPrimNot>(shadow_frame, inst, inst_data); 1180 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); 1181 break; 1182 } 1183 case Instruction::SGET_BOOLEAN: { 1184 PREAMBLE(); 1185 bool success = DoFieldGet<StaticPrimitiveRead, Primitive::kPrimBoolean, do_access_check>(self, shadow_frame, inst, inst_data); 1186 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); 1187 break; 1188 } 1189 case Instruction::SGET_BYTE: { 1190 PREAMBLE(); 1191 bool success = DoFieldGet<StaticPrimitiveRead, Primitive::kPrimByte, do_access_check>(self, shadow_frame, inst, inst_data); 1192 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); 1193 break; 1194 } 1195 case Instruction::SGET_CHAR: { 1196 PREAMBLE(); 1197 bool success = DoFieldGet<StaticPrimitiveRead, Primitive::kPrimChar, do_access_check>(self, shadow_frame, inst, inst_data); 1198 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); 1199 break; 1200 } 1201 case Instruction::SGET_SHORT: { 1202 PREAMBLE(); 1203 bool success = DoFieldGet<StaticPrimitiveRead, Primitive::kPrimShort, do_access_check>(self, shadow_frame, inst, inst_data); 1204 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); 1205 break; 1206 } 1207 case Instruction::SGET: { 1208 PREAMBLE(); 1209 bool success = DoFieldGet<StaticPrimitiveRead, Primitive::kPrimInt, do_access_check>(self, shadow_frame, inst, inst_data); 1210 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); 1211 break; 1212 } 1213 case Instruction::SGET_WIDE: { 1214 PREAMBLE(); 1215 bool success = DoFieldGet<StaticPrimitiveRead, Primitive::kPrimLong, do_access_check>(self, shadow_frame, inst, inst_data); 1216 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); 1217 break; 1218 } 1219 case Instruction::SGET_OBJECT: { 1220 PREAMBLE(); 1221 bool success = DoFieldGet<StaticObjectRead, Primitive::kPrimNot, do_access_check>(self, shadow_frame, inst, inst_data); 1222 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); 1223 break; 1224 } 1225 case Instruction::IPUT_BOOLEAN: { 1226 PREAMBLE(); 1227 bool success = DoFieldPut<InstancePrimitiveWrite, Primitive::kPrimBoolean, do_access_check, transaction_active>(self, shadow_frame, inst, inst_data); 1228 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); 1229 break; 1230 } 1231 case Instruction::IPUT_BYTE: { 1232 PREAMBLE(); 1233 bool success = DoFieldPut<InstancePrimitiveWrite, Primitive::kPrimByte, do_access_check, transaction_active>(self, shadow_frame, inst, inst_data); 1234 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); 1235 break; 1236 } 1237 case Instruction::IPUT_CHAR: { 1238 PREAMBLE(); 1239 bool success = DoFieldPut<InstancePrimitiveWrite, Primitive::kPrimChar, do_access_check, transaction_active>(self, shadow_frame, inst, inst_data); 1240 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); 1241 break; 1242 } 1243 case Instruction::IPUT_SHORT: { 1244 PREAMBLE(); 1245 bool success = DoFieldPut<InstancePrimitiveWrite, Primitive::kPrimShort, do_access_check, transaction_active>(self, shadow_frame, inst, inst_data); 1246 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); 1247 break; 1248 } 1249 case Instruction::IPUT: { 1250 PREAMBLE(); 1251 bool success = DoFieldPut<InstancePrimitiveWrite, Primitive::kPrimInt, do_access_check, transaction_active>(self, shadow_frame, inst, inst_data); 1252 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); 1253 break; 1254 } 1255 case Instruction::IPUT_WIDE: { 1256 PREAMBLE(); 1257 bool success = DoFieldPut<InstancePrimitiveWrite, Primitive::kPrimLong, do_access_check, transaction_active>(self, shadow_frame, inst, inst_data); 1258 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); 1259 break; 1260 } 1261 case Instruction::IPUT_OBJECT: { 1262 PREAMBLE(); 1263 bool success = DoFieldPut<InstanceObjectWrite, Primitive::kPrimNot, do_access_check, transaction_active>(self, shadow_frame, inst, inst_data); 1264 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); 1265 break; 1266 } 1267 case Instruction::IPUT_QUICK: { 1268 PREAMBLE(); 1269 bool success = DoIPutQuick<Primitive::kPrimInt, transaction_active>(shadow_frame, inst, inst_data); 1270 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); 1271 break; 1272 } 1273 case Instruction::IPUT_WIDE_QUICK: { 1274 PREAMBLE(); 1275 bool success = DoIPutQuick<Primitive::kPrimLong, transaction_active>(shadow_frame, inst, inst_data); 1276 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); 1277 break; 1278 } 1279 case Instruction::IPUT_OBJECT_QUICK: { 1280 PREAMBLE(); 1281 bool success = DoIPutQuick<Primitive::kPrimNot, transaction_active>(shadow_frame, inst, inst_data); 1282 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); 1283 break; 1284 } 1285 case Instruction::SPUT_BOOLEAN: { 1286 PREAMBLE(); 1287 bool success = DoFieldPut<StaticPrimitiveWrite, Primitive::kPrimBoolean, do_access_check, transaction_active>(self, shadow_frame, inst, inst_data); 1288 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); 1289 break; 1290 } 1291 case Instruction::SPUT_BYTE: { 1292 PREAMBLE(); 1293 bool success = DoFieldPut<StaticPrimitiveWrite, Primitive::kPrimByte, do_access_check, transaction_active>(self, shadow_frame, inst, inst_data); 1294 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); 1295 break; 1296 } 1297 case Instruction::SPUT_CHAR: { 1298 PREAMBLE(); 1299 bool success = DoFieldPut<StaticPrimitiveWrite, Primitive::kPrimChar, do_access_check, transaction_active>(self, shadow_frame, inst, inst_data); 1300 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); 1301 break; 1302 } 1303 case Instruction::SPUT_SHORT: { 1304 PREAMBLE(); 1305 bool success = DoFieldPut<StaticPrimitiveWrite, Primitive::kPrimShort, do_access_check, transaction_active>(self, shadow_frame, inst, inst_data); 1306 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); 1307 break; 1308 } 1309 case Instruction::SPUT: { 1310 PREAMBLE(); 1311 bool success = DoFieldPut<StaticPrimitiveWrite, Primitive::kPrimInt, do_access_check, transaction_active>(self, shadow_frame, inst, inst_data); 1312 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); 1313 break; 1314 } 1315 case Instruction::SPUT_WIDE: { 1316 PREAMBLE(); 1317 bool success = DoFieldPut<StaticPrimitiveWrite, Primitive::kPrimLong, do_access_check, transaction_active>(self, shadow_frame, inst, inst_data); 1318 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); 1319 break; 1320 } 1321 case Instruction::SPUT_OBJECT: { 1322 PREAMBLE(); 1323 bool success = DoFieldPut<StaticObjectWrite, Primitive::kPrimNot, do_access_check, transaction_active>(self, shadow_frame, inst, inst_data); 1324 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); 1325 break; 1326 } 1327 case Instruction::INVOKE_VIRTUAL: { 1328 PREAMBLE(); 1329 bool success = DoInvoke<kVirtual, false, do_access_check>(self, shadow_frame, inst, inst_data, &result_register); 1330 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_3xx); 1331 break; 1332 } 1333 case Instruction::INVOKE_VIRTUAL_RANGE: { 1334 PREAMBLE(); 1335 bool success = DoInvoke<kVirtual, true, do_access_check>(self, shadow_frame, inst, inst_data, &result_register); 1336 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_3xx); 1337 break; 1338 } 1339 case Instruction::INVOKE_SUPER: { 1340 PREAMBLE(); 1341 bool success = DoInvoke<kSuper, false, do_access_check>(self, shadow_frame, inst, inst_data, &result_register); 1342 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_3xx); 1343 break; 1344 } 1345 case Instruction::INVOKE_SUPER_RANGE: { 1346 PREAMBLE(); 1347 bool success = DoInvoke<kSuper, true, do_access_check>(self, shadow_frame, inst, inst_data, &result_register); 1348 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_3xx); 1349 break; 1350 } 1351 case Instruction::INVOKE_DIRECT: { 1352 PREAMBLE(); 1353 bool success = DoInvoke<kDirect, false, do_access_check>(self, shadow_frame, inst, inst_data, &result_register); 1354 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_3xx); 1355 break; 1356 } 1357 case Instruction::INVOKE_DIRECT_RANGE: { 1358 PREAMBLE(); 1359 bool success = DoInvoke<kDirect, true, do_access_check>(self, shadow_frame, inst, inst_data, &result_register); 1360 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_3xx); 1361 break; 1362 } 1363 case Instruction::INVOKE_INTERFACE: { 1364 PREAMBLE(); 1365 bool success = DoInvoke<kInterface, false, do_access_check>(self, shadow_frame, inst, inst_data, &result_register); 1366 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_3xx); 1367 break; 1368 } 1369 case Instruction::INVOKE_INTERFACE_RANGE: { 1370 PREAMBLE(); 1371 bool success = DoInvoke<kInterface, true, do_access_check>(self, shadow_frame, inst, inst_data, &result_register); 1372 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_3xx); 1373 break; 1374 } 1375 case Instruction::INVOKE_STATIC: { 1376 PREAMBLE(); 1377 bool success = DoInvoke<kStatic, false, do_access_check>(self, shadow_frame, inst, inst_data, &result_register); 1378 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_3xx); 1379 break; 1380 } 1381 case Instruction::INVOKE_STATIC_RANGE: { 1382 PREAMBLE(); 1383 bool success = DoInvoke<kStatic, true, do_access_check>(self, shadow_frame, inst, inst_data, &result_register); 1384 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_3xx); 1385 break; 1386 } 1387 case Instruction::INVOKE_VIRTUAL_QUICK: { 1388 PREAMBLE(); 1389 bool success = DoInvokeVirtualQuick<false>(self, shadow_frame, inst, inst_data, &result_register); 1390 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_3xx); 1391 break; 1392 } 1393 case Instruction::INVOKE_VIRTUAL_RANGE_QUICK: { 1394 PREAMBLE(); 1395 bool success = DoInvokeVirtualQuick<true>(self, shadow_frame, inst, inst_data, &result_register); 1396 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_3xx); 1397 break; 1398 } 1399 case Instruction::NEG_INT: 1400 PREAMBLE(); 1401 shadow_frame.SetVReg(inst->VRegA_12x(inst_data), -shadow_frame.GetVReg(inst->VRegB_12x(inst_data))); 1402 inst = inst->Next_1xx(); 1403 break; 1404 case Instruction::NOT_INT: 1405 PREAMBLE(); 1406 shadow_frame.SetVReg(inst->VRegA_12x(inst_data), ~shadow_frame.GetVReg(inst->VRegB_12x(inst_data))); 1407 inst = inst->Next_1xx(); 1408 break; 1409 case Instruction::NEG_LONG: 1410 PREAMBLE(); 1411 shadow_frame.SetVRegLong(inst->VRegA_12x(inst_data), -shadow_frame.GetVRegLong(inst->VRegB_12x(inst_data))); 1412 inst = inst->Next_1xx(); 1413 break; 1414 case Instruction::NOT_LONG: 1415 PREAMBLE(); 1416 shadow_frame.SetVRegLong(inst->VRegA_12x(inst_data), ~shadow_frame.GetVRegLong(inst->VRegB_12x(inst_data))); 1417 inst = inst->Next_1xx(); 1418 break; 1419 case Instruction::NEG_FLOAT: 1420 PREAMBLE(); 1421 shadow_frame.SetVRegFloat(inst->VRegA_12x(inst_data), -shadow_frame.GetVRegFloat(inst->VRegB_12x(inst_data))); 1422 inst = inst->Next_1xx(); 1423 break; 1424 case Instruction::NEG_DOUBLE: 1425 PREAMBLE(); 1426 shadow_frame.SetVRegDouble(inst->VRegA_12x(inst_data), -shadow_frame.GetVRegDouble(inst->VRegB_12x(inst_data))); 1427 inst = inst->Next_1xx(); 1428 break; 1429 case Instruction::INT_TO_LONG: 1430 PREAMBLE(); 1431 shadow_frame.SetVRegLong(inst->VRegA_12x(inst_data), 1432 shadow_frame.GetVReg(inst->VRegB_12x(inst_data))); 1433 inst = inst->Next_1xx(); 1434 break; 1435 case Instruction::INT_TO_FLOAT: 1436 PREAMBLE(); 1437 shadow_frame.SetVRegFloat(inst->VRegA_12x(inst_data), 1438 shadow_frame.GetVReg(inst->VRegB_12x(inst_data))); 1439 inst = inst->Next_1xx(); 1440 break; 1441 case Instruction::INT_TO_DOUBLE: 1442 PREAMBLE(); 1443 shadow_frame.SetVRegDouble(inst->VRegA_12x(inst_data), 1444 shadow_frame.GetVReg(inst->VRegB_12x(inst_data))); 1445 inst = inst->Next_1xx(); 1446 break; 1447 case Instruction::LONG_TO_INT: 1448 PREAMBLE(); 1449 shadow_frame.SetVReg(inst->VRegA_12x(inst_data), 1450 shadow_frame.GetVRegLong(inst->VRegB_12x(inst_data))); 1451 inst = inst->Next_1xx(); 1452 break; 1453 case Instruction::LONG_TO_FLOAT: 1454 PREAMBLE(); 1455 shadow_frame.SetVRegFloat(inst->VRegA_12x(inst_data), 1456 shadow_frame.GetVRegLong(inst->VRegB_12x(inst_data))); 1457 inst = inst->Next_1xx(); 1458 break; 1459 case Instruction::LONG_TO_DOUBLE: 1460 PREAMBLE(); 1461 shadow_frame.SetVRegDouble(inst->VRegA_12x(inst_data), 1462 shadow_frame.GetVRegLong(inst->VRegB_12x(inst_data))); 1463 inst = inst->Next_1xx(); 1464 break; 1465 case Instruction::FLOAT_TO_INT: { 1466 PREAMBLE(); 1467 float val = shadow_frame.GetVRegFloat(inst->VRegB_12x(inst_data)); 1468 int32_t result = art_float_to_integral<int32_t, float>(val); 1469 shadow_frame.SetVReg(inst->VRegA_12x(inst_data), result); 1470 inst = inst->Next_1xx(); 1471 break; 1472 } 1473 case Instruction::FLOAT_TO_LONG: { 1474 PREAMBLE(); 1475 float val = shadow_frame.GetVRegFloat(inst->VRegB_12x(inst_data)); 1476 int64_t result = art_float_to_integral<int64_t, float>(val); 1477 shadow_frame.SetVRegLong(inst->VRegA_12x(inst_data), result); 1478 inst = inst->Next_1xx(); 1479 break; 1480 } 1481 case Instruction::FLOAT_TO_DOUBLE: 1482 PREAMBLE(); 1483 shadow_frame.SetVRegDouble(inst->VRegA_12x(inst_data), 1484 shadow_frame.GetVRegFloat(inst->VRegB_12x(inst_data))); 1485 inst = inst->Next_1xx(); 1486 break; 1487 case Instruction::DOUBLE_TO_INT: { 1488 PREAMBLE(); 1489 double val = shadow_frame.GetVRegDouble(inst->VRegB_12x(inst_data)); 1490 int32_t result = art_float_to_integral<int32_t, double>(val); 1491 shadow_frame.SetVReg(inst->VRegA_12x(inst_data), result); 1492 inst = inst->Next_1xx(); 1493 break; 1494 } 1495 case Instruction::DOUBLE_TO_LONG: { 1496 PREAMBLE(); 1497 double val = shadow_frame.GetVRegDouble(inst->VRegB_12x(inst_data)); 1498 int64_t result = art_float_to_integral<int64_t, double>(val); 1499 shadow_frame.SetVRegLong(inst->VRegA_12x(inst_data), result); 1500 inst = inst->Next_1xx(); 1501 break; 1502 } 1503 case Instruction::DOUBLE_TO_FLOAT: 1504 PREAMBLE(); 1505 shadow_frame.SetVRegFloat(inst->VRegA_12x(inst_data), 1506 shadow_frame.GetVRegDouble(inst->VRegB_12x(inst_data))); 1507 inst = inst->Next_1xx(); 1508 break; 1509 case Instruction::INT_TO_BYTE: 1510 PREAMBLE(); 1511 shadow_frame.SetVReg(inst->VRegA_12x(inst_data), 1512 static_cast<int8_t>(shadow_frame.GetVReg(inst->VRegB_12x(inst_data)))); 1513 inst = inst->Next_1xx(); 1514 break; 1515 case Instruction::INT_TO_CHAR: 1516 PREAMBLE(); 1517 shadow_frame.SetVReg(inst->VRegA_12x(inst_data), 1518 static_cast<uint16_t>(shadow_frame.GetVReg(inst->VRegB_12x(inst_data)))); 1519 inst = inst->Next_1xx(); 1520 break; 1521 case Instruction::INT_TO_SHORT: 1522 PREAMBLE(); 1523 shadow_frame.SetVReg(inst->VRegA_12x(inst_data), 1524 static_cast<int16_t>(shadow_frame.GetVReg(inst->VRegB_12x(inst_data)))); 1525 inst = inst->Next_1xx(); 1526 break; 1527 case Instruction::ADD_INT: 1528 PREAMBLE(); 1529 shadow_frame.SetVReg(inst->VRegA_23x(inst_data), 1530 shadow_frame.GetVReg(inst->VRegB_23x()) + 1531 shadow_frame.GetVReg(inst->VRegC_23x())); 1532 inst = inst->Next_2xx(); 1533 break; 1534 case Instruction::SUB_INT: 1535 PREAMBLE(); 1536 shadow_frame.SetVReg(inst->VRegA_23x(inst_data), 1537 shadow_frame.GetVReg(inst->VRegB_23x()) - 1538 shadow_frame.GetVReg(inst->VRegC_23x())); 1539 inst = inst->Next_2xx(); 1540 break; 1541 case Instruction::MUL_INT: 1542 PREAMBLE(); 1543 shadow_frame.SetVReg(inst->VRegA_23x(inst_data), 1544 shadow_frame.GetVReg(inst->VRegB_23x()) * 1545 shadow_frame.GetVReg(inst->VRegC_23x())); 1546 inst = inst->Next_2xx(); 1547 break; 1548 case Instruction::DIV_INT: { 1549 PREAMBLE(); 1550 bool success = DoIntDivide(shadow_frame, inst->VRegA_23x(inst_data), 1551 shadow_frame.GetVReg(inst->VRegB_23x()), 1552 shadow_frame.GetVReg(inst->VRegC_23x())); 1553 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); 1554 break; 1555 } 1556 case Instruction::REM_INT: { 1557 PREAMBLE(); 1558 bool success = DoIntRemainder(shadow_frame, inst->VRegA_23x(inst_data), 1559 shadow_frame.GetVReg(inst->VRegB_23x()), 1560 shadow_frame.GetVReg(inst->VRegC_23x())); 1561 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); 1562 break; 1563 } 1564 case Instruction::SHL_INT: 1565 PREAMBLE(); 1566 shadow_frame.SetVReg(inst->VRegA_23x(inst_data), 1567 shadow_frame.GetVReg(inst->VRegB_23x()) << 1568 (shadow_frame.GetVReg(inst->VRegC_23x()) & 0x1f)); 1569 inst = inst->Next_2xx(); 1570 break; 1571 case Instruction::SHR_INT: 1572 PREAMBLE(); 1573 shadow_frame.SetVReg(inst->VRegA_23x(inst_data), 1574 shadow_frame.GetVReg(inst->VRegB_23x()) >> 1575 (shadow_frame.GetVReg(inst->VRegC_23x()) & 0x1f)); 1576 inst = inst->Next_2xx(); 1577 break; 1578 case Instruction::USHR_INT: 1579 PREAMBLE(); 1580 shadow_frame.SetVReg(inst->VRegA_23x(inst_data), 1581 static_cast<uint32_t>(shadow_frame.GetVReg(inst->VRegB_23x())) >> 1582 (shadow_frame.GetVReg(inst->VRegC_23x()) & 0x1f)); 1583 inst = inst->Next_2xx(); 1584 break; 1585 case Instruction::AND_INT: 1586 PREAMBLE(); 1587 shadow_frame.SetVReg(inst->VRegA_23x(inst_data), 1588 shadow_frame.GetVReg(inst->VRegB_23x()) & 1589 shadow_frame.GetVReg(inst->VRegC_23x())); 1590 inst = inst->Next_2xx(); 1591 break; 1592 case Instruction::OR_INT: 1593 PREAMBLE(); 1594 shadow_frame.SetVReg(inst->VRegA_23x(inst_data), 1595 shadow_frame.GetVReg(inst->VRegB_23x()) | 1596 shadow_frame.GetVReg(inst->VRegC_23x())); 1597 inst = inst->Next_2xx(); 1598 break; 1599 case Instruction::XOR_INT: 1600 PREAMBLE(); 1601 shadow_frame.SetVReg(inst->VRegA_23x(inst_data), 1602 shadow_frame.GetVReg(inst->VRegB_23x()) ^ 1603 shadow_frame.GetVReg(inst->VRegC_23x())); 1604 inst = inst->Next_2xx(); 1605 break; 1606 case Instruction::ADD_LONG: 1607 PREAMBLE(); 1608 shadow_frame.SetVRegLong(inst->VRegA_23x(inst_data), 1609 shadow_frame.GetVRegLong(inst->VRegB_23x()) + 1610 shadow_frame.GetVRegLong(inst->VRegC_23x())); 1611 inst = inst->Next_2xx(); 1612 break; 1613 case Instruction::SUB_LONG: 1614 PREAMBLE(); 1615 shadow_frame.SetVRegLong(inst->VRegA_23x(inst_data), 1616 shadow_frame.GetVRegLong(inst->VRegB_23x()) - 1617 shadow_frame.GetVRegLong(inst->VRegC_23x())); 1618 inst = inst->Next_2xx(); 1619 break; 1620 case Instruction::MUL_LONG: 1621 PREAMBLE(); 1622 shadow_frame.SetVRegLong(inst->VRegA_23x(inst_data), 1623 shadow_frame.GetVRegLong(inst->VRegB_23x()) * 1624 shadow_frame.GetVRegLong(inst->VRegC_23x())); 1625 inst = inst->Next_2xx(); 1626 break; 1627 case Instruction::DIV_LONG: 1628 PREAMBLE(); 1629 DoLongDivide(shadow_frame, inst->VRegA_23x(inst_data), 1630 shadow_frame.GetVRegLong(inst->VRegB_23x()), 1631 shadow_frame.GetVRegLong(inst->VRegC_23x())); 1632 POSSIBLY_HANDLE_PENDING_EXCEPTION(self->IsExceptionPending(), Next_2xx); 1633 break; 1634 case Instruction::REM_LONG: 1635 PREAMBLE(); 1636 DoLongRemainder(shadow_frame, inst->VRegA_23x(inst_data), 1637 shadow_frame.GetVRegLong(inst->VRegB_23x()), 1638 shadow_frame.GetVRegLong(inst->VRegC_23x())); 1639 POSSIBLY_HANDLE_PENDING_EXCEPTION(self->IsExceptionPending(), Next_2xx); 1640 break; 1641 case Instruction::AND_LONG: 1642 PREAMBLE(); 1643 shadow_frame.SetVRegLong(inst->VRegA_23x(inst_data), 1644 shadow_frame.GetVRegLong(inst->VRegB_23x()) & 1645 shadow_frame.GetVRegLong(inst->VRegC_23x())); 1646 inst = inst->Next_2xx(); 1647 break; 1648 case Instruction::OR_LONG: 1649 PREAMBLE(); 1650 shadow_frame.SetVRegLong(inst->VRegA_23x(inst_data), 1651 shadow_frame.GetVRegLong(inst->VRegB_23x()) | 1652 shadow_frame.GetVRegLong(inst->VRegC_23x())); 1653 inst = inst->Next_2xx(); 1654 break; 1655 case Instruction::XOR_LONG: 1656 PREAMBLE(); 1657 shadow_frame.SetVRegLong(inst->VRegA_23x(inst_data), 1658 shadow_frame.GetVRegLong(inst->VRegB_23x()) ^ 1659 shadow_frame.GetVRegLong(inst->VRegC_23x())); 1660 inst = inst->Next_2xx(); 1661 break; 1662 case Instruction::SHL_LONG: 1663 PREAMBLE(); 1664 shadow_frame.SetVRegLong(inst->VRegA_23x(inst_data), 1665 shadow_frame.GetVRegLong(inst->VRegB_23x()) << 1666 (shadow_frame.GetVReg(inst->VRegC_23x()) & 0x3f)); 1667 inst = inst->Next_2xx(); 1668 break; 1669 case Instruction::SHR_LONG: 1670 PREAMBLE(); 1671 shadow_frame.SetVRegLong(inst->VRegA_23x(inst_data), 1672 shadow_frame.GetVRegLong(inst->VRegB_23x()) >> 1673 (shadow_frame.GetVReg(inst->VRegC_23x()) & 0x3f)); 1674 inst = inst->Next_2xx(); 1675 break; 1676 case Instruction::USHR_LONG: 1677 PREAMBLE(); 1678 shadow_frame.SetVRegLong(inst->VRegA_23x(inst_data), 1679 static_cast<uint64_t>(shadow_frame.GetVRegLong(inst->VRegB_23x())) >> 1680 (shadow_frame.GetVReg(inst->VRegC_23x()) & 0x3f)); 1681 inst = inst->Next_2xx(); 1682 break; 1683 case Instruction::ADD_FLOAT: 1684 PREAMBLE(); 1685 shadow_frame.SetVRegFloat(inst->VRegA_23x(inst_data), 1686 shadow_frame.GetVRegFloat(inst->VRegB_23x()) + 1687 shadow_frame.GetVRegFloat(inst->VRegC_23x())); 1688 inst = inst->Next_2xx(); 1689 break; 1690 case Instruction::SUB_FLOAT: 1691 PREAMBLE(); 1692 shadow_frame.SetVRegFloat(inst->VRegA_23x(inst_data), 1693 shadow_frame.GetVRegFloat(inst->VRegB_23x()) - 1694 shadow_frame.GetVRegFloat(inst->VRegC_23x())); 1695 inst = inst->Next_2xx(); 1696 break; 1697 case Instruction::MUL_FLOAT: 1698 PREAMBLE(); 1699 shadow_frame.SetVRegFloat(inst->VRegA_23x(inst_data), 1700 shadow_frame.GetVRegFloat(inst->VRegB_23x()) * 1701 shadow_frame.GetVRegFloat(inst->VRegC_23x())); 1702 inst = inst->Next_2xx(); 1703 break; 1704 case Instruction::DIV_FLOAT: 1705 PREAMBLE(); 1706 shadow_frame.SetVRegFloat(inst->VRegA_23x(inst_data), 1707 shadow_frame.GetVRegFloat(inst->VRegB_23x()) / 1708 shadow_frame.GetVRegFloat(inst->VRegC_23x())); 1709 inst = inst->Next_2xx(); 1710 break; 1711 case Instruction::REM_FLOAT: 1712 PREAMBLE(); 1713 shadow_frame.SetVRegFloat(inst->VRegA_23x(inst_data), 1714 fmodf(shadow_frame.GetVRegFloat(inst->VRegB_23x()), 1715 shadow_frame.GetVRegFloat(inst->VRegC_23x()))); 1716 inst = inst->Next_2xx(); 1717 break; 1718 case Instruction::ADD_DOUBLE: 1719 PREAMBLE(); 1720 shadow_frame.SetVRegDouble(inst->VRegA_23x(inst_data), 1721 shadow_frame.GetVRegDouble(inst->VRegB_23x()) + 1722 shadow_frame.GetVRegDouble(inst->VRegC_23x())); 1723 inst = inst->Next_2xx(); 1724 break; 1725 case Instruction::SUB_DOUBLE: 1726 PREAMBLE(); 1727 shadow_frame.SetVRegDouble(inst->VRegA_23x(inst_data), 1728 shadow_frame.GetVRegDouble(inst->VRegB_23x()) - 1729 shadow_frame.GetVRegDouble(inst->VRegC_23x())); 1730 inst = inst->Next_2xx(); 1731 break; 1732 case Instruction::MUL_DOUBLE: 1733 PREAMBLE(); 1734 shadow_frame.SetVRegDouble(inst->VRegA_23x(inst_data), 1735 shadow_frame.GetVRegDouble(inst->VRegB_23x()) * 1736 shadow_frame.GetVRegDouble(inst->VRegC_23x())); 1737 inst = inst->Next_2xx(); 1738 break; 1739 case Instruction::DIV_DOUBLE: 1740 PREAMBLE(); 1741 shadow_frame.SetVRegDouble(inst->VRegA_23x(inst_data), 1742 shadow_frame.GetVRegDouble(inst->VRegB_23x()) / 1743 shadow_frame.GetVRegDouble(inst->VRegC_23x())); 1744 inst = inst->Next_2xx(); 1745 break; 1746 case Instruction::REM_DOUBLE: 1747 PREAMBLE(); 1748 shadow_frame.SetVRegDouble(inst->VRegA_23x(inst_data), 1749 fmod(shadow_frame.GetVRegDouble(inst->VRegB_23x()), 1750 shadow_frame.GetVRegDouble(inst->VRegC_23x()))); 1751 inst = inst->Next_2xx(); 1752 break; 1753 case Instruction::ADD_INT_2ADDR: { 1754 PREAMBLE(); 1755 uint4_t vregA = inst->VRegA_12x(inst_data); 1756 shadow_frame.SetVReg(vregA, 1757 shadow_frame.GetVReg(vregA) + 1758 shadow_frame.GetVReg(inst->VRegB_12x(inst_data))); 1759 inst = inst->Next_1xx(); 1760 break; 1761 } 1762 case Instruction::SUB_INT_2ADDR: { 1763 PREAMBLE(); 1764 uint4_t vregA = inst->VRegA_12x(inst_data); 1765 shadow_frame.SetVReg(vregA, 1766 shadow_frame.GetVReg(vregA) - 1767 shadow_frame.GetVReg(inst->VRegB_12x(inst_data))); 1768 inst = inst->Next_1xx(); 1769 break; 1770 } 1771 case Instruction::MUL_INT_2ADDR: { 1772 PREAMBLE(); 1773 uint4_t vregA = inst->VRegA_12x(inst_data); 1774 shadow_frame.SetVReg(vregA, 1775 shadow_frame.GetVReg(vregA) * 1776 shadow_frame.GetVReg(inst->VRegB_12x(inst_data))); 1777 inst = inst->Next_1xx(); 1778 break; 1779 } 1780 case Instruction::DIV_INT_2ADDR: { 1781 PREAMBLE(); 1782 uint4_t vregA = inst->VRegA_12x(inst_data); 1783 bool success = DoIntDivide(shadow_frame, vregA, shadow_frame.GetVReg(vregA), 1784 shadow_frame.GetVReg(inst->VRegB_12x(inst_data))); 1785 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_1xx); 1786 break; 1787 } 1788 case Instruction::REM_INT_2ADDR: { 1789 PREAMBLE(); 1790 uint4_t vregA = inst->VRegA_12x(inst_data); 1791 bool success = DoIntRemainder(shadow_frame, vregA, shadow_frame.GetVReg(vregA), 1792 shadow_frame.GetVReg(inst->VRegB_12x(inst_data))); 1793 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_1xx); 1794 break; 1795 } 1796 case Instruction::SHL_INT_2ADDR: { 1797 PREAMBLE(); 1798 uint4_t vregA = inst->VRegA_12x(inst_data); 1799 shadow_frame.SetVReg(vregA, 1800 shadow_frame.GetVReg(vregA) << 1801 (shadow_frame.GetVReg(inst->VRegB_12x(inst_data)) & 0x1f)); 1802 inst = inst->Next_1xx(); 1803 break; 1804 } 1805 case Instruction::SHR_INT_2ADDR: { 1806 PREAMBLE(); 1807 uint4_t vregA = inst->VRegA_12x(inst_data); 1808 shadow_frame.SetVReg(vregA, 1809 shadow_frame.GetVReg(vregA) >> 1810 (shadow_frame.GetVReg(inst->VRegB_12x(inst_data)) & 0x1f)); 1811 inst = inst->Next_1xx(); 1812 break; 1813 } 1814 case Instruction::USHR_INT_2ADDR: { 1815 PREAMBLE(); 1816 uint4_t vregA = inst->VRegA_12x(inst_data); 1817 shadow_frame.SetVReg(vregA, 1818 static_cast<uint32_t>(shadow_frame.GetVReg(vregA)) >> 1819 (shadow_frame.GetVReg(inst->VRegB_12x(inst_data)) & 0x1f)); 1820 inst = inst->Next_1xx(); 1821 break; 1822 } 1823 case Instruction::AND_INT_2ADDR: { 1824 PREAMBLE(); 1825 uint4_t vregA = inst->VRegA_12x(inst_data); 1826 shadow_frame.SetVReg(vregA, 1827 shadow_frame.GetVReg(vregA) & 1828 shadow_frame.GetVReg(inst->VRegB_12x(inst_data))); 1829 inst = inst->Next_1xx(); 1830 break; 1831 } 1832 case Instruction::OR_INT_2ADDR: { 1833 PREAMBLE(); 1834 uint4_t vregA = inst->VRegA_12x(inst_data); 1835 shadow_frame.SetVReg(vregA, 1836 shadow_frame.GetVReg(vregA) | 1837 shadow_frame.GetVReg(inst->VRegB_12x(inst_data))); 1838 inst = inst->Next_1xx(); 1839 break; 1840 } 1841 case Instruction::XOR_INT_2ADDR: { 1842 PREAMBLE(); 1843 uint4_t vregA = inst->VRegA_12x(inst_data); 1844 shadow_frame.SetVReg(vregA, 1845 shadow_frame.GetVReg(vregA) ^ 1846 shadow_frame.GetVReg(inst->VRegB_12x(inst_data))); 1847 inst = inst->Next_1xx(); 1848 break; 1849 } 1850 case Instruction::ADD_LONG_2ADDR: { 1851 PREAMBLE(); 1852 uint4_t vregA = inst->VRegA_12x(inst_data); 1853 shadow_frame.SetVRegLong(vregA, 1854 shadow_frame.GetVRegLong(vregA) + 1855 shadow_frame.GetVRegLong(inst->VRegB_12x(inst_data))); 1856 inst = inst->Next_1xx(); 1857 break; 1858 } 1859 case Instruction::SUB_LONG_2ADDR: { 1860 PREAMBLE(); 1861 uint4_t vregA = inst->VRegA_12x(inst_data); 1862 shadow_frame.SetVRegLong(vregA, 1863 shadow_frame.GetVRegLong(vregA) - 1864 shadow_frame.GetVRegLong(inst->VRegB_12x(inst_data))); 1865 inst = inst->Next_1xx(); 1866 break; 1867 } 1868 case Instruction::MUL_LONG_2ADDR: { 1869 PREAMBLE(); 1870 uint4_t vregA = inst->VRegA_12x(inst_data); 1871 shadow_frame.SetVRegLong(vregA, 1872 shadow_frame.GetVRegLong(vregA) * 1873 shadow_frame.GetVRegLong(inst->VRegB_12x(inst_data))); 1874 inst = inst->Next_1xx(); 1875 break; 1876 } 1877 case Instruction::DIV_LONG_2ADDR: { 1878 PREAMBLE(); 1879 uint4_t vregA = inst->VRegA_12x(inst_data); 1880 DoLongDivide(shadow_frame, vregA, shadow_frame.GetVRegLong(vregA), 1881 shadow_frame.GetVRegLong(inst->VRegB_12x(inst_data))); 1882 POSSIBLY_HANDLE_PENDING_EXCEPTION(self->IsExceptionPending(), Next_1xx); 1883 break; 1884 } 1885 case Instruction::REM_LONG_2ADDR: { 1886 PREAMBLE(); 1887 uint4_t vregA = inst->VRegA_12x(inst_data); 1888 DoLongRemainder(shadow_frame, vregA, shadow_frame.GetVRegLong(vregA), 1889 shadow_frame.GetVRegLong(inst->VRegB_12x(inst_data))); 1890 POSSIBLY_HANDLE_PENDING_EXCEPTION(self->IsExceptionPending(), Next_1xx); 1891 break; 1892 } 1893 case Instruction::AND_LONG_2ADDR: { 1894 PREAMBLE(); 1895 uint4_t vregA = inst->VRegA_12x(inst_data); 1896 shadow_frame.SetVRegLong(vregA, 1897 shadow_frame.GetVRegLong(vregA) & 1898 shadow_frame.GetVRegLong(inst->VRegB_12x(inst_data))); 1899 inst = inst->Next_1xx(); 1900 break; 1901 } 1902 case Instruction::OR_LONG_2ADDR: { 1903 PREAMBLE(); 1904 uint4_t vregA = inst->VRegA_12x(inst_data); 1905 shadow_frame.SetVRegLong(vregA, 1906 shadow_frame.GetVRegLong(vregA) | 1907 shadow_frame.GetVRegLong(inst->VRegB_12x(inst_data))); 1908 inst = inst->Next_1xx(); 1909 break; 1910 } 1911 case Instruction::XOR_LONG_2ADDR: { 1912 PREAMBLE(); 1913 uint4_t vregA = inst->VRegA_12x(inst_data); 1914 shadow_frame.SetVRegLong(vregA, 1915 shadow_frame.GetVRegLong(vregA) ^ 1916 shadow_frame.GetVRegLong(inst->VRegB_12x(inst_data))); 1917 inst = inst->Next_1xx(); 1918 break; 1919 } 1920 case Instruction::SHL_LONG_2ADDR: { 1921 PREAMBLE(); 1922 uint4_t vregA = inst->VRegA_12x(inst_data); 1923 shadow_frame.SetVRegLong(vregA, 1924 shadow_frame.GetVRegLong(vregA) << 1925 (shadow_frame.GetVReg(inst->VRegB_12x(inst_data)) & 0x3f)); 1926 inst = inst->Next_1xx(); 1927 break; 1928 } 1929 case Instruction::SHR_LONG_2ADDR: { 1930 PREAMBLE(); 1931 uint4_t vregA = inst->VRegA_12x(inst_data); 1932 shadow_frame.SetVRegLong(vregA, 1933 shadow_frame.GetVRegLong(vregA) >> 1934 (shadow_frame.GetVReg(inst->VRegB_12x(inst_data)) & 0x3f)); 1935 inst = inst->Next_1xx(); 1936 break; 1937 } 1938 case Instruction::USHR_LONG_2ADDR: { 1939 PREAMBLE(); 1940 uint4_t vregA = inst->VRegA_12x(inst_data); 1941 shadow_frame.SetVRegLong(vregA, 1942 static_cast<uint64_t>(shadow_frame.GetVRegLong(vregA)) >> 1943 (shadow_frame.GetVReg(inst->VRegB_12x(inst_data)) & 0x3f)); 1944 inst = inst->Next_1xx(); 1945 break; 1946 } 1947 case Instruction::ADD_FLOAT_2ADDR: { 1948 PREAMBLE(); 1949 uint4_t vregA = inst->VRegA_12x(inst_data); 1950 shadow_frame.SetVRegFloat(vregA, 1951 shadow_frame.GetVRegFloat(vregA) + 1952 shadow_frame.GetVRegFloat(inst->VRegB_12x(inst_data))); 1953 inst = inst->Next_1xx(); 1954 break; 1955 } 1956 case Instruction::SUB_FLOAT_2ADDR: { 1957 PREAMBLE(); 1958 uint4_t vregA = inst->VRegA_12x(inst_data); 1959 shadow_frame.SetVRegFloat(vregA, 1960 shadow_frame.GetVRegFloat(vregA) - 1961 shadow_frame.GetVRegFloat(inst->VRegB_12x(inst_data))); 1962 inst = inst->Next_1xx(); 1963 break; 1964 } 1965 case Instruction::MUL_FLOAT_2ADDR: { 1966 PREAMBLE(); 1967 uint4_t vregA = inst->VRegA_12x(inst_data); 1968 shadow_frame.SetVRegFloat(vregA, 1969 shadow_frame.GetVRegFloat(vregA) * 1970 shadow_frame.GetVRegFloat(inst->VRegB_12x(inst_data))); 1971 inst = inst->Next_1xx(); 1972 break; 1973 } 1974 case Instruction::DIV_FLOAT_2ADDR: { 1975 PREAMBLE(); 1976 uint4_t vregA = inst->VRegA_12x(inst_data); 1977 shadow_frame.SetVRegFloat(vregA, 1978 shadow_frame.GetVRegFloat(vregA) / 1979 shadow_frame.GetVRegFloat(inst->VRegB_12x(inst_data))); 1980 inst = inst->Next_1xx(); 1981 break; 1982 } 1983 case Instruction::REM_FLOAT_2ADDR: { 1984 PREAMBLE(); 1985 uint4_t vregA = inst->VRegA_12x(inst_data); 1986 shadow_frame.SetVRegFloat(vregA, 1987 fmodf(shadow_frame.GetVRegFloat(vregA), 1988 shadow_frame.GetVRegFloat(inst->VRegB_12x(inst_data)))); 1989 inst = inst->Next_1xx(); 1990 break; 1991 } 1992 case Instruction::ADD_DOUBLE_2ADDR: { 1993 PREAMBLE(); 1994 uint4_t vregA = inst->VRegA_12x(inst_data); 1995 shadow_frame.SetVRegDouble(vregA, 1996 shadow_frame.GetVRegDouble(vregA) + 1997 shadow_frame.GetVRegDouble(inst->VRegB_12x(inst_data))); 1998 inst = inst->Next_1xx(); 1999 break; 2000 } 2001 case Instruction::SUB_DOUBLE_2ADDR: { 2002 PREAMBLE(); 2003 uint4_t vregA = inst->VRegA_12x(inst_data); 2004 shadow_frame.SetVRegDouble(vregA, 2005 shadow_frame.GetVRegDouble(vregA) - 2006 shadow_frame.GetVRegDouble(inst->VRegB_12x(inst_data))); 2007 inst = inst->Next_1xx(); 2008 break; 2009 } 2010 case Instruction::MUL_DOUBLE_2ADDR: { 2011 PREAMBLE(); 2012 uint4_t vregA = inst->VRegA_12x(inst_data); 2013 shadow_frame.SetVRegDouble(vregA, 2014 shadow_frame.GetVRegDouble(vregA) * 2015 shadow_frame.GetVRegDouble(inst->VRegB_12x(inst_data))); 2016 inst = inst->Next_1xx(); 2017 break; 2018 } 2019 case Instruction::DIV_DOUBLE_2ADDR: { 2020 PREAMBLE(); 2021 uint4_t vregA = inst->VRegA_12x(inst_data); 2022 shadow_frame.SetVRegDouble(vregA, 2023 shadow_frame.GetVRegDouble(vregA) / 2024 shadow_frame.GetVRegDouble(inst->VRegB_12x(inst_data))); 2025 inst = inst->Next_1xx(); 2026 break; 2027 } 2028 case Instruction::REM_DOUBLE_2ADDR: { 2029 PREAMBLE(); 2030 uint4_t vregA = inst->VRegA_12x(inst_data); 2031 shadow_frame.SetVRegDouble(vregA, 2032 fmod(shadow_frame.GetVRegDouble(vregA), 2033 shadow_frame.GetVRegDouble(inst->VRegB_12x(inst_data)))); 2034 inst = inst->Next_1xx(); 2035 break; 2036 } 2037 case Instruction::ADD_INT_LIT16: 2038 PREAMBLE(); 2039 shadow_frame.SetVReg(inst->VRegA_22s(inst_data), 2040 shadow_frame.GetVReg(inst->VRegB_22s(inst_data)) + 2041 inst->VRegC_22s()); 2042 inst = inst->Next_2xx(); 2043 break; 2044 case Instruction::RSUB_INT: 2045 PREAMBLE(); 2046 shadow_frame.SetVReg(inst->VRegA_22s(inst_data), 2047 inst->VRegC_22s() - 2048 shadow_frame.GetVReg(inst->VRegB_22s(inst_data))); 2049 inst = inst->Next_2xx(); 2050 break; 2051 case Instruction::MUL_INT_LIT16: 2052 PREAMBLE(); 2053 shadow_frame.SetVReg(inst->VRegA_22s(inst_data), 2054 shadow_frame.GetVReg(inst->VRegB_22s(inst_data)) * 2055 inst->VRegC_22s()); 2056 inst = inst->Next_2xx(); 2057 break; 2058 case Instruction::DIV_INT_LIT16: { 2059 PREAMBLE(); 2060 bool success = DoIntDivide(shadow_frame, inst->VRegA_22s(inst_data), 2061 shadow_frame.GetVReg(inst->VRegB_22s(inst_data)), inst->VRegC_22s()); 2062 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); 2063 break; 2064 } 2065 case Instruction::REM_INT_LIT16: { 2066 PREAMBLE(); 2067 bool success = DoIntRemainder(shadow_frame, inst->VRegA_22s(inst_data), 2068 shadow_frame.GetVReg(inst->VRegB_22s(inst_data)), inst->VRegC_22s()); 2069 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); 2070 break; 2071 } 2072 case Instruction::AND_INT_LIT16: 2073 PREAMBLE(); 2074 shadow_frame.SetVReg(inst->VRegA_22s(inst_data), 2075 shadow_frame.GetVReg(inst->VRegB_22s(inst_data)) & 2076 inst->VRegC_22s()); 2077 inst = inst->Next_2xx(); 2078 break; 2079 case Instruction::OR_INT_LIT16: 2080 PREAMBLE(); 2081 shadow_frame.SetVReg(inst->VRegA_22s(inst_data), 2082 shadow_frame.GetVReg(inst->VRegB_22s(inst_data)) | 2083 inst->VRegC_22s()); 2084 inst = inst->Next_2xx(); 2085 break; 2086 case Instruction::XOR_INT_LIT16: 2087 PREAMBLE(); 2088 shadow_frame.SetVReg(inst->VRegA_22s(inst_data), 2089 shadow_frame.GetVReg(inst->VRegB_22s(inst_data)) ^ 2090 inst->VRegC_22s()); 2091 inst = inst->Next_2xx(); 2092 break; 2093 case Instruction::ADD_INT_LIT8: 2094 PREAMBLE(); 2095 shadow_frame.SetVReg(inst->VRegA_22b(inst_data), 2096 shadow_frame.GetVReg(inst->VRegB_22b()) + 2097 inst->VRegC_22b()); 2098 inst = inst->Next_2xx(); 2099 break; 2100 case Instruction::RSUB_INT_LIT8: 2101 PREAMBLE(); 2102 shadow_frame.SetVReg(inst->VRegA_22b(inst_data), 2103 inst->VRegC_22b() - 2104 shadow_frame.GetVReg(inst->VRegB_22b())); 2105 inst = inst->Next_2xx(); 2106 break; 2107 case Instruction::MUL_INT_LIT8: 2108 PREAMBLE(); 2109 shadow_frame.SetVReg(inst->VRegA_22b(inst_data), 2110 shadow_frame.GetVReg(inst->VRegB_22b()) * 2111 inst->VRegC_22b()); 2112 inst = inst->Next_2xx(); 2113 break; 2114 case Instruction::DIV_INT_LIT8: { 2115 PREAMBLE(); 2116 bool success = DoIntDivide(shadow_frame, inst->VRegA_22b(inst_data), 2117 shadow_frame.GetVReg(inst->VRegB_22b()), inst->VRegC_22b()); 2118 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); 2119 break; 2120 } 2121 case Instruction::REM_INT_LIT8: { 2122 PREAMBLE(); 2123 bool success = DoIntRemainder(shadow_frame, inst->VRegA_22b(inst_data), 2124 shadow_frame.GetVReg(inst->VRegB_22b()), inst->VRegC_22b()); 2125 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); 2126 break; 2127 } 2128 case Instruction::AND_INT_LIT8: 2129 PREAMBLE(); 2130 shadow_frame.SetVReg(inst->VRegA_22b(inst_data), 2131 shadow_frame.GetVReg(inst->VRegB_22b()) & 2132 inst->VRegC_22b()); 2133 inst = inst->Next_2xx(); 2134 break; 2135 case Instruction::OR_INT_LIT8: 2136 PREAMBLE(); 2137 shadow_frame.SetVReg(inst->VRegA_22b(inst_data), 2138 shadow_frame.GetVReg(inst->VRegB_22b()) | 2139 inst->VRegC_22b()); 2140 inst = inst->Next_2xx(); 2141 break; 2142 case Instruction::XOR_INT_LIT8: 2143 PREAMBLE(); 2144 shadow_frame.SetVReg(inst->VRegA_22b(inst_data), 2145 shadow_frame.GetVReg(inst->VRegB_22b()) ^ 2146 inst->VRegC_22b()); 2147 inst = inst->Next_2xx(); 2148 break; 2149 case Instruction::SHL_INT_LIT8: 2150 PREAMBLE(); 2151 shadow_frame.SetVReg(inst->VRegA_22b(inst_data), 2152 shadow_frame.GetVReg(inst->VRegB_22b()) << 2153 (inst->VRegC_22b() & 0x1f)); 2154 inst = inst->Next_2xx(); 2155 break; 2156 case Instruction::SHR_INT_LIT8: 2157 PREAMBLE(); 2158 shadow_frame.SetVReg(inst->VRegA_22b(inst_data), 2159 shadow_frame.GetVReg(inst->VRegB_22b()) >> 2160 (inst->VRegC_22b() & 0x1f)); 2161 inst = inst->Next_2xx(); 2162 break; 2163 case Instruction::USHR_INT_LIT8: 2164 PREAMBLE(); 2165 shadow_frame.SetVReg(inst->VRegA_22b(inst_data), 2166 static_cast<uint32_t>(shadow_frame.GetVReg(inst->VRegB_22b())) >> 2167 (inst->VRegC_22b() & 0x1f)); 2168 inst = inst->Next_2xx(); 2169 break; 2170 case Instruction::UNUSED_3E ... Instruction::UNUSED_43: 2171 case Instruction::UNUSED_EB ... Instruction::UNUSED_FF: 2172 case Instruction::UNUSED_79: 2173 case Instruction::UNUSED_7A: 2174 UnexpectedOpcode(inst, mh); 2175 } 2176 } 2177 } // NOLINT(readability/fn_size) 2178 2179 // Explicit definitions of ExecuteSwitchImpl. 2180 template SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) HOT_ATTR 2181 JValue ExecuteSwitchImpl<true, false>(Thread* self, MethodHelper& mh, 2182 const DexFile::CodeItem* code_item, 2183 ShadowFrame& shadow_frame, JValue result_register); 2184 template SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) HOT_ATTR 2185 JValue ExecuteSwitchImpl<false, false>(Thread* self, MethodHelper& mh, 2186 const DexFile::CodeItem* code_item, 2187 ShadowFrame& shadow_frame, JValue result_register); 2188 template SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) 2189 JValue ExecuteSwitchImpl<true, true>(Thread* self, MethodHelper& mh, 2190 const DexFile::CodeItem* code_item, 2191 ShadowFrame& shadow_frame, JValue result_register); 2192 template SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) 2193 JValue ExecuteSwitchImpl<false, true>(Thread* self, MethodHelper& mh, 2194 const DexFile::CodeItem* code_item, 2195 ShadowFrame& shadow_frame, JValue result_register); 2196 2197 } // namespace interpreter 2198 } // namespace art 2199
