jdk
1/*2* Copyright (c) 2003, 2023, Oracle and/or its affiliates. All rights reserved.3* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.4*5* This code is free software; you can redistribute it and/or modify it6* under the terms of the GNU General Public License version 2 only, as7* published by the Free Software Foundation.8*9* This code is distributed in the hope that it will be useful, but WITHOUT10* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or11* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License12* version 2 for more details (a copy is included in the LICENSE file that13* accompanied this code).14*15* You should have received a copy of the GNU General Public License version16* 2 along with this work; if not, write to the Free Software Foundation,17* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.18*19* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA20* or visit www.oracle.com if you need additional information or have any21* questions.22*23*/24// Size of interpreter code. Increase if too small. Interpreter will63// fail with a guarantee ("not enough space for interpreter generation");64// if too small.65// Run with +PrintInterpreter to get the VM to print out the size.66// Max size with JVMTI67#ifdef AMD6468int TemplateInterpreter::InterpreterCodeSize = JVMCI_ONLY(268) NOT_JVMCI(256) * 1024;69#else70int TemplateInterpreter::InterpreterCodeSize = 224 * 1024;71#endif // AMD6472// Global Register Names74static const Register rbcp = LP64_ONLY(r13) NOT_LP64(rsi);75static const Register rlocals = LP64_ONLY(r14) NOT_LP64(rdi);76//-----------------------------------------------------------------------------83}114}132}151}184}254}317}375}389// Helpers for commoning out cases in the various type of method entries.393//394// increment invocation count & check for overflow397//398// Note: checking for negative value instead of overflow399// so we have a 'sticky' overflow test400//401// rbx: method402// rcx: invocation counter403//404void TemplateInterpreterGenerator::generate_counter_incr(Label* overflow) {405Label done;406// Note: In tiered we increment either counters in Method* or in MDO depending if we're profiling or not.407Label no_mdo;408if (ProfileInterpreter) {409// Are we profiling?410__ movptr(rax, Address(rbx, Method::method_data_offset()));411__ testptr(rax, rax);412__ jccb(Assembler::zero, no_mdo);413// Increment counter in the MDO414const Address mdo_invocation_counter(rax, in_bytes(MethodData::invocation_counter_offset()) +415in_bytes(InvocationCounter::counter_offset()));416const Address mask(rax, in_bytes(MethodData::invoke_mask_offset()));417__ increment_mask_and_jump(mdo_invocation_counter, mask, rcx, overflow);418__ jmp(done);419}420__ bind(no_mdo);421// Increment counter in MethodCounters422const Address invocation_counter(rax,423MethodCounters::invocation_counter_offset() +424InvocationCounter::counter_offset());425__ get_method_counters(rbx, rax, done);426const Address mask(rax, in_bytes(MethodCounters::invoke_mask_offset()));427__ increment_mask_and_jump(invocation_counter, mask, rcx, overflow);428__ bind(done);429}430}463// See if we've got enough room on the stack for locals plus overhead below465// JavaThread::stack_overflow_limit(). If not, throw a StackOverflowError466// without going through the signal handler, i.e., reserved and yellow zones467// will not be made usable. The shadow zone must suffice to handle the468// overflow.469// The expression stack grows down incrementally, so the normal guard470// page mechanism will work for that.471//472// NOTE: Since the additional locals are also always pushed (wasn't473// obvious in generate_fixed_frame) so the guard should work for them474// too.475//476// Args:477// rdx: number of additional locals this frame needs (what we must check)478// rbx: Method*479//480// Kills:481// rax482void TemplateInterpreterGenerator::generate_stack_overflow_check(void) {483}557// Allocate monitor and lock method (asm interpreter)559//560// Args:561// rbx: Method*562// r14/rdi: locals563//564// Kills:565// rax566// c_rarg0, c_rarg1, c_rarg2, c_rarg3, ...(param regs)567// rscratch1, rscratch2 (scratch regs)568void TemplateInterpreterGenerator::lock_method() {569// synchronize method570const Address access_flags(rbx, Method::access_flags_offset());571const Address monitor_block_top(572rbp,573frame::interpreter_frame_monitor_block_top_offset * wordSize);574const int entry_size = frame::interpreter_frame_monitor_size_in_bytes();575}619// Generate a fixed interpreter frame. This is identical setup for621// interpreted methods and for native methods hence the shared code.622//623// Args:624// rax: return address625// rbx: Method*626// r14/rdi: pointer to locals627// r13/rsi: sender sp628// rdx: cp cache629void TemplateInterpreterGenerator::generate_fixed_frame(bool native_call) {630// initialize fixed part of activation frame631__ push(rax); // save return address632__ enter(); // save old & set new rbp633__ push(rbcp); // set sender sp634__ push(NULL_WORD); // leave last_sp as null635__ movptr(rbcp, Address(rbx, Method::const_offset())); // get ConstMethod*636__ lea(rbcp, Address(rbcp, ConstMethod::codes_offset())); // get codebase637__ push(rbx); // save Method*638// Get mirror and store it in the frame as GC root for this Method*639__ load_mirror(rdx, rbx, rscratch2);640__ push(rdx);641if (ProfileInterpreter) {642Label method_data_continue;643__ movptr(rdx, Address(rbx, in_bytes(Method::method_data_offset())));644__ testptr(rdx, rdx);645__ jcc(Assembler::zero, method_data_continue);646__ addptr(rdx, in_bytes(MethodData::data_offset()));647__ bind(method_data_continue);648__ push(rdx); // set the mdp (method data pointer)649} else {650__ push(0);651}652}671// End of helpers673// Method entry for java.lang.ref.Reference.get.675address TemplateInterpreterGenerator::generate_Reference_get_entry(void) {676// Code: _aload_0, _getfield, _areturn677// parameter size = 1678//679// The code that gets generated by this routine is split into 2 parts:680// 1. The "intrinsified" code performing an ON_WEAK_OOP_REF load,681// 2. The slow path - which is an expansion of the regular method entry.682//683// Notes:-684// * An intrinsic is always executed, where an ON_WEAK_OOP_REF load is performed.685// * We may jump to the slow path iff the receiver is null. If the686// Reference object is null then we no longer perform an ON_WEAK_OOP_REF load687// Thus we can use the regular method entry code to generate the NPE.688//689// rbx: Method*690}733}789// Interpreter stub for calling a native method. (asm interpreter)791// This sets up a somewhat different looking stack for calling the792// native method than the typical interpreter frame setup.793address TemplateInterpreterGenerator::generate_native_entry(bool synchronized) {794// determine code generation flags795bool inc_counter = UseCompiler || CountCompiledCalls;796}1307// Abstract method entry1309// Attempt to execute abstract method. Throw exception1310address TemplateInterpreterGenerator::generate_abstract_entry(void) {1311}1328//1330// Generic interpreted method entry to (asm) interpreter1331//1332address TemplateInterpreterGenerator::generate_normal_entry(bool synchronized) {1333// determine code generation flags1334bool inc_counter = UseCompiler || CountCompiledCalls;1335// __ incrementl(rdx);1360// __ andl(rdx, -2);1361}1485//-----------------------------------------------------------------------------1487// Exceptions1488}1717//1720// JVMTI ForceEarlyReturn support1721//1722address TemplateInterpreterGenerator::generate_earlyret_entry_for(TosState state) {1723address entry = __ pc();1724//-----------------------------------------------------------------------------1749// Helper for vtos entry point generation1750}1787//-----------------------------------------------------------------------------1789// Non-product code1791#ifndef PRODUCT1792}1831}1835}1839}1850}1869}1880#endif // !PRODUCT1881