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

annotate src/share/vm/runtime/sharedRuntime.cpp @ 13212:eb03a7335eb0

Use fixed instead of virtual register for target in far foreign call, since the register allocator does not support virtual registers to be used at call sites.

author	Christian Wimmer <christian.wimmer@oracle.com>
date	Mon, 02 Dec 2013 14:20:32 -0800
parents	cefad50507d8
children	02f27ecb4f3a

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

Mercurial > hg > truffle

annotate src/share/vm/runtime/sharedRuntime.cpp @ 13212:eb03a7335eb0