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