truffle: src/share/vm/runtime/sharedRuntime.hpp annotate

annotate src/share/vm/runtime/sharedRuntime.hpp @ 9126:bc26f978b0ce

HotSpotResolvedObjectType: implement hasFinalizeSubclass() correctly don't use the (wrong) cached value, but ask the runtime on each request. Fixes regression on xml.* benchmarks @ specjvm2008. The problem was: After the constructor of Object was deoptimized due to an assumption violation, it was recompiled again after some time. However, on recompilation, the value of hasFinalizeSubclass for the class was not updated and it was compiled again with a, now wrong, assumption, which then triggers deoptimization again. This was repeated until it hit the recompilation limit (defined by PerMethodRecompilationCutoff), and therefore only executed by the interpreter from now on, causing the performance regression.

author	Bernhard Urban <bernhard.urban@jku.at>
date	Mon, 15 Apr 2013 19:54:58 +0200
parents	f94bb5d20e5d
children	836a62f43af9

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

Mercurial > hg > truffle

annotate src/share/vm/runtime/sharedRuntime.hpp @ 9126:bc26f978b0ce