graal-jvmci-8: src/share/vm/runtime/sharedRuntime.hpp annotate

annotate src/share/vm/runtime/sharedRuntime.hpp @ 3979:4dfb2df418f2

6484982: G1: process references during evacuation pauses Summary: G1 now uses two reference processors - one is used by concurrent marking and the other is used by STW GCs (both full and incremental evacuation pauses). In an evacuation pause, the reference processor is embedded into the closures used to scan objects. Doing so causes causes reference objects to be 'discovered' by the reference processor. At the end of the evacuation pause, these discovered reference objects are processed - preserving (and copying) referent objects (and their reachable graphs) as appropriate. Reviewed-by: ysr, jwilhelm, brutisso, stefank, tonyp

author	johnc
date	Thu, 22 Sep 2011 10:57:37 -0700
parents	7588156f5cf9
children	04b9a2566eec 0382d2b469b2

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

Mercurial > hg > graal-jvmci-8

annotate src/share/vm/runtime/sharedRuntime.hpp @ 3979:4dfb2df418f2