Lines Matching full:instruction
361 const Instruction* inst = Instruction::At(code_item_->insns_ + dex_pc);
389 const Instruction* inst = Instruction::At(code_item_->insns_ + dex_pc);
390 const bool is_range = (inst->Opcode() == Instruction
410 // Allocate and initialize an array to hold instruction data.
416 // Perform static instruction verification.
442 // If we fail again at runtime, mark that this instruction would throw and force this
491 const Instruction* inst = Instruction::At(insns);
497 Instruction::Code opcode = inst->Opcode();
498 if (opcode == Instruction::NEW_INSTANCE) {
500 } else if (opcode == Instruction::MONITOR_ENTER) {
502 } else if (opcode == Instruction::CHECK_CAST) {
504 } else if ((inst->Opcode() == Instruction::INVOKE_VIRTUAL) ||
505 (inst->Opcode() == Instruction::INVOKE_VIRTUAL_RANGE) ||
506 (inst->Opcode() == Instruction::INVOKE_INTERFACE) ||
507 (inst->Opcode() == Instruction::INVOKE_INTERFACE_RANGE)) {
546 << "'try' block starts inside an instruction (" << start << ")";
586 const Instruction* inst = Instruction::At(code_item_->insns_);
612 bool MethodVerifier::VerifyInstruction(const Instruction* inst, uint32_t code_offset) {
616 case Instruction::kVerifyRegA:
619 case Instruction::kVerifyRegAWide:
624 case Instruction::kVerifyRegB:
627 case Instruction::kVerifyRegBField:
630 case Instruction::kVerifyRegBMethod:
633 case Instruction::kVerifyRegBNewInstance:
636 case Instruction::kVerifyRegBString:
639 case Instruction::kVerifyRegBType:
642 case Instruction::kVerifyRegBWide:
647 case Instruction::kVerifyRegC:
650 case Instruction::kVerifyRegCField:
653 case Instruction::kVerifyRegCNewArray:
656 case Instruction::kVerifyRegCType:
659 case Instruction::kVerifyRegCWide:
664 case Instruction::kVerifyArrayData:
667 case Instruction::kVerifyBranchTarget:
670 case Instruction::kVerifySwitchTargets:
673 case Instruction::kVerifyVarArg:
676 case Instruction::kVerifyVarArgRange:
679 case Instruction::kVerifyError:
858 case Instruction::GOTO:
861 case Instruction::GOTO_32:
865 case Instruction::GOTO_16:
868 case Instruction::IF_EQ:
869 case Instruction::IF_NE:
870 case Instruction::IF_LT:
871 case Instruction::IF_GE:
872 case Instruction::IF_GT:
873 case Instruction::IF_LE:
874 case Instruction::IF_EQZ:
875 case Instruction::IF_NEZ:
876 case Instruction::IF_LTZ:
877 case Instruction::IF_GEZ:
878 case Instruction::IF_GTZ:
879 case Instruction::IF_LEZ:
913 if ((*insns & 0xff) == Instruction::PACKED_SWITCH) {
917 expected_signature = Instruction::kPackedSwitchSignature;
922 expected_signature = Instruction::kSparseSwitchSignature;
1118 const Instruction* inst = Instruction::At(code_item_->insns_);
1277 /* Begin by marking the first instruction as "changed". */
1299 // We carry the working set of registers from instruction to instruction. If this address can
1300 // be the target of a branch (or throw) instruction, or if we're skipping around chasing
1302 // Because we always prefer to continue on to the next instruction, we should never have a
1303 // situation where we have a stray "changed" flag set on an instruction that isn't a branch
1354 if (insns[insn_idx] == Instruction::kPackedSwitchSignature ||
1355 insns[insn_idx] == Instruction::kSparseSwitchSignature ||
1356 insns[insn_idx] == Instruction::kArrayDataSignature ||
1357 (insns[insn_idx] == Instruction::NOP && (insn_idx + 1 < insns_size) &&
1358 (insns[insn_idx + 1] == Instruction::kPackedSwitchSignature ||
1359 insns[insn_idx + 1] == Instruction::kSparseSwitchSignature ||
1360 insns[insn_idx + 1] == Instruction::kArrayDataSignature))) {
1388 // We want the state _before_ the instruction, for the case where the dex pc we're
1389 // interested in is itself a monitor-enter instruction (which is a likely place
1399 * Once we finish decoding the instruction, we need to figure out where
1403 * (1) Continue to the next instruction. Applies to all but
1407 * (3) Exception handlers. Applies to any instruction that can
1411 * We can also return, in which case there is no successor instruction
1417 const Instruction* inst = Instruction::At(insns);
1418 int opcode_flags = Instruction::FlagsOf(inst->Opcode());
1429 * Make a copy of the previous register state. If the instruction
1435 if ((opcode_flags & Instruction::kThrow) != 0 && CurrentInsnFlags()->IsInTry()) {
1445 // peephole pattern we compute a new line for either the fallthrough instruction or the
1451 case Instruction::NOP:
1458 Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "encountered data table in instruction stream";
1462 case Instruction::MOVE:
1465 case Instruction::MOVE_FROM16:
1468 case Instruction::MOVE_16:
1471 case Instruction::MOVE_WIDE:
1474 case Instruction::MOVE_WIDE_FROM16:
1477 case Instruction::MOVE_WIDE_16:
1480 case Instruction::MOVE_OBJECT:
1483 case Instruction::MOVE_OBJECT_FROM16:
1486 case Instruction::MOVE_OBJECT_16:
1501 case Instruction::MOVE_RESULT:
1504 case Instruction::MOVE_RESULT_WIDE:
1507 case Instruction::MOVE_RESULT_OBJECT:
1511 case Instruction::MOVE_EXCEPTION: {
1513 * This statement can only appear as the first instruction in an exception handler. We verify
1520 case Instruction::RETURN_VOID:
1527 case Instruction::RETURN:
1552 case Instruction::RETURN_WIDE:
1568 case Instruction::RETURN_OBJECT:
1598 case Instruction::CONST_4: {
1603 case Instruction::CONST_16: {
1608 case Instruction::CONST:
1612 case Instruction::CONST_HIGH16:
1617 case Instruction::CONST_WIDE_16: {
1624 case Instruction::CONST_WIDE_32: {
1631 case Instruction::CONST_WIDE: {
1638 case Instruction::CONST_WIDE_HIGH16: {
1645 case Instruction::CONST_STRING:
1648 case Instruction::CONST_STRING_JUMBO:
1651 case Instruction::CONST_CLASS: {
1652 // Get type from instruction if unresolved then we need an access check
1661 case Instruction::MONITOR_ENTER:
1664 case Instruction::MONITOR_EXIT:
1668 * pointing to the following instruction. (This behavior goes back
1676 * failed on the -enter instruction, and the latter is impossible.
1685 opcode_flags &= ~Instruction::kThrow;
1689 case Instruction::CHECK_CAST:
1690 case Instruction::INSTANCE_OF: {
1692 * If this instruction succeeds, we will "downcast" register vA to the type in vB. (This
1698 const bool is_checkcast = (inst->Opcode() == Instruction::CHECK_CAST);
1732 case Instruction::ARRAY_LENGTH: {
1743 case Instruction::NEW_INSTANCE: {
1764 case Instruction::NEW_ARRAY:
1767 case Instruction::FILLED_NEW_ARRAY:
1771 case Instruction::FILLED_NEW_ARRAY_RANGE:
1775 case Instruction::CMPL_FLOAT:
1776 case Instruction::CMPG_FLOAT:
1785 case Instruction::CMPL_DOUBLE:
1786 case Instruction::CMPG_DOUBLE:
1797 case Instruction::CMP_LONG:
1808 case Instruction::THROW: {
1816 case Instruction::GOTO:
1817 case Instruction::GOTO_16:
1818 case Instruction::GOTO_32:
1822 case Instruction::PACKED_SWITCH:
1823 case Instruction::SPARSE_SWITCH:
1828 case Instruction::FILL_ARRAY_DATA: {
1846 if (array_data[0] != Instruction::kArrayDataSignature) {
1862 case Instruction::IF_EQ:
1863 case Instruction::IF_NE: {
1880 case Instruction::IF_LT:
1881 case Instruction::IF_GE:
1882 case Instruction::IF_GT:
1883 case Instruction::IF_LE: {
1892 case Instruction::IF_EQZ:
1893 case Instruction::IF_NEZ: {
1900 // Find previous instruction - its existence is a precondition to peephole optimization.
1912 const Instruction* instance_of_inst = Instruction::At(code_item_->insns_ + instance_of_idx);
1927 (Instruction::INSTANCE_OF == instance_of_inst->Opcode()) &&
1939 if (inst->Opcode() == Instruction::IF_EQZ) {
1955 const Instruction* move_inst = Instruction::At(code_item_->insns_ + move_idx);
1957 case Instruction::MOVE_OBJECT:
1962 case Instruction::MOVE_OBJECT_FROM16:
1967 case Instruction::MOVE_OBJECT_16:
1981 case Instruction::IF_LTZ:
1982 case Instruction::IF_GEZ:
1983 case Instruction::IF_GTZ:
1984 case Instruction::IF_LEZ: {
1992 case Instruction::AGET_BOOLEAN:
1995 case Instruction::AGET_BYTE:
1998 case Instruction::AGET_CHAR:
2001 case Instruction::AGET_SHORT:
2004 case Instruction::AGET:
2007 case Instruction::AGET_WIDE:
2010 case Instruction::AGET_OBJECT:
2014 case Instruction::APUT_BOOLEAN:
2017 case Instruction::APUT_BYTE:
2020 case Instruction::APUT_CHAR:
2023 case Instruction::APUT_SHORT:
2026 case Instruction::APUT:
2029 case Instruction::APUT_WIDE:
2032 case Instruction::APUT_OBJECT:
2036 case Instruction::IGET_BOOLEAN:
2039 case Instruction::IGET_BYTE:
2042 case Instruction::IGET_CHAR:
2045 case Instruction::IGET_SHORT:
2048 case Instruction::IGET:
2051 case Instruction::IGET_WIDE:
2054 case Instruction::IGET_OBJECT:
2058 case Instruction::IPUT_BOOLEAN:
2061 case Instruction::IPUT_BYTE:
2064 case Instruction::IPUT_CHAR:
2067 case Instruction::IPUT_SHORT:
2070 case Instruction::IPUT:
2073 case Instruction::IPUT_WIDE:
2076 case Instruction::IPUT_OBJECT:
2080 case Instruction::SGET_BOOLEAN:
2083 case Instruction::SGET_BYTE:
2086 case Instruction::SGET_CHAR:
2089 case Instruction::SGET_SHORT:
2092 case Instruction::SGET:
2095 case Instruction::SGET_WIDE:
2098 case Instruction::SGET_OBJECT:
2102 case Instruction::SPUT_BOOLEAN:
2105 case Instruction::SPUT_BYTE:
2108 case Instruction::SPUT_CHAR:
2111 case Instruction::SPUT_SHORT:
2114 case Instruction::SPUT:
2117 case Instruction::SPUT_WIDE:
2120 case Instruction::SPUT_OBJECT:
2124 case Instruction::INVOKE_VIRTUAL:
2125 case Instruction::INVOKE_VIRTUAL_RANGE:
2126 case Instruction::INVOKE_SUPER:
2127 case Instruction::INVOKE_SUPER_RANGE: {
2128 bool is_range = (inst->Opcode() == Instruction::INVOKE_VIRTUAL_RANGE ||
2129 inst->Opcode() == Instruction::INVOKE_SUPER_RANGE);
2130 bool is_super = (inst->Opcode() == Instruction::INVOKE_SUPER ||
2131 inst->Opcode() == Instruction::INVOKE_SUPER_RANGE);
2152 case Instruction::INVOKE_DIRECT:
2153 case Instruction::INVOKE_DIRECT_RANGE: {
2154 bool is_range = (inst->Opcode() == Instruction::INVOKE_DIRECT_RANGE);
2219 case Instruction::INVOKE_STATIC:
2220 case Instruction::INVOKE_STATIC_RANGE: {
2221 bool is_range = (inst->Opcode() == Instruction::INVOKE_STATIC_RANGE);
2244 case Instruction::INVOKE_INTERFACE:
2245 case Instruction::INVOKE_INTERFACE_RANGE: {
2246 bool is_range = (inst->Opcode() == Instruction::INVOKE_INTERFACE_RANGE);
2301 case Instruction::NEG_INT:
2302 case Instruction::NOT_INT:
2305 case Instruction::NEG_LONG:
2306 case Instruction::NOT_LONG:
2310 case Instruction::NEG_FLOAT:
2313 case Instruction::NEG_DOUBLE:
2317 case Instruction::INT_TO_LONG:
2321 case Instruction::INT_TO_FLOAT:
2324 case Instruction::INT_TO_DOUBLE:
2328 case Instruction
2332 case Instruction::LONG_TO_FLOAT:
2336 case Instruction::LONG_TO_DOUBLE:
2340 case Instruction::FLOAT_TO_INT:
2343 case Instruction::FLOAT_TO_LONG:
2347 case Instruction::FLOAT_TO_DOUBLE:
2351 case Instruction::DOUBLE_TO_INT:
2355 case Instruction::DOUBLE_TO_LONG:
2359 case Instruction::DOUBLE_TO_FLOAT:
2363 case Instruction::INT_TO_BYTE:
2366 case Instruction::INT_TO_CHAR:
2369 case Instruction::INT_TO_SHORT:
2373 case Instruction::ADD_INT:
2374 case Instruction::SUB_INT:
2375 case Instruction::MUL_INT:
2376 case Instruction::REM_INT:
2377 case Instruction::DIV_INT:
2378 case Instruction::SHL_INT:
2379 case Instruction::SHR_INT:
2380 case Instruction::USHR_INT:
2384 case Instruction::AND_INT:
2385 case Instruction::OR_INT:
2386 case Instruction::XOR_INT:
2390 case Instruction::ADD_LONG:
2391 case Instruction::SUB_LONG:
2392 case Instruction::MUL_LONG:
2393 case Instruction::DIV_LONG:
2394 case Instruction::REM_LONG:
2395 case Instruction::AND_LONG:
2396 case Instruction::OR_LONG:
2397 case Instruction::XOR_LONG:
2402 case Instruction::SHL_LONG:
2403 case Instruction::SHR_LONG:
2404 case Instruction::USHR_LONG:
2409 case Instruction::ADD_FLOAT:
2410 case Instruction::SUB_FLOAT:
2411 case Instruction::MUL_FLOAT:
2412 case Instruction::DIV_FLOAT:
2413 case Instruction::REM_FLOAT:
2420 case Instruction::ADD_DOUBLE:
2421 case Instruction::SUB_DOUBLE:
2422 case Instruction::MUL_DOUBLE:
2423 case Instruction::DIV_DOUBLE:
2424 case Instruction::REM_DOUBLE:
2429 case Instruction::ADD_INT_2ADDR:
2430 case Instruction::SUB_INT_2ADDR:
2431 case Instruction::MUL_INT_2ADDR:
2432 case Instruction::REM_INT_2ADDR:
2433 case Instruction::SHL_INT_2ADDR:
2434 case Instruction::SHR_INT_2ADDR:
2435 case Instruction::USHR_INT_2ADDR:
2442 case Instruction::AND_INT_2ADDR:
2443 case Instruction::OR_INT_2ADDR:
2444 case Instruction::XOR_INT_2ADDR:
2451 case Instruction::DIV_INT_2ADDR:
2458 case Instruction::ADD_LONG_2ADDR:
2459 case Instruction::SUB_LONG_2ADDR:
2460 case Instruction::MUL_LONG_2ADDR:
2461 case Instruction::DIV_LONG_2ADDR:
2462 case Instruction::REM_LONG_2ADDR:
2463 case Instruction::AND_LONG_2ADDR:
2464 case Instruction::OR_LONG_2ADDR:
2465 case Instruction::XOR_LONG_2ADDR:
2470 case Instruction::SHL_LONG_2ADDR:
2471 case Instruction::SHR_LONG_2ADDR:
2472 case Instruction::USHR_LONG_2ADDR:
2476 case Instruction::ADD_FLOAT_2ADDR:
2477 case Instruction::SUB_FLOAT_2ADDR:
2478 case Instruction::MUL_FLOAT_2ADDR:
2479 case Instruction::DIV_FLOAT_2ADDR:
2480 case Instruction::REM_FLOAT_2ADDR:
2487 case Instruction::ADD_DOUBLE_2ADDR:
2488 case Instruction::SUB_DOUBLE_2ADDR:
2489 case Instruction::MUL_DOUBLE_2ADDR:
2490 case Instruction::DIV_DOUBLE_2ADDR:
2491 case Instruction::REM_DOUBLE_2ADDR:
2496 case Instruction::ADD_INT_LIT16:
2497 case Instruction::RSUB_INT:
2498 case Instruction::MUL_INT_LIT16:
2499 case Instruction::DIV_INT_LIT16:
2500 case Instruction::REM_INT_LIT16:
2503 case Instruction::AND_INT_LIT16:
2504 case Instruction::OR_INT_LIT16:
2505 case Instruction::XOR_INT_LIT16:
2508 case Instruction::ADD_INT_LIT8:
2509 case Instruction::RSUB_INT_LIT8:
2510 case Instruction::MUL_INT_LIT8:
2511 case Instruction::DIV_INT_LIT8:
2512 case Instruction::REM_INT_LIT8:
2513 case Instruction::SHL_INT_LIT8:
2514 case Instruction::SHR_INT_LIT8:
2515 case Instruction::USHR_INT_LIT8:
2518 case Instruction::AND_INT_LIT8:
2519 case Instruction::OR_INT_LIT8:
2520 case Instruction::XOR_INT_LIT8:
2525 case Instruction::RETURN_VOID_BARRIER:
2534 case Instruction::IGET_QUICK:
2537 case Instruction::IGET_WIDE_QUICK:
2540 case Instruction::IGET_OBJECT_QUICK:
2543 case Instruction::IPUT_QUICK:
2546 case Instruction::IPUT_WIDE_QUICK:
2549 case Instruction::IPUT_OBJECT_QUICK:
2552 case Instruction::INVOKE_VIRTUAL_QUICK:
2553 case Instruction::INVOKE_VIRTUAL_RANGE_QUICK: {
2554 bool is_range = (inst->Opcode() == Instruction::INVOKE_VIRTUAL_RANGE_QUICK);
2570 case Instruction::UNUSED_3E:
2571 case Instruction::UNUSED_3F:
2572 case Instruction::UNUSED_40:
2573 case Instruction::UNUSED_41:
2574 case Instruction::UNUSED_42:
2575 case Instruction::UNUSED_43:
2576 case Instruction::UNUSED_79:
2577 case Instruction::UNUSED_7A:
2578 case Instruction::UNUSED_EB:
2579 case Instruction::UNUSED_EC:
2580 case Instruction::UNUSED_ED:
2581 case Instruction::UNUSED_EE:
2582 case Instruction::UNUSED_EF:
2583 case Instruction::UNUSED_F0:
2584 case Instruction::UNUSED_F1:
2585 case Instruction::UNUSED_F2:
2586 case Instruction::UNUSED_F3:
2587 case Instruction::UNUSED_F4:
2588 case Instruction::UNUSED_F5:
2589 case Instruction::UNUSED_F6:
2590 case Instruction::UNUSED_F7:
2591 case Instruction::UNUSED_F8:
2592 case Instruction::UNUSED_F9:
2593 case Instruction::UNUSED_FA:
2594 case Instruction::UNUSED_FB:
2595 case Instruction::UNUSED_FC:
2596 case Instruction::UNUSED_FD:
2597 case Instruction::UNUSED_FE:
2598 case Instruction::UNUSED_FF:
2604 * complain if an instruction is missing (which is desirable).
2618 opcode_flags = Instruction::kThrow;
2634 * NOTE: instructions like Instruction::EQZ provide information about the
2643 if ((opcode_flags & Instruction::kBranch) != 0) {
2650 DCHECK_EQ(isConditional, (opcode_flags & Instruction::kContinue) != 0);
2672 if ((opcode_flags & Instruction::kSwitch) != 0) {
2678 if ((*insns & 0xff) == Instruction::PACKED_SWITCH) {
2683 DCHECK((*insns & 0xff) == Instruction::SPARSE_SWITCH);
2709 if ((opcode_flags & Instruction::kThrow) != 0 && insn_flags_[work_insn_idx_].IsInTry()) {
2719 * "work_regs", because at runtime the exception will be thrown before the instruction
2729 * instruction. This does apply to monitor-exit because of async exception handling.
2733 * The state in work_line reflects the post-execution state. If the current instruction is a
2737 if (inst->Opcode() != Instruction::MONITOR_ENTER || work_line_->MonitorStackDepth() != 1) {
2739 << "expected to be within a catch-all for an instruction where a monitor is held";
2745 /* Handle "continue". Tag the next consecutive instruction.
2750 if ((opcode_flags & Instruction::kContinue) != 0) {
2756 // The only way to get to a move-exception instruction is to get thrown there. Make sure the
2757 // next instruction isn't one.
2767 const Instruction* ret_inst = Instruction::At(code_item_->insns_ + next_insn_idx);
2768 Instruction::Code opcode = ret_inst->Opcode();
2769 if ((opcode == Instruction::RETURN_VOID) || (opcode == Instruction::RETURN_VOID_BARRIER)) {
2772 if (opcode == Instruction::RETURN_WIDE) {
2781 // Merge registers into what we have for the next instruction,
2788 * We're not recording register data for the next instruction, so we don't know what the
2796 if ((opcode_flags & Instruction::kReturn) != 0) {
2803 * Update start_guess. Advance to the next instruction of that's
2808 if ((opcode_flags & Instruction::kContinue) != 0) {
2810 } else if ((opcode_flags & Instruction::kBranch) != 0) {
2973 // See if the method type implied by the invoke instruction matches the access flags for the
2986 mirror::ArtMethod* MethodVerifier::VerifyInvocationArgs(const Instruction* inst,
3109 mirror::ArtMethod* MethodVerifier::GetQuickInvokedMethod(const Instruction* inst,
3112 DCHECK(inst->Opcode() == Instruction::INVOKE_VIRTUAL_QUICK ||
3113 inst->Opcode() == Instruction::INVOKE_VIRTUAL_RANGE_QUICK);
3143 mirror::ArtMethod* MethodVerifier::VerifyInvokeVirtualQuickArgs(const Instruction* inst,
3234 void MethodVerifier::VerifyNewArray(const Instruction* inst, bool is_filled, bool is_range) {
3237 DCHECK_EQ(inst->Opcode(), Instruction::NEW_ARRAY);
3240 DCHECK_EQ(inst->Opcode(), Instruction::FILLED_NEW_ARRAY);
3243 DCHECK_EQ(inst->Opcode(), Instruction::FILLED_NEW_ARRAY_RANGE);
3282 void MethodVerifier::VerifyAGet(const Instruction* inst,
3291 // instruction type. TODO: have a proper notion of bottom here.
3318 // instruction, which can't differentiate object types and ints from floats, longs from
3368 void MethodVerifier::VerifyAPut(const Instruction* inst,
3377 // instruction type.
3390 // The instruction agrees with the type of array, confirm the value to be stored does too
3391 // Note: we use the instruction type (rather than the component type) for aput-object as
3500 void MethodVerifier::VerifyISGet(const Instruction* inst, const RegType& insn_type,
3554 void MethodVerifier::VerifyISPut(const Instruction* inst, const RegType& insn_type,
3621 mirror::ArtField* MethodVerifier::GetQuickFieldAccess(const Instruction* inst,
3623 DCHECK(inst->Opcode() == Instruction::IGET_QUICK ||
3624 inst->Opcode() == Instruction::IGET_WIDE_QUICK ||
3625 inst->Opcode() == Instruction::IGET_OBJECT_QUICK ||
3626 inst->Opcode() == Instruction::IPUT_QUICK ||
3627 inst->Opcode() == Instruction::IPUT_WIDE_QUICK ||
3628 inst->Opcode() == Instruction::IPUT_OBJECT_QUICK);
3653 void MethodVerifier::VerifyIGetQuick(const Instruction* inst, const RegType& insn_type,
3697 void MethodVerifier::VerifyIPutQuick(const Instruction* inst, const RegType& insn_type,
3767 if ((insns[insn_idx] & 0xff) == Instruction::MOVE_EXCEPTION) {
3779 * We haven't processed this instruction before, and we haven't touched the registers here, so
3792 const Instruction* ret_inst = Instruction::At(code_item_->insns_ + next_insn);
3793 Instruction::Code opcode = ret_inst->Opcode();
3794 if ((opcode == Instruction::RETURN_VOID) || (opcode == Instruction::RETURN_VOID_BARRIER)) {
3798 if (opcode == Instruction::RETURN_WIDE) {
3890 const Instruction* inst = Instruction::At(code_item_->insns_);
3891 const Instruction* end = Instruction::At(code_item_->insns_ +
3895 if (Instruction::CHECK_CAST != inst->Opcode()) {
3921 const Instruction* inst = Instruction::At(insns);
3922 const Instruction* end = Instruction::At(insns + code_item_->insns_size_in_code_units_);
3925 bool is_virtual = (inst->Opcode() == Instruction::INVOKE_VIRTUAL) ||
3926 (inst->Opcode() == Instruction::INVOKE_VIRTUAL_RANGE);
3927 bool is_interface = (inst->Opcode() == Instruction::INVOKE_INTERFACE) ||
3928 (inst->Opcode() == Instruction::INVOKE_INTERFACE_RANGE);
3936 bool is_range = (inst->Opcode() == Instruction::INVOKE_VIRTUAL_RANGE) ||
3937 (inst->Opcode() == Instruction::INVOKE_INTERFACE_RANGE);
