Mercurial > hg > graal-jvmci-8
annotate src/share/vm/runtime/sharedRuntime.cpp @ 8854:754c24457b20
7112912: Message "Error occurred during initialization of VM" on boxes with lots of RAM
Summary: Ergonomics now also takes available virtual memory into account when deciding for a heap size. The helper method to determine the maximum allocatable memory block now uses the appropriate OS specific calls to retrieve available virtual memory for the java process. In 32 bit environments this method now also searches for the maximum actually reservable amount of memory. Merge previously separate implementations for Linux/BSD/Solaris into a single method.
Reviewed-by: jmasa, tamao
| author | tschatzl |
|---|---|
| date | Wed, 27 Mar 2013 19:21:18 +0100 |
| parents | df8462fbe585 |
| children | 5fc51c1ecdeb a5c95fcf7cb7 |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
4872
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4807
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:
1507
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1507
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:
1507
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #include "precompiled.hpp" |
| 26 #include "classfile/systemDictionary.hpp" | |
| 27 #include "classfile/vmSymbols.hpp" | |
| 28 #include "code/compiledIC.hpp" | |
| 29 #include "code/scopeDesc.hpp" | |
| 30 #include "code/vtableStubs.hpp" | |
| 31 #include "compiler/abstractCompiler.hpp" | |
| 32 #include "compiler/compileBroker.hpp" | |
| 33 #include "compiler/compilerOracle.hpp" | |
|
7199
cd3d6a6b95d9
8003240: x86: move MacroAssembler into separate file
twisti
parents:
6983
diff
changeset
|
34 #include "compiler/disassembler.hpp" |
| 1972 | 35 #include "interpreter/interpreter.hpp" |
| 36 #include "interpreter/interpreterRuntime.hpp" | |
| 37 #include "memory/gcLocker.inline.hpp" | |
| 38 #include "memory/universe.inline.hpp" | |
| 39 #include "oops/oop.inline.hpp" | |
| 40 #include "prims/forte.hpp" | |
| 41 #include "prims/jvmtiExport.hpp" | |
| 42 #include "prims/jvmtiRedefineClassesTrace.hpp" | |
| 43 #include "prims/methodHandles.hpp" | |
| 44 #include "prims/nativeLookup.hpp" | |
| 45 #include "runtime/arguments.hpp" | |
| 46 #include "runtime/biasedLocking.hpp" | |
| 47 #include "runtime/handles.inline.hpp" | |
| 48 #include "runtime/init.hpp" | |
| 49 #include "runtime/interfaceSupport.hpp" | |
| 50 #include "runtime/javaCalls.hpp" | |
| 51 #include "runtime/sharedRuntime.hpp" | |
| 52 #include "runtime/stubRoutines.hpp" | |
| 53 #include "runtime/vframe.hpp" | |
| 54 #include "runtime/vframeArray.hpp" | |
| 55 #include "utilities/copy.hpp" | |
| 56 #include "utilities/dtrace.hpp" | |
| 57 #include "utilities/events.hpp" | |
| 58 #include "utilities/hashtable.inline.hpp" | |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7469
diff
changeset
|
59 #include "utilities/macros.hpp" |
| 1972 | 60 #include "utilities/xmlstream.hpp" |
| 61 #ifdef TARGET_ARCH_x86 | |
| 62 # include "nativeInst_x86.hpp" | |
| 63 # include "vmreg_x86.inline.hpp" | |
| 64 #endif | |
| 65 #ifdef TARGET_ARCH_sparc | |
| 66 # include "nativeInst_sparc.hpp" | |
| 67 # include "vmreg_sparc.inline.hpp" | |
| 68 #endif | |
| 69 #ifdef TARGET_ARCH_zero | |
| 70 # include "nativeInst_zero.hpp" | |
| 71 # include "vmreg_zero.inline.hpp" | |
| 72 #endif | |
|
2192
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
73 #ifdef TARGET_ARCH_arm |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
74 # include "nativeInst_arm.hpp" |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
75 # include "vmreg_arm.inline.hpp" |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
76 #endif |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
77 #ifdef TARGET_ARCH_ppc |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
78 # include "nativeInst_ppc.hpp" |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
79 # include "vmreg_ppc.inline.hpp" |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
80 #endif |
| 1972 | 81 #ifdef COMPILER1 |
| 82 #include "c1/c1_Runtime1.hpp" | |
| 83 #endif | |
| 84 | |
|
3753
cba7b5c2d53f
7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents:
3363
diff
changeset
|
85 // Shared stub locations |
|
cba7b5c2d53f
7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents:
3363
diff
changeset
|
86 RuntimeStub* SharedRuntime::_wrong_method_blob; |
|
cba7b5c2d53f
7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents:
3363
diff
changeset
|
87 RuntimeStub* SharedRuntime::_ic_miss_blob; |
|
cba7b5c2d53f
7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents:
3363
diff
changeset
|
88 RuntimeStub* SharedRuntime::_resolve_opt_virtual_call_blob; |
|
cba7b5c2d53f
7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents:
3363
diff
changeset
|
89 RuntimeStub* SharedRuntime::_resolve_virtual_call_blob; |
|
cba7b5c2d53f
7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents:
3363
diff
changeset
|
90 RuntimeStub* SharedRuntime::_resolve_static_call_blob; |
|
cba7b5c2d53f
7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents:
3363
diff
changeset
|
91 |
|
cba7b5c2d53f
7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents:
3363
diff
changeset
|
92 DeoptimizationBlob* SharedRuntime::_deopt_blob; |
|
6792
137868b7aa6f
7196199: java/text/Bidi/Bug6665028.java failed: Bidi run count incorrect
kvn
parents:
6790
diff
changeset
|
93 SafepointBlob* SharedRuntime::_polling_page_vectors_safepoint_handler_blob; |
|
3753
cba7b5c2d53f
7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents:
3363
diff
changeset
|
94 SafepointBlob* SharedRuntime::_polling_page_safepoint_handler_blob; |
|
cba7b5c2d53f
7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents:
3363
diff
changeset
|
95 SafepointBlob* SharedRuntime::_polling_page_return_handler_blob; |
|
cba7b5c2d53f
7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents:
3363
diff
changeset
|
96 |
|
cba7b5c2d53f
7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents:
3363
diff
changeset
|
97 #ifdef COMPILER2 |
|
cba7b5c2d53f
7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents:
3363
diff
changeset
|
98 UncommonTrapBlob* SharedRuntime::_uncommon_trap_blob; |
|
cba7b5c2d53f
7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents:
3363
diff
changeset
|
99 #endif // COMPILER2 |
|
cba7b5c2d53f
7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents:
3363
diff
changeset
|
100 |
|
cba7b5c2d53f
7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents:
3363
diff
changeset
|
101 |
|
cba7b5c2d53f
7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents:
3363
diff
changeset
|
102 //----------------------------generate_stubs----------------------------------- |
|
cba7b5c2d53f
7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents:
3363
diff
changeset
|
103 void SharedRuntime::generate_stubs() { |
|
cba7b5c2d53f
7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents:
3363
diff
changeset
|
104 _wrong_method_blob = generate_resolve_blob(CAST_FROM_FN_PTR(address, SharedRuntime::handle_wrong_method), "wrong_method_stub"); |
|
cba7b5c2d53f
7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents:
3363
diff
changeset
|
105 _ic_miss_blob = generate_resolve_blob(CAST_FROM_FN_PTR(address, SharedRuntime::handle_wrong_method_ic_miss), "ic_miss_stub"); |
|
cba7b5c2d53f
7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents:
3363
diff
changeset
|
106 _resolve_opt_virtual_call_blob = generate_resolve_blob(CAST_FROM_FN_PTR(address, SharedRuntime::resolve_opt_virtual_call_C), "resolve_opt_virtual_call"); |
|
cba7b5c2d53f
7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents:
3363
diff
changeset
|
107 _resolve_virtual_call_blob = generate_resolve_blob(CAST_FROM_FN_PTR(address, SharedRuntime::resolve_virtual_call_C), "resolve_virtual_call"); |
|
cba7b5c2d53f
7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents:
3363
diff
changeset
|
108 _resolve_static_call_blob = generate_resolve_blob(CAST_FROM_FN_PTR(address, SharedRuntime::resolve_static_call_C), "resolve_static_call"); |
|
cba7b5c2d53f
7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents:
3363
diff
changeset
|
109 |
|
6792
137868b7aa6f
7196199: java/text/Bidi/Bug6665028.java failed: Bidi run count incorrect
kvn
parents:
6790
diff
changeset
|
110 #ifdef COMPILER2 |
|
137868b7aa6f
7196199: java/text/Bidi/Bug6665028.java failed: Bidi run count incorrect
kvn
parents:
6790
diff
changeset
|
111 // Vectors are generated only by C2. |
|
137868b7aa6f
7196199: java/text/Bidi/Bug6665028.java failed: Bidi run count incorrect
kvn
parents:
6790
diff
changeset
|
112 if (is_wide_vector(MaxVectorSize)) { |
|
137868b7aa6f
7196199: java/text/Bidi/Bug6665028.java failed: Bidi run count incorrect
kvn
parents:
6790
diff
changeset
|
113 _polling_page_vectors_safepoint_handler_blob = generate_handler_blob(CAST_FROM_FN_PTR(address, SafepointSynchronize::handle_polling_page_exception), POLL_AT_VECTOR_LOOP); |
|
137868b7aa6f
7196199: java/text/Bidi/Bug6665028.java failed: Bidi run count incorrect
kvn
parents:
6790
diff
changeset
|
114 } |
|
137868b7aa6f
7196199: java/text/Bidi/Bug6665028.java failed: Bidi run count incorrect
kvn
parents:
6790
diff
changeset
|
115 #endif // COMPILER2 |
|
137868b7aa6f
7196199: java/text/Bidi/Bug6665028.java failed: Bidi run count incorrect
kvn
parents:
6790
diff
changeset
|
116 _polling_page_safepoint_handler_blob = generate_handler_blob(CAST_FROM_FN_PTR(address, SafepointSynchronize::handle_polling_page_exception), POLL_AT_LOOP); |
|
137868b7aa6f
7196199: java/text/Bidi/Bug6665028.java failed: Bidi run count incorrect
kvn
parents:
6790
diff
changeset
|
117 _polling_page_return_handler_blob = generate_handler_blob(CAST_FROM_FN_PTR(address, SafepointSynchronize::handle_polling_page_exception), POLL_AT_RETURN); |
|
3753
cba7b5c2d53f
7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents:
3363
diff
changeset
|
118 |
|
cba7b5c2d53f
7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents:
3363
diff
changeset
|
119 generate_deopt_blob(); |
|
cba7b5c2d53f
7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents:
3363
diff
changeset
|
120 |
|
cba7b5c2d53f
7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents:
3363
diff
changeset
|
121 #ifdef COMPILER2 |
|
cba7b5c2d53f
7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents:
3363
diff
changeset
|
122 generate_uncommon_trap_blob(); |
|
cba7b5c2d53f
7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents:
3363
diff
changeset
|
123 #endif // COMPILER2 |
|
cba7b5c2d53f
7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents:
3363
diff
changeset
|
124 } |
|
cba7b5c2d53f
7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents:
3363
diff
changeset
|
125 |
| 0 | 126 #include <math.h> |
| 127 | |
| 4006 | 128 #ifndef USDT2 |
| 0 | 129 HS_DTRACE_PROBE_DECL4(hotspot, object__alloc, Thread*, char*, int, size_t); |
| 130 HS_DTRACE_PROBE_DECL7(hotspot, method__entry, int, | |
| 131 char*, int, char*, int, char*, int); | |
| 132 HS_DTRACE_PROBE_DECL7(hotspot, method__return, int, | |
| 133 char*, int, char*, int, char*, int); | |
| 4006 | 134 #endif /* !USDT2 */ |
| 0 | 135 |
| 136 // Implementation of SharedRuntime | |
| 137 | |
| 138 #ifndef PRODUCT | |
| 139 // For statistics | |
| 140 int SharedRuntime::_ic_miss_ctr = 0; | |
| 141 int SharedRuntime::_wrong_method_ctr = 0; | |
| 142 int SharedRuntime::_resolve_static_ctr = 0; | |
| 143 int SharedRuntime::_resolve_virtual_ctr = 0; | |
| 144 int SharedRuntime::_resolve_opt_virtual_ctr = 0; | |
| 145 int SharedRuntime::_implicit_null_throws = 0; | |
| 146 int SharedRuntime::_implicit_div0_throws = 0; | |
| 147 int SharedRuntime::_throw_null_ctr = 0; | |
| 148 | |
| 149 int SharedRuntime::_nof_normal_calls = 0; | |
| 150 int SharedRuntime::_nof_optimized_calls = 0; | |
| 151 int SharedRuntime::_nof_inlined_calls = 0; | |
| 152 int SharedRuntime::_nof_megamorphic_calls = 0; | |
| 153 int SharedRuntime::_nof_static_calls = 0; | |
| 154 int SharedRuntime::_nof_inlined_static_calls = 0; | |
| 155 int SharedRuntime::_nof_interface_calls = 0; | |
| 156 int SharedRuntime::_nof_optimized_interface_calls = 0; | |
| 157 int SharedRuntime::_nof_inlined_interface_calls = 0; | |
| 158 int SharedRuntime::_nof_megamorphic_interface_calls = 0; | |
| 159 int SharedRuntime::_nof_removable_exceptions = 0; | |
| 160 | |
| 161 int SharedRuntime::_new_instance_ctr=0; | |
| 162 int SharedRuntime::_new_array_ctr=0; | |
| 163 int SharedRuntime::_multi1_ctr=0; | |
| 164 int SharedRuntime::_multi2_ctr=0; | |
| 165 int SharedRuntime::_multi3_ctr=0; | |
| 166 int SharedRuntime::_multi4_ctr=0; | |
| 167 int SharedRuntime::_multi5_ctr=0; | |
| 168 int SharedRuntime::_mon_enter_stub_ctr=0; | |
| 169 int SharedRuntime::_mon_exit_stub_ctr=0; | |
| 170 int SharedRuntime::_mon_enter_ctr=0; | |
| 171 int SharedRuntime::_mon_exit_ctr=0; | |
| 172 int SharedRuntime::_partial_subtype_ctr=0; | |
| 173 int SharedRuntime::_jbyte_array_copy_ctr=0; | |
| 174 int SharedRuntime::_jshort_array_copy_ctr=0; | |
| 175 int SharedRuntime::_jint_array_copy_ctr=0; | |
| 176 int SharedRuntime::_jlong_array_copy_ctr=0; | |
| 177 int SharedRuntime::_oop_array_copy_ctr=0; | |
| 178 int SharedRuntime::_checkcast_array_copy_ctr=0; | |
| 179 int SharedRuntime::_unsafe_array_copy_ctr=0; | |
| 180 int SharedRuntime::_generic_array_copy_ctr=0; | |
| 181 int SharedRuntime::_slow_array_copy_ctr=0; | |
| 182 int SharedRuntime::_find_handler_ctr=0; | |
| 183 int SharedRuntime::_rethrow_ctr=0; | |
| 184 | |
| 185 int SharedRuntime::_ICmiss_index = 0; | |
| 186 int SharedRuntime::_ICmiss_count[SharedRuntime::maxICmiss_count]; | |
| 187 address SharedRuntime::_ICmiss_at[SharedRuntime::maxICmiss_count]; | |
| 188 | |
|
3753
cba7b5c2d53f
7045514: SPARC assembly code for JSR 292 ricochet frames
never
parents:
3363
diff
changeset
|
189 |
| 0 | 190 void SharedRuntime::trace_ic_miss(address at) { |
| 191 for (int i = 0; i < _ICmiss_index; i++) { | |
| 192 if (_ICmiss_at[i] == at) { | |
| 193 _ICmiss_count[i]++; | |
| 194 return; | |
| 195 } | |
| 196 } | |
| 197 int index = _ICmiss_index++; | |
| 198 if (_ICmiss_index >= maxICmiss_count) _ICmiss_index = maxICmiss_count - 1; | |
| 199 _ICmiss_at[index] = at; | |
| 200 _ICmiss_count[index] = 1; | |
| 201 } | |
| 202 | |
| 203 void SharedRuntime::print_ic_miss_histogram() { | |
| 204 if (ICMissHistogram) { | |
| 205 tty->print_cr ("IC Miss Histogram:"); | |
| 206 int tot_misses = 0; | |
| 207 for (int i = 0; i < _ICmiss_index; i++) { | |
| 208 tty->print_cr(" at: " INTPTR_FORMAT " nof: %d", _ICmiss_at[i], _ICmiss_count[i]); | |
| 209 tot_misses += _ICmiss_count[i]; | |
| 210 } | |
| 211 tty->print_cr ("Total IC misses: %7d", tot_misses); | |
| 212 } | |
| 213 } | |
| 214 #endif // PRODUCT | |
| 215 | |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7469
diff
changeset
|
216 #if INCLUDE_ALL_GCS |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
128
diff
changeset
|
217 |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
128
diff
changeset
|
218 // G1 write-barrier pre: executed before a pointer store. |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
128
diff
changeset
|
219 JRT_LEAF(void, SharedRuntime::g1_wb_pre(oopDesc* orig, JavaThread *thread)) |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
128
diff
changeset
|
220 if (orig == NULL) { |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
128
diff
changeset
|
221 assert(false, "should be optimized out"); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
128
diff
changeset
|
222 return; |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
128
diff
changeset
|
223 } |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
742
diff
changeset
|
224 assert(orig->is_oop(true /* ignore mark word */), "Error"); |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
128
diff
changeset
|
225 // store the original value that was in the field reference |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
128
diff
changeset
|
226 thread->satb_mark_queue().enqueue(orig); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
128
diff
changeset
|
227 JRT_END |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
128
diff
changeset
|
228 |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
128
diff
changeset
|
229 // G1 write-barrier post: executed after a pointer store. |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
128
diff
changeset
|
230 JRT_LEAF(void, SharedRuntime::g1_wb_post(void* card_addr, JavaThread* thread)) |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
128
diff
changeset
|
231 thread->dirty_card_queue().enqueue(card_addr); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
128
diff
changeset
|
232 JRT_END |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
128
diff
changeset
|
233 |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7469
diff
changeset
|
234 #endif // INCLUDE_ALL_GCS |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
128
diff
changeset
|
235 |
| 0 | 236 |
| 237 JRT_LEAF(jlong, SharedRuntime::lmul(jlong y, jlong x)) | |
| 238 return x * y; | |
| 239 JRT_END | |
| 240 | |
| 241 | |
| 242 JRT_LEAF(jlong, SharedRuntime::ldiv(jlong y, jlong x)) | |
| 243 if (x == min_jlong && y == CONST64(-1)) { | |
| 244 return x; | |
| 245 } else { | |
| 246 return x / y; | |
| 247 } | |
| 248 JRT_END | |
| 249 | |
| 250 | |
| 251 JRT_LEAF(jlong, SharedRuntime::lrem(jlong y, jlong x)) | |
| 252 if (x == min_jlong && y == CONST64(-1)) { | |
| 253 return 0; | |
| 254 } else { | |
| 255 return x % y; | |
| 256 } | |
| 257 JRT_END | |
| 258 | |
| 259 | |
| 260 const juint float_sign_mask = 0x7FFFFFFF; | |
| 261 const juint float_infinity = 0x7F800000; | |
| 262 const julong double_sign_mask = CONST64(0x7FFFFFFFFFFFFFFF); | |
| 263 const julong double_infinity = CONST64(0x7FF0000000000000); | |
| 264 | |
| 265 JRT_LEAF(jfloat, SharedRuntime::frem(jfloat x, jfloat y)) | |
| 266 #ifdef _WIN64 | |
| 267 // 64-bit Windows on amd64 returns the wrong values for | |
| 268 // infinity operands. | |
| 269 union { jfloat f; juint i; } xbits, ybits; | |
| 270 xbits.f = x; | |
| 271 ybits.f = y; | |
| 272 // x Mod Infinity == x unless x is infinity | |
| 273 if ( ((xbits.i & float_sign_mask) != float_infinity) && | |
| 274 ((ybits.i & float_sign_mask) == float_infinity) ) { | |
| 275 return x; | |
| 276 } | |
| 277 #endif | |
| 278 return ((jfloat)fmod((double)x,(double)y)); | |
| 279 JRT_END | |
| 280 | |
| 281 | |
| 282 JRT_LEAF(jdouble, SharedRuntime::drem(jdouble x, jdouble y)) | |
| 283 #ifdef _WIN64 | |
| 284 union { jdouble d; julong l; } xbits, ybits; | |
| 285 xbits.d = x; | |
| 286 ybits.d = y; | |
| 287 // x Mod Infinity == x unless x is infinity | |
| 288 if ( ((xbits.l & double_sign_mask) != double_infinity) && | |
| 289 ((ybits.l & double_sign_mask) == double_infinity) ) { | |
| 290 return x; | |
| 291 } | |
| 292 #endif | |
| 293 return ((jdouble)fmod((double)x,(double)y)); | |
| 294 JRT_END | |
| 295 | |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
296 #ifdef __SOFTFP__ |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
297 JRT_LEAF(jfloat, SharedRuntime::fadd(jfloat x, jfloat y)) |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
298 return x + y; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
299 JRT_END |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
300 |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
301 JRT_LEAF(jfloat, SharedRuntime::fsub(jfloat x, jfloat y)) |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
302 return x - y; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
303 JRT_END |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
304 |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
305 JRT_LEAF(jfloat, SharedRuntime::fmul(jfloat x, jfloat y)) |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
306 return x * y; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
307 JRT_END |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
308 |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
309 JRT_LEAF(jfloat, SharedRuntime::fdiv(jfloat x, jfloat y)) |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
310 return x / y; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
311 JRT_END |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
312 |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
313 JRT_LEAF(jdouble, SharedRuntime::dadd(jdouble x, jdouble y)) |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
314 return x + y; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
315 JRT_END |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
316 |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
317 JRT_LEAF(jdouble, SharedRuntime::dsub(jdouble x, jdouble y)) |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
318 return x - y; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
319 JRT_END |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
320 |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
321 JRT_LEAF(jdouble, SharedRuntime::dmul(jdouble x, jdouble y)) |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
322 return x * y; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
323 JRT_END |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
324 |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
325 JRT_LEAF(jdouble, SharedRuntime::ddiv(jdouble x, jdouble y)) |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
326 return x / y; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
327 JRT_END |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
328 |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
329 JRT_LEAF(jfloat, SharedRuntime::i2f(jint x)) |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
330 return (jfloat)x; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
331 JRT_END |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
332 |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
333 JRT_LEAF(jdouble, SharedRuntime::i2d(jint x)) |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
334 return (jdouble)x; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
335 JRT_END |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
336 |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
337 JRT_LEAF(jdouble, SharedRuntime::f2d(jfloat x)) |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
338 return (jdouble)x; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
339 JRT_END |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
340 |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
341 JRT_LEAF(int, SharedRuntime::fcmpl(float x, float y)) |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
342 return x>y ? 1 : (x==y ? 0 : -1); /* x<y or is_nan*/ |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
343 JRT_END |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
344 |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
345 JRT_LEAF(int, SharedRuntime::fcmpg(float x, float y)) |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
346 return x<y ? -1 : (x==y ? 0 : 1); /* x>y or is_nan */ |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
347 JRT_END |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
348 |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
349 JRT_LEAF(int, SharedRuntime::dcmpl(double x, double y)) |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
350 return x>y ? 1 : (x==y ? 0 : -1); /* x<y or is_nan */ |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
351 JRT_END |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
352 |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
353 JRT_LEAF(int, SharedRuntime::dcmpg(double x, double y)) |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
354 return x<y ? -1 : (x==y ? 0 : 1); /* x>y or is_nan */ |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
355 JRT_END |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
356 |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
357 // Functions to return the opposite of the aeabi functions for nan. |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
358 JRT_LEAF(int, SharedRuntime::unordered_fcmplt(float x, float y)) |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
359 return (x < y) ? 1 : ((g_isnan(x) || g_isnan(y)) ? 1 : 0); |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
360 JRT_END |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
361 |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
362 JRT_LEAF(int, SharedRuntime::unordered_dcmplt(double x, double y)) |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
363 return (x < y) ? 1 : ((g_isnan(x) || g_isnan(y)) ? 1 : 0); |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
364 JRT_END |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
365 |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
366 JRT_LEAF(int, SharedRuntime::unordered_fcmple(float x, float y)) |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
367 return (x <= y) ? 1 : ((g_isnan(x) || g_isnan(y)) ? 1 : 0); |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
368 JRT_END |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
369 |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
370 JRT_LEAF(int, SharedRuntime::unordered_dcmple(double x, double y)) |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
371 return (x <= y) ? 1 : ((g_isnan(x) || g_isnan(y)) ? 1 : 0); |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
372 JRT_END |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
373 |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
374 JRT_LEAF(int, SharedRuntime::unordered_fcmpge(float x, float y)) |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
375 return (x >= y) ? 1 : ((g_isnan(x) || g_isnan(y)) ? 1 : 0); |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
376 JRT_END |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
377 |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
378 JRT_LEAF(int, SharedRuntime::unordered_dcmpge(double x, double y)) |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
379 return (x >= y) ? 1 : ((g_isnan(x) || g_isnan(y)) ? 1 : 0); |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
380 JRT_END |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
381 |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
382 JRT_LEAF(int, SharedRuntime::unordered_fcmpgt(float x, float y)) |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
383 return (x > y) ? 1 : ((g_isnan(x) || g_isnan(y)) ? 1 : 0); |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
384 JRT_END |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
385 |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
386 JRT_LEAF(int, SharedRuntime::unordered_dcmpgt(double x, double y)) |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
387 return (x > y) ? 1 : ((g_isnan(x) || g_isnan(y)) ? 1 : 0); |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
388 JRT_END |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
389 |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
390 // Intrinsics make gcc generate code for these. |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
391 float SharedRuntime::fneg(float f) { |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
392 return -f; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
393 } |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
394 |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
395 double SharedRuntime::dneg(double f) { |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
396 return -f; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
397 } |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
398 |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
399 #endif // __SOFTFP__ |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
400 |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
401 #if defined(__SOFTFP__) || defined(E500V2) |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
402 // Intrinsics make gcc generate code for these. |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
403 double SharedRuntime::dabs(double f) { |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
404 return (f <= (double)0.0) ? (double)0.0 - f : f; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
405 } |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
406 |
|
1868
3dc12ef8735e
6989297: Integrate additional portability improvements
bobv
parents:
1793
diff
changeset
|
407 #endif |
|
3dc12ef8735e
6989297: Integrate additional portability improvements
bobv
parents:
1793
diff
changeset
|
408 |
|
3dc12ef8735e
6989297: Integrate additional portability improvements
bobv
parents:
1793
diff
changeset
|
409 #if defined(__SOFTFP__) || defined(PPC) |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
410 double SharedRuntime::dsqrt(double f) { |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
411 return sqrt(f); |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
412 } |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
413 #endif |
| 0 | 414 |
| 415 JRT_LEAF(jint, SharedRuntime::f2i(jfloat x)) | |
|
508
6d8fc951eb25
6778657: Casts in SharedRuntime::f2i, f2l, d2i and d2l rely on undefined C++ behaviour
kvn
parents:
465
diff
changeset
|
416 if (g_isnan(x)) |
|
6d8fc951eb25
6778657: Casts in SharedRuntime::f2i, f2l, d2i and d2l rely on undefined C++ behaviour
kvn
parents:
465
diff
changeset
|
417 return 0; |
|
6d8fc951eb25
6778657: Casts in SharedRuntime::f2i, f2l, d2i and d2l rely on undefined C++ behaviour
kvn
parents:
465
diff
changeset
|
418 if (x >= (jfloat) max_jint) |
|
6d8fc951eb25
6778657: Casts in SharedRuntime::f2i, f2l, d2i and d2l rely on undefined C++ behaviour
kvn
parents:
465
diff
changeset
|
419 return max_jint; |
|
6d8fc951eb25
6778657: Casts in SharedRuntime::f2i, f2l, d2i and d2l rely on undefined C++ behaviour
kvn
parents:
465
diff
changeset
|
420 if (x <= (jfloat) min_jint) |
|
6d8fc951eb25
6778657: Casts in SharedRuntime::f2i, f2l, d2i and d2l rely on undefined C++ behaviour
kvn
parents:
465
diff
changeset
|
421 return min_jint; |
|
6d8fc951eb25
6778657: Casts in SharedRuntime::f2i, f2l, d2i and d2l rely on undefined C++ behaviour
kvn
parents:
465
diff
changeset
|
422 return (jint) x; |
| 0 | 423 JRT_END |
| 424 | |
| 425 | |
| 426 JRT_LEAF(jlong, SharedRuntime::f2l(jfloat x)) | |
|
508
6d8fc951eb25
6778657: Casts in SharedRuntime::f2i, f2l, d2i and d2l rely on undefined C++ behaviour
kvn
parents:
465
diff
changeset
|
427 if (g_isnan(x)) |
|
6d8fc951eb25
6778657: Casts in SharedRuntime::f2i, f2l, d2i and d2l rely on undefined C++ behaviour
kvn
parents:
465
diff
changeset
|
428 return 0; |
|
6d8fc951eb25
6778657: Casts in SharedRuntime::f2i, f2l, d2i and d2l rely on undefined C++ behaviour
kvn
parents:
465
diff
changeset
|
429 if (x >= (jfloat) max_jlong) |
|
6d8fc951eb25
6778657: Casts in SharedRuntime::f2i, f2l, d2i and d2l rely on undefined C++ behaviour
kvn
parents:
465
diff
changeset
|
430 return max_jlong; |
|
6d8fc951eb25
6778657: Casts in SharedRuntime::f2i, f2l, d2i and d2l rely on undefined C++ behaviour
kvn
parents:
465
diff
changeset
|
431 if (x <= (jfloat) min_jlong) |
|
6d8fc951eb25
6778657: Casts in SharedRuntime::f2i, f2l, d2i and d2l rely on undefined C++ behaviour
kvn
parents:
465
diff
changeset
|
432 return min_jlong; |
|
6d8fc951eb25
6778657: Casts in SharedRuntime::f2i, f2l, d2i and d2l rely on undefined C++ behaviour
kvn
parents:
465
diff
changeset
|
433 return (jlong) x; |
| 0 | 434 JRT_END |
| 435 | |
| 436 | |
| 437 JRT_LEAF(jint, SharedRuntime::d2i(jdouble x)) | |
|
508
6d8fc951eb25
6778657: Casts in SharedRuntime::f2i, f2l, d2i and d2l rely on undefined C++ behaviour
kvn
parents:
465
diff
changeset
|
438 if (g_isnan(x)) |
|
6d8fc951eb25
6778657: Casts in SharedRuntime::f2i, f2l, d2i and d2l rely on undefined C++ behaviour
kvn
parents:
465
diff
changeset
|
439 return 0; |
|
6d8fc951eb25
6778657: Casts in SharedRuntime::f2i, f2l, d2i and d2l rely on undefined C++ behaviour
kvn
parents:
465
diff
changeset
|
440 if (x >= (jdouble) max_jint) |
|
6d8fc951eb25
6778657: Casts in SharedRuntime::f2i, f2l, d2i and d2l rely on undefined C++ behaviour
kvn
parents:
465
diff
changeset
|
441 return max_jint; |
|
6d8fc951eb25
6778657: Casts in SharedRuntime::f2i, f2l, d2i and d2l rely on undefined C++ behaviour
kvn
parents:
465
diff
changeset
|
442 if (x <= (jdouble) min_jint) |
|
6d8fc951eb25
6778657: Casts in SharedRuntime::f2i, f2l, d2i and d2l rely on undefined C++ behaviour
kvn
parents:
465
diff
changeset
|
443 return min_jint; |
|
6d8fc951eb25
6778657: Casts in SharedRuntime::f2i, f2l, d2i and d2l rely on undefined C++ behaviour
kvn
parents:
465
diff
changeset
|
444 return (jint) x; |
| 0 | 445 JRT_END |
| 446 | |
| 447 | |
| 448 JRT_LEAF(jlong, SharedRuntime::d2l(jdouble x)) | |
|
508
6d8fc951eb25
6778657: Casts in SharedRuntime::f2i, f2l, d2i and d2l rely on undefined C++ behaviour
kvn
parents:
465
diff
changeset
|
449 if (g_isnan(x)) |
|
6d8fc951eb25
6778657: Casts in SharedRuntime::f2i, f2l, d2i and d2l rely on undefined C++ behaviour
kvn
parents:
465
diff
changeset
|
450 return 0; |
|
6d8fc951eb25
6778657: Casts in SharedRuntime::f2i, f2l, d2i and d2l rely on undefined C++ behaviour
kvn
parents:
465
diff
changeset
|
451 if (x >= (jdouble) max_jlong) |
|
6d8fc951eb25
6778657: Casts in SharedRuntime::f2i, f2l, d2i and d2l rely on undefined C++ behaviour
kvn
parents:
465
diff
changeset
|
452 return max_jlong; |
|
6d8fc951eb25
6778657: Casts in SharedRuntime::f2i, f2l, d2i and d2l rely on undefined C++ behaviour
kvn
parents:
465
diff
changeset
|
453 if (x <= (jdouble) min_jlong) |
|
6d8fc951eb25
6778657: Casts in SharedRuntime::f2i, f2l, d2i and d2l rely on undefined C++ behaviour
kvn
parents:
465
diff
changeset
|
454 return min_jlong; |
|
6d8fc951eb25
6778657: Casts in SharedRuntime::f2i, f2l, d2i and d2l rely on undefined C++ behaviour
kvn
parents:
465
diff
changeset
|
455 return (jlong) x; |
| 0 | 456 JRT_END |
| 457 | |
| 458 | |
| 459 JRT_LEAF(jfloat, SharedRuntime::d2f(jdouble x)) | |
| 460 return (jfloat)x; | |
| 461 JRT_END | |
| 462 | |
| 463 | |
| 464 JRT_LEAF(jfloat, SharedRuntime::l2f(jlong x)) | |
| 465 return (jfloat)x; | |
| 466 JRT_END | |
| 467 | |
| 468 | |
| 469 JRT_LEAF(jdouble, SharedRuntime::l2d(jlong x)) | |
| 470 return (jdouble)x; | |
| 471 JRT_END | |
| 472 | |
| 473 // Exception handling accross interpreter/compiler boundaries | |
| 474 // | |
| 475 // exception_handler_for_return_address(...) returns the continuation address. | |
| 476 // The continuation address is the entry point of the exception handler of the | |
| 477 // previous frame depending on the return address. | |
| 478 | |
| 1295 | 479 address SharedRuntime::raw_exception_handler_for_return_address(JavaThread* thread, address return_address) { |
|
2321
1b4e6a5d98e0
7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents:
2192
diff
changeset
|
480 assert(frame::verify_return_pc(return_address), err_msg("must be a return address: " INTPTR_FORMAT, return_address)); |
|
1b4e6a5d98e0
7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents:
2192
diff
changeset
|
481 |
|
1b4e6a5d98e0
7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents:
2192
diff
changeset
|
482 // Reset method handle flag. |
|
1368
93767e6a2dfd
6941529: SharedRuntime::raw_exception_handler_for_return_address must reset thread MethodHandle flag
twisti
parents:
1299
diff
changeset
|
483 thread->set_is_method_handle_return(false); |
|
93767e6a2dfd
6941529: SharedRuntime::raw_exception_handler_for_return_address must reset thread MethodHandle flag
twisti
parents:
1299
diff
changeset
|
484 |
|
2321
1b4e6a5d98e0
7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents:
2192
diff
changeset
|
485 // The fastest case first |
| 0 | 486 CodeBlob* blob = CodeCache::find_blob(return_address); |
|
2321
1b4e6a5d98e0
7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents:
2192
diff
changeset
|
487 nmethod* nm = (blob != NULL) ? blob->as_nmethod_or_null() : NULL; |
|
1b4e6a5d98e0
7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents:
2192
diff
changeset
|
488 if (nm != NULL) { |
|
1b4e6a5d98e0
7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents:
2192
diff
changeset
|
489 // Set flag if return address is a method handle call site. |
|
1b4e6a5d98e0
7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents:
2192
diff
changeset
|
490 thread->set_is_method_handle_return(nm->is_method_handle_return(return_address)); |
| 0 | 491 // native nmethods don't have exception handlers |
|
2321
1b4e6a5d98e0
7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents:
2192
diff
changeset
|
492 assert(!nm->is_native_method(), "no exception handler"); |
|
1b4e6a5d98e0
7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents:
2192
diff
changeset
|
493 assert(nm->header_begin() != nm->exception_begin(), "no exception handler"); |
|
1b4e6a5d98e0
7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents:
2192
diff
changeset
|
494 if (nm->is_deopt_pc(return_address)) { |
| 0 | 495 return SharedRuntime::deopt_blob()->unpack_with_exception(); |
| 496 } else { | |
|
2321
1b4e6a5d98e0
7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents:
2192
diff
changeset
|
497 return nm->exception_begin(); |
| 0 | 498 } |
| 499 } | |
| 500 | |
| 501 // Entry code | |
| 502 if (StubRoutines::returns_to_call_stub(return_address)) { | |
| 503 return StubRoutines::catch_exception_entry(); | |
| 504 } | |
| 505 // Interpreted code | |
| 506 if (Interpreter::contains(return_address)) { | |
| 507 return Interpreter::rethrow_exception_entry(); | |
| 508 } | |
| 509 | |
|
2321
1b4e6a5d98e0
7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents:
2192
diff
changeset
|
510 guarantee(blob == NULL || !blob->is_runtime_stub(), "caller should have skipped stub"); |
| 0 | 511 guarantee(!VtableStubs::contains(return_address), "NULL exceptions in vtables should have been handled already!"); |
|
2321
1b4e6a5d98e0
7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents:
2192
diff
changeset
|
512 |
| 0 | 513 #ifndef PRODUCT |
| 514 { ResourceMark rm; | |
| 515 tty->print_cr("No exception handler found for exception at " INTPTR_FORMAT " - potential problems:", return_address); | |
| 516 tty->print_cr("a) exception happened in (new?) code stubs/buffers that is not handled here"); | |
| 517 tty->print_cr("b) other problem"); | |
| 518 } | |
| 519 #endif // PRODUCT | |
|
2321
1b4e6a5d98e0
7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents:
2192
diff
changeset
|
520 |
| 0 | 521 ShouldNotReachHere(); |
| 522 return NULL; | |
| 523 } | |
| 524 | |
| 525 | |
| 1295 | 526 JRT_LEAF(address, SharedRuntime::exception_handler_for_return_address(JavaThread* thread, address return_address)) |
| 527 return raw_exception_handler_for_return_address(thread, return_address); | |
| 0 | 528 JRT_END |
| 529 | |
| 1295 | 530 |
| 0 | 531 address SharedRuntime::get_poll_stub(address pc) { |
| 532 address stub; | |
| 533 // Look up the code blob | |
| 534 CodeBlob *cb = CodeCache::find_blob(pc); | |
| 535 | |
| 536 // Should be an nmethod | |
| 537 assert( cb && cb->is_nmethod(), "safepoint polling: pc must refer to an nmethod" ); | |
| 538 | |
| 539 // Look up the relocation information | |
| 540 assert( ((nmethod*)cb)->is_at_poll_or_poll_return(pc), | |
| 541 "safepoint polling: type must be poll" ); | |
| 542 | |
| 543 assert( ((NativeInstruction*)pc)->is_safepoint_poll(), | |
| 544 "Only polling locations are used for safepoint"); | |
| 545 | |
| 546 bool at_poll_return = ((nmethod*)cb)->is_at_poll_return(pc); | |
|
6792
137868b7aa6f
7196199: java/text/Bidi/Bug6665028.java failed: Bidi run count incorrect
kvn
parents:
6790
diff
changeset
|
547 bool has_wide_vectors = ((nmethod*)cb)->has_wide_vectors(); |
| 0 | 548 if (at_poll_return) { |
| 549 assert(SharedRuntime::polling_page_return_handler_blob() != NULL, | |
| 550 "polling page return stub not created yet"); | |
| 1748 | 551 stub = SharedRuntime::polling_page_return_handler_blob()->entry_point(); |
|
6792
137868b7aa6f
7196199: java/text/Bidi/Bug6665028.java failed: Bidi run count incorrect
kvn
parents:
6790
diff
changeset
|
552 } else if (has_wide_vectors) { |
|
137868b7aa6f
7196199: java/text/Bidi/Bug6665028.java failed: Bidi run count incorrect
kvn
parents:
6790
diff
changeset
|
553 assert(SharedRuntime::polling_page_vectors_safepoint_handler_blob() != NULL, |
|
137868b7aa6f
7196199: java/text/Bidi/Bug6665028.java failed: Bidi run count incorrect
kvn
parents:
6790
diff
changeset
|
554 "polling page vectors safepoint stub not created yet"); |
|
137868b7aa6f
7196199: java/text/Bidi/Bug6665028.java failed: Bidi run count incorrect
kvn
parents:
6790
diff
changeset
|
555 stub = SharedRuntime::polling_page_vectors_safepoint_handler_blob()->entry_point(); |
| 0 | 556 } else { |
| 557 assert(SharedRuntime::polling_page_safepoint_handler_blob() != NULL, | |
| 558 "polling page safepoint stub not created yet"); | |
| 1748 | 559 stub = SharedRuntime::polling_page_safepoint_handler_blob()->entry_point(); |
| 0 | 560 } |
| 561 #ifndef PRODUCT | |
| 562 if( TraceSafepoint ) { | |
| 563 char buf[256]; | |
| 564 jio_snprintf(buf, sizeof(buf), | |
| 565 "... found polling page %s exception at pc = " | |
| 566 INTPTR_FORMAT ", stub =" INTPTR_FORMAT, | |
| 567 at_poll_return ? "return" : "loop", | |
| 568 (intptr_t)pc, (intptr_t)stub); | |
| 569 tty->print_raw_cr(buf); | |
| 570 } | |
| 571 #endif // PRODUCT | |
| 572 return stub; | |
| 573 } | |
| 574 | |
| 575 | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2142
diff
changeset
|
576 oop SharedRuntime::retrieve_receiver( Symbol* sig, frame caller ) { |
| 0 | 577 assert(caller.is_interpreted_frame(), ""); |
| 578 int args_size = ArgumentSizeComputer(sig).size() + 1; | |
| 579 assert(args_size <= caller.interpreter_frame_expression_stack_size(), "receiver must be on interpreter stack"); | |
| 580 oop result = (oop) *caller.interpreter_frame_tos_at(args_size - 1); | |
| 581 assert(Universe::heap()->is_in(result) && result->is_oop(), "receiver must be an oop"); | |
| 582 return result; | |
| 583 } | |
| 584 | |
| 585 | |
| 586 void SharedRuntime::throw_and_post_jvmti_exception(JavaThread *thread, Handle h_exception) { | |
|
1213
6deeaebad47a
6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents:
1187
diff
changeset
|
587 if (JvmtiExport::can_post_on_exceptions()) { |
| 0 | 588 vframeStream vfst(thread, true); |
| 589 methodHandle method = methodHandle(thread, vfst.method()); | |
| 590 address bcp = method()->bcp_from(vfst.bci()); | |
| 591 JvmtiExport::post_exception_throw(thread, method(), bcp, h_exception()); | |
| 592 } | |
| 593 Exceptions::_throw(thread, __FILE__, __LINE__, h_exception); | |
| 594 } | |
| 595 | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2142
diff
changeset
|
596 void SharedRuntime::throw_and_post_jvmti_exception(JavaThread *thread, Symbol* name, const char *message) { |
| 0 | 597 Handle h_exception = Exceptions::new_exception(thread, name, message); |
| 598 throw_and_post_jvmti_exception(thread, h_exception); | |
| 599 } | |
| 600 | |
|
610
70998f2e05ef
6805864: 4/3 Problem with jvmti->redefineClasses: some methods don't get redefined
dcubed
parents:
465
diff
changeset
|
601 // The interpreter code to call this tracing function is only |
|
70998f2e05ef
6805864: 4/3 Problem with jvmti->redefineClasses: some methods don't get redefined
dcubed
parents:
465
diff
changeset
|
602 // called/generated when TraceRedefineClasses has the right bits |
|
70998f2e05ef
6805864: 4/3 Problem with jvmti->redefineClasses: some methods don't get redefined
dcubed
parents:
465
diff
changeset
|
603 // set. Since obsolete methods are never compiled, we don't have |
|
70998f2e05ef
6805864: 4/3 Problem with jvmti->redefineClasses: some methods don't get redefined
dcubed
parents:
465
diff
changeset
|
604 // to modify the compilers to generate calls to this function. |
|
70998f2e05ef
6805864: 4/3 Problem with jvmti->redefineClasses: some methods don't get redefined
dcubed
parents:
465
diff
changeset
|
605 // |
|
70998f2e05ef
6805864: 4/3 Problem with jvmti->redefineClasses: some methods don't get redefined
dcubed
parents:
465
diff
changeset
|
606 JRT_LEAF(int, SharedRuntime::rc_trace_method_entry( |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
607 JavaThread* thread, Method* method)) |
|
610
70998f2e05ef
6805864: 4/3 Problem with jvmti->redefineClasses: some methods don't get redefined
dcubed
parents:
465
diff
changeset
|
608 assert(RC_TRACE_IN_RANGE(0x00001000, 0x00002000), "wrong call"); |
|
70998f2e05ef
6805864: 4/3 Problem with jvmti->redefineClasses: some methods don't get redefined
dcubed
parents:
465
diff
changeset
|
609 |
|
70998f2e05ef
6805864: 4/3 Problem with jvmti->redefineClasses: some methods don't get redefined
dcubed
parents:
465
diff
changeset
|
610 if (method->is_obsolete()) { |
|
70998f2e05ef
6805864: 4/3 Problem with jvmti->redefineClasses: some methods don't get redefined
dcubed
parents:
465
diff
changeset
|
611 // We are calling an obsolete method, but this is not necessarily |
|
70998f2e05ef
6805864: 4/3 Problem with jvmti->redefineClasses: some methods don't get redefined
dcubed
parents:
465
diff
changeset
|
612 // an error. Our method could have been redefined just after we |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
613 // fetched the Method* from the constant pool. |
|
610
70998f2e05ef
6805864: 4/3 Problem with jvmti->redefineClasses: some methods don't get redefined
dcubed
parents:
465
diff
changeset
|
614 |
|
70998f2e05ef
6805864: 4/3 Problem with jvmti->redefineClasses: some methods don't get redefined
dcubed
parents:
465
diff
changeset
|
615 // RC_TRACE macro has an embedded ResourceMark |
|
70998f2e05ef
6805864: 4/3 Problem with jvmti->redefineClasses: some methods don't get redefined
dcubed
parents:
465
diff
changeset
|
616 RC_TRACE_WITH_THREAD(0x00001000, thread, |
|
70998f2e05ef
6805864: 4/3 Problem with jvmti->redefineClasses: some methods don't get redefined
dcubed
parents:
465
diff
changeset
|
617 ("calling obsolete method '%s'", |
|
70998f2e05ef
6805864: 4/3 Problem with jvmti->redefineClasses: some methods don't get redefined
dcubed
parents:
465
diff
changeset
|
618 method->name_and_sig_as_C_string())); |
|
70998f2e05ef
6805864: 4/3 Problem with jvmti->redefineClasses: some methods don't get redefined
dcubed
parents:
465
diff
changeset
|
619 if (RC_TRACE_ENABLED(0x00002000)) { |
|
70998f2e05ef
6805864: 4/3 Problem with jvmti->redefineClasses: some methods don't get redefined
dcubed
parents:
465
diff
changeset
|
620 // this option is provided to debug calls to obsolete methods |
|
70998f2e05ef
6805864: 4/3 Problem with jvmti->redefineClasses: some methods don't get redefined
dcubed
parents:
465
diff
changeset
|
621 guarantee(false, "faulting at call to an obsolete method."); |
|
70998f2e05ef
6805864: 4/3 Problem with jvmti->redefineClasses: some methods don't get redefined
dcubed
parents:
465
diff
changeset
|
622 } |
|
70998f2e05ef
6805864: 4/3 Problem with jvmti->redefineClasses: some methods don't get redefined
dcubed
parents:
465
diff
changeset
|
623 } |
|
70998f2e05ef
6805864: 4/3 Problem with jvmti->redefineClasses: some methods don't get redefined
dcubed
parents:
465
diff
changeset
|
624 return 0; |
|
70998f2e05ef
6805864: 4/3 Problem with jvmti->redefineClasses: some methods don't get redefined
dcubed
parents:
465
diff
changeset
|
625 JRT_END |
|
70998f2e05ef
6805864: 4/3 Problem with jvmti->redefineClasses: some methods don't get redefined
dcubed
parents:
465
diff
changeset
|
626 |
| 0 | 627 // ret_pc points into caller; we are returning caller's exception handler |
| 628 // for given exception | |
| 629 address SharedRuntime::compute_compiled_exc_handler(nmethod* nm, address ret_pc, Handle& exception, | |
| 630 bool force_unwind, bool top_frame_only) { | |
| 631 assert(nm != NULL, "must exist"); | |
| 632 ResourceMark rm; | |
| 633 | |
| 634 ScopeDesc* sd = nm->scope_desc_at(ret_pc); | |
| 635 // determine handler bci, if any | |
| 636 EXCEPTION_MARK; | |
| 637 | |
| 638 int handler_bci = -1; | |
| 639 int scope_depth = 0; | |
| 640 if (!force_unwind) { | |
| 641 int bci = sd->bci(); | |
|
3998
ec5ce9326985
6865265: JVM crashes with "missing exception handler" error
kvn
parents:
3841
diff
changeset
|
642 bool recursive_exception = false; |
| 0 | 643 do { |
| 644 bool skip_scope_increment = false; | |
| 645 // exception handler lookup | |
| 646 KlassHandle ek (THREAD, exception->klass()); | |
|
7469
0c8717a92b2d
8001341: SIGSEGV in methodOopDesc::fast_exception_handler_bci_for(KlassHandle,int,Thread*)+0x3e9.
jiangli
parents:
7199
diff
changeset
|
647 methodHandle mh(THREAD, sd->method()); |
|
0c8717a92b2d
8001341: SIGSEGV in methodOopDesc::fast_exception_handler_bci_for(KlassHandle,int,Thread*)+0x3e9.
jiangli
parents:
7199
diff
changeset
|
648 handler_bci = Method::fast_exception_handler_bci_for(mh, ek, bci, THREAD); |
| 0 | 649 if (HAS_PENDING_EXCEPTION) { |
|
3998
ec5ce9326985
6865265: JVM crashes with "missing exception handler" error
kvn
parents:
3841
diff
changeset
|
650 recursive_exception = true; |
| 0 | 651 // We threw an exception while trying to find the exception handler. |
| 652 // Transfer the new exception to the exception handle which will | |
| 653 // be set into thread local storage, and do another lookup for an | |
| 654 // exception handler for this exception, this time starting at the | |
| 655 // BCI of the exception handler which caused the exception to be | |
| 656 // thrown (bugs 4307310 and 4546590). Set "exception" reference | |
| 657 // argument to ensure that the correct exception is thrown (4870175). | |
| 658 exception = Handle(THREAD, PENDING_EXCEPTION); | |
| 659 CLEAR_PENDING_EXCEPTION; | |
| 660 if (handler_bci >= 0) { | |
| 661 bci = handler_bci; | |
| 662 handler_bci = -1; | |
| 663 skip_scope_increment = true; | |
| 664 } | |
| 665 } | |
|
3998
ec5ce9326985
6865265: JVM crashes with "missing exception handler" error
kvn
parents:
3841
diff
changeset
|
666 else { |
|
ec5ce9326985
6865265: JVM crashes with "missing exception handler" error
kvn
parents:
3841
diff
changeset
|
667 recursive_exception = false; |
|
ec5ce9326985
6865265: JVM crashes with "missing exception handler" error
kvn
parents:
3841
diff
changeset
|
668 } |
| 0 | 669 if (!top_frame_only && handler_bci < 0 && !skip_scope_increment) { |
| 670 sd = sd->sender(); | |
| 671 if (sd != NULL) { | |
| 672 bci = sd->bci(); | |
| 673 } | |
| 674 ++scope_depth; | |
| 675 } | |
|
3998
ec5ce9326985
6865265: JVM crashes with "missing exception handler" error
kvn
parents:
3841
diff
changeset
|
676 } while (recursive_exception || (!top_frame_only && handler_bci < 0 && sd != NULL)); |
| 0 | 677 } |
| 678 | |
| 679 // found handling method => lookup exception handler | |
| 1748 | 680 int catch_pco = ret_pc - nm->code_begin(); |
| 0 | 681 |
| 682 ExceptionHandlerTable table(nm); | |
| 683 HandlerTableEntry *t = table.entry_for(catch_pco, handler_bci, scope_depth); | |
| 684 if (t == NULL && (nm->is_compiled_by_c1() || handler_bci != -1)) { | |
| 685 // Allow abbreviated catch tables. The idea is to allow a method | |
| 686 // to materialize its exceptions without committing to the exact | |
| 687 // routing of exceptions. In particular this is needed for adding | |
| 688 // a synthethic handler to unlock monitors when inlining | |
| 689 // synchonized methods since the unlock path isn't represented in | |
| 690 // the bytecodes. | |
| 691 t = table.entry_for(catch_pco, -1, 0); | |
| 692 } | |
| 693 | |
|
1378
9f5b60a14736
6939930: exception unwind changes in 6919934 hurts compilation speed
never
parents:
1368
diff
changeset
|
694 #ifdef COMPILER1 |
|
9f5b60a14736
6939930: exception unwind changes in 6919934 hurts compilation speed
never
parents:
1368
diff
changeset
|
695 if (t == NULL && nm->is_compiled_by_c1()) { |
|
9f5b60a14736
6939930: exception unwind changes in 6919934 hurts compilation speed
never
parents:
1368
diff
changeset
|
696 assert(nm->unwind_handler_begin() != NULL, ""); |
|
9f5b60a14736
6939930: exception unwind changes in 6919934 hurts compilation speed
never
parents:
1368
diff
changeset
|
697 return nm->unwind_handler_begin(); |
|
9f5b60a14736
6939930: exception unwind changes in 6919934 hurts compilation speed
never
parents:
1368
diff
changeset
|
698 } |
|
9f5b60a14736
6939930: exception unwind changes in 6919934 hurts compilation speed
never
parents:
1368
diff
changeset
|
699 #endif |
|
9f5b60a14736
6939930: exception unwind changes in 6919934 hurts compilation speed
never
parents:
1368
diff
changeset
|
700 |
| 0 | 701 if (t == NULL) { |
| 702 tty->print_cr("MISSING EXCEPTION HANDLER for pc " INTPTR_FORMAT " and handler bci %d", ret_pc, handler_bci); | |
| 703 tty->print_cr(" Exception:"); | |
| 704 exception->print(); | |
| 705 tty->cr(); | |
| 706 tty->print_cr(" Compiled exception table :"); | |
| 707 table.print(); | |
| 708 nm->print_code(); | |
| 709 guarantee(false, "missing exception handler"); | |
| 710 return NULL; | |
| 711 } | |
| 712 | |
| 1748 | 713 return nm->code_begin() + t->pco(); |
| 0 | 714 } |
| 715 | |
| 716 JRT_ENTRY(void, SharedRuntime::throw_AbstractMethodError(JavaThread* thread)) | |
| 717 // These errors occur only at call sites | |
| 718 throw_and_post_jvmti_exception(thread, vmSymbols::java_lang_AbstractMethodError()); | |
| 719 JRT_END | |
| 720 | |
|
16
f8236e79048a
6664627: Merge changes made only in hotspot 11 forward to jdk 7
dcubed
parents:
0
diff
changeset
|
721 JRT_ENTRY(void, SharedRuntime::throw_IncompatibleClassChangeError(JavaThread* thread)) |
|
f8236e79048a
6664627: Merge changes made only in hotspot 11 forward to jdk 7
dcubed
parents:
0
diff
changeset
|
722 // These errors occur only at call sites |
|
f8236e79048a
6664627: Merge changes made only in hotspot 11 forward to jdk 7
dcubed
parents:
0
diff
changeset
|
723 throw_and_post_jvmti_exception(thread, vmSymbols::java_lang_IncompatibleClassChangeError(), "vtable stub"); |
|
f8236e79048a
6664627: Merge changes made only in hotspot 11 forward to jdk 7
dcubed
parents:
0
diff
changeset
|
724 JRT_END |
|
f8236e79048a
6664627: Merge changes made only in hotspot 11 forward to jdk 7
dcubed
parents:
0
diff
changeset
|
725 |
| 0 | 726 JRT_ENTRY(void, SharedRuntime::throw_ArithmeticException(JavaThread* thread)) |
| 727 throw_and_post_jvmti_exception(thread, vmSymbols::java_lang_ArithmeticException(), "/ by zero"); | |
| 728 JRT_END | |
| 729 | |
| 730 JRT_ENTRY(void, SharedRuntime::throw_NullPointerException(JavaThread* thread)) | |
| 731 throw_and_post_jvmti_exception(thread, vmSymbols::java_lang_NullPointerException()); | |
| 732 JRT_END | |
| 733 | |
| 734 JRT_ENTRY(void, SharedRuntime::throw_NullPointerException_at_call(JavaThread* thread)) | |
| 735 // This entry point is effectively only used for NullPointerExceptions which occur at inline | |
| 736 // cache sites (when the callee activation is not yet set up) so we are at a call site | |
| 737 throw_and_post_jvmti_exception(thread, vmSymbols::java_lang_NullPointerException()); | |
| 738 JRT_END | |
| 739 | |
| 740 JRT_ENTRY(void, SharedRuntime::throw_StackOverflowError(JavaThread* thread)) | |
| 741 // We avoid using the normal exception construction in this case because | |
| 742 // it performs an upcall to Java, and we're already out of stack space. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
743 Klass* k = SystemDictionary::StackOverflowError_klass(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
744 oop exception_oop = InstanceKlass::cast(k)->allocate_instance(CHECK); |
| 0 | 745 Handle exception (thread, exception_oop); |
| 746 if (StackTraceInThrowable) { | |
| 747 java_lang_Throwable::fill_in_stack_trace(exception); | |
| 748 } | |
| 749 throw_and_post_jvmti_exception(thread, exception); | |
| 750 JRT_END | |
| 751 | |
| 752 address SharedRuntime::continuation_for_implicit_exception(JavaThread* thread, | |
| 753 address pc, | |
| 754 SharedRuntime::ImplicitExceptionKind exception_kind) | |
| 755 { | |
| 756 address target_pc = NULL; | |
| 757 | |
| 758 if (Interpreter::contains(pc)) { | |
| 759 #ifdef CC_INTERP | |
| 760 // C++ interpreter doesn't throw implicit exceptions | |
| 761 ShouldNotReachHere(); | |
| 762 #else | |
| 763 switch (exception_kind) { | |
| 764 case IMPLICIT_NULL: return Interpreter::throw_NullPointerException_entry(); | |
| 765 case IMPLICIT_DIVIDE_BY_ZERO: return Interpreter::throw_ArithmeticException_entry(); | |
| 766 case STACK_OVERFLOW: return Interpreter::throw_StackOverflowError_entry(); | |
| 767 default: ShouldNotReachHere(); | |
| 768 } | |
| 769 #endif // !CC_INTERP | |
| 770 } else { | |
| 771 switch (exception_kind) { | |
| 772 case STACK_OVERFLOW: { | |
| 773 // Stack overflow only occurs upon frame setup; the callee is | |
| 774 // going to be unwound. Dispatch to a shared runtime stub | |
| 775 // which will cause the StackOverflowError to be fabricated | |
| 776 // and processed. | |
| 777 // For stack overflow in deoptimization blob, cleanup thread. | |
| 778 if (thread->deopt_mark() != NULL) { | |
| 779 Deoptimization::cleanup_deopt_info(thread, NULL); | |
| 780 } | |
| 4944 | 781 Events::log_exception(thread, "StackOverflowError at " INTPTR_FORMAT, pc); |
| 0 | 782 return StubRoutines::throw_StackOverflowError_entry(); |
| 783 } | |
| 784 | |
| 785 case IMPLICIT_NULL: { | |
| 786 if (VtableStubs::contains(pc)) { | |
| 787 // We haven't yet entered the callee frame. Fabricate an | |
| 788 // exception and begin dispatching it in the caller. Since | |
| 789 // the caller was at a call site, it's safe to destroy all | |
| 790 // caller-saved registers, as these entry points do. | |
| 791 VtableStub* vt_stub = VtableStubs::stub_containing(pc); | |
|
465
dc16daa0329d
6739363: Xcheck jni doesn't check native function arguments
poonam
parents:
356
diff
changeset
|
792 |
|
dc16daa0329d
6739363: Xcheck jni doesn't check native function arguments
poonam
parents:
356
diff
changeset
|
793 // If vt_stub is NULL, then return NULL to signal handler to report the SEGV error. |
|
dc16daa0329d
6739363: Xcheck jni doesn't check native function arguments
poonam
parents:
356
diff
changeset
|
794 if (vt_stub == NULL) return NULL; |
|
dc16daa0329d
6739363: Xcheck jni doesn't check native function arguments
poonam
parents:
356
diff
changeset
|
795 |
| 0 | 796 if (vt_stub->is_abstract_method_error(pc)) { |
| 797 assert(!vt_stub->is_vtable_stub(), "should never see AbstractMethodErrors from vtable-type VtableStubs"); | |
| 4944 | 798 Events::log_exception(thread, "AbstractMethodError at " INTPTR_FORMAT, pc); |
| 0 | 799 return StubRoutines::throw_AbstractMethodError_entry(); |
| 800 } else { | |
| 4944 | 801 Events::log_exception(thread, "NullPointerException at vtable entry " INTPTR_FORMAT, pc); |
| 0 | 802 return StubRoutines::throw_NullPointerException_at_call_entry(); |
| 803 } | |
| 804 } else { | |
| 805 CodeBlob* cb = CodeCache::find_blob(pc); | |
|
465
dc16daa0329d
6739363: Xcheck jni doesn't check native function arguments
poonam
parents:
356
diff
changeset
|
806 |
|
dc16daa0329d
6739363: Xcheck jni doesn't check native function arguments
poonam
parents:
356
diff
changeset
|
807 // If code blob is NULL, then return NULL to signal handler to report the SEGV error. |
|
dc16daa0329d
6739363: Xcheck jni doesn't check native function arguments
poonam
parents:
356
diff
changeset
|
808 if (cb == NULL) return NULL; |
| 0 | 809 |
| 810 // Exception happened in CodeCache. Must be either: | |
| 811 // 1. Inline-cache check in C2I handler blob, | |
| 812 // 2. Inline-cache check in nmethod, or | |
| 813 // 3. Implict null exception in nmethod | |
| 814 | |
| 815 if (!cb->is_nmethod()) { | |
|
1299
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1295
diff
changeset
|
816 guarantee(cb->is_adapter_blob() || cb->is_method_handles_adapter_blob(), |
|
465
dc16daa0329d
6739363: Xcheck jni doesn't check native function arguments
poonam
parents:
356
diff
changeset
|
817 "exception happened outside interpreter, nmethods and vtable stubs (1)"); |
| 4944 | 818 Events::log_exception(thread, "NullPointerException in code blob at " INTPTR_FORMAT, pc); |
| 0 | 819 // There is no handler here, so we will simply unwind. |
| 820 return StubRoutines::throw_NullPointerException_at_call_entry(); | |
| 821 } | |
| 822 | |
| 823 // Otherwise, it's an nmethod. Consult its exception handlers. | |
| 824 nmethod* nm = (nmethod*)cb; | |
| 825 if (nm->inlinecache_check_contains(pc)) { | |
| 826 // exception happened inside inline-cache check code | |
| 827 // => the nmethod is not yet active (i.e., the frame | |
| 828 // is not set up yet) => use return address pushed by | |
| 829 // caller => don't push another return address | |
| 4944 | 830 Events::log_exception(thread, "NullPointerException in IC check " INTPTR_FORMAT, pc); |
| 0 | 831 return StubRoutines::throw_NullPointerException_at_call_entry(); |
| 832 } | |
| 833 | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
834 if (nm->method()->is_method_handle_intrinsic()) { |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
835 // exception happened inside MH dispatch code, similar to a vtable stub |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
836 Events::log_exception(thread, "NullPointerException in MH adapter " INTPTR_FORMAT, pc); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
837 return StubRoutines::throw_NullPointerException_at_call_entry(); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
838 } |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
839 |
| 0 | 840 #ifndef PRODUCT |
| 841 _implicit_null_throws++; | |
| 842 #endif | |
| 843 target_pc = nm->continuation_for_implicit_exception(pc); | |
| 1250 | 844 // If there's an unexpected fault, target_pc might be NULL, |
| 845 // in which case we want to fall through into the normal | |
| 846 // error handling code. | |
| 0 | 847 } |
| 848 | |
| 849 break; // fall through | |
| 850 } | |
| 851 | |
| 852 | |
| 853 case IMPLICIT_DIVIDE_BY_ZERO: { | |
| 854 nmethod* nm = CodeCache::find_nmethod(pc); | |
| 855 guarantee(nm != NULL, "must have containing nmethod for implicit division-by-zero exceptions"); | |
| 856 #ifndef PRODUCT | |
| 857 _implicit_div0_throws++; | |
| 858 #endif | |
| 859 target_pc = nm->continuation_for_implicit_exception(pc); | |
| 1250 | 860 // If there's an unexpected fault, target_pc might be NULL, |
| 861 // in which case we want to fall through into the normal | |
| 862 // error handling code. | |
| 0 | 863 break; // fall through |
| 864 } | |
| 865 | |
| 866 default: ShouldNotReachHere(); | |
| 867 } | |
| 868 | |
| 869 assert(exception_kind == IMPLICIT_NULL || exception_kind == IMPLICIT_DIVIDE_BY_ZERO, "wrong implicit exception kind"); | |
| 870 | |
| 871 // for AbortVMOnException flag | |
| 872 NOT_PRODUCT(Exceptions::debug_check_abort("java.lang.NullPointerException")); | |
| 873 if (exception_kind == IMPLICIT_NULL) { | |
|
4872
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4807
diff
changeset
|
874 Events::log_exception(thread, "Implicit null exception at " INTPTR_FORMAT " to " INTPTR_FORMAT, pc, target_pc); |
| 0 | 875 } else { |
|
4872
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4807
diff
changeset
|
876 Events::log_exception(thread, "Implicit division by zero exception at " INTPTR_FORMAT " to " INTPTR_FORMAT, pc, target_pc); |
| 0 | 877 } |
| 878 return target_pc; | |
| 879 } | |
| 880 | |
| 881 ShouldNotReachHere(); | |
| 882 return NULL; | |
| 883 } | |
| 884 | |
| 885 | |
| 886 JNI_ENTRY(void, throw_unsatisfied_link_error(JNIEnv* env, ...)) | |
| 887 { | |
| 888 THROW(vmSymbols::java_lang_UnsatisfiedLinkError()); | |
| 889 } | |
| 890 JNI_END | |
| 891 | |
|
6271
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
6266
diff
changeset
|
892 JNI_ENTRY(void, throw_unsupported_operation_exception(JNIEnv* env, ...)) |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
6266
diff
changeset
|
893 { |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
6266
diff
changeset
|
894 THROW(vmSymbols::java_lang_UnsupportedOperationException()); |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
6266
diff
changeset
|
895 } |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
6266
diff
changeset
|
896 JNI_END |
| 0 | 897 |
| 898 address SharedRuntime::native_method_throw_unsatisfied_link_error_entry() { | |
| 899 return CAST_FROM_FN_PTR(address, &throw_unsatisfied_link_error); | |
| 900 } | |
| 901 | |
|
6271
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
6266
diff
changeset
|
902 address SharedRuntime::native_method_throw_unsupported_operation_exception_entry() { |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
6266
diff
changeset
|
903 return CAST_FROM_FN_PTR(address, &throw_unsupported_operation_exception); |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
6266
diff
changeset
|
904 } |
|
93c71eb28866
7188911: nightly failures after JSR 292 lazy method handle update (round 2)
twisti
parents:
6266
diff
changeset
|
905 |
| 0 | 906 |
| 907 #ifndef PRODUCT | |
| 908 JRT_ENTRY(intptr_t, SharedRuntime::trace_bytecode(JavaThread* thread, intptr_t preserve_this_value, intptr_t tos, intptr_t tos2)) | |
| 909 const frame f = thread->last_frame(); | |
| 910 assert(f.is_interpreted_frame(), "must be an interpreted frame"); | |
| 911 #ifndef PRODUCT | |
| 912 methodHandle mh(THREAD, f.interpreter_frame_method()); | |
| 913 BytecodeTracer::trace(mh, f.interpreter_frame_bcp(), tos, tos2); | |
| 914 #endif // !PRODUCT | |
| 915 return preserve_this_value; | |
| 916 JRT_END | |
| 917 #endif // !PRODUCT | |
| 918 | |
| 919 | |
| 920 JRT_ENTRY(void, SharedRuntime::yield_all(JavaThread* thread, int attempts)) | |
| 921 os::yield_all(attempts); | |
| 922 JRT_END | |
| 923 | |
| 924 | |
| 925 JRT_ENTRY_NO_ASYNC(void, SharedRuntime::register_finalizer(JavaThread* thread, oopDesc* obj)) | |
| 926 assert(obj->is_oop(), "must be a valid oop"); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
927 assert(obj->klass()->has_finalizer(), "shouldn't be here otherwise"); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
928 InstanceKlass::register_finalizer(instanceOop(obj), CHECK); |
| 0 | 929 JRT_END |
| 930 | |
| 931 | |
| 932 jlong SharedRuntime::get_java_tid(Thread* thread) { | |
| 933 if (thread != NULL) { | |
| 934 if (thread->is_Java_thread()) { | |
| 935 oop obj = ((JavaThread*)thread)->threadObj(); | |
| 936 return (obj == NULL) ? 0 : java_lang_Thread::thread_id(obj); | |
| 937 } | |
| 938 } | |
| 939 return 0; | |
| 940 } | |
| 941 | |
| 942 /** | |
| 943 * This function ought to be a void function, but cannot be because | |
| 944 * it gets turned into a tail-call on sparc, which runs into dtrace bug | |
| 945 * 6254741. Once that is fixed we can remove the dummy return value. | |
| 946 */ | |
| 947 int SharedRuntime::dtrace_object_alloc(oopDesc* o) { | |
| 948 return dtrace_object_alloc_base(Thread::current(), o); | |
| 949 } | |
| 950 | |
| 951 int SharedRuntime::dtrace_object_alloc_base(Thread* thread, oopDesc* o) { | |
| 952 assert(DTraceAllocProbes, "wrong call"); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
953 Klass* klass = o->klass(); |
| 0 | 954 int size = o->size(); |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2142
diff
changeset
|
955 Symbol* name = klass->name(); |
| 4006 | 956 #ifndef USDT2 |
| 0 | 957 HS_DTRACE_PROBE4(hotspot, object__alloc, get_java_tid(thread), |
| 958 name->bytes(), name->utf8_length(), size * HeapWordSize); | |
| 4006 | 959 #else /* USDT2 */ |
| 960 HOTSPOT_OBJECT_ALLOC( | |
| 961 get_java_tid(thread), | |
| 962 (char *) name->bytes(), name->utf8_length(), size * HeapWordSize); | |
| 963 #endif /* USDT2 */ | |
| 0 | 964 return 0; |
| 965 } | |
| 966 | |
| 967 JRT_LEAF(int, SharedRuntime::dtrace_method_entry( | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
968 JavaThread* thread, Method* method)) |
| 0 | 969 assert(DTraceMethodProbes, "wrong call"); |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2142
diff
changeset
|
970 Symbol* kname = method->klass_name(); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2142
diff
changeset
|
971 Symbol* name = method->name(); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2142
diff
changeset
|
972 Symbol* sig = method->signature(); |
| 4006 | 973 #ifndef USDT2 |
| 0 | 974 HS_DTRACE_PROBE7(hotspot, method__entry, get_java_tid(thread), |
| 975 kname->bytes(), kname->utf8_length(), | |
| 976 name->bytes(), name->utf8_length(), | |
| 977 sig->bytes(), sig->utf8_length()); | |
| 4006 | 978 #else /* USDT2 */ |
| 979 HOTSPOT_METHOD_ENTRY( | |
| 980 get_java_tid(thread), | |
| 981 (char *) kname->bytes(), kname->utf8_length(), | |
| 982 (char *) name->bytes(), name->utf8_length(), | |
| 983 (char *) sig->bytes(), sig->utf8_length()); | |
| 984 #endif /* USDT2 */ | |
| 0 | 985 return 0; |
| 986 JRT_END | |
| 987 | |
| 988 JRT_LEAF(int, SharedRuntime::dtrace_method_exit( | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
989 JavaThread* thread, Method* method)) |
| 0 | 990 assert(DTraceMethodProbes, "wrong call"); |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2142
diff
changeset
|
991 Symbol* kname = method->klass_name(); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2142
diff
changeset
|
992 Symbol* name = method->name(); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2142
diff
changeset
|
993 Symbol* sig = method->signature(); |
| 4006 | 994 #ifndef USDT2 |
| 0 | 995 HS_DTRACE_PROBE7(hotspot, method__return, get_java_tid(thread), |
| 996 kname->bytes(), kname->utf8_length(), | |
| 997 name->bytes(), name->utf8_length(), | |
| 998 sig->bytes(), sig->utf8_length()); | |
| 4006 | 999 #else /* USDT2 */ |
| 1000 HOTSPOT_METHOD_RETURN( | |
| 1001 get_java_tid(thread), | |
| 1002 (char *) kname->bytes(), kname->utf8_length(), | |
| 1003 (char *) name->bytes(), name->utf8_length(), | |
| 1004 (char *) sig->bytes(), sig->utf8_length()); | |
| 1005 #endif /* USDT2 */ | |
| 0 | 1006 return 0; |
| 1007 JRT_END | |
| 1008 | |
| 1009 | |
| 1010 // Finds receiver, CallInfo (i.e. receiver method), and calling bytecode) | |
| 1011 // for a call current in progress, i.e., arguments has been pushed on stack | |
| 1012 // put callee has not been invoked yet. Used by: resolve virtual/static, | |
| 1013 // vtable updates, etc. Caller frame must be compiled. | |
| 1014 Handle SharedRuntime::find_callee_info(JavaThread* thread, Bytecodes::Code& bc, CallInfo& callinfo, TRAPS) { | |
| 1015 ResourceMark rm(THREAD); | |
| 1016 | |
| 1017 // last java frame on stack (which includes native call frames) | |
| 1018 vframeStream vfst(thread, true); // Do not skip and javaCalls | |
| 1019 | |
| 1020 return find_callee_info_helper(thread, vfst, bc, callinfo, CHECK_(Handle())); | |
| 1021 } | |
| 1022 | |
| 1023 | |
| 1024 // Finds receiver, CallInfo (i.e. receiver method), and calling bytecode | |
| 1025 // for a call current in progress, i.e., arguments has been pushed on stack | |
| 1026 // but callee has not been invoked yet. Caller frame must be compiled. | |
| 1027 Handle SharedRuntime::find_callee_info_helper(JavaThread* thread, | |
| 1028 vframeStream& vfst, | |
| 1029 Bytecodes::Code& bc, | |
| 1030 CallInfo& callinfo, TRAPS) { | |
| 1031 Handle receiver; | |
| 1032 Handle nullHandle; //create a handy null handle for exception returns | |
| 1033 | |
| 1034 assert(!vfst.at_end(), "Java frame must exist"); | |
| 1035 | |
| 1036 // Find caller and bci from vframe | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
1037 methodHandle caller(THREAD, vfst.method()); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
1038 int bci = vfst.bci(); |
| 0 | 1039 |
| 1040 // Find bytecode | |
| 2142 | 1041 Bytecode_invoke bytecode(caller, bci); |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
1042 bc = bytecode.invoke_code(); |
| 2142 | 1043 int bytecode_index = bytecode.index(); |
| 0 | 1044 |
| 1045 // Find receiver for non-static call | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
1046 if (bc != Bytecodes::_invokestatic && |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
1047 bc != Bytecodes::_invokedynamic) { |
| 0 | 1048 // This register map must be update since we need to find the receiver for |
| 1049 // compiled frames. The receiver might be in a register. | |
| 1050 RegisterMap reg_map2(thread); | |
| 1051 frame stubFrame = thread->last_frame(); | |
| 1052 // Caller-frame is a compiled frame | |
| 1053 frame callerFrame = stubFrame.sender(®_map2); | |
| 1054 | |
| 2142 | 1055 methodHandle callee = bytecode.static_target(CHECK_(nullHandle)); |
| 0 | 1056 if (callee.is_null()) { |
| 1057 THROW_(vmSymbols::java_lang_NoSuchMethodException(), nullHandle); | |
| 1058 } | |
| 1059 // Retrieve from a compiled argument list | |
| 1060 receiver = Handle(THREAD, callerFrame.retrieve_receiver(®_map2)); | |
| 1061 | |
| 1062 if (receiver.is_null()) { | |
| 1063 THROW_(vmSymbols::java_lang_NullPointerException(), nullHandle); | |
| 1064 } | |
| 1065 } | |
| 1066 | |
| 1067 // Resolve method. This is parameterized by bytecode. | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
1068 constantPoolHandle constants(THREAD, caller->constants()); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
1069 assert(receiver.is_null() || receiver->is_oop(), "wrong receiver"); |
| 0 | 1070 LinkResolver::resolve_invoke(callinfo, receiver, constants, bytecode_index, bc, CHECK_(nullHandle)); |
| 1071 | |
| 1072 #ifdef ASSERT | |
| 1073 // Check that the receiver klass is of the right subtype and that it is initialized for virtual calls | |
|
1135
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
845
diff
changeset
|
1074 if (bc != Bytecodes::_invokestatic && bc != Bytecodes::_invokedynamic) { |
| 0 | 1075 assert(receiver.not_null(), "should have thrown exception"); |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
1076 KlassHandle receiver_klass(THREAD, receiver->klass()); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1077 Klass* rk = constants->klass_ref_at(bytecode_index, CHECK_(nullHandle)); |
| 0 | 1078 // klass is already loaded |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
1079 KlassHandle static_receiver_klass(THREAD, rk); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
1080 // Method handle invokes might have been optimized to a direct call |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
1081 // so don't check for the receiver class. |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
1082 // FIXME this weakens the assert too much |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
1083 methodHandle callee = callinfo.selected_method(); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
1084 assert(receiver_klass->is_subtype_of(static_receiver_klass()) || |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
1085 callee->is_method_handle_intrinsic() || |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
1086 callee->is_compiled_lambda_form(), |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
1087 "actual receiver must be subclass of static receiver klass"); |
| 0 | 1088 if (receiver_klass->oop_is_instance()) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1089 if (InstanceKlass::cast(receiver_klass())->is_not_initialized()) { |
| 0 | 1090 tty->print_cr("ERROR: Klass not yet initialized!!"); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1091 receiver_klass()->print(); |
| 0 | 1092 } |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1093 assert(!InstanceKlass::cast(receiver_klass())->is_not_initialized(), "receiver_klass must be initialized"); |
| 0 | 1094 } |
| 1095 } | |
| 1096 #endif | |
| 1097 | |
| 1098 return receiver; | |
| 1099 } | |
| 1100 | |
| 1101 methodHandle SharedRuntime::find_callee_method(JavaThread* thread, TRAPS) { | |
| 1102 ResourceMark rm(THREAD); | |
| 1103 // We need first to check if any Java activations (compiled, interpreted) | |
| 1104 // exist on the stack since last JavaCall. If not, we need | |
| 1105 // to get the target method from the JavaCall wrapper. | |
| 1106 vframeStream vfst(thread, true); // Do not skip any javaCalls | |
| 1107 methodHandle callee_method; | |
| 1108 if (vfst.at_end()) { | |
| 1109 // No Java frames were found on stack since we did the JavaCall. | |
| 1110 // Hence the stack can only contain an entry_frame. We need to | |
| 1111 // find the target method from the stub frame. | |
| 1112 RegisterMap reg_map(thread, false); | |
| 1113 frame fr = thread->last_frame(); | |
| 1114 assert(fr.is_runtime_frame(), "must be a runtimeStub"); | |
| 1115 fr = fr.sender(®_map); | |
| 1116 assert(fr.is_entry_frame(), "must be"); | |
| 1117 // fr is now pointing to the entry frame. | |
| 1118 callee_method = methodHandle(THREAD, fr.entry_frame_call_wrapper()->callee_method()); | |
| 1119 assert(fr.entry_frame_call_wrapper()->receiver() == NULL || !callee_method->is_static(), "non-null receiver for static call??"); | |
| 1120 } else { | |
| 1121 Bytecodes::Code bc; | |
| 1122 CallInfo callinfo; | |
| 1123 find_callee_info_helper(thread, vfst, bc, callinfo, CHECK_(methodHandle())); | |
| 1124 callee_method = callinfo.selected_method(); | |
| 1125 } | |
| 1126 assert(callee_method()->is_method(), "must be"); | |
| 1127 return callee_method; | |
| 1128 } | |
| 1129 | |
| 1130 // Resolves a call. | |
| 1131 methodHandle SharedRuntime::resolve_helper(JavaThread *thread, | |
| 1132 bool is_virtual, | |
| 1133 bool is_optimized, TRAPS) { | |
| 1134 methodHandle callee_method; | |
| 1135 callee_method = resolve_sub_helper(thread, is_virtual, is_optimized, THREAD); | |
| 1136 if (JvmtiExport::can_hotswap_or_post_breakpoint()) { | |
| 1137 int retry_count = 0; | |
| 1138 while (!HAS_PENDING_EXCEPTION && callee_method->is_old() && | |
| 1142 | 1139 callee_method->method_holder() != SystemDictionary::Object_klass()) { |
| 0 | 1140 // If has a pending exception then there is no need to re-try to |
| 1141 // resolve this method. | |
| 1142 // If the method has been redefined, we need to try again. | |
| 1143 // Hack: we have no way to update the vtables of arrays, so don't | |
| 1144 // require that java.lang.Object has been updated. | |
| 1145 | |
| 1146 // It is very unlikely that method is redefined more than 100 times | |
| 1147 // in the middle of resolve. If it is looping here more than 100 times | |
| 1148 // means then there could be a bug here. | |
| 1149 guarantee((retry_count++ < 100), | |
| 1150 "Could not resolve to latest version of redefined method"); | |
| 1151 // method is redefined in the middle of resolve so re-try. | |
| 1152 callee_method = resolve_sub_helper(thread, is_virtual, is_optimized, THREAD); | |
| 1153 } | |
| 1154 } | |
| 1155 return callee_method; | |
| 1156 } | |
| 1157 | |
| 1158 // Resolves a call. The compilers generate code for calls that go here | |
| 1159 // and are patched with the real destination of the call. | |
| 1160 methodHandle SharedRuntime::resolve_sub_helper(JavaThread *thread, | |
| 1161 bool is_virtual, | |
| 1162 bool is_optimized, TRAPS) { | |
| 1163 | |
| 1164 ResourceMark rm(thread); | |
| 1165 RegisterMap cbl_map(thread, false); | |
| 1166 frame caller_frame = thread->last_frame().sender(&cbl_map); | |
| 1167 | |
| 1295 | 1168 CodeBlob* caller_cb = caller_frame.cb(); |
| 1169 guarantee(caller_cb != NULL && caller_cb->is_nmethod(), "must be called from nmethod"); | |
| 1170 nmethod* caller_nm = caller_cb->as_nmethod_or_null(); | |
| 0 | 1171 // make sure caller is not getting deoptimized |
| 1172 // and removed before we are done with it. | |
| 1173 // CLEANUP - with lazy deopt shouldn't need this lock | |
| 1295 | 1174 nmethodLocker caller_lock(caller_nm); |
| 0 | 1175 |
| 1176 | |
| 1177 // determine call info & receiver | |
| 1178 // note: a) receiver is NULL for static calls | |
| 1179 // b) an exception is thrown if receiver is NULL for non-static calls | |
| 1180 CallInfo call_info; | |
| 1181 Bytecodes::Code invoke_code = Bytecodes::_illegal; | |
| 1182 Handle receiver = find_callee_info(thread, invoke_code, | |
| 1183 call_info, CHECK_(methodHandle())); | |
| 1184 methodHandle callee_method = call_info.selected_method(); | |
| 1185 | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
1186 assert((!is_virtual && invoke_code == Bytecodes::_invokestatic ) || |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
1187 (!is_virtual && invoke_code == Bytecodes::_invokehandle ) || |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
1188 (!is_virtual && invoke_code == Bytecodes::_invokedynamic) || |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
1189 ( is_virtual && invoke_code != Bytecodes::_invokestatic ), "inconsistent bytecode"); |
| 0 | 1190 |
| 1191 #ifndef PRODUCT | |
| 1192 // tracing/debugging/statistics | |
| 1193 int *addr = (is_optimized) ? (&_resolve_opt_virtual_ctr) : | |
| 1194 (is_virtual) ? (&_resolve_virtual_ctr) : | |
| 1195 (&_resolve_static_ctr); | |
| 1196 Atomic::inc(addr); | |
| 1197 | |
| 1198 if (TraceCallFixup) { | |
| 1199 ResourceMark rm(thread); | |
| 1200 tty->print("resolving %s%s (%s) call to", | |
| 1201 (is_optimized) ? "optimized " : "", (is_virtual) ? "virtual" : "static", | |
| 1202 Bytecodes::name(invoke_code)); | |
| 1203 callee_method->print_short_name(tty); | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
1204 tty->print_cr(" at pc: " INTPTR_FORMAT " to code: " INTPTR_FORMAT, caller_frame.pc(), callee_method->code()); |
| 0 | 1205 } |
| 1206 #endif | |
| 1207 | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
1208 // JSR 292 key invariant: |
| 1295 | 1209 // If the resolved method is a MethodHandle invoke target the call |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
1210 // site must be a MethodHandle call site, because the lambda form might tail-call |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
1211 // leaving the stack in a state unknown to either caller or callee |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
1212 // TODO detune for now but we might need it again |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
1213 // assert(!callee_method->is_compiled_lambda_form() || |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
1214 // caller_nm->is_method_handle_return(caller_frame.pc()), "must be MH call site"); |
| 1295 | 1215 |
| 0 | 1216 // Compute entry points. This might require generation of C2I converter |
| 1217 // frames, so we cannot be holding any locks here. Furthermore, the | |
| 1218 // computation of the entry points is independent of patching the call. We | |
| 1219 // always return the entry-point, but we only patch the stub if the call has | |
| 1220 // not been deoptimized. Return values: For a virtual call this is an | |
| 1221 // (cached_oop, destination address) pair. For a static call/optimized | |
| 1222 // virtual this is just a destination address. | |
| 1223 | |
| 1224 StaticCallInfo static_call_info; | |
| 1225 CompiledICInfo virtual_call_info; | |
| 1226 | |
| 1227 // Make sure the callee nmethod does not get deoptimized and removed before | |
| 1228 // we are done patching the code. | |
| 1295 | 1229 nmethod* callee_nm = callee_method->code(); |
| 1230 nmethodLocker nl_callee(callee_nm); | |
| 0 | 1231 #ifdef ASSERT |
| 1295 | 1232 address dest_entry_point = callee_nm == NULL ? 0 : callee_nm->entry_point(); // used below |
| 0 | 1233 #endif |
| 1234 | |
| 1235 if (is_virtual) { | |
| 1236 assert(receiver.not_null(), "sanity check"); | |
| 1237 bool static_bound = call_info.resolved_method()->can_be_statically_bound(); | |
| 1238 KlassHandle h_klass(THREAD, receiver->klass()); | |
| 1239 CompiledIC::compute_monomorphic_entry(callee_method, h_klass, | |
| 1240 is_optimized, static_bound, virtual_call_info, | |
| 1241 CHECK_(methodHandle())); | |
| 1242 } else { | |
| 1243 // static call | |
| 1244 CompiledStaticCall::compute_entry(callee_method, static_call_info); | |
| 1245 } | |
| 1246 | |
| 1247 // grab lock, check for deoptimization and potentially patch caller | |
| 1248 { | |
| 1249 MutexLocker ml_patch(CompiledIC_lock); | |
| 1250 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1251 // Now that we are ready to patch if the Method* was redefined then |
| 0 | 1252 // don't update call site and let the caller retry. |
| 1253 | |
| 1254 if (!callee_method->is_old()) { | |
| 1255 #ifdef ASSERT | |
| 1256 // We must not try to patch to jump to an already unloaded method. | |
| 1257 if (dest_entry_point != 0) { | |
| 1258 assert(CodeCache::find_blob(dest_entry_point) != NULL, | |
| 1259 "should not unload nmethod while locked"); | |
| 1260 } | |
| 1261 #endif | |
| 1262 if (is_virtual) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1263 nmethod* nm = callee_nm; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1264 if (nm == NULL) CodeCache::find_blob(caller_frame.pc()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1265 CompiledIC* inline_cache = CompiledIC_before(caller_nm, caller_frame.pc()); |
| 0 | 1266 if (inline_cache->is_clean()) { |
| 1267 inline_cache->set_to_monomorphic(virtual_call_info); | |
| 1268 } | |
| 1269 } else { | |
| 1270 CompiledStaticCall* ssc = compiledStaticCall_before(caller_frame.pc()); | |
| 1271 if (ssc->is_clean()) ssc->set(static_call_info); | |
| 1272 } | |
| 1273 } | |
| 1274 | |
| 1275 } // unlock CompiledIC_lock | |
| 1276 | |
| 1277 return callee_method; | |
| 1278 } | |
| 1279 | |
| 1280 | |
| 1281 // Inline caches exist only in compiled code | |
| 1282 JRT_BLOCK_ENTRY(address, SharedRuntime::handle_wrong_method_ic_miss(JavaThread* thread)) | |
| 1283 #ifdef ASSERT | |
| 1284 RegisterMap reg_map(thread, false); | |
| 1285 frame stub_frame = thread->last_frame(); | |
| 1286 assert(stub_frame.is_runtime_frame(), "sanity check"); | |
| 1287 frame caller_frame = stub_frame.sender(®_map); | |
| 1288 assert(!caller_frame.is_interpreted_frame() && !caller_frame.is_entry_frame(), "unexpected frame"); | |
| 1289 #endif /* ASSERT */ | |
| 1290 | |
| 1291 methodHandle callee_method; | |
| 1292 JRT_BLOCK | |
| 1293 callee_method = SharedRuntime::handle_ic_miss_helper(thread, CHECK_NULL); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1294 // Return Method* through TLS |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1295 thread->set_vm_result_2(callee_method()); |
| 0 | 1296 JRT_BLOCK_END |
| 1297 // return compiled code entry point after potential safepoints | |
| 1298 assert(callee_method->verified_code_entry() != NULL, " Jump to zero!"); | |
| 1299 return callee_method->verified_code_entry(); | |
| 1300 JRT_END | |
| 1301 | |
| 1302 | |
| 1303 // Handle call site that has been made non-entrant | |
| 1304 JRT_BLOCK_ENTRY(address, SharedRuntime::handle_wrong_method(JavaThread* thread)) | |
| 1305 // 6243940 We might end up in here if the callee is deoptimized | |
| 1306 // as we race to call it. We don't want to take a safepoint if | |
| 1307 // the caller was interpreted because the caller frame will look | |
| 1308 // interpreted to the stack walkers and arguments are now | |
| 1309 // "compiled" so it is much better to make this transition | |
| 1310 // invisible to the stack walking code. The i2c path will | |
| 1311 // place the callee method in the callee_target. It is stashed | |
| 1312 // there because if we try and find the callee by normal means a | |
| 1313 // safepoint is possible and have trouble gc'ing the compiled args. | |
| 1314 RegisterMap reg_map(thread, false); | |
| 1315 frame stub_frame = thread->last_frame(); | |
| 1316 assert(stub_frame.is_runtime_frame(), "sanity check"); | |
| 1317 frame caller_frame = stub_frame.sender(®_map); | |
|
1135
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
845
diff
changeset
|
1318 |
|
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
845
diff
changeset
|
1319 // MethodHandle invokes don't have a CompiledIC and should always |
|
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
845
diff
changeset
|
1320 // simply redispatch to the callee_target. |
|
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
845
diff
changeset
|
1321 address sender_pc = caller_frame.pc(); |
|
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
845
diff
changeset
|
1322 CodeBlob* sender_cb = caller_frame.cb(); |
|
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
845
diff
changeset
|
1323 nmethod* sender_nm = sender_cb->as_nmethod_or_null(); |
|
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
845
diff
changeset
|
1324 |
|
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
845
diff
changeset
|
1325 if (caller_frame.is_interpreted_frame() || |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
1326 caller_frame.is_entry_frame()) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1327 Method* callee = thread->callee_target(); |
| 0 | 1328 guarantee(callee != NULL && callee->is_method(), "bad handshake"); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1329 thread->set_vm_result_2(callee); |
| 0 | 1330 thread->set_callee_target(NULL); |
| 1331 return callee->get_c2i_entry(); | |
| 1332 } | |
| 1333 | |
| 1334 // Must be compiled to compiled path which is safe to stackwalk | |
| 1335 methodHandle callee_method; | |
| 1336 JRT_BLOCK | |
| 1337 // Force resolving of caller (if we called from compiled frame) | |
| 1338 callee_method = SharedRuntime::reresolve_call_site(thread, CHECK_NULL); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1339 thread->set_vm_result_2(callee_method()); |
| 0 | 1340 JRT_BLOCK_END |
| 1341 // return compiled code entry point after potential safepoints | |
| 1342 assert(callee_method->verified_code_entry() != NULL, " Jump to zero!"); | |
| 1343 return callee_method->verified_code_entry(); | |
| 1344 JRT_END | |
| 1345 | |
| 1346 | |
| 1347 // resolve a static call and patch code | |
| 1348 JRT_BLOCK_ENTRY(address, SharedRuntime::resolve_static_call_C(JavaThread *thread )) | |
| 1349 methodHandle callee_method; | |
| 1350 JRT_BLOCK | |
| 1351 callee_method = SharedRuntime::resolve_helper(thread, false, false, CHECK_NULL); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1352 thread->set_vm_result_2(callee_method()); |
| 0 | 1353 JRT_BLOCK_END |
| 1354 // return compiled code entry point after potential safepoints | |
| 1355 assert(callee_method->verified_code_entry() != NULL, " Jump to zero!"); | |
| 1356 return callee_method->verified_code_entry(); | |
| 1357 JRT_END | |
| 1358 | |
| 1359 | |
| 1360 // resolve virtual call and update inline cache to monomorphic | |
| 1361 JRT_BLOCK_ENTRY(address, SharedRuntime::resolve_virtual_call_C(JavaThread *thread )) | |
| 1362 methodHandle callee_method; | |
| 1363 JRT_BLOCK | |
| 1364 callee_method = SharedRuntime::resolve_helper(thread, true, false, CHECK_NULL); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1365 thread->set_vm_result_2(callee_method()); |
| 0 | 1366 JRT_BLOCK_END |
| 1367 // return compiled code entry point after potential safepoints | |
| 1368 assert(callee_method->verified_code_entry() != NULL, " Jump to zero!"); | |
| 1369 return callee_method->verified_code_entry(); | |
| 1370 JRT_END | |
| 1371 | |
| 1372 | |
| 1373 // Resolve a virtual call that can be statically bound (e.g., always | |
| 1374 // monomorphic, so it has no inline cache). Patch code to resolved target. | |
| 1375 JRT_BLOCK_ENTRY(address, SharedRuntime::resolve_opt_virtual_call_C(JavaThread *thread)) | |
| 1376 methodHandle callee_method; | |
| 1377 JRT_BLOCK | |
| 1378 callee_method = SharedRuntime::resolve_helper(thread, true, true, CHECK_NULL); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1379 thread->set_vm_result_2(callee_method()); |
| 0 | 1380 JRT_BLOCK_END |
| 1381 // return compiled code entry point after potential safepoints | |
| 1382 assert(callee_method->verified_code_entry() != NULL, " Jump to zero!"); | |
| 1383 return callee_method->verified_code_entry(); | |
| 1384 JRT_END | |
| 1385 | |
| 1386 | |
| 1387 | |
| 1388 | |
| 1389 | |
| 1390 methodHandle SharedRuntime::handle_ic_miss_helper(JavaThread *thread, TRAPS) { | |
| 1391 ResourceMark rm(thread); | |
| 1392 CallInfo call_info; | |
| 1393 Bytecodes::Code bc; | |
| 1394 | |
| 1395 // receiver is NULL for static calls. An exception is thrown for NULL | |
| 1396 // receivers for non-static calls | |
| 1397 Handle receiver = find_callee_info(thread, bc, call_info, | |
| 1398 CHECK_(methodHandle())); | |
| 1399 // Compiler1 can produce virtual call sites that can actually be statically bound | |
| 1400 // If we fell thru to below we would think that the site was going megamorphic | |
| 1401 // when in fact the site can never miss. Worse because we'd think it was megamorphic | |
| 1402 // we'd try and do a vtable dispatch however methods that can be statically bound | |
| 1403 // don't have vtable entries (vtable_index < 0) and we'd blow up. So we force a | |
| 1404 // reresolution of the call site (as if we did a handle_wrong_method and not an | |
| 1405 // plain ic_miss) and the site will be converted to an optimized virtual call site | |
| 1406 // never to miss again. I don't believe C2 will produce code like this but if it | |
| 1407 // did this would still be the correct thing to do for it too, hence no ifdef. | |
| 1408 // | |
| 1409 if (call_info.resolved_method()->can_be_statically_bound()) { | |
| 1410 methodHandle callee_method = SharedRuntime::reresolve_call_site(thread, CHECK_(methodHandle())); | |
| 1411 if (TraceCallFixup) { | |
| 1412 RegisterMap reg_map(thread, false); | |
| 1413 frame caller_frame = thread->last_frame().sender(®_map); | |
| 1414 ResourceMark rm(thread); | |
| 1415 tty->print("converting IC miss to reresolve (%s) call to", Bytecodes::name(bc)); | |
| 1416 callee_method->print_short_name(tty); | |
| 1417 tty->print_cr(" from pc: " INTPTR_FORMAT, caller_frame.pc()); | |
| 1418 tty->print_cr(" code: " INTPTR_FORMAT, callee_method->code()); | |
| 1419 } | |
| 1420 return callee_method; | |
| 1421 } | |
| 1422 | |
| 1423 methodHandle callee_method = call_info.selected_method(); | |
| 1424 | |
| 1425 bool should_be_mono = false; | |
| 1426 | |
| 1427 #ifndef PRODUCT | |
| 1428 Atomic::inc(&_ic_miss_ctr); | |
| 1429 | |
| 1430 // Statistics & Tracing | |
| 1431 if (TraceCallFixup) { | |
| 1432 ResourceMark rm(thread); | |
| 1433 tty->print("IC miss (%s) call to", Bytecodes::name(bc)); | |
| 1434 callee_method->print_short_name(tty); | |
| 1435 tty->print_cr(" code: " INTPTR_FORMAT, callee_method->code()); | |
| 1436 } | |
| 1437 | |
| 1438 if (ICMissHistogram) { | |
| 1439 MutexLocker m(VMStatistic_lock); | |
| 1440 RegisterMap reg_map(thread, false); | |
| 1441 frame f = thread->last_frame().real_sender(®_map);// skip runtime stub | |
| 1442 // produce statistics under the lock | |
| 1443 trace_ic_miss(f.pc()); | |
| 1444 } | |
| 1445 #endif | |
| 1446 | |
| 1447 // install an event collector so that when a vtable stub is created the | |
| 1448 // profiler can be notified via a DYNAMIC_CODE_GENERATED event. The | |
| 1449 // event can't be posted when the stub is created as locks are held | |
| 1450 // - instead the event will be deferred until the event collector goes | |
| 1451 // out of scope. | |
| 1452 JvmtiDynamicCodeEventCollector event_collector; | |
| 1453 | |
| 1454 // Update inline cache to megamorphic. Skip update if caller has been | |
| 1455 // made non-entrant or we are called from interpreted. | |
| 1456 { MutexLocker ml_patch (CompiledIC_lock); | |
| 1457 RegisterMap reg_map(thread, false); | |
| 1458 frame caller_frame = thread->last_frame().sender(®_map); | |
| 1459 CodeBlob* cb = caller_frame.cb(); | |
| 1460 if (cb->is_nmethod() && ((nmethod*)cb)->is_in_use()) { | |
| 1461 // Not a non-entrant nmethod, so find inline_cache | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1462 CompiledIC* inline_cache = CompiledIC_before(((nmethod*)cb), caller_frame.pc()); |
| 0 | 1463 bool should_be_mono = false; |
| 1464 if (inline_cache->is_optimized()) { | |
| 1465 if (TraceCallFixup) { | |
| 1466 ResourceMark rm(thread); | |
| 1467 tty->print("OPTIMIZED IC miss (%s) call to", Bytecodes::name(bc)); | |
| 1468 callee_method->print_short_name(tty); | |
| 1469 tty->print_cr(" code: " INTPTR_FORMAT, callee_method->code()); | |
| 1470 } | |
| 1471 should_be_mono = true; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1472 } else if (inline_cache->is_icholder_call()) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1473 CompiledICHolder* ic_oop = inline_cache->cached_icholder(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1474 if ( ic_oop != NULL) { |
| 0 | 1475 |
| 1476 if (receiver()->klass() == ic_oop->holder_klass()) { | |
| 1477 // This isn't a real miss. We must have seen that compiled code | |
| 1478 // is now available and we want the call site converted to a | |
| 1479 // monomorphic compiled call site. | |
| 1480 // We can't assert for callee_method->code() != NULL because it | |
| 1481 // could have been deoptimized in the meantime | |
| 1482 if (TraceCallFixup) { | |
| 1483 ResourceMark rm(thread); | |
| 1484 tty->print("FALSE IC miss (%s) converting to compiled call to", Bytecodes::name(bc)); | |
| 1485 callee_method->print_short_name(tty); | |
| 1486 tty->print_cr(" code: " INTPTR_FORMAT, callee_method->code()); | |
| 1487 } | |
| 1488 should_be_mono = true; | |
| 1489 } | |
| 1490 } | |
| 1491 } | |
| 1492 | |
| 1493 if (should_be_mono) { | |
| 1494 | |
| 1495 // We have a path that was monomorphic but was going interpreted | |
| 1496 // and now we have (or had) a compiled entry. We correct the IC | |
| 1497 // by using a new icBuffer. | |
| 1498 CompiledICInfo info; | |
| 1499 KlassHandle receiver_klass(THREAD, receiver()->klass()); | |
| 1500 inline_cache->compute_monomorphic_entry(callee_method, | |
| 1501 receiver_klass, | |
| 1502 inline_cache->is_optimized(), | |
| 1503 false, | |
| 1504 info, CHECK_(methodHandle())); | |
| 1505 inline_cache->set_to_monomorphic(info); | |
| 1506 } else if (!inline_cache->is_megamorphic() && !inline_cache->is_clean()) { | |
| 1507 // Change to megamorphic | |
| 1508 inline_cache->set_to_megamorphic(&call_info, bc, CHECK_(methodHandle())); | |
| 1509 } else { | |
| 1510 // Either clean or megamorphic | |
| 1511 } | |
| 1512 } | |
| 1513 } // Release CompiledIC_lock | |
| 1514 | |
| 1515 return callee_method; | |
| 1516 } | |
| 1517 | |
| 1518 // | |
| 1519 // Resets a call-site in compiled code so it will get resolved again. | |
| 1520 // This routines handles both virtual call sites, optimized virtual call | |
| 1521 // sites, and static call sites. Typically used to change a call sites | |
| 1522 // destination from compiled to interpreted. | |
| 1523 // | |
| 1524 methodHandle SharedRuntime::reresolve_call_site(JavaThread *thread, TRAPS) { | |
| 1525 ResourceMark rm(thread); | |
| 1526 RegisterMap reg_map(thread, false); | |
| 1527 frame stub_frame = thread->last_frame(); | |
| 1528 assert(stub_frame.is_runtime_frame(), "must be a runtimeStub"); | |
| 1529 frame caller = stub_frame.sender(®_map); | |
| 1530 | |
| 1531 // Do nothing if the frame isn't a live compiled frame. | |
| 1532 // nmethod could be deoptimized by the time we get here | |
| 1533 // so no update to the caller is needed. | |
| 1534 | |
| 1535 if (caller.is_compiled_frame() && !caller.is_deoptimized_frame()) { | |
| 1536 | |
| 1537 address pc = caller.pc(); | |
| 1538 | |
| 1539 // Default call_addr is the location of the "basic" call. | |
| 1540 // Determine the address of the call we a reresolving. With | |
| 1541 // Inline Caches we will always find a recognizable call. | |
| 1542 // With Inline Caches disabled we may or may not find a | |
| 1543 // recognizable call. We will always find a call for static | |
| 1544 // calls and for optimized virtual calls. For vanilla virtual | |
| 1545 // calls it depends on the state of the UseInlineCaches switch. | |
| 1546 // | |
| 1547 // With Inline Caches disabled we can get here for a virtual call | |
| 1548 // for two reasons: | |
| 1549 // 1 - calling an abstract method. The vtable for abstract methods | |
| 1550 // will run us thru handle_wrong_method and we will eventually | |
| 1551 // end up in the interpreter to throw the ame. | |
| 1552 // 2 - a racing deoptimization. We could be doing a vanilla vtable | |
| 1553 // call and between the time we fetch the entry address and | |
| 1554 // we jump to it the target gets deoptimized. Similar to 1 | |
| 1555 // we will wind up in the interprter (thru a c2i with c2). | |
| 1556 // | |
| 1557 address call_addr = NULL; | |
| 1558 { | |
| 1559 // Get call instruction under lock because another thread may be | |
| 1560 // busy patching it. | |
| 1561 MutexLockerEx ml_patch(Patching_lock, Mutex::_no_safepoint_check_flag); | |
| 1562 // Location of call instruction | |
| 1563 if (NativeCall::is_call_before(pc)) { | |
| 1564 NativeCall *ncall = nativeCall_before(pc); | |
| 1565 call_addr = ncall->instruction_address(); | |
| 1566 } | |
| 1567 } | |
| 1568 | |
| 1569 // Check for static or virtual call | |
| 1570 bool is_static_call = false; | |
| 1571 nmethod* caller_nm = CodeCache::find_nmethod(pc); | |
| 1572 // Make sure nmethod doesn't get deoptimized and removed until | |
| 1573 // this is done with it. | |
| 1574 // CLEANUP - with lazy deopt shouldn't need this lock | |
| 1575 nmethodLocker nmlock(caller_nm); | |
| 1576 | |
| 1577 if (call_addr != NULL) { | |
| 1578 RelocIterator iter(caller_nm, call_addr, call_addr+1); | |
| 1579 int ret = iter.next(); // Get item | |
| 1580 if (ret) { | |
| 1581 assert(iter.addr() == call_addr, "must find call"); | |
| 1582 if (iter.type() == relocInfo::static_call_type) { | |
| 1583 is_static_call = true; | |
| 1584 } else { | |
| 1585 assert(iter.type() == relocInfo::virtual_call_type || | |
| 1586 iter.type() == relocInfo::opt_virtual_call_type | |
| 1587 , "unexpected relocInfo. type"); | |
| 1588 } | |
| 1589 } else { | |
| 1590 assert(!UseInlineCaches, "relocation info. must exist for this address"); | |
| 1591 } | |
| 1592 | |
| 1593 // Cleaning the inline cache will force a new resolve. This is more robust | |
| 1594 // than directly setting it to the new destination, since resolving of calls | |
| 1595 // is always done through the same code path. (experience shows that it | |
| 1596 // leads to very hard to track down bugs, if an inline cache gets updated | |
| 1597 // to a wrong method). It should not be performance critical, since the | |
| 1598 // resolve is only done once. | |
| 1599 | |
| 1600 MutexLocker ml(CompiledIC_lock); | |
| 1601 // | |
| 1602 // We do not patch the call site if the nmethod has been made non-entrant | |
| 1603 // as it is a waste of time | |
| 1604 // | |
| 1605 if (caller_nm->is_in_use()) { | |
| 1606 if (is_static_call) { | |
| 1607 CompiledStaticCall* ssc= compiledStaticCall_at(call_addr); | |
| 1608 ssc->set_to_clean(); | |
| 1609 } else { | |
| 1610 // compiled, dispatched call (which used to call an interpreted method) | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1611 CompiledIC* inline_cache = CompiledIC_at(caller_nm, call_addr); |
| 0 | 1612 inline_cache->set_to_clean(); |
| 1613 } | |
| 1614 } | |
| 1615 } | |
| 1616 | |
| 1617 } | |
| 1618 | |
| 1619 methodHandle callee_method = find_callee_method(thread, CHECK_(methodHandle())); | |
| 1620 | |
| 1621 | |
| 1622 #ifndef PRODUCT | |
| 1623 Atomic::inc(&_wrong_method_ctr); | |
| 1624 | |
| 1625 if (TraceCallFixup) { | |
| 1626 ResourceMark rm(thread); | |
| 1627 tty->print("handle_wrong_method reresolving call to"); | |
| 1628 callee_method->print_short_name(tty); | |
| 1629 tty->print_cr(" code: " INTPTR_FORMAT, callee_method->code()); | |
| 1630 } | |
| 1631 #endif | |
| 1632 | |
| 1633 return callee_method; | |
| 1634 } | |
| 1635 | |
|
6790
2cb2f30450c7
7196262: JSR 292: java/lang/invoke/PrivateInvokeTest.java fails on solaris-sparc
twisti
parents:
6725
diff
changeset
|
1636 #ifdef ASSERT |
|
2cb2f30450c7
7196262: JSR 292: java/lang/invoke/PrivateInvokeTest.java fails on solaris-sparc
twisti
parents:
6725
diff
changeset
|
1637 void SharedRuntime::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
|
1638 const BasicType* sig_bt, |
|
2cb2f30450c7
7196262: JSR 292: java/lang/invoke/PrivateInvokeTest.java fails on solaris-sparc
twisti
parents:
6725
diff
changeset
|
1639 const VMRegPair* regs) { |
|
2cb2f30450c7
7196262: JSR 292: java/lang/invoke/PrivateInvokeTest.java fails on solaris-sparc
twisti
parents:
6725
diff
changeset
|
1640 ResourceMark rm; |
|
2cb2f30450c7
7196262: JSR 292: java/lang/invoke/PrivateInvokeTest.java fails on solaris-sparc
twisti
parents:
6725
diff
changeset
|
1641 const int total_args_passed = method->size_of_parameters(); |
|
2cb2f30450c7
7196262: JSR 292: java/lang/invoke/PrivateInvokeTest.java fails on solaris-sparc
twisti
parents:
6725
diff
changeset
|
1642 const VMRegPair* regs_with_member_name = regs; |
|
2cb2f30450c7
7196262: JSR 292: java/lang/invoke/PrivateInvokeTest.java fails on solaris-sparc
twisti
parents:
6725
diff
changeset
|
1643 VMRegPair* regs_without_member_name = NEW_RESOURCE_ARRAY(VMRegPair, total_args_passed - 1); |
|
2cb2f30450c7
7196262: JSR 292: java/lang/invoke/PrivateInvokeTest.java fails on solaris-sparc
twisti
parents:
6725
diff
changeset
|
1644 |
|
2cb2f30450c7
7196262: JSR 292: java/lang/invoke/PrivateInvokeTest.java fails on solaris-sparc
twisti
parents:
6725
diff
changeset
|
1645 const int member_arg_pos = total_args_passed - 1; |
|
2cb2f30450c7
7196262: JSR 292: java/lang/invoke/PrivateInvokeTest.java fails on solaris-sparc
twisti
parents:
6725
diff
changeset
|
1646 assert(member_arg_pos >= 0 && member_arg_pos < total_args_passed, "oob"); |
|
2cb2f30450c7
7196262: JSR 292: java/lang/invoke/PrivateInvokeTest.java fails on solaris-sparc
twisti
parents:
6725
diff
changeset
|
1647 assert(sig_bt[member_arg_pos] == T_OBJECT, "dispatch argument must be an object"); |
|
2cb2f30450c7
7196262: JSR 292: java/lang/invoke/PrivateInvokeTest.java fails on solaris-sparc
twisti
parents:
6725
diff
changeset
|
1648 |
|
2cb2f30450c7
7196262: JSR 292: java/lang/invoke/PrivateInvokeTest.java fails on solaris-sparc
twisti
parents:
6725
diff
changeset
|
1649 const bool is_outgoing = method->is_method_handle_intrinsic(); |
|
2cb2f30450c7
7196262: JSR 292: java/lang/invoke/PrivateInvokeTest.java fails on solaris-sparc
twisti
parents:
6725
diff
changeset
|
1650 int comp_args_on_stack = java_calling_convention(sig_bt, regs_without_member_name, total_args_passed - 1, is_outgoing); |
|
2cb2f30450c7
7196262: JSR 292: java/lang/invoke/PrivateInvokeTest.java fails on solaris-sparc
twisti
parents:
6725
diff
changeset
|
1651 |
|
2cb2f30450c7
7196262: JSR 292: java/lang/invoke/PrivateInvokeTest.java fails on solaris-sparc
twisti
parents:
6725
diff
changeset
|
1652 for (int i = 0; i < member_arg_pos; i++) { |
|
2cb2f30450c7
7196262: JSR 292: java/lang/invoke/PrivateInvokeTest.java fails on solaris-sparc
twisti
parents:
6725
diff
changeset
|
1653 VMReg a = regs_with_member_name[i].first(); |
|
2cb2f30450c7
7196262: JSR 292: java/lang/invoke/PrivateInvokeTest.java fails on solaris-sparc
twisti
parents:
6725
diff
changeset
|
1654 VMReg b = regs_without_member_name[i].first(); |
|
2cb2f30450c7
7196262: JSR 292: java/lang/invoke/PrivateInvokeTest.java fails on solaris-sparc
twisti
parents:
6725
diff
changeset
|
1655 assert(a->value() == b->value(), err_msg_res("register allocation mismatch: a=%d, b=%d", a->value(), b->value())); |
|
2cb2f30450c7
7196262: JSR 292: java/lang/invoke/PrivateInvokeTest.java fails on solaris-sparc
twisti
parents:
6725
diff
changeset
|
1656 } |
|
2cb2f30450c7
7196262: JSR 292: java/lang/invoke/PrivateInvokeTest.java fails on solaris-sparc
twisti
parents:
6725
diff
changeset
|
1657 assert(regs_with_member_name[member_arg_pos].first()->is_valid(), "bad member arg"); |
|
2cb2f30450c7
7196262: JSR 292: java/lang/invoke/PrivateInvokeTest.java fails on solaris-sparc
twisti
parents:
6725
diff
changeset
|
1658 } |
|
2cb2f30450c7
7196262: JSR 292: java/lang/invoke/PrivateInvokeTest.java fails on solaris-sparc
twisti
parents:
6725
diff
changeset
|
1659 #endif |
|
2cb2f30450c7
7196262: JSR 292: java/lang/invoke/PrivateInvokeTest.java fails on solaris-sparc
twisti
parents:
6725
diff
changeset
|
1660 |
| 0 | 1661 // --------------------------------------------------------------------------- |
| 1662 // We are calling the interpreter via a c2i. Normally this would mean that | |
| 1663 // we were called by a compiled method. However we could have lost a race | |
| 1664 // where we went int -> i2c -> c2i and so the caller could in fact be | |
| 1205 | 1665 // interpreted. If the caller is compiled we attempt to patch the caller |
| 0 | 1666 // 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
|
1667 IRT_LEAF(void, SharedRuntime::fixup_callers_callsite(Method* method, address caller_pc)) |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1668 Method* moop(method); |
| 0 | 1669 |
| 1670 address entry_point = moop->from_compiled_entry(); | |
| 1671 | |
| 1672 // It's possible that deoptimization can occur at a call site which hasn't | |
| 1673 // been resolved yet, in which case this function will be called from | |
| 1674 // an nmethod that has been patched for deopt and we can ignore the | |
| 1675 // request for a fixup. | |
| 1676 // Also it is possible that we lost a race in that from_compiled_entry | |
| 1677 // is now back to the i2c in that case we don't need to patch and if | |
| 1678 // we did we'd leap into space because the callsite needs to use | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1679 // "to interpreter" stub in order to load up the Method*. Don't |
| 0 | 1680 // ask me how I know this... |
| 1681 | |
| 1682 CodeBlob* cb = CodeCache::find_blob(caller_pc); | |
| 1205 | 1683 if (!cb->is_nmethod() || entry_point == moop->get_c2i_entry()) { |
| 1684 return; | |
| 1685 } | |
| 1686 | |
| 1687 // The check above makes sure this is a nmethod. | |
| 1688 nmethod* nm = cb->as_nmethod_or_null(); | |
| 1689 assert(nm, "must be"); | |
| 1690 | |
|
4044
2ec638646e86
7101642: JSR 292: SIGSEGV in java.lang.invoke.MethodHandleImpl$FieldAccessor.getFieldI(Ljava/lang/Object;)I
twisti
parents:
4007
diff
changeset
|
1691 // Get the return PC for the passed caller PC. |
|
2ec638646e86
7101642: JSR 292: SIGSEGV in java.lang.invoke.MethodHandleImpl$FieldAccessor.getFieldI(Ljava/lang/Object;)I
twisti
parents:
4007
diff
changeset
|
1692 address return_pc = caller_pc + frame::pc_return_offset; |
|
2ec638646e86
7101642: JSR 292: SIGSEGV in java.lang.invoke.MethodHandleImpl$FieldAccessor.getFieldI(Ljava/lang/Object;)I
twisti
parents:
4007
diff
changeset
|
1693 |
| 0 | 1694 // There is a benign race here. We could be attempting to patch to a compiled |
| 1695 // entry point at the same time the callee is being deoptimized. If that is | |
| 1696 // the case then entry_point may in fact point to a c2i and we'd patch the | |
| 1697 // call site with the same old data. clear_code will set code() to NULL | |
| 1698 // at the end of it. If we happen to see that NULL then we can skip trying | |
| 1699 // to patch. If we hit the window where the callee has a c2i in the | |
| 1700 // from_compiled_entry and the NULL isn't present yet then we lose the race | |
| 1701 // and patch the code with the same old data. Asi es la vida. | |
| 1702 | |
| 1703 if (moop->code() == NULL) return; | |
| 1704 | |
| 1205 | 1705 if (nm->is_in_use()) { |
| 0 | 1706 |
| 1707 // Expect to find a native call there (unless it was no-inline cache vtable dispatch) | |
| 1708 MutexLockerEx ml_patch(Patching_lock, Mutex::_no_safepoint_check_flag); | |
|
4044
2ec638646e86
7101642: JSR 292: SIGSEGV in java.lang.invoke.MethodHandleImpl$FieldAccessor.getFieldI(Ljava/lang/Object;)I
twisti
parents:
4007
diff
changeset
|
1709 if (NativeCall::is_call_before(return_pc)) { |
|
2ec638646e86
7101642: JSR 292: SIGSEGV in java.lang.invoke.MethodHandleImpl$FieldAccessor.getFieldI(Ljava/lang/Object;)I
twisti
parents:
4007
diff
changeset
|
1710 NativeCall *call = nativeCall_before(return_pc); |
| 0 | 1711 // |
| 1712 // bug 6281185. We might get here after resolving a call site to a vanilla | |
| 1713 // virtual call. Because the resolvee uses the verified entry it may then | |
| 1714 // see compiled code and attempt to patch the site by calling us. This would | |
| 1715 // then incorrectly convert the call site to optimized and its downhill from | |
| 1716 // there. If you're lucky you'll get the assert in the bugid, if not you've | |
| 1717 // just made a call site that could be megamorphic into a monomorphic site | |
| 1718 // for the rest of its life! Just another racing bug in the life of | |
| 1719 // fixup_callers_callsite ... | |
| 1720 // | |
|
1563
1a5913bf5e19
6951083: oops and relocations should part of nmethod not CodeBlob
twisti
parents:
1507
diff
changeset
|
1721 RelocIterator iter(nm, call->instruction_address(), call->next_instruction_address()); |
| 0 | 1722 iter.next(); |
| 1723 assert(iter.has_current(), "must have a reloc at java call site"); | |
| 1724 relocInfo::relocType typ = iter.reloc()->type(); | |
| 1725 if ( typ != relocInfo::static_call_type && | |
| 1726 typ != relocInfo::opt_virtual_call_type && | |
| 1727 typ != relocInfo::static_stub_type) { | |
| 1728 return; | |
| 1729 } | |
| 1730 address destination = call->destination(); | |
| 1731 if (destination != entry_point) { | |
| 1732 CodeBlob* callee = CodeCache::find_blob(destination); | |
| 1733 // callee == cb seems weird. It means calling interpreter thru stub. | |
| 1734 if (callee == cb || callee->is_adapter_blob()) { | |
| 1735 // static call or optimized virtual | |
| 1736 if (TraceCallFixup) { | |
| 1204 | 1737 tty->print("fixup callsite at " INTPTR_FORMAT " to compiled code for", caller_pc); |
| 0 | 1738 moop->print_short_name(tty); |
| 1739 tty->print_cr(" to " INTPTR_FORMAT, entry_point); | |
| 1740 } | |
| 1741 call->set_destination_mt_safe(entry_point); | |
| 1742 } else { | |
| 1743 if (TraceCallFixup) { | |
| 1744 tty->print("failed to fixup callsite at " INTPTR_FORMAT " to compiled code for", caller_pc); | |
| 1745 moop->print_short_name(tty); | |
| 1746 tty->print_cr(" to " INTPTR_FORMAT, entry_point); | |
| 1747 } | |
| 1748 // assert is too strong could also be resolve destinations. | |
| 1749 // assert(InlineCacheBuffer::contains(destination) || VtableStubs::contains(destination), "must be"); | |
| 1750 } | |
| 1751 } else { | |
| 1752 if (TraceCallFixup) { | |
| 1204 | 1753 tty->print("already patched callsite at " INTPTR_FORMAT " to compiled code for", caller_pc); |
| 0 | 1754 moop->print_short_name(tty); |
| 1755 tty->print_cr(" to " INTPTR_FORMAT, entry_point); | |
| 1756 } | |
| 1757 } | |
| 1758 } | |
| 1759 } | |
| 1760 IRT_END | |
| 1761 | |
| 1762 | |
| 1763 // same as JVM_Arraycopy, but called directly from compiled code | |
| 1764 JRT_ENTRY(void, SharedRuntime::slow_arraycopy_C(oopDesc* src, jint src_pos, | |
| 1765 oopDesc* dest, jint dest_pos, | |
| 1766 jint length, | |
| 1767 JavaThread* thread)) { | |
| 1768 #ifndef PRODUCT | |
| 1769 _slow_array_copy_ctr++; | |
| 1770 #endif | |
| 1771 // Check if we have null pointers | |
| 1772 if (src == NULL || dest == NULL) { | |
| 1773 THROW(vmSymbols::java_lang_NullPointerException()); | |
| 1774 } | |
| 1775 // Do the copy. The casts to arrayOop are necessary to the copy_array API, | |
| 1776 // even though the copy_array API also performs dynamic checks to ensure | |
| 1777 // that src and dest are truly arrays (and are conformable). | |
| 1778 // The copy_array mechanism is awkward and could be removed, but | |
| 1779 // the compilers don't call this function except as a last resort, | |
| 1780 // so it probably doesn't matter. | |
| 6983 | 1781 src->klass()->copy_array((arrayOopDesc*)src, src_pos, |
| 0 | 1782 (arrayOopDesc*)dest, dest_pos, |
| 1783 length, thread); | |
| 1784 } | |
| 1785 JRT_END | |
| 1786 | |
| 1787 char* SharedRuntime::generate_class_cast_message( | |
| 1788 JavaThread* thread, const char* objName) { | |
| 1789 | |
| 1790 // Get target class name from the checkcast instruction | |
| 1791 vframeStream vfst(thread, true); | |
| 1792 assert(!vfst.at_end(), "Java frame must exist"); | |
| 2142 | 1793 Bytecode_checkcast cc(vfst.method(), vfst.method()->bcp_from(vfst.bci())); |
| 6983 | 1794 Klass* targetKlass = vfst.method()->constants()->klass_at( |
| 1795 cc.index(), thread); | |
| 0 | 1796 return generate_class_cast_message(objName, targetKlass->external_name()); |
| 1797 } | |
| 1798 | |
| 1799 char* SharedRuntime::generate_class_cast_message( | |
| 710 | 1800 const char* objName, const char* targetKlassName, const char* desc) { |
| 0 | 1801 size_t msglen = strlen(objName) + strlen(desc) + strlen(targetKlassName) + 1; |
| 1802 | |
| 53 | 1803 char* message = NEW_RESOURCE_ARRAY(char, msglen); |
| 0 | 1804 if (NULL == message) { |
| 53 | 1805 // Shouldn't happen, but don't cause even more problems if it does |
| 0 | 1806 message = const_cast<char*>(objName); |
| 1807 } else { | |
| 1808 jio_snprintf(message, msglen, "%s%s%s", objName, desc, targetKlassName); | |
| 1809 } | |
| 1810 return message; | |
| 1811 } | |
| 1812 | |
| 1813 JRT_LEAF(void, SharedRuntime::reguard_yellow_pages()) | |
| 1814 (void) JavaThread::current()->reguard_stack(); | |
| 1815 JRT_END | |
| 1816 | |
| 1817 | |
| 1818 // Handles the uncommon case in locking, i.e., contention or an inflated lock. | |
| 1819 #ifndef PRODUCT | |
| 1820 int SharedRuntime::_monitor_enter_ctr=0; | |
| 1821 #endif | |
| 1822 JRT_ENTRY_NO_ASYNC(void, SharedRuntime::complete_monitor_locking_C(oopDesc* _obj, BasicLock* lock, JavaThread* thread)) | |
| 1823 oop obj(_obj); | |
| 1824 #ifndef PRODUCT | |
| 1825 _monitor_enter_ctr++; // monitor enter slow | |
| 1826 #endif | |
| 1827 if (PrintBiasedLockingStatistics) { | |
| 1828 Atomic::inc(BiasedLocking::slow_path_entry_count_addr()); | |
| 1829 } | |
| 1830 Handle h_obj(THREAD, obj); | |
| 1831 if (UseBiasedLocking) { | |
| 1832 // Retry fast entry if bias is revoked to avoid unnecessary inflation | |
| 1833 ObjectSynchronizer::fast_enter(h_obj, lock, true, CHECK); | |
| 1834 } else { | |
| 1835 ObjectSynchronizer::slow_enter(h_obj, lock, CHECK); | |
| 1836 } | |
| 1837 assert(!HAS_PENDING_EXCEPTION, "Should have no exception here"); | |
| 1838 JRT_END | |
| 1839 | |
| 1840 #ifndef PRODUCT | |
| 1841 int SharedRuntime::_monitor_exit_ctr=0; | |
| 1842 #endif | |
| 1843 // Handles the uncommon cases of monitor unlocking in compiled code | |
| 1844 JRT_LEAF(void, SharedRuntime::complete_monitor_unlocking_C(oopDesc* _obj, BasicLock* lock)) | |
| 1845 oop obj(_obj); | |
| 1846 #ifndef PRODUCT | |
| 1847 _monitor_exit_ctr++; // monitor exit slow | |
| 1848 #endif | |
| 1849 Thread* THREAD = JavaThread::current(); | |
| 1850 // I'm not convinced we need the code contained by MIGHT_HAVE_PENDING anymore | |
| 1851 // testing was unable to ever fire the assert that guarded it so I have removed it. | |
| 1852 assert(!HAS_PENDING_EXCEPTION, "Do we need code below anymore?"); | |
| 1853 #undef MIGHT_HAVE_PENDING | |
| 1854 #ifdef MIGHT_HAVE_PENDING | |
| 1855 // Save and restore any pending_exception around the exception mark. | |
| 1856 // While the slow_exit must not throw an exception, we could come into | |
| 1857 // this routine with one set. | |
| 1858 oop pending_excep = NULL; | |
| 1859 const char* pending_file; | |
| 1860 int pending_line; | |
| 1861 if (HAS_PENDING_EXCEPTION) { | |
| 1862 pending_excep = PENDING_EXCEPTION; | |
| 1863 pending_file = THREAD->exception_file(); | |
| 1864 pending_line = THREAD->exception_line(); | |
| 1865 CLEAR_PENDING_EXCEPTION; | |
| 1866 } | |
| 1867 #endif /* MIGHT_HAVE_PENDING */ | |
| 1868 | |
| 1869 { | |
| 1870 // Exit must be non-blocking, and therefore no exceptions can be thrown. | |
| 1871 EXCEPTION_MARK; | |
| 1872 ObjectSynchronizer::slow_exit(obj, lock, THREAD); | |
| 1873 } | |
| 1874 | |
| 1875 #ifdef MIGHT_HAVE_PENDING | |
| 1876 if (pending_excep != NULL) { | |
| 1877 THREAD->set_pending_exception(pending_excep, pending_file, pending_line); | |
| 1878 } | |
| 1879 #endif /* MIGHT_HAVE_PENDING */ | |
| 1880 JRT_END | |
| 1881 | |
| 1882 #ifndef PRODUCT | |
| 1883 | |
| 1884 void SharedRuntime::print_statistics() { | |
| 1885 ttyLocker ttyl; | |
| 1886 if (xtty != NULL) xtty->head("statistics type='SharedRuntime'"); | |
| 1887 | |
| 1888 if (_monitor_enter_ctr ) tty->print_cr("%5d monitor enter slow", _monitor_enter_ctr); | |
| 1889 if (_monitor_exit_ctr ) tty->print_cr("%5d monitor exit slow", _monitor_exit_ctr); | |
| 1890 if (_throw_null_ctr) tty->print_cr("%5d implicit null throw", _throw_null_ctr); | |
| 1891 | |
| 1892 SharedRuntime::print_ic_miss_histogram(); | |
| 1893 | |
| 1894 if (CountRemovableExceptions) { | |
| 1895 if (_nof_removable_exceptions > 0) { | |
| 1896 Unimplemented(); // this counter is not yet incremented | |
| 1897 tty->print_cr("Removable exceptions: %d", _nof_removable_exceptions); | |
| 1898 } | |
| 1899 } | |
| 1900 | |
| 1901 // Dump the JRT_ENTRY counters | |
| 1902 if( _new_instance_ctr ) tty->print_cr("%5d new instance requires GC", _new_instance_ctr); | |
| 1903 if( _new_array_ctr ) tty->print_cr("%5d new array requires GC", _new_array_ctr); | |
| 1904 if( _multi1_ctr ) tty->print_cr("%5d multianewarray 1 dim", _multi1_ctr); | |
| 1905 if( _multi2_ctr ) tty->print_cr("%5d multianewarray 2 dim", _multi2_ctr); | |
| 1906 if( _multi3_ctr ) tty->print_cr("%5d multianewarray 3 dim", _multi3_ctr); | |
| 1907 if( _multi4_ctr ) tty->print_cr("%5d multianewarray 4 dim", _multi4_ctr); | |
| 1908 if( _multi5_ctr ) tty->print_cr("%5d multianewarray 5 dim", _multi5_ctr); | |
| 1909 | |
| 1910 tty->print_cr("%5d inline cache miss in compiled", _ic_miss_ctr ); | |
| 1911 tty->print_cr("%5d wrong method", _wrong_method_ctr ); | |
| 1912 tty->print_cr("%5d unresolved static call site", _resolve_static_ctr ); | |
| 1913 tty->print_cr("%5d unresolved virtual call site", _resolve_virtual_ctr ); | |
| 1914 tty->print_cr("%5d unresolved opt virtual call site", _resolve_opt_virtual_ctr ); | |
| 1915 | |
| 1916 if( _mon_enter_stub_ctr ) tty->print_cr("%5d monitor enter stub", _mon_enter_stub_ctr ); | |
| 1917 if( _mon_exit_stub_ctr ) tty->print_cr("%5d monitor exit stub", _mon_exit_stub_ctr ); | |
| 1918 if( _mon_enter_ctr ) tty->print_cr("%5d monitor enter slow", _mon_enter_ctr ); | |
| 1919 if( _mon_exit_ctr ) tty->print_cr("%5d monitor exit slow", _mon_exit_ctr ); | |
| 1920 if( _partial_subtype_ctr) tty->print_cr("%5d slow partial subtype", _partial_subtype_ctr ); | |
| 1921 if( _jbyte_array_copy_ctr ) tty->print_cr("%5d byte array copies", _jbyte_array_copy_ctr ); | |
| 1922 if( _jshort_array_copy_ctr ) tty->print_cr("%5d short array copies", _jshort_array_copy_ctr ); | |
| 1923 if( _jint_array_copy_ctr ) tty->print_cr("%5d int array copies", _jint_array_copy_ctr ); | |
| 1924 if( _jlong_array_copy_ctr ) tty->print_cr("%5d long array copies", _jlong_array_copy_ctr ); | |
| 1925 if( _oop_array_copy_ctr ) tty->print_cr("%5d oop array copies", _oop_array_copy_ctr ); | |
| 1926 if( _checkcast_array_copy_ctr ) tty->print_cr("%5d checkcast array copies", _checkcast_array_copy_ctr ); | |
| 1927 if( _unsafe_array_copy_ctr ) tty->print_cr("%5d unsafe array copies", _unsafe_array_copy_ctr ); | |
| 1928 if( _generic_array_copy_ctr ) tty->print_cr("%5d generic array copies", _generic_array_copy_ctr ); | |
| 1929 if( _slow_array_copy_ctr ) tty->print_cr("%5d slow array copies", _slow_array_copy_ctr ); | |
| 1930 if( _find_handler_ctr ) tty->print_cr("%5d find exception handler", _find_handler_ctr ); | |
| 1931 if( _rethrow_ctr ) tty->print_cr("%5d rethrow handler", _rethrow_ctr ); | |
| 1932 | |
|
1187
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
1933 AdapterHandlerLibrary::print_statistics(); |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
1934 |
| 0 | 1935 if (xtty != NULL) xtty->tail("statistics"); |
| 1936 } | |
| 1937 | |
| 1938 inline double percent(int x, int y) { | |
| 1939 return 100.0 * x / MAX2(y, 1); | |
| 1940 } | |
| 1941 | |
| 1942 class MethodArityHistogram { | |
| 1943 public: | |
| 1944 enum { MAX_ARITY = 256 }; | |
| 1945 private: | |
| 1946 static int _arity_histogram[MAX_ARITY]; // histogram of #args | |
| 1947 static int _size_histogram[MAX_ARITY]; // histogram of arg size in words | |
| 1948 static int _max_arity; // max. arity seen | |
| 1949 static int _max_size; // max. arg size seen | |
| 1950 | |
| 1951 static void add_method_to_histogram(nmethod* nm) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1952 Method* m = nm->method(); |
| 0 | 1953 ArgumentCount args(m->signature()); |
| 1954 int arity = args.size() + (m->is_static() ? 0 : 1); | |
| 1955 int argsize = m->size_of_parameters(); | |
| 1956 arity = MIN2(arity, MAX_ARITY-1); | |
| 1957 argsize = MIN2(argsize, MAX_ARITY-1); | |
| 1958 int count = nm->method()->compiled_invocation_count(); | |
| 1959 _arity_histogram[arity] += count; | |
| 1960 _size_histogram[argsize] += count; | |
| 1961 _max_arity = MAX2(_max_arity, arity); | |
| 1962 _max_size = MAX2(_max_size, argsize); | |
| 1963 } | |
| 1964 | |
| 1965 void print_histogram_helper(int n, int* histo, const char* name) { | |
| 1966 const int N = MIN2(5, n); | |
| 1967 tty->print_cr("\nHistogram of call arity (incl. rcvr, calls to compiled methods only):"); | |
| 1968 double sum = 0; | |
| 1969 double weighted_sum = 0; | |
| 1970 int i; | |
| 1971 for (i = 0; i <= n; i++) { sum += histo[i]; weighted_sum += i*histo[i]; } | |
| 1972 double rest = sum; | |
| 1973 double percent = sum / 100; | |
| 1974 for (i = 0; i <= N; i++) { | |
| 1975 rest -= histo[i]; | |
| 1976 tty->print_cr("%4d: %7d (%5.1f%%)", i, histo[i], histo[i] / percent); | |
| 1977 } | |
| 1978 tty->print_cr("rest: %7d (%5.1f%%))", (int)rest, rest / percent); | |
| 1979 tty->print_cr("(avg. %s = %3.1f, max = %d)", name, weighted_sum / sum, n); | |
| 1980 } | |
| 1981 | |
| 1982 void print_histogram() { | |
| 1983 tty->print_cr("\nHistogram of call arity (incl. rcvr, calls to compiled methods only):"); | |
| 1984 print_histogram_helper(_max_arity, _arity_histogram, "arity"); | |
| 1985 tty->print_cr("\nSame for parameter size (in words):"); | |
| 1986 print_histogram_helper(_max_size, _size_histogram, "size"); | |
| 1987 tty->cr(); | |
| 1988 } | |
| 1989 | |
| 1990 public: | |
| 1991 MethodArityHistogram() { | |
| 1992 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); | |
| 1993 _max_arity = _max_size = 0; | |
| 1994 for (int i = 0; i < MAX_ARITY; i++) _arity_histogram[i] = _size_histogram [i] = 0; | |
| 1995 CodeCache::nmethods_do(add_method_to_histogram); | |
| 1996 print_histogram(); | |
| 1997 } | |
| 1998 }; | |
| 1999 | |
| 2000 int MethodArityHistogram::_arity_histogram[MethodArityHistogram::MAX_ARITY]; | |
| 2001 int MethodArityHistogram::_size_histogram[MethodArityHistogram::MAX_ARITY]; | |
| 2002 int MethodArityHistogram::_max_arity; | |
| 2003 int MethodArityHistogram::_max_size; | |
| 2004 | |
| 2005 void SharedRuntime::print_call_statistics(int comp_total) { | |
| 2006 tty->print_cr("Calls from compiled code:"); | |
| 2007 int total = _nof_normal_calls + _nof_interface_calls + _nof_static_calls; | |
| 2008 int mono_c = _nof_normal_calls - _nof_optimized_calls - _nof_megamorphic_calls; | |
| 2009 int mono_i = _nof_interface_calls - _nof_optimized_interface_calls - _nof_megamorphic_interface_calls; | |
| 2010 tty->print_cr("\t%9d (%4.1f%%) total non-inlined ", total, percent(total, total)); | |
| 2011 tty->print_cr("\t%9d (%4.1f%%) virtual calls ", _nof_normal_calls, percent(_nof_normal_calls, total)); | |
| 2012 tty->print_cr("\t %9d (%3.0f%%) inlined ", _nof_inlined_calls, percent(_nof_inlined_calls, _nof_normal_calls)); | |
| 2013 tty->print_cr("\t %9d (%3.0f%%) optimized ", _nof_optimized_calls, percent(_nof_optimized_calls, _nof_normal_calls)); | |
| 2014 tty->print_cr("\t %9d (%3.0f%%) monomorphic ", mono_c, percent(mono_c, _nof_normal_calls)); | |
| 2015 tty->print_cr("\t %9d (%3.0f%%) megamorphic ", _nof_megamorphic_calls, percent(_nof_megamorphic_calls, _nof_normal_calls)); | |
| 2016 tty->print_cr("\t%9d (%4.1f%%) interface calls ", _nof_interface_calls, percent(_nof_interface_calls, total)); | |
| 2017 tty->print_cr("\t %9d (%3.0f%%) inlined ", _nof_inlined_interface_calls, percent(_nof_inlined_interface_calls, _nof_interface_calls)); | |
| 2018 tty->print_cr("\t %9d (%3.0f%%) optimized ", _nof_optimized_interface_calls, percent(_nof_optimized_interface_calls, _nof_interface_calls)); | |
| 2019 tty->print_cr("\t %9d (%3.0f%%) monomorphic ", mono_i, percent(mono_i, _nof_interface_calls)); | |
| 2020 tty->print_cr("\t %9d (%3.0f%%) megamorphic ", _nof_megamorphic_interface_calls, percent(_nof_megamorphic_interface_calls, _nof_interface_calls)); | |
| 2021 tty->print_cr("\t%9d (%4.1f%%) static/special calls", _nof_static_calls, percent(_nof_static_calls, total)); | |
| 2022 tty->print_cr("\t %9d (%3.0f%%) inlined ", _nof_inlined_static_calls, percent(_nof_inlined_static_calls, _nof_static_calls)); | |
| 2023 tty->cr(); | |
| 2024 tty->print_cr("Note 1: counter updates are not MT-safe."); | |
| 2025 tty->print_cr("Note 2: %% in major categories are relative to total non-inlined calls;"); | |
| 2026 tty->print_cr(" %% in nested categories are relative to their category"); | |
| 2027 tty->print_cr(" (and thus add up to more than 100%% with inlining)"); | |
| 2028 tty->cr(); | |
| 2029 | |
| 2030 MethodArityHistogram h; | |
| 2031 } | |
| 2032 #endif | |
| 2033 | |
| 2034 | |
|
1187
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2035 // A simple wrapper class around the calling convention information |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2036 // that allows sharing of adapters for the same calling convention. |
| 6197 | 2037 class AdapterFingerPrint : public CHeapObj<mtCode> { |
|
1187
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2038 private: |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
2039 enum { |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
2040 _basic_type_bits = 4, |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
2041 _basic_type_mask = right_n_bits(_basic_type_bits), |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
2042 _basic_types_per_int = BitsPerInt / _basic_type_bits, |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
2043 _compact_int_count = 3 |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
2044 }; |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
2045 // TO DO: Consider integrating this with a more global scheme for compressing signatures. |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
2046 // For now, 4 bits per components (plus T_VOID gaps after double/long) is not excessive. |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
2047 |
|
1187
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2048 union { |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
2049 int _compact[_compact_int_count]; |
|
1207
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2050 int* _fingerprint; |
|
1187
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2051 } _value; |
|
1207
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2052 int _length; // A negative length indicates the fingerprint is in the compact form, |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2053 // Otherwise _value._fingerprint is the array. |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2054 |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2055 // Remap BasicTypes that are handled equivalently by the adapters. |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2056 // These are correct for the current system but someday it might be |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2057 // necessary to make this mapping platform dependent. |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
2058 static int adapter_encoding(BasicType in) { |
|
1207
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2059 switch(in) { |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2060 case T_BOOLEAN: |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2061 case T_BYTE: |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2062 case T_SHORT: |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2063 case T_CHAR: |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2064 // There are all promoted to T_INT in the calling convention |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2065 return T_INT; |
|
1187
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2066 |
|
1207
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2067 case T_OBJECT: |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2068 case T_ARRAY: |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
2069 // In other words, we assume that any register good enough for |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
2070 // an int or long is good enough for a managed pointer. |
|
1207
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2071 #ifdef _LP64 |
| 1506 | 2072 return T_LONG; |
|
1207
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2073 #else |
| 1506 | 2074 return T_INT; |
|
1207
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2075 #endif |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2076 |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2077 case T_INT: |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2078 case T_LONG: |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2079 case T_FLOAT: |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2080 case T_DOUBLE: |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2081 case T_VOID: |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2082 return in; |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2083 |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2084 default: |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2085 ShouldNotReachHere(); |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2086 return T_CONFLICT; |
|
1187
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2087 } |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2088 } |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2089 |
|
1207
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2090 public: |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2091 AdapterFingerPrint(int total_args_passed, BasicType* sig_bt) { |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2092 // The fingerprint is based on the BasicType signature encoded |
|
3841
0f34fdee809e
7071427: AdapterFingerPrint can hold 8 entries per int
never
parents:
3781
diff
changeset
|
2093 // into an array of ints with eight entries per int. |
|
1207
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2094 int* ptr; |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
2095 int len = (total_args_passed + (_basic_types_per_int-1)) / _basic_types_per_int; |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
2096 if (len <= _compact_int_count) { |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
2097 assert(_compact_int_count == 3, "else change next line"); |
|
1207
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2098 _value._compact[0] = _value._compact[1] = _value._compact[2] = 0; |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2099 // Storing the signature encoded as signed chars hits about 98% |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2100 // of the time. |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2101 _length = -len; |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2102 ptr = _value._compact; |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2103 } else { |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2104 _length = len; |
| 6197 | 2105 _value._fingerprint = NEW_C_HEAP_ARRAY(int, _length, mtCode); |
|
1207
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2106 ptr = _value._fingerprint; |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2107 } |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2108 |
|
3841
0f34fdee809e
7071427: AdapterFingerPrint can hold 8 entries per int
never
parents:
3781
diff
changeset
|
2109 // Now pack the BasicTypes with 8 per int |
|
1207
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2110 int sig_index = 0; |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2111 for (int index = 0; index < len; index++) { |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2112 int value = 0; |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
2113 for (int byte = 0; byte < _basic_types_per_int; byte++) { |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
2114 int bt = ((sig_index < total_args_passed) |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
2115 ? adapter_encoding(sig_bt[sig_index++]) |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
2116 : 0); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
2117 assert((bt & _basic_type_mask) == bt, "must fit in 4 bits"); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
2118 value = (value << _basic_type_bits) | bt; |
|
1207
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2119 } |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2120 ptr[index] = value; |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2121 } |
|
1187
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2122 } |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2123 |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2124 ~AdapterFingerPrint() { |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2125 if (_length > 0) { |
| 6197 | 2126 FREE_C_HEAP_ARRAY(int, _value._fingerprint, mtCode); |
|
1187
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2127 } |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2128 } |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2129 |
|
1207
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2130 int value(int index) { |
|
1187
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2131 if (_length < 0) { |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2132 return _value._compact[index]; |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2133 } |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2134 return _value._fingerprint[index]; |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2135 } |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2136 int length() { |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2137 if (_length < 0) return -_length; |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2138 return _length; |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2139 } |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2140 |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2141 bool is_compact() { |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2142 return _length <= 0; |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2143 } |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2144 |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2145 unsigned int compute_hash() { |
|
1207
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2146 int hash = 0; |
|
1187
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2147 for (int i = 0; i < length(); i++) { |
|
1207
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2148 int v = value(i); |
|
1187
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2149 hash = (hash << 8) ^ v ^ (hash >> 5); |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2150 } |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2151 return (unsigned int)hash; |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2152 } |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2153 |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2154 const char* as_string() { |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2155 stringStream st; |
|
3841
0f34fdee809e
7071427: AdapterFingerPrint can hold 8 entries per int
never
parents:
3781
diff
changeset
|
2156 st.print("0x"); |
|
1187
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2157 for (int i = 0; i < length(); i++) { |
|
3841
0f34fdee809e
7071427: AdapterFingerPrint can hold 8 entries per int
never
parents:
3781
diff
changeset
|
2158 st.print("%08x", value(i)); |
|
1187
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2159 } |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2160 return st.as_string(); |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2161 } |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2162 |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2163 bool equals(AdapterFingerPrint* other) { |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2164 if (other->_length != _length) { |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2165 return false; |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2166 } |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2167 if (_length < 0) { |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
2168 assert(_compact_int_count == 3, "else change next line"); |
|
1207
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2169 return _value._compact[0] == other->_value._compact[0] && |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2170 _value._compact[1] == other->_value._compact[1] && |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2171 _value._compact[2] == other->_value._compact[2]; |
|
1187
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2172 } else { |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2173 for (int i = 0; i < _length; i++) { |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2174 if (_value._fingerprint[i] != other->_value._fingerprint[i]) { |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2175 return false; |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2176 } |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2177 } |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2178 } |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2179 return true; |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2180 } |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2181 }; |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2182 |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2183 |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2184 // A hashtable mapping from AdapterFingerPrints to AdapterHandlerEntries |
| 6197 | 2185 class AdapterHandlerTable : public BasicHashtable<mtCode> { |
|
1187
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2186 friend class AdapterHandlerTableIterator; |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2187 |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2188 private: |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2189 |
|
1263
e7b1cc79bd25
6926697: "optimized" VM build failed: The type "AdapterHandlerTableIterator" is incomplete
kvn
parents:
1257
diff
changeset
|
2190 #ifndef PRODUCT |
|
1187
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2191 static int _lookups; // number of calls to lookup |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2192 static int _buckets; // number of buckets checked |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2193 static int _equals; // number of buckets checked with matching hash |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2194 static int _hits; // number of successful lookups |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2195 static int _compact; // number of equals calls with compact signature |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2196 #endif |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2197 |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2198 AdapterHandlerEntry* bucket(int i) { |
| 6197 | 2199 return (AdapterHandlerEntry*)BasicHashtable<mtCode>::bucket(i); |
|
1187
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2200 } |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2201 |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2202 public: |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2203 AdapterHandlerTable() |
| 6197 | 2204 : BasicHashtable<mtCode>(293, sizeof(AdapterHandlerEntry)) { } |
|
1187
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2205 |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2206 // Create a new entry suitable for insertion in the table |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2207 AdapterHandlerEntry* new_entry(AdapterFingerPrint* fingerprint, address i2c_entry, address c2i_entry, address c2i_unverified_entry) { |
| 6197 | 2208 AdapterHandlerEntry* entry = (AdapterHandlerEntry*)BasicHashtable<mtCode>::new_entry(fingerprint->compute_hash()); |
|
1187
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2209 entry->init(fingerprint, i2c_entry, c2i_entry, c2i_unverified_entry); |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2210 return entry; |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2211 } |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2212 |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2213 // Insert an entry into the table |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2214 void add(AdapterHandlerEntry* entry) { |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2215 int index = hash_to_index(entry->hash()); |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2216 add_entry(index, entry); |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2217 } |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2218 |
|
1207
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2219 void free_entry(AdapterHandlerEntry* entry) { |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2220 entry->deallocate(); |
| 6197 | 2221 BasicHashtable<mtCode>::free_entry(entry); |
|
1207
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2222 } |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2223 |
|
1187
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2224 // Find a entry with the same fingerprint if it exists |
|
1207
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2225 AdapterHandlerEntry* lookup(int total_args_passed, BasicType* sig_bt) { |
|
1263
e7b1cc79bd25
6926697: "optimized" VM build failed: The type "AdapterHandlerTableIterator" is incomplete
kvn
parents:
1257
diff
changeset
|
2226 NOT_PRODUCT(_lookups++); |
|
1207
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2227 AdapterFingerPrint fp(total_args_passed, sig_bt); |
|
1187
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2228 unsigned int hash = fp.compute_hash(); |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2229 int index = hash_to_index(hash); |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2230 for (AdapterHandlerEntry* e = bucket(index); e != NULL; e = e->next()) { |
|
1263
e7b1cc79bd25
6926697: "optimized" VM build failed: The type "AdapterHandlerTableIterator" is incomplete
kvn
parents:
1257
diff
changeset
|
2231 NOT_PRODUCT(_buckets++); |
|
1187
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2232 if (e->hash() == hash) { |
|
1263
e7b1cc79bd25
6926697: "optimized" VM build failed: The type "AdapterHandlerTableIterator" is incomplete
kvn
parents:
1257
diff
changeset
|
2233 NOT_PRODUCT(_equals++); |
|
1187
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2234 if (fp.equals(e->fingerprint())) { |
|
1263
e7b1cc79bd25
6926697: "optimized" VM build failed: The type "AdapterHandlerTableIterator" is incomplete
kvn
parents:
1257
diff
changeset
|
2235 #ifndef PRODUCT |
|
1187
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2236 if (fp.is_compact()) _compact++; |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2237 _hits++; |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2238 #endif |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2239 return e; |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2240 } |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2241 } |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2242 } |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2243 return NULL; |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2244 } |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2245 |
|
1263
e7b1cc79bd25
6926697: "optimized" VM build failed: The type "AdapterHandlerTableIterator" is incomplete
kvn
parents:
1257
diff
changeset
|
2246 #ifndef PRODUCT |
|
1187
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2247 void print_statistics() { |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2248 ResourceMark rm; |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2249 int longest = 0; |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2250 int empty = 0; |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2251 int total = 0; |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2252 int nonempty = 0; |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2253 for (int index = 0; index < table_size(); index++) { |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2254 int count = 0; |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2255 for (AdapterHandlerEntry* e = bucket(index); e != NULL; e = e->next()) { |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2256 count++; |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2257 } |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2258 if (count != 0) nonempty++; |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2259 if (count == 0) empty++; |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2260 if (count > longest) longest = count; |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2261 total += count; |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2262 } |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2263 tty->print_cr("AdapterHandlerTable: empty %d longest %d total %d average %f", |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2264 empty, longest, total, total / (double)nonempty); |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2265 tty->print_cr("AdapterHandlerTable: lookups %d buckets %d equals %d hits %d compact %d", |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2266 _lookups, _buckets, _equals, _hits, _compact); |
|
1263
e7b1cc79bd25
6926697: "optimized" VM build failed: The type "AdapterHandlerTableIterator" is incomplete
kvn
parents:
1257
diff
changeset
|
2267 } |
|
1187
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2268 #endif |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2269 }; |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2270 |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2271 |
|
1263
e7b1cc79bd25
6926697: "optimized" VM build failed: The type "AdapterHandlerTableIterator" is incomplete
kvn
parents:
1257
diff
changeset
|
2272 #ifndef PRODUCT |
|
1187
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2273 |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2274 int AdapterHandlerTable::_lookups; |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2275 int AdapterHandlerTable::_buckets; |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2276 int AdapterHandlerTable::_equals; |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2277 int AdapterHandlerTable::_hits; |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2278 int AdapterHandlerTable::_compact; |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2279 |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
2280 #endif |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
2281 |
|
1187
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2282 class AdapterHandlerTableIterator : public StackObj { |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2283 private: |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2284 AdapterHandlerTable* _table; |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2285 int _index; |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2286 AdapterHandlerEntry* _current; |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2287 |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2288 void scan() { |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2289 while (_index < _table->table_size()) { |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2290 AdapterHandlerEntry* a = _table->bucket(_index); |
| 1564 | 2291 _index++; |
|
1187
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2292 if (a != NULL) { |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2293 _current = a; |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2294 return; |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2295 } |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2296 } |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2297 } |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2298 |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2299 public: |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2300 AdapterHandlerTableIterator(AdapterHandlerTable* table): _table(table), _index(0), _current(NULL) { |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2301 scan(); |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2302 } |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2303 bool has_next() { |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2304 return _current != NULL; |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2305 } |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2306 AdapterHandlerEntry* next() { |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2307 if (_current != NULL) { |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2308 AdapterHandlerEntry* result = _current; |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2309 _current = _current->next(); |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2310 if (_current == NULL) scan(); |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2311 return result; |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2312 } else { |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2313 return NULL; |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2314 } |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2315 } |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2316 }; |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2317 |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2318 |
| 0 | 2319 // --------------------------------------------------------------------------- |
| 2320 // Implementation of AdapterHandlerLibrary | |
|
1187
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2321 AdapterHandlerTable* AdapterHandlerLibrary::_adapters = NULL; |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2322 AdapterHandlerEntry* AdapterHandlerLibrary::_abstract_method_handler = NULL; |
| 0 | 2323 const int AdapterHandlerLibrary_size = 16*K; |
|
742
45463a04ca27
6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents:
710
diff
changeset
|
2324 BufferBlob* AdapterHandlerLibrary::_buffer = NULL; |
|
45463a04ca27
6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents:
710
diff
changeset
|
2325 |
|
45463a04ca27
6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents:
710
diff
changeset
|
2326 BufferBlob* AdapterHandlerLibrary::buffer_blob() { |
|
45463a04ca27
6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents:
710
diff
changeset
|
2327 // Should be called only when AdapterHandlerLibrary_lock is active. |
|
45463a04ca27
6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents:
710
diff
changeset
|
2328 if (_buffer == NULL) // Initialize lazily |
|
45463a04ca27
6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents:
710
diff
changeset
|
2329 _buffer = BufferBlob::create("adapters", AdapterHandlerLibrary_size); |
|
45463a04ca27
6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents:
710
diff
changeset
|
2330 return _buffer; |
|
45463a04ca27
6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents:
710
diff
changeset
|
2331 } |
| 0 | 2332 |
| 2333 void AdapterHandlerLibrary::initialize() { | |
|
1187
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2334 if (_adapters != NULL) return; |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2335 _adapters = new AdapterHandlerTable(); |
| 0 | 2336 |
| 2337 // Create a special handler for abstract methods. Abstract methods | |
| 2338 // are never compiled so an i2c entry is somewhat meaningless, but | |
| 2339 // fill it in with something appropriate just in case. Pass handle | |
| 2340 // wrong method for the c2i transitions. | |
| 2341 address wrong_method = SharedRuntime::get_handle_wrong_method_stub(); | |
|
1187
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2342 _abstract_method_handler = AdapterHandlerLibrary::new_entry(new AdapterFingerPrint(0, NULL), |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2343 StubRoutines::throw_AbstractMethodError_entry(), |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2344 wrong_method, wrong_method); |
| 0 | 2345 } |
| 2346 | |
|
1187
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2347 AdapterHandlerEntry* AdapterHandlerLibrary::new_entry(AdapterFingerPrint* fingerprint, |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2348 address i2c_entry, |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2349 address c2i_entry, |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2350 address c2i_unverified_entry) { |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2351 return _adapters->new_entry(fingerprint, i2c_entry, c2i_entry, c2i_unverified_entry); |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2352 } |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2353 |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2354 AdapterHandlerEntry* AdapterHandlerLibrary::get_adapter(methodHandle method) { |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2355 // Use customized signature handler. Need to lock around updates to |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2356 // the AdapterHandlerTable (it is not safe for concurrent readers |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2357 // and a single writer: this could be fixed if it becomes a |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2358 // problem). |
| 0 | 2359 |
| 2360 // Get the address of the ic_miss handlers before we grab the | |
| 2361 // AdapterHandlerLibrary_lock. This fixes bug 6236259 which | |
| 2362 // was caused by the initialization of the stubs happening | |
| 2363 // while we held the lock and then notifying jvmti while | |
| 2364 // holding it. This just forces the initialization to be a little | |
| 2365 // earlier. | |
| 2366 address ic_miss = SharedRuntime::get_ic_miss_stub(); | |
| 2367 assert(ic_miss != NULL, "must have handler"); | |
| 2368 | |
|
1187
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2369 ResourceMark rm; |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2370 |
| 1748 | 2371 NOT_PRODUCT(int insts_size); |
|
1299
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1295
diff
changeset
|
2372 AdapterBlob* B = NULL; |
|
742
45463a04ca27
6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents:
710
diff
changeset
|
2373 AdapterHandlerEntry* entry = NULL; |
|
1187
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2374 AdapterFingerPrint* fingerprint = NULL; |
| 0 | 2375 { |
| 2376 MutexLocker mu(AdapterHandlerLibrary_lock); | |
| 2377 // make sure data structure is initialized | |
| 2378 initialize(); | |
| 2379 | |
| 2380 if (method->is_abstract()) { | |
|
1187
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2381 return _abstract_method_handler; |
| 0 | 2382 } |
| 2383 | |
|
1187
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2384 // Fill in the signature array, for the calling-convention call. |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2385 int total_args_passed = method->size_of_parameters(); // All args on stack |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2386 |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2387 BasicType* sig_bt = NEW_RESOURCE_ARRAY(BasicType, total_args_passed); |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2388 VMRegPair* regs = NEW_RESOURCE_ARRAY(VMRegPair, total_args_passed); |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2389 int i = 0; |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2390 if (!method->is_static()) // Pass in receiver first |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2391 sig_bt[i++] = T_OBJECT; |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2392 for (SignatureStream ss(method->signature()); !ss.at_return_type(); ss.next()) { |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2393 sig_bt[i++] = ss.type(); // Collect remaining bits of signature |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2394 if (ss.type() == T_LONG || ss.type() == T_DOUBLE) |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2395 sig_bt[i++] = T_VOID; // Longs & doubles take 2 Java slots |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2396 } |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2397 assert(i == total_args_passed, ""); |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2398 |
|
1207
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2399 // Lookup method signature's fingerprint |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2400 entry = _adapters->lookup(total_args_passed, sig_bt); |
|
1187
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2401 |
|
1207
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2402 #ifdef ASSERT |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2403 AdapterHandlerEntry* shared_entry = NULL; |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2404 if (VerifyAdapterSharing && entry != NULL) { |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2405 shared_entry = entry; |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2406 entry = NULL; |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2407 } |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2408 #endif |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2409 |
|
1187
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2410 if (entry != NULL) { |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2411 return entry; |
| 0 | 2412 } |
| 2413 | |
|
1207
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2414 // Get a description of the compiled java calling convention and the largest used (VMReg) stack slot usage |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2415 int comp_args_on_stack = SharedRuntime::java_calling_convention(sig_bt, regs, total_args_passed, false); |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2416 |
|
1187
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2417 // Make a C heap allocated version of the fingerprint to store in the adapter |
|
1207
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2418 fingerprint = new AdapterFingerPrint(total_args_passed, sig_bt); |
|
1187
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2419 |
| 0 | 2420 // Create I2C & C2I handlers |
| 2421 | |
|
1299
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1295
diff
changeset
|
2422 BufferBlob* buf = buffer_blob(); // the temporary code buffer in CodeCache |
|
742
45463a04ca27
6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents:
710
diff
changeset
|
2423 if (buf != NULL) { |
| 1748 | 2424 CodeBuffer buffer(buf); |
|
742
45463a04ca27
6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents:
710
diff
changeset
|
2425 short buffer_locs[20]; |
|
45463a04ca27
6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents:
710
diff
changeset
|
2426 buffer.insts()->initialize_shared_locs((relocInfo*)buffer_locs, |
|
45463a04ca27
6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents:
710
diff
changeset
|
2427 sizeof(buffer_locs)/sizeof(relocInfo)); |
|
45463a04ca27
6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents:
710
diff
changeset
|
2428 MacroAssembler _masm(&buffer); |
|
45463a04ca27
6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents:
710
diff
changeset
|
2429 |
|
45463a04ca27
6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents:
710
diff
changeset
|
2430 entry = SharedRuntime::generate_i2c2i_adapters(&_masm, |
|
45463a04ca27
6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents:
710
diff
changeset
|
2431 total_args_passed, |
|
45463a04ca27
6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents:
710
diff
changeset
|
2432 comp_args_on_stack, |
|
45463a04ca27
6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents:
710
diff
changeset
|
2433 sig_bt, |
|
1187
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2434 regs, |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2435 fingerprint); |
| 0 | 2436 |
|
1207
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2437 #ifdef ASSERT |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2438 if (VerifyAdapterSharing) { |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2439 if (shared_entry != NULL) { |
| 1748 | 2440 assert(shared_entry->compare_code(buf->code_begin(), buffer.insts_size(), total_args_passed, sig_bt), |
|
1207
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2441 "code must match"); |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2442 // Release the one just created and return the original |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2443 _adapters->free_entry(entry); |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2444 return shared_entry; |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2445 } else { |
| 1748 | 2446 entry->save_code(buf->code_begin(), buffer.insts_size(), total_args_passed, sig_bt); |
|
1207
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2447 } |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2448 } |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2449 #endif |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2450 |
|
1299
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1295
diff
changeset
|
2451 B = AdapterBlob::create(&buffer); |
| 1748 | 2452 NOT_PRODUCT(insts_size = buffer.insts_size()); |
|
742
45463a04ca27
6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents:
710
diff
changeset
|
2453 } |
| 28 | 2454 if (B == NULL) { |
| 2455 // CodeCache is full, disable compilation | |
| 2456 // Ought to log this but compile log is only per compile thread | |
| 2457 // and we're some non descript Java thread. | |
| 1202 | 2458 MutexUnlocker mu(AdapterHandlerLibrary_lock); |
| 2459 CompileBroker::handle_full_code_cache(); | |
|
1187
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2460 return NULL; // Out of CodeCache space |
| 28 | 2461 } |
| 1748 | 2462 entry->relocate(B->content_begin()); |
| 0 | 2463 #ifndef PRODUCT |
| 2464 // debugging suppport | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
2465 if (PrintAdapterHandlers || PrintStubCode) { |
|
6796
b31471cdc53e
7200163: add CodeComments functionality to assember stubs
kvn
parents:
6792
diff
changeset
|
2466 ttyLocker ttyl; |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
2467 entry->print_adapter_on(tty); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
2468 tty->print_cr("i2c argument handler #%d for: %s %s (%d bytes generated)", |
|
1187
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2469 _adapters->number_of_entries(), (method->is_static() ? "static" : "receiver"), |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
2470 method->signature()->as_C_string(), insts_size); |
| 0 | 2471 tty->print_cr("c2i argument handler starts at %p",entry->get_c2i_entry()); |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
2472 if (Verbose || PrintStubCode) { |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
2473 address first_pc = entry->base_address(); |
|
6796
b31471cdc53e
7200163: add CodeComments functionality to assember stubs
kvn
parents:
6792
diff
changeset
|
2474 if (first_pc != NULL) { |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
2475 Disassembler::decode(first_pc, first_pc + insts_size); |
|
6796
b31471cdc53e
7200163: add CodeComments functionality to assember stubs
kvn
parents:
6792
diff
changeset
|
2476 tty->cr(); |
|
b31471cdc53e
7200163: add CodeComments functionality to assember stubs
kvn
parents:
6792
diff
changeset
|
2477 } |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
2478 } |
| 0 | 2479 } |
| 2480 #endif | |
| 2481 | |
|
1187
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2482 _adapters->add(entry); |
| 0 | 2483 } |
| 2484 // Outside of the lock | |
| 2485 if (B != NULL) { | |
| 2486 char blob_id[256]; | |
| 2487 jio_snprintf(blob_id, | |
| 2488 sizeof(blob_id), | |
|
1187
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2489 "%s(%s)@" PTR_FORMAT, |
|
1299
9eba43136cb5
6934494: JSR 292 MethodHandles adapters should be generated into their own CodeBlob
twisti
parents:
1295
diff
changeset
|
2490 B->name(), |
|
1187
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2491 fingerprint->as_string(), |
| 1748 | 2492 B->content_begin()); |
| 2493 Forte::register_stub(blob_id, B->content_begin(), B->content_end()); | |
| 0 | 2494 |
| 2495 if (JvmtiExport::should_post_dynamic_code_generated()) { | |
| 1748 | 2496 JvmtiExport::post_dynamic_code_generated(blob_id, B->content_begin(), B->content_end()); |
| 0 | 2497 } |
| 2498 } | |
|
1187
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2499 return entry; |
| 0 | 2500 } |
| 2501 | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
2502 address AdapterHandlerEntry::base_address() { |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
2503 address base = _i2c_entry; |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
2504 if (base == NULL) base = _c2i_entry; |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
2505 assert(base <= _c2i_entry || _c2i_entry == NULL, ""); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
2506 assert(base <= _c2i_unverified_entry || _c2i_unverified_entry == NULL, ""); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
2507 return base; |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
2508 } |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
2509 |
| 0 | 2510 void AdapterHandlerEntry::relocate(address new_base) { |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
2511 address old_base = base_address(); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
2512 assert(old_base != NULL, ""); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
2513 ptrdiff_t delta = new_base - old_base; |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
2514 if (_i2c_entry != NULL) |
| 0 | 2515 _i2c_entry += delta; |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
2516 if (_c2i_entry != NULL) |
| 0 | 2517 _c2i_entry += delta; |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
2518 if (_c2i_unverified_entry != NULL) |
| 0 | 2519 _c2i_unverified_entry += delta; |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
2520 assert(base_address() == new_base, ""); |
| 0 | 2521 } |
| 2522 | |
|
1207
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2523 |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2524 void AdapterHandlerEntry::deallocate() { |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2525 delete _fingerprint; |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2526 #ifdef ASSERT |
| 6197 | 2527 if (_saved_code) FREE_C_HEAP_ARRAY(unsigned char, _saved_code, mtCode); |
| 2528 if (_saved_sig) FREE_C_HEAP_ARRAY(Basictype, _saved_sig, mtCode); | |
|
1207
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2529 #endif |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2530 } |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2531 |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2532 |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2533 #ifdef ASSERT |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2534 // Capture the code before relocation so that it can be compared |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2535 // against other versions. If the code is captured after relocation |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2536 // then relative instructions won't be equivalent. |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2537 void AdapterHandlerEntry::save_code(unsigned char* buffer, int length, int total_args_passed, BasicType* sig_bt) { |
| 6197 | 2538 _saved_code = NEW_C_HEAP_ARRAY(unsigned char, length, mtCode); |
|
1207
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2539 _code_length = length; |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2540 memcpy(_saved_code, buffer, length); |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2541 _total_args_passed = total_args_passed; |
| 6197 | 2542 _saved_sig = NEW_C_HEAP_ARRAY(BasicType, _total_args_passed, mtCode); |
|
1207
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2543 memcpy(_saved_sig, sig_bt, _total_args_passed * sizeof(BasicType)); |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2544 } |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2545 |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2546 |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2547 bool AdapterHandlerEntry::compare_code(unsigned char* buffer, int length, int total_args_passed, BasicType* sig_bt) { |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2548 if (length != _code_length) { |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2549 return false; |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2550 } |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2551 for (int i = 0; i < length; i++) { |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2552 if (buffer[i] != _saved_code[i]) { |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2553 return false; |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2554 } |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2555 } |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2556 return true; |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2557 } |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2558 #endif |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2559 |
|
74c848d437ab
6921922: fix for 6911204 breaks tagged stack interpreter
never
parents:
1205
diff
changeset
|
2560 |
| 0 | 2561 // Create a native wrapper for this native method. The wrapper converts the |
| 2562 // java compiled calling convention to the native convention, handlizes | |
| 2563 // arguments, and transitions to native. On return from the native we transition | |
| 2564 // back to java blocking if a safepoint is in progress. | |
|
2405
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2321
diff
changeset
|
2565 nmethod *AdapterHandlerLibrary::create_native_wrapper(methodHandle method, int compile_id) { |
| 0 | 2566 ResourceMark rm; |
| 2567 nmethod* nm = NULL; | |
| 2568 | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
2569 assert(method->is_native(), "must be native"); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
2570 assert(method->is_method_handle_intrinsic() || |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
2571 method->has_native_function(), "must have something valid to call!"); |
| 0 | 2572 |
| 2573 { | |
| 2574 // perform the work while holding the lock, but perform any printing outside the lock | |
| 2575 MutexLocker mu(AdapterHandlerLibrary_lock); | |
| 2576 // See if somebody beat us to it | |
| 2577 nm = method->code(); | |
| 2578 if (nm) { | |
| 2579 return nm; | |
| 2580 } | |
| 2581 | |
|
742
45463a04ca27
6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents:
710
diff
changeset
|
2582 ResourceMark rm; |
| 0 | 2583 |
|
742
45463a04ca27
6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents:
710
diff
changeset
|
2584 BufferBlob* buf = buffer_blob(); // the temporary code buffer in CodeCache |
|
45463a04ca27
6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents:
710
diff
changeset
|
2585 if (buf != NULL) { |
| 1748 | 2586 CodeBuffer buffer(buf); |
|
742
45463a04ca27
6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents:
710
diff
changeset
|
2587 double locs_buf[20]; |
|
45463a04ca27
6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents:
710
diff
changeset
|
2588 buffer.insts()->initialize_shared_locs((relocInfo*)locs_buf, sizeof(locs_buf) / sizeof(relocInfo)); |
|
45463a04ca27
6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents:
710
diff
changeset
|
2589 MacroAssembler _masm(&buffer); |
|
45463a04ca27
6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents:
710
diff
changeset
|
2590 |
|
45463a04ca27
6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents:
710
diff
changeset
|
2591 // Fill in the signature array, for the calling-convention call. |
|
6790
2cb2f30450c7
7196262: JSR 292: java/lang/invoke/PrivateInvokeTest.java fails on solaris-sparc
twisti
parents:
6725
diff
changeset
|
2592 const int total_args_passed = method->size_of_parameters(); |
|
2cb2f30450c7
7196262: JSR 292: java/lang/invoke/PrivateInvokeTest.java fails on solaris-sparc
twisti
parents:
6725
diff
changeset
|
2593 |
|
2cb2f30450c7
7196262: JSR 292: java/lang/invoke/PrivateInvokeTest.java fails on solaris-sparc
twisti
parents:
6725
diff
changeset
|
2594 BasicType* sig_bt = NEW_RESOURCE_ARRAY(BasicType, total_args_passed); |
|
2cb2f30450c7
7196262: JSR 292: java/lang/invoke/PrivateInvokeTest.java fails on solaris-sparc
twisti
parents:
6725
diff
changeset
|
2595 VMRegPair* regs = NEW_RESOURCE_ARRAY(VMRegPair, total_args_passed); |
|
742
45463a04ca27
6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents:
710
diff
changeset
|
2596 int i=0; |
|
45463a04ca27
6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents:
710
diff
changeset
|
2597 if( !method->is_static() ) // Pass in receiver first |
|
45463a04ca27
6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents:
710
diff
changeset
|
2598 sig_bt[i++] = T_OBJECT; |
|
45463a04ca27
6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents:
710
diff
changeset
|
2599 SignatureStream ss(method->signature()); |
|
45463a04ca27
6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents:
710
diff
changeset
|
2600 for( ; !ss.at_return_type(); ss.next()) { |
|
45463a04ca27
6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents:
710
diff
changeset
|
2601 sig_bt[i++] = ss.type(); // Collect remaining bits of signature |
|
45463a04ca27
6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents:
710
diff
changeset
|
2602 if( ss.type() == T_LONG || ss.type() == T_DOUBLE ) |
|
45463a04ca27
6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents:
710
diff
changeset
|
2603 sig_bt[i++] = T_VOID; // Longs & doubles take 2 Java slots |
|
45463a04ca27
6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents:
710
diff
changeset
|
2604 } |
|
6790
2cb2f30450c7
7196262: JSR 292: java/lang/invoke/PrivateInvokeTest.java fails on solaris-sparc
twisti
parents:
6725
diff
changeset
|
2605 assert(i == total_args_passed, ""); |
|
742
45463a04ca27
6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents:
710
diff
changeset
|
2606 BasicType ret_type = ss.type(); |
|
45463a04ca27
6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents:
710
diff
changeset
|
2607 |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
2608 // Now get the compiled-Java layout as input (or output) arguments. |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
2609 // NOTE: Stubs for compiled entry points of method handle intrinsics |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
2610 // are just trampolines so the argument registers must be outgoing ones. |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
2611 const bool is_outgoing = method->is_method_handle_intrinsic(); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
2612 int comp_args_on_stack = SharedRuntime::java_calling_convention(sig_bt, regs, total_args_passed, is_outgoing); |
|
742
45463a04ca27
6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents:
710
diff
changeset
|
2613 |
|
45463a04ca27
6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents:
710
diff
changeset
|
2614 // Generate the compiled-to-native wrapper code |
|
45463a04ca27
6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents:
710
diff
changeset
|
2615 nm = SharedRuntime::generate_native_wrapper(&_masm, |
|
45463a04ca27
6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents:
710
diff
changeset
|
2616 method, |
|
2405
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2321
diff
changeset
|
2617 compile_id, |
|
6790
2cb2f30450c7
7196262: JSR 292: java/lang/invoke/PrivateInvokeTest.java fails on solaris-sparc
twisti
parents:
6725
diff
changeset
|
2618 sig_bt, |
|
2cb2f30450c7
7196262: JSR 292: java/lang/invoke/PrivateInvokeTest.java fails on solaris-sparc
twisti
parents:
6725
diff
changeset
|
2619 regs, |
|
742
45463a04ca27
6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents:
710
diff
changeset
|
2620 ret_type); |
| 0 | 2621 } |
| 2622 } | |
| 2623 | |
| 2624 // Must unlock before calling set_code | |
|
1728
a62d332029cf
6976372: # assert(_owner == Thread::current()) failed: invariant
never
parents:
1681
diff
changeset
|
2625 |
| 0 | 2626 // Install the generated code. |
| 2627 if (nm != NULL) { | |
|
2405
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2321
diff
changeset
|
2628 if (PrintCompilation) { |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2321
diff
changeset
|
2629 ttyLocker ttyl; |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2321
diff
changeset
|
2630 CompileTask::print_compilation(tty, nm, method->is_static() ? "(static)" : ""); |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2321
diff
changeset
|
2631 } |
| 0 | 2632 method->set_code(method, nm); |
| 2633 nm->post_compiled_method_load_event(); | |
| 2634 } else { | |
| 2635 // CodeCache is full, disable compilation | |
| 1202 | 2636 CompileBroker::handle_full_code_cache(); |
| 0 | 2637 } |
| 2638 return nm; | |
| 2639 } | |
| 2640 | |
|
4873
0382d2b469b2
7013347: allow crypto functions to be called inline to enhance performance
never
parents:
4872
diff
changeset
|
2641 JRT_ENTRY_NO_ASYNC(void, SharedRuntime::block_for_jni_critical(JavaThread* thread)) |
|
0382d2b469b2
7013347: allow crypto functions to be called inline to enhance performance
never
parents:
4872
diff
changeset
|
2642 assert(thread == JavaThread::current(), "must be"); |
|
0382d2b469b2
7013347: allow crypto functions to be called inline to enhance performance
never
parents:
4872
diff
changeset
|
2643 // The code is about to enter a JNI lazy critical native method and |
|
0382d2b469b2
7013347: allow crypto functions to be called inline to enhance performance
never
parents:
4872
diff
changeset
|
2644 // _needs_gc is true, so if this thread is already in a critical |
|
0382d2b469b2
7013347: allow crypto functions to be called inline to enhance performance
never
parents:
4872
diff
changeset
|
2645 // section then just return, otherwise this thread should block |
|
0382d2b469b2
7013347: allow crypto functions to be called inline to enhance performance
never
parents:
4872
diff
changeset
|
2646 // until needs_gc has been cleared. |
|
0382d2b469b2
7013347: allow crypto functions to be called inline to enhance performance
never
parents:
4872
diff
changeset
|
2647 if (thread->in_critical()) { |
|
0382d2b469b2
7013347: allow crypto functions to be called inline to enhance performance
never
parents:
4872
diff
changeset
|
2648 return; |
|
0382d2b469b2
7013347: allow crypto functions to be called inline to enhance performance
never
parents:
4872
diff
changeset
|
2649 } |
|
0382d2b469b2
7013347: allow crypto functions to be called inline to enhance performance
never
parents:
4872
diff
changeset
|
2650 // Lock and unlock a critical section to give the system a chance to block |
|
0382d2b469b2
7013347: allow crypto functions to be called inline to enhance performance
never
parents:
4872
diff
changeset
|
2651 GC_locker::lock_critical(thread); |
|
0382d2b469b2
7013347: allow crypto functions to be called inline to enhance performance
never
parents:
4872
diff
changeset
|
2652 GC_locker::unlock_critical(thread); |
|
0382d2b469b2
7013347: allow crypto functions to be called inline to enhance performance
never
parents:
4872
diff
changeset
|
2653 JRT_END |
|
0382d2b469b2
7013347: allow crypto functions to be called inline to enhance performance
never
parents:
4872
diff
changeset
|
2654 |
|
116
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2655 #ifdef HAVE_DTRACE_H |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2656 // Create a dtrace nmethod for this method. The wrapper converts the |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2657 // java compiled calling convention to the native convention, makes a dummy call |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2658 // (actually nops for the size of the call instruction, which become a trap if |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2659 // probe is enabled). The returns to the caller. Since this all looks like a |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2660 // leaf no thread transition is needed. |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2661 |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2662 nmethod *AdapterHandlerLibrary::create_dtrace_nmethod(methodHandle method) { |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2663 ResourceMark rm; |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2664 nmethod* nm = NULL; |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2665 |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2666 if (PrintCompilation) { |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2667 ttyLocker ttyl; |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2668 tty->print("--- n%s "); |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2669 method->print_short_name(tty); |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2670 if (method->is_static()) { |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2671 tty->print(" (static)"); |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2672 } |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2673 tty->cr(); |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2674 } |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2675 |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2676 { |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2677 // perform the work while holding the lock, but perform any printing |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2678 // outside the lock |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2679 MutexLocker mu(AdapterHandlerLibrary_lock); |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2680 // See if somebody beat us to it |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2681 nm = method->code(); |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2682 if (nm) { |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2683 return nm; |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2684 } |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2685 |
|
742
45463a04ca27
6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents:
710
diff
changeset
|
2686 ResourceMark rm; |
|
45463a04ca27
6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents:
710
diff
changeset
|
2687 |
|
45463a04ca27
6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents:
710
diff
changeset
|
2688 BufferBlob* buf = buffer_blob(); // the temporary code buffer in CodeCache |
|
45463a04ca27
6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents:
710
diff
changeset
|
2689 if (buf != NULL) { |
| 1748 | 2690 CodeBuffer buffer(buf); |
|
742
45463a04ca27
6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents:
710
diff
changeset
|
2691 // Need a few relocation entries |
|
45463a04ca27
6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents:
710
diff
changeset
|
2692 double locs_buf[20]; |
|
45463a04ca27
6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents:
710
diff
changeset
|
2693 buffer.insts()->initialize_shared_locs( |
|
116
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2694 (relocInfo*)locs_buf, sizeof(locs_buf) / sizeof(relocInfo)); |
|
742
45463a04ca27
6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents:
710
diff
changeset
|
2695 MacroAssembler _masm(&buffer); |
|
116
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2696 |
|
742
45463a04ca27
6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents:
710
diff
changeset
|
2697 // Generate the compiled-to-native wrapper code |
|
45463a04ca27
6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents:
710
diff
changeset
|
2698 nm = SharedRuntime::generate_dtrace_nmethod(&_masm, method); |
|
45463a04ca27
6834177: Running jsynprog on Solaris Nevada can cause JVM crash
kvn
parents:
710
diff
changeset
|
2699 } |
|
116
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2700 } |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2701 return nm; |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2702 } |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2703 |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2704 // the dtrace method needs to convert java lang string to utf8 string. |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2705 void SharedRuntime::get_utf(oopDesc* src, address dst) { |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2706 typeArrayOop jlsValue = java_lang_String::value(src); |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2707 int jlsOffset = java_lang_String::offset(src); |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2708 int jlsLen = java_lang_String::length(src); |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2709 jchar* jlsPos = (jlsLen == 0) ? NULL : |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2710 jlsValue->char_at_addr(jlsOffset); |
|
6831
d8ce2825b193
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
6796
diff
changeset
|
2711 assert(TypeArrayKlass::cast(jlsValue->klass())->element_type() == T_CHAR, "compressed string"); |
|
116
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2712 (void) UNICODE::as_utf8(jlsPos, jlsLen, (char *)dst, max_dtrace_string_size); |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2713 } |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2714 #endif // ndef HAVE_DTRACE_H |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
62
diff
changeset
|
2715 |
| 0 | 2716 // ------------------------------------------------------------------------- |
| 2717 // Java-Java calling convention | |
| 2718 // (what you use when Java calls Java) | |
| 2719 | |
| 2720 //------------------------------name_for_receiver---------------------------------- | |
| 2721 // For a given signature, return the VMReg for parameter 0. | |
| 2722 VMReg SharedRuntime::name_for_receiver() { | |
| 2723 VMRegPair regs; | |
| 2724 BasicType sig_bt = T_OBJECT; | |
| 2725 (void) java_calling_convention(&sig_bt, ®s, 1, true); | |
| 2726 // Return argument 0 register. In the LP64 build pointers | |
| 2727 // take 2 registers, but the VM wants only the 'main' name. | |
| 2728 return regs.first(); | |
| 2729 } | |
| 2730 | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2142
diff
changeset
|
2731 VMRegPair *SharedRuntime::find_callee_arguments(Symbol* sig, bool has_receiver, int* arg_size) { |
| 0 | 2732 // This method is returning a data structure allocating as a |
| 2733 // ResourceObject, so do not put any ResourceMarks in here. | |
| 2734 char *s = sig->as_C_string(); | |
| 2735 int len = (int)strlen(s); | |
| 2736 *s++; len--; // Skip opening paren | |
| 2737 char *t = s+len; | |
| 2738 while( *(--t) != ')' ) ; // Find close paren | |
| 2739 | |
| 2740 BasicType *sig_bt = NEW_RESOURCE_ARRAY( BasicType, 256 ); | |
| 2741 VMRegPair *regs = NEW_RESOURCE_ARRAY( VMRegPair, 256 ); | |
| 2742 int cnt = 0; | |
|
1138
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
1135
diff
changeset
|
2743 if (has_receiver) { |
| 0 | 2744 sig_bt[cnt++] = T_OBJECT; // Receiver is argument 0; not in signature |
| 2745 } | |
| 2746 | |
| 2747 while( s < t ) { | |
| 2748 switch( *s++ ) { // Switch on signature character | |
| 2749 case 'B': sig_bt[cnt++] = T_BYTE; break; | |
| 2750 case 'C': sig_bt[cnt++] = T_CHAR; break; | |
| 2751 case 'D': sig_bt[cnt++] = T_DOUBLE; sig_bt[cnt++] = T_VOID; break; | |
| 2752 case 'F': sig_bt[cnt++] = T_FLOAT; break; | |
| 2753 case 'I': sig_bt[cnt++] = T_INT; break; | |
| 2754 case 'J': sig_bt[cnt++] = T_LONG; sig_bt[cnt++] = T_VOID; break; | |
| 2755 case 'S': sig_bt[cnt++] = T_SHORT; break; | |
| 2756 case 'Z': sig_bt[cnt++] = T_BOOLEAN; break; | |
| 2757 case 'V': sig_bt[cnt++] = T_VOID; break; | |
| 2758 case 'L': // Oop | |
| 2759 while( *s++ != ';' ) ; // Skip signature | |
| 2760 sig_bt[cnt++] = T_OBJECT; | |
| 2761 break; | |
| 2762 case '[': { // Array | |
| 2763 do { // Skip optional size | |
| 2764 while( *s >= '0' && *s <= '9' ) s++; | |
| 2765 } while( *s++ == '[' ); // Nested arrays? | |
| 2766 // Skip element type | |
| 2767 if( s[-1] == 'L' ) | |
| 2768 while( *s++ != ';' ) ; // Skip signature | |
| 2769 sig_bt[cnt++] = T_ARRAY; | |
| 2770 break; | |
| 2771 } | |
| 2772 default : ShouldNotReachHere(); | |
| 2773 } | |
| 2774 } | |
| 2775 assert( cnt < 256, "grow table size" ); | |
| 2776 | |
| 2777 int comp_args_on_stack; | |
| 2778 comp_args_on_stack = java_calling_convention(sig_bt, regs, cnt, true); | |
| 2779 | |
| 2780 // the calling convention doesn't count out_preserve_stack_slots so | |
| 2781 // we must add that in to get "true" stack offsets. | |
| 2782 | |
| 2783 if (comp_args_on_stack) { | |
| 2784 for (int i = 0; i < cnt; i++) { | |
| 2785 VMReg reg1 = regs[i].first(); | |
| 2786 if( reg1->is_stack()) { | |
| 2787 // Yuck | |
| 2788 reg1 = reg1->bias(out_preserve_stack_slots()); | |
| 2789 } | |
| 2790 VMReg reg2 = regs[i].second(); | |
| 2791 if( reg2->is_stack()) { | |
| 2792 // Yuck | |
| 2793 reg2 = reg2->bias(out_preserve_stack_slots()); | |
| 2794 } | |
| 2795 regs[i].set_pair(reg2, reg1); | |
| 2796 } | |
| 2797 } | |
| 2798 | |
| 2799 // results | |
| 2800 *arg_size = cnt; | |
| 2801 return regs; | |
| 2802 } | |
| 2803 | |
| 2804 // OSR Migration Code | |
| 2805 // | |
| 2806 // This code is used convert interpreter frames into compiled frames. It is | |
| 2807 // called from very start of a compiled OSR nmethod. A temp array is | |
| 2808 // allocated to hold the interesting bits of the interpreter frame. All | |
| 2809 // active locks are inflated to allow them to move. The displaced headers and | |
| 2810 // active interpeter locals are copied into the temp buffer. Then we return | |
| 2811 // back to the compiled code. The compiled code then pops the current | |
| 2812 // interpreter frame off the stack and pushes a new compiled frame. Then it | |
| 2813 // copies the interpreter locals and displaced headers where it wants. | |
| 2814 // Finally it calls back to free the temp buffer. | |
| 2815 // | |
| 2816 // All of this is done NOT at any Safepoint, nor is any safepoint or GC allowed. | |
| 2817 | |
| 2818 JRT_LEAF(intptr_t*, SharedRuntime::OSR_migration_begin( JavaThread *thread) ) | |
| 2819 | |
| 2820 // | |
| 2821 // This code is dependent on the memory layout of the interpreter local | |
| 2822 // array and the monitors. On all of our platforms the layout is identical | |
| 2823 // so this code is shared. If some platform lays the their arrays out | |
| 2824 // differently then this code could move to platform specific code or | |
| 2825 // the code here could be modified to copy items one at a time using | |
| 2826 // frame accessor methods and be platform independent. | |
| 2827 | |
| 2828 frame fr = thread->last_frame(); | |
| 2829 assert( fr.is_interpreted_frame(), "" ); | |
| 2830 assert( fr.interpreter_frame_expression_stack_size()==0, "only handle empty stacks" ); | |
| 2831 | |
| 2832 // Figure out how many monitors are active. | |
| 2833 int active_monitor_count = 0; | |
| 2834 for( BasicObjectLock *kptr = fr.interpreter_frame_monitor_end(); | |
| 2835 kptr < fr.interpreter_frame_monitor_begin(); | |
| 2836 kptr = fr.next_monitor_in_interpreter_frame(kptr) ) { | |
| 2837 if( kptr->obj() != NULL ) active_monitor_count++; | |
| 2838 } | |
| 2839 | |
| 2840 // QQQ we could place number of active monitors in the array so that compiled code | |
| 2841 // could double check it. | |
| 2842 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2843 Method* moop = fr.interpreter_frame_method(); |
| 0 | 2844 int max_locals = moop->max_locals(); |
| 2845 // Allocate temp buffer, 1 word per local & 2 per active monitor | |
| 2846 int buf_size_words = max_locals + active_monitor_count*2; | |
| 6197 | 2847 intptr_t *buf = NEW_C_HEAP_ARRAY(intptr_t,buf_size_words, mtCode); |
| 0 | 2848 |
| 2849 // Copy the locals. Order is preserved so that loading of longs works. | |
| 2850 // Since there's no GC I can copy the oops blindly. | |
| 2851 assert( sizeof(HeapWord)==sizeof(intptr_t), "fix this code"); | |
| 1506 | 2852 Copy::disjoint_words((HeapWord*)fr.interpreter_frame_local_at(max_locals-1), |
| 0 | 2853 (HeapWord*)&buf[0], |
| 2854 max_locals); | |
| 2855 | |
| 2856 // Inflate locks. Copy the displaced headers. Be careful, there can be holes. | |
| 2857 int i = max_locals; | |
| 2858 for( BasicObjectLock *kptr2 = fr.interpreter_frame_monitor_end(); | |
| 2859 kptr2 < fr.interpreter_frame_monitor_begin(); | |
| 2860 kptr2 = fr.next_monitor_in_interpreter_frame(kptr2) ) { | |
| 2861 if( kptr2->obj() != NULL) { // Avoid 'holes' in the monitor array | |
| 2862 BasicLock *lock = kptr2->lock(); | |
| 2863 // Inflate so the displaced header becomes position-independent | |
| 2864 if (lock->displaced_header()->is_unlocked()) | |
| 2865 ObjectSynchronizer::inflate_helper(kptr2->obj()); | |
| 2866 // Now the displaced header is free to move | |
| 2867 buf[i++] = (intptr_t)lock->displaced_header(); | |
| 2868 buf[i++] = (intptr_t)kptr2->obj(); | |
| 2869 } | |
| 2870 } | |
| 2871 assert( i - max_locals == active_monitor_count*2, "found the expected number of monitors" ); | |
| 2872 | |
| 2873 return buf; | |
| 2874 JRT_END | |
| 2875 | |
| 2876 JRT_LEAF(void, SharedRuntime::OSR_migration_end( intptr_t* buf) ) | |
| 6197 | 2877 FREE_C_HEAP_ARRAY(intptr_t,buf, mtCode); |
| 0 | 2878 JRT_END |
| 2879 | |
| 2880 bool AdapterHandlerLibrary::contains(CodeBlob* b) { | |
|
1187
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2881 AdapterHandlerTableIterator iter(_adapters); |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2882 while (iter.has_next()) { |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2883 AdapterHandlerEntry* a = iter.next(); |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2884 if ( b == CodeCache::find_blob(a->get_i2c_entry()) ) return true; |
| 0 | 2885 } |
| 2886 return false; | |
| 2887 } | |
| 2888 | |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
2889 void AdapterHandlerLibrary::print_handler_on(outputStream* st, CodeBlob* b) { |
|
1187
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2890 AdapterHandlerTableIterator iter(_adapters); |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2891 while (iter.has_next()) { |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2892 AdapterHandlerEntry* a = iter.next(); |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
2893 if (b == CodeCache::find_blob(a->get_i2c_entry())) { |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
2894 st->print("Adapter for signature: "); |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
2895 a->print_adapter_on(tty); |
| 0 | 2896 return; |
| 2897 } | |
| 2898 } | |
| 2899 assert(false, "Should have found handler"); | |
| 2900 } | |
|
1187
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2901 |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
2902 void AdapterHandlerEntry::print_adapter_on(outputStream* st) const { |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
2903 st->print_cr("AHE@" INTPTR_FORMAT ": %s i2c: " INTPTR_FORMAT " c2i: " INTPTR_FORMAT " c2iUV: " INTPTR_FORMAT, |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
2904 (intptr_t) this, fingerprint()->as_string(), |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
2905 get_i2c_entry(), get_c2i_entry(), get_c2i_unverified_entry()); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
2906 |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
2907 } |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
2908 |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
2909 #ifndef PRODUCT |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
2910 |
|
1187
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2911 void AdapterHandlerLibrary::print_statistics() { |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2912 _adapters->print_statistics(); |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2913 } |
|
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1142
diff
changeset
|
2914 |
| 0 | 2915 #endif /* PRODUCT */ |