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

src/share/vm/interpreter/templateInterpreter.cpp@feeb96a45707 (annotated)

src/share/vm/interpreter/templateInterpreter.cpp

Wed, 28 May 2008 21:06:24 -0700

author

coleenp

date

Wed, 28 May 2008 21:06:24 -0700

changeset 602

feeb96a45707

parent 435

a61af66fc99e

child 1145

e5b0439ef4ae

permissions

-rw-r--r--

6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
Summary: decouple set_klass() with zeroing the gap when compressed.
Reviewed-by: kvn, ysr, jrose

duke@435	1	/*
duke@435	2	* Copyright 1997-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/_templateInterpreter.cpp.incl"
duke@435	27
duke@435	28	#ifndef CC_INTERP
duke@435	29
duke@435	30	# define __ _masm->
duke@435	31
duke@435	32	void TemplateInterpreter::initialize() {
duke@435	33	if (_code != NULL) return;
duke@435	34	// assertions
duke@435	35	assert((int)Bytecodes::number_of_codes <= (int)DispatchTable::length,
duke@435	36	"dispatch table too small");
duke@435	37
duke@435	38	AbstractInterpreter::initialize();
duke@435	39
duke@435	40	TemplateTable::initialize();
duke@435	41
duke@435	42	// generate interpreter
duke@435	43	{ ResourceMark rm;
duke@435	44	TraceTime timer("Interpreter generation", TraceStartupTime);
duke@435	45	int code_size = InterpreterCodeSize;
duke@435	46	NOT_PRODUCT(code_size *= 4;) // debug uses extra interpreter code space
duke@435	47	_code = new StubQueue(new InterpreterCodeletInterface, code_size, NULL,
duke@435	48	"Interpreter");
duke@435	49	InterpreterGenerator g(_code);
duke@435	50	if (PrintInterpreter) print();
duke@435	51	}
duke@435	52
duke@435	53	// initialize dispatch table
duke@435	54	_active_table = _normal_table;
duke@435	55	}
duke@435	56
duke@435	57	//------------------------------------------------------------------------------------------------------------------------
duke@435	58	// Implementation of EntryPoint
duke@435	59
duke@435	60	EntryPoint::EntryPoint() {
duke@435	61	assert(number_of_states == 9, "check the code below");
duke@435	62	_entry[btos] = NULL;
duke@435	63	_entry[ctos] = NULL;
duke@435	64	_entry[stos] = NULL;
duke@435	65	_entry[atos] = NULL;
duke@435	66	_entry[itos] = NULL;
duke@435	67	_entry[ltos] = NULL;
duke@435	68	_entry[ftos] = NULL;
duke@435	69	_entry[dtos] = NULL;
duke@435	70	_entry[vtos] = NULL;
duke@435	71	}
duke@435	72
duke@435	73
duke@435	74	EntryPoint::EntryPoint(address bentry, address centry, address sentry, address aentry, address ientry, address lentry, address fentry, address dentry, address ventry) {
duke@435	75	assert(number_of_states == 9, "check the code below");
duke@435	76	_entry[btos] = bentry;
duke@435	77	_entry[ctos] = centry;
duke@435	78	_entry[stos] = sentry;
duke@435	79	_entry[atos] = aentry;
duke@435	80	_entry[itos] = ientry;
duke@435	81	_entry[ltos] = lentry;
duke@435	82	_entry[ftos] = fentry;
duke@435	83	_entry[dtos] = dentry;
duke@435	84	_entry[vtos] = ventry;
duke@435	85	}
duke@435	86
duke@435	87
duke@435	88	void EntryPoint::set_entry(TosState state, address entry) {
duke@435	89	assert(0 <= state && state < number_of_states, "state out of bounds");
duke@435	90	_entry[state] = entry;
duke@435	91	}
duke@435	92
duke@435	93
duke@435	94	address EntryPoint::entry(TosState state) const {
duke@435	95	assert(0 <= state && state < number_of_states, "state out of bounds");
duke@435	96	return _entry[state];
duke@435	97	}
duke@435	98
duke@435	99
duke@435	100	void EntryPoint::print() {
duke@435	101	tty->print("[");
duke@435	102	for (int i = 0; i < number_of_states; i++) {
duke@435	103	if (i > 0) tty->print(", ");
duke@435	104	tty->print(INTPTR_FORMAT, _entry[i]);
duke@435	105	}
duke@435	106	tty->print("]");
duke@435	107	}
duke@435	108
duke@435	109
duke@435	110	bool EntryPoint::operator == (const EntryPoint& y) {
duke@435	111	int i = number_of_states;
duke@435	112	while (i-- > 0) {
duke@435	113	if (_entry[i] != y._entry[i]) return false;
duke@435	114	}
duke@435	115	return true;
duke@435	116	}
duke@435	117
duke@435	118
duke@435	119	//------------------------------------------------------------------------------------------------------------------------
duke@435	120	// Implementation of DispatchTable
duke@435	121
duke@435	122	EntryPoint DispatchTable::entry(int i) const {
duke@435	123	assert(0 <= i && i < length, "index out of bounds");
duke@435	124	return
duke@435	125	EntryPoint(
duke@435	126	_table[btos][i],
duke@435	127	_table[ctos][i],
duke@435	128	_table[stos][i],
duke@435	129	_table[atos][i],
duke@435	130	_table[itos][i],
duke@435	131	_table[ltos][i],
duke@435	132	_table[ftos][i],
duke@435	133	_table[dtos][i],
duke@435	134	_table[vtos][i]
duke@435	135	);
duke@435	136	}
duke@435	137
duke@435	138
duke@435	139	void DispatchTable::set_entry(int i, EntryPoint& entry) {
duke@435	140	assert(0 <= i && i < length, "index out of bounds");
duke@435	141	assert(number_of_states == 9, "check the code below");
duke@435	142	_table[btos][i] = entry.entry(btos);
duke@435	143	_table[ctos][i] = entry.entry(ctos);
duke@435	144	_table[stos][i] = entry.entry(stos);
duke@435	145	_table[atos][i] = entry.entry(atos);
duke@435	146	_table[itos][i] = entry.entry(itos);
duke@435	147	_table[ltos][i] = entry.entry(ltos);
duke@435	148	_table[ftos][i] = entry.entry(ftos);
duke@435	149	_table[dtos][i] = entry.entry(dtos);
duke@435	150	_table[vtos][i] = entry.entry(vtos);
duke@435	151	}
duke@435	152
duke@435	153
duke@435	154	bool DispatchTable::operator == (DispatchTable& y) {
duke@435	155	int i = length;
duke@435	156	while (i-- > 0) {
duke@435	157	EntryPoint t = y.entry(i); // for compiler compatibility (BugId 4150096)
duke@435	158	if (!(entry(i) == t)) return false;
duke@435	159	}
duke@435	160	return true;
duke@435	161	}
duke@435	162
duke@435	163	address TemplateInterpreter::_remove_activation_entry = NULL;
duke@435	164	address TemplateInterpreter::_remove_activation_preserving_args_entry = NULL;
duke@435	165
duke@435	166
duke@435	167	address TemplateInterpreter::_throw_ArrayIndexOutOfBoundsException_entry = NULL;
duke@435	168	address TemplateInterpreter::_throw_ArrayStoreException_entry = NULL;
duke@435	169	address TemplateInterpreter::_throw_ArithmeticException_entry = NULL;
duke@435	170	address TemplateInterpreter::_throw_ClassCastException_entry = NULL;
duke@435	171	address TemplateInterpreter::_throw_NullPointerException_entry = NULL;
duke@435	172	address TemplateInterpreter::_throw_StackOverflowError_entry = NULL;
duke@435	173	address TemplateInterpreter::_throw_exception_entry = NULL;
duke@435	174
duke@435	175	#ifndef PRODUCT
duke@435	176	EntryPoint TemplateInterpreter::_trace_code;
duke@435	177	#endif // !PRODUCT
duke@435	178	EntryPoint TemplateInterpreter::_return_entry[TemplateInterpreter::number_of_return_entries];
duke@435	179	EntryPoint TemplateInterpreter::_earlyret_entry;
duke@435	180	EntryPoint TemplateInterpreter::_deopt_entry [TemplateInterpreter::number_of_deopt_entries ];
duke@435	181	EntryPoint TemplateInterpreter::_continuation_entry;
duke@435	182	EntryPoint TemplateInterpreter::_safept_entry;
duke@435	183
duke@435	184	address TemplateInterpreter::_return_3_addrs_by_index[TemplateInterpreter::number_of_return_addrs];
duke@435	185	address TemplateInterpreter::_return_5_addrs_by_index[TemplateInterpreter::number_of_return_addrs];
duke@435	186
duke@435	187	DispatchTable TemplateInterpreter::_active_table;
duke@435	188	DispatchTable TemplateInterpreter::_normal_table;
duke@435	189	DispatchTable TemplateInterpreter::_safept_table;
duke@435	190	address TemplateInterpreter::_wentry_point[DispatchTable::length];
duke@435	191
duke@435	192	TemplateInterpreterGenerator::TemplateInterpreterGenerator(StubQueue* _code): AbstractInterpreterGenerator(_code) {
duke@435	193	_unimplemented_bytecode = NULL;
duke@435	194	_illegal_bytecode_sequence = NULL;
duke@435	195	}
duke@435	196
duke@435	197	static const BasicType types[Interpreter::number_of_result_handlers] = {
duke@435	198	T_BOOLEAN,
duke@435	199	T_CHAR ,
duke@435	200	T_BYTE ,
duke@435	201	T_SHORT ,
duke@435	202	T_INT ,
duke@435	203	T_LONG ,
duke@435	204	T_VOID ,
duke@435	205	T_FLOAT ,
duke@435	206	T_DOUBLE ,
duke@435	207	T_OBJECT
duke@435	208	};
duke@435	209
duke@435	210	void TemplateInterpreterGenerator::generate_all() {
duke@435	211	AbstractInterpreterGenerator::generate_all();
duke@435	212
duke@435	213	{ CodeletMark cm(_masm, "error exits");
duke@435	214	_unimplemented_bytecode = generate_error_exit("unimplemented bytecode");
duke@435	215	_illegal_bytecode_sequence = generate_error_exit("illegal bytecode sequence - method not verified");
duke@435	216	}
duke@435	217
duke@435	218	#ifndef PRODUCT
duke@435	219	if (TraceBytecodes) {
duke@435	220	CodeletMark cm(_masm, "bytecode tracing support");
duke@435	221	Interpreter::_trace_code =
duke@435	222	EntryPoint(
duke@435	223	generate_trace_code(btos),
duke@435	224	generate_trace_code(ctos),
duke@435	225	generate_trace_code(stos),
duke@435	226	generate_trace_code(atos),
duke@435	227	generate_trace_code(itos),
duke@435	228	generate_trace_code(ltos),
duke@435	229	generate_trace_code(ftos),
duke@435	230	generate_trace_code(dtos),
duke@435	231	generate_trace_code(vtos)
duke@435	232	);
duke@435	233	}
duke@435	234	#endif // !PRODUCT
duke@435	235
duke@435	236	{ CodeletMark cm(_masm, "return entry points");
duke@435	237	for (int i = 0; i < Interpreter::number_of_return_entries; i++) {
duke@435	238	Interpreter::_return_entry[i] =
duke@435	239	EntryPoint(
duke@435	240	generate_return_entry_for(itos, i),
duke@435	241	generate_return_entry_for(itos, i),
duke@435	242	generate_return_entry_for(itos, i),
duke@435	243	generate_return_entry_for(atos, i),
duke@435	244	generate_return_entry_for(itos, i),
duke@435	245	generate_return_entry_for(ltos, i),
duke@435	246	generate_return_entry_for(ftos, i),
duke@435	247	generate_return_entry_for(dtos, i),
duke@435	248	generate_return_entry_for(vtos, i)
duke@435	249	);
duke@435	250	}
duke@435	251	}
duke@435	252
duke@435	253	{ CodeletMark cm(_masm, "earlyret entry points");
duke@435	254	Interpreter::_earlyret_entry =
duke@435	255	EntryPoint(
duke@435	256	generate_earlyret_entry_for(btos),
duke@435	257	generate_earlyret_entry_for(ctos),
duke@435	258	generate_earlyret_entry_for(stos),
duke@435	259	generate_earlyret_entry_for(atos),
duke@435	260	generate_earlyret_entry_for(itos),
duke@435	261	generate_earlyret_entry_for(ltos),
duke@435	262	generate_earlyret_entry_for(ftos),
duke@435	263	generate_earlyret_entry_for(dtos),
duke@435	264	generate_earlyret_entry_for(vtos)
duke@435	265	);
duke@435	266	}
duke@435	267
duke@435	268	{ CodeletMark cm(_masm, "deoptimization entry points");
duke@435	269	for (int i = 0; i < Interpreter::number_of_deopt_entries; i++) {
duke@435	270	Interpreter::_deopt_entry[i] =
duke@435	271	EntryPoint(
duke@435	272	generate_deopt_entry_for(itos, i),
duke@435	273	generate_deopt_entry_for(itos, i),
duke@435	274	generate_deopt_entry_for(itos, i),
duke@435	275	generate_deopt_entry_for(atos, i),
duke@435	276	generate_deopt_entry_for(itos, i),
duke@435	277	generate_deopt_entry_for(ltos, i),
duke@435	278	generate_deopt_entry_for(ftos, i),
duke@435	279	generate_deopt_entry_for(dtos, i),
duke@435	280	generate_deopt_entry_for(vtos, i)
duke@435	281	);
duke@435	282	}
duke@435	283	}
duke@435	284
duke@435	285	{ CodeletMark cm(_masm, "result handlers for native calls");
duke@435	286	// The various result converter stublets.
duke@435	287	int is_generated[Interpreter::number_of_result_handlers];
duke@435	288	memset(is_generated, 0, sizeof(is_generated));
duke@435	289
duke@435	290	for (int i = 0; i < Interpreter::number_of_result_handlers; i++) {
duke@435	291	BasicType type = types[i];
duke@435	292	if (!is_generated[Interpreter::BasicType_as_index(type)]++) {
duke@435	293	Interpreter::_native_abi_to_tosca[Interpreter::BasicType_as_index(type)] = generate_result_handler_for(type);
duke@435	294	}
duke@435	295	}
duke@435	296	}
duke@435	297
duke@435	298	for (int j = 0; j < number_of_states; j++) {
duke@435	299	const TosState states[] = {btos, ctos, stos, itos, ltos, ftos, dtos, atos, vtos};
duke@435	300	Interpreter::_return_3_addrs_by_index[Interpreter::TosState_as_index(states[j])] = Interpreter::return_entry(states[j], 3);
duke@435	301	Interpreter::_return_5_addrs_by_index[Interpreter::TosState_as_index(states[j])] = Interpreter::return_entry(states[j], 5);
duke@435	302	}
duke@435	303
duke@435	304	{ CodeletMark cm(_masm, "continuation entry points");
duke@435	305	Interpreter::_continuation_entry =
duke@435	306	EntryPoint(
duke@435	307	generate_continuation_for(btos),
duke@435	308	generate_continuation_for(ctos),
duke@435	309	generate_continuation_for(stos),
duke@435	310	generate_continuation_for(atos),
duke@435	311	generate_continuation_for(itos),
duke@435	312	generate_continuation_for(ltos),
duke@435	313	generate_continuation_for(ftos),
duke@435	314	generate_continuation_for(dtos),
duke@435	315	generate_continuation_for(vtos)
duke@435	316	);
duke@435	317	}
duke@435	318
duke@435	319	{ CodeletMark cm(_masm, "safepoint entry points");
duke@435	320	Interpreter::_safept_entry =
duke@435	321	EntryPoint(
duke@435	322	generate_safept_entry_for(btos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)),
duke@435	323	generate_safept_entry_for(ctos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)),
duke@435	324	generate_safept_entry_for(stos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)),
duke@435	325	generate_safept_entry_for(atos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)),
duke@435	326	generate_safept_entry_for(itos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)),
duke@435	327	generate_safept_entry_for(ltos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)),
duke@435	328	generate_safept_entry_for(ftos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)),
duke@435	329	generate_safept_entry_for(dtos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)),
duke@435	330	generate_safept_entry_for(vtos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint))
duke@435	331	);
duke@435	332	}
duke@435	333
duke@435	334	{ CodeletMark cm(_masm, "exception handling");
duke@435	335	// (Note: this is not safepoint safe because thread may return to compiled code)
duke@435	336	generate_throw_exception();
duke@435	337	}
duke@435	338
duke@435	339	{ CodeletMark cm(_masm, "throw exception entrypoints");
duke@435	340	Interpreter::_throw_ArrayIndexOutOfBoundsException_entry = generate_ArrayIndexOutOfBounds_handler("java/lang/ArrayIndexOutOfBoundsException");
duke@435	341	Interpreter::_throw_ArrayStoreException_entry = generate_klass_exception_handler("java/lang/ArrayStoreException" );
duke@435	342	Interpreter::_throw_ArithmeticException_entry = generate_exception_handler("java/lang/ArithmeticException" , "/ by zero");
duke@435	343	Interpreter::_throw_ClassCastException_entry = generate_ClassCastException_handler();
duke@435	344	Interpreter::_throw_NullPointerException_entry = generate_exception_handler("java/lang/NullPointerException" , NULL );
duke@435	345	Interpreter::_throw_StackOverflowError_entry = generate_StackOverflowError_handler();
duke@435	346	}
duke@435	347
duke@435	348
duke@435	349
duke@435	350	#define method_entry(kind) \
duke@435	351	{ CodeletMark cm(_masm, "method entry point (kind = " #kind ")"); \
duke@435	352	Interpreter::_entry_table[Interpreter::kind] = generate_method_entry(Interpreter::kind); \
duke@435	353	}
duke@435	354
duke@435	355	// all non-native method kinds
duke@435	356	method_entry(zerolocals)
duke@435	357	method_entry(zerolocals_synchronized)
duke@435	358	method_entry(empty)
duke@435	359	method_entry(accessor)
duke@435	360	method_entry(abstract)
duke@435	361	method_entry(java_lang_math_sin )
duke@435	362	method_entry(java_lang_math_cos )
duke@435	363	method_entry(java_lang_math_tan )
duke@435	364	method_entry(java_lang_math_abs )
duke@435	365	method_entry(java_lang_math_sqrt )
duke@435	366	method_entry(java_lang_math_log )
duke@435	367	method_entry(java_lang_math_log10)
duke@435	368
duke@435	369	// all native method kinds (must be one contiguous block)
duke@435	370	Interpreter::_native_entry_begin = Interpreter::code()->code_end();
duke@435	371	method_entry(native)
duke@435	372	method_entry(native_synchronized)
duke@435	373	Interpreter::_native_entry_end = Interpreter::code()->code_end();
duke@435	374
duke@435	375	#undef method_entry
duke@435	376
duke@435	377	// Bytecodes
duke@435	378	set_entry_points_for_all_bytes();
duke@435	379	set_safepoints_for_all_bytes();
duke@435	380	}
duke@435	381
duke@435	382	//------------------------------------------------------------------------------------------------------------------------
duke@435	383
duke@435	384	address TemplateInterpreterGenerator::generate_error_exit(const char* msg) {
duke@435	385	address entry = __ pc();
duke@435	386	__ stop(msg);
duke@435	387	return entry;
duke@435	388	}
duke@435	389
duke@435	390
duke@435	391	//------------------------------------------------------------------------------------------------------------------------
duke@435	392
duke@435	393	void TemplateInterpreterGenerator::set_entry_points_for_all_bytes() {
duke@435	394	for (int i = 0; i < DispatchTable::length; i++) {
duke@435	395	Bytecodes::Code code = (Bytecodes::Code)i;
duke@435	396	if (Bytecodes::is_defined(code)) {
duke@435	397	set_entry_points(code);
duke@435	398	} else {
duke@435	399	set_unimplemented(i);
duke@435	400	}
duke@435	401	}
duke@435	402	}
duke@435	403
duke@435	404
duke@435	405	void TemplateInterpreterGenerator::set_safepoints_for_all_bytes() {
duke@435	406	for (int i = 0; i < DispatchTable::length; i++) {
duke@435	407	Bytecodes::Code code = (Bytecodes::Code)i;
duke@435	408	if (Bytecodes::is_defined(code)) Interpreter::_safept_table.set_entry(code, Interpreter::_safept_entry);
duke@435	409	}
duke@435	410	}
duke@435	411
duke@435	412
duke@435	413	void TemplateInterpreterGenerator::set_unimplemented(int i) {
duke@435	414	address e = _unimplemented_bytecode;
duke@435	415	EntryPoint entry(e, e, e, e, e, e, e, e, e);
duke@435	416	Interpreter::_normal_table.set_entry(i, entry);
duke@435	417	Interpreter::_wentry_point[i] = _unimplemented_bytecode;
duke@435	418	}
duke@435	419
duke@435	420
duke@435	421	void TemplateInterpreterGenerator::set_entry_points(Bytecodes::Code code) {
duke@435	422	CodeletMark cm(_masm, Bytecodes::name(code), code);
duke@435	423	// initialize entry points
duke@435	424	assert(_unimplemented_bytecode != NULL, "should have been generated before");
duke@435	425	assert(_illegal_bytecode_sequence != NULL, "should have been generated before");
duke@435	426	address bep = _illegal_bytecode_sequence;
duke@435	427	address cep = _illegal_bytecode_sequence;
duke@435	428	address sep = _illegal_bytecode_sequence;
duke@435	429	address aep = _illegal_bytecode_sequence;
duke@435	430	address iep = _illegal_bytecode_sequence;
duke@435	431	address lep = _illegal_bytecode_sequence;
duke@435	432	address fep = _illegal_bytecode_sequence;
duke@435	433	address dep = _illegal_bytecode_sequence;
duke@435	434	address vep = _unimplemented_bytecode;
duke@435	435	address wep = _unimplemented_bytecode;
duke@435	436	// code for short & wide version of bytecode
duke@435	437	if (Bytecodes::is_defined(code)) {
duke@435	438	Template* t = TemplateTable::template_for(code);
duke@435	439	assert(t->is_valid(), "just checking");
duke@435	440	set_short_entry_points(t, bep, cep, sep, aep, iep, lep, fep, dep, vep);
duke@435	441	}
duke@435	442	if (Bytecodes::wide_is_defined(code)) {
duke@435	443	Template* t = TemplateTable::template_for_wide(code);
duke@435	444	assert(t->is_valid(), "just checking");
duke@435	445	set_wide_entry_point(t, wep);
duke@435	446	}
duke@435	447	// set entry points
duke@435	448	EntryPoint entry(bep, cep, sep, aep, iep, lep, fep, dep, vep);
duke@435	449	Interpreter::_normal_table.set_entry(code, entry);
duke@435	450	Interpreter::_wentry_point[code] = wep;
duke@435	451	}
duke@435	452
duke@435	453
duke@435	454	void TemplateInterpreterGenerator::set_wide_entry_point(Template* t, address& wep) {
duke@435	455	assert(t->is_valid(), "template must exist");
duke@435	456	assert(t->tos_in() == vtos, "only vtos tos_in supported for wide instructions")
duke@435	457	wep = __ pc(); generate_and_dispatch(t);
duke@435	458	}
duke@435	459
duke@435	460
duke@435	461	void TemplateInterpreterGenerator::set_short_entry_points(Template* t, address& bep, address& cep, address& sep, address& aep, address& iep, address& lep, address& fep, address& dep, address& vep) {
duke@435	462	assert(t->is_valid(), "template must exist");
duke@435	463	switch (t->tos_in()) {
duke@435	464	case btos: vep = __ pc(); __ pop(btos); bep = __ pc(); generate_and_dispatch(t); break;
duke@435	465	case ctos: vep = __ pc(); __ pop(ctos); sep = __ pc(); generate_and_dispatch(t); break;
duke@435	466	case stos: vep = __ pc(); __ pop(stos); sep = __ pc(); generate_and_dispatch(t); break;
duke@435	467	case atos: vep = __ pc(); __ pop(atos); aep = __ pc(); generate_and_dispatch(t); break;
duke@435	468	case itos: vep = __ pc(); __ pop(itos); iep = __ pc(); generate_and_dispatch(t); break;
duke@435	469	case ltos: vep = __ pc(); __ pop(ltos); lep = __ pc(); generate_and_dispatch(t); break;
duke@435	470	case ftos: vep = __ pc(); __ pop(ftos); fep = __ pc(); generate_and_dispatch(t); break;
duke@435	471	case dtos: vep = __ pc(); __ pop(dtos); dep = __ pc(); generate_and_dispatch(t); break;
duke@435	472	case vtos: set_vtos_entry_points(t, bep, cep, sep, aep, iep, lep, fep, dep, vep); break;
duke@435	473	default : ShouldNotReachHere(); break;
duke@435	474	}
duke@435	475	}
duke@435	476
duke@435	477
duke@435	478	//------------------------------------------------------------------------------------------------------------------------
duke@435	479
duke@435	480	void TemplateInterpreterGenerator::generate_and_dispatch(Template* t, TosState tos_out) {
duke@435	481	if (PrintBytecodeHistogram) histogram_bytecode(t);
duke@435	482	#ifndef PRODUCT
duke@435	483	// debugging code
duke@435	484	if (CountBytecodes || TraceBytecodes || StopInterpreterAt > 0) count_bytecode();
duke@435	485	if (PrintBytecodePairHistogram) histogram_bytecode_pair(t);
duke@435	486	if (TraceBytecodes) trace_bytecode(t);
duke@435	487	if (StopInterpreterAt > 0) stop_interpreter_at();
duke@435	488	__ verify_FPU(1, t->tos_in());
duke@435	489	#endif // !PRODUCT
duke@435	490	int step;
duke@435	491	if (!t->does_dispatch()) {
duke@435	492	step = t->is_wide() ? Bytecodes::wide_length_for(t->bytecode()) : Bytecodes::length_for(t->bytecode());
duke@435	493	if (tos_out == ilgl) tos_out = t->tos_out();
duke@435	494	// compute bytecode size
duke@435	495	assert(step > 0, "just checkin'");
duke@435	496	// setup stuff for dispatching next bytecode
duke@435	497	if (ProfileInterpreter && VerifyDataPointer
duke@435	498	&& methodDataOopDesc::bytecode_has_profile(t->bytecode())) {
duke@435	499	__ verify_method_data_pointer();
duke@435	500	}
duke@435	501	__ dispatch_prolog(tos_out, step);
duke@435	502	}
duke@435	503	// generate template
duke@435	504	t->generate(_masm);
duke@435	505	// advance
duke@435	506	if (t->does_dispatch()) {
duke@435	507	#ifdef ASSERT
duke@435	508	// make sure execution doesn't go beyond this point if code is broken
duke@435	509	__ should_not_reach_here();
duke@435	510	#endif // ASSERT
duke@435	511	} else {
duke@435	512	// dispatch to next bytecode
duke@435	513	__ dispatch_epilog(tos_out, step);
duke@435	514	}
duke@435	515	}
duke@435	516
duke@435	517	//------------------------------------------------------------------------------------------------------------------------
duke@435	518	// Entry points
duke@435	519
duke@435	520	address TemplateInterpreter::return_entry(TosState state, int length) {
duke@435	521	guarantee(0 <= length && length < Interpreter::number_of_return_entries, "illegal length");
duke@435	522	return _return_entry[length].entry(state);
duke@435	523	}
duke@435	524
duke@435	525
duke@435	526	address TemplateInterpreter::deopt_entry(TosState state, int length) {
duke@435	527	guarantee(0 <= length && length < Interpreter::number_of_deopt_entries, "illegal length");
duke@435	528	return _deopt_entry[length].entry(state);
duke@435	529	}
duke@435	530
duke@435	531	//------------------------------------------------------------------------------------------------------------------------
duke@435	532	// Suport for invokes
duke@435	533
duke@435	534	int TemplateInterpreter::TosState_as_index(TosState state) {
duke@435	535	assert( state < number_of_states , "Invalid state in TosState_as_index");
duke@435	536	assert(0 <= (int)state && (int)state < TemplateInterpreter::number_of_return_addrs, "index out of bounds");
duke@435	537	return (int)state;
duke@435	538	}
duke@435	539
duke@435	540
duke@435	541	//------------------------------------------------------------------------------------------------------------------------
duke@435	542	// Safepoint suppport
duke@435	543
duke@435	544	static inline void copy_table(address* from, address* to, int size) {
duke@435	545	// Copy non-overlapping tables. The copy has to occur word wise for MT safety.
duke@435	546	while (size-- > 0) *to++ = *from++;
duke@435	547	}
duke@435	548
duke@435	549	void TemplateInterpreter::notice_safepoints() {
duke@435	550	if (!_notice_safepoints) {
duke@435	551	// switch to safepoint dispatch table
duke@435	552	_notice_safepoints = true;
duke@435	553	copy_table((address*)&_safept_table, (address*)&_active_table, sizeof(_active_table) / sizeof(address));
duke@435	554	}
duke@435	555	}
duke@435	556
duke@435	557	// switch from the dispatch table which notices safepoints back to the
duke@435	558	// normal dispatch table. So that we can notice single stepping points,
duke@435	559	// keep the safepoint dispatch table if we are single stepping in JVMTI.
duke@435	560	// Note that the should_post_single_step test is exactly as fast as the
duke@435	561	// JvmtiExport::_enabled test and covers both cases.
duke@435	562	void TemplateInterpreter::ignore_safepoints() {
duke@435	563	if (_notice_safepoints) {
duke@435	564	if (!JvmtiExport::should_post_single_step()) {
duke@435	565	// switch to normal dispatch table
duke@435	566	_notice_safepoints = false;
duke@435	567	copy_table((address*)&_normal_table, (address*)&_active_table, sizeof(_active_table) / sizeof(address));
duke@435	568	}
duke@435	569	}
duke@435	570	}
duke@435	571
duke@435	572	// If deoptimization happens, this method returns the point where to continue in
duke@435	573	// interpreter. For calls (invokexxxx, newxxxx) the continuation is at next
duke@435	574	// bci and the top of stack is in eax/edx/FPU tos.
duke@435	575	// For putfield/getfield, put/getstatic, the continuation is at the same
duke@435	576	// bci and the TOS is on stack.
duke@435	577
duke@435	578	// Note: deopt_entry(type, 0) means reexecute bytecode
duke@435	579	// deopt_entry(type, length) means continue at next bytecode
duke@435	580
duke@435	581	address TemplateInterpreter::continuation_for(methodOop method, address bcp, int callee_parameters, bool is_top_frame, bool& use_next_mdp) {
duke@435	582	assert(method->contains(bcp), "just checkin'");
duke@435	583	Bytecodes::Code code = Bytecodes::java_code_at(bcp);
duke@435	584	if (code == Bytecodes::_return) {
duke@435	585	// This is used for deopt during registration of finalizers
duke@435	586	// during Object.<init>. We simply need to resume execution at
duke@435	587	// the standard return vtos bytecode to pop the frame normally.
duke@435	588	// reexecuting the real bytecode would cause double registration
duke@435	589	// of the finalizable object.
duke@435	590	assert(is_top_frame, "must be on top");
duke@435	591	return _normal_table.entry(Bytecodes::_return).entry(vtos);
duke@435	592	} else {
duke@435	593	return AbstractInterpreter::continuation_for(method, bcp, callee_parameters, is_top_frame, use_next_mdp);
duke@435	594	}
duke@435	595	}
duke@435	596
duke@435	597	#endif // !CC_INTERP