• file
• revisions
• annotate
• diff
• comparison
• raw

src/cpu/x86/vm/templateInterpreter_x86_64.cpp@18a08a7e16b5 (annotated)

src/cpu/x86/vm/templateInterpreter_x86_64.cpp

Fri, 26 Jun 2009 07:26:10 -0700

author

twisti

date

Fri, 26 Jun 2009 07:26:10 -0700

changeset 1259

18a08a7e16b5

parent 1161

be93aad57795

child 1494

389049f3f393

permissions

-rw-r--r--

5057225: Remove useless I2L conversions
Summary: The optimizer should be told to normalize (AndL (ConvI2L x) 0xFF) to (ConvI2L (AndI x 0xFF)), and then the existing matcher rule will work for free.
Reviewed-by: kvn

duke@435	1	/*
jrose@1145	2	* Copyright 2003-2009 Sun Microsystems, Inc. All Rights Reserved.
duke@435	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
duke@435	4	*
duke@435	5	* This code is free software; you can redistribute it and/or modify it
duke@435	6	* under the terms of the GNU General Public License version 2 only, as
duke@435	7	* published by the Free Software Foundation.
duke@435	8	*
duke@435	9	* This code is distributed in the hope that it will be useful, but WITHOUT
duke@435	10	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
duke@435	11	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
duke@435	12	* version 2 for more details (a copy is included in the LICENSE file that
duke@435	13	* accompanied this code).
duke@435	14	*
duke@435	15	* You should have received a copy of the GNU General Public License version
duke@435	16	* 2 along with this work; if not, write to the Free Software Foundation,
duke@435	17	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
duke@435	18	*
duke@435	19	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
duke@435	20	* CA 95054 USA or visit www.sun.com if you need additional information or
duke@435	21	* have any questions.
duke@435	22	*
duke@435	23	*/
duke@435	24
duke@435	25	#include "incls/_precompiled.incl"
duke@435	26	#include "incls/_interpreter_x86_64.cpp.incl"
duke@435	27
duke@435	28	#define __ _masm->
duke@435	29
never@739	30	#ifndef CC_INTERP
never@739	31
duke@435	32	const int method_offset = frame::interpreter_frame_method_offset * wordSize;
duke@435	33	const int bci_offset = frame::interpreter_frame_bcx_offset * wordSize;
duke@435	34	const int locals_offset = frame::interpreter_frame_locals_offset * wordSize;
duke@435	35
duke@435	36	//-----------------------------------------------------------------------------
duke@435	37
duke@435	38	address TemplateInterpreterGenerator::generate_StackOverflowError_handler() {
duke@435	39	address entry = __ pc();
duke@435	40
duke@435	41	#ifdef ASSERT
duke@435	42	{
duke@435	43	Label L;
never@739	44	__ lea(rax, Address(rbp,
never@739	45	frame::interpreter_frame_monitor_block_top_offset *
never@739	46	wordSize));
never@739	47	__ cmpptr(rax, rsp); // rax = maximal rsp for current rbp (stack
never@739	48	// grows negative)
duke@435	49	__ jcc(Assembler::aboveEqual, L); // check if frame is complete
duke@435	50	__ stop ("interpreter frame not set up");
duke@435	51	__ bind(L);
duke@435	52	}
duke@435	53	#endif // ASSERT
duke@435	54	// Restore bcp under the assumption that the current frame is still
duke@435	55	// interpreted
duke@435	56	__ restore_bcp();
duke@435	57
duke@435	58	// expression stack must be empty before entering the VM if an
duke@435	59	// exception happened
duke@435	60	__ empty_expression_stack();
duke@435	61	// throw exception
duke@435	62	__ call_VM(noreg,
duke@435	63	CAST_FROM_FN_PTR(address,
duke@435	64	InterpreterRuntime::throw_StackOverflowError));
duke@435	65	return entry;
duke@435	66	}
duke@435	67
duke@435	68	address TemplateInterpreterGenerator::generate_ArrayIndexOutOfBounds_handler(
duke@435	69	const char* name) {
duke@435	70	address entry = __ pc();
duke@435	71	// expression stack must be empty before entering the VM if an
duke@435	72	// exception happened
duke@435	73	__ empty_expression_stack();
duke@435	74	// setup parameters
duke@435	75	// ??? convention: expect aberrant index in register ebx
duke@435	76	__ lea(c_rarg1, ExternalAddress((address)name));
duke@435	77	__ call_VM(noreg,
duke@435	78	CAST_FROM_FN_PTR(address,
duke@435	79	InterpreterRuntime::
duke@435	80	throw_ArrayIndexOutOfBoundsException),
duke@435	81	c_rarg1, rbx);
duke@435	82	return entry;
duke@435	83	}
duke@435	84
duke@435	85	address TemplateInterpreterGenerator::generate_ClassCastException_handler() {
duke@435	86	address entry = __ pc();
duke@435	87
duke@435	88	// object is at TOS
never@739	89	__ pop(c_rarg1);
duke@435	90
duke@435	91	// expression stack must be empty before entering the VM if an
duke@435	92	// exception happened
duke@435	93	__ empty_expression_stack();
duke@435	94
duke@435	95	__ call_VM(noreg,
duke@435	96	CAST_FROM_FN_PTR(address,
duke@435	97	InterpreterRuntime::
duke@435	98	throw_ClassCastException),
duke@435	99	c_rarg1);
duke@435	100	return entry;
duke@435	101	}
duke@435	102
jrose@1145	103	// Arguments are: required type in rarg1, failing object (or NULL) in rarg2
jrose@1145	104	address TemplateInterpreterGenerator::generate_WrongMethodType_handler() {
jrose@1145	105	address entry = __ pc();
jrose@1145	106
jrose@1145	107	__ pop(c_rarg2); // failing object is at TOS
jrose@1145	108	__ pop(c_rarg1); // required type is at TOS+8
jrose@1145	109
jrose@1145	110	// expression stack must be empty before entering the VM if an
jrose@1145	111	// exception happened
jrose@1145	112	__ empty_expression_stack();
jrose@1145	113
jrose@1145	114	__ call_VM(noreg,
jrose@1145	115	CAST_FROM_FN_PTR(address,
jrose@1145	116	InterpreterRuntime::
jrose@1145	117	throw_WrongMethodTypeException),
jrose@1145	118	// pass required type, failing object (or NULL)
jrose@1145	119	c_rarg1, c_rarg2);
jrose@1145	120	return entry;
jrose@1145	121	}
jrose@1145	122
duke@435	123	address TemplateInterpreterGenerator::generate_exception_handler_common(
duke@435	124	const char* name, const char* message, bool pass_oop) {
duke@435	125	assert(!pass_oop || message == NULL, "either oop or message but not both");
duke@435	126	address entry = __ pc();
duke@435	127	if (pass_oop) {
duke@435	128	// object is at TOS
never@739	129	__ pop(c_rarg2);
duke@435	130	}
duke@435	131	// expression stack must be empty before entering the VM if an
duke@435	132	// exception happened
duke@435	133	__ empty_expression_stack();
duke@435	134	// setup parameters
duke@435	135	__ lea(c_rarg1, ExternalAddress((address)name));
duke@435	136	if (pass_oop) {
duke@435	137	__ call_VM(rax, CAST_FROM_FN_PTR(address,
duke@435	138	InterpreterRuntime::
duke@435	139	create_klass_exception),
duke@435	140	c_rarg1, c_rarg2);
duke@435	141	} else {
duke@435	142	// kind of lame ExternalAddress can't take NULL because
duke@435	143	// external_word_Relocation will assert.
duke@435	144	if (message != NULL) {
duke@435	145	__ lea(c_rarg2, ExternalAddress((address)message));
duke@435	146	} else {
duke@435	147	__ movptr(c_rarg2, NULL_WORD);
duke@435	148	}
duke@435	149	__ call_VM(rax,
duke@435	150	CAST_FROM_FN_PTR(address, InterpreterRuntime::create_exception),
duke@435	151	c_rarg1, c_rarg2);
duke@435	152	}
duke@435	153	// throw exception
duke@435	154	__ jump(ExternalAddress(Interpreter::throw_exception_entry()));
duke@435	155	return entry;
duke@435	156	}
duke@435	157
duke@435	158
duke@435	159	address TemplateInterpreterGenerator::generate_continuation_for(TosState state) {
duke@435	160	address entry = __ pc();
duke@435	161	// NULL last_sp until next java call
never@739	162	__ movptr(Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize), (int32_t)NULL_WORD);
duke@435	163	__ dispatch_next(state);
duke@435	164	return entry;
duke@435	165	}
duke@435	166
duke@435	167
duke@435	168	address TemplateInterpreterGenerator::generate_return_entry_for(TosState state,
jrose@1161	169	int step, bool unbox) {
jrose@1161	170	assert(!unbox, "NYI");//6815692//
duke@435	171
duke@435	172	// amd64 doesn't need to do anything special about compiled returns
duke@435	173	// to the interpreter so the code that exists on x86 to place a sentinel
duke@435	174	// here and the specialized cleanup code is not needed here.
duke@435	175
duke@435	176	address entry = __ pc();
duke@435	177
duke@435	178	// Restore stack bottom in case i2c adjusted stack
never@739	179	__ movptr(rsp, Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize));
duke@435	180	// and NULL it as marker that esp is now tos until next java call
never@739	181	__ movptr(Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize), (int32_t)NULL_WORD);
duke@435	182
duke@435	183	__ restore_bcp();
duke@435	184	__ restore_locals();
never@739	185
duke@435	186	__ get_cache_and_index_at_bcp(rbx, rcx, 1);
duke@435	187	__ movl(rbx, Address(rbx, rcx,
duke@435	188	Address::times_8,
duke@435	189	in_bytes(constantPoolCacheOopDesc::base_offset()) +
duke@435	190	3 * wordSize));
duke@435	191	__ andl(rbx, 0xFF);
duke@435	192	if (TaggedStackInterpreter) __ shll(rbx, 1); // 2 slots per parameter.
never@739	193	__ lea(rsp, Address(rsp, rbx, Address::times_8));
duke@435	194	__ dispatch_next(state, step);
duke@435	195	return entry;
duke@435	196	}
duke@435	197
duke@435	198
duke@435	199	address TemplateInterpreterGenerator::generate_deopt_entry_for(TosState state,
duke@435	200	int step) {
duke@435	201	address entry = __ pc();
duke@435	202	// NULL last_sp until next java call
never@739	203	__ movptr(Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize), (int32_t)NULL_WORD);
duke@435	204	__ restore_bcp();
duke@435	205	__ restore_locals();
duke@435	206	// handle exceptions
duke@435	207	{
duke@435	208	Label L;
never@739	209	__ cmpptr(Address(r15_thread, Thread::pending_exception_offset()), (int32_t) NULL_WORD);
duke@435	210	__ jcc(Assembler::zero, L);
duke@435	211	__ call_VM(noreg,
duke@435	212	CAST_FROM_FN_PTR(address,
duke@435	213	InterpreterRuntime::throw_pending_exception));
duke@435	214	__ should_not_reach_here();
duke@435	215	__ bind(L);
duke@435	216	}
duke@435	217	__ dispatch_next(state, step);
duke@435	218	return entry;
duke@435	219	}
duke@435	220
duke@435	221	int AbstractInterpreter::BasicType_as_index(BasicType type) {
duke@435	222	int i = 0;
duke@435	223	switch (type) {
duke@435	224	case T_BOOLEAN: i = 0; break;
duke@435	225	case T_CHAR : i = 1; break;
duke@435	226	case T_BYTE : i = 2; break;
duke@435	227	case T_SHORT : i = 3; break;
duke@435	228	case T_INT : i = 4; break;
duke@435	229	case T_LONG : i = 5; break;
duke@435	230	case T_VOID : i = 6; break;
duke@435	231	case T_FLOAT : i = 7; break;
duke@435	232	case T_DOUBLE : i = 8; break;
duke@435	233	case T_OBJECT : i = 9; break;
duke@435	234	case T_ARRAY : i = 9; break;
duke@435	235	default : ShouldNotReachHere();
duke@435	236	}
duke@435	237	assert(0 <= i && i < AbstractInterpreter::number_of_result_handlers,
duke@435	238	"index out of bounds");
duke@435	239	return i;
duke@435	240	}
duke@435	241
duke@435	242
duke@435	243	address TemplateInterpreterGenerator::generate_result_handler_for(
duke@435	244	BasicType type) {
duke@435	245	address entry = __ pc();
duke@435	246	switch (type) {
duke@435	247	case T_BOOLEAN: __ c2bool(rax); break;
duke@435	248	case T_CHAR : __ movzwl(rax, rax); break;
duke@435	249	case T_BYTE : __ sign_extend_byte(rax); break;
duke@435	250	case T_SHORT : __ sign_extend_short(rax); break;
duke@435	251	case T_INT : /* nothing to do */ break;
duke@435	252	case T_LONG : /* nothing to do */ break;
duke@435	253	case T_VOID : /* nothing to do */ break;
duke@435	254	case T_FLOAT : /* nothing to do */ break;
duke@435	255	case T_DOUBLE : /* nothing to do */ break;
duke@435	256	case T_OBJECT :
duke@435	257	// retrieve result from frame
never@739	258	__ movptr(rax, Address(rbp, frame::interpreter_frame_oop_temp_offset*wordSize));
duke@435	259	// and verify it
duke@435	260	__ verify_oop(rax);
duke@435	261	break;
duke@435	262	default : ShouldNotReachHere();
duke@435	263	}
duke@435	264	__ ret(0); // return from result handler
duke@435	265	return entry;
duke@435	266	}
duke@435	267
duke@435	268	address TemplateInterpreterGenerator::generate_safept_entry_for(
duke@435	269	TosState state,
duke@435	270	address runtime_entry) {
duke@435	271	address entry = __ pc();
duke@435	272	__ push(state);
duke@435	273	__ call_VM(noreg, runtime_entry);
duke@435	274	__ dispatch_via(vtos, Interpreter::_normal_table.table_for(vtos));
duke@435	275	return entry;
duke@435	276	}
duke@435	277
duke@435	278
duke@435	279
duke@435	280	// Helpers for commoning out cases in the various type of method entries.
duke@435	281	//
duke@435	282
duke@435	283
duke@435	284	// increment invocation count & check for overflow
duke@435	285	//
duke@435	286	// Note: checking for negative value instead of overflow
duke@435	287	// so we have a 'sticky' overflow test
duke@435	288	//
duke@435	289	// rbx: method
duke@435	290	// ecx: invocation counter
duke@435	291	//
duke@435	292	void InterpreterGenerator::generate_counter_incr(
duke@435	293	Label* overflow,
duke@435	294	Label* profile_method,
duke@435	295	Label* profile_method_continue) {
duke@435	296
duke@435	297	const Address invocation_counter(rbx,
duke@435	298	methodOopDesc::invocation_counter_offset() +
duke@435	299	InvocationCounter::counter_offset());
duke@435	300	const Address backedge_counter(rbx,
duke@435	301	methodOopDesc::backedge_counter_offset() +
duke@435	302	InvocationCounter::counter_offset());
duke@435	303
duke@435	304	if (ProfileInterpreter) { // %%% Merge this into methodDataOop
duke@435	305	__ incrementl(Address(rbx,
duke@435	306	methodOopDesc::interpreter_invocation_counter_offset()));
duke@435	307	}
duke@435	308	// Update standard invocation counters
duke@435	309	__ movl(rax, backedge_counter); // load backedge counter
duke@435	310
duke@435	311	__ incrementl(rcx, InvocationCounter::count_increment);
duke@435	312	__ andl(rax, InvocationCounter::count_mask_value); // mask out the
duke@435	313	// status bits
duke@435	314
duke@435	315	__ movl(invocation_counter, rcx); // save invocation count
duke@435	316	__ addl(rcx, rax); // add both counters
duke@435	317
duke@435	318	// profile_method is non-null only for interpreted method so
duke@435	319	// profile_method != NULL == !native_call
duke@435	320
duke@435	321	if (ProfileInterpreter && profile_method != NULL) {
duke@435	322	// Test to see if we should create a method data oop
duke@435	323	__ cmp32(rcx, ExternalAddress((address)&InvocationCounter::InterpreterProfileLimit));
duke@435	324	__ jcc(Assembler::less, *profile_method_continue);
duke@435	325
duke@435	326	// if no method data exists, go to profile_method
duke@435	327	__ test_method_data_pointer(rax, *profile_method);
duke@435	328	}
duke@435	329
duke@435	330	__ cmp32(rcx, ExternalAddress((address)&InvocationCounter::InterpreterInvocationLimit));
duke@435	331	__ jcc(Assembler::aboveEqual, *overflow);
duke@435	332	}
duke@435	333
duke@435	334	void InterpreterGenerator::generate_counter_overflow(Label* do_continue) {
duke@435	335
duke@435	336	// Asm interpreter on entry
duke@435	337	// r14 - locals
duke@435	338	// r13 - bcp
duke@435	339	// rbx - method
duke@435	340	// edx - cpool --- DOES NOT APPEAR TO BE TRUE
duke@435	341	// rbp - interpreter frame
duke@435	342
duke@435	343	// On return (i.e. jump to entry_point) [ back to invocation of interpreter ]
duke@435	344	// Everything as it was on entry
duke@435	345	// rdx is not restored. Doesn't appear to really be set.
duke@435	346
duke@435	347	const Address size_of_parameters(rbx,
duke@435	348	methodOopDesc::size_of_parameters_offset());
duke@435	349
duke@435	350	// InterpreterRuntime::frequency_counter_overflow takes two
duke@435	351	// arguments, the first (thread) is passed by call_VM, the second
duke@435	352	// indicates if the counter overflow occurs at a backwards branch
duke@435	353	// (NULL bcp). We pass zero for it. The call returns the address
duke@435	354	// of the verified entry point for the method or NULL if the
duke@435	355	// compilation did not complete (either went background or bailed
duke@435	356	// out).
duke@435	357	__ movl(c_rarg1, 0);
duke@435	358	__ call_VM(noreg,
duke@435	359	CAST_FROM_FN_PTR(address,
duke@435	360	InterpreterRuntime::frequency_counter_overflow),
duke@435	361	c_rarg1);
duke@435	362
never@739	363	__ movptr(rbx, Address(rbp, method_offset)); // restore methodOop
duke@435	364	// Preserve invariant that r13/r14 contain bcp/locals of sender frame
duke@435	365	// and jump to the interpreted entry.
duke@435	366	__ jmp(*do_continue, relocInfo::none);
duke@435	367	}
duke@435	368
duke@435	369	// See if we've got enough room on the stack for locals plus overhead.
duke@435	370	// The expression stack grows down incrementally, so the normal guard
duke@435	371	// page mechanism will work for that.
duke@435	372	//
duke@435	373	// NOTE: Since the additional locals are also always pushed (wasn't
duke@435	374	// obvious in generate_method_entry) so the guard should work for them
duke@435	375	// too.
duke@435	376	//
duke@435	377	// Args:
duke@435	378	// rdx: number of additional locals this frame needs (what we must check)
duke@435	379	// rbx: methodOop
duke@435	380	//
duke@435	381	// Kills:
duke@435	382	// rax
duke@435	383	void InterpreterGenerator::generate_stack_overflow_check(void) {
duke@435	384
duke@435	385	// monitor entry size: see picture of stack set
duke@435	386	// (generate_method_entry) and frame_amd64.hpp
duke@435	387	const int entry_size = frame::interpreter_frame_monitor_size() * wordSize;
duke@435	388
duke@435	389	// total overhead size: entry_size + (saved rbp through expr stack
duke@435	390	// bottom). be sure to change this if you add/subtract anything
duke@435	391	// to/from the overhead area
duke@435	392	const int overhead_size =
duke@435	393	-(frame::interpreter_frame_initial_sp_offset * wordSize) + entry_size;
duke@435	394
duke@435	395	const int page_size = os::vm_page_size();
duke@435	396
duke@435	397	Label after_frame_check;
duke@435	398
duke@435	399	// see if the frame is greater than one page in size. If so,
duke@435	400	// then we need to verify there is enough stack space remaining
duke@435	401	// for the additional locals.
duke@435	402	__ cmpl(rdx, (page_size - overhead_size) / Interpreter::stackElementSize());
duke@435	403	__ jcc(Assembler::belowEqual, after_frame_check);
duke@435	404
duke@435	405	// compute rsp as if this were going to be the last frame on
duke@435	406	// the stack before the red zone
duke@435	407
duke@435	408	const Address stack_base(r15_thread, Thread::stack_base_offset());
duke@435	409	const Address stack_size(r15_thread, Thread::stack_size_offset());
duke@435	410
duke@435	411	// locals + overhead, in bytes
never@739	412	__ mov(rax, rdx);
never@739	413	__ shlptr(rax, Interpreter::logStackElementSize()); // 2 slots per parameter.
never@739	414	__ addptr(rax, overhead_size);
duke@435	415
duke@435	416	#ifdef ASSERT
duke@435	417	Label stack_base_okay, stack_size_okay;
duke@435	418	// verify that thread stack base is non-zero
never@739	419	__ cmpptr(stack_base, (int32_t)NULL_WORD);
duke@435	420	__ jcc(Assembler::notEqual, stack_base_okay);
duke@435	421	__ stop("stack base is zero");
duke@435	422	__ bind(stack_base_okay);
duke@435	423	// verify that thread stack size is non-zero
never@739	424	__ cmpptr(stack_size, 0);
duke@435	425	__ jcc(Assembler::notEqual, stack_size_okay);
duke@435	426	__ stop("stack size is zero");
duke@435	427	__ bind(stack_size_okay);
duke@435	428	#endif
duke@435	429
duke@435	430	// Add stack base to locals and subtract stack size
never@739	431	__ addptr(rax, stack_base);
never@739	432	__ subptr(rax, stack_size);
duke@435	433
duke@435	434	// add in the red and yellow zone sizes
never@739	435	__ addptr(rax, (StackRedPages + StackYellowPages) * page_size);
duke@435	436
duke@435	437	// check against the current stack bottom
never@739	438	__ cmpptr(rsp, rax);
duke@435	439	__ jcc(Assembler::above, after_frame_check);
duke@435	440
never@739	441	__ pop(rax); // get return address
duke@435	442	__ jump(ExternalAddress(Interpreter::throw_StackOverflowError_entry()));
duke@435	443
duke@435	444	// all done with frame size check
duke@435	445	__ bind(after_frame_check);
duke@435	446	}
duke@435	447
duke@435	448	// Allocate monitor and lock method (asm interpreter)
duke@435	449	//
duke@435	450	// Args:
duke@435	451	// rbx: methodOop
duke@435	452	// r14: locals
duke@435	453	//
duke@435	454	// Kills:
duke@435	455	// rax
duke@435	456	// c_rarg0, c_rarg1, c_rarg2, c_rarg3, ...(param regs)
duke@435	457	// rscratch1, rscratch2 (scratch regs)
duke@435	458	void InterpreterGenerator::lock_method(void) {
duke@435	459	// synchronize method
duke@435	460	const Address access_flags(rbx, methodOopDesc::access_flags_offset());
duke@435	461	const Address monitor_block_top(
duke@435	462	rbp,
duke@435	463	frame::interpreter_frame_monitor_block_top_offset * wordSize);
duke@435	464	const int entry_size = frame::interpreter_frame_monitor_size() * wordSize;
duke@435	465
duke@435	466	#ifdef ASSERT
duke@435	467	{
duke@435	468	Label L;
duke@435	469	__ movl(rax, access_flags);
duke@435	470	__ testl(rax, JVM_ACC_SYNCHRONIZED);
duke@435	471	__ jcc(Assembler::notZero, L);
duke@435	472	__ stop("method doesn't need synchronization");
duke@435	473	__ bind(L);
duke@435	474	}
duke@435	475	#endif // ASSERT
duke@435	476
duke@435	477	// get synchronization object
duke@435	478	{
duke@435	479	const int mirror_offset = klassOopDesc::klass_part_offset_in_bytes() +
duke@435	480	Klass::java_mirror_offset_in_bytes();
duke@435	481	Label done;
duke@435	482	__ movl(rax, access_flags);
duke@435	483	__ testl(rax, JVM_ACC_STATIC);
duke@435	484	// get receiver (assume this is frequent case)
never@739	485	__ movptr(rax, Address(r14, Interpreter::local_offset_in_bytes(0)));
duke@435	486	__ jcc(Assembler::zero, done);
never@739	487	__ movptr(rax, Address(rbx, methodOopDesc::constants_offset()));
never@739	488	__ movptr(rax, Address(rax,
never@739	489	constantPoolOopDesc::pool_holder_offset_in_bytes()));
never@739	490	__ movptr(rax, Address(rax, mirror_offset));
duke@435	491
duke@435	492	#ifdef ASSERT
duke@435	493	{
duke@435	494	Label L;
never@739	495	__ testptr(rax, rax);
duke@435	496	__ jcc(Assembler::notZero, L);
duke@435	497	__ stop("synchronization object is NULL");
duke@435	498	__ bind(L);
duke@435	499	}
duke@435	500	#endif // ASSERT
duke@435	501
duke@435	502	__ bind(done);
duke@435	503	}
duke@435	504
duke@435	505	// add space for monitor & lock
never@739	506	__ subptr(rsp, entry_size); // add space for a monitor entry
never@739	507	__ movptr(monitor_block_top, rsp); // set new monitor block top
duke@435	508	// store object
never@739	509	__ movptr(Address(rsp, BasicObjectLock::obj_offset_in_bytes()), rax);
never@739	510	__ movptr(c_rarg1, rsp); // object address
duke@435	511	__ lock_object(c_rarg1);
duke@435	512	}
duke@435	513
duke@435	514	// Generate a fixed interpreter frame. This is identical setup for
duke@435	515	// interpreted methods and for native methods hence the shared code.
duke@435	516	//
duke@435	517	// Args:
duke@435	518	// rax: return address
duke@435	519	// rbx: methodOop
duke@435	520	// r14: pointer to locals
duke@435	521	// r13: sender sp
duke@435	522	// rdx: cp cache
duke@435	523	void TemplateInterpreterGenerator::generate_fixed_frame(bool native_call) {
duke@435	524	// initialize fixed part of activation frame
never@739	525	__ push(rax); // save return address
duke@435	526	__ enter(); // save old & set new rbp
never@739	527	__ push(r13); // set sender sp
never@739	528	__ push((int)NULL_WORD); // leave last_sp as null
never@739	529	__ movptr(r13, Address(rbx, methodOopDesc::const_offset())); // get constMethodOop
never@739	530	__ lea(r13, Address(r13, constMethodOopDesc::codes_offset())); // get codebase
never@739	531	__ push(rbx); // save methodOop
duke@435	532	if (ProfileInterpreter) {
duke@435	533	Label method_data_continue;
never@739	534	__ movptr(rdx, Address(rbx, in_bytes(methodOopDesc::method_data_offset())));
never@739	535	__ testptr(rdx, rdx);
duke@435	536	__ jcc(Assembler::zero, method_data_continue);
never@739	537	__ addptr(rdx, in_bytes(methodDataOopDesc::data_offset()));
duke@435	538	__ bind(method_data_continue);
never@739	539	__ push(rdx); // set the mdp (method data pointer)
duke@435	540	} else {
never@739	541	__ push(0);
duke@435	542	}
duke@435	543
never@739	544	__ movptr(rdx, Address(rbx, methodOopDesc::constants_offset()));
never@739	545	__ movptr(rdx, Address(rdx, constantPoolOopDesc::cache_offset_in_bytes()));
never@739	546	__ push(rdx); // set constant pool cache
never@739	547	__ push(r14); // set locals pointer
duke@435	548	if (native_call) {
never@739	549	__ push(0); // no bcp
duke@435	550	} else {
never@739	551	__ push(r13); // set bcp
duke@435	552	}
never@739	553	__ push(0); // reserve word for pointer to expression stack bottom
never@739	554	__ movptr(Address(rsp, 0), rsp); // set expression stack bottom
duke@435	555	}
duke@435	556
duke@435	557	// End of helpers
duke@435	558
never@739	559	// Various method entries
never@739	560	//------------------------------------------------------------------------------------------------------------------------
never@739	561	//
never@739	562	//
never@739	563
never@739	564	// Call an accessor method (assuming it is resolved, otherwise drop
never@739	565	// into vanilla (slow path) entry
never@739	566	address InterpreterGenerator::generate_accessor_entry(void) {
never@739	567	// rbx: methodOop
never@739	568
never@739	569	// r13: senderSP must preserver for slow path, set SP to it on fast path
never@739	570
never@739	571	address entry_point = __ pc();
never@739	572	Label xreturn_path;
never@739	573
never@739	574	// do fastpath for resolved accessor methods
never@739	575	if (UseFastAccessorMethods) {
never@739	576	// Code: _aload_0, _(i|a)getfield, _(i|a)return or any rewrites
never@739	577	// thereof; parameter size = 1
never@739	578	// Note: We can only use this code if the getfield has been resolved
never@739	579	// and if we don't have a null-pointer exception => check for
never@739	580	// these conditions first and use slow path if necessary.
never@739	581	Label slow_path;
never@739	582	// If we need a safepoint check, generate full interpreter entry.
never@739	583	__ cmp32(ExternalAddress(SafepointSynchronize::address_of_state()),
never@739	584	SafepointSynchronize::_not_synchronized);
never@739	585
never@739	586	__ jcc(Assembler::notEqual, slow_path);
never@739	587	// rbx: method
never@739	588	__ movptr(rax, Address(rsp, wordSize));
never@739	589
never@739	590	// check if local 0 != NULL and read field
never@739	591	__ testptr(rax, rax);
never@739	592	__ jcc(Assembler::zero, slow_path);
never@739	593
never@739	594	__ movptr(rdi, Address(rbx, methodOopDesc::constants_offset()));
never@739	595	// read first instruction word and extract bytecode @ 1 and index @ 2
never@739	596	__ movptr(rdx, Address(rbx, methodOopDesc::const_offset()));
never@739	597	__ movl(rdx, Address(rdx, constMethodOopDesc::codes_offset()));
never@739	598	// Shift codes right to get the index on the right.
never@739	599	// The bytecode fetched looks like <index><0xb4><0x2a>
never@739	600	__ shrl(rdx, 2 * BitsPerByte);
never@739	601	__ shll(rdx, exact_log2(in_words(ConstantPoolCacheEntry::size())));
never@739	602	__ movptr(rdi, Address(rdi, constantPoolOopDesc::cache_offset_in_bytes()));
never@739	603
never@739	604	// rax: local 0
never@739	605	// rbx: method
never@739	606	// rdx: constant pool cache index
never@739	607	// rdi: constant pool cache
never@739	608
never@739	609	// check if getfield has been resolved and read constant pool cache entry
never@739	610	// check the validity of the cache entry by testing whether _indices field
never@739	611	// contains Bytecode::_getfield in b1 byte.
never@739	612	assert(in_words(ConstantPoolCacheEntry::size()) == 4,
never@739	613	"adjust shift below");
never@739	614	__ movl(rcx,
never@739	615	Address(rdi,
never@739	616	rdx,
never@739	617	Address::times_8,
never@739	618	constantPoolCacheOopDesc::base_offset() +
never@739	619	ConstantPoolCacheEntry::indices_offset()));
never@739	620	__ shrl(rcx, 2 * BitsPerByte);
never@739	621	__ andl(rcx, 0xFF);
never@739	622	__ cmpl(rcx, Bytecodes::_getfield);
never@739	623	__ jcc(Assembler::notEqual, slow_path);
never@739	624
never@739	625	// Note: constant pool entry is not valid before bytecode is resolved
never@739	626	__ movptr(rcx,
never@739	627	Address(rdi,
never@739	628	rdx,
never@739	629	Address::times_8,
never@739	630	constantPoolCacheOopDesc::base_offset() +
never@739	631	ConstantPoolCacheEntry::f2_offset()));
never@739	632	// edx: flags
never@739	633	__ movl(rdx,
never@739	634	Address(rdi,
never@739	635	rdx,
never@739	636	Address::times_8,
never@739	637	constantPoolCacheOopDesc::base_offset() +
never@739	638	ConstantPoolCacheEntry::flags_offset()));
never@739	639
never@739	640	Label notObj, notInt, notByte, notShort;
never@739	641	const Address field_address(rax, rcx, Address::times_1);
never@739	642
never@739	643	// Need to differentiate between igetfield, agetfield, bgetfield etc.
never@739	644	// because they are different sizes.
never@739	645	// Use the type from the constant pool cache
never@739	646	__ shrl(rdx, ConstantPoolCacheEntry::tosBits);
never@739	647	// Make sure we don't need to mask edx for tosBits after the above shift
never@739	648	ConstantPoolCacheEntry::verify_tosBits();
never@739	649
never@739	650	__ cmpl(rdx, atos);
never@739	651	__ jcc(Assembler::notEqual, notObj);
never@739	652	// atos
never@739	653	__ load_heap_oop(rax, field_address);
never@739	654	__ jmp(xreturn_path);
never@739	655
never@739	656	__ bind(notObj);
never@739	657	__ cmpl(rdx, itos);
never@739	658	__ jcc(Assembler::notEqual, notInt);
never@739	659	// itos
never@739	660	__ movl(rax, field_address);
never@739	661	__ jmp(xreturn_path);
never@739	662
never@739	663	__ bind(notInt);
never@739	664	__ cmpl(rdx, btos);
never@739	665	__ jcc(Assembler::notEqual, notByte);
never@739	666	// btos
never@739	667	__ load_signed_byte(rax, field_address);
never@739	668	__ jmp(xreturn_path);
never@739	669
never@739	670	__ bind(notByte);
never@739	671	__ cmpl(rdx, stos);
never@739	672	__ jcc(Assembler::notEqual, notShort);
never@739	673	// stos
jrose@1057	674	__ load_signed_short(rax, field_address);
never@739	675	__ jmp(xreturn_path);
never@739	676
never@739	677	__ bind(notShort);
never@739	678	#ifdef ASSERT
never@739	679	Label okay;
never@739	680	__ cmpl(rdx, ctos);
never@739	681	__ jcc(Assembler::equal, okay);
never@739	682	__ stop("what type is this?");
never@739	683	__ bind(okay);
never@739	684	#endif
never@739	685	// ctos
jrose@1057	686	__ load_unsigned_short(rax, field_address);
never@739	687
never@739	688	__ bind(xreturn_path);
never@739	689
never@739	690	// _ireturn/_areturn
never@739	691	__ pop(rdi);
never@739	692	__ mov(rsp, r13);
never@739	693	__ jmp(rdi);
never@739	694	__ ret(0);
never@739	695
never@739	696	// generate a vanilla interpreter entry as the slow path
never@739	697	__ bind(slow_path);
never@739	698	(void) generate_normal_entry(false);
never@739	699	} else {
never@739	700	(void) generate_normal_entry(false);
never@739	701	}
never@739	702
never@739	703	return entry_point;
never@739	704	}
never@739	705
duke@435	706	// Interpreter stub for calling a native method. (asm interpreter)
duke@435	707	// This sets up a somewhat different looking stack for calling the
duke@435	708	// native method than the typical interpreter frame setup.
duke@435	709	address InterpreterGenerator::generate_native_entry(bool synchronized) {
duke@435	710	// determine code generation flags
duke@435	711	bool inc_counter = UseCompiler || CountCompiledCalls;
duke@435	712
duke@435	713	// rbx: methodOop
duke@435	714	// r13: sender sp
duke@435	715
duke@435	716	address entry_point = __ pc();
duke@435	717
duke@435	718	const Address size_of_parameters(rbx, methodOopDesc::
duke@435	719	size_of_parameters_offset());
duke@435	720	const Address invocation_counter(rbx, methodOopDesc::
duke@435	721	invocation_counter_offset() +
duke@435	722	InvocationCounter::counter_offset());
duke@435	723	const Address access_flags (rbx, methodOopDesc::access_flags_offset());
duke@435	724
duke@435	725	// get parameter size (always needed)
jrose@1057	726	__ load_unsigned_short(rcx, size_of_parameters);
duke@435	727
duke@435	728	// native calls don't need the stack size check since they have no
duke@435	729	// expression stack and the arguments are already on the stack and
duke@435	730	// we only add a handful of words to the stack
duke@435	731
duke@435	732	// rbx: methodOop
duke@435	733	// rcx: size of parameters
duke@435	734	// r13: sender sp
never@739	735	__ pop(rax); // get return address
duke@435	736
duke@435	737	// for natives the size of locals is zero
duke@435	738
duke@435	739	// compute beginning of parameters (r14)
duke@435	740	if (TaggedStackInterpreter) __ shll(rcx, 1); // 2 slots per parameter.
never@739	741	__ lea(r14, Address(rsp, rcx, Address::times_8, -wordSize));
duke@435	742
duke@435	743	// add 2 zero-initialized slots for native calls
duke@435	744	// initialize result_handler slot
never@739	745	__ push((int) NULL_WORD);
duke@435	746	// slot for oop temp
duke@435	747	// (static native method holder mirror/jni oop result)
never@739	748	__ push((int) NULL_WORD);
duke@435	749
duke@435	750	if (inc_counter) {
duke@435	751	__ movl(rcx, invocation_counter); // (pre-)fetch invocation count
duke@435	752	}
duke@435	753
duke@435	754	// initialize fixed part of activation frame
duke@435	755	generate_fixed_frame(true);
duke@435	756
duke@435	757	// make sure method is native & not abstract
duke@435	758	#ifdef ASSERT
duke@435	759	__ movl(rax, access_flags);
duke@435	760	{
duke@435	761	Label L;
duke@435	762	__ testl(rax, JVM_ACC_NATIVE);
duke@435	763	__ jcc(Assembler::notZero, L);
duke@435	764	__ stop("tried to execute non-native method as native");
duke@435	765	__ bind(L);
duke@435	766	}
duke@435	767	{
duke@435	768	Label L;
duke@435	769	__ testl(rax, JVM_ACC_ABSTRACT);
duke@435	770	__ jcc(Assembler::zero, L);
duke@435	771	__ stop("tried to execute abstract method in interpreter");
duke@435	772	__ bind(L);
duke@435	773	}
duke@435	774	#endif
duke@435	775
duke@435	776	// Since at this point in the method invocation the exception handler
duke@435	777	// would try to exit the monitor of synchronized methods which hasn't
duke@435	778	// been entered yet, we set the thread local variable
duke@435	779	// _do_not_unlock_if_synchronized to true. The remove_activation will
duke@435	780	// check this flag.
duke@435	781
duke@435	782	const Address do_not_unlock_if_synchronized(r15_thread,
duke@435	783	in_bytes(JavaThread::do_not_unlock_if_synchronized_offset()));
duke@435	784	__ movbool(do_not_unlock_if_synchronized, true);
duke@435	785
duke@435	786	// increment invocation count & check for overflow
duke@435	787	Label invocation_counter_overflow;
duke@435	788	if (inc_counter) {
duke@435	789	generate_counter_incr(&invocation_counter_overflow, NULL, NULL);
duke@435	790	}
duke@435	791
duke@435	792	Label continue_after_compile;
duke@435	793	__ bind(continue_after_compile);
duke@435	794
duke@435	795	bang_stack_shadow_pages(true);
duke@435	796
duke@435	797	// reset the _do_not_unlock_if_synchronized flag
duke@435	798	__ movbool(do_not_unlock_if_synchronized, false);
duke@435	799
duke@435	800	// check for synchronized methods
duke@435	801	// Must happen AFTER invocation_counter check and stack overflow check,
duke@435	802	// so method is not locked if overflows.
duke@435	803	if (synchronized) {
duke@435	804	lock_method();
duke@435	805	} else {
duke@435	806	// no synchronization necessary
duke@435	807	#ifdef ASSERT
duke@435	808	{
duke@435	809	Label L;
duke@435	810	__ movl(rax, access_flags);
duke@435	811	__ testl(rax, JVM_ACC_SYNCHRONIZED);
duke@435	812	__ jcc(Assembler::zero, L);
duke@435	813	__ stop("method needs synchronization");
duke@435	814	__ bind(L);
duke@435	815	}
duke@435	816	#endif
duke@435	817	}
duke@435	818
duke@435	819	// start execution
duke@435	820	#ifdef ASSERT
duke@435	821	{
duke@435	822	Label L;
duke@435	823	const Address monitor_block_top(rbp,
duke@435	824	frame::interpreter_frame_monitor_block_top_offset * wordSize);
never@739	825	__ movptr(rax, monitor_block_top);
never@739	826	__ cmpptr(rax, rsp);
duke@435	827	__ jcc(Assembler::equal, L);
duke@435	828	__ stop("broken stack frame setup in interpreter");
duke@435	829	__ bind(L);
duke@435	830	}
duke@435	831	#endif
duke@435	832
duke@435	833	// jvmti support
duke@435	834	__ notify_method_entry();
duke@435	835
duke@435	836	// work registers
duke@435	837	const Register method = rbx;
coleenp@548	838	const Register t = r11;
duke@435	839
duke@435	840	// allocate space for parameters
duke@435	841	__ get_method(method);
duke@435	842	__ verify_oop(method);
jrose@1057	843	__ load_unsigned_short(t,
jrose@1057	844	Address(method,
jrose@1057	845	methodOopDesc::size_of_parameters_offset()));
duke@435	846	__ shll(t, Interpreter::logStackElementSize());
duke@435	847
never@739	848	__ subptr(rsp, t);
never@739	849	__ subptr(rsp, frame::arg_reg_save_area_bytes); // windows
twisti@1040	850	__ andptr(rsp, -16); // must be 16 byte boundary (see amd64 ABI)
duke@435	851
duke@435	852	// get signature handler
duke@435	853	{
duke@435	854	Label L;
never@739	855	__ movptr(t, Address(method, methodOopDesc::signature_handler_offset()));
never@739	856	__ testptr(t, t);
duke@435	857	__ jcc(Assembler::notZero, L);
duke@435	858	__ call_VM(noreg,
duke@435	859	CAST_FROM_FN_PTR(address,
duke@435	860	InterpreterRuntime::prepare_native_call),
duke@435	861	method);
duke@435	862	__ get_method(method);
never@739	863	__ movptr(t, Address(method, methodOopDesc::signature_handler_offset()));
duke@435	864	__ bind(L);
duke@435	865	}
duke@435	866
duke@435	867	// call signature handler
duke@435	868	assert(InterpreterRuntime::SignatureHandlerGenerator::from() == r14,
duke@435	869	"adjust this code");
duke@435	870	assert(InterpreterRuntime::SignatureHandlerGenerator::to() == rsp,
duke@435	871	"adjust this code");
duke@435	872	assert(InterpreterRuntime::SignatureHandlerGenerator::temp() == rscratch1,
duke@435	873	"adjust this code");
duke@435	874
duke@435	875	// The generated handlers do not touch RBX (the method oop).
duke@435	876	// However, large signatures cannot be cached and are generated
duke@435	877	// each time here. The slow-path generator can do a GC on return,
duke@435	878	// so we must reload it after the call.
duke@435	879	__ call(t);
duke@435	880	__ get_method(method); // slow path can do a GC, reload RBX
duke@435	881
duke@435	882
duke@435	883	// result handler is in rax
duke@435	884	// set result handler
never@739	885	__ movptr(Address(rbp,
never@739	886	(frame::interpreter_frame_result_handler_offset) * wordSize),
never@739	887	rax);
duke@435	888
duke@435	889	// pass mirror handle if static call
duke@435	890	{
duke@435	891	Label L;
duke@435	892	const int mirror_offset = klassOopDesc::klass_part_offset_in_bytes() +
duke@435	893	Klass::java_mirror_offset_in_bytes();
duke@435	894	__ movl(t, Address(method, methodOopDesc::access_flags_offset()));
duke@435	895	__ testl(t, JVM_ACC_STATIC);
duke@435	896	__ jcc(Assembler::zero, L);
duke@435	897	// get mirror
never@739	898	__ movptr(t, Address(method, methodOopDesc::constants_offset()));
never@739	899	__ movptr(t, Address(t, constantPoolOopDesc::pool_holder_offset_in_bytes()));
never@739	900	__ movptr(t, Address(t, mirror_offset));
duke@435	901	// copy mirror into activation frame
never@739	902	__ movptr(Address(rbp, frame::interpreter_frame_oop_temp_offset * wordSize),
duke@435	903	t);
duke@435	904	// pass handle to mirror
never@739	905	__ lea(c_rarg1,
never@739	906	Address(rbp, frame::interpreter_frame_oop_temp_offset * wordSize));
duke@435	907	__ bind(L);
duke@435	908	}
duke@435	909
duke@435	910	// get native function entry point
duke@435	911	{
duke@435	912	Label L;
never@739	913	__ movptr(rax, Address(method, methodOopDesc::native_function_offset()));
duke@435	914	ExternalAddress unsatisfied(SharedRuntime::native_method_throw_unsatisfied_link_error_entry());
duke@435	915	__ movptr(rscratch2, unsatisfied.addr());
never@739	916	__ cmpptr(rax, rscratch2);
duke@435	917	__ jcc(Assembler::notEqual, L);
duke@435	918	__ call_VM(noreg,
duke@435	919	CAST_FROM_FN_PTR(address,
duke@435	920	InterpreterRuntime::prepare_native_call),
duke@435	921	method);
duke@435	922	__ get_method(method);
duke@435	923	__ verify_oop(method);
never@739	924	__ movptr(rax, Address(method, methodOopDesc::native_function_offset()));
duke@435	925	__ bind(L);
duke@435	926	}
duke@435	927
duke@435	928	// pass JNIEnv
never@739	929	__ lea(c_rarg0, Address(r15_thread, JavaThread::jni_environment_offset()));
duke@435	930
duke@435	931	// It is enough that the pc() points into the right code
duke@435	932	// segment. It does not have to be the correct return pc.
duke@435	933	__ set_last_Java_frame(rsp, rbp, (address) __ pc());
duke@435	934
duke@435	935	// change thread state
duke@435	936	#ifdef ASSERT
duke@435	937	{
duke@435	938	Label L;
duke@435	939	__ movl(t, Address(r15_thread, JavaThread::thread_state_offset()));
duke@435	940	__ cmpl(t, _thread_in_Java);
duke@435	941	__ jcc(Assembler::equal, L);
duke@435	942	__ stop("Wrong thread state in native stub");
duke@435	943	__ bind(L);
duke@435	944	}
duke@435	945	#endif
duke@435	946
duke@435	947	// Change state to native
duke@435	948
duke@435	949	__ movl(Address(r15_thread, JavaThread::thread_state_offset()),
duke@435	950	_thread_in_native);
duke@435	951
duke@435	952	// Call the native method.
duke@435	953	__ call(rax);
duke@435	954	// result potentially in rax or xmm0
duke@435	955
duke@435	956	// Depending on runtime options, either restore the MXCSR
duke@435	957	// register after returning from the JNI Call or verify that
duke@435	958	// it wasn't changed during -Xcheck:jni.
duke@435	959	if (RestoreMXCSROnJNICalls) {
never@739	960	__ ldmxcsr(ExternalAddress(StubRoutines::x86::mxcsr_std()));
duke@435	961	}
duke@435	962	else if (CheckJNICalls) {
never@739	963	__ call(RuntimeAddress(CAST_FROM_FN_PTR(address, StubRoutines::x86::verify_mxcsr_entry())));
duke@435	964	}
duke@435	965
duke@435	966	// NOTE: The order of these pushes is known to frame::interpreter_frame_result
duke@435	967	// in order to extract the result of a method call. If the order of these
duke@435	968	// pushes change or anything else is added to the stack then the code in
duke@435	969	// interpreter_frame_result must also change.
duke@435	970
duke@435	971	__ push(dtos);
duke@435	972	__ push(ltos);
duke@435	973
duke@435	974	// change thread state
duke@435	975	__ movl(Address(r15_thread, JavaThread::thread_state_offset()),
duke@435	976	_thread_in_native_trans);
duke@435	977
duke@435	978	if (os::is_MP()) {
duke@435	979	if (UseMembar) {
duke@435	980	// Force this write out before the read below
duke@435	981	__ membar(Assembler::Membar_mask_bits(
duke@435	982	Assembler::LoadLoad | Assembler::LoadStore |
duke@435	983	Assembler::StoreLoad | Assembler::StoreStore));
duke@435	984	} else {
duke@435	985	// Write serialization page so VM thread can do a pseudo remote membar.
duke@435	986	// We use the current thread pointer to calculate a thread specific
duke@435	987	// offset to write to within the page. This minimizes bus traffic
duke@435	988	// due to cache line collision.
duke@435	989	__ serialize_memory(r15_thread, rscratch2);
duke@435	990	}
duke@435	991	}
duke@435	992
duke@435	993	// check for safepoint operation in progress and/or pending suspend requests
duke@435	994	{
duke@435	995	Label Continue;
duke@435	996	__ cmp32(ExternalAddress(SafepointSynchronize::address_of_state()),
duke@435	997	SafepointSynchronize::_not_synchronized);
duke@435	998
duke@435	999	Label L;
duke@435	1000	__ jcc(Assembler::notEqual, L);
duke@435	1001	__ cmpl(Address(r15_thread, JavaThread::suspend_flags_offset()), 0);
duke@435	1002	__ jcc(Assembler::equal, Continue);
duke@435	1003	__ bind(L);
duke@435	1004
duke@435	1005	// Don't use call_VM as it will see a possible pending exception
duke@435	1006	// and forward it and never return here preventing us from
duke@435	1007	// clearing _last_native_pc down below. Also can't use
duke@435	1008	// call_VM_leaf either as it will check to see if r13 & r14 are
duke@435	1009	// preserved and correspond to the bcp/locals pointers. So we do a
duke@435	1010	// runtime call by hand.
duke@435	1011	//
never@739	1012	__ mov(c_rarg0, r15_thread);
never@739	1013	__ mov(r12, rsp); // remember sp
never@739	1014	__ subptr(rsp, frame::arg_reg_save_area_bytes); // windows
never@739	1015	__ andptr(rsp, -16); // align stack as required by ABI
duke@435	1016	__ call(RuntimeAddress(CAST_FROM_FN_PTR(address, JavaThread::check_special_condition_for_native_trans)));
never@739	1017	__ mov(rsp, r12); // restore sp
coleenp@548	1018	__ reinit_heapbase();
duke@435	1019	__ bind(Continue);
duke@435	1020	}
duke@435	1021
duke@435	1022	// change thread state
duke@435	1023	__ movl(Address(r15_thread, JavaThread::thread_state_offset()), _thread_in_Java);
duke@435	1024
duke@435	1025	// reset_last_Java_frame
duke@435	1026	__ reset_last_Java_frame(true, true);
duke@435	1027
duke@435	1028	// reset handle block
never@739	1029	__ movptr(t, Address(r15_thread, JavaThread::active_handles_offset()));
never@739	1030	__ movptr(Address(t, JNIHandleBlock::top_offset_in_bytes()), (int32_t)NULL_WORD);
duke@435	1031
duke@435	1032	// If result is an oop unbox and store it in frame where gc will see it
duke@435	1033	// and result handler will pick it up
duke@435	1034
duke@435	1035	{
duke@435	1036	Label no_oop, store_result;
duke@435	1037	__ lea(t, ExternalAddress(AbstractInterpreter::result_handler(T_OBJECT)));
never@739	1038	__ cmpptr(t, Address(rbp, frame::interpreter_frame_result_handler_offset*wordSize));
duke@435	1039	__ jcc(Assembler::notEqual, no_oop);
duke@435	1040	// retrieve result
duke@435	1041	__ pop(ltos);
never@739	1042	__ testptr(rax, rax);
duke@435	1043	__ jcc(Assembler::zero, store_result);
never@739	1044	__ movptr(rax, Address(rax, 0));
duke@435	1045	__ bind(store_result);
never@739	1046	__ movptr(Address(rbp, frame::interpreter_frame_oop_temp_offset*wordSize), rax);
duke@435	1047	// keep stack depth as expected by pushing oop which will eventually be discarde
duke@435	1048	__ push(ltos);
duke@435	1049	__ bind(no_oop);
duke@435	1050	}
duke@435	1051
duke@435	1052
duke@435	1053	{
duke@435	1054	Label no_reguard;
duke@435	1055	__ cmpl(Address(r15_thread, JavaThread::stack_guard_state_offset()),
duke@435	1056	JavaThread::stack_guard_yellow_disabled);
duke@435	1057	__ jcc(Assembler::notEqual, no_reguard);
duke@435	1058
never@739	1059	__ pusha(); // XXX only save smashed registers
never@739	1060	__ mov(r12, rsp); // remember sp
never@739	1061	__ subptr(rsp, frame::arg_reg_save_area_bytes); // windows
never@739	1062	__ andptr(rsp, -16); // align stack as required by ABI
duke@435	1063	__ call(RuntimeAddress(CAST_FROM_FN_PTR(address, SharedRuntime::reguard_yellow_pages)));
never@739	1064	__ mov(rsp, r12); // restore sp
never@739	1065	__ popa(); // XXX only restore smashed registers
coleenp@548	1066	__ reinit_heapbase();
duke@435	1067
duke@435	1068	__ bind(no_reguard);
duke@435	1069	}
duke@435	1070
duke@435	1071
duke@435	1072	// The method register is junk from after the thread_in_native transition
duke@435	1073	// until here. Also can't call_VM until the bcp has been
duke@435	1074	// restored. Need bcp for throwing exception below so get it now.
duke@435	1075	__ get_method(method);
duke@435	1076	__ verify_oop(method);
duke@435	1077
duke@435	1078	// restore r13 to have legal interpreter frame, i.e., bci == 0 <=>
duke@435	1079	// r13 == code_base()
never@739	1080	__ movptr(r13, Address(method, methodOopDesc::const_offset())); // get constMethodOop
never@739	1081	__ lea(r13, Address(r13, constMethodOopDesc::codes_offset())); // get codebase
duke@435	1082	// handle exceptions (exception handling will handle unlocking!)
duke@435	1083	{
duke@435	1084	Label L;
never@739	1085	__ cmpptr(Address(r15_thread, Thread::pending_exception_offset()), (int32_t) NULL_WORD);
duke@435	1086	__ jcc(Assembler::zero, L);
duke@435	1087	// Note: At some point we may want to unify this with the code
duke@435	1088	// used in call_VM_base(); i.e., we should use the
duke@435	1089	// StubRoutines::forward_exception code. For now this doesn't work
duke@435	1090	// here because the rsp is not correctly set at this point.
duke@435	1091	__ MacroAssembler::call_VM(noreg,
duke@435	1092	CAST_FROM_FN_PTR(address,
duke@435	1093	InterpreterRuntime::throw_pending_exception));
duke@435	1094	__ should_not_reach_here();
duke@435	1095	__ bind(L);
duke@435	1096	}
duke@435	1097
duke@435	1098	// do unlocking if necessary
duke@435	1099	{
duke@435	1100	Label L;
duke@435	1101	__ movl(t, Address(method, methodOopDesc::access_flags_offset()));
duke@435	1102	__ testl(t, JVM_ACC_SYNCHRONIZED);
duke@435	1103	__ jcc(Assembler::zero, L);
duke@435	1104	// the code below should be shared with interpreter macro
duke@435	1105	// assembler implementation
duke@435	1106	{
duke@435	1107	Label unlock;
duke@435	1108	// BasicObjectLock will be first in list, since this is a
duke@435	1109	// synchronized method. However, need to check that the object
duke@435	1110	// has not been unlocked by an explicit monitorexit bytecode.
duke@435	1111	const Address monitor(rbp,
duke@435	1112	(intptr_t)(frame::interpreter_frame_initial_sp_offset *
duke@435	1113	wordSize - sizeof(BasicObjectLock)));
duke@435	1114
duke@435	1115	// monitor expect in c_rarg1 for slow unlock path
never@739	1116	__ lea(c_rarg1, monitor); // address of first monitor
duke@435	1117
never@739	1118	__ movptr(t, Address(c_rarg1, BasicObjectLock::obj_offset_in_bytes()));
never@739	1119	__ testptr(t, t);
duke@435	1120	__ jcc(Assembler::notZero, unlock);
duke@435	1121
duke@435	1122	// Entry already unlocked, need to throw exception
duke@435	1123	__ MacroAssembler::call_VM(noreg,
duke@435	1124	CAST_FROM_FN_PTR(address,
duke@435	1125	InterpreterRuntime::throw_illegal_monitor_state_exception));
duke@435	1126	__ should_not_reach_here();
duke@435	1127
duke@435	1128	__ bind(unlock);
duke@435	1129	__ unlock_object(c_rarg1);
duke@435	1130	}
duke@435	1131	__ bind(L);
duke@435	1132	}
duke@435	1133
duke@435	1134	// jvmti support
duke@435	1135	// Note: This must happen _after_ handling/throwing any exceptions since
duke@435	1136	// the exception handler code notifies the runtime of method exits
duke@435	1137	// too. If this happens before, method entry/exit notifications are
duke@435	1138	// not properly paired (was bug - gri 11/22/99).
duke@435	1139	__ notify_method_exit(vtos, InterpreterMacroAssembler::NotifyJVMTI);
duke@435	1140
duke@435	1141	// restore potential result in edx:eax, call result handler to
duke@435	1142	// restore potential result in ST0 & handle result
duke@435	1143
duke@435	1144	__ pop(ltos);
duke@435	1145	__ pop(dtos);
duke@435	1146
never@739	1147	__ movptr(t, Address(rbp,
never@739	1148	(frame::interpreter_frame_result_handler_offset) * wordSize));
duke@435	1149	__ call(t);
duke@435	1150
duke@435	1151	// remove activation
never@739	1152	__ movptr(t, Address(rbp,
never@739	1153	frame::interpreter_frame_sender_sp_offset *
never@739	1154	wordSize)); // get sender sp
duke@435	1155	__ leave(); // remove frame anchor
never@739	1156	__ pop(rdi); // get return address
never@739	1157	__ mov(rsp, t); // set sp to sender sp
duke@435	1158	__ jmp(rdi);
duke@435	1159
duke@435	1160	if (inc_counter) {
duke@435	1161	// Handle overflow of counter and compile method
duke@435	1162	__ bind(invocation_counter_overflow);
duke@435	1163	generate_counter_overflow(&continue_after_compile);
duke@435	1164	}
duke@435	1165
duke@435	1166	return entry_point;
duke@435	1167	}
duke@435	1168
duke@435	1169	//
duke@435	1170	// Generic interpreted method entry to (asm) interpreter
duke@435	1171	//
duke@435	1172	address InterpreterGenerator::generate_normal_entry(bool synchronized) {
duke@435	1173	// determine code generation flags
duke@435	1174	bool inc_counter = UseCompiler || CountCompiledCalls;
duke@435	1175
duke@435	1176	// ebx: methodOop
duke@435	1177	// r13: sender sp
duke@435	1178	address entry_point = __ pc();
duke@435	1179
duke@435	1180	const Address size_of_parameters(rbx,
duke@435	1181	methodOopDesc::size_of_parameters_offset());
duke@435	1182	const Address size_of_locals(rbx, methodOopDesc::size_of_locals_offset());
duke@435	1183	const Address invocation_counter(rbx,
duke@435	1184	methodOopDesc::invocation_counter_offset() +
duke@435	1185	InvocationCounter::counter_offset());
duke@435	1186	const Address access_flags(rbx, methodOopDesc::access_flags_offset());
duke@435	1187
duke@435	1188	// get parameter size (always needed)
jrose@1057	1189	__ load_unsigned_short(rcx, size_of_parameters);
duke@435	1190
duke@435	1191	// rbx: methodOop
duke@435	1192	// rcx: size of parameters
duke@435	1193	// r13: sender_sp (could differ from sp+wordSize if we were called via c2i )
duke@435	1194
jrose@1057	1195	__ load_unsigned_short(rdx, size_of_locals); // get size of locals in words
duke@435	1196	__ subl(rdx, rcx); // rdx = no. of additional locals
duke@435	1197
duke@435	1198	// YYY
duke@435	1199	// __ incrementl(rdx);
duke@435	1200	// __ andl(rdx, -2);
duke@435	1201
duke@435	1202	// see if we've got enough room on the stack for locals plus overhead.
duke@435	1203	generate_stack_overflow_check();
duke@435	1204
duke@435	1205	// get return address
never@739	1206	__ pop(rax);
duke@435	1207
duke@435	1208	// compute beginning of parameters (r14)
duke@435	1209	if (TaggedStackInterpreter) __ shll(rcx, 1); // 2 slots per parameter.
never@739	1210	__ lea(r14, Address(rsp, rcx, Address::times_8, -wordSize));
duke@435	1211
duke@435	1212	// rdx - # of additional locals
duke@435	1213	// allocate space for locals
duke@435	1214	// explicitly initialize locals
duke@435	1215	{
duke@435	1216	Label exit, loop;
duke@435	1217	__ testl(rdx, rdx);
duke@435	1218	__ jcc(Assembler::lessEqual, exit); // do nothing if rdx <= 0
duke@435	1219	__ bind(loop);
never@739	1220	if (TaggedStackInterpreter) __ push((int) NULL_WORD); // push tag
never@739	1221	__ push((int) NULL_WORD); // initialize local variables
duke@435	1222	__ decrementl(rdx); // until everything initialized
duke@435	1223	__ jcc(Assembler::greater, loop);
duke@435	1224	__ bind(exit);
duke@435	1225	}
duke@435	1226
duke@435	1227	// (pre-)fetch invocation count
duke@435	1228	if (inc_counter) {
duke@435	1229	__ movl(rcx, invocation_counter);
duke@435	1230	}
duke@435	1231	// initialize fixed part of activation frame
duke@435	1232	generate_fixed_frame(false);
duke@435	1233
duke@435	1234	// make sure method is not native & not abstract
duke@435	1235	#ifdef ASSERT
duke@435	1236	__ movl(rax, access_flags);
duke@435	1237	{
duke@435	1238	Label L;
duke@435	1239	__ testl(rax, JVM_ACC_NATIVE);
duke@435	1240	__ jcc(Assembler::zero, L);
duke@435	1241	__ stop("tried to execute native method as non-native");
duke@435	1242	__ bind(L);
duke@435	1243	}
duke@435	1244	{
duke@435	1245	Label L;
duke@435	1246	__ testl(rax, JVM_ACC_ABSTRACT);
duke@435	1247	__ jcc(Assembler::zero, L);
duke@435	1248	__ stop("tried to execute abstract method in interpreter");
duke@435	1249	__ bind(L);
duke@435	1250	}
duke@435	1251	#endif
duke@435	1252
duke@435	1253	// Since at this point in the method invocation the exception
duke@435	1254	// handler would try to exit the monitor of synchronized methods
duke@435	1255	// which hasn't been entered yet, we set the thread local variable
duke@435	1256	// _do_not_unlock_if_synchronized to true. The remove_activation
duke@435	1257	// will check this flag.
duke@435	1258
duke@435	1259	const Address do_not_unlock_if_synchronized(r15_thread,
duke@435	1260	in_bytes(JavaThread::do_not_unlock_if_synchronized_offset()));
duke@435	1261	__ movbool(do_not_unlock_if_synchronized, true);
duke@435	1262
duke@435	1263	// increment invocation count & check for overflow
duke@435	1264	Label invocation_counter_overflow;
duke@435	1265	Label profile_method;
duke@435	1266	Label profile_method_continue;
duke@435	1267	if (inc_counter) {
duke@435	1268	generate_counter_incr(&invocation_counter_overflow,
duke@435	1269	&profile_method,
duke@435	1270	&profile_method_continue);
duke@435	1271	if (ProfileInterpreter) {
duke@435	1272	__ bind(profile_method_continue);
duke@435	1273	}
duke@435	1274	}
duke@435	1275
duke@435	1276	Label continue_after_compile;
duke@435	1277	__ bind(continue_after_compile);
duke@435	1278
duke@435	1279	// check for synchronized interpreted methods
duke@435	1280	bang_stack_shadow_pages(false);
duke@435	1281
duke@435	1282	// reset the _do_not_unlock_if_synchronized flag
duke@435	1283	__ movbool(do_not_unlock_if_synchronized, false);
duke@435	1284
duke@435	1285	// check for synchronized methods
duke@435	1286	// Must happen AFTER invocation_counter check and stack overflow check,
duke@435	1287	// so method is not locked if overflows.
duke@435	1288	if (synchronized) {
duke@435	1289	// Allocate monitor and lock method
duke@435	1290	lock_method();
duke@435	1291	} else {
duke@435	1292	// no synchronization necessary
duke@435	1293	#ifdef ASSERT
duke@435	1294	{
duke@435	1295	Label L;
duke@435	1296	__ movl(rax, access_flags);
duke@435	1297	__ testl(rax, JVM_ACC_SYNCHRONIZED);
duke@435	1298	__ jcc(Assembler::zero, L);
duke@435	1299	__ stop("method needs synchronization");
duke@435	1300	__ bind(L);
duke@435	1301	}
duke@435	1302	#endif
duke@435	1303	}
duke@435	1304
duke@435	1305	// start execution
duke@435	1306	#ifdef ASSERT
duke@435	1307	{
duke@435	1308	Label L;
duke@435	1309	const Address monitor_block_top (rbp,
duke@435	1310	frame::interpreter_frame_monitor_block_top_offset * wordSize);
never@739	1311	__ movptr(rax, monitor_block_top);
never@739	1312	__ cmpptr(rax, rsp);
duke@435	1313	__ jcc(Assembler::equal, L);
duke@435	1314	__ stop("broken stack frame setup in interpreter");
duke@435	1315	__ bind(L);
duke@435	1316	}
duke@435	1317	#endif
duke@435	1318
duke@435	1319	// jvmti support
duke@435	1320	__ notify_method_entry();
duke@435	1321
duke@435	1322	__ dispatch_next(vtos);
duke@435	1323
duke@435	1324	// invocation counter overflow
duke@435	1325	if (inc_counter) {
duke@435	1326	if (ProfileInterpreter) {
duke@435	1327	// We have decided to profile this method in the interpreter
duke@435	1328	__ bind(profile_method);
duke@435	1329
duke@435	1330	__ call_VM(noreg,
duke@435	1331	CAST_FROM_FN_PTR(address, InterpreterRuntime::profile_method),
duke@435	1332	r13, true);
duke@435	1333
never@739	1334	__ movptr(rbx, Address(rbp, method_offset)); // restore methodOop
never@739	1335	__ movptr(rax, Address(rbx,
never@739	1336	in_bytes(methodOopDesc::method_data_offset())));
never@739	1337	__ movptr(Address(rbp, frame::interpreter_frame_mdx_offset * wordSize),
never@739	1338	rax);
duke@435	1339	__ test_method_data_pointer(rax, profile_method_continue);
never@739	1340	__ addptr(rax, in_bytes(methodDataOopDesc::data_offset()));
never@739	1341	__ movptr(Address(rbp, frame::interpreter_frame_mdx_offset * wordSize),
duke@435	1342	rax);
duke@435	1343	__ jmp(profile_method_continue);
duke@435	1344	}
duke@435	1345	// Handle overflow of counter and compile method
duke@435	1346	__ bind(invocation_counter_overflow);
duke@435	1347	generate_counter_overflow(&continue_after_compile);
duke@435	1348	}
duke@435	1349
duke@435	1350	return entry_point;
duke@435	1351	}
duke@435	1352
duke@435	1353	// Entry points
duke@435	1354	//
duke@435	1355	// Here we generate the various kind of entries into the interpreter.
duke@435	1356	// The two main entry type are generic bytecode methods and native
duke@435	1357	// call method. These both come in synchronized and non-synchronized
duke@435	1358	// versions but the frame layout they create is very similar. The
duke@435	1359	// other method entry types are really just special purpose entries
duke@435	1360	// that are really entry and interpretation all in one. These are for
duke@435	1361	// trivial methods like accessor, empty, or special math methods.
duke@435	1362	//
duke@435	1363	// When control flow reaches any of the entry types for the interpreter
duke@435	1364	// the following holds ->
duke@435	1365	//
duke@435	1366	// Arguments:
duke@435	1367	//
duke@435	1368	// rbx: methodOop
duke@435	1369	//
duke@435	1370	// Stack layout immediately at entry
duke@435	1371	//
duke@435	1372	// [ return address ] <--- rsp
duke@435	1373	// [ parameter n ]
duke@435	1374	// ...
duke@435	1375	// [ parameter 1 ]
duke@435	1376	// [ expression stack ] (caller's java expression stack)
duke@435	1377
duke@435	1378	// Assuming that we don't go to one of the trivial specialized entries
duke@435	1379	// the stack will look like below when we are ready to execute the
duke@435	1380	// first bytecode (or call the native routine). The register usage
duke@435	1381	// will be as the template based interpreter expects (see
duke@435	1382	// interpreter_amd64.hpp).
duke@435	1383	//
duke@435	1384	// local variables follow incoming parameters immediately; i.e.
duke@435	1385	// the return address is moved to the end of the locals).
duke@435	1386	//
duke@435	1387	// [ monitor entry ] <--- rsp
duke@435	1388	// ...
duke@435	1389	// [ monitor entry ]
duke@435	1390	// [ expr. stack bottom ]
duke@435	1391	// [ saved r13 ]
duke@435	1392	// [ current r14 ]
duke@435	1393	// [ methodOop ]
duke@435	1394	// [ saved ebp ] <--- rbp
duke@435	1395	// [ return address ]
duke@435	1396	// [ local variable m ]
duke@435	1397	// ...
duke@435	1398	// [ local variable 1 ]
duke@435	1399	// [ parameter n ]
duke@435	1400	// ...
duke@435	1401	// [ parameter 1 ] <--- r14
duke@435	1402
duke@435	1403	address AbstractInterpreterGenerator::generate_method_entry(
duke@435	1404	AbstractInterpreter::MethodKind kind) {
duke@435	1405	// determine code generation flags
duke@435	1406	bool synchronized = false;
duke@435	1407	address entry_point = NULL;
duke@435	1408
duke@435	1409	switch (kind) {
duke@435	1410	case Interpreter::zerolocals : break;
duke@435	1411	case Interpreter::zerolocals_synchronized: synchronized = true; break;
duke@435	1412	case Interpreter::native : entry_point = ((InterpreterGenerator*) this)->generate_native_entry(false); break;
duke@435	1413	case Interpreter::native_synchronized : entry_point = ((InterpreterGenerator*) this)->generate_native_entry(true); break;
duke@435	1414	case Interpreter::empty : entry_point = ((InterpreterGenerator*) this)->generate_empty_entry(); break;
duke@435	1415	case Interpreter::accessor : entry_point = ((InterpreterGenerator*) this)->generate_accessor_entry(); break;
duke@435	1416	case Interpreter::abstract : entry_point = ((InterpreterGenerator*) this)->generate_abstract_entry(); break;
jrose@1145	1417	case Interpreter::method_handle : entry_point = ((InterpreterGenerator*) this)->generate_method_handle_entry();break;
never@1141	1418
never@1141	1419	case Interpreter::java_lang_math_sin : // fall thru
never@1141	1420	case Interpreter::java_lang_math_cos : // fall thru
never@1141	1421	case Interpreter::java_lang_math_tan : // fall thru
never@1141	1422	case Interpreter::java_lang_math_abs : // fall thru
never@1141	1423	case Interpreter::java_lang_math_log : // fall thru
never@1141	1424	case Interpreter::java_lang_math_log10 : // fall thru
duke@435	1425	case Interpreter::java_lang_math_sqrt : entry_point = ((InterpreterGenerator*) this)->generate_math_entry(kind); break;
duke@435	1426	default : ShouldNotReachHere(); break;
duke@435	1427	}
duke@435	1428
duke@435	1429	if (entry_point) {
duke@435	1430	return entry_point;
duke@435	1431	}
duke@435	1432
duke@435	1433	return ((InterpreterGenerator*) this)->
duke@435	1434	generate_normal_entry(synchronized);
duke@435	1435	}
duke@435	1436
duke@435	1437	// How much stack a method activation needs in words.
duke@435	1438	int AbstractInterpreter::size_top_interpreter_activation(methodOop method) {
duke@435	1439	const int entry_size = frame::interpreter_frame_monitor_size();
duke@435	1440
duke@435	1441	// total overhead size: entry_size + (saved rbp thru expr stack
duke@435	1442	// bottom). be sure to change this if you add/subtract anything
duke@435	1443	// to/from the overhead area
duke@435	1444	const int overhead_size =
duke@435	1445	-(frame::interpreter_frame_initial_sp_offset) + entry_size;
duke@435	1446
duke@435	1447	const int stub_code = frame::entry_frame_after_call_words;
jrose@1145	1448	const int extra_stack = methodOopDesc::extra_stack_entries();
jrose@1145	1449	const int method_stack = (method->max_locals() + method->max_stack() + extra_stack) *
duke@435	1450	Interpreter::stackElementWords();
duke@435	1451	return (overhead_size + method_stack + stub_code);
duke@435	1452	}
duke@435	1453
duke@435	1454	int AbstractInterpreter::layout_activation(methodOop method,
duke@435	1455	int tempcount,
duke@435	1456	int popframe_extra_args,
duke@435	1457	int moncount,
duke@435	1458	int callee_param_count,
duke@435	1459	int callee_locals,
duke@435	1460	frame* caller,
duke@435	1461	frame* interpreter_frame,
duke@435	1462	bool is_top_frame) {
duke@435	1463	// Note: This calculation must exactly parallel the frame setup
duke@435	1464	// in AbstractInterpreterGenerator::generate_method_entry.
duke@435	1465	// If interpreter_frame!=NULL, set up the method, locals, and monitors.
duke@435	1466	// The frame interpreter_frame, if not NULL, is guaranteed to be the
duke@435	1467	// right size, as determined by a previous call to this method.
duke@435	1468	// It is also guaranteed to be walkable even though it is in a skeletal state
duke@435	1469
duke@435	1470	// fixed size of an interpreter frame:
duke@435	1471	int max_locals = method->max_locals() * Interpreter::stackElementWords();
duke@435	1472	int extra_locals = (method->max_locals() - method->size_of_parameters()) *
duke@435	1473	Interpreter::stackElementWords();
duke@435	1474
duke@435	1475	int overhead = frame::sender_sp_offset -
duke@435	1476	frame::interpreter_frame_initial_sp_offset;
duke@435	1477	// Our locals were accounted for by the caller (or last_frame_adjust
duke@435	1478	// on the transistion) Since the callee parameters already account
duke@435	1479	// for the callee's params we only need to account for the extra
duke@435	1480	// locals.
duke@435	1481	int size = overhead +
duke@435	1482	(callee_locals - callee_param_count)*Interpreter::stackElementWords() +
duke@435	1483	moncount * frame::interpreter_frame_monitor_size() +
duke@435	1484	tempcount* Interpreter::stackElementWords() + popframe_extra_args;
duke@435	1485	if (interpreter_frame != NULL) {
duke@435	1486	#ifdef ASSERT
duke@435	1487	assert(caller->unextended_sp() == interpreter_frame->interpreter_frame_sender_sp(),
duke@435	1488	"Frame not properly walkable");
duke@435	1489	assert(caller->sp() == interpreter_frame->sender_sp(), "Frame not properly walkable(2)");
duke@435	1490	#endif
duke@435	1491
duke@435	1492	interpreter_frame->interpreter_frame_set_method(method);
duke@435	1493	// NOTE the difference in using sender_sp and
duke@435	1494	// interpreter_frame_sender_sp interpreter_frame_sender_sp is
duke@435	1495	// the original sp of the caller (the unextended_sp) and
duke@435	1496	// sender_sp is fp+16 XXX
duke@435	1497	intptr_t* locals = interpreter_frame->sender_sp() + max_locals - 1;
duke@435	1498
duke@435	1499	interpreter_frame->interpreter_frame_set_locals(locals);
duke@435	1500	BasicObjectLock* montop = interpreter_frame->interpreter_frame_monitor_begin();
duke@435	1501	BasicObjectLock* monbot = montop - moncount;
duke@435	1502	interpreter_frame->interpreter_frame_set_monitor_end(monbot);
duke@435	1503
duke@435	1504	// Set last_sp
duke@435	1505	intptr_t* esp = (intptr_t*) monbot -
duke@435	1506	tempcount*Interpreter::stackElementWords() -
duke@435	1507	popframe_extra_args;
duke@435	1508	interpreter_frame->interpreter_frame_set_last_sp(esp);
duke@435	1509
duke@435	1510	// All frames but the initial (oldest) interpreter frame we fill in have
duke@435	1511	// a value for sender_sp that allows walking the stack but isn't
duke@435	1512	// truly correct. Correct the value here.
duke@435	1513	if (extra_locals != 0 &&
duke@435	1514	interpreter_frame->sender_sp() ==
duke@435	1515	interpreter_frame->interpreter_frame_sender_sp()) {
duke@435	1516	interpreter_frame->set_interpreter_frame_sender_sp(caller->sp() +
duke@435	1517	extra_locals);
duke@435	1518	}
duke@435	1519	*interpreter_frame->interpreter_frame_cache_addr() =
duke@435	1520	method->constants()->cache();
duke@435	1521	}
duke@435	1522	return size;
duke@435	1523	}
duke@435	1524
duke@435	1525	//-----------------------------------------------------------------------------
duke@435	1526	// Exceptions
duke@435	1527
duke@435	1528	void TemplateInterpreterGenerator::generate_throw_exception() {
duke@435	1529	// Entry point in previous activation (i.e., if the caller was
duke@435	1530	// interpreted)
duke@435	1531	Interpreter::_rethrow_exception_entry = __ pc();
duke@435	1532	// Restore sp to interpreter_frame_last_sp even though we are going
duke@435	1533	// to empty the expression stack for the exception processing.
never@739	1534	__ movptr(Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize), (int32_t)NULL_WORD);
duke@435	1535	// rax: exception
duke@435	1536	// rdx: return address/pc that threw exception
duke@435	1537	__ restore_bcp(); // r13 points to call/send
duke@435	1538	__ restore_locals();
coleenp@548	1539	__ reinit_heapbase(); // restore r12 as heapbase.
duke@435	1540	// Entry point for exceptions thrown within interpreter code
duke@435	1541	Interpreter::_throw_exception_entry = __ pc();
duke@435	1542	// expression stack is undefined here
duke@435	1543	// rax: exception
duke@435	1544	// r13: exception bcp
duke@435	1545	__ verify_oop(rax);
never@739	1546	__ mov(c_rarg1, rax);
duke@435	1547
duke@435	1548	// expression stack must be empty before entering the VM in case of
duke@435	1549	// an exception
duke@435	1550	__ empty_expression_stack();
duke@435	1551	// find exception handler address and preserve exception oop
duke@435	1552	__ call_VM(rdx,
duke@435	1553	CAST_FROM_FN_PTR(address,
duke@435	1554	InterpreterRuntime::exception_handler_for_exception),
duke@435	1555	c_rarg1);
duke@435	1556	// rax: exception handler entry point
duke@435	1557	// rdx: preserved exception oop
duke@435	1558	// r13: bcp for exception handler
duke@435	1559	__ push_ptr(rdx); // push exception which is now the only value on the stack
duke@435	1560	__ jmp(rax); // jump to exception handler (may be _remove_activation_entry!)
duke@435	1561
duke@435	1562	// If the exception is not handled in the current frame the frame is
duke@435	1563	// removed and the exception is rethrown (i.e. exception
duke@435	1564	// continuation is _rethrow_exception).
duke@435	1565	//
duke@435	1566	// Note: At this point the bci is still the bxi for the instruction
duke@435	1567	// which caused the exception and the expression stack is
duke@435	1568	// empty. Thus, for any VM calls at this point, GC will find a legal
duke@435	1569	// oop map (with empty expression stack).
duke@435	1570
duke@435	1571	// In current activation
duke@435	1572	// tos: exception
duke@435	1573	// esi: exception bcp
duke@435	1574
duke@435	1575	//
duke@435	1576	// JVMTI PopFrame support
duke@435	1577	//
duke@435	1578
duke@435	1579	Interpreter::_remove_activation_preserving_args_entry = __ pc();
duke@435	1580	__ empty_expression_stack();
duke@435	1581	// Set the popframe_processing bit in pending_popframe_condition
duke@435	1582	// indicating that we are currently handling popframe, so that
duke@435	1583	// call_VMs that may happen later do not trigger new popframe
duke@435	1584	// handling cycles.
duke@435	1585	__ movl(rdx, Address(r15_thread, JavaThread::popframe_condition_offset()));
duke@435	1586	__ orl(rdx, JavaThread::popframe_processing_bit);
duke@435	1587	__ movl(Address(r15_thread, JavaThread::popframe_condition_offset()), rdx);
duke@435	1588
duke@435	1589	{
duke@435	1590	// Check to see whether we are returning to a deoptimized frame.
duke@435	1591	// (The PopFrame call ensures that the caller of the popped frame is
duke@435	1592	// either interpreted or compiled and deoptimizes it if compiled.)
duke@435	1593	// In this case, we can't call dispatch_next() after the frame is
duke@435	1594	// popped, but instead must save the incoming arguments and restore
duke@435	1595	// them after deoptimization has occurred.
duke@435	1596	//
duke@435	1597	// Note that we don't compare the return PC against the
duke@435	1598	// deoptimization blob's unpack entry because of the presence of
duke@435	1599	// adapter frames in C2.
duke@435	1600	Label caller_not_deoptimized;
never@739	1601	__ movptr(c_rarg1, Address(rbp, frame::return_addr_offset * wordSize));
duke@435	1602	__ super_call_VM_leaf(CAST_FROM_FN_PTR(address,
duke@435	1603	InterpreterRuntime::interpreter_contains), c_rarg1);
duke@435	1604	__ testl(rax, rax);
duke@435	1605	__ jcc(Assembler::notZero, caller_not_deoptimized);
duke@435	1606
duke@435	1607	// Compute size of arguments for saving when returning to
duke@435	1608	// deoptimized caller
duke@435	1609	__ get_method(rax);
jrose@1057	1610	__ load_unsigned_short(rax, Address(rax, in_bytes(methodOopDesc::
duke@435	1611	size_of_parameters_offset())));
duke@435	1612	__ shll(rax, Interpreter::logStackElementSize());
duke@435	1613	__ restore_locals(); // XXX do we need this?
never@739	1614	__ subptr(r14, rax);
never@739	1615	__ addptr(r14, wordSize);
duke@435	1616	// Save these arguments
duke@435	1617	__ super_call_VM_leaf(CAST_FROM_FN_PTR(address,
duke@435	1618	Deoptimization::
duke@435	1619	popframe_preserve_args),
duke@435	1620	r15_thread, rax, r14);
duke@435	1621
duke@435	1622	__ remove_activation(vtos, rdx,
duke@435	1623	/* throw_monitor_exception */ false,
duke@435	1624	/* install_monitor_exception */ false,
duke@435	1625	/* notify_jvmdi */ false);
duke@435	1626
duke@435	1627	// Inform deoptimization that it is responsible for restoring
duke@435	1628	// these arguments
duke@435	1629	__ movl(Address(r15_thread, JavaThread::popframe_condition_offset()),
duke@435	1630	JavaThread::popframe_force_deopt_reexecution_bit);
duke@435	1631
duke@435	1632	// Continue in deoptimization handler
duke@435	1633	__ jmp(rdx);
duke@435	1634
duke@435	1635	__ bind(caller_not_deoptimized);
duke@435	1636	}
duke@435	1637
duke@435	1638	__ remove_activation(vtos, rdx, /* rdx result (retaddr) is not used */
duke@435	1639	/* throw_monitor_exception */ false,
duke@435	1640	/* install_monitor_exception */ false,
duke@435	1641	/* notify_jvmdi */ false);
duke@435	1642
duke@435	1643	// Finish with popframe handling
duke@435	1644	// A previous I2C followed by a deoptimization might have moved the
duke@435	1645	// outgoing arguments further up the stack. PopFrame expects the
duke@435	1646	// mutations to those outgoing arguments to be preserved and other
duke@435	1647	// constraints basically require this frame to look exactly as
duke@435	1648	// though it had previously invoked an interpreted activation with
duke@435	1649	// no space between the top of the expression stack (current
duke@435	1650	// last_sp) and the top of stack. Rather than force deopt to
duke@435	1651	// maintain this kind of invariant all the time we call a small
duke@435	1652	// fixup routine to move the mutated arguments onto the top of our
duke@435	1653	// expression stack if necessary.
never@739	1654	__ mov(c_rarg1, rsp);
never@739	1655	__ movptr(c_rarg2, Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize));
duke@435	1656	// PC must point into interpreter here
duke@435	1657	__ set_last_Java_frame(noreg, rbp, __ pc());
duke@435	1658	__ super_call_VM_leaf(CAST_FROM_FN_PTR(address, InterpreterRuntime::popframe_move_outgoing_args), r15_thread, c_rarg1, c_rarg2);
duke@435	1659	__ reset_last_Java_frame(true, true);
duke@435	1660	// Restore the last_sp and null it out
never@739	1661	__ movptr(rsp, Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize));
never@739	1662	__ movptr(Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize), (int32_t)NULL_WORD);
duke@435	1663
duke@435	1664	__ restore_bcp(); // XXX do we need this?
duke@435	1665	__ restore_locals(); // XXX do we need this?
duke@435	1666	// The method data pointer was incremented already during
duke@435	1667	// call profiling. We have to restore the mdp for the current bcp.
duke@435	1668	if (ProfileInterpreter) {
duke@435	1669	__ set_method_data_pointer_for_bcp();
duke@435	1670	}
duke@435	1671
duke@435	1672	// Clear the popframe condition flag
duke@435	1673	__ movl(Address(r15_thread, JavaThread::popframe_condition_offset()),
duke@435	1674	JavaThread::popframe_inactive);
duke@435	1675
duke@435	1676	__ dispatch_next(vtos);
duke@435	1677	// end of PopFrame support
duke@435	1678
duke@435	1679	Interpreter::_remove_activation_entry = __ pc();
duke@435	1680
duke@435	1681	// preserve exception over this code sequence
duke@435	1682	__ pop_ptr(rax);
never@739	1683	__ movptr(Address(r15_thread, JavaThread::vm_result_offset()), rax);
duke@435	1684	// remove the activation (without doing throws on illegalMonitorExceptions)
duke@435	1685	__ remove_activation(vtos, rdx, false, true, false);
duke@435	1686	// restore exception
never@739	1687	__ movptr(rax, Address(r15_thread, JavaThread::vm_result_offset()));
never@739	1688	__ movptr(Address(r15_thread, JavaThread::vm_result_offset()), (int32_t)NULL_WORD);
duke@435	1689	__ verify_oop(rax);
duke@435	1690
duke@435	1691	// In between activations - previous activation type unknown yet
duke@435	1692	// compute continuation point - the continuation point expects the
duke@435	1693	// following registers set up:
duke@435	1694	//
duke@435	1695	// rax: exception
duke@435	1696	// rdx: return address/pc that threw exception
duke@435	1697	// rsp: expression stack of caller
duke@435	1698	// rbp: ebp of caller
never@739	1699	__ push(rax); // save exception
never@739	1700	__ push(rdx); // save return address
duke@435	1701	__ super_call_VM_leaf(CAST_FROM_FN_PTR(address,
duke@435	1702	SharedRuntime::exception_handler_for_return_address),
duke@435	1703	rdx);
never@739	1704	__ mov(rbx, rax); // save exception handler
never@739	1705	__ pop(rdx); // restore return address
never@739	1706	__ pop(rax); // restore exception
duke@435	1707	// Note that an "issuing PC" is actually the next PC after the call
duke@435	1708	__ jmp(rbx); // jump to exception
duke@435	1709	// handler of caller
duke@435	1710	}
duke@435	1711
duke@435	1712
duke@435	1713	//
duke@435	1714	// JVMTI ForceEarlyReturn support
duke@435	1715	//
duke@435	1716	address TemplateInterpreterGenerator::generate_earlyret_entry_for(TosState state) {
duke@435	1717	address entry = __ pc();
duke@435	1718
duke@435	1719	__ restore_bcp();
duke@435	1720	__ restore_locals();
duke@435	1721	__ empty_expression_stack();
duke@435	1722	__ load_earlyret_value(state);
duke@435	1723
never@739	1724	__ movptr(rdx, Address(r15_thread, JavaThread::jvmti_thread_state_offset()));
duke@435	1725	Address cond_addr(rdx, JvmtiThreadState::earlyret_state_offset());
duke@435	1726
duke@435	1727	// Clear the earlyret state
duke@435	1728	__ movl(cond_addr, JvmtiThreadState::earlyret_inactive);
duke@435	1729
duke@435	1730	__ remove_activation(state, rsi,
duke@435	1731	false, /* throw_monitor_exception */
duke@435	1732	false, /* install_monitor_exception */
duke@435	1733	true); /* notify_jvmdi */
duke@435	1734	__ jmp(rsi);
duke@435	1735
duke@435	1736	return entry;
duke@435	1737	} // end of ForceEarlyReturn support
duke@435	1738
duke@435	1739
duke@435	1740	//-----------------------------------------------------------------------------
duke@435	1741	// Helper for vtos entry point generation
duke@435	1742
duke@435	1743	void TemplateInterpreterGenerator::set_vtos_entry_points(Template* t,
duke@435	1744	address& bep,
duke@435	1745	address& cep,
duke@435	1746	address& sep,
duke@435	1747	address& aep,
duke@435	1748	address& iep,
duke@435	1749	address& lep,
duke@435	1750	address& fep,
duke@435	1751	address& dep,
duke@435	1752	address& vep) {
duke@435	1753	assert(t->is_valid() && t->tos_in() == vtos, "illegal template");
duke@435	1754	Label L;
duke@435	1755	aep = __ pc(); __ push_ptr(); __ jmp(L);
duke@435	1756	fep = __ pc(); __ push_f(); __ jmp(L);
duke@435	1757	dep = __ pc(); __ push_d(); __ jmp(L);
duke@435	1758	lep = __ pc(); __ push_l(); __ jmp(L);
duke@435	1759	bep = cep = sep =
duke@435	1760	iep = __ pc(); __ push_i();
duke@435	1761	vep = __ pc();
duke@435	1762	__ bind(L);
duke@435	1763	generate_and_dispatch(t);
duke@435	1764	}
duke@435	1765
duke@435	1766
duke@435	1767	//-----------------------------------------------------------------------------
duke@435	1768	// Generation of individual instructions
duke@435	1769
duke@435	1770	// helpers for generate_and_dispatch
duke@435	1771
duke@435	1772
duke@435	1773	InterpreterGenerator::InterpreterGenerator(StubQueue* code)
duke@435	1774	: TemplateInterpreterGenerator(code) {
duke@435	1775	generate_all(); // down here so it can be "virtual"
duke@435	1776	}
duke@435	1777
duke@435	1778	//-----------------------------------------------------------------------------
duke@435	1779
duke@435	1780	// Non-product code
duke@435	1781	#ifndef PRODUCT
duke@435	1782	address TemplateInterpreterGenerator::generate_trace_code(TosState state) {
duke@435	1783	address entry = __ pc();
duke@435	1784
duke@435	1785	__ push(state);
never@739	1786	__ push(c_rarg0);
never@739	1787	__ push(c_rarg1);
never@739	1788	__ push(c_rarg2);
never@739	1789	__ push(c_rarg3);
never@739	1790	__ mov(c_rarg2, rax); // Pass itos
duke@435	1791	#ifdef _WIN64
duke@435	1792	__ movflt(xmm3, xmm0); // Pass ftos
duke@435	1793	#endif
duke@435	1794	__ call_VM(noreg,
duke@435	1795	CAST_FROM_FN_PTR(address, SharedRuntime::trace_bytecode),
duke@435	1796	c_rarg1, c_rarg2, c_rarg3);
never@739	1797	__ pop(c_rarg3);
never@739	1798	__ pop(c_rarg2);
never@739	1799	__ pop(c_rarg1);
never@739	1800	__ pop(c_rarg0);
duke@435	1801	__ pop(state);
duke@435	1802	__ ret(0); // return from result handler
duke@435	1803
duke@435	1804	return entry;
duke@435	1805	}
duke@435	1806
duke@435	1807	void TemplateInterpreterGenerator::count_bytecode() {
duke@435	1808	__ incrementl(ExternalAddress((address) &BytecodeCounter::_counter_value));
duke@435	1809	}
duke@435	1810
duke@435	1811	void TemplateInterpreterGenerator::histogram_bytecode(Template* t) {
duke@435	1812	__ incrementl(ExternalAddress((address) &BytecodeHistogram::_counters[t->bytecode()]));
duke@435	1813	}
duke@435	1814
duke@435	1815	void TemplateInterpreterGenerator::histogram_bytecode_pair(Template* t) {
duke@435	1816	__ mov32(rbx, ExternalAddress((address) &BytecodePairHistogram::_index));
duke@435	1817	__ shrl(rbx, BytecodePairHistogram::log2_number_of_codes);
duke@435	1818	__ orl(rbx,
duke@435	1819	((int) t->bytecode()) <<
duke@435	1820	BytecodePairHistogram::log2_number_of_codes);
duke@435	1821	__ mov32(ExternalAddress((address) &BytecodePairHistogram::_index), rbx);
duke@435	1822	__ lea(rscratch1, ExternalAddress((address) BytecodePairHistogram::_counters));
duke@435	1823	__ incrementl(Address(rscratch1, rbx, Address::times_4));
duke@435	1824	}
duke@435	1825
duke@435	1826
duke@435	1827	void TemplateInterpreterGenerator::trace_bytecode(Template* t) {
duke@435	1828	// Call a little run-time stub to avoid blow-up for each bytecode.
duke@435	1829	// The run-time runtime saves the right registers, depending on
duke@435	1830	// the tosca in-state for the given template.
duke@435	1831
duke@435	1832	assert(Interpreter::trace_code(t->tos_in()) != NULL,
duke@435	1833	"entry must have been generated");
never@739	1834	__ mov(r12, rsp); // remember sp
never@739	1835	__ andptr(rsp, -16); // align stack as required by ABI
duke@435	1836	__ call(RuntimeAddress(Interpreter::trace_code(t->tos_in())));
never@739	1837	__ mov(rsp, r12); // restore sp
coleenp@548	1838	__ reinit_heapbase();
duke@435	1839	}
duke@435	1840
duke@435	1841
duke@435	1842	void TemplateInterpreterGenerator::stop_interpreter_at() {
duke@435	1843	Label L;
duke@435	1844	__ cmp32(ExternalAddress((address) &BytecodeCounter::_counter_value),
duke@435	1845	StopInterpreterAt);
duke@435	1846	__ jcc(Assembler::notEqual, L);
duke@435	1847	__ int3();
duke@435	1848	__ bind(L);
duke@435	1849	}
duke@435	1850	#endif // !PRODUCT
never@739	1851	#endif // ! CC_INTERP