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

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

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

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

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

Mercurial > hg > truffle

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