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

src/cpu/x86/vm/templateInterpreter_x86_64.cpp@98cb887364d3 (annotated)

src/cpu/x86/vm/templateInterpreter_x86_64.cpp

Fri, 27 Feb 2009 13:27:09 -0800

author

twisti

date

Fri, 27 Feb 2009 13:27:09 -0800

changeset 1040

98cb887364d3

parent 739

dc7f315e41f7

child 1057

56aae7be60d4

permissions

-rw-r--r--

6810672: Comment typos
Summary: I have collected some typos I have found while looking at the code.
Reviewed-by: kvn, never

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