326
327 #undef DECACHE_PC
328 #undef CACHE_PC
329 #define DECACHE_PC() istate->set_bcp(pc);
330 #define CACHE_PC() pc = istate->bcp();
331 #define CACHE_CP() cp = istate->constants();
332 #define CACHE_LOCALS() locals = istate->locals();
333 #undef CACHE_FRAME
334 #define CACHE_FRAME()
335
336 // BCI() returns the current bytecode-index.
337 #undef BCI
338 #define BCI() ((int)(intptr_t)(pc - (intptr_t)istate->method()->code_base()))
339
340 /*
341 * CHECK_NULL - Macro for throwing a NullPointerException if the object
342 * passed is a null ref.
343 * On some architectures/platforms it should be possible to do this implicitly
344 */
345 #undef CHECK_NULL
346 #define CHECK_NULL(obj_) \
347 if ((obj_) == nullptr) { \
348 VM_JAVA_ERROR(vmSymbols::java_lang_NullPointerException(), nullptr); \
349 } \
350 VERIFY_OOP(obj_)
351
352 #define VMdoubleConstZero() 0.0
353 #define VMdoubleConstOne() 1.0
354 #define VMlongConstZero() (max_jlong-max_jlong)
355 #define VMlongConstOne() ((max_jlong-max_jlong)+1)
356
357 /*
358 * Alignment
359 */
360 #define VMalignWordUp(val) (((uintptr_t)(val) + 3) & ~3)
361
362 // Decache the interpreter state that interpreter modifies directly (i.e. GC is indirect mod)
363 #define DECACHE_STATE() DECACHE_PC(); DECACHE_TOS();
364
365 // Reload interpreter state after calling the VM or a possible GC
366 #define CACHE_STATE() \
367 CACHE_TOS(); \
368 CACHE_PC(); \
369 CACHE_CP(); \
370 CACHE_LOCALS();
564 /* 0x8C */ &&opc_f2l, &&opc_f2d, &&opc_d2i, &&opc_d2l,
565
566 /* 0x90 */ &&opc_d2f, &&opc_i2b, &&opc_i2c, &&opc_i2s,
567 /* 0x94 */ &&opc_lcmp, &&opc_fcmpl, &&opc_fcmpg, &&opc_dcmpl,
568 /* 0x98 */ &&opc_dcmpg, &&opc_ifeq, &&opc_ifne, &&opc_iflt,
569 /* 0x9C */ &&opc_ifge, &&opc_ifgt, &&opc_ifle, &&opc_if_icmpeq,
570
571 /* 0xA0 */ &&opc_if_icmpne, &&opc_if_icmplt, &&opc_if_icmpge, &&opc_if_icmpgt,
572 /* 0xA4 */ &&opc_if_icmple, &&opc_if_acmpeq, &&opc_if_acmpne, &&opc_goto,
573 /* 0xA8 */ &&opc_jsr, &&opc_ret, &&opc_tableswitch, &&opc_lookupswitch,
574 /* 0xAC */ &&opc_ireturn, &&opc_lreturn, &&opc_freturn, &&opc_dreturn,
575
576 /* 0xB0 */ &&opc_areturn, &&opc_return, &&opc_getstatic, &&opc_putstatic,
577 /* 0xB4 */ &&opc_getfield, &&opc_putfield, &&opc_invokevirtual, &&opc_invokespecial,
578 /* 0xB8 */ &&opc_invokestatic, &&opc_invokeinterface, &&opc_invokedynamic, &&opc_new,
579 /* 0xBC */ &&opc_newarray, &&opc_anewarray, &&opc_arraylength, &&opc_athrow,
580
581 /* 0xC0 */ &&opc_checkcast, &&opc_instanceof, &&opc_monitorenter, &&opc_monitorexit,
582 /* 0xC4 */ &&opc_wide, &&opc_multianewarray, &&opc_ifnull, &&opc_ifnonnull,
583 /* 0xC8 */ &&opc_goto_w, &&opc_jsr_w, &&opc_breakpoint, &&opc_fast_agetfield,
584 /* 0xCC */ &&opc_fast_bgetfield,&&opc_fast_cgetfield, &&opc_fast_dgetfield, &&opc_fast_fgetfield,
585
586 /* 0xD0 */ &&opc_fast_igetfield,&&opc_fast_lgetfield, &&opc_fast_sgetfield, &&opc_fast_aputfield,
587 /* 0xD4 */ &&opc_fast_bputfield,&&opc_fast_zputfield, &&opc_fast_cputfield, &&opc_fast_dputfield,
588 /* 0xD8 */ &&opc_fast_fputfield,&&opc_fast_iputfield, &&opc_fast_lputfield, &&opc_fast_sputfield,
589 /* 0xDC */ &&opc_fast_aload_0, &&opc_fast_iaccess_0, &&opc_fast_aaccess_0, &&opc_fast_faccess_0,
590
591 /* 0xE0 */ &&opc_fast_iload, &&opc_fast_iload2, &&opc_fast_icaload, &&opc_fast_invokevfinal,
592 /* 0xE4 */ &&opc_default, &&opc_default, &&opc_fast_aldc, &&opc_fast_aldc_w,
593 /* 0xE8 */ &&opc_return_register_finalizer,
594 &&opc_invokehandle, &&opc_nofast_getfield,&&opc_nofast_putfield,
595 /* 0xEC */ &&opc_nofast_aload_0,&&opc_nofast_iload, &&opc_default, &&opc_default,
596
597 /* 0xF0 */ &&opc_default, &&opc_default, &&opc_default, &&opc_default,
598 /* 0xF4 */ &&opc_default, &&opc_default, &&opc_default, &&opc_default,
599 /* 0xF8 */ &&opc_default, &&opc_default, &&opc_default, &&opc_default,
600 /* 0xFC */ &&opc_default, &&opc_default, &&opc_default, &&opc_default
601 };
602 uintptr_t *dispatch_table = (uintptr_t*)&opclabels_data[0];
603 #endif /* USELABELS */
604
605 switch (istate->msg()) {
606 case initialize: {
607 ShouldNotCallThis();
608 return;
609 }
610 case method_entry: {
611 THREAD->set_do_not_unlock_if_synchronized(true);
612
613 // Lock method if synchronized.
614 if (METHOD->is_synchronized()) {
615 // oop rcvr = locals[0].j.r;
1485 SET_ ## stackRes(*(T2 *)(((address) arrObj->base(T)) + index * sizeof(T2)), \
1486 -2); \
1487 UPDATE_PC_AND_TOS_AND_CONTINUE(1, -1); \
1488 }
1489
1490 /* 64-bit loads */
1491 #define ARRAY_LOADTO64(T,T2, stackRes, extra) \
1492 { \
1493 ARRAY_INTRO(-2); \
1494 SET_ ## stackRes(*(T2 *)(((address) arrObj->base(T)) + index * sizeof(T2)), -1); \
1495 (void)extra; \
1496 UPDATE_PC_AND_CONTINUE(1); \
1497 }
1498
1499 CASE(_iaload):
1500 ARRAY_LOADTO32(T_INT, jint, "%d", STACK_INT, 0);
1501 CASE(_faload):
1502 ARRAY_LOADTO32(T_FLOAT, jfloat, "%f", STACK_FLOAT, 0);
1503 CASE(_aaload): {
1504 ARRAY_INTRO(-2);
1505 SET_STACK_OBJECT(((objArrayOop) arrObj)->obj_at(index), -2);
1506 UPDATE_PC_AND_TOS_AND_CONTINUE(1, -1);
1507 }
1508 CASE(_baload):
1509 ARRAY_LOADTO32(T_BYTE, jbyte, "%d", STACK_INT, 0);
1510 CASE(_caload):
1511 ARRAY_LOADTO32(T_CHAR, jchar, "%d", STACK_INT, 0);
1512 CASE(_saload):
1513 ARRAY_LOADTO32(T_SHORT, jshort, "%d", STACK_INT, 0);
1514 CASE(_laload):
1515 ARRAY_LOADTO64(T_LONG, jlong, STACK_LONG, 0);
1516 CASE(_daload):
1517 ARRAY_LOADTO64(T_DOUBLE, jdouble, STACK_DOUBLE, 0);
1518
1519 CASE(_fast_icaload): {
1520 // Custom fast access for iload,caload pair.
1521 arrayOop arrObj = (arrayOop) STACK_OBJECT(-1);
1522 jint index = LOCALS_INT(pc[1]);
1523 ARRAY_INDEX_CHECK(arrObj, index);
1524 SET_STACK_INT(*(jchar *)(((address) arrObj->base(T_CHAR)) + index * sizeof(jchar)), -1);
1525 UPDATE_PC_AND_TOS_AND_CONTINUE(3, 0);
1549 ARRAY_STOREFROM32(T_FLOAT, jfloat, "%f", STACK_FLOAT, 0);
1550 /*
1551 * This one looks different because of the assignability check
1552 */
1553 CASE(_aastore): {
1554 oop rhsObject = STACK_OBJECT(-1);
1555 VERIFY_OOP(rhsObject);
1556 ARRAY_INTRO( -3);
1557 // arrObj, index are set
1558 if (rhsObject != nullptr) {
1559 /* Check assignability of rhsObject into arrObj */
1560 Klass* rhsKlass = rhsObject->klass(); // EBX (subclass)
1561 Klass* elemKlass = ObjArrayKlass::cast(arrObj->klass())->element_klass(); // superklass EAX
1562 //
1563 // Check for compatibility. This check must not GC!!
1564 // Seems way more expensive now that we must dispatch
1565 //
1566 if (rhsKlass != elemKlass && !rhsKlass->is_subtype_of(elemKlass)) { // ebx->is...
1567 VM_JAVA_ERROR(vmSymbols::java_lang_ArrayStoreException(), "");
1568 }
1569 }
1570 ((objArrayOop) arrObj)->obj_at_put(index, rhsObject);
1571 UPDATE_PC_AND_TOS_AND_CONTINUE(1, -3);
1572 }
1573 CASE(_bastore): {
1574 ARRAY_INTRO(-3);
1575 int item = STACK_INT(-1);
1576 // if it is a T_BOOLEAN array, mask the stored value to 0/1
1577 if (arrObj->klass() == Universe::boolArrayKlass()) {
1578 item &= 1;
1579 } else {
1580 assert(arrObj->klass() == Universe::byteArrayKlass(),
1581 "should be byte array otherwise");
1582 }
1583 ((typeArrayOop)arrObj)->byte_at_put(index, item);
1584 UPDATE_PC_AND_TOS_AND_CONTINUE(1, -3);
1585 }
1586 CASE(_castore):
1587 ARRAY_STOREFROM32(T_CHAR, jchar, "%d", STACK_INT, 0);
1588 CASE(_sastore):
1713 SET_STACK_INT(obj->char_field_acquire(field_offset), -1);
1714 break;
1715 case stos:
1716 SET_STACK_INT(obj->short_field_acquire(field_offset), -1);
1717 break;
1718 case itos:
1719 SET_STACK_INT(obj->int_field_acquire(field_offset), -1);
1720 break;
1721 case ftos:
1722 SET_STACK_FLOAT(obj->float_field_acquire(field_offset), -1);
1723 break;
1724 case ltos:
1725 SET_STACK_LONG(obj->long_field_acquire(field_offset), 0);
1726 MORE_STACK(1);
1727 break;
1728 case dtos:
1729 SET_STACK_DOUBLE(obj->double_field_acquire(field_offset), 0);
1730 MORE_STACK(1);
1731 break;
1732 case atos: {
1733 oop val = obj->obj_field_acquire(field_offset);
1734 VERIFY_OOP(val);
1735 SET_STACK_OBJECT(val, -1);
1736 break;
1737 }
1738 default:
1739 ShouldNotReachHere();
1740 }
1741 } else {
1742 switch (tos_type) {
1743 case btos:
1744 case ztos:
1745 SET_STACK_INT(obj->byte_field(field_offset), -1);
1746 break;
1747 case ctos:
1748 SET_STACK_INT(obj->char_field(field_offset), -1);
1749 break;
1750 case stos:
1751 SET_STACK_INT(obj->short_field(field_offset), -1);
1752 break;
1753 case itos:
1754 SET_STACK_INT(obj->int_field(field_offset), -1);
1755 break;
1756 case ftos:
1757 SET_STACK_FLOAT(obj->float_field(field_offset), -1);
1758 break;
1759 case ltos:
1760 SET_STACK_LONG(obj->long_field(field_offset), 0);
1761 MORE_STACK(1);
1762 break;
1763 case dtos:
1764 SET_STACK_DOUBLE(obj->double_field(field_offset), 0);
1765 MORE_STACK(1);
1766 break;
1767 case atos: {
1768 oop val = obj->obj_field(field_offset);
1769 VERIFY_OOP(val);
1770 SET_STACK_OBJECT(val, -1);
1771 break;
1772 }
1773 default:
1774 ShouldNotReachHere();
1775 }
1776 }
1777
1778 UPDATE_PC_AND_CONTINUE(3);
1779 }
1780
1781 CASE(_putfield):
1782 CASE(_nofast_putfield):
1783 CASE(_putstatic):
1784 {
1785 u2 index = Bytes::get_native_u2(pc+1);
1786 ResolvedFieldEntry* entry = cp->resolved_field_entry_at(index);
1787
1788 // Interpreter runtime does not expect "nofast" opcodes,
1841 break;
1842 case ctos:
1843 obj->release_char_field_put(field_offset, STACK_INT(-1));
1844 break;
1845 case stos:
1846 obj->release_short_field_put(field_offset, STACK_INT(-1));
1847 break;
1848 case itos:
1849 obj->release_int_field_put(field_offset, STACK_INT(-1));
1850 break;
1851 case ftos:
1852 obj->release_float_field_put(field_offset, STACK_FLOAT(-1));
1853 break;
1854 case ltos:
1855 obj->release_long_field_put(field_offset, STACK_LONG(-1));
1856 break;
1857 case dtos:
1858 obj->release_double_field_put(field_offset, STACK_DOUBLE(-1));
1859 break;
1860 case atos: {
1861 oop val = STACK_OBJECT(-1);
1862 VERIFY_OOP(val);
1863 obj->release_obj_field_put(field_offset, val);
1864 break;
1865 }
1866 default:
1867 ShouldNotReachHere();
1868 }
1869 OrderAccess::storeload();
1870 } else {
1871 switch (tos_type) {
1872 case ztos:
1873 obj->byte_field_put(field_offset, (STACK_INT(-1) & 1)); // only store LSB
1874 break;
1875 case btos:
1876 obj->byte_field_put(field_offset, STACK_INT(-1));
1877 break;
1878 case ctos:
1879 obj->char_field_put(field_offset, STACK_INT(-1));
1880 break;
1881 case stos:
1882 obj->short_field_put(field_offset, STACK_INT(-1));
1883 break;
1884 case itos:
1885 obj->int_field_put(field_offset, STACK_INT(-1));
1886 break;
1887 case ftos:
1888 obj->float_field_put(field_offset, STACK_FLOAT(-1));
1889 break;
1890 case ltos:
1891 obj->long_field_put(field_offset, STACK_LONG(-1));
1892 break;
1893 case dtos:
1894 obj->double_field_put(field_offset, STACK_DOUBLE(-1));
1895 break;
1896 case atos: {
1897 oop val = STACK_OBJECT(-1);
1898 VERIFY_OOP(val);
1899 obj->obj_field_put(field_offset, val);
1900 break;
1901 }
1902 default:
1903 ShouldNotReachHere();
1904 }
1905 }
1906
1907 UPDATE_PC_AND_TOS_AND_CONTINUE(3, count);
1908 }
1909
1910 CASE(_new): {
1911 u2 index = Bytes::get_Java_u2(pc+1);
1912
1913 // Attempt TLAB allocation first.
1914 //
1915 // To do this, we need to make sure:
1916 // - klass is initialized
1917 // - klass can be fastpath allocated (e.g. does not have finalizer)
1918 // - TLAB accepts the allocation
1919 ConstantPool* constants = istate->method()->constants();
2512 RESET_LAST_JAVA_FRAME();
2513 CACHE_STATE();
2514 if (THREAD->has_pending_exception()) goto handle_exception;
2515 CALL_VM(InterpreterRuntime::_breakpoint(THREAD, METHOD, pc),
2516 handle_exception);
2517
2518 opcode = (jubyte)original_bytecode;
2519 goto opcode_switch;
2520 }
2521
2522 CASE(_fast_agetfield): {
2523 u2 index = Bytes::get_native_u2(pc+1);
2524 ResolvedFieldEntry* entry = cp->resolved_field_entry_at(index);
2525 int field_offset = entry->field_offset();
2526
2527 oop obj = STACK_OBJECT(-1);
2528 CHECK_NULL(obj);
2529
2530 MAYBE_POST_FIELD_ACCESS(obj);
2531
2532 VERIFY_OOP(obj->obj_field(field_offset));
2533 SET_STACK_OBJECT(obj->obj_field(field_offset), -1);
2534 UPDATE_PC_AND_CONTINUE(3);
2535 }
2536
2537 CASE(_fast_bgetfield): {
2538 u2 index = Bytes::get_native_u2(pc+1);
2539 ResolvedFieldEntry* entry = cp->resolved_field_entry_at(index);
2540 int field_offset = entry->field_offset();
2541
2542 oop obj = STACK_OBJECT(-1);
2543 CHECK_NULL(obj);
2544
2545 MAYBE_POST_FIELD_ACCESS(obj);
2546
2547 SET_STACK_INT(obj->byte_field(field_offset), -1);
2548 UPDATE_PC_AND_CONTINUE(3);
2549 }
2550
2551 CASE(_fast_cgetfield): {
2552 u2 index = Bytes::get_native_u2(pc+1);
2553 ResolvedFieldEntry* entry = cp->resolved_field_entry_at(index);
2627
2628 oop obj = STACK_OBJECT(-1);
2629 CHECK_NULL(obj);
2630
2631 MAYBE_POST_FIELD_ACCESS(obj);
2632
2633 SET_STACK_INT(obj->short_field(field_offset), -1);
2634 UPDATE_PC_AND_CONTINUE(3);
2635 }
2636
2637 CASE(_fast_aputfield): {
2638 u2 index = Bytes::get_native_u2(pc+1);
2639 ResolvedFieldEntry* entry = cp->resolved_field_entry_at(index);
2640
2641 oop obj = STACK_OBJECT(-2);
2642 CHECK_NULL(obj);
2643
2644 MAYBE_POST_FIELD_MODIFICATION(obj);
2645
2646 int field_offset = entry->field_offset();
2647 obj->obj_field_put(field_offset, STACK_OBJECT(-1));
2648
2649 UPDATE_PC_AND_TOS_AND_CONTINUE(3, -2);
2650 }
2651
2652 CASE(_fast_bputfield): {
2653 u2 index = Bytes::get_native_u2(pc+1);
2654 ResolvedFieldEntry* entry = cp->resolved_field_entry_at(index);
2655
2656 oop obj = STACK_OBJECT(-2);
2657 CHECK_NULL(obj);
2658
2659 MAYBE_POST_FIELD_MODIFICATION(obj);
2660
2661 int field_offset = entry->field_offset();
2662 obj->byte_field_put(field_offset, STACK_INT(-1));
2663
2664 UPDATE_PC_AND_TOS_AND_CONTINUE(3, -2);
2665 }
2666
2667 CASE(_fast_zputfield): {
2770 }
2771
2772 CASE(_fast_aload_0): {
2773 oop obj = LOCALS_OBJECT(0);
2774 VERIFY_OOP(obj);
2775 SET_STACK_OBJECT(obj, 0);
2776 UPDATE_PC_AND_TOS_AND_CONTINUE(1, 1);
2777 }
2778
2779 CASE(_fast_aaccess_0): {
2780 u2 index = Bytes::get_native_u2(pc+2);
2781 ResolvedFieldEntry* entry = cp->resolved_field_entry_at(index);
2782 int field_offset = entry->field_offset();
2783
2784 oop obj = LOCALS_OBJECT(0);
2785 CHECK_NULL(obj);
2786 VERIFY_OOP(obj);
2787
2788 MAYBE_POST_FIELD_ACCESS(obj);
2789
2790 VERIFY_OOP(obj->obj_field(field_offset));
2791 SET_STACK_OBJECT(obj->obj_field(field_offset), 0);
2792 UPDATE_PC_AND_TOS_AND_CONTINUE(4, 1);
2793 }
2794
2795 CASE(_fast_iaccess_0): {
2796 u2 index = Bytes::get_native_u2(pc+2);
2797 ResolvedFieldEntry* entry = cp->resolved_field_entry_at(index);
2798 int field_offset = entry->field_offset();
2799
2800 oop obj = LOCALS_OBJECT(0);
2801 CHECK_NULL(obj);
2802 VERIFY_OOP(obj);
2803
2804 MAYBE_POST_FIELD_ACCESS(obj);
2805
2806 SET_STACK_INT(obj->int_field(field_offset), 0);
2807 UPDATE_PC_AND_TOS_AND_CONTINUE(4, 1);
2808 }
2809
2810 CASE(_fast_faccess_0): {
2811 u2 index = Bytes::get_native_u2(pc+2);
|
326
327 #undef DECACHE_PC
328 #undef CACHE_PC
329 #define DECACHE_PC() istate->set_bcp(pc);
330 #define CACHE_PC() pc = istate->bcp();
331 #define CACHE_CP() cp = istate->constants();
332 #define CACHE_LOCALS() locals = istate->locals();
333 #undef CACHE_FRAME
334 #define CACHE_FRAME()
335
336 // BCI() returns the current bytecode-index.
337 #undef BCI
338 #define BCI() ((int)(intptr_t)(pc - (intptr_t)istate->method()->code_base()))
339
340 /*
341 * CHECK_NULL - Macro for throwing a NullPointerException if the object
342 * passed is a null ref.
343 * On some architectures/platforms it should be possible to do this implicitly
344 */
345 #undef CHECK_NULL
346 #define CHECK_NULL_MSG(obj_, msg) \
347 if ((obj_) == nullptr) { \
348 VM_JAVA_ERROR(vmSymbols::java_lang_NullPointerException(), (msg)); \
349 } \
350 VERIFY_OOP(obj_)
351 #define CHECK_NULL(obj_) CHECK_NULL_MSG(obj_, nullptr)
352
353 #define VMdoubleConstZero() 0.0
354 #define VMdoubleConstOne() 1.0
355 #define VMlongConstZero() (max_jlong-max_jlong)
356 #define VMlongConstOne() ((max_jlong-max_jlong)+1)
357
358 /*
359 * Alignment
360 */
361 #define VMalignWordUp(val) (((uintptr_t)(val) + 3) & ~3)
362
363 // Decache the interpreter state that interpreter modifies directly (i.e. GC is indirect mod)
364 #define DECACHE_STATE() DECACHE_PC(); DECACHE_TOS();
365
366 // Reload interpreter state after calling the VM or a possible GC
367 #define CACHE_STATE() \
368 CACHE_TOS(); \
369 CACHE_PC(); \
370 CACHE_CP(); \
371 CACHE_LOCALS();
565 /* 0x8C */ &&opc_f2l, &&opc_f2d, &&opc_d2i, &&opc_d2l,
566
567 /* 0x90 */ &&opc_d2f, &&opc_i2b, &&opc_i2c, &&opc_i2s,
568 /* 0x94 */ &&opc_lcmp, &&opc_fcmpl, &&opc_fcmpg, &&opc_dcmpl,
569 /* 0x98 */ &&opc_dcmpg, &&opc_ifeq, &&opc_ifne, &&opc_iflt,
570 /* 0x9C */ &&opc_ifge, &&opc_ifgt, &&opc_ifle, &&opc_if_icmpeq,
571
572 /* 0xA0 */ &&opc_if_icmpne, &&opc_if_icmplt, &&opc_if_icmpge, &&opc_if_icmpgt,
573 /* 0xA4 */ &&opc_if_icmple, &&opc_if_acmpeq, &&opc_if_acmpne, &&opc_goto,
574 /* 0xA8 */ &&opc_jsr, &&opc_ret, &&opc_tableswitch, &&opc_lookupswitch,
575 /* 0xAC */ &&opc_ireturn, &&opc_lreturn, &&opc_freturn, &&opc_dreturn,
576
577 /* 0xB0 */ &&opc_areturn, &&opc_return, &&opc_getstatic, &&opc_putstatic,
578 /* 0xB4 */ &&opc_getfield, &&opc_putfield, &&opc_invokevirtual, &&opc_invokespecial,
579 /* 0xB8 */ &&opc_invokestatic, &&opc_invokeinterface, &&opc_invokedynamic, &&opc_new,
580 /* 0xBC */ &&opc_newarray, &&opc_anewarray, &&opc_arraylength, &&opc_athrow,
581
582 /* 0xC0 */ &&opc_checkcast, &&opc_instanceof, &&opc_monitorenter, &&opc_monitorexit,
583 /* 0xC4 */ &&opc_wide, &&opc_multianewarray, &&opc_ifnull, &&opc_ifnonnull,
584 /* 0xC8 */ &&opc_goto_w, &&opc_jsr_w, &&opc_breakpoint, &&opc_fast_agetfield,
585 /* 0xCC */ &&opc_default, &&opc_fast_bgetfield, &&opc_fast_cgetfield, &&opc_fast_dgetfield,
586
587 /* 0xD0 */ &&opc_fast_fgetfield, &&opc_fast_igetfield, &&opc_fast_lgetfield, &&opc_fast_sgetfield,
588 /* 0xD4 */ &&opc_fast_aputfield, &&opc_default, &&opc_fast_bputfield, &&opc_fast_zputfield,
589 /* 0xD8 */ &&opc_fast_cputfield, &&opc_fast_dputfield, &&opc_fast_fputfield, &&opc_fast_iputfield,
590 /* 0xDC */ &&opc_fast_lputfield, &&opc_fast_sputfield, &&opc_fast_aload_0, &&opc_fast_iaccess_0,
591
592 /* 0xE0 */ &&opc_fast_aaccess_0, &&opc_fast_faccess_0, &&opc_fast_iload, &&opc_fast_iload2,
593 /* 0xE4 */ &&opc_fast_icaload, &&opc_fast_invokevfinal, &&opc_default, &&opc_default,
594 /* 0xE8 */ &&opc_fast_aldc, &&opc_fast_aldc_w, &&opc_return_register_finalizer, &&opc_invokehandle,
595 /* 0xEC */ &&opc_nofast_getfield, &&opc_nofast_putfield, &&opc_nofast_aload_0, &&opc_nofast_iload,
596
597 /* 0xF0 */ &&opc_default, &&opc_default, &&opc_default, &&opc_default,
598 /* 0xF4 */ &&opc_default, &&opc_default, &&opc_default, &&opc_default,
599 /* 0xF8 */ &&opc_default, &&opc_default, &&opc_default, &&opc_default,
600 /* 0xFC */ &&opc_default, &&opc_default, &&opc_default, &&opc_default
601 };
602 uintptr_t *dispatch_table = (uintptr_t*)&opclabels_data[0];
603 #endif /* USELABELS */
604
605 switch (istate->msg()) {
606 case initialize: {
607 ShouldNotCallThis();
608 return;
609 }
610 case method_entry: {
611 THREAD->set_do_not_unlock_if_synchronized(true);
612
613 // Lock method if synchronized.
614 if (METHOD->is_synchronized()) {
615 // oop rcvr = locals[0].j.r;
1485 SET_ ## stackRes(*(T2 *)(((address) arrObj->base(T)) + index * sizeof(T2)), \
1486 -2); \
1487 UPDATE_PC_AND_TOS_AND_CONTINUE(1, -1); \
1488 }
1489
1490 /* 64-bit loads */
1491 #define ARRAY_LOADTO64(T,T2, stackRes, extra) \
1492 { \
1493 ARRAY_INTRO(-2); \
1494 SET_ ## stackRes(*(T2 *)(((address) arrObj->base(T)) + index * sizeof(T2)), -1); \
1495 (void)extra; \
1496 UPDATE_PC_AND_CONTINUE(1); \
1497 }
1498
1499 CASE(_iaload):
1500 ARRAY_LOADTO32(T_INT, jint, "%d", STACK_INT, 0);
1501 CASE(_faload):
1502 ARRAY_LOADTO32(T_FLOAT, jfloat, "%f", STACK_FLOAT, 0);
1503 CASE(_aaload): {
1504 ARRAY_INTRO(-2);
1505 if (((objArrayOop) arrObj)->is_flatArray()) {
1506 CALL_VM(InterpreterRuntime::flat_array_load(THREAD, (objArrayOop) arrObj, index), handle_exception);
1507 SET_STACK_OBJECT(THREAD->vm_result_oop(),-2);
1508 THREAD->set_vm_result_oop(nullptr);
1509 } else {
1510 SET_STACK_OBJECT(((objArrayOop) arrObj)->obj_at(index), -2);
1511 }
1512 UPDATE_PC_AND_TOS_AND_CONTINUE(1, -1);
1513 }
1514 CASE(_baload):
1515 ARRAY_LOADTO32(T_BYTE, jbyte, "%d", STACK_INT, 0);
1516 CASE(_caload):
1517 ARRAY_LOADTO32(T_CHAR, jchar, "%d", STACK_INT, 0);
1518 CASE(_saload):
1519 ARRAY_LOADTO32(T_SHORT, jshort, "%d", STACK_INT, 0);
1520 CASE(_laload):
1521 ARRAY_LOADTO64(T_LONG, jlong, STACK_LONG, 0);
1522 CASE(_daload):
1523 ARRAY_LOADTO64(T_DOUBLE, jdouble, STACK_DOUBLE, 0);
1524
1525 CASE(_fast_icaload): {
1526 // Custom fast access for iload,caload pair.
1527 arrayOop arrObj = (arrayOop) STACK_OBJECT(-1);
1528 jint index = LOCALS_INT(pc[1]);
1529 ARRAY_INDEX_CHECK(arrObj, index);
1530 SET_STACK_INT(*(jchar *)(((address) arrObj->base(T_CHAR)) + index * sizeof(jchar)), -1);
1531 UPDATE_PC_AND_TOS_AND_CONTINUE(3, 0);
1555 ARRAY_STOREFROM32(T_FLOAT, jfloat, "%f", STACK_FLOAT, 0);
1556 /*
1557 * This one looks different because of the assignability check
1558 */
1559 CASE(_aastore): {
1560 oop rhsObject = STACK_OBJECT(-1);
1561 VERIFY_OOP(rhsObject);
1562 ARRAY_INTRO( -3);
1563 // arrObj, index are set
1564 if (rhsObject != nullptr) {
1565 /* Check assignability of rhsObject into arrObj */
1566 Klass* rhsKlass = rhsObject->klass(); // EBX (subclass)
1567 Klass* elemKlass = ObjArrayKlass::cast(arrObj->klass())->element_klass(); // superklass EAX
1568 //
1569 // Check for compatibility. This check must not GC!!
1570 // Seems way more expensive now that we must dispatch
1571 //
1572 if (rhsKlass != elemKlass && !rhsKlass->is_subtype_of(elemKlass)) { // ebx->is...
1573 VM_JAVA_ERROR(vmSymbols::java_lang_ArrayStoreException(), "");
1574 }
1575 } else if (arrObj->is_null_free_array()) {
1576 VM_JAVA_ERROR(vmSymbols::java_lang_NullPointerException(), "Cannot store null in a null-restricted array");
1577 }
1578 ((objArrayOop) arrObj)->obj_at_put(index, rhsObject);
1579 UPDATE_PC_AND_TOS_AND_CONTINUE(1, -3);
1580 }
1581 CASE(_bastore): {
1582 ARRAY_INTRO(-3);
1583 int item = STACK_INT(-1);
1584 // if it is a T_BOOLEAN array, mask the stored value to 0/1
1585 if (arrObj->klass() == Universe::boolArrayKlass()) {
1586 item &= 1;
1587 } else {
1588 assert(arrObj->klass() == Universe::byteArrayKlass(),
1589 "should be byte array otherwise");
1590 }
1591 ((typeArrayOop)arrObj)->byte_at_put(index, item);
1592 UPDATE_PC_AND_TOS_AND_CONTINUE(1, -3);
1593 }
1594 CASE(_castore):
1595 ARRAY_STOREFROM32(T_CHAR, jchar, "%d", STACK_INT, 0);
1596 CASE(_sastore):
1721 SET_STACK_INT(obj->char_field_acquire(field_offset), -1);
1722 break;
1723 case stos:
1724 SET_STACK_INT(obj->short_field_acquire(field_offset), -1);
1725 break;
1726 case itos:
1727 SET_STACK_INT(obj->int_field_acquire(field_offset), -1);
1728 break;
1729 case ftos:
1730 SET_STACK_FLOAT(obj->float_field_acquire(field_offset), -1);
1731 break;
1732 case ltos:
1733 SET_STACK_LONG(obj->long_field_acquire(field_offset), 0);
1734 MORE_STACK(1);
1735 break;
1736 case dtos:
1737 SET_STACK_DOUBLE(obj->double_field_acquire(field_offset), 0);
1738 MORE_STACK(1);
1739 break;
1740 case atos: {
1741 assert(!entry->is_flat(), "Flat volatile field not supported");
1742 oop val = obj->obj_field_acquire(field_offset);
1743 VERIFY_OOP(val);
1744 SET_STACK_OBJECT(val, -1);
1745 break;
1746 }
1747 default:
1748 ShouldNotReachHere();
1749 }
1750 } else {
1751 switch (tos_type) {
1752 case btos:
1753 case ztos:
1754 SET_STACK_INT(obj->byte_field(field_offset), -1);
1755 break;
1756 case ctos:
1757 SET_STACK_INT(obj->char_field(field_offset), -1);
1758 break;
1759 case stos:
1760 SET_STACK_INT(obj->short_field(field_offset), -1);
1761 break;
1762 case itos:
1763 SET_STACK_INT(obj->int_field(field_offset), -1);
1764 break;
1765 case ftos:
1766 SET_STACK_FLOAT(obj->float_field(field_offset), -1);
1767 break;
1768 case ltos:
1769 SET_STACK_LONG(obj->long_field(field_offset), 0);
1770 MORE_STACK(1);
1771 break;
1772 case dtos:
1773 SET_STACK_DOUBLE(obj->double_field(field_offset), 0);
1774 MORE_STACK(1);
1775 break;
1776 case atos: {
1777 oop val;
1778 if (entry->is_flat()) {
1779 CALL_VM(InterpreterRuntime::read_flat_field(THREAD, obj, entry), handle_exception);
1780 val = THREAD->vm_result_oop();
1781 THREAD->set_vm_result_oop(nullptr);
1782 } else {
1783 val = obj->obj_field(field_offset);
1784 }
1785 VERIFY_OOP(val);
1786 SET_STACK_OBJECT(val, -1);
1787 break;
1788 }
1789 default:
1790 ShouldNotReachHere();
1791 }
1792 }
1793
1794 UPDATE_PC_AND_CONTINUE(3);
1795 }
1796
1797 CASE(_putfield):
1798 CASE(_nofast_putfield):
1799 CASE(_putstatic):
1800 {
1801 u2 index = Bytes::get_native_u2(pc+1);
1802 ResolvedFieldEntry* entry = cp->resolved_field_entry_at(index);
1803
1804 // Interpreter runtime does not expect "nofast" opcodes,
1857 break;
1858 case ctos:
1859 obj->release_char_field_put(field_offset, STACK_INT(-1));
1860 break;
1861 case stos:
1862 obj->release_short_field_put(field_offset, STACK_INT(-1));
1863 break;
1864 case itos:
1865 obj->release_int_field_put(field_offset, STACK_INT(-1));
1866 break;
1867 case ftos:
1868 obj->release_float_field_put(field_offset, STACK_FLOAT(-1));
1869 break;
1870 case ltos:
1871 obj->release_long_field_put(field_offset, STACK_LONG(-1));
1872 break;
1873 case dtos:
1874 obj->release_double_field_put(field_offset, STACK_DOUBLE(-1));
1875 break;
1876 case atos: {
1877 assert(!entry->is_flat(), "Flat volatile field not supported");
1878 oop val = STACK_OBJECT(-1);
1879 VERIFY_OOP(val);
1880 obj->release_obj_field_put(field_offset, val);
1881 break;
1882 }
1883 default:
1884 ShouldNotReachHere();
1885 }
1886 OrderAccess::storeload();
1887 } else {
1888 switch (tos_type) {
1889 case ztos:
1890 obj->byte_field_put(field_offset, (STACK_INT(-1) & 1)); // only store LSB
1891 break;
1892 case btos:
1893 obj->byte_field_put(field_offset, STACK_INT(-1));
1894 break;
1895 case ctos:
1896 obj->char_field_put(field_offset, STACK_INT(-1));
1897 break;
1898 case stos:
1899 obj->short_field_put(field_offset, STACK_INT(-1));
1900 break;
1901 case itos:
1902 obj->int_field_put(field_offset, STACK_INT(-1));
1903 break;
1904 case ftos:
1905 obj->float_field_put(field_offset, STACK_FLOAT(-1));
1906 break;
1907 case ltos:
1908 obj->long_field_put(field_offset, STACK_LONG(-1));
1909 break;
1910 case dtos:
1911 obj->double_field_put(field_offset, STACK_DOUBLE(-1));
1912 break;
1913 case atos: {
1914 oop val = STACK_OBJECT(-1);
1915 VERIFY_OOP(val);
1916 if (entry->is_flat()) {
1917 CALL_VM(InterpreterRuntime::write_flat_field(THREAD, obj, val, entry), handle_exception);
1918 } else {
1919 obj->obj_field_put(field_offset, val);
1920 }
1921 break;
1922 }
1923 default:
1924 ShouldNotReachHere();
1925 }
1926 }
1927
1928 UPDATE_PC_AND_TOS_AND_CONTINUE(3, count);
1929 }
1930
1931 CASE(_new): {
1932 u2 index = Bytes::get_Java_u2(pc+1);
1933
1934 // Attempt TLAB allocation first.
1935 //
1936 // To do this, we need to make sure:
1937 // - klass is initialized
1938 // - klass can be fastpath allocated (e.g. does not have finalizer)
1939 // - TLAB accepts the allocation
1940 ConstantPool* constants = istate->method()->constants();
2533 RESET_LAST_JAVA_FRAME();
2534 CACHE_STATE();
2535 if (THREAD->has_pending_exception()) goto handle_exception;
2536 CALL_VM(InterpreterRuntime::_breakpoint(THREAD, METHOD, pc),
2537 handle_exception);
2538
2539 opcode = (jubyte)original_bytecode;
2540 goto opcode_switch;
2541 }
2542
2543 CASE(_fast_agetfield): {
2544 u2 index = Bytes::get_native_u2(pc+1);
2545 ResolvedFieldEntry* entry = cp->resolved_field_entry_at(index);
2546 int field_offset = entry->field_offset();
2547
2548 oop obj = STACK_OBJECT(-1);
2549 CHECK_NULL(obj);
2550
2551 MAYBE_POST_FIELD_ACCESS(obj);
2552
2553 oop val;
2554 if (entry->is_flat()) {
2555 CALL_VM(InterpreterRuntime::read_flat_field(THREAD, obj, entry), handle_exception);
2556 val = THREAD->vm_result_oop();
2557 THREAD->set_vm_result_oop(nullptr);
2558 } else {
2559 val = obj->obj_field(field_offset);
2560 }
2561
2562 VERIFY_OOP(val);
2563 SET_STACK_OBJECT(val, -1);
2564 UPDATE_PC_AND_CONTINUE(3);
2565 }
2566
2567 CASE(_fast_bgetfield): {
2568 u2 index = Bytes::get_native_u2(pc+1);
2569 ResolvedFieldEntry* entry = cp->resolved_field_entry_at(index);
2570 int field_offset = entry->field_offset();
2571
2572 oop obj = STACK_OBJECT(-1);
2573 CHECK_NULL(obj);
2574
2575 MAYBE_POST_FIELD_ACCESS(obj);
2576
2577 SET_STACK_INT(obj->byte_field(field_offset), -1);
2578 UPDATE_PC_AND_CONTINUE(3);
2579 }
2580
2581 CASE(_fast_cgetfield): {
2582 u2 index = Bytes::get_native_u2(pc+1);
2583 ResolvedFieldEntry* entry = cp->resolved_field_entry_at(index);
2657
2658 oop obj = STACK_OBJECT(-1);
2659 CHECK_NULL(obj);
2660
2661 MAYBE_POST_FIELD_ACCESS(obj);
2662
2663 SET_STACK_INT(obj->short_field(field_offset), -1);
2664 UPDATE_PC_AND_CONTINUE(3);
2665 }
2666
2667 CASE(_fast_aputfield): {
2668 u2 index = Bytes::get_native_u2(pc+1);
2669 ResolvedFieldEntry* entry = cp->resolved_field_entry_at(index);
2670
2671 oop obj = STACK_OBJECT(-2);
2672 CHECK_NULL(obj);
2673
2674 MAYBE_POST_FIELD_MODIFICATION(obj);
2675
2676 int field_offset = entry->field_offset();
2677 oop val = STACK_OBJECT(-1);
2678
2679 if (entry->is_null_free_inline_type()) {
2680 CHECK_NULL_MSG(val, "Value is null");
2681 }
2682
2683 if (entry->is_flat()) {
2684 CALL_VM(InterpreterRuntime::write_flat_field(THREAD, obj, val, entry), handle_exception);
2685 } else {
2686 obj->obj_field_put(field_offset, val);
2687 }
2688
2689 UPDATE_PC_AND_TOS_AND_CONTINUE(3, -2);
2690 }
2691
2692 CASE(_fast_bputfield): {
2693 u2 index = Bytes::get_native_u2(pc+1);
2694 ResolvedFieldEntry* entry = cp->resolved_field_entry_at(index);
2695
2696 oop obj = STACK_OBJECT(-2);
2697 CHECK_NULL(obj);
2698
2699 MAYBE_POST_FIELD_MODIFICATION(obj);
2700
2701 int field_offset = entry->field_offset();
2702 obj->byte_field_put(field_offset, STACK_INT(-1));
2703
2704 UPDATE_PC_AND_TOS_AND_CONTINUE(3, -2);
2705 }
2706
2707 CASE(_fast_zputfield): {
2810 }
2811
2812 CASE(_fast_aload_0): {
2813 oop obj = LOCALS_OBJECT(0);
2814 VERIFY_OOP(obj);
2815 SET_STACK_OBJECT(obj, 0);
2816 UPDATE_PC_AND_TOS_AND_CONTINUE(1, 1);
2817 }
2818
2819 CASE(_fast_aaccess_0): {
2820 u2 index = Bytes::get_native_u2(pc+2);
2821 ResolvedFieldEntry* entry = cp->resolved_field_entry_at(index);
2822 int field_offset = entry->field_offset();
2823
2824 oop obj = LOCALS_OBJECT(0);
2825 CHECK_NULL(obj);
2826 VERIFY_OOP(obj);
2827
2828 MAYBE_POST_FIELD_ACCESS(obj);
2829
2830 oop val;
2831 if (entry->is_flat()) {
2832 CALL_VM(InterpreterRuntime::read_flat_field(THREAD, obj, entry), handle_exception);
2833 val = THREAD->vm_result_oop();
2834 THREAD->set_vm_result_oop(nullptr);
2835 } else {
2836 val = obj->obj_field(field_offset);
2837 }
2838
2839 VERIFY_OOP(val);
2840 SET_STACK_OBJECT(val, 0);
2841 UPDATE_PC_AND_TOS_AND_CONTINUE(4, 1);
2842 }
2843
2844 CASE(_fast_iaccess_0): {
2845 u2 index = Bytes::get_native_u2(pc+2);
2846 ResolvedFieldEntry* entry = cp->resolved_field_entry_at(index);
2847 int field_offset = entry->field_offset();
2848
2849 oop obj = LOCALS_OBJECT(0);
2850 CHECK_NULL(obj);
2851 VERIFY_OOP(obj);
2852
2853 MAYBE_POST_FIELD_ACCESS(obj);
2854
2855 SET_STACK_INT(obj->int_field(field_offset), 0);
2856 UPDATE_PC_AND_TOS_AND_CONTINUE(4, 1);
2857 }
2858
2859 CASE(_fast_faccess_0): {
2860 u2 index = Bytes::get_native_u2(pc+2);
|