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

src/cpu/x86/vm/c1_Runtime1_x86.cpp@37f87013dfd8 (annotated)

src/cpu/x86/vm/c1_Runtime1_x86.cpp

Thu, 05 Jun 2008 15:57:56 -0700

author

ysr

date

Thu, 05 Jun 2008 15:57:56 -0700

changeset 777

37f87013dfd8

parent 435

a61af66fc99e

child 797

f8199438385b

permissions

-rw-r--r--

6711316: Open source the Garbage-First garbage collector
Summary: First mercurial integration of the code for the Garbage-First garbage collector.
Reviewed-by: apetrusenko, iveresov, jmasa, sgoldman, tonyp, ysr

duke@435	1	/*
duke@435	2	* Copyright 1999-2007 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/_c1_Runtime1_x86.cpp.incl"
duke@435	27
duke@435	28
duke@435	29	// Implementation of StubAssembler
duke@435	30
duke@435	31	int StubAssembler::call_RT(Register oop_result1, Register oop_result2, address entry, int args_size) {
duke@435	32	// setup registers
duke@435	33	const Register thread = rdi; // is callee-saved register (Visual C++ calling conventions)
duke@435	34	assert(!(oop_result1->is_valid() || oop_result2->is_valid()) || oop_result1 != oop_result2, "registers must be different");
duke@435	35	assert(oop_result1 != thread && oop_result2 != thread, "registers must be different");
duke@435	36	assert(args_size >= 0, "illegal args_size");
duke@435	37
duke@435	38	set_num_rt_args(1 + args_size);
duke@435	39
duke@435	40	// push java thread (becomes first argument of C function)
duke@435	41	get_thread(thread);
duke@435	42	pushl(thread);
duke@435	43
duke@435	44	set_last_Java_frame(thread, noreg, rbp, NULL);
duke@435	45	// do the call
duke@435	46	call(RuntimeAddress(entry));
duke@435	47	int call_offset = offset();
duke@435	48	// verify callee-saved register
duke@435	49	#ifdef ASSERT
duke@435	50	guarantee(thread != rax, "change this code");
duke@435	51	pushl(rax);
duke@435	52	{ Label L;
duke@435	53	get_thread(rax);
duke@435	54	cmpl(thread, rax);
duke@435	55	jcc(Assembler::equal, L);
duke@435	56	int3();
duke@435	57	stop("StubAssembler::call_RT: rdi not callee saved?");
duke@435	58	bind(L);
duke@435	59	}
duke@435	60	popl(rax);
duke@435	61	#endif
duke@435	62	reset_last_Java_frame(thread, true, false);
duke@435	63
duke@435	64	// discard thread and arguments
duke@435	65	addl(rsp, (1 + args_size)*BytesPerWord);
duke@435	66
duke@435	67	// check for pending exceptions
duke@435	68	{ Label L;
duke@435	69	cmpl(Address(thread, Thread::pending_exception_offset()), NULL_WORD);
duke@435	70	jcc(Assembler::equal, L);
duke@435	71	// exception pending => remove activation and forward to exception handler
duke@435	72	movl(rax, Address(thread, Thread::pending_exception_offset()));
duke@435	73	// make sure that the vm_results are cleared
duke@435	74	if (oop_result1->is_valid()) {
duke@435	75	movl(Address(thread, JavaThread::vm_result_offset()), NULL_WORD);
duke@435	76	}
duke@435	77	if (oop_result2->is_valid()) {
duke@435	78	movl(Address(thread, JavaThread::vm_result_2_offset()), NULL_WORD);
duke@435	79	}
duke@435	80	if (frame_size() == no_frame_size) {
duke@435	81	leave();
duke@435	82	jump(RuntimeAddress(StubRoutines::forward_exception_entry()));
duke@435	83	} else if (_stub_id == Runtime1::forward_exception_id) {
duke@435	84	should_not_reach_here();
duke@435	85	} else {
duke@435	86	jump(RuntimeAddress(Runtime1::entry_for(Runtime1::forward_exception_id)));
duke@435	87	}
duke@435	88	bind(L);
duke@435	89	}
duke@435	90	// get oop results if there are any and reset the values in the thread
duke@435	91	if (oop_result1->is_valid()) {
duke@435	92	movl(oop_result1, Address(thread, JavaThread::vm_result_offset()));
duke@435	93	movl(Address(thread, JavaThread::vm_result_offset()), NULL_WORD);
duke@435	94	verify_oop(oop_result1);
duke@435	95	}
duke@435	96	if (oop_result2->is_valid()) {
duke@435	97	movl(oop_result2, Address(thread, JavaThread::vm_result_2_offset()));
duke@435	98	movl(Address(thread, JavaThread::vm_result_2_offset()), NULL_WORD);
duke@435	99	verify_oop(oop_result2);
duke@435	100	}
duke@435	101	return call_offset;
duke@435	102	}
duke@435	103
duke@435	104
duke@435	105	int StubAssembler::call_RT(Register oop_result1, Register oop_result2, address entry, Register arg1) {
duke@435	106	pushl(arg1);
duke@435	107	return call_RT(oop_result1, oop_result2, entry, 1);
duke@435	108	}
duke@435	109
duke@435	110
duke@435	111	int StubAssembler::call_RT(Register oop_result1, Register oop_result2, address entry, Register arg1, Register arg2) {
duke@435	112	pushl(arg2);
duke@435	113	pushl(arg1);
duke@435	114	return call_RT(oop_result1, oop_result2, entry, 2);
duke@435	115	}
duke@435	116
duke@435	117
duke@435	118	int StubAssembler::call_RT(Register oop_result1, Register oop_result2, address entry, Register arg1, Register arg2, Register arg3) {
duke@435	119	pushl(arg3);
duke@435	120	pushl(arg2);
duke@435	121	pushl(arg1);
duke@435	122	return call_RT(oop_result1, oop_result2, entry, 3);
duke@435	123	}
duke@435	124
duke@435	125
duke@435	126	// Implementation of StubFrame
duke@435	127
duke@435	128	class StubFrame: public StackObj {
duke@435	129	private:
duke@435	130	StubAssembler* _sasm;
duke@435	131
duke@435	132	public:
duke@435	133	StubFrame(StubAssembler* sasm, const char* name, bool must_gc_arguments);
duke@435	134	void load_argument(int offset_in_words, Register reg);
duke@435	135
duke@435	136	~StubFrame();
duke@435	137	};
duke@435	138
duke@435	139
duke@435	140	#define __ _sasm->
duke@435	141
duke@435	142	StubFrame::StubFrame(StubAssembler* sasm, const char* name, bool must_gc_arguments) {
duke@435	143	_sasm = sasm;
duke@435	144	__ set_info(name, must_gc_arguments);
duke@435	145	__ enter();
duke@435	146	}
duke@435	147
duke@435	148	// load parameters that were stored with LIR_Assembler::store_parameter
duke@435	149	// Note: offsets for store_parameter and load_argument must match
duke@435	150	void StubFrame::load_argument(int offset_in_words, Register reg) {
duke@435	151	// rbp, + 0: link
duke@435	152	// + 1: return address
duke@435	153	// + 2: argument with offset 0
duke@435	154	// + 3: argument with offset 1
duke@435	155	// + 4: ...
duke@435	156
duke@435	157	__ movl(reg, Address(rbp, (offset_in_words + 2) * BytesPerWord));
duke@435	158	}
duke@435	159
duke@435	160
duke@435	161	StubFrame::~StubFrame() {
duke@435	162	__ leave();
duke@435	163	__ ret(0);
duke@435	164	}
duke@435	165
duke@435	166	#undef __
duke@435	167
duke@435	168
duke@435	169	// Implementation of Runtime1
duke@435	170
duke@435	171	#define __ sasm->
duke@435	172
duke@435	173	const int float_regs_as_doubles_size_in_words = 16;
duke@435	174	const int xmm_regs_as_doubles_size_in_words = 16;
duke@435	175
duke@435	176	// Stack layout for saving/restoring all the registers needed during a runtime
duke@435	177	// call (this includes deoptimization)
duke@435	178	// Note: note that users of this frame may well have arguments to some runtime
duke@435	179	// while these values are on the stack. These positions neglect those arguments
duke@435	180	// but the code in save_live_registers will take the argument count into
duke@435	181	// account.
duke@435	182	//
duke@435	183	enum reg_save_layout {
duke@435	184	dummy1,
duke@435	185	dummy2,
duke@435	186	// Two temps to be used as needed by users of save/restore callee registers
duke@435	187	temp_2_off,
duke@435	188	temp_1_off,
duke@435	189	xmm_regs_as_doubles_off,
duke@435	190	float_regs_as_doubles_off = xmm_regs_as_doubles_off + xmm_regs_as_doubles_size_in_words,
duke@435	191	fpu_state_off = float_regs_as_doubles_off + float_regs_as_doubles_size_in_words,
duke@435	192	fpu_state_end_off = fpu_state_off + FPUStateSizeInWords,
duke@435	193	marker = fpu_state_end_off,
duke@435	194	extra_space_offset,
duke@435	195	rdi_off = extra_space_offset,
duke@435	196	rsi_off,
duke@435	197	rbp_off,
duke@435	198	rsp_off,
duke@435	199	rbx_off,
duke@435	200	rdx_off,
duke@435	201	rcx_off,
duke@435	202	rax_off,
duke@435	203	saved_rbp_off,
duke@435	204	return_off,
duke@435	205	reg_save_frame_size, // As noted: neglects any parameters to runtime
duke@435	206
duke@435	207	// equates
duke@435	208
duke@435	209	// illegal instruction handler
duke@435	210	continue_dest_off = temp_1_off,
duke@435	211
duke@435	212	// deoptimization equates
duke@435	213	fp0_off = float_regs_as_doubles_off, // slot for java float/double return value
duke@435	214	xmm0_off = xmm_regs_as_doubles_off, // slot for java float/double return value
duke@435	215	deopt_type = temp_2_off, // slot for type of deopt in progress
duke@435	216	ret_type = temp_1_off // slot for return type
duke@435	217	};
duke@435	218
duke@435	219
duke@435	220
duke@435	221	// Save off registers which might be killed by calls into the runtime.
duke@435	222	// Tries to smart of about FP registers. In particular we separate
duke@435	223	// saving and describing the FPU registers for deoptimization since we
duke@435	224	// have to save the FPU registers twice if we describe them and on P4
duke@435	225	// saving FPU registers which don't contain anything appears
duke@435	226	// expensive. The deopt blob is the only thing which needs to
duke@435	227	// describe FPU registers. In all other cases it should be sufficient
duke@435	228	// to simply save their current value.
duke@435	229
duke@435	230	static OopMap* generate_oop_map(StubAssembler* sasm, int num_rt_args,
duke@435	231	bool save_fpu_registers = true) {
duke@435	232	int frame_size = reg_save_frame_size + num_rt_args; // args + thread
duke@435	233	sasm->set_frame_size(frame_size);
duke@435	234
duke@435	235	// record saved value locations in an OopMap
duke@435	236	// locations are offsets from sp after runtime call; num_rt_args is number of arguments in call, including thread
duke@435	237	OopMap* map = new OopMap(frame_size, 0);
duke@435	238	map->set_callee_saved(VMRegImpl::stack2reg(rax_off + num_rt_args), rax->as_VMReg());
duke@435	239	map->set_callee_saved(VMRegImpl::stack2reg(rcx_off + num_rt_args), rcx->as_VMReg());
duke@435	240	map->set_callee_saved(VMRegImpl::stack2reg(rdx_off + num_rt_args), rdx->as_VMReg());
duke@435	241	map->set_callee_saved(VMRegImpl::stack2reg(rbx_off + num_rt_args), rbx->as_VMReg());
duke@435	242	map->set_callee_saved(VMRegImpl::stack2reg(rsi_off + num_rt_args), rsi->as_VMReg());
duke@435	243	map->set_callee_saved(VMRegImpl::stack2reg(rdi_off + num_rt_args), rdi->as_VMReg());
duke@435	244
duke@435	245	if (save_fpu_registers) {
duke@435	246	if (UseSSE < 2) {
duke@435	247	int fpu_off = float_regs_as_doubles_off;
duke@435	248	for (int n = 0; n < FrameMap::nof_fpu_regs; n++) {
duke@435	249	VMReg fpu_name_0 = FrameMap::fpu_regname(n);
duke@435	250	map->set_callee_saved(VMRegImpl::stack2reg(fpu_off + num_rt_args), fpu_name_0);
duke@435	251	// %%% This is really a waste but we'll keep things as they were for now
duke@435	252	if (true) {
duke@435	253	map->set_callee_saved(VMRegImpl::stack2reg(fpu_off + 1 + num_rt_args), fpu_name_0->next());
duke@435	254	}
duke@435	255	fpu_off += 2;
duke@435	256	}
duke@435	257	assert(fpu_off == fpu_state_off, "incorrect number of fpu stack slots");
duke@435	258	}
duke@435	259
duke@435	260	if (UseSSE >= 2) {
duke@435	261	int xmm_off = xmm_regs_as_doubles_off;
duke@435	262	for (int n = 0; n < FrameMap::nof_xmm_regs; n++) {
duke@435	263	VMReg xmm_name_0 = as_XMMRegister(n)->as_VMReg();
duke@435	264	map->set_callee_saved(VMRegImpl::stack2reg(xmm_off + num_rt_args), xmm_name_0);
duke@435	265	// %%% This is really a waste but we'll keep things as they were for now
duke@435	266	if (true) {
duke@435	267	map->set_callee_saved(VMRegImpl::stack2reg(xmm_off + 1 + num_rt_args), xmm_name_0->next());
duke@435	268	}
duke@435	269	xmm_off += 2;
duke@435	270	}
duke@435	271	assert(xmm_off == float_regs_as_doubles_off, "incorrect number of xmm registers");
duke@435	272
duke@435	273	} else if (UseSSE == 1) {
duke@435	274	int xmm_off = xmm_regs_as_doubles_off;
duke@435	275	for (int n = 0; n < FrameMap::nof_xmm_regs; n++) {
duke@435	276	VMReg xmm_name_0 = as_XMMRegister(n)->as_VMReg();
duke@435	277	map->set_callee_saved(VMRegImpl::stack2reg(xmm_off + num_rt_args), xmm_name_0);
duke@435	278	xmm_off += 2;
duke@435	279	}
duke@435	280	assert(xmm_off == float_regs_as_doubles_off, "incorrect number of xmm registers");
duke@435	281	}
duke@435	282	}
duke@435	283
duke@435	284	return map;
duke@435	285	}
duke@435	286
duke@435	287	static OopMap* save_live_registers(StubAssembler* sasm, int num_rt_args,
duke@435	288	bool save_fpu_registers = true) {
duke@435	289	__ block_comment("save_live_registers");
duke@435	290
duke@435	291	int frame_size = reg_save_frame_size + num_rt_args; // args + thread
duke@435	292	// frame_size = round_to(frame_size, 4);
duke@435	293	sasm->set_frame_size(frame_size);
duke@435	294
duke@435	295	__ pushad(); // integer registers
duke@435	296
duke@435	297	// assert(float_regs_as_doubles_off % 2 == 0, "misaligned offset");
duke@435	298	// assert(xmm_regs_as_doubles_off % 2 == 0, "misaligned offset");
duke@435	299
duke@435	300	__ subl(rsp, extra_space_offset * wordSize);
duke@435	301
duke@435	302	#ifdef ASSERT
duke@435	303	__ movl(Address(rsp, marker * wordSize), 0xfeedbeef);
duke@435	304	#endif
duke@435	305
duke@435	306	if (save_fpu_registers) {
duke@435	307	if (UseSSE < 2) {
duke@435	308	// save FPU stack
duke@435	309	__ fnsave(Address(rsp, fpu_state_off * wordSize));
duke@435	310	__ fwait();
duke@435	311
duke@435	312	#ifdef ASSERT
duke@435	313	Label ok;
duke@435	314	__ cmpw(Address(rsp, fpu_state_off * wordSize), StubRoutines::fpu_cntrl_wrd_std());
duke@435	315	__ jccb(Assembler::equal, ok);
duke@435	316	__ stop("corrupted control word detected");
duke@435	317	__ bind(ok);
duke@435	318	#endif
duke@435	319
duke@435	320	// Reset the control word to guard against exceptions being unmasked
duke@435	321	// since fstp_d can cause FPU stack underflow exceptions. Write it
duke@435	322	// into the on stack copy and then reload that to make sure that the
duke@435	323	// current and future values are correct.
duke@435	324	__ movw(Address(rsp, fpu_state_off * wordSize), StubRoutines::fpu_cntrl_wrd_std());
duke@435	325	__ frstor(Address(rsp, fpu_state_off * wordSize));
duke@435	326
duke@435	327	// Save the FPU registers in de-opt-able form
duke@435	328	__ fstp_d(Address(rsp, float_regs_as_doubles_off * BytesPerWord + 0));
duke@435	329	__ fstp_d(Address(rsp, float_regs_as_doubles_off * BytesPerWord + 8));
duke@435	330	__ fstp_d(Address(rsp, float_regs_as_doubles_off * BytesPerWord + 16));
duke@435	331	__ fstp_d(Address(rsp, float_regs_as_doubles_off * BytesPerWord + 24));
duke@435	332	__ fstp_d(Address(rsp, float_regs_as_doubles_off * BytesPerWord + 32));
duke@435	333	__ fstp_d(Address(rsp, float_regs_as_doubles_off * BytesPerWord + 40));
duke@435	334	__ fstp_d(Address(rsp, float_regs_as_doubles_off * BytesPerWord + 48));
duke@435	335	__ fstp_d(Address(rsp, float_regs_as_doubles_off * BytesPerWord + 56));
duke@435	336	}
duke@435	337
duke@435	338	if (UseSSE >= 2) {
duke@435	339	// save XMM registers
duke@435	340	// XMM registers can contain float or double values, but this is not known here,
duke@435	341	// so always save them as doubles.
duke@435	342	// note that float values are _not_ converted automatically, so for float values
duke@435	343	// the second word contains only garbage data.
duke@435	344	__ movdbl(Address(rsp, xmm_regs_as_doubles_off * wordSize + 0), xmm0);
duke@435	345	__ movdbl(Address(rsp, xmm_regs_as_doubles_off * wordSize + 8), xmm1);
duke@435	346	__ movdbl(Address(rsp, xmm_regs_as_doubles_off * wordSize + 16), xmm2);
duke@435	347	__ movdbl(Address(rsp, xmm_regs_as_doubles_off * wordSize + 24), xmm3);
duke@435	348	__ movdbl(Address(rsp, xmm_regs_as_doubles_off * wordSize + 32), xmm4);
duke@435	349	__ movdbl(Address(rsp, xmm_regs_as_doubles_off * wordSize + 40), xmm5);
duke@435	350	__ movdbl(Address(rsp, xmm_regs_as_doubles_off * wordSize + 48), xmm6);
duke@435	351	__ movdbl(Address(rsp, xmm_regs_as_doubles_off * wordSize + 56), xmm7);
duke@435	352	} else if (UseSSE == 1) {
duke@435	353	// save XMM registers as float because double not supported without SSE2
duke@435	354	__ movflt(Address(rsp, xmm_regs_as_doubles_off * wordSize + 0), xmm0);
duke@435	355	__ movflt(Address(rsp, xmm_regs_as_doubles_off * wordSize + 8), xmm1);
duke@435	356	__ movflt(Address(rsp, xmm_regs_as_doubles_off * wordSize + 16), xmm2);
duke@435	357	__ movflt(Address(rsp, xmm_regs_as_doubles_off * wordSize + 24), xmm3);
duke@435	358	__ movflt(Address(rsp, xmm_regs_as_doubles_off * wordSize + 32), xmm4);
duke@435	359	__ movflt(Address(rsp, xmm_regs_as_doubles_off * wordSize + 40), xmm5);
duke@435	360	__ movflt(Address(rsp, xmm_regs_as_doubles_off * wordSize + 48), xmm6);
duke@435	361	__ movflt(Address(rsp, xmm_regs_as_doubles_off * wordSize + 56), xmm7);
duke@435	362	}
duke@435	363	}
duke@435	364
duke@435	365	// FPU stack must be empty now
duke@435	366	__ verify_FPU(0, "save_live_registers");
duke@435	367
duke@435	368	return generate_oop_map(sasm, num_rt_args, save_fpu_registers);
duke@435	369	}
duke@435	370
duke@435	371
duke@435	372	static void restore_fpu(StubAssembler* sasm, bool restore_fpu_registers = true) {
duke@435	373	if (restore_fpu_registers) {
duke@435	374	if (UseSSE >= 2) {
duke@435	375	// restore XMM registers
duke@435	376	__ movdbl(xmm0, Address(rsp, xmm_regs_as_doubles_off * wordSize + 0));
duke@435	377	__ movdbl(xmm1, Address(rsp, xmm_regs_as_doubles_off * wordSize + 8));
duke@435	378	__ movdbl(xmm2, Address(rsp, xmm_regs_as_doubles_off * wordSize + 16));
duke@435	379	__ movdbl(xmm3, Address(rsp, xmm_regs_as_doubles_off * wordSize + 24));
duke@435	380	__ movdbl(xmm4, Address(rsp, xmm_regs_as_doubles_off * wordSize + 32));
duke@435	381	__ movdbl(xmm5, Address(rsp, xmm_regs_as_doubles_off * wordSize + 40));
duke@435	382	__ movdbl(xmm6, Address(rsp, xmm_regs_as_doubles_off * wordSize + 48));
duke@435	383	__ movdbl(xmm7, Address(rsp, xmm_regs_as_doubles_off * wordSize + 56));
duke@435	384	} else if (UseSSE == 1) {
duke@435	385	// restore XMM registers
duke@435	386	__ movflt(xmm0, Address(rsp, xmm_regs_as_doubles_off * wordSize + 0));
duke@435	387	__ movflt(xmm1, Address(rsp, xmm_regs_as_doubles_off * wordSize + 8));
duke@435	388	__ movflt(xmm2, Address(rsp, xmm_regs_as_doubles_off * wordSize + 16));
duke@435	389	__ movflt(xmm3, Address(rsp, xmm_regs_as_doubles_off * wordSize + 24));
duke@435	390	__ movflt(xmm4, Address(rsp, xmm_regs_as_doubles_off * wordSize + 32));
duke@435	391	__ movflt(xmm5, Address(rsp, xmm_regs_as_doubles_off * wordSize + 40));
duke@435	392	__ movflt(xmm6, Address(rsp, xmm_regs_as_doubles_off * wordSize + 48));
duke@435	393	__ movflt(xmm7, Address(rsp, xmm_regs_as_doubles_off * wordSize + 56));
duke@435	394	}
duke@435	395
duke@435	396	if (UseSSE < 2) {
duke@435	397	__ frstor(Address(rsp, fpu_state_off * wordSize));
duke@435	398	} else {
duke@435	399	// check that FPU stack is really empty
duke@435	400	__ verify_FPU(0, "restore_live_registers");
duke@435	401	}
duke@435	402
duke@435	403	} else {
duke@435	404	// check that FPU stack is really empty
duke@435	405	__ verify_FPU(0, "restore_live_registers");
duke@435	406	}
duke@435	407
duke@435	408	#ifdef ASSERT
duke@435	409	{
duke@435	410	Label ok;
duke@435	411	__ cmpl(Address(rsp, marker * wordSize), 0xfeedbeef);
duke@435	412	__ jcc(Assembler::equal, ok);
duke@435	413	__ stop("bad offsets in frame");
duke@435	414	__ bind(ok);
duke@435	415	}
duke@435	416	#endif
duke@435	417
duke@435	418	__ addl(rsp, extra_space_offset * wordSize);
duke@435	419	}
duke@435	420
duke@435	421
duke@435	422	static void restore_live_registers(StubAssembler* sasm, bool restore_fpu_registers = true) {
duke@435	423	__ block_comment("restore_live_registers");
duke@435	424
duke@435	425	restore_fpu(sasm, restore_fpu_registers);
duke@435	426	__ popad();
duke@435	427	}
duke@435	428
duke@435	429
duke@435	430	static void restore_live_registers_except_rax(StubAssembler* sasm, bool restore_fpu_registers = true) {
duke@435	431	__ block_comment("restore_live_registers_except_rax");
duke@435	432
duke@435	433	restore_fpu(sasm, restore_fpu_registers);
duke@435	434
duke@435	435	__ popl(rdi);
duke@435	436	__ popl(rsi);
duke@435	437	__ popl(rbp);
duke@435	438	__ popl(rbx); // skip this value
duke@435	439	__ popl(rbx);
duke@435	440	__ popl(rdx);
duke@435	441	__ popl(rcx);
duke@435	442	__ addl(rsp, 4);
duke@435	443	}
duke@435	444
duke@435	445
duke@435	446	void Runtime1::initialize_pd() {
duke@435	447	// nothing to do
duke@435	448	}
duke@435	449
duke@435	450
duke@435	451	// target: the entry point of the method that creates and posts the exception oop
duke@435	452	// has_argument: true if the exception needs an argument (passed on stack because registers must be preserved)
duke@435	453
duke@435	454	OopMapSet* Runtime1::generate_exception_throw(StubAssembler* sasm, address target, bool has_argument) {
duke@435	455	// preserve all registers
duke@435	456	int num_rt_args = has_argument ? 2 : 1;
duke@435	457	OopMap* oop_map = save_live_registers(sasm, num_rt_args);
duke@435	458
duke@435	459	// now all registers are saved and can be used freely
duke@435	460	// verify that no old value is used accidentally
duke@435	461	__ invalidate_registers(true, true, true, true, true, true);
duke@435	462
duke@435	463	// registers used by this stub
duke@435	464	const Register temp_reg = rbx;
duke@435	465
duke@435	466	// load argument for exception that is passed as an argument into the stub
duke@435	467	if (has_argument) {
duke@435	468	__ movl(temp_reg, Address(rbp, 2*BytesPerWord));
duke@435	469	__ pushl(temp_reg);
duke@435	470	}
duke@435	471
duke@435	472	int call_offset = __ call_RT(noreg, noreg, target, num_rt_args - 1);
duke@435	473
duke@435	474	OopMapSet* oop_maps = new OopMapSet();
duke@435	475	oop_maps->add_gc_map(call_offset, oop_map);
duke@435	476
duke@435	477	__ stop("should not reach here");
duke@435	478
duke@435	479	return oop_maps;
duke@435	480	}
duke@435	481
duke@435	482
duke@435	483	void Runtime1::generate_handle_exception(StubAssembler *sasm, OopMapSet* oop_maps, OopMap* oop_map, bool save_fpu_registers) {
duke@435	484	// incoming parameters
duke@435	485	const Register exception_oop = rax;
duke@435	486	const Register exception_pc = rdx;
duke@435	487	// other registers used in this stub
duke@435	488	const Register real_return_addr = rbx;
duke@435	489	const Register thread = rdi;
duke@435	490
duke@435	491	__ block_comment("generate_handle_exception");
duke@435	492
duke@435	493	#ifdef TIERED
duke@435	494	// C2 can leave the fpu stack dirty
duke@435	495	if (UseSSE < 2 ) {
duke@435	496	__ empty_FPU_stack();
duke@435	497	}
duke@435	498	#endif // TIERED
duke@435	499
duke@435	500	// verify that only rax, and rdx is valid at this time
duke@435	501	__ invalidate_registers(false, true, true, false, true, true);
duke@435	502	// verify that rax, contains a valid exception
duke@435	503	__ verify_not_null_oop(exception_oop);
duke@435	504
duke@435	505	// load address of JavaThread object for thread-local data
duke@435	506	__ get_thread(thread);
duke@435	507
duke@435	508	#ifdef ASSERT
duke@435	509	// check that fields in JavaThread for exception oop and issuing pc are
duke@435	510	// empty before writing to them
duke@435	511	Label oop_empty;
duke@435	512	__ cmpl(Address(thread, JavaThread::exception_oop_offset()), 0);
duke@435	513	__ jcc(Assembler::equal, oop_empty);
duke@435	514	__ stop("exception oop already set");
duke@435	515	__ bind(oop_empty);
duke@435	516
duke@435	517	Label pc_empty;
duke@435	518	__ cmpl(Address(thread, JavaThread::exception_pc_offset()), 0);
duke@435	519	__ jcc(Assembler::equal, pc_empty);
duke@435	520	__ stop("exception pc already set");
duke@435	521	__ bind(pc_empty);
duke@435	522	#endif
duke@435	523
duke@435	524	// save exception oop and issuing pc into JavaThread
duke@435	525	// (exception handler will load it from here)
duke@435	526	__ movl(Address(thread, JavaThread::exception_oop_offset()), exception_oop);
duke@435	527	__ movl(Address(thread, JavaThread::exception_pc_offset()), exception_pc);
duke@435	528
duke@435	529	// save real return address (pc that called this stub)
duke@435	530	__ movl(real_return_addr, Address(rbp, 1*BytesPerWord));
duke@435	531	__ movl(Address(rsp, temp_1_off * BytesPerWord), real_return_addr);
duke@435	532
duke@435	533	// patch throwing pc into return address (has bci & oop map)
duke@435	534	__ movl(Address(rbp, 1*BytesPerWord), exception_pc);
duke@435	535
duke@435	536	// compute the exception handler.
duke@435	537	// the exception oop and the throwing pc are read from the fields in JavaThread
duke@435	538	int call_offset = __ call_RT(noreg, noreg, CAST_FROM_FN_PTR(address, exception_handler_for_pc));
duke@435	539	oop_maps->add_gc_map(call_offset, oop_map);
duke@435	540
duke@435	541	// rax,: handler address or NULL if no handler exists
duke@435	542	// will be the deopt blob if nmethod was deoptimized while we looked up
duke@435	543	// handler regardless of whether handler existed in the nmethod.
duke@435	544
duke@435	545	// only rax, is valid at this time, all other registers have been destroyed by the runtime call
duke@435	546	__ invalidate_registers(false, true, true, true, true, true);
duke@435	547
duke@435	548	// Do we have an exception handler in the nmethod?
duke@435	549	Label no_handler;
duke@435	550	Label done;
duke@435	551	__ testl(rax, rax);
duke@435	552	__ jcc(Assembler::zero, no_handler);
duke@435	553
duke@435	554	// exception handler found
duke@435	555	// patch the return address -> the stub will directly return to the exception handler
duke@435	556	__ movl(Address(rbp, 1*BytesPerWord), rax);
duke@435	557
duke@435	558	// restore registers
duke@435	559	restore_live_registers(sasm, save_fpu_registers);
duke@435	560
duke@435	561	// return to exception handler
duke@435	562	__ leave();
duke@435	563	__ ret(0);
duke@435	564
duke@435	565	__ bind(no_handler);
duke@435	566	// no exception handler found in this method, so the exception is
duke@435	567	// forwarded to the caller (using the unwind code of the nmethod)
duke@435	568	// there is no need to restore the registers
duke@435	569
duke@435	570	// restore the real return address that was saved before the RT-call
duke@435	571	__ movl(real_return_addr, Address(rsp, temp_1_off * BytesPerWord));
duke@435	572	__ movl(Address(rbp, 1*BytesPerWord), real_return_addr);
duke@435	573
duke@435	574	// load address of JavaThread object for thread-local data
duke@435	575	__ get_thread(thread);
duke@435	576	// restore exception oop into rax, (convention for unwind code)
duke@435	577	__ movl(exception_oop, Address(thread, JavaThread::exception_oop_offset()));
duke@435	578
duke@435	579	// clear exception fields in JavaThread because they are no longer needed
duke@435	580	// (fields must be cleared because they are processed by GC otherwise)
duke@435	581	__ movl(Address(thread, JavaThread::exception_oop_offset()), NULL_WORD);
duke@435	582	__ movl(Address(thread, JavaThread::exception_pc_offset()), NULL_WORD);
duke@435	583
duke@435	584	// pop the stub frame off
duke@435	585	__ leave();
duke@435	586
duke@435	587	generate_unwind_exception(sasm);
duke@435	588	__ stop("should not reach here");
duke@435	589	}
duke@435	590
duke@435	591
duke@435	592	void Runtime1::generate_unwind_exception(StubAssembler *sasm) {
duke@435	593	// incoming parameters
duke@435	594	const Register exception_oop = rax;
duke@435	595	// other registers used in this stub
duke@435	596	const Register exception_pc = rdx;
duke@435	597	const Register handler_addr = rbx;
duke@435	598	const Register thread = rdi;
duke@435	599
duke@435	600	// verify that only rax, is valid at this time
duke@435	601	__ invalidate_registers(false, true, true, true, true, true);
duke@435	602
duke@435	603	#ifdef ASSERT
duke@435	604	// check that fields in JavaThread for exception oop and issuing pc are empty
duke@435	605	__ get_thread(thread);
duke@435	606	Label oop_empty;
duke@435	607	__ cmpl(Address(thread, JavaThread::exception_oop_offset()), 0);
duke@435	608	__ jcc(Assembler::equal, oop_empty);
duke@435	609	__ stop("exception oop must be empty");
duke@435	610	__ bind(oop_empty);
duke@435	611
duke@435	612	Label pc_empty;
duke@435	613	__ cmpl(Address(thread, JavaThread::exception_pc_offset()), 0);
duke@435	614	__ jcc(Assembler::equal, pc_empty);
duke@435	615	__ stop("exception pc must be empty");
duke@435	616	__ bind(pc_empty);
duke@435	617	#endif
duke@435	618
duke@435	619	// clear the FPU stack in case any FPU results are left behind
duke@435	620	__ empty_FPU_stack();
duke@435	621
duke@435	622	// leave activation of nmethod
duke@435	623	__ leave();
duke@435	624	// store return address (is on top of stack after leave)
duke@435	625	__ movl(exception_pc, Address(rsp, 0));
duke@435	626
duke@435	627	__ verify_oop(exception_oop);
duke@435	628
duke@435	629	// save exception oop from rax, to stack before call
duke@435	630	__ pushl(exception_oop);
duke@435	631
duke@435	632	// search the exception handler address of the caller (using the return address)
duke@435	633	__ call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::exception_handler_for_return_address), exception_pc);
duke@435	634	// rax,: exception handler address of the caller
duke@435	635
duke@435	636	// only rax, is valid at this time, all other registers have been destroyed by the call
duke@435	637	__ invalidate_registers(false, true, true, true, true, true);
duke@435	638
duke@435	639	// move result of call into correct register
duke@435	640	__ movl(handler_addr, rax);
duke@435	641
duke@435	642	// restore exception oop in rax, (required convention of exception handler)
duke@435	643	__ popl(exception_oop);
duke@435	644
duke@435	645	__ verify_oop(exception_oop);
duke@435	646
duke@435	647	// get throwing pc (= return address).
duke@435	648	// rdx has been destroyed by the call, so it must be set again
duke@435	649	// the pop is also necessary to simulate the effect of a ret(0)
duke@435	650	__ popl(exception_pc);
duke@435	651
duke@435	652	// verify that that there is really a valid exception in rax,
duke@435	653	__ verify_not_null_oop(exception_oop);
duke@435	654
duke@435	655	// continue at exception handler (return address removed)
duke@435	656	// note: do *not* remove arguments when unwinding the
duke@435	657	// activation since the caller assumes having
duke@435	658	// all arguments on the stack when entering the
duke@435	659	// runtime to determine the exception handler
duke@435	660	// (GC happens at call site with arguments!)
duke@435	661	// rax,: exception oop
duke@435	662	// rdx: throwing pc
duke@435	663	// rbx,: exception handler
duke@435	664	__ jmp(handler_addr);
duke@435	665	}
duke@435	666
duke@435	667
duke@435	668	OopMapSet* Runtime1::generate_patching(StubAssembler* sasm, address target) {
duke@435	669	// use the maximum number of runtime-arguments here because it is difficult to
duke@435	670	// distinguish each RT-Call.
duke@435	671	// Note: This number affects also the RT-Call in generate_handle_exception because
duke@435	672	// the oop-map is shared for all calls.
duke@435	673	const int num_rt_args = 2; // thread + dummy
duke@435	674
duke@435	675	DeoptimizationBlob* deopt_blob = SharedRuntime::deopt_blob();
duke@435	676	assert(deopt_blob != NULL, "deoptimization blob must have been created");
duke@435	677
duke@435	678	OopMap* oop_map = save_live_registers(sasm, num_rt_args);
duke@435	679
duke@435	680	__ pushl(rax); // push dummy
duke@435	681
duke@435	682	const Register thread = rdi; // is callee-saved register (Visual C++ calling conventions)
duke@435	683	// push java thread (becomes first argument of C function)
duke@435	684	__ get_thread(thread);
duke@435	685	__ pushl(thread);
duke@435	686	__ set_last_Java_frame(thread, noreg, rbp, NULL);
duke@435	687	// do the call
duke@435	688	__ call(RuntimeAddress(target));
duke@435	689	OopMapSet* oop_maps = new OopMapSet();
duke@435	690	oop_maps->add_gc_map(__ offset(), oop_map);
duke@435	691	// verify callee-saved register
duke@435	692	#ifdef ASSERT
duke@435	693	guarantee(thread != rax, "change this code");
duke@435	694	__ pushl(rax);
duke@435	695	{ Label L;
duke@435	696	__ get_thread(rax);
duke@435	697	__ cmpl(thread, rax);
duke@435	698	__ jcc(Assembler::equal, L);
duke@435	699	__ stop("StubAssembler::call_RT: rdi not callee saved?");
duke@435	700	__ bind(L);
duke@435	701	}
duke@435	702	__ popl(rax);
duke@435	703	#endif
duke@435	704	__ reset_last_Java_frame(thread, true, false);
duke@435	705	__ popl(rcx); // discard thread arg
duke@435	706	__ popl(rcx); // discard dummy
duke@435	707
duke@435	708	// check for pending exceptions
duke@435	709	{ Label L;
duke@435	710	__ cmpl(Address(thread, Thread::pending_exception_offset()), NULL_WORD);
duke@435	711	__ jcc(Assembler::equal, L);
duke@435	712	// exception pending => remove activation and forward to exception handler
duke@435	713
duke@435	714	__ testl(rax, rax); // have we deoptimized?
duke@435	715	__ jump_cc(Assembler::equal,
duke@435	716	RuntimeAddress(Runtime1::entry_for(Runtime1::forward_exception_id)));
duke@435	717
duke@435	718	// the deopt blob expects exceptions in the special fields of
duke@435	719	// JavaThread, so copy and clear pending exception.
duke@435	720
duke@435	721	// load and clear pending exception
duke@435	722	__ movl(rax, Address(thread, Thread::pending_exception_offset()));
duke@435	723	__ movl(Address(thread, Thread::pending_exception_offset()), NULL_WORD);
duke@435	724
duke@435	725	// check that there is really a valid exception
duke@435	726	__ verify_not_null_oop(rax);
duke@435	727
duke@435	728	// load throwing pc: this is the return address of the stub
duke@435	729	__ movl(rdx, Address(rsp, return_off * BytesPerWord));
duke@435	730
duke@435	731	#ifdef ASSERT
duke@435	732	// check that fields in JavaThread for exception oop and issuing pc are empty
duke@435	733	Label oop_empty;
duke@435	734	__ cmpoop(Address(thread, JavaThread::exception_oop_offset()), 0);
duke@435	735	__ jcc(Assembler::equal, oop_empty);
duke@435	736	__ stop("exception oop must be empty");
duke@435	737	__ bind(oop_empty);
duke@435	738
duke@435	739	Label pc_empty;
duke@435	740	__ cmpl(Address(thread, JavaThread::exception_pc_offset()), 0);
duke@435	741	__ jcc(Assembler::equal, pc_empty);
duke@435	742	__ stop("exception pc must be empty");
duke@435	743	__ bind(pc_empty);
duke@435	744	#endif
duke@435	745
duke@435	746	// store exception oop and throwing pc to JavaThread
duke@435	747	__ movl(Address(thread, JavaThread::exception_oop_offset()), rax);
duke@435	748	__ movl(Address(thread, JavaThread::exception_pc_offset()), rdx);
duke@435	749
duke@435	750	restore_live_registers(sasm);
duke@435	751
duke@435	752	__ leave();
duke@435	753	__ addl(rsp, 4); // remove return address from stack
duke@435	754
duke@435	755	// Forward the exception directly to deopt blob. We can blow no
duke@435	756	// registers and must leave throwing pc on the stack. A patch may
duke@435	757	// have values live in registers so the entry point with the
duke@435	758	// exception in tls.
duke@435	759	__ jump(RuntimeAddress(deopt_blob->unpack_with_exception_in_tls()));
duke@435	760
duke@435	761	__ bind(L);
duke@435	762	}
duke@435	763
duke@435	764
duke@435	765	// Runtime will return true if the nmethod has been deoptimized during
duke@435	766	// the patching process. In that case we must do a deopt reexecute instead.
duke@435	767
duke@435	768	Label reexecuteEntry, cont;
duke@435	769
duke@435	770	__ testl(rax, rax); // have we deoptimized?
duke@435	771	__ jcc(Assembler::equal, cont); // no
duke@435	772
duke@435	773	// Will reexecute. Proper return address is already on the stack we just restore
duke@435	774	// registers, pop all of our frame but the return address and jump to the deopt blob
duke@435	775	restore_live_registers(sasm);
duke@435	776	__ leave();
duke@435	777	__ jump(RuntimeAddress(deopt_blob->unpack_with_reexecution()));
duke@435	778
duke@435	779	__ bind(cont);
duke@435	780	restore_live_registers(sasm);
duke@435	781	__ leave();
duke@435	782	__ ret(0);
duke@435	783
duke@435	784	return oop_maps;
duke@435	785
duke@435	786	}
duke@435	787
duke@435	788
duke@435	789	OopMapSet* Runtime1::generate_code_for(StubID id, StubAssembler* sasm) {
duke@435	790
duke@435	791	// for better readability
duke@435	792	const bool must_gc_arguments = true;
duke@435	793	const bool dont_gc_arguments = false;
duke@435	794
duke@435	795	// default value; overwritten for some optimized stubs that are called from methods that do not use the fpu
duke@435	796	bool save_fpu_registers = true;
duke@435	797
duke@435	798	// stub code & info for the different stubs
duke@435	799	OopMapSet* oop_maps = NULL;
duke@435	800	switch (id) {
duke@435	801	case forward_exception_id:
duke@435	802	{
duke@435	803	// we're handling an exception in the context of a compiled
duke@435	804	// frame. The registers have been saved in the standard
duke@435	805	// places. Perform an exception lookup in the caller and
duke@435	806	// dispatch to the handler if found. Otherwise unwind and
duke@435	807	// dispatch to the callers exception handler.
duke@435	808
duke@435	809	const Register thread = rdi;
duke@435	810	const Register exception_oop = rax;
duke@435	811	const Register exception_pc = rdx;
duke@435	812
duke@435	813	// load pending exception oop into rax,
duke@435	814	__ movl(exception_oop, Address(thread, Thread::pending_exception_offset()));
duke@435	815	// clear pending exception
duke@435	816	__ movl(Address(thread, Thread::pending_exception_offset()), NULL_WORD);
duke@435	817
duke@435	818	// load issuing PC (the return address for this stub) into rdx
duke@435	819	__ movl(exception_pc, Address(rbp, 1*BytesPerWord));
duke@435	820
duke@435	821	// make sure that the vm_results are cleared (may be unnecessary)
duke@435	822	__ movl(Address(thread, JavaThread::vm_result_offset()), NULL_WORD);
duke@435	823	__ movl(Address(thread, JavaThread::vm_result_2_offset()), NULL_WORD);
duke@435	824
duke@435	825	// verify that that there is really a valid exception in rax,
duke@435	826	__ verify_not_null_oop(exception_oop);
duke@435	827
duke@435	828
duke@435	829	oop_maps = new OopMapSet();
duke@435	830	OopMap* oop_map = generate_oop_map(sasm, 1);
duke@435	831	generate_handle_exception(sasm, oop_maps, oop_map);
duke@435	832	__ stop("should not reach here");
duke@435	833	}
duke@435	834	break;
duke@435	835
duke@435	836	case new_instance_id:
duke@435	837	case fast_new_instance_id:
duke@435	838	case fast_new_instance_init_check_id:
duke@435	839	{
duke@435	840	Register klass = rdx; // Incoming
duke@435	841	Register obj = rax; // Result
duke@435	842
duke@435	843	if (id == new_instance_id) {
duke@435	844	__ set_info("new_instance", dont_gc_arguments);
duke@435	845	} else if (id == fast_new_instance_id) {
duke@435	846	__ set_info("fast new_instance", dont_gc_arguments);
duke@435	847	} else {
duke@435	848	assert(id == fast_new_instance_init_check_id, "bad StubID");
duke@435	849	__ set_info("fast new_instance init check", dont_gc_arguments);
duke@435	850	}
duke@435	851
duke@435	852	if ((id == fast_new_instance_id || id == fast_new_instance_init_check_id) &&
duke@435	853	UseTLAB && FastTLABRefill) {
duke@435	854	Label slow_path;
duke@435	855	Register obj_size = rcx;
duke@435	856	Register t1 = rbx;
duke@435	857	Register t2 = rsi;
duke@435	858	assert_different_registers(klass, obj, obj_size, t1, t2);
duke@435	859
duke@435	860	__ pushl(rdi);
duke@435	861	__ pushl(rbx);
duke@435	862
duke@435	863	if (id == fast_new_instance_init_check_id) {
duke@435	864	// make sure the klass is initialized
duke@435	865	__ cmpl(Address(klass, instanceKlass::init_state_offset_in_bytes() + sizeof(oopDesc)), instanceKlass::fully_initialized);
duke@435	866	__ jcc(Assembler::notEqual, slow_path);
duke@435	867	}
duke@435	868
duke@435	869	#ifdef ASSERT
duke@435	870	// assert object can be fast path allocated
duke@435	871	{
duke@435	872	Label ok, not_ok;
duke@435	873	__ movl(obj_size, Address(klass, Klass::layout_helper_offset_in_bytes() + sizeof(oopDesc)));
duke@435	874	__ cmpl(obj_size, 0); // make sure it's an instance (LH > 0)
duke@435	875	__ jcc(Assembler::lessEqual, not_ok);
duke@435	876	__ testl(obj_size, Klass::_lh_instance_slow_path_bit);
duke@435	877	__ jcc(Assembler::zero, ok);
duke@435	878	__ bind(not_ok);
duke@435	879	__ stop("assert(can be fast path allocated)");
duke@435	880	__ should_not_reach_here();
duke@435	881	__ bind(ok);
duke@435	882	}
duke@435	883	#endif // ASSERT
duke@435	884
duke@435	885	// if we got here then the TLAB allocation failed, so try
duke@435	886	// refilling the TLAB or allocating directly from eden.
duke@435	887	Label retry_tlab, try_eden;
duke@435	888	__ tlab_refill(retry_tlab, try_eden, slow_path); // does not destroy rdx (klass)
duke@435	889
duke@435	890	__ bind(retry_tlab);
duke@435	891
duke@435	892	// get the instance size
duke@435	893	__ movl(obj_size, Address(klass, klassOopDesc::header_size() * HeapWordSize + Klass::layout_helper_offset_in_bytes()));
duke@435	894	__ tlab_allocate(obj, obj_size, 0, t1, t2, slow_path);
duke@435	895	__ initialize_object(obj, klass, obj_size, 0, t1, t2);
duke@435	896	__ verify_oop(obj);
duke@435	897	__ popl(rbx);
duke@435	898	__ popl(rdi);
duke@435	899	__ ret(0);
duke@435	900
duke@435	901	__ bind(try_eden);
duke@435	902	// get the instance size
duke@435	903	__ movl(obj_size, Address(klass, klassOopDesc::header_size() * HeapWordSize + Klass::layout_helper_offset_in_bytes()));
duke@435	904	__ eden_allocate(obj, obj_size, 0, t1, slow_path);
duke@435	905	__ initialize_object(obj, klass, obj_size, 0, t1, t2);
duke@435	906	__ verify_oop(obj);
duke@435	907	__ popl(rbx);
duke@435	908	__ popl(rdi);
duke@435	909	__ ret(0);
duke@435	910
duke@435	911	__ bind(slow_path);
duke@435	912	__ popl(rbx);
duke@435	913	__ popl(rdi);
duke@435	914	}
duke@435	915
duke@435	916	__ enter();
duke@435	917	OopMap* map = save_live_registers(sasm, 2);
duke@435	918	int call_offset = __ call_RT(obj, noreg, CAST_FROM_FN_PTR(address, new_instance), klass);
duke@435	919	oop_maps = new OopMapSet();
duke@435	920	oop_maps->add_gc_map(call_offset, map);
duke@435	921	restore_live_registers_except_rax(sasm);
duke@435	922	__ verify_oop(obj);
duke@435	923	__ leave();
duke@435	924	__ ret(0);
duke@435	925
duke@435	926	// rax,: new instance
duke@435	927	}
duke@435	928
duke@435	929	break;
duke@435	930
duke@435	931	#ifdef TIERED
duke@435	932	case counter_overflow_id:
duke@435	933	{
duke@435	934	Register bci = rax;
duke@435	935	__ enter();
duke@435	936	OopMap* map = save_live_registers(sasm, 2);
duke@435	937	// Retrieve bci
duke@435	938	__ movl(bci, Address(rbp, 2*BytesPerWord));
duke@435	939	int call_offset = __ call_RT(noreg, noreg, CAST_FROM_FN_PTR(address, counter_overflow), bci);
duke@435	940	oop_maps = new OopMapSet();
duke@435	941	oop_maps->add_gc_map(call_offset, map);
duke@435	942	restore_live_registers(sasm);
duke@435	943	__ leave();
duke@435	944	__ ret(0);
duke@435	945	}
duke@435	946	break;
duke@435	947	#endif // TIERED
duke@435	948
duke@435	949	case new_type_array_id:
duke@435	950	case new_object_array_id:
duke@435	951	{
duke@435	952	Register length = rbx; // Incoming
duke@435	953	Register klass = rdx; // Incoming
duke@435	954	Register obj = rax; // Result
duke@435	955
duke@435	956	if (id == new_type_array_id) {
duke@435	957	__ set_info("new_type_array", dont_gc_arguments);
duke@435	958	} else {
duke@435	959	__ set_info("new_object_array", dont_gc_arguments);
duke@435	960	}
duke@435	961
duke@435	962	#ifdef ASSERT
duke@435	963	// assert object type is really an array of the proper kind
duke@435	964	{
duke@435	965	Label ok;
duke@435	966	Register t0 = obj;
duke@435	967	__ movl(t0, Address(klass, Klass::layout_helper_offset_in_bytes() + sizeof(oopDesc)));
duke@435	968	__ sarl(t0, Klass::_lh_array_tag_shift);
duke@435	969	int tag = ((id == new_type_array_id)
duke@435	970	? Klass::_lh_array_tag_type_value
duke@435	971	: Klass::_lh_array_tag_obj_value);
duke@435	972	__ cmpl(t0, tag);
duke@435	973	__ jcc(Assembler::equal, ok);
duke@435	974	__ stop("assert(is an array klass)");
duke@435	975	__ should_not_reach_here();
duke@435	976	__ bind(ok);
duke@435	977	}
duke@435	978	#endif // ASSERT
duke@435	979
duke@435	980	if (UseTLAB && FastTLABRefill) {
duke@435	981	Register arr_size = rsi;
duke@435	982	Register t1 = rcx; // must be rcx for use as shift count
duke@435	983	Register t2 = rdi;
duke@435	984	Label slow_path;
duke@435	985	assert_different_registers(length, klass, obj, arr_size, t1, t2);
duke@435	986
duke@435	987	// check that array length is small enough for fast path.
duke@435	988	__ cmpl(length, C1_MacroAssembler::max_array_allocation_length);
duke@435	989	__ jcc(Assembler::above, slow_path);
duke@435	990
duke@435	991	// if we got here then the TLAB allocation failed, so try
duke@435	992	// refilling the TLAB or allocating directly from eden.
duke@435	993	Label retry_tlab, try_eden;
duke@435	994	__ tlab_refill(retry_tlab, try_eden, slow_path); // preserves rbx, & rdx
duke@435	995
duke@435	996	__ bind(retry_tlab);
duke@435	997
duke@435	998	// get the allocation size: round_up(hdr + length << (layout_helper & 0x1F))
duke@435	999	__ movl(t1, Address(klass, klassOopDesc::header_size() * HeapWordSize + Klass::layout_helper_offset_in_bytes()));
duke@435	1000	__ movl(arr_size, length);
duke@435	1001	assert(t1 == rcx, "fixed register usage");
duke@435	1002	__ shll(arr_size /* by t1=rcx, mod 32 */);
duke@435	1003	__ shrl(t1, Klass::_lh_header_size_shift);
duke@435	1004	__ andl(t1, Klass::_lh_header_size_mask);
duke@435	1005	__ addl(arr_size, t1);
duke@435	1006	__ addl(arr_size, MinObjAlignmentInBytesMask); // align up
duke@435	1007	__ andl(arr_size, ~MinObjAlignmentInBytesMask);
duke@435	1008
duke@435	1009	__ tlab_allocate(obj, arr_size, 0, t1, t2, slow_path); // preserves arr_size
duke@435	1010
duke@435	1011	__ initialize_header(obj, klass, length, t1, t2);
duke@435	1012	__ movb(t1, Address(klass, klassOopDesc::header_size() * HeapWordSize + Klass::layout_helper_offset_in_bytes() + (Klass::_lh_header_size_shift / BitsPerByte)));
duke@435	1013	assert(Klass::_lh_header_size_shift % BitsPerByte == 0, "bytewise");
duke@435	1014	assert(Klass::_lh_header_size_mask <= 0xFF, "bytewise");
duke@435	1015	__ andl(t1, Klass::_lh_header_size_mask);
duke@435	1016	__ subl(arr_size, t1); // body length
duke@435	1017	__ addl(t1, obj); // body start
duke@435	1018	__ initialize_body(t1, arr_size, 0, t2);
duke@435	1019	__ verify_oop(obj);
duke@435	1020	__ ret(0);
duke@435	1021
duke@435	1022	__ bind(try_eden);
duke@435	1023	// get the allocation size: round_up(hdr + length << (layout_helper & 0x1F))
duke@435	1024	__ movl(t1, Address(klass, klassOopDesc::header_size() * HeapWordSize + Klass::layout_helper_offset_in_bytes()));
duke@435	1025	__ movl(arr_size, length);
duke@435	1026	assert(t1 == rcx, "fixed register usage");
duke@435	1027	__ shll(arr_size /* by t1=rcx, mod 32 */);
duke@435	1028	__ shrl(t1, Klass::_lh_header_size_shift);
duke@435	1029	__ andl(t1, Klass::_lh_header_size_mask);
duke@435	1030	__ addl(arr_size, t1);
duke@435	1031	__ addl(arr_size, MinObjAlignmentInBytesMask); // align up
duke@435	1032	__ andl(arr_size, ~MinObjAlignmentInBytesMask);
duke@435	1033
duke@435	1034	__ eden_allocate(obj, arr_size, 0, t1, slow_path); // preserves arr_size
duke@435	1035
duke@435	1036	__ initialize_header(obj, klass, length, t1, t2);
duke@435	1037	__ movb(t1, Address(klass, klassOopDesc::header_size() * HeapWordSize + Klass::layout_helper_offset_in_bytes() + (Klass::_lh_header_size_shift / BitsPerByte)));
duke@435	1038	assert(Klass::_lh_header_size_shift % BitsPerByte == 0, "bytewise");
duke@435	1039	assert(Klass::_lh_header_size_mask <= 0xFF, "bytewise");
duke@435	1040	__ andl(t1, Klass::_lh_header_size_mask);
duke@435	1041	__ subl(arr_size, t1); // body length
duke@435	1042	__ addl(t1, obj); // body start
duke@435	1043	__ initialize_body(t1, arr_size, 0, t2);
duke@435	1044	__ verify_oop(obj);
duke@435	1045	__ ret(0);
duke@435	1046
duke@435	1047	__ bind(slow_path);
duke@435	1048	}
duke@435	1049
duke@435	1050	__ enter();
duke@435	1051	OopMap* map = save_live_registers(sasm, 3);
duke@435	1052	int call_offset;
duke@435	1053	if (id == new_type_array_id) {
duke@435	1054	call_offset = __ call_RT(obj, noreg, CAST_FROM_FN_PTR(address, new_type_array), klass, length);
duke@435	1055	} else {
duke@435	1056	call_offset = __ call_RT(obj, noreg, CAST_FROM_FN_PTR(address, new_object_array), klass, length);
duke@435	1057	}
duke@435	1058
duke@435	1059	oop_maps = new OopMapSet();
duke@435	1060	oop_maps->add_gc_map(call_offset, map);
duke@435	1061	restore_live_registers_except_rax(sasm);
duke@435	1062
duke@435	1063	__ verify_oop(obj);
duke@435	1064	__ leave();
duke@435	1065	__ ret(0);
duke@435	1066
duke@435	1067	// rax,: new array
duke@435	1068	}
duke@435	1069	break;
duke@435	1070
duke@435	1071	case new_multi_array_id:
duke@435	1072	{ StubFrame f(sasm, "new_multi_array", dont_gc_arguments);
duke@435	1073	// rax,: klass
duke@435	1074	// rbx,: rank
duke@435	1075	// rcx: address of 1st dimension
duke@435	1076	OopMap* map = save_live_registers(sasm, 4);
duke@435	1077	int call_offset = __ call_RT(rax, noreg, CAST_FROM_FN_PTR(address, new_multi_array), rax, rbx, rcx);
duke@435	1078
duke@435	1079	oop_maps = new OopMapSet();
duke@435	1080	oop_maps->add_gc_map(call_offset, map);
duke@435	1081	restore_live_registers_except_rax(sasm);
duke@435	1082
duke@435	1083	// rax,: new multi array
duke@435	1084	__ verify_oop(rax);
duke@435	1085	}
duke@435	1086	break;
duke@435	1087
duke@435	1088	case register_finalizer_id:
duke@435	1089	{
duke@435	1090	__ set_info("register_finalizer", dont_gc_arguments);
duke@435	1091
duke@435	1092	// The object is passed on the stack and we haven't pushed a
duke@435	1093	// frame yet so it's one work away from top of stack.
duke@435	1094	__ movl(rax, Address(rsp, 1 * BytesPerWord));
duke@435	1095	__ verify_oop(rax);
duke@435	1096
duke@435	1097	// load the klass and check the has finalizer flag
duke@435	1098	Label register_finalizer;
duke@435	1099	Register t = rsi;
duke@435	1100	__ movl(t, Address(rax, oopDesc::klass_offset_in_bytes()));
duke@435	1101	__ movl(t, Address(t, Klass::access_flags_offset_in_bytes() + sizeof(oopDesc)));
duke@435	1102	__ testl(t, JVM_ACC_HAS_FINALIZER);
duke@435	1103	__ jcc(Assembler::notZero, register_finalizer);
duke@435	1104	__ ret(0);
duke@435	1105
duke@435	1106	__ bind(register_finalizer);
duke@435	1107	__ enter();
duke@435	1108	OopMap* oop_map = save_live_registers(sasm, 2 /*num_rt_args */);
duke@435	1109	int call_offset = __ call_RT(noreg, noreg,
duke@435	1110	CAST_FROM_FN_PTR(address, SharedRuntime::register_finalizer), rax);
duke@435	1111	oop_maps = new OopMapSet();
duke@435	1112	oop_maps->add_gc_map(call_offset, oop_map);
duke@435	1113
duke@435	1114	// Now restore all the live registers
duke@435	1115	restore_live_registers(sasm);
duke@435	1116
duke@435	1117	__ leave();
duke@435	1118	__ ret(0);
duke@435	1119	}
duke@435	1120	break;
duke@435	1121
duke@435	1122	case throw_range_check_failed_id:
duke@435	1123	{ StubFrame f(sasm, "range_check_failed", dont_gc_arguments);
duke@435	1124	oop_maps = generate_exception_throw(sasm, CAST_FROM_FN_PTR(address, throw_range_check_exception), true);
duke@435	1125	}
duke@435	1126	break;
duke@435	1127
duke@435	1128	case throw_index_exception_id:
duke@435	1129	{ StubFrame f(sasm, "index_range_check_failed", dont_gc_arguments);
duke@435	1130	oop_maps = generate_exception_throw(sasm, CAST_FROM_FN_PTR(address, throw_index_exception), true);
duke@435	1131	}
duke@435	1132	break;
duke@435	1133
duke@435	1134	case throw_div0_exception_id:
duke@435	1135	{ StubFrame f(sasm, "throw_div0_exception", dont_gc_arguments);
duke@435	1136	oop_maps = generate_exception_throw(sasm, CAST_FROM_FN_PTR(address, throw_div0_exception), false);
duke@435	1137	}
duke@435	1138	break;
duke@435	1139
duke@435	1140	case throw_null_pointer_exception_id:
duke@435	1141	{ StubFrame f(sasm, "throw_null_pointer_exception", dont_gc_arguments);
duke@435	1142	oop_maps = generate_exception_throw(sasm, CAST_FROM_FN_PTR(address, throw_null_pointer_exception), false);
duke@435	1143	}
duke@435	1144	break;
duke@435	1145
duke@435	1146	case handle_exception_nofpu_id:
duke@435	1147	save_fpu_registers = false;
duke@435	1148	// fall through
duke@435	1149	case handle_exception_id:
duke@435	1150	{ StubFrame f(sasm, "handle_exception", dont_gc_arguments);
duke@435	1151	oop_maps = new OopMapSet();
duke@435	1152	OopMap* oop_map = save_live_registers(sasm, 1, save_fpu_registers);
duke@435	1153	generate_handle_exception(sasm, oop_maps, oop_map, save_fpu_registers);
duke@435	1154	}
duke@435	1155	break;
duke@435	1156
duke@435	1157	case unwind_exception_id:
duke@435	1158	{ __ set_info("unwind_exception", dont_gc_arguments);
duke@435	1159	// note: no stubframe since we are about to leave the current
duke@435	1160	// activation and we are calling a leaf VM function only.
duke@435	1161	generate_unwind_exception(sasm);
duke@435	1162	}
duke@435	1163	break;
duke@435	1164
duke@435	1165	case throw_array_store_exception_id:
duke@435	1166	{ StubFrame f(sasm, "throw_array_store_exception", dont_gc_arguments);
duke@435	1167	// tos + 0: link
duke@435	1168	// + 1: return address
duke@435	1169	oop_maps = generate_exception_throw(sasm, CAST_FROM_FN_PTR(address, throw_array_store_exception), false);
duke@435	1170	}
duke@435	1171	break;
duke@435	1172
duke@435	1173	case throw_class_cast_exception_id:
duke@435	1174	{ StubFrame f(sasm, "throw_class_cast_exception", dont_gc_arguments);
duke@435	1175	oop_maps = generate_exception_throw(sasm, CAST_FROM_FN_PTR(address, throw_class_cast_exception), true);
duke@435	1176	}
duke@435	1177	break;
duke@435	1178
duke@435	1179	case throw_incompatible_class_change_error_id:
duke@435	1180	{ StubFrame f(sasm, "throw_incompatible_class_cast_exception", dont_gc_arguments);
duke@435	1181	oop_maps = generate_exception_throw(sasm, CAST_FROM_FN_PTR(address, throw_incompatible_class_change_error), false);
duke@435	1182	}
duke@435	1183	break;
duke@435	1184
duke@435	1185	case slow_subtype_check_id:
duke@435	1186	{
duke@435	1187	enum layout {
duke@435	1188	rax_off,
duke@435	1189	rcx_off,
duke@435	1190	rsi_off,
duke@435	1191	rdi_off,
duke@435	1192	saved_rbp_off,
duke@435	1193	return_off,
duke@435	1194	sub_off,
duke@435	1195	super_off,
duke@435	1196	framesize
duke@435	1197	};
duke@435	1198
duke@435	1199	__ set_info("slow_subtype_check", dont_gc_arguments);
duke@435	1200	__ pushl(rdi);
duke@435	1201	__ pushl(rsi);
duke@435	1202	__ pushl(rcx);
duke@435	1203	__ pushl(rax);
duke@435	1204	__ movl(rsi, Address(rsp, (super_off - 1) * BytesPerWord)); // super
duke@435	1205	__ movl(rax, Address(rsp, (sub_off - 1) * BytesPerWord)); // sub
duke@435	1206
duke@435	1207	__ movl(rdi,Address(rsi,sizeof(oopDesc) + Klass::secondary_supers_offset_in_bytes()));
duke@435	1208	__ movl(rcx,Address(rdi,arrayOopDesc::length_offset_in_bytes()));
duke@435	1209	__ addl(rdi,arrayOopDesc::base_offset_in_bytes(T_OBJECT));
duke@435	1210
duke@435	1211	Label miss;
duke@435	1212	__ repne_scan();
duke@435	1213	__ jcc(Assembler::notEqual, miss);
duke@435	1214	__ movl(Address(rsi,sizeof(oopDesc) + Klass::secondary_super_cache_offset_in_bytes()), rax);
duke@435	1215	__ movl(Address(rsp, (super_off - 1) * BytesPerWord), 1); // result
duke@435	1216	__ popl(rax);
duke@435	1217	__ popl(rcx);
duke@435	1218	__ popl(rsi);
duke@435	1219	__ popl(rdi);
duke@435	1220	__ ret(0);
duke@435	1221
duke@435	1222	__ bind(miss);
duke@435	1223	__ movl(Address(rsp, (super_off - 1) * BytesPerWord), 0); // result
duke@435	1224	__ popl(rax);
duke@435	1225	__ popl(rcx);
duke@435	1226	__ popl(rsi);
duke@435	1227	__ popl(rdi);
duke@435	1228	__ ret(0);
duke@435	1229	}
duke@435	1230	break;
duke@435	1231
duke@435	1232	case monitorenter_nofpu_id:
duke@435	1233	save_fpu_registers = false;
duke@435	1234	// fall through
duke@435	1235	case monitorenter_id:
duke@435	1236	{
duke@435	1237	StubFrame f(sasm, "monitorenter", dont_gc_arguments);
duke@435	1238	OopMap* map = save_live_registers(sasm, 3, save_fpu_registers);
duke@435	1239
duke@435	1240	f.load_argument(1, rax); // rax,: object
duke@435	1241	f.load_argument(0, rbx); // rbx,: lock address
duke@435	1242
duke@435	1243	int call_offset = __ call_RT(noreg, noreg, CAST_FROM_FN_PTR(address, monitorenter), rax, rbx);
duke@435	1244
duke@435	1245	oop_maps = new OopMapSet();
duke@435	1246	oop_maps->add_gc_map(call_offset, map);
duke@435	1247	restore_live_registers(sasm, save_fpu_registers);
duke@435	1248	}
duke@435	1249	break;
duke@435	1250
duke@435	1251	case monitorexit_nofpu_id:
duke@435	1252	save_fpu_registers = false;
duke@435	1253	// fall through
duke@435	1254	case monitorexit_id:
duke@435	1255	{
duke@435	1256	StubFrame f(sasm, "monitorexit", dont_gc_arguments);
duke@435	1257	OopMap* map = save_live_registers(sasm, 2, save_fpu_registers);
duke@435	1258
duke@435	1259	f.load_argument(0, rax); // rax,: lock address
duke@435	1260
duke@435	1261	// note: really a leaf routine but must setup last java sp
duke@435	1262	// => use call_RT for now (speed can be improved by
duke@435	1263	// doing last java sp setup manually)
duke@435	1264	int call_offset = __ call_RT(noreg, noreg, CAST_FROM_FN_PTR(address, monitorexit), rax);
duke@435	1265
duke@435	1266	oop_maps = new OopMapSet();
duke@435	1267	oop_maps->add_gc_map(call_offset, map);
duke@435	1268	restore_live_registers(sasm, save_fpu_registers);
duke@435	1269
duke@435	1270	}
duke@435	1271	break;
duke@435	1272
duke@435	1273	case access_field_patching_id:
duke@435	1274	{ StubFrame f(sasm, "access_field_patching", dont_gc_arguments);
duke@435	1275	// we should set up register map
duke@435	1276	oop_maps = generate_patching(sasm, CAST_FROM_FN_PTR(address, access_field_patching));
duke@435	1277	}
duke@435	1278	break;
duke@435	1279
duke@435	1280	case load_klass_patching_id:
duke@435	1281	{ StubFrame f(sasm, "load_klass_patching", dont_gc_arguments);
duke@435	1282	// we should set up register map
duke@435	1283	oop_maps = generate_patching(sasm, CAST_FROM_FN_PTR(address, move_klass_patching));
duke@435	1284	}
duke@435	1285	break;
duke@435	1286
duke@435	1287	case jvmti_exception_throw_id:
duke@435	1288	{ // rax,: exception oop
duke@435	1289	StubFrame f(sasm, "jvmti_exception_throw", dont_gc_arguments);
duke@435	1290	// Preserve all registers across this potentially blocking call
duke@435	1291	const int num_rt_args = 2; // thread, exception oop
duke@435	1292	OopMap* map = save_live_registers(sasm, num_rt_args);
duke@435	1293	int call_offset = __ call_RT(noreg, noreg, CAST_FROM_FN_PTR(address, Runtime1::post_jvmti_exception_throw), rax);
duke@435	1294	oop_maps = new OopMapSet();
duke@435	1295	oop_maps->add_gc_map(call_offset, map);
duke@435	1296	restore_live_registers(sasm);
duke@435	1297	}
duke@435	1298	break;
duke@435	1299
duke@435	1300	case dtrace_object_alloc_id:
duke@435	1301	{ // rax,: object
duke@435	1302	StubFrame f(sasm, "dtrace_object_alloc", dont_gc_arguments);
duke@435	1303	// we can't gc here so skip the oopmap but make sure that all
duke@435	1304	// the live registers get saved.
duke@435	1305	save_live_registers(sasm, 1);
duke@435	1306
duke@435	1307	__ pushl(rax);
duke@435	1308	__ call(RuntimeAddress(CAST_FROM_FN_PTR(address, SharedRuntime::dtrace_object_alloc)));
duke@435	1309	__ popl(rax);
duke@435	1310
duke@435	1311	restore_live_registers(sasm);
duke@435	1312	}
duke@435	1313	break;
duke@435	1314
duke@435	1315	case fpu2long_stub_id:
duke@435	1316	{
duke@435	1317	// rax, and rdx are destroyed, but should be free since the result is returned there
duke@435	1318	// preserve rsi,ecx
duke@435	1319	__ pushl(rsi);
duke@435	1320	__ pushl(rcx);
duke@435	1321
duke@435	1322	// check for NaN
duke@435	1323	Label return0, do_return, return_min_jlong, do_convert;
duke@435	1324
duke@435	1325	Address value_high_word(rsp, 8);
duke@435	1326	Address value_low_word(rsp, 4);
duke@435	1327	Address result_high_word(rsp, 16);
duke@435	1328	Address result_low_word(rsp, 12);
duke@435	1329
duke@435	1330	__ subl(rsp, 20);
duke@435	1331	__ fst_d(value_low_word);
duke@435	1332	__ movl(rax, value_high_word);
duke@435	1333	__ andl(rax, 0x7ff00000);
duke@435	1334	__ cmpl(rax, 0x7ff00000);
duke@435	1335	__ jcc(Assembler::notEqual, do_convert);
duke@435	1336	__ movl(rax, value_high_word);
duke@435	1337	__ andl(rax, 0xfffff);
duke@435	1338	__ orl(rax, value_low_word);
duke@435	1339	__ jcc(Assembler::notZero, return0);
duke@435	1340
duke@435	1341	__ bind(do_convert);
duke@435	1342	__ fnstcw(Address(rsp, 0));
duke@435	1343	__ movzxw(rax, Address(rsp, 0));
duke@435	1344	__ orl(rax, 0xc00);
duke@435	1345	__ movw(Address(rsp, 2), rax);
duke@435	1346	__ fldcw(Address(rsp, 2));
duke@435	1347	__ fwait();
duke@435	1348	__ fistp_d(result_low_word);
duke@435	1349	__ fldcw(Address(rsp, 0));
duke@435	1350	__ fwait();
duke@435	1351	__ movl(rax, result_low_word);
duke@435	1352	__ movl(rdx, result_high_word);
duke@435	1353	__ movl(rcx, rax);
duke@435	1354	// What the heck is the point of the next instruction???
duke@435	1355	__ xorl(rcx, 0x0);
duke@435	1356	__ movl(rsi, 0x80000000);
duke@435	1357	__ xorl(rsi, rdx);
duke@435	1358	__ orl(rcx, rsi);
duke@435	1359	__ jcc(Assembler::notEqual, do_return);
duke@435	1360	__ fldz();
duke@435	1361	__ fcomp_d(value_low_word);
duke@435	1362	__ fnstsw_ax();
duke@435	1363	__ sahf();
duke@435	1364	__ jcc(Assembler::above, return_min_jlong);
duke@435	1365	// return max_jlong
duke@435	1366	__ movl(rdx, 0x7fffffff);
duke@435	1367	__ movl(rax, 0xffffffff);
duke@435	1368	__ jmp(do_return);
duke@435	1369
duke@435	1370	__ bind(return_min_jlong);
duke@435	1371	__ movl(rdx, 0x80000000);
duke@435	1372	__ xorl(rax, rax);
duke@435	1373	__ jmp(do_return);
duke@435	1374
duke@435	1375	__ bind(return0);
duke@435	1376	__ fpop();
duke@435	1377	__ xorl(rdx,rdx);
duke@435	1378	__ xorl(rax,rax);
duke@435	1379
duke@435	1380	__ bind(do_return);
duke@435	1381	__ addl(rsp, 20);
duke@435	1382	__ popl(rcx);
duke@435	1383	__ popl(rsi);
duke@435	1384	__ ret(0);
duke@435	1385	}
duke@435	1386	break;
duke@435	1387
ysr@777	1388	#ifndef SERIALGC
ysr@777	1389	case g1_pre_barrier_slow_id:
ysr@777	1390	{
ysr@777	1391	StubFrame f(sasm, "g1_pre_barrier", dont_gc_arguments);
ysr@777	1392	// arg0 : previous value of memory
ysr@777	1393
ysr@777	1394	BarrierSet* bs = Universe::heap()->barrier_set();
ysr@777	1395	if (bs->kind() != BarrierSet::G1SATBCTLogging) {
ysr@777	1396	__ movl(rax, (int)id);
ysr@777	1397	__ call_RT(noreg, noreg, CAST_FROM_FN_PTR(address, unimplemented_entry), rax);
ysr@777	1398	__ should_not_reach_here();
ysr@777	1399	break;
ysr@777	1400	}
ysr@777	1401
ysr@777	1402	__ pushl(rax);
ysr@777	1403	__ pushl(rdx);
ysr@777	1404
ysr@777	1405	const Register pre_val = rax;
ysr@777	1406	const Register thread = rax;
ysr@777	1407	const Register tmp = rdx;
ysr@777	1408
ysr@777	1409	__ get_thread(thread);
ysr@777	1410
ysr@777	1411	Address in_progress(thread, in_bytes(JavaThread::satb_mark_queue_offset() +
ysr@777	1412	PtrQueue::byte_offset_of_active()));
ysr@777	1413
ysr@777	1414	Address queue_index(thread, in_bytes(JavaThread::satb_mark_queue_offset() +
ysr@777	1415	PtrQueue::byte_offset_of_index()));
ysr@777	1416	Address buffer(thread, in_bytes(JavaThread::satb_mark_queue_offset() +
ysr@777	1417	PtrQueue::byte_offset_of_buf()));
ysr@777	1418
ysr@777	1419
ysr@777	1420	Label done;
ysr@777	1421	Label runtime;
ysr@777	1422
ysr@777	1423	// Can we store original value in the thread's buffer?
ysr@777	1424
ysr@777	1425	__ cmpl(queue_index, 0);
ysr@777	1426	__ jcc(Assembler::equal, runtime);
ysr@777	1427	__ subl(queue_index, wordSize);
ysr@777	1428	__ movl(tmp, buffer);
ysr@777	1429	__ addl(tmp, queue_index);
ysr@777	1430	// prev_val (rax)
ysr@777	1431	f.load_argument(0, pre_val);
ysr@777	1432	__ movl(Address(tmp, 0), pre_val);
ysr@777	1433	__ jmp(done);
ysr@777	1434
ysr@777	1435	__ bind(runtime);
ysr@777	1436	// load the pre-value
ysr@777	1437	__ pushl(rcx);
ysr@777	1438	f.load_argument(0, rcx);
ysr@777	1439	__ call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::g1_wb_pre), rcx, thread);
ysr@777	1440	__ popl(rcx);
ysr@777	1441
ysr@777	1442	__ bind(done);
ysr@777	1443	__ popl(rdx);
ysr@777	1444	__ popl(rax);
ysr@777	1445	}
ysr@777	1446	break;
ysr@777	1447
ysr@777	1448	case g1_post_barrier_slow_id:
ysr@777	1449	{
ysr@777	1450	StubFrame f(sasm, "g1_post_barrier", dont_gc_arguments);
ysr@777	1451
ysr@777	1452
ysr@777	1453	// arg0: store_address
ysr@777	1454	Address store_addr(rbp, 2*BytesPerWord);
ysr@777	1455
ysr@777	1456	BarrierSet* bs = Universe::heap()->barrier_set();
ysr@777	1457	CardTableModRefBS* ct = (CardTableModRefBS*)bs;
ysr@777	1458	Label done;
ysr@777	1459	Label runtime;
ysr@777	1460
ysr@777	1461	// At this point we know new_value is non-NULL and the new_value crosses regsion.
ysr@777	1462	// Must check to see if card is already dirty
ysr@777	1463
ysr@777	1464	const Register card_index = rdx;
ysr@777	1465
ysr@777	1466	const Register thread = rax;
ysr@777	1467	Address queue_index(thread, in_bytes(JavaThread::dirty_card_queue_offset() +
ysr@777	1468	PtrQueue::byte_offset_of_index()));
ysr@777	1469	Address buffer(thread, in_bytes(JavaThread::dirty_card_queue_offset() +
ysr@777	1470	PtrQueue::byte_offset_of_buf()));
ysr@777	1471
ysr@777	1472	__ pushl(rax);
ysr@777	1473	__ pushl(rdx);
ysr@777	1474
ysr@777	1475	__ movl(card_index, store_addr);
ysr@777	1476	__ get_thread(rax);
ysr@777	1477	__ shrl(card_index, CardTableModRefBS::card_shift);
ysr@777	1478	assert(sizeof(*ct->byte_map_base) == sizeof(jbyte), "adjust this code");
ysr@777	1479
ysr@777	1480	ExternalAddress cardtable((address)ct->byte_map_base);
ysr@777	1481	Address index(noreg, card_index, Address::times_1);
ysr@777	1482	const Register card_addr = rdx;
ysr@777	1483	__ leal(card_addr, __ as_Address(ArrayAddress(cardtable, index)));
ysr@777	1484	__ cmpb(Address(card_addr, 0), 0);
ysr@777	1485	__ jcc(Assembler::equal, done);
ysr@777	1486
ysr@777	1487	// storing region crossing non-NULL, card is clean.
ysr@777	1488	// dirty card and log.
ysr@777	1489
ysr@777	1490	__ movb(Address(card_addr, 0), 0);
ysr@777	1491
ysr@777	1492	__ cmpl(queue_index, 0);
ysr@777	1493	__ jcc(Assembler::equal, runtime);
ysr@777	1494	__ subl(queue_index, wordSize);
ysr@777	1495
ysr@777	1496	const Register buffer_addr = rbx;
ysr@777	1497	__ pushl(rbx);
ysr@777	1498
ysr@777	1499	__ movl(buffer_addr, buffer);
ysr@777	1500	__ addl(buffer_addr, queue_index);
ysr@777	1501	__ movl(Address(buffer_addr, 0), card_addr);
ysr@777	1502	__ popl(rbx);
ysr@777	1503	__ jmp(done);
ysr@777	1504
ysr@777	1505	__ bind(runtime);
ysr@777	1506	__ pushl(rcx);
ysr@777	1507	__ call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::g1_wb_post), card_addr, thread);
ysr@777	1508	__ popl(rcx);
ysr@777	1509
ysr@777	1510	__ bind(done);
ysr@777	1511	__ popl(rdx);
ysr@777	1512	__ popl(rax);
ysr@777	1513
ysr@777	1514	}
ysr@777	1515	break;
ysr@777	1516	#endif // !SERIALGC
ysr@777	1517
duke@435	1518	default:
duke@435	1519	{ StubFrame f(sasm, "unimplemented entry", dont_gc_arguments);
duke@435	1520	__ movl(rax, (int)id);
duke@435	1521	__ call_RT(noreg, noreg, CAST_FROM_FN_PTR(address, unimplemented_entry), rax);
duke@435	1522	__ should_not_reach_here();
duke@435	1523	}
duke@435	1524	break;
duke@435	1525	}
duke@435	1526	return oop_maps;
duke@435	1527	}
duke@435	1528
duke@435	1529	#undef __