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