jdk-sandbox: hotspot/src/share/vm/interpreter/templateInterpreter.cpp@53be635ad49c (annotated)

1 489c9b5090e2 Initial load duke parents: diff changeset	1	/*
31620 53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	2	* Copyright (c) 1997, 2015, Oracle and/or its affiliates. All rights reserved.
1 489c9b5090e2 Initial load duke parents: diff changeset	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
489c9b5090e2 Initial load duke parents: diff changeset	4	*
489c9b5090e2 Initial load duke parents: diff changeset	5	* This code is free software; you can redistribute it and/or modify it
489c9b5090e2 Initial load duke parents: diff changeset	6	* under the terms of the GNU General Public License version 2 only, as
489c9b5090e2 Initial load duke parents: diff changeset	7	* published by the Free Software Foundation.
489c9b5090e2 Initial load duke parents: diff changeset	8	*
489c9b5090e2 Initial load duke parents: diff changeset	9	* This code is distributed in the hope that it will be useful, but WITHOUT
489c9b5090e2 Initial load duke parents: diff changeset	10	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
489c9b5090e2 Initial load duke parents: diff changeset	11	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
489c9b5090e2 Initial load duke parents: diff changeset	12	* version 2 for more details (a copy is included in the LICENSE file that
489c9b5090e2 Initial load duke parents: diff changeset	13	* accompanied this code).
489c9b5090e2 Initial load duke parents: diff changeset	14	*
489c9b5090e2 Initial load duke parents: diff changeset	15	* You should have received a copy of the GNU General Public License version
489c9b5090e2 Initial load duke parents: diff changeset	16	* 2 along with this work; if not, write to the Free Software Foundation,
489c9b5090e2 Initial load duke parents: diff changeset	17	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
489c9b5090e2 Initial load duke parents: diff changeset	18	*
5547 f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 5402 diff changeset	19	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 5402 diff changeset	20	* or visit www.oracle.com if you need additional information or have any
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 5402 diff changeset	21	* questions.
1 489c9b5090e2 Initial load duke parents: diff changeset	22	*
489c9b5090e2 Initial load duke parents: diff changeset	23	*/
489c9b5090e2 Initial load duke parents: diff changeset	24
7397 5b173b4ca846 6989984: Use standard include model for Hospot stefank parents: 5547 diff changeset	25	#include "precompiled.hpp"
31620 53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	26	#include "code/codeCacheExtensions.hpp"
7397 5b173b4ca846 6989984: Use standard include model for Hospot stefank parents: 5547 diff changeset	27	#include "interpreter/interpreter.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot stefank parents: 5547 diff changeset	28	#include "interpreter/interpreterGenerator.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot stefank parents: 5547 diff changeset	29	#include "interpreter/interpreterRuntime.hpp"
25715 d5a8dbdc5150 8049325: Introduce and clean up umbrella headers for the files in the cpu subdirectories. goetz parents: 24424 diff changeset	30	#include "interpreter/interp_masm.hpp"
d5a8dbdc5150 8049325: Introduce and clean up umbrella headers for the files in the cpu subdirectories. goetz parents: 24424 diff changeset	31	#include "interpreter/templateInterpreter.hpp"
7397 5b173b4ca846 6989984: Use standard include model for Hospot stefank parents: 5547 diff changeset	32	#include "interpreter/templateTable.hpp"
1 489c9b5090e2 Initial load duke parents: diff changeset	33
489c9b5090e2 Initial load duke parents: diff changeset	34	#ifndef CC_INTERP
489c9b5090e2 Initial load duke parents: diff changeset	35
489c9b5090e2 Initial load duke parents: diff changeset	36	# define __ _masm->
489c9b5090e2 Initial load duke parents: diff changeset	37
489c9b5090e2 Initial load duke parents: diff changeset	38	void TemplateInterpreter::initialize() {
489c9b5090e2 Initial load duke parents: diff changeset	39	if (_code != NULL) return;
489c9b5090e2 Initial load duke parents: diff changeset	40	// assertions
489c9b5090e2 Initial load duke parents: diff changeset	41	assert((int)Bytecodes::number_of_codes <= (int)DispatchTable::length,
489c9b5090e2 Initial load duke parents: diff changeset	42	"dispatch table too small");
489c9b5090e2 Initial load duke parents: diff changeset	43
489c9b5090e2 Initial load duke parents: diff changeset	44	AbstractInterpreter::initialize();
489c9b5090e2 Initial load duke parents: diff changeset	45
489c9b5090e2 Initial load duke parents: diff changeset	46	TemplateTable::initialize();
489c9b5090e2 Initial load duke parents: diff changeset	47
489c9b5090e2 Initial load duke parents: diff changeset	48	// generate interpreter
489c9b5090e2 Initial load duke parents: diff changeset	49	{ ResourceMark rm;
489c9b5090e2 Initial load duke parents: diff changeset	50	TraceTime timer("Interpreter generation", TraceStartupTime);
489c9b5090e2 Initial load duke parents: diff changeset	51	int code_size = InterpreterCodeSize;
489c9b5090e2 Initial load duke parents: diff changeset	52	NOT_PRODUCT(code_size *= 4;) // debug uses extra interpreter code space
31620 53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	53	#if INCLUDE_JVMTI
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	54	if (CodeCacheExtensions::saving_generated_interpreter()) {
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	55	// May requires several versions of the codelets.
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	56	// Final size will automatically be optimized.
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	57	code_size *= 2;
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	58	}
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	59	#endif
1 489c9b5090e2 Initial load duke parents: diff changeset	60	_code = new StubQueue(new InterpreterCodeletInterface, code_size, NULL,
489c9b5090e2 Initial load duke parents: diff changeset	61	"Interpreter");
489c9b5090e2 Initial load duke parents: diff changeset	62	InterpreterGenerator g(_code);
31620 53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	63	}
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	64	if (PrintInterpreter) {
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	65	if (CodeCacheExtensions::saving_generated_interpreter() &&
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	66	CodeCacheExtensions::use_pregenerated_interpreter()) {
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	67	ResourceMark rm;
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	68	tty->print("Printing the newly generated interpreter first");
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	69	print();
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	70	tty->print("Printing the pregenerated interpreter next");
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	71	}
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	72	}
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	73
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	74	// Install the pregenerated interpreter code before printing it
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	75	CodeCacheExtensions::complete_step(CodeCacheExtensionsSteps::TemplateInterpreter);
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	76
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	77	if (PrintInterpreter) {
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	78	ResourceMark rm;
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	79	print();
1 489c9b5090e2 Initial load duke parents: diff changeset	80	}
489c9b5090e2 Initial load duke parents: diff changeset	81
489c9b5090e2 Initial load duke parents: diff changeset	82	// initialize dispatch table
489c9b5090e2 Initial load duke parents: diff changeset	83	_active_table = _normal_table;
489c9b5090e2 Initial load duke parents: diff changeset	84	}
489c9b5090e2 Initial load duke parents: diff changeset	85
489c9b5090e2 Initial load duke parents: diff changeset	86	//------------------------------------------------------------------------------------------------------------------------
489c9b5090e2 Initial load duke parents: diff changeset	87	// Implementation of EntryPoint
489c9b5090e2 Initial load duke parents: diff changeset	88
489c9b5090e2 Initial load duke parents: diff changeset	89	EntryPoint::EntryPoint() {
489c9b5090e2 Initial load duke parents: diff changeset	90	assert(number_of_states == 9, "check the code below");
489c9b5090e2 Initial load duke parents: diff changeset	91	_entry[btos] = NULL;
489c9b5090e2 Initial load duke parents: diff changeset	92	_entry[ctos] = NULL;
489c9b5090e2 Initial load duke parents: diff changeset	93	_entry[stos] = NULL;
489c9b5090e2 Initial load duke parents: diff changeset	94	_entry[atos] = NULL;
489c9b5090e2 Initial load duke parents: diff changeset	95	_entry[itos] = NULL;
489c9b5090e2 Initial load duke parents: diff changeset	96	_entry[ltos] = NULL;
489c9b5090e2 Initial load duke parents: diff changeset	97	_entry[ftos] = NULL;
489c9b5090e2 Initial load duke parents: diff changeset	98	_entry[dtos] = NULL;
489c9b5090e2 Initial load duke parents: diff changeset	99	_entry[vtos] = NULL;
489c9b5090e2 Initial load duke parents: diff changeset	100	}
489c9b5090e2 Initial load duke parents: diff changeset	101
489c9b5090e2 Initial load duke parents: diff changeset	102
489c9b5090e2 Initial load duke parents: diff changeset	103	EntryPoint::EntryPoint(address bentry, address centry, address sentry, address aentry, address ientry, address lentry, address fentry, address dentry, address ventry) {
489c9b5090e2 Initial load duke parents: diff changeset	104	assert(number_of_states == 9, "check the code below");
489c9b5090e2 Initial load duke parents: diff changeset	105	_entry[btos] = bentry;
489c9b5090e2 Initial load duke parents: diff changeset	106	_entry[ctos] = centry;
489c9b5090e2 Initial load duke parents: diff changeset	107	_entry[stos] = sentry;
489c9b5090e2 Initial load duke parents: diff changeset	108	_entry[atos] = aentry;
489c9b5090e2 Initial load duke parents: diff changeset	109	_entry[itos] = ientry;
489c9b5090e2 Initial load duke parents: diff changeset	110	_entry[ltos] = lentry;
489c9b5090e2 Initial load duke parents: diff changeset	111	_entry[ftos] = fentry;
489c9b5090e2 Initial load duke parents: diff changeset	112	_entry[dtos] = dentry;
489c9b5090e2 Initial load duke parents: diff changeset	113	_entry[vtos] = ventry;
489c9b5090e2 Initial load duke parents: diff changeset	114	}
489c9b5090e2 Initial load duke parents: diff changeset	115
489c9b5090e2 Initial load duke parents: diff changeset	116
489c9b5090e2 Initial load duke parents: diff changeset	117	void EntryPoint::set_entry(TosState state, address entry) {
489c9b5090e2 Initial load duke parents: diff changeset	118	assert(0 <= state && state < number_of_states, "state out of bounds");
489c9b5090e2 Initial load duke parents: diff changeset	119	_entry[state] = entry;
489c9b5090e2 Initial load duke parents: diff changeset	120	}
489c9b5090e2 Initial load duke parents: diff changeset	121
489c9b5090e2 Initial load duke parents: diff changeset	122
489c9b5090e2 Initial load duke parents: diff changeset	123	address EntryPoint::entry(TosState state) const {
489c9b5090e2 Initial load duke parents: diff changeset	124	assert(0 <= state && state < number_of_states, "state out of bounds");
489c9b5090e2 Initial load duke parents: diff changeset	125	return _entry[state];
489c9b5090e2 Initial load duke parents: diff changeset	126	}
489c9b5090e2 Initial load duke parents: diff changeset	127
489c9b5090e2 Initial load duke parents: diff changeset	128
489c9b5090e2 Initial load duke parents: diff changeset	129	void EntryPoint::print() {
489c9b5090e2 Initial load duke parents: diff changeset	130	tty->print("[");
489c9b5090e2 Initial load duke parents: diff changeset	131	for (int i = 0; i < number_of_states; i++) {
489c9b5090e2 Initial load duke parents: diff changeset	132	if (i > 0) tty->print(", ");
24424 2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang drchase parents: 21198 diff changeset	133	tty->print(INTPTR_FORMAT, p2i(_entry[i]));
1 489c9b5090e2 Initial load duke parents: diff changeset	134	}
489c9b5090e2 Initial load duke parents: diff changeset	135	tty->print("]");
489c9b5090e2 Initial load duke parents: diff changeset	136	}
489c9b5090e2 Initial load duke parents: diff changeset	137
489c9b5090e2 Initial load duke parents: diff changeset	138
489c9b5090e2 Initial load duke parents: diff changeset	139	bool EntryPoint::operator == (const EntryPoint& y) {
489c9b5090e2 Initial load duke parents: diff changeset	140	int i = number_of_states;
489c9b5090e2 Initial load duke parents: diff changeset	141	while (i-- > 0) {
489c9b5090e2 Initial load duke parents: diff changeset	142	if (_entry[i] != y._entry[i]) return false;
489c9b5090e2 Initial load duke parents: diff changeset	143	}
489c9b5090e2 Initial load duke parents: diff changeset	144	return true;
489c9b5090e2 Initial load duke parents: diff changeset	145	}
489c9b5090e2 Initial load duke parents: diff changeset	146
489c9b5090e2 Initial load duke parents: diff changeset	147
489c9b5090e2 Initial load duke parents: diff changeset	148	//------------------------------------------------------------------------------------------------------------------------
489c9b5090e2 Initial load duke parents: diff changeset	149	// Implementation of DispatchTable
489c9b5090e2 Initial load duke parents: diff changeset	150
489c9b5090e2 Initial load duke parents: diff changeset	151	EntryPoint DispatchTable::entry(int i) const {
489c9b5090e2 Initial load duke parents: diff changeset	152	assert(0 <= i && i < length, "index out of bounds");
489c9b5090e2 Initial load duke parents: diff changeset	153	return
489c9b5090e2 Initial load duke parents: diff changeset	154	EntryPoint(
489c9b5090e2 Initial load duke parents: diff changeset	155	_table[btos][i],
489c9b5090e2 Initial load duke parents: diff changeset	156	_table[ctos][i],
489c9b5090e2 Initial load duke parents: diff changeset	157	_table[stos][i],
489c9b5090e2 Initial load duke parents: diff changeset	158	_table[atos][i],
489c9b5090e2 Initial load duke parents: diff changeset	159	_table[itos][i],
489c9b5090e2 Initial load duke parents: diff changeset	160	_table[ltos][i],
489c9b5090e2 Initial load duke parents: diff changeset	161	_table[ftos][i],
489c9b5090e2 Initial load duke parents: diff changeset	162	_table[dtos][i],
489c9b5090e2 Initial load duke parents: diff changeset	163	_table[vtos][i]
489c9b5090e2 Initial load duke parents: diff changeset	164	);
489c9b5090e2 Initial load duke parents: diff changeset	165	}
489c9b5090e2 Initial load duke parents: diff changeset	166
489c9b5090e2 Initial load duke parents: diff changeset	167
489c9b5090e2 Initial load duke parents: diff changeset	168	void DispatchTable::set_entry(int i, EntryPoint& entry) {
489c9b5090e2 Initial load duke parents: diff changeset	169	assert(0 <= i && i < length, "index out of bounds");
489c9b5090e2 Initial load duke parents: diff changeset	170	assert(number_of_states == 9, "check the code below");
489c9b5090e2 Initial load duke parents: diff changeset	171	_table[btos][i] = entry.entry(btos);
489c9b5090e2 Initial load duke parents: diff changeset	172	_table[ctos][i] = entry.entry(ctos);
489c9b5090e2 Initial load duke parents: diff changeset	173	_table[stos][i] = entry.entry(stos);
489c9b5090e2 Initial load duke parents: diff changeset	174	_table[atos][i] = entry.entry(atos);
489c9b5090e2 Initial load duke parents: diff changeset	175	_table[itos][i] = entry.entry(itos);
489c9b5090e2 Initial load duke parents: diff changeset	176	_table[ltos][i] = entry.entry(ltos);
489c9b5090e2 Initial load duke parents: diff changeset	177	_table[ftos][i] = entry.entry(ftos);
489c9b5090e2 Initial load duke parents: diff changeset	178	_table[dtos][i] = entry.entry(dtos);
489c9b5090e2 Initial load duke parents: diff changeset	179	_table[vtos][i] = entry.entry(vtos);
489c9b5090e2 Initial load duke parents: diff changeset	180	}
489c9b5090e2 Initial load duke parents: diff changeset	181
489c9b5090e2 Initial load duke parents: diff changeset	182
489c9b5090e2 Initial load duke parents: diff changeset	183	bool DispatchTable::operator == (DispatchTable& y) {
489c9b5090e2 Initial load duke parents: diff changeset	184	int i = length;
489c9b5090e2 Initial load duke parents: diff changeset	185	while (i-- > 0) {
489c9b5090e2 Initial load duke parents: diff changeset	186	EntryPoint t = y.entry(i); // for compiler compatibility (BugId 4150096)
489c9b5090e2 Initial load duke parents: diff changeset	187	if (!(entry(i) == t)) return false;
489c9b5090e2 Initial load duke parents: diff changeset	188	}
489c9b5090e2 Initial load duke parents: diff changeset	189	return true;
489c9b5090e2 Initial load duke parents: diff changeset	190	}
489c9b5090e2 Initial load duke parents: diff changeset	191
489c9b5090e2 Initial load duke parents: diff changeset	192	address TemplateInterpreter::_remove_activation_entry = NULL;
489c9b5090e2 Initial load duke parents: diff changeset	193	address TemplateInterpreter::_remove_activation_preserving_args_entry = NULL;
489c9b5090e2 Initial load duke parents: diff changeset	194
489c9b5090e2 Initial load duke parents: diff changeset	195
489c9b5090e2 Initial load duke parents: diff changeset	196	address TemplateInterpreter::_throw_ArrayIndexOutOfBoundsException_entry = NULL;
489c9b5090e2 Initial load duke parents: diff changeset	197	address TemplateInterpreter::_throw_ArrayStoreException_entry = NULL;
489c9b5090e2 Initial load duke parents: diff changeset	198	address TemplateInterpreter::_throw_ArithmeticException_entry = NULL;
489c9b5090e2 Initial load duke parents: diff changeset	199	address TemplateInterpreter::_throw_ClassCastException_entry = NULL;
489c9b5090e2 Initial load duke parents: diff changeset	200	address TemplateInterpreter::_throw_NullPointerException_entry = NULL;
489c9b5090e2 Initial load duke parents: diff changeset	201	address TemplateInterpreter::_throw_StackOverflowError_entry = NULL;
489c9b5090e2 Initial load duke parents: diff changeset	202	address TemplateInterpreter::_throw_exception_entry = NULL;
489c9b5090e2 Initial load duke parents: diff changeset	203
489c9b5090e2 Initial load duke parents: diff changeset	204	#ifndef PRODUCT
489c9b5090e2 Initial load duke parents: diff changeset	205	EntryPoint TemplateInterpreter::_trace_code;
489c9b5090e2 Initial load duke parents: diff changeset	206	#endif // !PRODUCT
489c9b5090e2 Initial load duke parents: diff changeset	207	EntryPoint TemplateInterpreter::_return_entry[TemplateInterpreter::number_of_return_entries];
489c9b5090e2 Initial load duke parents: diff changeset	208	EntryPoint TemplateInterpreter::_earlyret_entry;
489c9b5090e2 Initial load duke parents: diff changeset	209	EntryPoint TemplateInterpreter::_deopt_entry [TemplateInterpreter::number_of_deopt_entries ];
489c9b5090e2 Initial load duke parents: diff changeset	210	EntryPoint TemplateInterpreter::_continuation_entry;
489c9b5090e2 Initial load duke parents: diff changeset	211	EntryPoint TemplateInterpreter::_safept_entry;
489c9b5090e2 Initial load duke parents: diff changeset	212
21198 dd647e8d1d72 8026328: Setting a breakpoint on invokedynamic crashes the JVM twisti parents: 18507 diff changeset	213	address TemplateInterpreter::_invoke_return_entry[TemplateInterpreter::number_of_return_addrs];
dd647e8d1d72 8026328: Setting a breakpoint on invokedynamic crashes the JVM twisti parents: 18507 diff changeset	214	address TemplateInterpreter::_invokeinterface_return_entry[TemplateInterpreter::number_of_return_addrs];
dd647e8d1d72 8026328: Setting a breakpoint on invokedynamic crashes the JVM twisti parents: 18507 diff changeset	215	address TemplateInterpreter::_invokedynamic_return_entry[TemplateInterpreter::number_of_return_addrs];
1 489c9b5090e2 Initial load duke parents: diff changeset	216
489c9b5090e2 Initial load duke parents: diff changeset	217	DispatchTable TemplateInterpreter::_active_table;
489c9b5090e2 Initial load duke parents: diff changeset	218	DispatchTable TemplateInterpreter::_normal_table;
489c9b5090e2 Initial load duke parents: diff changeset	219	DispatchTable TemplateInterpreter::_safept_table;
489c9b5090e2 Initial load duke parents: diff changeset	220	address TemplateInterpreter::_wentry_point[DispatchTable::length];
489c9b5090e2 Initial load duke parents: diff changeset	221
489c9b5090e2 Initial load duke parents: diff changeset	222	TemplateInterpreterGenerator::TemplateInterpreterGenerator(StubQueue* _code): AbstractInterpreterGenerator(_code) {
489c9b5090e2 Initial load duke parents: diff changeset	223	_unimplemented_bytecode = NULL;
489c9b5090e2 Initial load duke parents: diff changeset	224	_illegal_bytecode_sequence = NULL;
489c9b5090e2 Initial load duke parents: diff changeset	225	}
489c9b5090e2 Initial load duke parents: diff changeset	226
489c9b5090e2 Initial load duke parents: diff changeset	227	static const BasicType types[Interpreter::number_of_result_handlers] = {
489c9b5090e2 Initial load duke parents: diff changeset	228	T_BOOLEAN,
489c9b5090e2 Initial load duke parents: diff changeset	229	T_CHAR ,
489c9b5090e2 Initial load duke parents: diff changeset	230	T_BYTE ,
489c9b5090e2 Initial load duke parents: diff changeset	231	T_SHORT ,
489c9b5090e2 Initial load duke parents: diff changeset	232	T_INT ,
489c9b5090e2 Initial load duke parents: diff changeset	233	T_LONG ,
489c9b5090e2 Initial load duke parents: diff changeset	234	T_VOID ,
489c9b5090e2 Initial load duke parents: diff changeset	235	T_FLOAT ,
489c9b5090e2 Initial load duke parents: diff changeset	236	T_DOUBLE ,
489c9b5090e2 Initial load duke parents: diff changeset	237	T_OBJECT
489c9b5090e2 Initial load duke parents: diff changeset	238	};
489c9b5090e2 Initial load duke parents: diff changeset	239
489c9b5090e2 Initial load duke parents: diff changeset	240	void TemplateInterpreterGenerator::generate_all() {
31620 53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	241	// Loop, in case we need several variants of the interpreter entries
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	242	do {
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	243	if (!CodeCacheExtensions::skip_code_generation()) {
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	244	// bypass code generation when useless
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	245	AbstractInterpreterGenerator::generate_all();
1 489c9b5090e2 Initial load duke parents: diff changeset	246
31620 53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	247	{ CodeletMark cm(_masm, "error exits");
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	248	_unimplemented_bytecode = generate_error_exit("unimplemented bytecode");
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	249	_illegal_bytecode_sequence = generate_error_exit("illegal bytecode sequence - method not verified");
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	250	}
1 489c9b5090e2 Initial load duke parents: diff changeset	251
489c9b5090e2 Initial load duke parents: diff changeset	252	#ifndef PRODUCT
31620 53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	253	if (TraceBytecodes) {
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	254	CodeletMark cm(_masm, "bytecode tracing support");
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	255	Interpreter::_trace_code =
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	256	EntryPoint(
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	257	generate_trace_code(btos),
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	258	generate_trace_code(ctos),
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	259	generate_trace_code(stos),
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	260	generate_trace_code(atos),
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	261	generate_trace_code(itos),
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	262	generate_trace_code(ltos),
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	263	generate_trace_code(ftos),
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	264	generate_trace_code(dtos),
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	265	generate_trace_code(vtos)
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	266	);
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	267	}
1 489c9b5090e2 Initial load duke parents: diff changeset	268	#endif // !PRODUCT
489c9b5090e2 Initial load duke parents: diff changeset	269
31620 53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	270	{ CodeletMark cm(_masm, "return entry points");
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	271	const int index_size = sizeof(u2);
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	272	for (int i = 0; i < Interpreter::number_of_return_entries; i++) {
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	273	Interpreter::_return_entry[i] =
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	274	EntryPoint(
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	275	generate_return_entry_for(itos, i, index_size),
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	276	generate_return_entry_for(itos, i, index_size),
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	277	generate_return_entry_for(itos, i, index_size),
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	278	generate_return_entry_for(atos, i, index_size),
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	279	generate_return_entry_for(itos, i, index_size),
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	280	generate_return_entry_for(ltos, i, index_size),
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	281	generate_return_entry_for(ftos, i, index_size),
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	282	generate_return_entry_for(dtos, i, index_size),
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	283	generate_return_entry_for(vtos, i, index_size)
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	284	);
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	285	}
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	286	}
1 489c9b5090e2 Initial load duke parents: diff changeset	287
31620 53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	288	{ CodeletMark cm(_masm, "invoke return entry points");
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	289	const TosState states[] = {itos, itos, itos, itos, ltos, ftos, dtos, atos, vtos};
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	290	const int invoke_length = Bytecodes::length_for(Bytecodes::_invokestatic);
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	291	const int invokeinterface_length = Bytecodes::length_for(Bytecodes::_invokeinterface);
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	292	const int invokedynamic_length = Bytecodes::length_for(Bytecodes::_invokedynamic);
21198 dd647e8d1d72 8026328: Setting a breakpoint on invokedynamic crashes the JVM twisti parents: 18507 diff changeset	293
31620 53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	294	for (int i = 0; i < Interpreter::number_of_return_addrs; i++) {
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	295	TosState state = states[i];
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	296	Interpreter::_invoke_return_entry[i] = generate_return_entry_for(state, invoke_length, sizeof(u2));
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	297	Interpreter::_invokeinterface_return_entry[i] = generate_return_entry_for(state, invokeinterface_length, sizeof(u2));
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	298	Interpreter::_invokedynamic_return_entry[i] = generate_return_entry_for(state, invokedynamic_length, sizeof(u4));
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	299	}
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	300	}
21198 dd647e8d1d72 8026328: Setting a breakpoint on invokedynamic crashes the JVM twisti parents: 18507 diff changeset	301
31620 53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	302	{ CodeletMark cm(_masm, "earlyret entry points");
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	303	Interpreter::_earlyret_entry =
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	304	EntryPoint(
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	305	generate_earlyret_entry_for(btos),
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	306	generate_earlyret_entry_for(ctos),
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	307	generate_earlyret_entry_for(stos),
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	308	generate_earlyret_entry_for(atos),
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	309	generate_earlyret_entry_for(itos),
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	310	generate_earlyret_entry_for(ltos),
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	311	generate_earlyret_entry_for(ftos),
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	312	generate_earlyret_entry_for(dtos),
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	313	generate_earlyret_entry_for(vtos)
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	314	);
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	315	}
1 489c9b5090e2 Initial load duke parents: diff changeset	316
31620 53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	317	{ CodeletMark cm(_masm, "deoptimization entry points");
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	318	for (int i = 0; i < Interpreter::number_of_deopt_entries; i++) {
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	319	Interpreter::_deopt_entry[i] =
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	320	EntryPoint(
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	321	generate_deopt_entry_for(itos, i),
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	322	generate_deopt_entry_for(itos, i),
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	323	generate_deopt_entry_for(itos, i),
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	324	generate_deopt_entry_for(atos, i),
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	325	generate_deopt_entry_for(itos, i),
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	326	generate_deopt_entry_for(ltos, i),
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	327	generate_deopt_entry_for(ftos, i),
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	328	generate_deopt_entry_for(dtos, i),
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	329	generate_deopt_entry_for(vtos, i)
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	330	);
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	331	}
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	332	}
1 489c9b5090e2 Initial load duke parents: diff changeset	333
31620 53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	334	{ CodeletMark cm(_masm, "result handlers for native calls");
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	335	// The various result converter stublets.
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	336	int is_generated[Interpreter::number_of_result_handlers];
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	337	memset(is_generated, 0, sizeof(is_generated));
1 489c9b5090e2 Initial load duke parents: diff changeset	338
31620 53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	339	for (int i = 0; i < Interpreter::number_of_result_handlers; i++) {
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	340	BasicType type = types[i];
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	341	if (!is_generated[Interpreter::BasicType_as_index(type)]++) {
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	342	Interpreter::_native_abi_to_tosca[Interpreter::BasicType_as_index(type)] = generate_result_handler_for(type);
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	343	}
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	344	}
1 489c9b5090e2 Initial load duke parents: diff changeset	345	}
489c9b5090e2 Initial load duke parents: diff changeset	346
31620 53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	347	{ CodeletMark cm(_masm, "continuation entry points");
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	348	Interpreter::_continuation_entry =
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	349	EntryPoint(
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	350	generate_continuation_for(btos),
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	351	generate_continuation_for(ctos),
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	352	generate_continuation_for(stos),
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	353	generate_continuation_for(atos),
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	354	generate_continuation_for(itos),
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	355	generate_continuation_for(ltos),
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	356	generate_continuation_for(ftos),
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	357	generate_continuation_for(dtos),
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	358	generate_continuation_for(vtos)
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	359	);
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	360	}
1 489c9b5090e2 Initial load duke parents: diff changeset	361
31620 53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	362	{ CodeletMark cm(_masm, "safepoint entry points");
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	363	Interpreter::_safept_entry =
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	364	EntryPoint(
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	365	generate_safept_entry_for(btos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)),
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	366	generate_safept_entry_for(ctos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)),
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	367	generate_safept_entry_for(stos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)),
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	368	generate_safept_entry_for(atos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)),
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	369	generate_safept_entry_for(itos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)),
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	370	generate_safept_entry_for(ltos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)),
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	371	generate_safept_entry_for(ftos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)),
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	372	generate_safept_entry_for(dtos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint)),
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	373	generate_safept_entry_for(vtos, CAST_FROM_FN_PTR(address, InterpreterRuntime::at_safepoint))
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	374	);
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	375	}
1 489c9b5090e2 Initial load duke parents: diff changeset	376
31620 53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	377	{ CodeletMark cm(_masm, "exception handling");
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	378	// (Note: this is not safepoint safe because thread may return to compiled code)
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	379	generate_throw_exception();
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	380	}
1 489c9b5090e2 Initial load duke parents: diff changeset	381
31620 53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	382	{ CodeletMark cm(_masm, "throw exception entrypoints");
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	383	Interpreter::_throw_ArrayIndexOutOfBoundsException_entry = generate_ArrayIndexOutOfBounds_handler("java/lang/ArrayIndexOutOfBoundsException");
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	384	Interpreter::_throw_ArrayStoreException_entry = generate_klass_exception_handler("java/lang/ArrayStoreException" );
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	385	Interpreter::_throw_ArithmeticException_entry = generate_exception_handler("java/lang/ArithmeticException" , "/ by zero");
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	386	Interpreter::_throw_ClassCastException_entry = generate_ClassCastException_handler();
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	387	Interpreter::_throw_NullPointerException_entry = generate_exception_handler("java/lang/NullPointerException" , NULL );
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	388	Interpreter::_throw_StackOverflowError_entry = generate_StackOverflowError_handler();
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	389	}
1 489c9b5090e2 Initial load duke parents: diff changeset	390
489c9b5090e2 Initial load duke parents: diff changeset	391
489c9b5090e2 Initial load duke parents: diff changeset	392
31620 53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	393	#define method_entry(kind) \
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	394	{ CodeletMark cm(_masm, "method entry point (kind = " #kind ")"); \
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	395	Interpreter::_entry_table[Interpreter::kind] = ((InterpreterGenerator*)this)->generate_method_entry(Interpreter::kind); \
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	396	}
1 489c9b5090e2 Initial load duke parents: diff changeset	397
31620 53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	398	// all non-native method kinds
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	399	method_entry(zerolocals)
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	400	method_entry(zerolocals_synchronized)
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	401	method_entry(empty)
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	402	method_entry(accessor)
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	403	method_entry(abstract)
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	404	method_entry(java_lang_math_sin )
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	405	method_entry(java_lang_math_cos )
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	406	method_entry(java_lang_math_tan )
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	407	method_entry(java_lang_math_abs )
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	408	method_entry(java_lang_math_sqrt )
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	409	method_entry(java_lang_math_log )
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	410	method_entry(java_lang_math_log10)
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	411	method_entry(java_lang_math_exp )
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	412	method_entry(java_lang_math_pow )
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	413	method_entry(java_lang_ref_reference_get)
1 489c9b5090e2 Initial load duke parents: diff changeset	414
31620 53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	415	if (UseCRC32Intrinsics) {
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	416	method_entry(java_util_zip_CRC32_update)
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	417	method_entry(java_util_zip_CRC32_updateBytes)
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	418	method_entry(java_util_zip_CRC32_updateByteBuffer)
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	419	}
18507 61bfc8995bb3 7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32 drchase parents: 14294 diff changeset	420
31620 53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	421	initialize_method_handle_entries();
13391 30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 12739 diff changeset	422
31620 53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	423	// all native method kinds (must be one contiguous block)
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	424	Interpreter::_native_entry_begin = Interpreter::code()->code_end();
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	425	method_entry(native)
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	426	method_entry(native_synchronized)
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	427	Interpreter::_native_entry_end = Interpreter::code()->code_end();
1 489c9b5090e2 Initial load duke parents: diff changeset	428
489c9b5090e2 Initial load duke parents: diff changeset	429	#undef method_entry
489c9b5090e2 Initial load duke parents: diff changeset	430
31620 53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	431	// Bytecodes
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	432	set_entry_points_for_all_bytes();
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	433	}
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	434	} while (CodeCacheExtensions::needs_other_interpreter_variant());
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	435
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	436	// installation of code in other places in the runtime
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	437	// (ExcutableCodeManager calls not needed to copy the entries)
1 489c9b5090e2 Initial load duke parents: diff changeset	438	set_safepoints_for_all_bytes();
489c9b5090e2 Initial load duke parents: diff changeset	439	}
489c9b5090e2 Initial load duke parents: diff changeset	440
489c9b5090e2 Initial load duke parents: diff changeset	441	//------------------------------------------------------------------------------------------------------------------------
489c9b5090e2 Initial load duke parents: diff changeset	442
489c9b5090e2 Initial load duke parents: diff changeset	443	address TemplateInterpreterGenerator::generate_error_exit(const char* msg) {
489c9b5090e2 Initial load duke parents: diff changeset	444	address entry = __ pc();
489c9b5090e2 Initial load duke parents: diff changeset	445	__ stop(msg);
489c9b5090e2 Initial load duke parents: diff changeset	446	return entry;
489c9b5090e2 Initial load duke parents: diff changeset	447	}
489c9b5090e2 Initial load duke parents: diff changeset	448
489c9b5090e2 Initial load duke parents: diff changeset	449
489c9b5090e2 Initial load duke parents: diff changeset	450	//------------------------------------------------------------------------------------------------------------------------
489c9b5090e2 Initial load duke parents: diff changeset	451
489c9b5090e2 Initial load duke parents: diff changeset	452	void TemplateInterpreterGenerator::set_entry_points_for_all_bytes() {
489c9b5090e2 Initial load duke parents: diff changeset	453	for (int i = 0; i < DispatchTable::length; i++) {
489c9b5090e2 Initial load duke parents: diff changeset	454	Bytecodes::Code code = (Bytecodes::Code)i;
489c9b5090e2 Initial load duke parents: diff changeset	455	if (Bytecodes::is_defined(code)) {
489c9b5090e2 Initial load duke parents: diff changeset	456	set_entry_points(code);
489c9b5090e2 Initial load duke parents: diff changeset	457	} else {
489c9b5090e2 Initial load duke parents: diff changeset	458	set_unimplemented(i);
489c9b5090e2 Initial load duke parents: diff changeset	459	}
489c9b5090e2 Initial load duke parents: diff changeset	460	}
489c9b5090e2 Initial load duke parents: diff changeset	461	}
489c9b5090e2 Initial load duke parents: diff changeset	462
489c9b5090e2 Initial load duke parents: diff changeset	463
489c9b5090e2 Initial load duke parents: diff changeset	464	void TemplateInterpreterGenerator::set_safepoints_for_all_bytes() {
489c9b5090e2 Initial load duke parents: diff changeset	465	for (int i = 0; i < DispatchTable::length; i++) {
489c9b5090e2 Initial load duke parents: diff changeset	466	Bytecodes::Code code = (Bytecodes::Code)i;
489c9b5090e2 Initial load duke parents: diff changeset	467	if (Bytecodes::is_defined(code)) Interpreter::_safept_table.set_entry(code, Interpreter::_safept_entry);
489c9b5090e2 Initial load duke parents: diff changeset	468	}
489c9b5090e2 Initial load duke parents: diff changeset	469	}
489c9b5090e2 Initial load duke parents: diff changeset	470
489c9b5090e2 Initial load duke parents: diff changeset	471
489c9b5090e2 Initial load duke parents: diff changeset	472	void TemplateInterpreterGenerator::set_unimplemented(int i) {
489c9b5090e2 Initial load duke parents: diff changeset	473	address e = _unimplemented_bytecode;
489c9b5090e2 Initial load duke parents: diff changeset	474	EntryPoint entry(e, e, e, e, e, e, e, e, e);
489c9b5090e2 Initial load duke parents: diff changeset	475	Interpreter::_normal_table.set_entry(i, entry);
489c9b5090e2 Initial load duke parents: diff changeset	476	Interpreter::_wentry_point[i] = _unimplemented_bytecode;
489c9b5090e2 Initial load duke parents: diff changeset	477	}
489c9b5090e2 Initial load duke parents: diff changeset	478
489c9b5090e2 Initial load duke parents: diff changeset	479
489c9b5090e2 Initial load duke parents: diff changeset	480	void TemplateInterpreterGenerator::set_entry_points(Bytecodes::Code code) {
31620 53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	481	if (CodeCacheExtensions::skip_template_interpreter_entries(code)) {
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	482	return;
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	483	}
1 489c9b5090e2 Initial load duke parents: diff changeset	484	CodeletMark cm(_masm, Bytecodes::name(code), code);
489c9b5090e2 Initial load duke parents: diff changeset	485	// initialize entry points
489c9b5090e2 Initial load duke parents: diff changeset	486	assert(_unimplemented_bytecode != NULL, "should have been generated before");
489c9b5090e2 Initial load duke parents: diff changeset	487	assert(_illegal_bytecode_sequence != NULL, "should have been generated before");
489c9b5090e2 Initial load duke parents: diff changeset	488	address bep = _illegal_bytecode_sequence;
489c9b5090e2 Initial load duke parents: diff changeset	489	address cep = _illegal_bytecode_sequence;
489c9b5090e2 Initial load duke parents: diff changeset	490	address sep = _illegal_bytecode_sequence;
489c9b5090e2 Initial load duke parents: diff changeset	491	address aep = _illegal_bytecode_sequence;
489c9b5090e2 Initial load duke parents: diff changeset	492	address iep = _illegal_bytecode_sequence;
489c9b5090e2 Initial load duke parents: diff changeset	493	address lep = _illegal_bytecode_sequence;
489c9b5090e2 Initial load duke parents: diff changeset	494	address fep = _illegal_bytecode_sequence;
489c9b5090e2 Initial load duke parents: diff changeset	495	address dep = _illegal_bytecode_sequence;
489c9b5090e2 Initial load duke parents: diff changeset	496	address vep = _unimplemented_bytecode;
489c9b5090e2 Initial load duke parents: diff changeset	497	address wep = _unimplemented_bytecode;
489c9b5090e2 Initial load duke parents: diff changeset	498	// code for short & wide version of bytecode
489c9b5090e2 Initial load duke parents: diff changeset	499	if (Bytecodes::is_defined(code)) {
489c9b5090e2 Initial load duke parents: diff changeset	500	Template* t = TemplateTable::template_for(code);
489c9b5090e2 Initial load duke parents: diff changeset	501	assert(t->is_valid(), "just checking");
489c9b5090e2 Initial load duke parents: diff changeset	502	set_short_entry_points(t, bep, cep, sep, aep, iep, lep, fep, dep, vep);
489c9b5090e2 Initial load duke parents: diff changeset	503	}
489c9b5090e2 Initial load duke parents: diff changeset	504	if (Bytecodes::wide_is_defined(code)) {
489c9b5090e2 Initial load duke parents: diff changeset	505	Template* t = TemplateTable::template_for_wide(code);
489c9b5090e2 Initial load duke parents: diff changeset	506	assert(t->is_valid(), "just checking");
489c9b5090e2 Initial load duke parents: diff changeset	507	set_wide_entry_point(t, wep);
489c9b5090e2 Initial load duke parents: diff changeset	508	}
489c9b5090e2 Initial load duke parents: diff changeset	509	// set entry points
489c9b5090e2 Initial load duke parents: diff changeset	510	EntryPoint entry(bep, cep, sep, aep, iep, lep, fep, dep, vep);
489c9b5090e2 Initial load duke parents: diff changeset	511	Interpreter::_normal_table.set_entry(code, entry);
489c9b5090e2 Initial load duke parents: diff changeset	512	Interpreter::_wentry_point[code] = wep;
31620 53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter bdelsart parents: 25950 diff changeset	513	CodeCacheExtensions::completed_template_interpreter_entries(_masm, code);
1 489c9b5090e2 Initial load duke parents: diff changeset	514	}
489c9b5090e2 Initial load duke parents: diff changeset	515
489c9b5090e2 Initial load duke parents: diff changeset	516
489c9b5090e2 Initial load duke parents: diff changeset	517	void TemplateInterpreterGenerator::set_wide_entry_point(Template* t, address& wep) {
489c9b5090e2 Initial load duke parents: diff changeset	518	assert(t->is_valid(), "template must exist");
5402 c51fd0c1d005 6888953: some calls to function-like macros are missing semicolons jcoomes parents: 4441 diff changeset	519	assert(t->tos_in() == vtos, "only vtos tos_in supported for wide instructions");
1 489c9b5090e2 Initial load duke parents: diff changeset	520	wep = __ pc(); generate_and_dispatch(t);
489c9b5090e2 Initial load duke parents: diff changeset	521	}
489c9b5090e2 Initial load duke parents: diff changeset	522
489c9b5090e2 Initial load duke parents: diff changeset	523
489c9b5090e2 Initial load duke parents: diff changeset	524	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) {
489c9b5090e2 Initial load duke parents: diff changeset	525	assert(t->is_valid(), "template must exist");
489c9b5090e2 Initial load duke parents: diff changeset	526	switch (t->tos_in()) {
4441 1dfb3f44c62a 6902000: use ShouldNotReachHere() for btos/ctos/stos in TemplateInterpreterGenerator::set_short_entry_points twisti parents: 4429 diff changeset	527	case btos:
1dfb3f44c62a 6902000: use ShouldNotReachHere() for btos/ctos/stos in TemplateInterpreterGenerator::set_short_entry_points twisti parents: 4429 diff changeset	528	case ctos:
1dfb3f44c62a 6902000: use ShouldNotReachHere() for btos/ctos/stos in TemplateInterpreterGenerator::set_short_entry_points twisti parents: 4429 diff changeset	529	case stos:
1dfb3f44c62a 6902000: use ShouldNotReachHere() for btos/ctos/stos in TemplateInterpreterGenerator::set_short_entry_points twisti parents: 4429 diff changeset	530	ShouldNotReachHere(); // btos/ctos/stos should use itos.
1dfb3f44c62a 6902000: use ShouldNotReachHere() for btos/ctos/stos in TemplateInterpreterGenerator::set_short_entry_points twisti parents: 4429 diff changeset	531	break;
1 489c9b5090e2 Initial load duke parents: diff changeset	532	case atos: vep = __ pc(); __ pop(atos); aep = __ pc(); generate_and_dispatch(t); break;
489c9b5090e2 Initial load duke parents: diff changeset	533	case itos: vep = __ pc(); __ pop(itos); iep = __ pc(); generate_and_dispatch(t); break;
489c9b5090e2 Initial load duke parents: diff changeset	534	case ltos: vep = __ pc(); __ pop(ltos); lep = __ pc(); generate_and_dispatch(t); break;
489c9b5090e2 Initial load duke parents: diff changeset	535	case ftos: vep = __ pc(); __ pop(ftos); fep = __ pc(); generate_and_dispatch(t); break;
489c9b5090e2 Initial load duke parents: diff changeset	536	case dtos: vep = __ pc(); __ pop(dtos); dep = __ pc(); generate_and_dispatch(t); break;
489c9b5090e2 Initial load duke parents: diff changeset	537	case vtos: set_vtos_entry_points(t, bep, cep, sep, aep, iep, lep, fep, dep, vep); break;
489c9b5090e2 Initial load duke parents: diff changeset	538	default : ShouldNotReachHere(); break;
489c9b5090e2 Initial load duke parents: diff changeset	539	}
489c9b5090e2 Initial load duke parents: diff changeset	540	}
489c9b5090e2 Initial load duke parents: diff changeset	541
489c9b5090e2 Initial load duke parents: diff changeset	542
489c9b5090e2 Initial load duke parents: diff changeset	543	//------------------------------------------------------------------------------------------------------------------------
489c9b5090e2 Initial load duke parents: diff changeset	544
489c9b5090e2 Initial load duke parents: diff changeset	545	void TemplateInterpreterGenerator::generate_and_dispatch(Template* t, TosState tos_out) {
489c9b5090e2 Initial load duke parents: diff changeset	546	if (PrintBytecodeHistogram) histogram_bytecode(t);
489c9b5090e2 Initial load duke parents: diff changeset	547	#ifndef PRODUCT
489c9b5090e2 Initial load duke parents: diff changeset	548	// debugging code
489c9b5090e2 Initial load duke parents: diff changeset	549	if (CountBytecodes \|\| TraceBytecodes \|\| StopInterpreterAt > 0) count_bytecode();
489c9b5090e2 Initial load duke parents: diff changeset	550	if (PrintBytecodePairHistogram) histogram_bytecode_pair(t);
489c9b5090e2 Initial load duke parents: diff changeset	551	if (TraceBytecodes) trace_bytecode(t);
489c9b5090e2 Initial load duke parents: diff changeset	552	if (StopInterpreterAt > 0) stop_interpreter_at();
489c9b5090e2 Initial load duke parents: diff changeset	553	__ verify_FPU(1, t->tos_in());
489c9b5090e2 Initial load duke parents: diff changeset	554	#endif // !PRODUCT
489c9b5090e2 Initial load duke parents: diff changeset	555	int step;
489c9b5090e2 Initial load duke parents: diff changeset	556	if (!t->does_dispatch()) {
489c9b5090e2 Initial load duke parents: diff changeset	557	step = t->is_wide() ? Bytecodes::wide_length_for(t->bytecode()) : Bytecodes::length_for(t->bytecode());
489c9b5090e2 Initial load duke parents: diff changeset	558	if (tos_out == ilgl) tos_out = t->tos_out();
489c9b5090e2 Initial load duke parents: diff changeset	559	// compute bytecode size
489c9b5090e2 Initial load duke parents: diff changeset	560	assert(step > 0, "just checkin'");
489c9b5090e2 Initial load duke parents: diff changeset	561	// setup stuff for dispatching next bytecode
489c9b5090e2 Initial load duke parents: diff changeset	562	if (ProfileInterpreter && VerifyDataPointer
13728 882756847a04 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 13391 diff changeset	563	&& MethodData::bytecode_has_profile(t->bytecode())) {
1 489c9b5090e2 Initial load duke parents: diff changeset	564	__ verify_method_data_pointer();
489c9b5090e2 Initial load duke parents: diff changeset	565	}
489c9b5090e2 Initial load duke parents: diff changeset	566	__ dispatch_prolog(tos_out, step);
489c9b5090e2 Initial load duke parents: diff changeset	567	}
489c9b5090e2 Initial load duke parents: diff changeset	568	// generate template
489c9b5090e2 Initial load duke parents: diff changeset	569	t->generate(_masm);
489c9b5090e2 Initial load duke parents: diff changeset	570	// advance
489c9b5090e2 Initial load duke parents: diff changeset	571	if (t->does_dispatch()) {
489c9b5090e2 Initial load duke parents: diff changeset	572	#ifdef ASSERT
489c9b5090e2 Initial load duke parents: diff changeset	573	// make sure execution doesn't go beyond this point if code is broken
489c9b5090e2 Initial load duke parents: diff changeset	574	__ should_not_reach_here();
489c9b5090e2 Initial load duke parents: diff changeset	575	#endif // ASSERT
489c9b5090e2 Initial load duke parents: diff changeset	576	} else {
489c9b5090e2 Initial load duke parents: diff changeset	577	// dispatch to next bytecode
489c9b5090e2 Initial load duke parents: diff changeset	578	__ dispatch_epilog(tos_out, step);
489c9b5090e2 Initial load duke parents: diff changeset	579	}
489c9b5090e2 Initial load duke parents: diff changeset	580	}
489c9b5090e2 Initial load duke parents: diff changeset	581
489c9b5090e2 Initial load duke parents: diff changeset	582	//------------------------------------------------------------------------------------------------------------------------
489c9b5090e2 Initial load duke parents: diff changeset	583	// Entry points
489c9b5090e2 Initial load duke parents: diff changeset	584
21198 dd647e8d1d72 8026328: Setting a breakpoint on invokedynamic crashes the JVM twisti parents: 18507 diff changeset	585	/**
dd647e8d1d72 8026328: Setting a breakpoint on invokedynamic crashes the JVM twisti parents: 18507 diff changeset	586	* Returns the return entry table for the given invoke bytecode.
dd647e8d1d72 8026328: Setting a breakpoint on invokedynamic crashes the JVM twisti parents: 18507 diff changeset	587	*/
dd647e8d1d72 8026328: Setting a breakpoint on invokedynamic crashes the JVM twisti parents: 18507 diff changeset	588	address* TemplateInterpreter::invoke_return_entry_table_for(Bytecodes::Code code) {
dd647e8d1d72 8026328: Setting a breakpoint on invokedynamic crashes the JVM twisti parents: 18507 diff changeset	589	switch (code) {
dd647e8d1d72 8026328: Setting a breakpoint on invokedynamic crashes the JVM twisti parents: 18507 diff changeset	590	case Bytecodes::_invokestatic:
dd647e8d1d72 8026328: Setting a breakpoint on invokedynamic crashes the JVM twisti parents: 18507 diff changeset	591	case Bytecodes::_invokespecial:
dd647e8d1d72 8026328: Setting a breakpoint on invokedynamic crashes the JVM twisti parents: 18507 diff changeset	592	case Bytecodes::_invokevirtual:
dd647e8d1d72 8026328: Setting a breakpoint on invokedynamic crashes the JVM twisti parents: 18507 diff changeset	593	case Bytecodes::_invokehandle:
dd647e8d1d72 8026328: Setting a breakpoint on invokedynamic crashes the JVM twisti parents: 18507 diff changeset	594	return Interpreter::invoke_return_entry_table();
dd647e8d1d72 8026328: Setting a breakpoint on invokedynamic crashes the JVM twisti parents: 18507 diff changeset	595	case Bytecodes::_invokeinterface:
dd647e8d1d72 8026328: Setting a breakpoint on invokedynamic crashes the JVM twisti parents: 18507 diff changeset	596	return Interpreter::invokeinterface_return_entry_table();
dd647e8d1d72 8026328: Setting a breakpoint on invokedynamic crashes the JVM twisti parents: 18507 diff changeset	597	case Bytecodes::_invokedynamic:
dd647e8d1d72 8026328: Setting a breakpoint on invokedynamic crashes the JVM twisti parents: 18507 diff changeset	598	return Interpreter::invokedynamic_return_entry_table();
dd647e8d1d72 8026328: Setting a breakpoint on invokedynamic crashes the JVM twisti parents: 18507 diff changeset	599	default:
dd647e8d1d72 8026328: Setting a breakpoint on invokedynamic crashes the JVM twisti parents: 18507 diff changeset	600	fatal(err_msg("invalid bytecode: %s", Bytecodes::name(code)));
dd647e8d1d72 8026328: Setting a breakpoint on invokedynamic crashes the JVM twisti parents: 18507 diff changeset	601	return NULL;
dd647e8d1d72 8026328: Setting a breakpoint on invokedynamic crashes the JVM twisti parents: 18507 diff changeset	602	}
dd647e8d1d72 8026328: Setting a breakpoint on invokedynamic crashes the JVM twisti parents: 18507 diff changeset	603	}
dd647e8d1d72 8026328: Setting a breakpoint on invokedynamic crashes the JVM twisti parents: 18507 diff changeset	604
dd647e8d1d72 8026328: Setting a breakpoint on invokedynamic crashes the JVM twisti parents: 18507 diff changeset	605	/**
dd647e8d1d72 8026328: Setting a breakpoint on invokedynamic crashes the JVM twisti parents: 18507 diff changeset	606	* Returns the return entry address for the given top-of-stack state and bytecode.
dd647e8d1d72 8026328: Setting a breakpoint on invokedynamic crashes the JVM twisti parents: 18507 diff changeset	607	*/
dd647e8d1d72 8026328: Setting a breakpoint on invokedynamic crashes the JVM twisti parents: 18507 diff changeset	608	address TemplateInterpreter::return_entry(TosState state, int length, Bytecodes::Code code) {
1 489c9b5090e2 Initial load duke parents: diff changeset	609	guarantee(0 <= length && length < Interpreter::number_of_return_entries, "illegal length");
21198 dd647e8d1d72 8026328: Setting a breakpoint on invokedynamic crashes the JVM twisti parents: 18507 diff changeset	610	const int index = TosState_as_index(state);
dd647e8d1d72 8026328: Setting a breakpoint on invokedynamic crashes the JVM twisti parents: 18507 diff changeset	611	switch (code) {
dd647e8d1d72 8026328: Setting a breakpoint on invokedynamic crashes the JVM twisti parents: 18507 diff changeset	612	case Bytecodes::_invokestatic:
dd647e8d1d72 8026328: Setting a breakpoint on invokedynamic crashes the JVM twisti parents: 18507 diff changeset	613	case Bytecodes::_invokespecial:
dd647e8d1d72 8026328: Setting a breakpoint on invokedynamic crashes the JVM twisti parents: 18507 diff changeset	614	case Bytecodes::_invokevirtual:
dd647e8d1d72 8026328: Setting a breakpoint on invokedynamic crashes the JVM twisti parents: 18507 diff changeset	615	case Bytecodes::_invokehandle:
dd647e8d1d72 8026328: Setting a breakpoint on invokedynamic crashes the JVM twisti parents: 18507 diff changeset	616	return _invoke_return_entry[index];
dd647e8d1d72 8026328: Setting a breakpoint on invokedynamic crashes the JVM twisti parents: 18507 diff changeset	617	case Bytecodes::_invokeinterface:
dd647e8d1d72 8026328: Setting a breakpoint on invokedynamic crashes the JVM twisti parents: 18507 diff changeset	618	return _invokeinterface_return_entry[index];
dd647e8d1d72 8026328: Setting a breakpoint on invokedynamic crashes the JVM twisti parents: 18507 diff changeset	619	case Bytecodes::_invokedynamic:
dd647e8d1d72 8026328: Setting a breakpoint on invokedynamic crashes the JVM twisti parents: 18507 diff changeset	620	return _invokedynamic_return_entry[index];
dd647e8d1d72 8026328: Setting a breakpoint on invokedynamic crashes the JVM twisti parents: 18507 diff changeset	621	default:
dd647e8d1d72 8026328: Setting a breakpoint on invokedynamic crashes the JVM twisti parents: 18507 diff changeset	622	assert(!Bytecodes::is_invoke(code), err_msg("invoke instructions should be handled separately: %s", Bytecodes::name(code)));
dd647e8d1d72 8026328: Setting a breakpoint on invokedynamic crashes the JVM twisti parents: 18507 diff changeset	623	return _return_entry[length].entry(state);
dd647e8d1d72 8026328: Setting a breakpoint on invokedynamic crashes the JVM twisti parents: 18507 diff changeset	624	}
1 489c9b5090e2 Initial load duke parents: diff changeset	625	}
489c9b5090e2 Initial load duke parents: diff changeset	626
489c9b5090e2 Initial load duke parents: diff changeset	627
489c9b5090e2 Initial load duke parents: diff changeset	628	address TemplateInterpreter::deopt_entry(TosState state, int length) {
489c9b5090e2 Initial load duke parents: diff changeset	629	guarantee(0 <= length && length < Interpreter::number_of_deopt_entries, "illegal length");
489c9b5090e2 Initial load duke parents: diff changeset	630	return _deopt_entry[length].entry(state);
489c9b5090e2 Initial load duke parents: diff changeset	631	}
489c9b5090e2 Initial load duke parents: diff changeset	632
489c9b5090e2 Initial load duke parents: diff changeset	633	//------------------------------------------------------------------------------------------------------------------------
489c9b5090e2 Initial load duke parents: diff changeset	634	// Suport for invokes
489c9b5090e2 Initial load duke parents: diff changeset	635
489c9b5090e2 Initial load duke parents: diff changeset	636	int TemplateInterpreter::TosState_as_index(TosState state) {
489c9b5090e2 Initial load duke parents: diff changeset	637	assert( state < number_of_states , "Invalid state in TosState_as_index");
489c9b5090e2 Initial load duke parents: diff changeset	638	assert(0 <= (int)state && (int)state < TemplateInterpreter::number_of_return_addrs, "index out of bounds");
489c9b5090e2 Initial load duke parents: diff changeset	639	return (int)state;
489c9b5090e2 Initial load duke parents: diff changeset	640	}
489c9b5090e2 Initial load duke parents: diff changeset	641
489c9b5090e2 Initial load duke parents: diff changeset	642
489c9b5090e2 Initial load duke parents: diff changeset	643	//------------------------------------------------------------------------------------------------------------------------
489c9b5090e2 Initial load duke parents: diff changeset	644	// Safepoint suppport
489c9b5090e2 Initial load duke parents: diff changeset	645
489c9b5090e2 Initial load duke parents: diff changeset	646	static inline void copy_table(address* from, address* to, int size) {
489c9b5090e2 Initial load duke parents: diff changeset	647	// Copy non-overlapping tables. The copy has to occur word wise for MT safety.
489c9b5090e2 Initial load duke parents: diff changeset	648	while (size-- > 0) to++ = from++;
489c9b5090e2 Initial load duke parents: diff changeset	649	}
489c9b5090e2 Initial load duke parents: diff changeset	650
489c9b5090e2 Initial load duke parents: diff changeset	651	void TemplateInterpreter::notice_safepoints() {
489c9b5090e2 Initial load duke parents: diff changeset	652	if (!_notice_safepoints) {
489c9b5090e2 Initial load duke parents: diff changeset	653	// switch to safepoint dispatch table
489c9b5090e2 Initial load duke parents: diff changeset	654	_notice_safepoints = true;
489c9b5090e2 Initial load duke parents: diff changeset	655	copy_table((address)&_safept_table, (address)&_active_table, sizeof(_active_table) / sizeof(address));
489c9b5090e2 Initial load duke parents: diff changeset	656	}
489c9b5090e2 Initial load duke parents: diff changeset	657	}
489c9b5090e2 Initial load duke parents: diff changeset	658
489c9b5090e2 Initial load duke parents: diff changeset	659	// switch from the dispatch table which notices safepoints back to the
489c9b5090e2 Initial load duke parents: diff changeset	660	// normal dispatch table. So that we can notice single stepping points,
489c9b5090e2 Initial load duke parents: diff changeset	661	// keep the safepoint dispatch table if we are single stepping in JVMTI.
489c9b5090e2 Initial load duke parents: diff changeset	662	// Note that the should_post_single_step test is exactly as fast as the
489c9b5090e2 Initial load duke parents: diff changeset	663	// JvmtiExport::_enabled test and covers both cases.
489c9b5090e2 Initial load duke parents: diff changeset	664	void TemplateInterpreter::ignore_safepoints() {
489c9b5090e2 Initial load duke parents: diff changeset	665	if (_notice_safepoints) {
489c9b5090e2 Initial load duke parents: diff changeset	666	if (!JvmtiExport::should_post_single_step()) {
489c9b5090e2 Initial load duke parents: diff changeset	667	// switch to normal dispatch table
489c9b5090e2 Initial load duke parents: diff changeset	668	_notice_safepoints = false;
489c9b5090e2 Initial load duke parents: diff changeset	669	copy_table((address)&_normal_table, (address)&_active_table, sizeof(_active_table) / sizeof(address));
489c9b5090e2 Initial load duke parents: diff changeset	670	}
489c9b5090e2 Initial load duke parents: diff changeset	671	}
489c9b5090e2 Initial load duke parents: diff changeset	672	}
489c9b5090e2 Initial load duke parents: diff changeset	673
3600 27aa4477d039 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot cfang parents: 2570 diff changeset	674	//------------------------------------------------------------------------------------------------------------------------
27aa4477d039 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot cfang parents: 2570 diff changeset	675	// Deoptimization support
1 489c9b5090e2 Initial load duke parents: diff changeset	676
3600 27aa4477d039 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot cfang parents: 2570 diff changeset	677	// If deoptimization happens, this function returns the point of next bytecode to continue execution
13728 882756847a04 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 13391 diff changeset	678	address TemplateInterpreter::deopt_continue_after_entry(Method* method, address bcp, int callee_parameters, bool is_top_frame) {
3600 27aa4477d039 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot cfang parents: 2570 diff changeset	679	return AbstractInterpreter::deopt_continue_after_entry(method, bcp, callee_parameters, is_top_frame);
27aa4477d039 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot cfang parents: 2570 diff changeset	680	}
1 489c9b5090e2 Initial load duke parents: diff changeset	681
3600 27aa4477d039 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot cfang parents: 2570 diff changeset	682	// If deoptimization happens, this function returns the point where the interpreter reexecutes
27aa4477d039 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot cfang parents: 2570 diff changeset	683	// the bytecode.
27aa4477d039 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot cfang parents: 2570 diff changeset	684	// Note: Bytecodes::_athrow (C1 only) and Bytecodes::_return are the special cases
27aa4477d039 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot cfang parents: 2570 diff changeset	685	// that do not return "Interpreter::deopt_entry(vtos, 0)"
13728 882756847a04 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 13391 diff changeset	686	address TemplateInterpreter::deopt_reexecute_entry(Method* method, address bcp) {
1 489c9b5090e2 Initial load duke parents: diff changeset	687	assert(method->contains(bcp), "just checkin'");
7913 dd096a83bdbb 4926272: methodOopDesc::method_from_bcp is unsafe never parents: 7397 diff changeset	688	Bytecodes::Code code = Bytecodes::java_code_at(method, bcp);
1 489c9b5090e2 Initial load duke parents: diff changeset	689	if (code == Bytecodes::_return) {
3600 27aa4477d039 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot cfang parents: 2570 diff changeset	690	// This is used for deopt during registration of finalizers
27aa4477d039 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot cfang parents: 2570 diff changeset	691	// during Object.<init>. We simply need to resume execution at
27aa4477d039 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot cfang parents: 2570 diff changeset	692	// the standard return vtos bytecode to pop the frame normally.
27aa4477d039 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot cfang parents: 2570 diff changeset	693	// reexecuting the real bytecode would cause double registration
27aa4477d039 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot cfang parents: 2570 diff changeset	694	// of the finalizable object.
27aa4477d039 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot cfang parents: 2570 diff changeset	695	return _normal_table.entry(Bytecodes::_return).entry(vtos);
1 489c9b5090e2 Initial load duke parents: diff changeset	696	} else {
3600 27aa4477d039 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot cfang parents: 2570 diff changeset	697	return AbstractInterpreter::deopt_reexecute_entry(method, bcp);
27aa4477d039 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot cfang parents: 2570 diff changeset	698	}
27aa4477d039 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot cfang parents: 2570 diff changeset	699	}
27aa4477d039 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot cfang parents: 2570 diff changeset	700
27aa4477d039 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot cfang parents: 2570 diff changeset	701	// If deoptimization happens, the interpreter should reexecute this bytecode.
27aa4477d039 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot cfang parents: 2570 diff changeset	702	// This function mainly helps the compilers to set up the reexecute bit.
27aa4477d039 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot cfang parents: 2570 diff changeset	703	bool TemplateInterpreter::bytecode_should_reexecute(Bytecodes::Code code) {
27aa4477d039 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot cfang parents: 2570 diff changeset	704	if (code == Bytecodes::_return) {
27aa4477d039 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot cfang parents: 2570 diff changeset	705	//Yes, we consider Bytecodes::_return as a special case of reexecution
27aa4477d039 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot cfang parents: 2570 diff changeset	706	return true;
27aa4477d039 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot cfang parents: 2570 diff changeset	707	} else {
27aa4477d039 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot cfang parents: 2570 diff changeset	708	return AbstractInterpreter::bytecode_should_reexecute(code);
1 489c9b5090e2 Initial load duke parents: diff changeset	709	}
489c9b5090e2 Initial load duke parents: diff changeset	710	}
489c9b5090e2 Initial load duke parents: diff changeset	711
489c9b5090e2 Initial load duke parents: diff changeset	712	#endif // !CC_INTERP

author	bdelsart
	Wed, 01 Jul 2015 10:53:26 +0200
changeset 31620	53be635ad49c
parent 25950	b5c40ed1d349
child 32391	01e2f5e916c7
permissions	-rw-r--r--