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

src/share/vm/runtime/sharedRuntime.hpp@d2ede61b7a12 (annotated)

src/share/vm/runtime/sharedRuntime.hpp

Wed, 11 Aug 2010 05:51:21 -0700

author

twisti

date

Wed, 11 Aug 2010 05:51:21 -0700

changeset 2047

d2ede61b7a12

parent 2036

126ea7725993

child 2103

3e8fbc61cee8

permissions

-rw-r--r--

6976186: integrate Shark HotSpot changes
Summary: Shark is a JIT compiler for Zero that uses the LLVM compiler infrastructure.
Reviewed-by: kvn, twisti
Contributed-by: Gary Benson <gbenson@redhat.com>

duke@435	1	/*
trims@1907	2	* Copyright (c) 1997, 2010, Oracle and/or its affiliates. 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	*
trims@1907	19	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
trims@1907	20	* or visit www.oracle.com if you need additional information or have any
trims@1907	21	* questions.
duke@435	22	*
duke@435	23	*/
duke@435	24
duke@435	25	class AdapterHandlerEntry;
never@1622	26	class AdapterHandlerTable;
never@1622	27	class AdapterFingerPrint;
duke@435	28	class vframeStream;
duke@435	29
duke@435	30	// Runtime is the base class for various runtime interfaces
duke@435	31	// (InterpreterRuntime, CompilerRuntime, etc.). It provides
duke@435	32	// shared functionality such as exception forwarding (C++ to
duke@435	33	// Java exceptions), locking/unlocking mechanisms, statistical
duke@435	34	// information, etc.
duke@435	35
duke@435	36	class SharedRuntime: AllStatic {
duke@435	37	private:
duke@435	38	static methodHandle resolve_sub_helper(JavaThread *thread,
duke@435	39	bool is_virtual,
duke@435	40	bool is_optimized, TRAPS);
duke@435	41
duke@435	42	// Shared stub locations
duke@435	43
duke@435	44	static RuntimeStub* _wrong_method_blob;
duke@435	45	static RuntimeStub* _ic_miss_blob;
duke@435	46	static RuntimeStub* _resolve_opt_virtual_call_blob;
duke@435	47	static RuntimeStub* _resolve_virtual_call_blob;
duke@435	48	static RuntimeStub* _resolve_static_call_blob;
duke@435	49
duke@435	50	static SafepointBlob* _polling_page_safepoint_handler_blob;
duke@435	51	static SafepointBlob* _polling_page_return_handler_blob;
duke@435	52	#ifdef COMPILER2
duke@435	53	static ExceptionBlob* _exception_blob;
duke@435	54	static UncommonTrapBlob* _uncommon_trap_blob;
duke@435	55	#endif // COMPILER2
duke@435	56
duke@435	57	#ifndef PRODUCT
duke@435	58
duke@435	59	// Counters
duke@435	60	static int _nof_megamorphic_calls; // total # of megamorphic calls (through vtable)
duke@435	61
duke@435	62	#endif // !PRODUCT
duke@435	63	public:
kamg@551	64
kamg@551	65	// max bytes for each dtrace string parameter
kamg@551	66	enum { max_dtrace_string_size = 256 };
kamg@551	67
duke@435	68	// The following arithmetic routines are used on platforms that do
duke@435	69	// not have machine instructions to implement their functionality.
duke@435	70	// Do not remove these.
duke@435	71
duke@435	72	// long arithmetics
duke@435	73	static jlong lmul(jlong y, jlong x);
duke@435	74	static jlong ldiv(jlong y, jlong x);
duke@435	75	static jlong lrem(jlong y, jlong x);
duke@435	76
duke@435	77	// float and double remainder
duke@435	78	static jfloat frem(jfloat x, jfloat y);
duke@435	79	static jdouble drem(jdouble x, jdouble y);
duke@435	80
bobv@2036	81	#ifdef __SOFTFP__
bobv@2036	82	static jfloat fadd(jfloat x, jfloat y);
bobv@2036	83	static jfloat fsub(jfloat x, jfloat y);
bobv@2036	84	static jfloat fmul(jfloat x, jfloat y);
bobv@2036	85	static jfloat fdiv(jfloat x, jfloat y);
bobv@2036	86
bobv@2036	87	static jdouble dadd(jdouble x, jdouble y);
bobv@2036	88	static jdouble dsub(jdouble x, jdouble y);
bobv@2036	89	static jdouble dmul(jdouble x, jdouble y);
bobv@2036	90	static jdouble ddiv(jdouble x, jdouble y);
bobv@2036	91	#endif // __SOFTFP__
bobv@2036	92
duke@435	93	// float conversion (needs to set appropriate rounding mode)
duke@435	94	static jint f2i (jfloat x);
duke@435	95	static jlong f2l (jfloat x);
duke@435	96	static jint d2i (jdouble x);
duke@435	97	static jlong d2l (jdouble x);
duke@435	98	static jfloat d2f (jdouble x);
duke@435	99	static jfloat l2f (jlong x);
duke@435	100	static jdouble l2d (jlong x);
duke@435	101
bobv@2036	102	#ifdef __SOFTFP__
bobv@2036	103	static jfloat i2f (jint x);
bobv@2036	104	static jdouble i2d (jint x);
bobv@2036	105	static jdouble f2d (jfloat x);
bobv@2036	106	#endif // __SOFTFP__
bobv@2036	107
duke@435	108	// double trigonometrics and transcendentals
duke@435	109	static jdouble dsin(jdouble x);
duke@435	110	static jdouble dcos(jdouble x);
duke@435	111	static jdouble dtan(jdouble x);
duke@435	112	static jdouble dlog(jdouble x);
duke@435	113	static jdouble dlog10(jdouble x);
duke@435	114	static jdouble dexp(jdouble x);
duke@435	115	static jdouble dpow(jdouble x, jdouble y);
duke@435	116
bobv@2036	117	#if defined(__SOFTFP__) || defined(E500V2)
bobv@2036	118	static double dabs(double f);
bobv@2036	119	static double dsqrt(double f);
bobv@2036	120	#endif
bobv@2036	121
bobv@2036	122	#ifdef __SOFTFP__
bobv@2036	123	// C++ compiler generates soft float instructions as well as passing
bobv@2036	124	// float and double in registers.
bobv@2036	125	static int fcmpl(float x, float y);
bobv@2036	126	static int fcmpg(float x, float y);
bobv@2036	127	static int dcmpl(double x, double y);
bobv@2036	128	static int dcmpg(double x, double y);
bobv@2036	129
bobv@2036	130	static int unordered_fcmplt(float x, float y);
bobv@2036	131	static int unordered_dcmplt(double x, double y);
bobv@2036	132	static int unordered_fcmple(float x, float y);
bobv@2036	133	static int unordered_dcmple(double x, double y);
bobv@2036	134	static int unordered_fcmpge(float x, float y);
bobv@2036	135	static int unordered_dcmpge(double x, double y);
bobv@2036	136	static int unordered_fcmpgt(float x, float y);
bobv@2036	137	static int unordered_dcmpgt(double x, double y);
bobv@2036	138
bobv@2036	139	static float fneg(float f);
bobv@2036	140	static double dneg(double f);
bobv@2036	141	#endif
bobv@2036	142
duke@435	143	// exception handling across interpreter/compiler boundaries
twisti@1730	144	static address raw_exception_handler_for_return_address(JavaThread* thread, address return_address);
twisti@1730	145	static address exception_handler_for_return_address(JavaThread* thread, address return_address);
duke@435	146
ysr@777	147	#ifndef SERIALGC
ysr@777	148	// G1 write barriers
ysr@777	149	static void g1_wb_pre(oopDesc* orig, JavaThread *thread);
ysr@777	150	static void g1_wb_post(void* card_addr, JavaThread* thread);
ysr@777	151	#endif // !SERIALGC
ysr@777	152
duke@435	153	// exception handling and implicit exceptions
duke@435	154	static address compute_compiled_exc_handler(nmethod* nm, address ret_pc, Handle& exception,
duke@435	155	bool force_unwind, bool top_frame_only);
duke@435	156	enum ImplicitExceptionKind {
duke@435	157	IMPLICIT_NULL,
duke@435	158	IMPLICIT_DIVIDE_BY_ZERO,
duke@435	159	STACK_OVERFLOW
duke@435	160	};
duke@435	161	static void throw_AbstractMethodError(JavaThread* thread);
dcubed@451	162	static void throw_IncompatibleClassChangeError(JavaThread* thread);
duke@435	163	static void throw_ArithmeticException(JavaThread* thread);
duke@435	164	static void throw_NullPointerException(JavaThread* thread);
duke@435	165	static void throw_NullPointerException_at_call(JavaThread* thread);
duke@435	166	static void throw_StackOverflowError(JavaThread* thread);
duke@435	167	static address continuation_for_implicit_exception(JavaThread* thread,
duke@435	168	address faulting_pc,
duke@435	169	ImplicitExceptionKind exception_kind);
duke@435	170
duke@435	171	// Shared stub locations
duke@435	172	static address get_poll_stub(address pc);
duke@435	173
duke@435	174	static address get_ic_miss_stub() {
duke@435	175	assert(_ic_miss_blob!= NULL, "oops");
duke@435	176	return _ic_miss_blob->instructions_begin();
duke@435	177	}
duke@435	178
duke@435	179	static address get_handle_wrong_method_stub() {
duke@435	180	assert(_wrong_method_blob!= NULL, "oops");
duke@435	181	return _wrong_method_blob->instructions_begin();
duke@435	182	}
duke@435	183
duke@435	184	#ifdef COMPILER2
duke@435	185	static void generate_uncommon_trap_blob(void);
duke@435	186	static UncommonTrapBlob* uncommon_trap_blob() { return _uncommon_trap_blob; }
duke@435	187	#endif // COMPILER2
duke@435	188
duke@435	189	static address get_resolve_opt_virtual_call_stub(){
duke@435	190	assert(_resolve_opt_virtual_call_blob != NULL, "oops");
duke@435	191	return _resolve_opt_virtual_call_blob->instructions_begin();
duke@435	192	}
duke@435	193	static address get_resolve_virtual_call_stub() {
duke@435	194	assert(_resolve_virtual_call_blob != NULL, "oops");
duke@435	195	return _resolve_virtual_call_blob->instructions_begin();
duke@435	196	}
duke@435	197	static address get_resolve_static_call_stub() {
duke@435	198	assert(_resolve_static_call_blob != NULL, "oops");
duke@435	199	return _resolve_static_call_blob->instructions_begin();
duke@435	200	}
duke@435	201
duke@435	202	static SafepointBlob* polling_page_return_handler_blob() { return _polling_page_return_handler_blob; }
duke@435	203	static SafepointBlob* polling_page_safepoint_handler_blob() { return _polling_page_safepoint_handler_blob; }
duke@435	204
duke@435	205	// Counters
duke@435	206	#ifndef PRODUCT
duke@435	207	static address nof_megamorphic_calls_addr() { return (address)&_nof_megamorphic_calls; }
duke@435	208	#endif // PRODUCT
duke@435	209
duke@435	210	// Helper routine for full-speed JVMTI exception throwing support
duke@435	211	static void throw_and_post_jvmti_exception(JavaThread *thread, Handle h_exception);
duke@435	212	static void throw_and_post_jvmti_exception(JavaThread *thread, symbolOop name, const char *message = NULL);
duke@435	213
dcubed@1045	214	// RedefineClasses() tracing support for obsolete method entry
dcubed@1045	215	static int rc_trace_method_entry(JavaThread* thread, methodOopDesc* m);
dcubed@1045	216
duke@435	217	// To be used as the entry point for unresolved native methods.
duke@435	218	static address native_method_throw_unsatisfied_link_error_entry();
duke@435	219
duke@435	220	// bytecode tracing is only used by the TraceBytecodes
duke@435	221	static intptr_t trace_bytecode(JavaThread* thread, intptr_t preserve_this_value, intptr_t tos, intptr_t tos2) PRODUCT_RETURN0;
duke@435	222
duke@435	223	// Used to back off a spin lock that is under heavy contention
duke@435	224	static void yield_all(JavaThread* thread, int attempts = 0);
duke@435	225
duke@435	226	static oop retrieve_receiver( symbolHandle sig, frame caller );
duke@435	227
duke@435	228	static void register_finalizer(JavaThread* thread, oopDesc* obj);
duke@435	229
duke@435	230	// dtrace notifications
duke@435	231	static int dtrace_object_alloc(oopDesc* o);
duke@435	232	static int dtrace_object_alloc_base(Thread* thread, oopDesc* o);
duke@435	233	static int dtrace_method_entry(JavaThread* thread, methodOopDesc* m);
duke@435	234	static int dtrace_method_exit(JavaThread* thread, methodOopDesc* m);
duke@435	235
duke@435	236	// Utility method for retrieving the Java thread id, returns 0 if the
duke@435	237	// thread is not a well formed Java thread.
duke@435	238	static jlong get_java_tid(Thread* thread);
duke@435	239
duke@435	240
duke@435	241	// used by native wrappers to reenable yellow if overflow happened in native code
duke@435	242	static void reguard_yellow_pages();
duke@435	243
duke@435	244	/**
duke@435	245	* Fill in the "X cannot be cast to a Y" message for ClassCastException
duke@435	246	*
duke@435	247	* @param thr the current thread
duke@435	248	* @param name the name of the class of the object attempted to be cast
duke@435	249	* @return the dynamically allocated exception message (must be freed
duke@435	250	* by the caller using a resource mark)
duke@435	251	*
duke@435	252	* BCP must refer to the current 'checkcast' opcode for the frame
duke@435	253	* on top of the stack.
duke@435	254	* The caller (or one of it's callers) must use a ResourceMark
duke@435	255	* in order to correctly free the result.
duke@435	256	*/
duke@435	257	static char* generate_class_cast_message(JavaThread* thr, const char* name);
duke@435	258
duke@435	259	/**
jrose@1145	260	* Fill in the message for a WrongMethodTypeException
jrose@1145	261	*
jrose@1145	262	* @param thr the current thread
jrose@1145	263	* @param mtype (optional) expected method type (or argument class)
jrose@1145	264	* @param mhandle (optional) actual method handle (or argument)
jrose@1145	265	* @return the dynamically allocated exception message
jrose@1145	266	*
jrose@1145	267	* BCP for the frame on top of the stack must refer to an
jrose@1145	268	* 'invokevirtual' op for a method handle, or an 'invokedyamic' op.
jrose@1145	269	* The caller (or one of its callers) must use a ResourceMark
jrose@1145	270	* in order to correctly free the result.
jrose@1145	271	*/
jrose@1145	272	static char* generate_wrong_method_type_message(JavaThread* thr,
jrose@1145	273	oopDesc* mtype = NULL,
jrose@1145	274	oopDesc* mhandle = NULL);
jrose@1145	275
jrose@1145	276	/** Return non-null if the mtype is a klass or Class, not a MethodType. */
jrose@1145	277	static oop wrong_method_type_is_for_single_argument(JavaThread* thr,
jrose@1145	278	oopDesc* mtype);
jrose@1145	279
jrose@1145	280	/**
duke@435	281	* Fill in the "X cannot be cast to a Y" message for ClassCastException
duke@435	282	*
duke@435	283	* @param name the name of the class of the object attempted to be cast
duke@435	284	* @param klass the name of the target klass attempt
jrose@1145	285	* @param gripe the specific kind of problem being reported
duke@435	286	* @return the dynamically allocated exception message (must be freed
duke@435	287	* by the caller using a resource mark)
duke@435	288	*
duke@435	289	* This version does not require access the frame, so it can be called
duke@435	290	* from interpreted code
duke@435	291	* The caller (or one of it's callers) must use a ResourceMark
duke@435	292	* in order to correctly free the result.
duke@435	293	*/
jrose@1145	294	static char* generate_class_cast_message(const char* name, const char* klass,
jrose@1145	295	const char* gripe = " cannot be cast to ");
duke@435	296
duke@435	297	// Resolves a call site- may patch in the destination of the call into the
duke@435	298	// compiled code.
duke@435	299	static methodHandle resolve_helper(JavaThread *thread,
duke@435	300	bool is_virtual,
duke@435	301	bool is_optimized, TRAPS);
duke@435	302
duke@435	303	static void generate_stubs(void);
duke@435	304
duke@435	305	private:
duke@435	306	// deopt blob
duke@435	307	static void generate_deopt_blob(void);
duke@435	308	static DeoptimizationBlob* _deopt_blob;
duke@435	309
duke@435	310	public:
duke@435	311	static DeoptimizationBlob* deopt_blob(void) { return _deopt_blob; }
duke@435	312
duke@435	313	// Resets a call-site in compiled code so it will get resolved again.
duke@435	314	static methodHandle reresolve_call_site(JavaThread *thread, TRAPS);
duke@435	315
duke@435	316	// In the code prolog, if the klass comparison fails, the inline cache
duke@435	317	// misses and the call site is patched to megamorphic
duke@435	318	static methodHandle handle_ic_miss_helper(JavaThread* thread, TRAPS);
duke@435	319
duke@435	320	// Find the method that called us.
duke@435	321	static methodHandle find_callee_method(JavaThread* thread, TRAPS);
duke@435	322
duke@435	323
duke@435	324	private:
duke@435	325	static Handle find_callee_info(JavaThread* thread,
duke@435	326	Bytecodes::Code& bc,
duke@435	327	CallInfo& callinfo, TRAPS);
duke@435	328	static Handle find_callee_info_helper(JavaThread* thread,
duke@435	329	vframeStream& vfst,
duke@435	330	Bytecodes::Code& bc,
duke@435	331	CallInfo& callinfo, TRAPS);
duke@435	332
duke@435	333	static address clean_virtual_call_entry();
duke@435	334	static address clean_opt_virtual_call_entry();
duke@435	335	static address clean_static_call_entry();
duke@435	336
duke@435	337	public:
duke@435	338
duke@435	339	// Read the array of BasicTypes from a Java signature, and compute where
duke@435	340	// compiled Java code would like to put the results. Values in reg_lo and
duke@435	341	// reg_hi refer to 4-byte quantities. Values less than SharedInfo::stack0 are
duke@435	342	// registers, those above refer to 4-byte stack slots. All stack slots are
duke@435	343	// based off of the window top. SharedInfo::stack0 refers to the first usable
duke@435	344	// slot in the bottom of the frame. SharedInfo::stack0+1 refers to the memory word
duke@435	345	// 4-bytes higher. So for sparc because the register window save area is at
duke@435	346	// the bottom of the frame the first 16 words will be skipped and SharedInfo::stack0
duke@435	347	// will be just above it. (
duke@435	348	// return value is the maximum number of VMReg stack slots the convention will use.
duke@435	349	static int java_calling_convention(const BasicType *sig_bt, VMRegPair *regs, int total_args_passed, int is_outgoing);
duke@435	350
duke@435	351	// Ditto except for calling C
duke@435	352	static int c_calling_convention(const BasicType *sig_bt, VMRegPair *regs, int total_args_passed);
duke@435	353
duke@435	354	// Generate I2C and C2I adapters. These adapters are simple argument marshalling
duke@435	355	// blobs. Unlike adapters in the tiger and earlier releases the code in these
duke@435	356	// blobs does not create a new frame and are therefore virtually invisible
duke@435	357	// to the stack walking code. In general these blobs extend the callers stack
duke@435	358	// as needed for the conversion of argument locations.
duke@435	359
duke@435	360	// When calling a c2i blob the code will always call the interpreter even if
duke@435	361	// by the time we reach the blob there is compiled code available. This allows
duke@435	362	// the blob to pass the incoming stack pointer (the sender sp) in a known
duke@435	363	// location for the interpreter to record. This is used by the frame code
duke@435	364	// to correct the sender code to match up with the stack pointer when the
duke@435	365	// thread left the compiled code. In addition it allows the interpreter
duke@435	366	// to remove the space the c2i adapter allocated to do it argument conversion.
duke@435	367
duke@435	368	// Although a c2i blob will always run interpreted even if compiled code is
duke@435	369	// present if we see that compiled code is present the compiled call site
duke@435	370	// will be patched/re-resolved so that later calls will run compiled.
duke@435	371
duke@435	372	// Aditionally a c2i blob need to have a unverified entry because it can be reached
duke@435	373	// in situations where the call site is an inlined cache site and may go megamorphic.
duke@435	374
duke@435	375	// A i2c adapter is simpler than the c2i adapter. This is because it is assumed
duke@435	376	// that the interpreter before it does any call dispatch will record the current
duke@435	377	// stack pointer in the interpreter frame. On return it will restore the stack
duke@435	378	// pointer as needed. This means the i2c adapter code doesn't need any special
duke@435	379	// handshaking path with compiled code to keep the stack walking correct.
duke@435	380
duke@435	381	static AdapterHandlerEntry* generate_i2c2i_adapters(MacroAssembler *_masm,
duke@435	382	int total_args_passed,
duke@435	383	int max_arg,
duke@435	384	const BasicType *sig_bt,
never@1622	385	const VMRegPair *regs,
never@1622	386	AdapterFingerPrint* fingerprint);
duke@435	387
duke@435	388	// OSR support
duke@435	389
duke@435	390	// OSR_migration_begin will extract the jvm state from an interpreter
duke@435	391	// frame (locals, monitors) and store the data in a piece of C heap
duke@435	392	// storage. This then allows the interpreter frame to be removed from the
duke@435	393	// stack and the OSR nmethod to be called. That method is called with a
duke@435	394	// pointer to the C heap storage. This pointer is the return value from
duke@435	395	// OSR_migration_begin.
duke@435	396
duke@435	397	static intptr_t* OSR_migration_begin( JavaThread *thread);
duke@435	398
duke@435	399	// OSR_migration_end is a trivial routine. It is called after the compiled
duke@435	400	// method has extracted the jvm state from the C heap that OSR_migration_begin
duke@435	401	// created. It's entire job is to simply free this storage.
duke@435	402	static void OSR_migration_end ( intptr_t* buf);
duke@435	403
duke@435	404	// Convert a sig into a calling convention register layout
duke@435	405	// and find interesting things about it.
twisti@1573	406	static VMRegPair* find_callee_arguments(symbolOop sig, bool has_receiver, int *arg_size);
duke@435	407	static VMReg name_for_receiver();
duke@435	408
duke@435	409	// "Top of Stack" slots that may be unused by the calling convention but must
duke@435	410	// otherwise be preserved.
duke@435	411	// On Intel these are not necessary and the value can be zero.
duke@435	412	// On Sparc this describes the words reserved for storing a register window
duke@435	413	// when an interrupt occurs.
duke@435	414	static uint out_preserve_stack_slots();
duke@435	415
duke@435	416	// Save and restore a native result
duke@435	417	static void save_native_result(MacroAssembler *_masm, BasicType ret_type, int frame_slots );
duke@435	418	static void restore_native_result(MacroAssembler *_masm, BasicType ret_type, int frame_slots );
duke@435	419
duke@435	420	// Generate a native wrapper for a given method. The method takes arguments
duke@435	421	// in the Java compiled code convention, marshals them to the native
duke@435	422	// convention (handlizes oops, etc), transitions to native, makes the call,
duke@435	423	// returns to java state (possibly blocking), unhandlizes any result and
duke@435	424	// returns.
duke@435	425	static nmethod *generate_native_wrapper(MacroAssembler* masm,
duke@435	426	methodHandle method,
duke@435	427	int total_args_passed,
duke@435	428	int max_arg,
duke@435	429	BasicType *sig_bt,
duke@435	430	VMRegPair *regs,
duke@435	431	BasicType ret_type );
duke@435	432
kamg@551	433	#ifdef HAVE_DTRACE_H
kamg@551	434	// Generate a dtrace wrapper for a given method. The method takes arguments
kamg@551	435	// in the Java compiled code convention, marshals them to the native
kamg@551	436	// convention (handlizes oops, etc), transitions to native, makes the call,
kamg@551	437	// returns to java state (possibly blocking), unhandlizes any result and
kamg@551	438	// returns.
kamg@551	439	static nmethod *generate_dtrace_nmethod(MacroAssembler* masm,
kamg@551	440	methodHandle method);
kamg@551	441
kamg@551	442	// dtrace support to convert a Java string to utf8
kamg@551	443	static void get_utf(oopDesc* src, address dst);
kamg@551	444	#endif // def HAVE_DTRACE_H
kamg@551	445
duke@435	446	// A compiled caller has just called the interpreter, but compiled code
duke@435	447	// exists. Patch the caller so he no longer calls into the interpreter.
duke@435	448	static void fixup_callers_callsite(methodOopDesc* moop, address ret_pc);
duke@435	449
duke@435	450	// Slow-path Locking and Unlocking
duke@435	451	static void complete_monitor_locking_C(oopDesc* obj, BasicLock* lock, JavaThread* thread);
duke@435	452	static void complete_monitor_unlocking_C(oopDesc* obj, BasicLock* lock);
duke@435	453
duke@435	454	// Resolving of calls
duke@435	455	static address resolve_static_call_C (JavaThread *thread);
duke@435	456	static address resolve_virtual_call_C (JavaThread *thread);
duke@435	457	static address resolve_opt_virtual_call_C(JavaThread *thread);
duke@435	458
duke@435	459	// arraycopy, the non-leaf version. (See StubRoutines for all the leaf calls.)
duke@435	460	static void slow_arraycopy_C(oopDesc* src, jint src_pos,
duke@435	461	oopDesc* dest, jint dest_pos,
duke@435	462	jint length, JavaThread* thread);
duke@435	463
duke@435	464	// handle ic miss with caller being compiled code
duke@435	465	// wrong method handling (inline cache misses, zombie methods)
duke@435	466	static address handle_wrong_method(JavaThread* thread);
duke@435	467	static address handle_wrong_method_ic_miss(JavaThread* thread);
duke@435	468
duke@435	469	#ifndef PRODUCT
duke@435	470
duke@435	471	// Collect and print inline cache miss statistics
duke@435	472	private:
duke@435	473	enum { maxICmiss_count = 100 };
duke@435	474	static int _ICmiss_index; // length of IC miss histogram
duke@435	475	static int _ICmiss_count[maxICmiss_count]; // miss counts
duke@435	476	static address _ICmiss_at[maxICmiss_count]; // miss addresses
duke@435	477	static void trace_ic_miss(address at);
duke@435	478
duke@435	479	public:
duke@435	480	static int _monitor_enter_ctr; // monitor enter slow
duke@435	481	static int _monitor_exit_ctr; // monitor exit slow
duke@435	482	static int _throw_null_ctr; // throwing a null-pointer exception
duke@435	483	static int _ic_miss_ctr; // total # of IC misses
duke@435	484	static int _wrong_method_ctr;
duke@435	485	static int _resolve_static_ctr;
duke@435	486	static int _resolve_virtual_ctr;
duke@435	487	static int _resolve_opt_virtual_ctr;
duke@435	488	static int _implicit_null_throws;
duke@435	489	static int _implicit_div0_throws;
duke@435	490
duke@435	491	static int _jbyte_array_copy_ctr; // Slow-path byte array copy
duke@435	492	static int _jshort_array_copy_ctr; // Slow-path short array copy
duke@435	493	static int _jint_array_copy_ctr; // Slow-path int array copy
duke@435	494	static int _jlong_array_copy_ctr; // Slow-path long array copy
duke@435	495	static int _oop_array_copy_ctr; // Slow-path oop array copy
duke@435	496	static int _checkcast_array_copy_ctr; // Slow-path oop array copy, with cast
duke@435	497	static int _unsafe_array_copy_ctr; // Slow-path includes alignment checks
duke@435	498	static int _generic_array_copy_ctr; // Slow-path includes type decoding
duke@435	499	static int _slow_array_copy_ctr; // Slow-path failed out to a method call
duke@435	500
duke@435	501	static int _new_instance_ctr; // 'new' object requires GC
duke@435	502	static int _new_array_ctr; // 'new' array requires GC
duke@435	503	static int _multi1_ctr, _multi2_ctr, _multi3_ctr, _multi4_ctr, _multi5_ctr;
duke@435	504	static int _find_handler_ctr; // find exception handler
duke@435	505	static int _rethrow_ctr; // rethrow exception
duke@435	506	static int _mon_enter_stub_ctr; // monitor enter stub
duke@435	507	static int _mon_exit_stub_ctr; // monitor exit stub
duke@435	508	static int _mon_enter_ctr; // monitor enter slow
duke@435	509	static int _mon_exit_ctr; // monitor exit slow
duke@435	510	static int _partial_subtype_ctr; // SubRoutines::partial_subtype_check
duke@435	511
duke@435	512	// Statistics code
duke@435	513	// stats for "normal" compiled calls (non-interface)
duke@435	514	static int _nof_normal_calls; // total # of calls
duke@435	515	static int _nof_optimized_calls; // total # of statically-bound calls
duke@435	516	static int _nof_inlined_calls; // total # of inlined normal calls
duke@435	517	static int _nof_static_calls; // total # of calls to static methods or super methods (invokespecial)
duke@435	518	static int _nof_inlined_static_calls; // total # of inlined static calls
duke@435	519	// stats for compiled interface calls
duke@435	520	static int _nof_interface_calls; // total # of compiled calls
duke@435	521	static int _nof_optimized_interface_calls; // total # of statically-bound interface calls
duke@435	522	static int _nof_inlined_interface_calls; // total # of inlined interface calls
duke@435	523	static int _nof_megamorphic_interface_calls;// total # of megamorphic interface calls
duke@435	524	// stats for runtime exceptions
duke@435	525	static int _nof_removable_exceptions; // total # of exceptions that could be replaced by branches due to inlining
duke@435	526
duke@435	527	public: // for compiler
duke@435	528	static address nof_normal_calls_addr() { return (address)&_nof_normal_calls; }
duke@435	529	static address nof_optimized_calls_addr() { return (address)&_nof_optimized_calls; }
duke@435	530	static address nof_inlined_calls_addr() { return (address)&_nof_inlined_calls; }
duke@435	531	static address nof_static_calls_addr() { return (address)&_nof_static_calls; }
duke@435	532	static address nof_inlined_static_calls_addr() { return (address)&_nof_inlined_static_calls; }
duke@435	533	static address nof_interface_calls_addr() { return (address)&_nof_interface_calls; }
duke@435	534	static address nof_optimized_interface_calls_addr() { return (address)&_nof_optimized_interface_calls; }
duke@435	535	static address nof_inlined_interface_calls_addr() { return (address)&_nof_inlined_interface_calls; }
duke@435	536	static address nof_megamorphic_interface_calls_addr() { return (address)&_nof_megamorphic_interface_calls; }
duke@435	537	static void print_call_statistics(int comp_total);
duke@435	538	static void print_statistics();
duke@435	539	static void print_ic_miss_histogram();
duke@435	540
duke@435	541	#endif // PRODUCT
duke@435	542	};
duke@435	543
duke@435	544
duke@435	545	// ---------------------------------------------------------------------------
duke@435	546	// Implementation of AdapterHandlerLibrary
duke@435	547	//
duke@435	548	// This library manages argument marshaling adapters and native wrappers.
duke@435	549	// There are 2 flavors of adapters: I2C and C2I.
duke@435	550	//
duke@435	551	// The I2C flavor takes a stock interpreted call setup, marshals the arguments
duke@435	552	// for a Java-compiled call, and jumps to Rmethod-> code()->
duke@435	553	// instructions_begin(). It is broken to call it without an nmethod assigned.
duke@435	554	// The usual behavior is to lift any register arguments up out of the stack
duke@435	555	// and possibly re-pack the extra arguments to be contigious. I2C adapters
duke@435	556	// will save what the interpreter's stack pointer will be after arguments are
duke@435	557	// popped, then adjust the interpreter's frame size to force alignment and
duke@435	558	// possibly to repack the arguments. After re-packing, it jumps to the
duke@435	559	// compiled code start. There are no safepoints in this adapter code and a GC
duke@435	560	// cannot happen while marshaling is in progress.
duke@435	561	//
duke@435	562	// The C2I flavor takes a stock compiled call setup plus the target method in
duke@435	563	// Rmethod, marshals the arguments for an interpreted call and jumps to
duke@435	564	// Rmethod->_i2i_entry. On entry, the interpreted frame has not yet been
duke@435	565	// setup. Compiled frames are fixed-size and the args are likely not in the
duke@435	566	// right place. Hence all the args will likely be copied into the
duke@435	567	// interpreter's frame, forcing that frame to grow. The compiled frame's
duke@435	568	// outgoing stack args will be dead after the copy.
duke@435	569	//
duke@435	570	// Native wrappers, like adapters, marshal arguments. Unlike adapters they
duke@435	571	// also perform an offical frame push & pop. They have a call to the native
duke@435	572	// routine in their middles and end in a return (instead of ending in a jump).
duke@435	573	// The native wrappers are stored in real nmethods instead of the BufferBlobs
duke@435	574	// used by the adapters. The code generation happens here because it's very
duke@435	575	// similar to what the adapters have to do.
duke@435	576
never@1622	577	class AdapterHandlerEntry : public BasicHashtableEntry {
never@1622	578	friend class AdapterHandlerTable;
never@1622	579
duke@435	580	private:
never@1622	581	AdapterFingerPrint* _fingerprint;
duke@435	582	address _i2c_entry;
duke@435	583	address _c2i_entry;
duke@435	584	address _c2i_unverified_entry;
duke@435	585
never@1642	586	#ifdef ASSERT
never@1642	587	// Captures code and signature used to generate this adapter when
never@1642	588	// verifing adapter equivalence.
never@1642	589	unsigned char* _saved_code;
never@1642	590	int _code_length;
never@1642	591	BasicType* _saved_sig;
never@1642	592	int _total_args_passed;
never@1642	593	#endif
never@1642	594
never@1622	595	void init(AdapterFingerPrint* fingerprint, address i2c_entry, address c2i_entry, address c2i_unverified_entry) {
never@1622	596	_fingerprint = fingerprint;
never@1622	597	_i2c_entry = i2c_entry;
never@1622	598	_c2i_entry = c2i_entry;
never@1622	599	_c2i_unverified_entry = c2i_unverified_entry;
never@1642	600	#ifdef ASSERT
never@1642	601	_saved_code = NULL;
never@1642	602	_code_length = 0;
never@1642	603	_saved_sig = NULL;
never@1642	604	_total_args_passed = 0;
never@1642	605	#endif
never@1622	606	}
never@1622	607
never@1642	608	void deallocate();
never@1642	609
never@1622	610	// should never be used
never@1622	611	AdapterHandlerEntry();
never@1622	612
duke@435	613	public:
duke@435	614	address get_i2c_entry() { return _i2c_entry; }
duke@435	615	address get_c2i_entry() { return _c2i_entry; }
duke@435	616	address get_c2i_unverified_entry() { return _c2i_unverified_entry; }
kamg@551	617
duke@435	618	void relocate(address new_base);
never@1622	619
never@1622	620	AdapterFingerPrint* fingerprint() { return _fingerprint; }
never@1622	621
never@1622	622	AdapterHandlerEntry* next() {
never@1622	623	return (AdapterHandlerEntry*)BasicHashtableEntry::next();
never@1622	624	}
never@1622	625
never@1642	626	#ifdef ASSERT
never@1642	627	// Used to verify that code generated for shared adapters is equivalent
never@1642	628	void save_code(unsigned char* code, int length, int total_args_passed, BasicType* sig_bt);
never@1642	629	bool compare_code(unsigned char* code, int length, int total_args_passed, BasicType* sig_bt);
never@1642	630	#endif
never@1642	631
duke@435	632	void print();
duke@435	633	};
duke@435	634
duke@435	635	class AdapterHandlerLibrary: public AllStatic {
duke@435	636	private:
kvn@1177	637	static BufferBlob* _buffer; // the temporary code buffer in CodeCache
never@1622	638	static AdapterHandlerTable* _adapters;
never@1622	639	static AdapterHandlerEntry* _abstract_method_handler;
kvn@1177	640	static BufferBlob* buffer_blob();
duke@435	641	static void initialize();
duke@435	642
duke@435	643	public:
never@1622	644
never@1622	645	static AdapterHandlerEntry* new_entry(AdapterFingerPrint* fingerprint,
never@1622	646	address i2c_entry, address c2i_entry, address c2i_unverified_entry);
duke@435	647	static nmethod* create_native_wrapper(methodHandle method);
never@1622	648	static AdapterHandlerEntry* get_adapter(methodHandle method);
never@1622	649
kamg@551	650	#ifdef HAVE_DTRACE_H
kamg@551	651	static nmethod* create_dtrace_nmethod (methodHandle method);
kamg@551	652	#endif // HAVE_DTRACE_H
duke@435	653
bobv@2036	654	static void print_handler(CodeBlob* b) { print_handler_on(tty, b); }
bobv@2036	655	static void print_handler_on(outputStream* st, CodeBlob* b);
bobv@2036	656	static bool contains(CodeBlob* b);
duke@435	657	#ifndef PRODUCT
never@1622	658	static void print_statistics();
duke@435	659	#endif /* PRODUCT */
duke@435	660
duke@435	661	};