24 */
25
26 #include "asm/macroAssembler.inline.hpp"
27 #include "classfile/javaClasses.hpp"
28 #include "compiler/disassembler.hpp"
29 #include "compiler/compiler_globals.hpp"
30 #include "gc/shared/barrierSetAssembler.hpp"
31 #include "interpreter/bytecodeHistogram.hpp"
32 #include "interpreter/interpreter.hpp"
33 #include "interpreter/interpreterRuntime.hpp"
34 #include "interpreter/interp_masm.hpp"
35 #include "interpreter/templateInterpreterGenerator.hpp"
36 #include "interpreter/templateTable.hpp"
37 #include "interpreter/bytecodeTracer.hpp"
38 #include "memory/resourceArea.hpp"
39 #include "oops/arrayOop.hpp"
40 #include "oops/method.hpp"
41 #include "oops/methodCounters.hpp"
42 #include "oops/methodData.hpp"
43 #include "oops/oop.inline.hpp"
44 #include "oops/resolvedIndyEntry.hpp"
45 #include "oops/resolvedMethodEntry.hpp"
46 #include "prims/jvmtiExport.hpp"
47 #include "prims/jvmtiThreadState.hpp"
48 #include "runtime/arguments.hpp"
49 #include "runtime/deoptimization.hpp"
50 #include "runtime/frame.inline.hpp"
51 #include "runtime/globals.hpp"
52 #include "runtime/jniHandles.hpp"
53 #include "runtime/sharedRuntime.hpp"
54 #include "runtime/stubRoutines.hpp"
55 #include "runtime/synchronizer.hpp"
56 #include "runtime/timer.hpp"
57 #include "runtime/vframeArray.hpp"
58 #include "utilities/checkedCast.hpp"
59 #include "utilities/debug.hpp"
60 #include "utilities/powerOfTwo.hpp"
61 #include <sys/types.h>
62
63 // Size of interpreter code. Increase if too small. Interpreter will
450 } else {
451 __ mov(c_rarg2, NULL_WORD);
452 }
453 __ call_VM(r0,
454 CAST_FROM_FN_PTR(address, InterpreterRuntime::create_exception),
455 c_rarg1, c_rarg2);
456 }
457 // throw exception
458 __ b(address(Interpreter::throw_exception_entry()));
459 return entry;
460 }
461
462 address TemplateInterpreterGenerator::generate_return_entry_for(TosState state, int step, size_t index_size) {
463 address entry = __ pc();
464
465 // Restore stack bottom in case i2c adjusted stack
466 __ ldr(rscratch1, Address(rfp, frame::interpreter_frame_last_sp_offset * wordSize));
467 __ lea(esp, Address(rfp, rscratch1, Address::lsl(Interpreter::logStackElementSize)));
468 // and null it as marker that esp is now tos until next java call
469 __ str(zr, Address(rfp, frame::interpreter_frame_last_sp_offset * wordSize));
470 __ restore_bcp();
471 __ restore_locals();
472 __ restore_constant_pool_cache();
473 __ get_method(rmethod);
474
475 if (state == atos) {
476 Register obj = r0;
477 Register mdp = r1;
478 Register tmp = r2;
479 __ profile_return_type(mdp, obj, tmp);
480 }
481
482 const Register cache = r1;
483 const Register index = r2;
484
485 if (index_size == sizeof(u4)) {
486 __ load_resolved_indy_entry(cache, index);
487 __ load_unsigned_short(cache, Address(cache, in_bytes(ResolvedIndyEntry::num_parameters_offset())));
488 __ add(esp, esp, cache, Assembler::LSL, 3);
489 } else {
1616
1617 JFR_ONLY(__ leave_jfr_critical_section();)
1618
1619 // restore sender sp
1620 __ mov(sp, esp);
1621
1622 __ ret(lr);
1623
1624 if (inc_counter) {
1625 // Handle overflow of counter and compile method
1626 __ bind(invocation_counter_overflow);
1627 generate_counter_overflow(continue_after_compile);
1628 }
1629
1630 return entry_point;
1631 }
1632
1633 //
1634 // Generic interpreted method entry to (asm) interpreter
1635 //
1636 address TemplateInterpreterGenerator::generate_normal_entry(bool synchronized) {
1637 // determine code generation flags
1638 bool inc_counter = UseCompiler || CountCompiledCalls;
1639
1640 // rscratch1: sender sp
1641 address entry_point = __ pc();
1642
1643 const Address constMethod(rmethod, Method::const_offset());
1644 const Address access_flags(rmethod, Method::access_flags_offset());
1645 const Address size_of_parameters(r3,
1646 ConstMethod::size_of_parameters_offset());
1647 const Address size_of_locals(r3, ConstMethod::size_of_locals_offset());
1648
1649 // get parameter size (always needed)
1650 // need to load the const method first
1651 __ ldr(r3, constMethod);
1652 __ load_unsigned_short(r2, size_of_parameters);
1653
1654 // r2: size of parameters
1655
1656 __ load_unsigned_short(r3, size_of_locals); // get size of locals in words
1743 // check for synchronized methods
1744 // Must happen AFTER invocation_counter check and stack overflow check,
1745 // so method is not locked if overflows.
1746 if (synchronized) {
1747 // Allocate monitor and lock method
1748 lock_method();
1749 } else {
1750 // no synchronization necessary
1751 #ifdef ASSERT
1752 {
1753 Label L;
1754 __ ldrh(r0, access_flags);
1755 __ tst(r0, JVM_ACC_SYNCHRONIZED);
1756 __ br(Assembler::EQ, L);
1757 __ stop("method needs synchronization");
1758 __ bind(L);
1759 }
1760 #endif
1761 }
1762
1763 // start execution
1764 #ifdef ASSERT
1765 {
1766 Label L;
1767 const Address monitor_block_top (rfp,
1768 frame::interpreter_frame_monitor_block_top_offset * wordSize);
1769 __ ldr(rscratch1, monitor_block_top);
1770 __ lea(rscratch1, Address(rfp, rscratch1, Address::lsl(Interpreter::logStackElementSize)));
1771 __ cmp(esp, rscratch1);
1772 __ br(Assembler::EQ, L);
1773 __ stop("broken stack frame setup in interpreter 2");
1774 __ bind(L);
1775 }
1776 #endif
1777
1778 // jvmti support
1779 __ notify_method_entry();
1780
1781 __ dispatch_next(vtos);
1782
|
24 */
25
26 #include "asm/macroAssembler.inline.hpp"
27 #include "classfile/javaClasses.hpp"
28 #include "compiler/disassembler.hpp"
29 #include "compiler/compiler_globals.hpp"
30 #include "gc/shared/barrierSetAssembler.hpp"
31 #include "interpreter/bytecodeHistogram.hpp"
32 #include "interpreter/interpreter.hpp"
33 #include "interpreter/interpreterRuntime.hpp"
34 #include "interpreter/interp_masm.hpp"
35 #include "interpreter/templateInterpreterGenerator.hpp"
36 #include "interpreter/templateTable.hpp"
37 #include "interpreter/bytecodeTracer.hpp"
38 #include "memory/resourceArea.hpp"
39 #include "oops/arrayOop.hpp"
40 #include "oops/method.hpp"
41 #include "oops/methodCounters.hpp"
42 #include "oops/methodData.hpp"
43 #include "oops/oop.inline.hpp"
44 #include "oops/inlineKlass.hpp"
45 #include "oops/resolvedIndyEntry.hpp"
46 #include "oops/resolvedMethodEntry.hpp"
47 #include "prims/jvmtiExport.hpp"
48 #include "prims/jvmtiThreadState.hpp"
49 #include "runtime/arguments.hpp"
50 #include "runtime/deoptimization.hpp"
51 #include "runtime/frame.inline.hpp"
52 #include "runtime/globals.hpp"
53 #include "runtime/jniHandles.hpp"
54 #include "runtime/sharedRuntime.hpp"
55 #include "runtime/stubRoutines.hpp"
56 #include "runtime/synchronizer.hpp"
57 #include "runtime/timer.hpp"
58 #include "runtime/vframeArray.hpp"
59 #include "utilities/checkedCast.hpp"
60 #include "utilities/debug.hpp"
61 #include "utilities/powerOfTwo.hpp"
62 #include <sys/types.h>
63
64 // Size of interpreter code. Increase if too small. Interpreter will
451 } else {
452 __ mov(c_rarg2, NULL_WORD);
453 }
454 __ call_VM(r0,
455 CAST_FROM_FN_PTR(address, InterpreterRuntime::create_exception),
456 c_rarg1, c_rarg2);
457 }
458 // throw exception
459 __ b(address(Interpreter::throw_exception_entry()));
460 return entry;
461 }
462
463 address TemplateInterpreterGenerator::generate_return_entry_for(TosState state, int step, size_t index_size) {
464 address entry = __ pc();
465
466 // Restore stack bottom in case i2c adjusted stack
467 __ ldr(rscratch1, Address(rfp, frame::interpreter_frame_last_sp_offset * wordSize));
468 __ lea(esp, Address(rfp, rscratch1, Address::lsl(Interpreter::logStackElementSize)));
469 // and null it as marker that esp is now tos until next java call
470 __ str(zr, Address(rfp, frame::interpreter_frame_last_sp_offset * wordSize));
471
472 if (state == atos && InlineTypeReturnedAsFields) {
473 __ store_inline_type_fields_to_buf(nullptr, true);
474 }
475
476 __ restore_bcp();
477 __ restore_locals();
478 __ restore_constant_pool_cache();
479 __ get_method(rmethod);
480
481 if (state == atos) {
482 Register obj = r0;
483 Register mdp = r1;
484 Register tmp = r2;
485 __ profile_return_type(mdp, obj, tmp);
486 }
487
488 const Register cache = r1;
489 const Register index = r2;
490
491 if (index_size == sizeof(u4)) {
492 __ load_resolved_indy_entry(cache, index);
493 __ load_unsigned_short(cache, Address(cache, in_bytes(ResolvedIndyEntry::num_parameters_offset())));
494 __ add(esp, esp, cache, Assembler::LSL, 3);
495 } else {
1622
1623 JFR_ONLY(__ leave_jfr_critical_section();)
1624
1625 // restore sender sp
1626 __ mov(sp, esp);
1627
1628 __ ret(lr);
1629
1630 if (inc_counter) {
1631 // Handle overflow of counter and compile method
1632 __ bind(invocation_counter_overflow);
1633 generate_counter_overflow(continue_after_compile);
1634 }
1635
1636 return entry_point;
1637 }
1638
1639 //
1640 // Generic interpreted method entry to (asm) interpreter
1641 //
1642 address TemplateInterpreterGenerator::generate_normal_entry(bool synchronized, bool object_init) {
1643 // determine code generation flags
1644 bool inc_counter = UseCompiler || CountCompiledCalls;
1645
1646 // rscratch1: sender sp
1647 address entry_point = __ pc();
1648
1649 const Address constMethod(rmethod, Method::const_offset());
1650 const Address access_flags(rmethod, Method::access_flags_offset());
1651 const Address size_of_parameters(r3,
1652 ConstMethod::size_of_parameters_offset());
1653 const Address size_of_locals(r3, ConstMethod::size_of_locals_offset());
1654
1655 // get parameter size (always needed)
1656 // need to load the const method first
1657 __ ldr(r3, constMethod);
1658 __ load_unsigned_short(r2, size_of_parameters);
1659
1660 // r2: size of parameters
1661
1662 __ load_unsigned_short(r3, size_of_locals); // get size of locals in words
1749 // check for synchronized methods
1750 // Must happen AFTER invocation_counter check and stack overflow check,
1751 // so method is not locked if overflows.
1752 if (synchronized) {
1753 // Allocate monitor and lock method
1754 lock_method();
1755 } else {
1756 // no synchronization necessary
1757 #ifdef ASSERT
1758 {
1759 Label L;
1760 __ ldrh(r0, access_flags);
1761 __ tst(r0, JVM_ACC_SYNCHRONIZED);
1762 __ br(Assembler::EQ, L);
1763 __ stop("method needs synchronization");
1764 __ bind(L);
1765 }
1766 #endif
1767 }
1768
1769 // Issue a StoreStore barrier on entry to Object_init if the
1770 // class has strict field fields. Be lazy, always do it.
1771 if (object_init) {
1772 __ membar(MacroAssembler::StoreStore);
1773 }
1774
1775 // start execution
1776 #ifdef ASSERT
1777 {
1778 Label L;
1779 const Address monitor_block_top (rfp,
1780 frame::interpreter_frame_monitor_block_top_offset * wordSize);
1781 __ ldr(rscratch1, monitor_block_top);
1782 __ lea(rscratch1, Address(rfp, rscratch1, Address::lsl(Interpreter::logStackElementSize)));
1783 __ cmp(esp, rscratch1);
1784 __ br(Assembler::EQ, L);
1785 __ stop("broken stack frame setup in interpreter 2");
1786 __ bind(L);
1787 }
1788 #endif
1789
1790 // jvmti support
1791 __ notify_method_entry();
1792
1793 __ dispatch_next(vtos);
1794
|