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

annotate src/share/vm/runtime/deoptimization.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	b9a918201d47
children	314814fa0223

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: 4777 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: 1255 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1255 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: 1255 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: 1905 diff changeset	25 #include "precompiled.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1905 diff changeset	26 #include "classfile/systemDictionary.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1905 diff changeset	27 #include "code/debugInfoRec.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1905 diff changeset	28 #include "code/nmethod.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1905 diff changeset	29 #include "code/pcDesc.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1905 diff changeset	30 #include "code/scopeDesc.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1905 diff changeset	31 #include "interpreter/bytecode.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1905 diff changeset	32 #include "interpreter/interpreter.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1905 diff changeset	33 #include "interpreter/oopMapCache.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1905 diff changeset	34 #include "memory/allocation.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1905 diff changeset	35 #include "memory/oopFactory.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1905 diff changeset	36 #include "memory/resourceArea.hpp"
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	37 #include "oops/method.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1905 diff changeset	38 #include "oops/oop.inline.hpp"
6948 e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 6428 6940 diff changeset	39 #include "oops/fieldStreams.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1905 diff changeset	40 #include "prims/jvmtiThreadState.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1905 diff changeset	41 #include "runtime/biasedLocking.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1905 diff changeset	42 #include "runtime/compilationPolicy.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1905 diff changeset	43 #include "runtime/deoptimization.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1905 diff changeset	44 #include "runtime/interfaceSupport.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1905 diff changeset	45 #include "runtime/sharedRuntime.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1905 diff changeset	46 #include "runtime/signature.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1905 diff changeset	47 #include "runtime/stubRoutines.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1905 diff changeset	48 #include "runtime/thread.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1905 diff changeset	49 #include "runtime/vframe.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1905 diff changeset	50 #include "runtime/vframeArray.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1905 diff changeset	51 #include "runtime/vframe_hp.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1905 diff changeset	52 #include "utilities/events.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1905 diff changeset	53 #include "utilities/xmlstream.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1905 diff changeset	54 #ifdef TARGET_ARCH_x86
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1905 diff changeset	55 # include "vmreg_x86.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1905 diff changeset	56 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1905 diff changeset	57 #ifdef TARGET_ARCH_sparc
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1905 diff changeset	58 # include "vmreg_sparc.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1905 diff changeset	59 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1905 diff changeset	60 #ifdef TARGET_ARCH_zero
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1905 diff changeset	61 # include "vmreg_zero.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1905 diff changeset	62 #endif
2192 b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	63 #ifdef TARGET_ARCH_arm
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	64 # include "vmreg_arm.inline.hpp"
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	65 #endif
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	66 #ifdef TARGET_ARCH_ppc
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	67 # include "vmreg_ppc.inline.hpp"
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	68 #endif
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1905 diff changeset	69 #ifdef COMPILER2
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1905 diff changeset	70 #ifdef TARGET_ARCH_MODEL_x86_32
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1905 diff changeset	71 # include "adfiles/ad_x86_32.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1905 diff changeset	72 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1905 diff changeset	73 #ifdef TARGET_ARCH_MODEL_x86_64
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1905 diff changeset	74 # include "adfiles/ad_x86_64.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1905 diff changeset	75 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1905 diff changeset	76 #ifdef TARGET_ARCH_MODEL_sparc
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1905 diff changeset	77 # include "adfiles/ad_sparc.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1905 diff changeset	78 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1905 diff changeset	79 #ifdef TARGET_ARCH_MODEL_zero
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1905 diff changeset	80 # include "adfiles/ad_zero.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1905 diff changeset	81 #endif
2192 b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	82 #ifdef TARGET_ARCH_MODEL_arm
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	83 # include "adfiles/ad_arm.hpp"
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	84 #endif
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	85 #ifdef TARGET_ARCH_MODEL_ppc
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	86 # include "adfiles/ad_ppc.hpp"
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	87 #endif
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1905 diff changeset	88 #endif
0 a61af66fc99e Initial load duke parents: diff changeset	89
5129 51111665eda6 Support for recording a leaf graph id for each deoptimization point in the debug info. Lukas Stadler <lukas.stadler@jku.at> parents: 5038 diff changeset	90 #ifdef GRAAL
51111665eda6 Support for recording a leaf graph id for each deoptimization point in the debug info. Lukas Stadler <lukas.stadler@jku.at> parents: 5038 diff changeset	91 #include "graal/graalCompiler.hpp"
51111665eda6 Support for recording a leaf graph id for each deoptimization point in the debug info. Lukas Stadler <lukas.stadler@jku.at> parents: 5038 diff changeset	92 #endif
51111665eda6 Support for recording a leaf graph id for each deoptimization point in the debug info. Lukas Stadler <lukas.stadler@jku.at> parents: 5038 diff changeset	93
51111665eda6 Support for recording a leaf graph id for each deoptimization point in the debug info. Lukas Stadler <lukas.stadler@jku.at> parents: 5038 diff changeset	94
0 a61af66fc99e Initial load duke parents: diff changeset	95 bool DeoptimizationMarker::_is_active = false;
a61af66fc99e Initial load duke parents: diff changeset	96
a61af66fc99e Initial load duke parents: diff changeset	97 Deoptimization::UnrollBlock::UnrollBlock(int size_of_deoptimized_frame,
a61af66fc99e Initial load duke parents: diff changeset	98 int caller_adjustment,
3369 3d2ab563047a 7043461: VM crashes in void LinkResolver::runtime_resolve_virtual_method never parents: 3346 diff changeset	99 int caller_actual_parameters,
0 a61af66fc99e Initial load duke parents: diff changeset	100 int number_of_frames,
a61af66fc99e Initial load duke parents: diff changeset	101 intptr_t* frame_sizes,
a61af66fc99e Initial load duke parents: diff changeset	102 address* frame_pcs,
a61af66fc99e Initial load duke parents: diff changeset	103 BasicType return_type) {
a61af66fc99e Initial load duke parents: diff changeset	104 _size_of_deoptimized_frame = size_of_deoptimized_frame;
a61af66fc99e Initial load duke parents: diff changeset	105 _caller_adjustment = caller_adjustment;
3369 3d2ab563047a 7043461: VM crashes in void LinkResolver::runtime_resolve_virtual_method never parents: 3346 diff changeset	106 _caller_actual_parameters = caller_actual_parameters;
0 a61af66fc99e Initial load duke parents: diff changeset	107 _number_of_frames = number_of_frames;
a61af66fc99e Initial load duke parents: diff changeset	108 _frame_sizes = frame_sizes;
a61af66fc99e Initial load duke parents: diff changeset	109 _frame_pcs = frame_pcs;
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 4872 diff changeset	110 _register_block = NEW_C_HEAP_ARRAY(intptr_t, RegisterMap::reg_count * 2, mtCompiler);
0 a61af66fc99e Initial load duke parents: diff changeset	111 _return_type = return_type;
3931 5432047c7db7 7087445: Improve platform independence of JSR292 shared code bdelsart parents: 3369 diff changeset	112 _initial_info = 0;
0 a61af66fc99e Initial load duke parents: diff changeset	113 // PD (x86 only)
a61af66fc99e Initial load duke parents: diff changeset	114 _counter_temp = 0;
a61af66fc99e Initial load duke parents: diff changeset	115 _unpack_kind = 0;
a61af66fc99e Initial load duke parents: diff changeset	116 _sender_sp_temp = 0;
a61af66fc99e Initial load duke parents: diff changeset	117
a61af66fc99e Initial load duke parents: diff changeset	118 _total_frame_sizes = size_of_frames();
a61af66fc99e Initial load duke parents: diff changeset	119 }
a61af66fc99e Initial load duke parents: diff changeset	120
a61af66fc99e Initial load duke parents: diff changeset	121
a61af66fc99e Initial load duke parents: diff changeset	122 Deoptimization::UnrollBlock::~UnrollBlock() {
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 4872 diff changeset	123 FREE_C_HEAP_ARRAY(intptr_t, _frame_sizes, mtCompiler);
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 4872 diff changeset	124 FREE_C_HEAP_ARRAY(intptr_t, _frame_pcs, mtCompiler);
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 4872 diff changeset	125 FREE_C_HEAP_ARRAY(intptr_t, _register_block, mtCompiler);
0 a61af66fc99e Initial load duke parents: diff changeset	126 }
a61af66fc99e Initial load duke parents: diff changeset	127
a61af66fc99e Initial load duke parents: diff changeset	128
a61af66fc99e Initial load duke parents: diff changeset	129 intptr_t* Deoptimization::UnrollBlock::value_addr_at(int register_number) const {
a61af66fc99e Initial load duke parents: diff changeset	130 assert(register_number < RegisterMap::reg_count, "checking register number");
a61af66fc99e Initial load duke parents: diff changeset	131 return &_register_block[register_number * 2];
a61af66fc99e Initial load duke parents: diff changeset	132 }
a61af66fc99e Initial load duke parents: diff changeset	133
a61af66fc99e Initial load duke parents: diff changeset	134
a61af66fc99e Initial load duke parents: diff changeset	135
a61af66fc99e Initial load duke parents: diff changeset	136 int Deoptimization::UnrollBlock::size_of_frames() const {
a61af66fc99e Initial load duke parents: diff changeset	137 // Acount first for the adjustment of the initial frame
a61af66fc99e Initial load duke parents: diff changeset	138 int result = _caller_adjustment;
a61af66fc99e Initial load duke parents: diff changeset	139 for (int index = 0; index < number_of_frames(); index++) {
a61af66fc99e Initial load duke parents: diff changeset	140 result += frame_sizes()[index];
a61af66fc99e Initial load duke parents: diff changeset	141 }
a61af66fc99e Initial load duke parents: diff changeset	142 return result;
a61af66fc99e Initial load duke parents: diff changeset	143 }
a61af66fc99e Initial load duke parents: diff changeset	144
a61af66fc99e Initial load duke parents: diff changeset	145
a61af66fc99e Initial load duke parents: diff changeset	146 void Deoptimization::UnrollBlock::print() {
a61af66fc99e Initial load duke parents: diff changeset	147 ttyLocker ttyl;
a61af66fc99e Initial load duke parents: diff changeset	148 tty->print_cr("UnrollBlock");
a61af66fc99e Initial load duke parents: diff changeset	149 tty->print_cr(" size_of_deoptimized_frame = %d", _size_of_deoptimized_frame);
a61af66fc99e Initial load duke parents: diff changeset	150 tty->print( " frame_sizes: ");
a61af66fc99e Initial load duke parents: diff changeset	151 for (int index = 0; index < number_of_frames(); index++) {
a61af66fc99e Initial load duke parents: diff changeset	152 tty->print("%d ", frame_sizes()[index]);
a61af66fc99e Initial load duke parents: diff changeset	153 }
a61af66fc99e Initial load duke parents: diff changeset	154 tty->cr();
a61af66fc99e Initial load duke parents: diff changeset	155 }
a61af66fc99e Initial load duke parents: diff changeset	156
a61af66fc99e Initial load duke parents: diff changeset	157
a61af66fc99e Initial load duke parents: diff changeset	158 // In order to make fetch_unroll_info work properly with escape
a61af66fc99e Initial load duke parents: diff changeset	159 // analysis, The method was changed from JRT_LEAF to JRT_BLOCK_ENTRY and
a61af66fc99e Initial load duke parents: diff changeset	160 // ResetNoHandleMark and HandleMark were removed from it. The actual reallocation
a61af66fc99e Initial load duke parents: diff changeset	161 // of previously eliminated objects occurs in realloc_objects, which is
a61af66fc99e Initial load duke parents: diff changeset	162 // called from the method fetch_unroll_info_helper below.
a61af66fc99e Initial load duke parents: diff changeset	163 JRT_BLOCK_ENTRY(Deoptimization::UnrollBlock, Deoptimization::fetch_unroll_info(JavaThread thread))
a61af66fc99e Initial load duke parents: diff changeset	164 // It is actually ok to allocate handles in a leaf method. It causes no safepoints,
a61af66fc99e Initial load duke parents: diff changeset	165 // but makes the entry a little slower. There is however a little dance we have to
a61af66fc99e Initial load duke parents: diff changeset	166 // do in debug mode to get around the NoHandleMark code in the JRT_LEAF macro
a61af66fc99e Initial load duke parents: diff changeset	167
a61af66fc99e Initial load duke parents: diff changeset	168 // fetch_unroll_info() is called at the beginning of the deoptimization
a61af66fc99e Initial load duke parents: diff changeset	169 // handler. Note this fact before we start generating temporary frames
a61af66fc99e Initial load duke parents: diff changeset	170 // that can confuse an asynchronous stack walker. This counter is
a61af66fc99e Initial load duke parents: diff changeset	171 // decremented at the end of unpack_frames().
4674 e1c053324210 changed TraceDeoptimization output Christian Haeubl <christian.haeubl@oracle.com> parents: 4668 diff changeset	172 if (TraceDeoptimization) {
5038 1b907994bf2d fixed deoptimization output Christian Haeubl <christian.haeubl@oracle.com> parents: 4978 diff changeset	173 tty->print_cr("Deoptimizing thread " INTPTR_FORMAT, thread);
4674 e1c053324210 changed TraceDeoptimization output Christian Haeubl <christian.haeubl@oracle.com> parents: 4668 diff changeset	174 }
0 a61af66fc99e Initial load duke parents: diff changeset	175 thread->inc_in_deopt_handler();
a61af66fc99e Initial load duke parents: diff changeset	176
a61af66fc99e Initial load duke parents: diff changeset	177 return fetch_unroll_info_helper(thread);
a61af66fc99e Initial load duke parents: diff changeset	178 JRT_END
a61af66fc99e Initial load duke parents: diff changeset	179
a61af66fc99e Initial load duke parents: diff changeset	180
a61af66fc99e Initial load duke parents: diff changeset	181 // This is factored, since it is both called from a JRT_LEAF (deoptimization) and a JRT_ENTRY (uncommon_trap)
a61af66fc99e Initial load duke parents: diff changeset	182 Deoptimization::UnrollBlock* Deoptimization::fetch_unroll_info_helper(JavaThread* thread) {
a61af66fc99e Initial load duke parents: diff changeset	183
a61af66fc99e Initial load duke parents: diff changeset	184 // Note: there is a safepoint safety issue here. No matter whether we enter
a61af66fc99e Initial load duke parents: diff changeset	185 // via vanilla deopt or uncommon trap we MUST NOT stop at a safepoint once
a61af66fc99e Initial load duke parents: diff changeset	186 // the vframeArray is created.
a61af66fc99e Initial load duke parents: diff changeset	187 //
a61af66fc99e Initial load duke parents: diff changeset	188
a61af66fc99e Initial load duke parents: diff changeset	189 // Allocate our special deoptimization ResourceMark
a61af66fc99e Initial load duke parents: diff changeset	190 DeoptResourceMark* dmark = new DeoptResourceMark(thread);
a61af66fc99e Initial load duke parents: diff changeset	191 assert(thread->deopt_mark() == NULL, "Pending deopt!");
a61af66fc99e Initial load duke parents: diff changeset	192 thread->set_deopt_mark(dmark);
a61af66fc99e Initial load duke parents: diff changeset	193
a61af66fc99e Initial load duke parents: diff changeset	194 frame stub_frame = thread->last_frame(); // Makes stack walkable as side effect
a61af66fc99e Initial load duke parents: diff changeset	195 RegisterMap map(thread, true);
a61af66fc99e Initial load duke parents: diff changeset	196 RegisterMap dummy_map(thread, false);
a61af66fc99e Initial load duke parents: diff changeset	197 // Now get the deoptee with a valid map
a61af66fc99e Initial load duke parents: diff changeset	198 frame deoptee = stub_frame.sender(&map);
1814 fd5d4527cdf5 6986270: guarantee(bcp != Bytecodes::_monitorenter \|\| exec_mode != Deoptimization::Unpack_exception) fails iveresov* parents: 1783 diff changeset	199 // Set the deoptee nmethod
fd5d4527cdf5 6986270: guarantee(bcp != Bytecodes::_monitorenter \|\| exec_mode != Deoptimization::Unpack_exception) fails iveresov* parents: 1783 diff changeset	200 assert(thread->deopt_nmethod() == NULL, "Pending deopt!");
fd5d4527cdf5 6986270: guarantee(bcp != Bytecodes::_monitorenter \|\| exec_mode != Deoptimization::Unpack_exception) fails iveresov* parents: 1783 diff changeset	201 thread->set_deopt_nmethod(deoptee.cb()->as_nmethod_or_null());
0 a61af66fc99e Initial load duke parents: diff changeset	202
3336 2e038ad0c1d0 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp never parents: 2338 diff changeset	203 if (VerifyStack) {
2e038ad0c1d0 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp never parents: 2338 diff changeset	204 thread->validate_frame_layout();
2e038ad0c1d0 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp never parents: 2338 diff changeset	205 }
2e038ad0c1d0 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp never parents: 2338 diff changeset	206
0 a61af66fc99e Initial load duke parents: diff changeset	207 // Create a growable array of VFrames where each VFrame represents an inlined
a61af66fc99e Initial load duke parents: diff changeset	208 // Java frame. This storage is allocated with the usual system arena.
a61af66fc99e Initial load duke parents: diff changeset	209 assert(deoptee.is_compiled_frame(), "Wrong frame type");
5129 51111665eda6 Support for recording a leaf graph id for each deoptimization point in the debug info. Lukas Stadler <lukas.stadler@jku.at> parents: 5038 diff changeset	210
51111665eda6 Support for recording a leaf graph id for each deoptimization point in the debug info. Lukas Stadler <lukas.stadler@jku.at> parents: 5038 diff changeset	211 #ifdef GRAAL
7660 0b646334c5f7 keep track of leafGraphIds only at the StructuredGraph level (see GRAAL-60) Lukas Stadler <lukas.stadler@jku.at> parents: 7232 diff changeset	212 nmethod* nm = (nmethod*) deoptee.cb();
0b646334c5f7 keep track of leafGraphIds only at the StructuredGraph level (see GRAAL-60) Lukas Stadler <lukas.stadler@jku.at> parents: 7232 diff changeset	213 GraalCompiler* compiler = (GraalCompiler*) nm->compiler();
0b646334c5f7 keep track of leafGraphIds only at the StructuredGraph level (see GRAAL-60) Lukas Stadler <lukas.stadler@jku.at> parents: 7232 diff changeset	214 for (jlong* p = nm->leaf_graph_ids_begin(); p != nm->leaf_graph_ids_end(); p++) {
8609 9f9aaa65294e fixed -XX:+PrintDeoptimizationDetails in debug/fastdebug build Christian Haeubl <haeubl@ssw.jku.at> parents: 8328 diff changeset	215 compiler->deopt_leaf_graph(*p);
9f9aaa65294e fixed -XX:+PrintDeoptimizationDetails in debug/fastdebug build Christian Haeubl <haeubl@ssw.jku.at> parents: 8328 diff changeset	216 }
9f9aaa65294e fixed -XX:+PrintDeoptimizationDetails in debug/fastdebug build Christian Haeubl <haeubl@ssw.jku.at> parents: 8328 diff changeset	217 if (PrintDeoptimizationDetails) {
9f9aaa65294e fixed -XX:+PrintDeoptimizationDetails in debug/fastdebug build Christian Haeubl <haeubl@ssw.jku.at> parents: 8328 diff changeset	218 tty->print("leaf graph ids: ");
9f9aaa65294e fixed -XX:+PrintDeoptimizationDetails in debug/fastdebug build Christian Haeubl <haeubl@ssw.jku.at> parents: 8328 diff changeset	219 for (jlong* p = nm->leaf_graph_ids_begin(); p != nm->leaf_graph_ids_end(); p++) {
9f9aaa65294e fixed -XX:+PrintDeoptimizationDetails in debug/fastdebug build Christian Haeubl <haeubl@ssw.jku.at> parents: 8328 diff changeset	220 tty->print("%d ", *p);
5129 51111665eda6 Support for recording a leaf graph id for each deoptimization point in the debug info. Lukas Stadler <lukas.stadler@jku.at> parents: 5038 diff changeset	221 }
8609 9f9aaa65294e fixed -XX:+PrintDeoptimizationDetails in debug/fastdebug build Christian Haeubl <haeubl@ssw.jku.at> parents: 8328 diff changeset	222 tty->cr();
5129 51111665eda6 Support for recording a leaf graph id for each deoptimization point in the debug info. Lukas Stadler <lukas.stadler@jku.at> parents: 5038 diff changeset	223 }
51111665eda6 Support for recording a leaf graph id for each deoptimization point in the debug info. Lukas Stadler <lukas.stadler@jku.at> parents: 5038 diff changeset	224 #endif
51111665eda6 Support for recording a leaf graph id for each deoptimization point in the debug info. Lukas Stadler <lukas.stadler@jku.at> parents: 5038 diff changeset	225
0 a61af66fc99e Initial load duke parents: diff changeset	226 GrowableArray<compiledVFrame> chunk = new GrowableArray<compiledVFrame*>(10);
a61af66fc99e Initial load duke parents: diff changeset	227 vframe* vf = vframe::new_vframe(&deoptee, &map, thread);
a61af66fc99e Initial load duke parents: diff changeset	228 while (!vf->is_top()) {
a61af66fc99e Initial load duke parents: diff changeset	229 assert(vf->is_compiled_frame(), "Wrong frame type");
a61af66fc99e Initial load duke parents: diff changeset	230 chunk->push(compiledVFrame::cast(vf));
a61af66fc99e Initial load duke parents: diff changeset	231 vf = vf->sender();
a61af66fc99e Initial load duke parents: diff changeset	232 }
a61af66fc99e Initial load duke parents: diff changeset	233 assert(vf->is_compiled_frame(), "Wrong frame type");
a61af66fc99e Initial load duke parents: diff changeset	234 chunk->push(compiledVFrame::cast(vf));
a61af66fc99e Initial load duke parents: diff changeset	235
4674 e1c053324210 changed TraceDeoptimization output Christian Haeubl <christian.haeubl@oracle.com> parents: 4668 diff changeset	236 #if defined(COMPILER2) \|\| defined(GRAAL)
0 a61af66fc99e Initial load duke parents: diff changeset	237 // Reallocate the non-escaping objects and restore their fields. Then
a61af66fc99e Initial load duke parents: diff changeset	238 // relock objects if synchronization on them was eliminated.
4674 e1c053324210 changed TraceDeoptimization output Christian Haeubl <christian.haeubl@oracle.com> parents: 4668 diff changeset	239 #ifdef COMPILER2
4777 e9a5e0a812c8 7125896: Eliminate nested locks kvn parents: 4055 diff changeset	240 if (DoEscapeAnalysis \|\| EliminateNestedLocks) {
44 52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	241 if (EliminateAllocations) {
4674 e1c053324210 changed TraceDeoptimization output Christian Haeubl <christian.haeubl@oracle.com> parents: 4668 diff changeset	242 #endif // COMPILER2
83 d3cd40645d0d 6681646: Relocking of a scalar replaced object during deoptimization is broken kvn parents: 44 diff changeset	243 assert (chunk->at(0)->scope() != NULL,"expect only compiled java frames");
44 52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	244 GrowableArray<ScopeValue> objects = chunk->at(0)->scope()->objects();
1253 f70b0d9ab095 6910618: C2: Error: assert(d->is_oop(),"JVM_ArrayCopy: dst not an oop") kvn parents: 1206 diff changeset	245
f70b0d9ab095 6910618: C2: Error: assert(d->is_oop(),"JVM_ArrayCopy: dst not an oop") kvn parents: 1206 diff changeset	246 // The flag return_oop() indicates call sites which return oop
f70b0d9ab095 6910618: C2: Error: assert(d->is_oop(),"JVM_ArrayCopy: dst not an oop") kvn parents: 1206 diff changeset	247 // in compiled code. Such sites include java method calls,
f70b0d9ab095 6910618: C2: Error: assert(d->is_oop(),"JVM_ArrayCopy: dst not an oop") kvn parents: 1206 diff changeset	248 // runtime calls (for example, used to allocate new objects/arrays
f70b0d9ab095 6910618: C2: Error: assert(d->is_oop(),"JVM_ArrayCopy: dst not an oop") kvn parents: 1206 diff changeset	249 // on slow code path) and any other calls generated in compiled code.
f70b0d9ab095 6910618: C2: Error: assert(d->is_oop(),"JVM_ArrayCopy: dst not an oop") kvn parents: 1206 diff changeset	250 // It is not guaranteed that we can get such information here only
f70b0d9ab095 6910618: C2: Error: assert(d->is_oop(),"JVM_ArrayCopy: dst not an oop") kvn parents: 1206 diff changeset	251 // by analyzing bytecode in deoptimized frames. This is why this flag
f70b0d9ab095 6910618: C2: Error: assert(d->is_oop(),"JVM_ArrayCopy: dst not an oop") kvn parents: 1206 diff changeset	252 // is set during method compilation (see Compile::Process_OopMap_Node()).
f70b0d9ab095 6910618: C2: Error: assert(d->is_oop(),"JVM_ArrayCopy: dst not an oop") kvn parents: 1206 diff changeset	253 bool save_oop_result = chunk->at(0)->scope()->return_oop();
f70b0d9ab095 6910618: C2: Error: assert(d->is_oop(),"JVM_ArrayCopy: dst not an oop") kvn parents: 1206 diff changeset	254 Handle return_value;
f70b0d9ab095 6910618: C2: Error: assert(d->is_oop(),"JVM_ArrayCopy: dst not an oop") kvn parents: 1206 diff changeset	255 if (save_oop_result) {
f70b0d9ab095 6910618: C2: Error: assert(d->is_oop(),"JVM_ArrayCopy: dst not an oop") kvn parents: 1206 diff changeset	256 // Reallocation may trigger GC. If deoptimization happened on return from
f70b0d9ab095 6910618: C2: Error: assert(d->is_oop(),"JVM_ArrayCopy: dst not an oop") kvn parents: 1206 diff changeset	257 // call which returns oop we need to save it since it is not in oopmap.
f70b0d9ab095 6910618: C2: Error: assert(d->is_oop(),"JVM_ArrayCopy: dst not an oop") kvn parents: 1206 diff changeset	258 oop result = deoptee.saved_oop_result(&map);
f70b0d9ab095 6910618: C2: Error: assert(d->is_oop(),"JVM_ArrayCopy: dst not an oop") kvn parents: 1206 diff changeset	259 assert(result == NULL \|\| result->is_oop(), "must be oop");
f70b0d9ab095 6910618: C2: Error: assert(d->is_oop(),"JVM_ArrayCopy: dst not an oop") kvn parents: 1206 diff changeset	260 return_value = Handle(thread, result);
f70b0d9ab095 6910618: C2: Error: assert(d->is_oop(),"JVM_ArrayCopy: dst not an oop") kvn parents: 1206 diff changeset	261 assert(Universe::heap()->is_in_or_null(result), "must be heap pointer");
f70b0d9ab095 6910618: C2: Error: assert(d->is_oop(),"JVM_ArrayCopy: dst not an oop") kvn parents: 1206 diff changeset	262 if (TraceDeoptimization) {
6843 c3e799c37717 7177003: C1: LogCompilation support vlivanov parents: 6725 diff changeset	263 ttyLocker ttyl;
1253 f70b0d9ab095 6910618: C2: Error: assert(d->is_oop(),"JVM_ArrayCopy: dst not an oop") kvn parents: 1206 diff changeset	264 tty->print_cr("SAVED OOP RESULT " INTPTR_FORMAT " in thread " INTPTR_FORMAT, result, thread);
f70b0d9ab095 6910618: C2: Error: assert(d->is_oop(),"JVM_ArrayCopy: dst not an oop") kvn parents: 1206 diff changeset	265 }
f70b0d9ab095 6910618: C2: Error: assert(d->is_oop(),"JVM_ArrayCopy: dst not an oop") kvn parents: 1206 diff changeset	266 }
44 52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	267 bool reallocated = false;
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	268 if (objects != NULL) {
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	269 JRT_BLOCK
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	270 reallocated = realloc_objects(thread, &deoptee, objects, THREAD);
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	271 JRT_END
0 a61af66fc99e Initial load duke parents: diff changeset	272 }
44 52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	273 if (reallocated) {
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	274 reassign_fields(&deoptee, &map, objects);
0 a61af66fc99e Initial load duke parents: diff changeset	275 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	276 if (TraceDeoptimization) {
a61af66fc99e Initial load duke parents: diff changeset	277 ttyLocker ttyl;
44 52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	278 tty->print_cr("REALLOC OBJECTS in thread " INTPTR_FORMAT, thread);
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	279 print_objects(objects);
1253 f70b0d9ab095 6910618: C2: Error: assert(d->is_oop(),"JVM_ArrayCopy: dst not an oop") kvn parents: 1206 diff changeset	280 }
f70b0d9ab095 6910618: C2: Error: assert(d->is_oop(),"JVM_ArrayCopy: dst not an oop") kvn parents: 1206 diff changeset	281 #endif
44 52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	282 }
1253 f70b0d9ab095 6910618: C2: Error: assert(d->is_oop(),"JVM_ArrayCopy: dst not an oop") kvn parents: 1206 diff changeset	283 if (save_oop_result) {
f70b0d9ab095 6910618: C2: Error: assert(d->is_oop(),"JVM_ArrayCopy: dst not an oop") kvn parents: 1206 diff changeset	284 // Restore result.
f70b0d9ab095 6910618: C2: Error: assert(d->is_oop(),"JVM_ArrayCopy: dst not an oop") kvn parents: 1206 diff changeset	285 deoptee.set_saved_oop_result(&map, return_value());
44 52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	286 }
4674 e1c053324210 changed TraceDeoptimization output Christian Haeubl <christian.haeubl@oracle.com> parents: 4668 diff changeset	287 #ifdef COMPILER2
44 52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	288 }
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	289 if (EliminateLocks) {
4674 e1c053324210 changed TraceDeoptimization output Christian Haeubl <christian.haeubl@oracle.com> parents: 4668 diff changeset	290 #endif // COMPILER2
83 d3cd40645d0d 6681646: Relocking of a scalar replaced object during deoptimization is broken kvn parents: 44 diff changeset	291 #ifndef PRODUCT
d3cd40645d0d 6681646: Relocking of a scalar replaced object during deoptimization is broken kvn parents: 44 diff changeset	292 bool first = true;
d3cd40645d0d 6681646: Relocking of a scalar replaced object during deoptimization is broken kvn parents: 44 diff changeset	293 #endif
44 52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	294 for (int i = 0; i < chunk->length(); i++) {
83 d3cd40645d0d 6681646: Relocking of a scalar replaced object during deoptimization is broken kvn parents: 44 diff changeset	295 compiledVFrame* cvf = chunk->at(i);
d3cd40645d0d 6681646: Relocking of a scalar replaced object during deoptimization is broken kvn parents: 44 diff changeset	296 assert (cvf->scope() != NULL,"expect only compiled java frames");
d3cd40645d0d 6681646: Relocking of a scalar replaced object during deoptimization is broken kvn parents: 44 diff changeset	297 GrowableArray<MonitorInfo> monitors = cvf->monitors();
d3cd40645d0d 6681646: Relocking of a scalar replaced object during deoptimization is broken kvn parents: 44 diff changeset	298 if (monitors->is_nonempty()) {
d3cd40645d0d 6681646: Relocking of a scalar replaced object during deoptimization is broken kvn parents: 44 diff changeset	299 relock_objects(monitors, thread);
44 52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	300 #ifndef PRODUCT
4668 3dbcd1013cc8 added flag PrintDeoptimizationDetails Christian Haeubl <christian.haeubl@oracle.com> parents: 4661 diff changeset	301 if (PrintDeoptimizationDetails) {
44 52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	302 ttyLocker ttyl;
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	303 for (int j = 0; j < monitors->length(); j++) {
83 d3cd40645d0d 6681646: Relocking of a scalar replaced object during deoptimization is broken kvn parents: 44 diff changeset	304 MonitorInfo* mi = monitors->at(j);
d3cd40645d0d 6681646: Relocking of a scalar replaced object during deoptimization is broken kvn parents: 44 diff changeset	305 if (mi->eliminated()) {
d3cd40645d0d 6681646: Relocking of a scalar replaced object during deoptimization is broken kvn parents: 44 diff changeset	306 if (first) {
d3cd40645d0d 6681646: Relocking of a scalar replaced object during deoptimization is broken kvn parents: 44 diff changeset	307 first = false;
d3cd40645d0d 6681646: Relocking of a scalar replaced object during deoptimization is broken kvn parents: 44 diff changeset	308 tty->print_cr("RELOCK OBJECTS in thread " INTPTR_FORMAT, thread);
d3cd40645d0d 6681646: Relocking of a scalar replaced object during deoptimization is broken kvn parents: 44 diff changeset	309 }
d3cd40645d0d 6681646: Relocking of a scalar replaced object during deoptimization is broken kvn parents: 44 diff changeset	310 tty->print_cr(" object <" INTPTR_FORMAT "> locked", mi->owner());
44 52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	311 }
0 a61af66fc99e Initial load duke parents: diff changeset	312 }
a61af66fc99e Initial load duke parents: diff changeset	313 }
4674 e1c053324210 changed TraceDeoptimization output Christian Haeubl <christian.haeubl@oracle.com> parents: 4668 diff changeset	314 #endif // !PRODUCT
0 a61af66fc99e Initial load duke parents: diff changeset	315 }
a61af66fc99e Initial load duke parents: diff changeset	316 }
4674 e1c053324210 changed TraceDeoptimization output Christian Haeubl <christian.haeubl@oracle.com> parents: 4668 diff changeset	317 #ifdef COMPILER2
0 a61af66fc99e Initial load duke parents: diff changeset	318 }
a61af66fc99e Initial load duke parents: diff changeset	319 }
a61af66fc99e Initial load duke parents: diff changeset	320 #endif // COMPILER2
4674 e1c053324210 changed TraceDeoptimization output Christian Haeubl <christian.haeubl@oracle.com> parents: 4668 diff changeset	321 #endif // COMPILER2 \|\| GRAAL
e1c053324210 changed TraceDeoptimization output Christian Haeubl <christian.haeubl@oracle.com> parents: 4668 diff changeset	322
0 a61af66fc99e Initial load duke parents: diff changeset	323 // Ensure that no safepoint is taken after pointers have been stored
a61af66fc99e Initial load duke parents: diff changeset	324 // in fields of rematerialized objects. If a safepoint occurs from here on
a61af66fc99e Initial load duke parents: diff changeset	325 // out the java state residing in the vframeArray will be missed.
a61af66fc99e Initial load duke parents: diff changeset	326 No_Safepoint_Verifier no_safepoint;
a61af66fc99e Initial load duke parents: diff changeset	327
a61af66fc99e Initial load duke parents: diff changeset	328 vframeArray* array = create_vframeArray(thread, deoptee, &map, chunk);
a61af66fc99e Initial load duke parents: diff changeset	329
a61af66fc99e Initial load duke parents: diff changeset	330 assert(thread->vframe_array_head() == NULL, "Pending deopt!");;
a61af66fc99e Initial load duke parents: diff changeset	331 thread->set_vframe_array_head(array);
a61af66fc99e Initial load duke parents: diff changeset	332
a61af66fc99e Initial load duke parents: diff changeset	333 // Now that the vframeArray has been created if we have any deferred local writes
a61af66fc99e Initial load duke parents: diff changeset	334 // added by jvmti then we can free up that structure as the data is now in the
a61af66fc99e Initial load duke parents: diff changeset	335 // vframeArray
a61af66fc99e Initial load duke parents: diff changeset	336
a61af66fc99e Initial load duke parents: diff changeset	337 if (thread->deferred_locals() != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	338 GrowableArray<jvmtiDeferredLocalVariableSet> list = thread->deferred_locals();
a61af66fc99e Initial load duke parents: diff changeset	339 int i = 0;
a61af66fc99e Initial load duke parents: diff changeset	340 do {
a61af66fc99e Initial load duke parents: diff changeset	341 // Because of inlining we could have multiple vframes for a single frame
a61af66fc99e Initial load duke parents: diff changeset	342 // and several of the vframes could have deferred writes. Find them all.
a61af66fc99e Initial load duke parents: diff changeset	343 if (list->at(i)->id() == array->original().id()) {
a61af66fc99e Initial load duke parents: diff changeset	344 jvmtiDeferredLocalVariableSet* dlv = list->at(i);
a61af66fc99e Initial load duke parents: diff changeset	345 list->remove_at(i);
a61af66fc99e Initial load duke parents: diff changeset	346 // individual jvmtiDeferredLocalVariableSet are CHeapObj's
a61af66fc99e Initial load duke parents: diff changeset	347 delete dlv;
a61af66fc99e Initial load duke parents: diff changeset	348 } else {
a61af66fc99e Initial load duke parents: diff changeset	349 i++;
a61af66fc99e Initial load duke parents: diff changeset	350 }
a61af66fc99e Initial load duke parents: diff changeset	351 } while ( i < list->length() );
a61af66fc99e Initial load duke parents: diff changeset	352 if (list->length() == 0) {
a61af66fc99e Initial load duke parents: diff changeset	353 thread->set_deferred_locals(NULL);
a61af66fc99e Initial load duke parents: diff changeset	354 // free the list and elements back to C heap.
a61af66fc99e Initial load duke parents: diff changeset	355 delete list;
a61af66fc99e Initial load duke parents: diff changeset	356 }
a61af66fc99e Initial load duke parents: diff changeset	357
a61af66fc99e Initial load duke parents: diff changeset	358 }
a61af66fc99e Initial load duke parents: diff changeset	359
1692 d2ede61b7a12 6976186: integrate Shark HotSpot changes twisti parents: 1552 diff changeset	360 #ifndef SHARK
0 a61af66fc99e Initial load duke parents: diff changeset	361 // Compute the caller frame based on the sender sp of stub_frame and stored frame sizes info.
a61af66fc99e Initial load duke parents: diff changeset	362 CodeBlob* cb = stub_frame.cb();
a61af66fc99e Initial load duke parents: diff changeset	363 // Verify we have the right vframeArray
a61af66fc99e Initial load duke parents: diff changeset	364 assert(cb->frame_size() >= 0, "Unexpected frame size");
a61af66fc99e Initial load duke parents: diff changeset	365 intptr_t* unpack_sp = stub_frame.sp() + cb->frame_size();
a61af66fc99e Initial load duke parents: diff changeset	366
1204 18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	367 // If the deopt call site is a MethodHandle invoke call site we have
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	368 // to adjust the unpack_sp.
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	369 nmethod* deoptee_nm = deoptee.cb()->as_nmethod_or_null();
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	370 if (deoptee_nm != NULL && deoptee_nm->is_method_handle_return(deoptee.pc()))
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	371 unpack_sp = deoptee.unextended_sp();
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1201 diff changeset	372
0 a61af66fc99e Initial load duke parents: diff changeset	373 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	374 assert(cb->is_deoptimization_stub() \|\| cb->is_uncommon_trap_stub(), "just checking");
a61af66fc99e Initial load duke parents: diff changeset	375 #endif
1692 d2ede61b7a12 6976186: integrate Shark HotSpot changes twisti parents: 1552 diff changeset	376 #else
d2ede61b7a12 6976186: integrate Shark HotSpot changes twisti parents: 1552 diff changeset	377 intptr_t* unpack_sp = stub_frame.sender(&dummy_map).unextended_sp();
d2ede61b7a12 6976186: integrate Shark HotSpot changes twisti parents: 1552 diff changeset	378 #endif // !SHARK
d2ede61b7a12 6976186: integrate Shark HotSpot changes twisti parents: 1552 diff changeset	379
0 a61af66fc99e Initial load duke parents: diff changeset	380 // This is a guarantee instead of an assert because if vframe doesn't match
a61af66fc99e Initial load duke parents: diff changeset	381 // we will unpack the wrong deoptimized frame and wind up in strange places
a61af66fc99e Initial load duke parents: diff changeset	382 // where it will be very difficult to figure out what went wrong. Better
a61af66fc99e Initial load duke parents: diff changeset	383 // to die an early death here than some very obscure death later when the
a61af66fc99e Initial load duke parents: diff changeset	384 // trail is cold.
a61af66fc99e Initial load duke parents: diff changeset	385 // Note: on ia64 this guarantee can be fooled by frames with no memory stack
a61af66fc99e Initial load duke parents: diff changeset	386 // in that it will fail to detect a problem when there is one. This needs
a61af66fc99e Initial load duke parents: diff changeset	387 // more work in tiger timeframe.
a61af66fc99e Initial load duke parents: diff changeset	388 guarantee(array->unextended_sp() == unpack_sp, "vframe_array_head must contain the vframeArray to unpack");
a61af66fc99e Initial load duke parents: diff changeset	389
a61af66fc99e Initial load duke parents: diff changeset	390 int number_of_frames = array->frames();
a61af66fc99e Initial load duke parents: diff changeset	391
a61af66fc99e Initial load duke parents: diff changeset	392 // Compute the vframes' sizes. Note that frame_sizes[] entries are ordered from outermost to innermost
a61af66fc99e Initial load duke parents: diff changeset	393 // virtual activation, which is the reverse of the elements in the vframes array.
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 4872 diff changeset	394 intptr_t* frame_sizes = NEW_C_HEAP_ARRAY(intptr_t, number_of_frames, mtCompiler);
0 a61af66fc99e Initial load duke parents: diff changeset	395 // +1 because we always have an interpreter return address for the final slot.
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 4872 diff changeset	396 address* frame_pcs = NEW_C_HEAP_ARRAY(address, number_of_frames + 1, mtCompiler);
0 a61af66fc99e Initial load duke parents: diff changeset	397 int popframe_extra_args = 0;
a61af66fc99e Initial load duke parents: diff changeset	398 // Create an interpreter return address for the stub to use as its return
a61af66fc99e Initial load duke parents: diff changeset	399 // address so the skeletal frames are perfectly walkable
a61af66fc99e Initial load duke parents: diff changeset	400 frame_pcs[number_of_frames] = Interpreter::deopt_entry(vtos, 0);
a61af66fc99e Initial load duke parents: diff changeset	401
a61af66fc99e Initial load duke parents: diff changeset	402 // PopFrame requires that the preserved incoming arguments from the recently-popped topmost
a61af66fc99e Initial load duke parents: diff changeset	403 // activation be put back on the expression stack of the caller for reexecution
a61af66fc99e Initial load duke parents: diff changeset	404 if (JvmtiExport::can_pop_frame() && thread->popframe_forcing_deopt_reexecution()) {
a61af66fc99e Initial load duke parents: diff changeset	405 popframe_extra_args = in_words(thread->popframe_preserved_args_size_in_words());
a61af66fc99e Initial load duke parents: diff changeset	406 }
a61af66fc99e Initial load duke parents: diff changeset	407
3369 3d2ab563047a 7043461: VM crashes in void LinkResolver::runtime_resolve_virtual_method never parents: 3346 diff changeset	408 // Find the current pc for sender of the deoptee. Since the sender may have been deoptimized
3d2ab563047a 7043461: VM crashes in void LinkResolver::runtime_resolve_virtual_method never parents: 3346 diff changeset	409 // itself since the deoptee vframeArray was created we must get a fresh value of the pc rather
3d2ab563047a 7043461: VM crashes in void LinkResolver::runtime_resolve_virtual_method never parents: 3346 diff changeset	410 // than simply use array->sender.pc(). This requires us to walk the current set of frames
3d2ab563047a 7043461: VM crashes in void LinkResolver::runtime_resolve_virtual_method never parents: 3346 diff changeset	411 //
3d2ab563047a 7043461: VM crashes in void LinkResolver::runtime_resolve_virtual_method never parents: 3346 diff changeset	412 frame deopt_sender = stub_frame.sender(&dummy_map); // First is the deoptee frame
3d2ab563047a 7043461: VM crashes in void LinkResolver::runtime_resolve_virtual_method never parents: 3346 diff changeset	413 deopt_sender = deopt_sender.sender(&dummy_map); // Now deoptee caller
3d2ab563047a 7043461: VM crashes in void LinkResolver::runtime_resolve_virtual_method never parents: 3346 diff changeset	414
3d2ab563047a 7043461: VM crashes in void LinkResolver::runtime_resolve_virtual_method never parents: 3346 diff changeset	415 // It's possible that the number of paramters at the call site is
3d2ab563047a 7043461: VM crashes in void LinkResolver::runtime_resolve_virtual_method never parents: 3346 diff changeset	416 // different than number of arguments in the callee when method
3d2ab563047a 7043461: VM crashes in void LinkResolver::runtime_resolve_virtual_method never parents: 3346 diff changeset	417 // handles are used. If the caller is interpreted get the real
3d2ab563047a 7043461: VM crashes in void LinkResolver::runtime_resolve_virtual_method never parents: 3346 diff changeset	418 // value so that the proper amount of space can be added to it's
3d2ab563047a 7043461: VM crashes in void LinkResolver::runtime_resolve_virtual_method never parents: 3346 diff changeset	419 // frame.
4042 b20d64f83668 7090904: JSR 292: JRuby junit test crashes in PSScavengeRootsClosure::do_oop twisti parents: 3931 diff changeset	420 bool caller_was_method_handle = false;
3369 3d2ab563047a 7043461: VM crashes in void LinkResolver::runtime_resolve_virtual_method never parents: 3346 diff changeset	421 if (deopt_sender.is_interpreted_frame()) {
3d2ab563047a 7043461: VM crashes in void LinkResolver::runtime_resolve_virtual_method never parents: 3346 diff changeset	422 methodHandle method = deopt_sender.interpreter_frame_method();
4055 e342a5110bed 7106774: JSR 292: nightly test inlineMHTarget fails with wrong result twisti parents: 4042 diff changeset	423 Bytecode_invoke cur = Bytecode_invoke_check(method, deopt_sender.interpreter_frame_bci());
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 6197 diff changeset	424 if (cur.is_invokedynamic() \|\| cur.is_invokehandle()) {
4042 b20d64f83668 7090904: JSR 292: JRuby junit test crashes in PSScavengeRootsClosure::do_oop twisti parents: 3931 diff changeset	425 // Method handle invokes may involve fairly arbitrary chains of
b20d64f83668 7090904: JSR 292: JRuby junit test crashes in PSScavengeRootsClosure::do_oop twisti parents: 3931 diff changeset	426 // calls so it's impossible to know how much actual space the
b20d64f83668 7090904: JSR 292: JRuby junit test crashes in PSScavengeRootsClosure::do_oop twisti parents: 3931 diff changeset	427 // caller has for locals.
b20d64f83668 7090904: JSR 292: JRuby junit test crashes in PSScavengeRootsClosure::do_oop twisti parents: 3931 diff changeset	428 caller_was_method_handle = true;
b20d64f83668 7090904: JSR 292: JRuby junit test crashes in PSScavengeRootsClosure::do_oop twisti parents: 3931 diff changeset	429 }
3369 3d2ab563047a 7043461: VM crashes in void LinkResolver::runtime_resolve_virtual_method never parents: 3346 diff changeset	430 }
3d2ab563047a 7043461: VM crashes in void LinkResolver::runtime_resolve_virtual_method never parents: 3346 diff changeset	431
0 a61af66fc99e Initial load duke parents: diff changeset	432 //
a61af66fc99e Initial load duke parents: diff changeset	433 // frame_sizes/frame_pcs[0] oldest frame (int or c2i)
a61af66fc99e Initial load duke parents: diff changeset	434 // frame_sizes/frame_pcs[1] next oldest frame (int)
a61af66fc99e Initial load duke parents: diff changeset	435 // frame_sizes/frame_pcs[n] youngest frame (int)
a61af66fc99e Initial load duke parents: diff changeset	436 //
a61af66fc99e Initial load duke parents: diff changeset	437 // Now a pc in frame_pcs is actually the return address to the frame's caller (a frame
a61af66fc99e Initial load duke parents: diff changeset	438 // owns the space for the return address to it's caller). Confusing ain't it.
a61af66fc99e Initial load duke parents: diff changeset	439 //
a61af66fc99e Initial load duke parents: diff changeset	440 // The vframe array can address vframes with indices running from
a61af66fc99e Initial load duke parents: diff changeset	441 // 0.._frames-1. Index 0 is the youngest frame and _frame - 1 is the oldest (root) frame.
a61af66fc99e Initial load duke parents: diff changeset	442 // When we create the skeletal frames we need the oldest frame to be in the zero slot
a61af66fc99e Initial load duke parents: diff changeset	443 // in the frame_sizes/frame_pcs so the assembly code can do a trivial walk.
a61af66fc99e Initial load duke parents: diff changeset	444 // so things look a little strange in this loop.
a61af66fc99e Initial load duke parents: diff changeset	445 //
4042 b20d64f83668 7090904: JSR 292: JRuby junit test crashes in PSScavengeRootsClosure::do_oop twisti parents: 3931 diff changeset	446 int callee_parameters = 0;
b20d64f83668 7090904: JSR 292: JRuby junit test crashes in PSScavengeRootsClosure::do_oop twisti parents: 3931 diff changeset	447 int callee_locals = 0;
0 a61af66fc99e Initial load duke parents: diff changeset	448 for (int index = 0; index < array->frames(); index++ ) {
a61af66fc99e Initial load duke parents: diff changeset	449 // frame[number_of_frames - 1 ] = on_stack_size(youngest)
a61af66fc99e Initial load duke parents: diff changeset	450 // frame[number_of_frames - 2 ] = on_stack_size(sender(youngest))
a61af66fc99e Initial load duke parents: diff changeset	451 // frame[number_of_frames - 3 ] = on_stack_size(sender(sender(youngest)))
3369 3d2ab563047a 7043461: VM crashes in void LinkResolver::runtime_resolve_virtual_method never parents: 3346 diff changeset	452 int caller_parms = callee_parameters;
4042 b20d64f83668 7090904: JSR 292: JRuby junit test crashes in PSScavengeRootsClosure::do_oop twisti parents: 3931 diff changeset	453 if ((index == array->frames() - 1) && caller_was_method_handle) {
b20d64f83668 7090904: JSR 292: JRuby junit test crashes in PSScavengeRootsClosure::do_oop twisti parents: 3931 diff changeset	454 caller_parms = 0;
3369 3d2ab563047a 7043461: VM crashes in void LinkResolver::runtime_resolve_virtual_method never parents: 3346 diff changeset	455 }
3d2ab563047a 7043461: VM crashes in void LinkResolver::runtime_resolve_virtual_method never parents: 3346 diff changeset	456 frame_sizes[number_of_frames - 1 - index] = BytesPerWord * array->element(index)->on_stack_size(caller_parms,
3d2ab563047a 7043461: VM crashes in void LinkResolver::runtime_resolve_virtual_method never parents: 3346 diff changeset	457 callee_parameters,
0 a61af66fc99e Initial load duke parents: diff changeset	458 callee_locals,
a61af66fc99e Initial load duke parents: diff changeset	459 index == 0,
8727 0094485b46c7 8009761: Deoptimization on sparc doesn't set Llast_SP correctly in the interpreter frames it creates roland parents: 7998 diff changeset	460 index == array->frames() - 1,
0 a61af66fc99e Initial load duke parents: diff changeset	461 popframe_extra_args);
a61af66fc99e Initial load duke parents: diff changeset	462 // This pc doesn't have to be perfect just good enough to identify the frame
a61af66fc99e Initial load duke parents: diff changeset	463 // as interpreted so the skeleton frame will be walkable
a61af66fc99e Initial load duke parents: diff changeset	464 // The correct pc will be set when the skeleton frame is completely filled out
a61af66fc99e Initial load duke parents: diff changeset	465 // The final pc we store in the loop is wrong and will be overwritten below
a61af66fc99e Initial load duke parents: diff changeset	466 frame_pcs[number_of_frames - 1 - index ] = Interpreter::deopt_entry(vtos, 0) - frame::pc_return_offset;
a61af66fc99e Initial load duke parents: diff changeset	467
a61af66fc99e Initial load duke parents: diff changeset	468 callee_parameters = array->element(index)->method()->size_of_parameters();
a61af66fc99e Initial load duke parents: diff changeset	469 callee_locals = array->element(index)->method()->max_locals();
a61af66fc99e Initial load duke parents: diff changeset	470 popframe_extra_args = 0;
a61af66fc99e Initial load duke parents: diff changeset	471 }
a61af66fc99e Initial load duke parents: diff changeset	472
a61af66fc99e Initial load duke parents: diff changeset	473 // Compute whether the root vframe returns a float or double value.
a61af66fc99e Initial load duke parents: diff changeset	474 BasicType return_type;
a61af66fc99e Initial load duke parents: diff changeset	475 {
a61af66fc99e Initial load duke parents: diff changeset	476 HandleMark hm;
a61af66fc99e Initial load duke parents: diff changeset	477 methodHandle method(thread, array->element(0)->method());
2142 8012aa3ccede 4926272: methodOopDesc::method_from_bcp is unsafe never parents: 1972 diff changeset	478 Bytecode_invoke invoke = Bytecode_invoke_check(method, array->element(0)->bci());
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2142 diff changeset	479 return_type = invoke.is_valid() ? invoke.result_type() : T_ILLEGAL;
0 a61af66fc99e Initial load duke parents: diff changeset	480 }
a61af66fc99e Initial load duke parents: diff changeset	481
a61af66fc99e Initial load duke parents: diff changeset	482 // Compute information for handling adapters and adjusting the frame size of the caller.
a61af66fc99e Initial load duke parents: diff changeset	483 int caller_adjustment = 0;
a61af66fc99e Initial load duke parents: diff changeset	484
a61af66fc99e Initial load duke parents: diff changeset	485 // Compute the amount the oldest interpreter frame will have to adjust
a61af66fc99e Initial load duke parents: diff changeset	486 // its caller's stack by. If the caller is a compiled frame then
a61af66fc99e Initial load duke parents: diff changeset	487 // we pretend that the callee has no parameters so that the
a61af66fc99e Initial load duke parents: diff changeset	488 // extension counts for the full amount of locals and not just
a61af66fc99e Initial load duke parents: diff changeset	489 // locals-parms. This is because without a c2i adapter the parm
a61af66fc99e Initial load duke parents: diff changeset	490 // area as created by the compiled frame will not be usable by
a61af66fc99e Initial load duke parents: diff changeset	491 // the interpreter. (Depending on the calling convention there
a61af66fc99e Initial load duke parents: diff changeset	492 // may not even be enough space).
a61af66fc99e Initial load duke parents: diff changeset	493
a61af66fc99e Initial load duke parents: diff changeset	494 // QQQ I'd rather see this pushed down into last_frame_adjust
a61af66fc99e Initial load duke parents: diff changeset	495 // and have it take the sender (aka caller).
a61af66fc99e Initial load duke parents: diff changeset	496
4042 b20d64f83668 7090904: JSR 292: JRuby junit test crashes in PSScavengeRootsClosure::do_oop twisti parents: 3931 diff changeset	497 if (deopt_sender.is_compiled_frame() \|\| caller_was_method_handle) {
0 a61af66fc99e Initial load duke parents: diff changeset	498 caller_adjustment = last_frame_adjust(0, callee_locals);
4042 b20d64f83668 7090904: JSR 292: JRuby junit test crashes in PSScavengeRootsClosure::do_oop twisti parents: 3931 diff changeset	499 } else if (callee_locals > callee_parameters) {
0 a61af66fc99e Initial load duke parents: diff changeset	500 // The caller frame may need extending to accommodate
a61af66fc99e Initial load duke parents: diff changeset	501 // non-parameter locals of the first unpacked interpreted frame.
a61af66fc99e Initial load duke parents: diff changeset	502 // Compute that adjustment.
4042 b20d64f83668 7090904: JSR 292: JRuby junit test crashes in PSScavengeRootsClosure::do_oop twisti parents: 3931 diff changeset	503 caller_adjustment = last_frame_adjust(callee_parameters, callee_locals);
0 a61af66fc99e Initial load duke parents: diff changeset	504 }
a61af66fc99e Initial load duke parents: diff changeset	505
a61af66fc99e Initial load duke parents: diff changeset	506 // If the sender is deoptimized the we must retrieve the address of the handler
a61af66fc99e Initial load duke parents: diff changeset	507 // since the frame will "magically" show the original pc before the deopt
a61af66fc99e Initial load duke parents: diff changeset	508 // and we'd undo the deopt.
a61af66fc99e Initial load duke parents: diff changeset	509
a61af66fc99e Initial load duke parents: diff changeset	510 frame_pcs[0] = deopt_sender.raw_pc();
a61af66fc99e Initial load duke parents: diff changeset	511
1692 d2ede61b7a12 6976186: integrate Shark HotSpot changes twisti parents: 1552 diff changeset	512 #ifndef SHARK
0 a61af66fc99e Initial load duke parents: diff changeset	513 assert(CodeCache::find_blob_unsafe(frame_pcs[0]) != NULL, "bad pc");
1692 d2ede61b7a12 6976186: integrate Shark HotSpot changes twisti parents: 1552 diff changeset	514 #endif // SHARK
0 a61af66fc99e Initial load duke parents: diff changeset	515
a61af66fc99e Initial load duke parents: diff changeset	516 UnrollBlock* info = new UnrollBlock(array->frame_size() * BytesPerWord,
a61af66fc99e Initial load duke parents: diff changeset	517 caller_adjustment * BytesPerWord,
4042 b20d64f83668 7090904: JSR 292: JRuby junit test crashes in PSScavengeRootsClosure::do_oop twisti parents: 3931 diff changeset	518 caller_was_method_handle ? 0 : callee_parameters,
0 a61af66fc99e Initial load duke parents: diff changeset	519 number_of_frames,
a61af66fc99e Initial load duke parents: diff changeset	520 frame_sizes,
a61af66fc99e Initial load duke parents: diff changeset	521 frame_pcs,
a61af66fc99e Initial load duke parents: diff changeset	522 return_type);
3931 5432047c7db7 7087445: Improve platform independence of JSR292 shared code bdelsart parents: 3369 diff changeset	523 // On some platforms, we need a way to pass some platform dependent
5432047c7db7 7087445: Improve platform independence of JSR292 shared code bdelsart parents: 3369 diff changeset	524 // information to the unpacking code so the skeletal frames come out
5432047c7db7 7087445: Improve platform independence of JSR292 shared code bdelsart parents: 3369 diff changeset	525 // correct (initial fp value, unextended sp, ...)
5432047c7db7 7087445: Improve platform independence of JSR292 shared code bdelsart parents: 3369 diff changeset	526 info->set_initial_info((intptr_t) array->sender().initial_deoptimization_info());
0 a61af66fc99e Initial load duke parents: diff changeset	527
a61af66fc99e Initial load duke parents: diff changeset	528 if (array->frames() > 1) {
a61af66fc99e Initial load duke parents: diff changeset	529 if (VerifyStack && TraceDeoptimization) {
6843 c3e799c37717 7177003: C1: LogCompilation support vlivanov parents: 6725 diff changeset	530 ttyLocker ttyl;
0 a61af66fc99e Initial load duke parents: diff changeset	531 tty->print_cr("Deoptimizing method containing inlining");
a61af66fc99e Initial load duke parents: diff changeset	532 }
a61af66fc99e Initial load duke parents: diff changeset	533 }
a61af66fc99e Initial load duke parents: diff changeset	534
a61af66fc99e Initial load duke parents: diff changeset	535 array->set_unroll_block(info);
a61af66fc99e Initial load duke parents: diff changeset	536 return info;
a61af66fc99e Initial load duke parents: diff changeset	537 }
a61af66fc99e Initial load duke parents: diff changeset	538
a61af66fc99e Initial load duke parents: diff changeset	539 // Called to cleanup deoptimization data structures in normal case
a61af66fc99e Initial load duke parents: diff changeset	540 // after unpacking to stack and when stack overflow error occurs
a61af66fc99e Initial load duke parents: diff changeset	541 void Deoptimization::cleanup_deopt_info(JavaThread *thread,
a61af66fc99e Initial load duke parents: diff changeset	542 vframeArray *array) {
a61af66fc99e Initial load duke parents: diff changeset	543
a61af66fc99e Initial load duke parents: diff changeset	544 // Get array if coming from exception
a61af66fc99e Initial load duke parents: diff changeset	545 if (array == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	546 array = thread->vframe_array_head();
a61af66fc99e Initial load duke parents: diff changeset	547 }
a61af66fc99e Initial load duke parents: diff changeset	548 thread->set_vframe_array_head(NULL);
a61af66fc99e Initial load duke parents: diff changeset	549
a61af66fc99e Initial load duke parents: diff changeset	550 // Free the previous UnrollBlock
a61af66fc99e Initial load duke parents: diff changeset	551 vframeArray* old_array = thread->vframe_array_last();
a61af66fc99e Initial load duke parents: diff changeset	552 thread->set_vframe_array_last(array);
a61af66fc99e Initial load duke parents: diff changeset	553
a61af66fc99e Initial load duke parents: diff changeset	554 if (old_array != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	555 UnrollBlock* old_info = old_array->unroll_block();
a61af66fc99e Initial load duke parents: diff changeset	556 old_array->set_unroll_block(NULL);
a61af66fc99e Initial load duke parents: diff changeset	557 delete old_info;
a61af66fc99e Initial load duke parents: diff changeset	558 delete old_array;
a61af66fc99e Initial load duke parents: diff changeset	559 }
a61af66fc99e Initial load duke parents: diff changeset	560
a61af66fc99e Initial load duke parents: diff changeset	561 // Deallocate any resource creating in this routine and any ResourceObjs allocated
a61af66fc99e Initial load duke parents: diff changeset	562 // inside the vframeArray (StackValueCollections)
a61af66fc99e Initial load duke parents: diff changeset	563
a61af66fc99e Initial load duke parents: diff changeset	564 delete thread->deopt_mark();
a61af66fc99e Initial load duke parents: diff changeset	565 thread->set_deopt_mark(NULL);
1814 fd5d4527cdf5 6986270: guarantee(bcp != Bytecodes::_monitorenter \|\| exec_mode != Deoptimization::Unpack_exception) fails iveresov* parents: 1783 diff changeset	566 thread->set_deopt_nmethod(NULL);
0 a61af66fc99e Initial load duke parents: diff changeset	567
a61af66fc99e Initial load duke parents: diff changeset	568
a61af66fc99e Initial load duke parents: diff changeset	569 if (JvmtiExport::can_pop_frame()) {
a61af66fc99e Initial load duke parents: diff changeset	570 #ifndef CC_INTERP
a61af66fc99e Initial load duke parents: diff changeset	571 // Regardless of whether we entered this routine with the pending
a61af66fc99e Initial load duke parents: diff changeset	572 // popframe condition bit set, we should always clear it now
a61af66fc99e Initial load duke parents: diff changeset	573 thread->clear_popframe_condition();
a61af66fc99e Initial load duke parents: diff changeset	574 #else
a61af66fc99e Initial load duke parents: diff changeset	575 // C++ interpeter will clear has_pending_popframe when it enters
a61af66fc99e Initial load duke parents: diff changeset	576 // with method_resume. For deopt_resume2 we clear it now.
a61af66fc99e Initial load duke parents: diff changeset	577 if (thread->popframe_forcing_deopt_reexecution())
a61af66fc99e Initial load duke parents: diff changeset	578 thread->clear_popframe_condition();
a61af66fc99e Initial load duke parents: diff changeset	579 #endif /* CC_INTERP */
a61af66fc99e Initial load duke parents: diff changeset	580 }
a61af66fc99e Initial load duke parents: diff changeset	581
a61af66fc99e Initial load duke parents: diff changeset	582 // unpack_frames() is called at the end of the deoptimization handler
a61af66fc99e Initial load duke parents: diff changeset	583 // and (in C2) at the end of the uncommon trap handler. Note this fact
a61af66fc99e Initial load duke parents: diff changeset	584 // so that an asynchronous stack walker can work again. This counter is
a61af66fc99e Initial load duke parents: diff changeset	585 // incremented at the beginning of fetch_unroll_info() and (in C2) at
a61af66fc99e Initial load duke parents: diff changeset	586 // the beginning of uncommon_trap().
a61af66fc99e Initial load duke parents: diff changeset	587 thread->dec_in_deopt_handler();
a61af66fc99e Initial load duke parents: diff changeset	588 }
a61af66fc99e Initial load duke parents: diff changeset	589
a61af66fc99e Initial load duke parents: diff changeset	590
a61af66fc99e Initial load duke parents: diff changeset	591 // Return BasicType of value being returned
a61af66fc99e Initial load duke parents: diff changeset	592 JRT_LEAF(BasicType, Deoptimization::unpack_frames(JavaThread* thread, int exec_mode))
a61af66fc99e Initial load duke parents: diff changeset	593
a61af66fc99e Initial load duke parents: diff changeset	594 // We are already active int he special DeoptResourceMark any ResourceObj's we
a61af66fc99e Initial load duke parents: diff changeset	595 // allocate will be freed at the end of the routine.
a61af66fc99e Initial load duke parents: diff changeset	596
a61af66fc99e Initial load duke parents: diff changeset	597 // It is actually ok to allocate handles in a leaf method. It causes no safepoints,
a61af66fc99e Initial load duke parents: diff changeset	598 // but makes the entry a little slower. There is however a little dance we have to
a61af66fc99e Initial load duke parents: diff changeset	599 // do in debug mode to get around the NoHandleMark code in the JRT_LEAF macro
a61af66fc99e Initial load duke parents: diff changeset	600 ResetNoHandleMark rnhm; // No-op in release/product versions
a61af66fc99e Initial load duke parents: diff changeset	601 HandleMark hm;
a61af66fc99e Initial load duke parents: diff changeset	602
a61af66fc99e Initial load duke parents: diff changeset	603 frame stub_frame = thread->last_frame();
a61af66fc99e Initial load duke parents: diff changeset	604
a61af66fc99e Initial load duke parents: diff changeset	605 // Since the frame to unpack is the top frame of this thread, the vframe_array_head
a61af66fc99e Initial load duke parents: diff changeset	606 // must point to the vframeArray for the unpack frame.
a61af66fc99e Initial load duke parents: diff changeset	607 vframeArray* array = thread->vframe_array_head();
a61af66fc99e Initial load duke parents: diff changeset	608
a61af66fc99e Initial load duke parents: diff changeset	609 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	610 if (TraceDeoptimization) {
6843 c3e799c37717 7177003: C1: LogCompilation support vlivanov parents: 6725 diff changeset	611 ttyLocker ttyl;
0 a61af66fc99e Initial load duke parents: diff changeset	612 tty->print_cr("DEOPT UNPACKING thread " INTPTR_FORMAT " vframeArray " INTPTR_FORMAT " mode %d", thread, array, exec_mode);
a61af66fc99e Initial load duke parents: diff changeset	613 }
a61af66fc99e Initial load duke parents: diff changeset	614 #endif
4872 aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4777 diff changeset	615 Events::log(thread, "DEOPT UNPACKING pc=" INTPTR_FORMAT " sp=" INTPTR_FORMAT " mode %d",
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4777 diff changeset	616 stub_frame.pc(), stub_frame.sp(), exec_mode);
0 a61af66fc99e Initial load duke parents: diff changeset	617
a61af66fc99e Initial load duke parents: diff changeset	618 UnrollBlock* info = array->unroll_block();
a61af66fc99e Initial load duke parents: diff changeset	619
a61af66fc99e Initial load duke parents: diff changeset	620 // Unpack the interpreter frames and any adapter frame (c2 only) we might create.
3369 3d2ab563047a 7043461: VM crashes in void LinkResolver::runtime_resolve_virtual_method never parents: 3346 diff changeset	621 array->unpack_to_stack(stub_frame, exec_mode, info->caller_actual_parameters());
0 a61af66fc99e Initial load duke parents: diff changeset	622
a61af66fc99e Initial load duke parents: diff changeset	623 BasicType bt = info->return_type();
a61af66fc99e Initial load duke parents: diff changeset	624
a61af66fc99e Initial load duke parents: diff changeset	625 // If we have an exception pending, claim that the return type is an oop
a61af66fc99e Initial load duke parents: diff changeset	626 // so the deopt_blob does not overwrite the exception_oop.
a61af66fc99e Initial load duke parents: diff changeset	627
a61af66fc99e Initial load duke parents: diff changeset	628 if (exec_mode == Unpack_exception)
a61af66fc99e Initial load duke parents: diff changeset	629 bt = T_OBJECT;
a61af66fc99e Initial load duke parents: diff changeset	630
a61af66fc99e Initial load duke parents: diff changeset	631 // Cleanup thread deopt data
a61af66fc99e Initial load duke parents: diff changeset	632 cleanup_deopt_info(thread, array);
a61af66fc99e Initial load duke parents: diff changeset	633
a61af66fc99e Initial load duke parents: diff changeset	634 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	635 if (VerifyStack) {
a61af66fc99e Initial load duke parents: diff changeset	636 ResourceMark res_mark;
a61af66fc99e Initial load duke parents: diff changeset	637
3336 2e038ad0c1d0 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp never parents: 2338 diff changeset	638 thread->validate_frame_layout();
2e038ad0c1d0 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp never parents: 2338 diff changeset	639
0 a61af66fc99e Initial load duke parents: diff changeset	640 // Verify that the just-unpacked frames match the interpreter's
a61af66fc99e Initial load duke parents: diff changeset	641 // notions of expression stack and locals
a61af66fc99e Initial load duke parents: diff changeset	642 vframeArray* cur_array = thread->vframe_array_last();
a61af66fc99e Initial load duke parents: diff changeset	643 RegisterMap rm(thread, false);
a61af66fc99e Initial load duke parents: diff changeset	644 rm.set_include_argument_oops(false);
a61af66fc99e Initial load duke parents: diff changeset	645 bool is_top_frame = true;
a61af66fc99e Initial load duke parents: diff changeset	646 int callee_size_of_parameters = 0;
a61af66fc99e Initial load duke parents: diff changeset	647 int callee_max_locals = 0;
a61af66fc99e Initial load duke parents: diff changeset	648 for (int i = 0; i < cur_array->frames(); i++) {
a61af66fc99e Initial load duke parents: diff changeset	649 vframeArrayElement* el = cur_array->element(i);
a61af66fc99e Initial load duke parents: diff changeset	650 frame* iframe = el->iframe();
a61af66fc99e Initial load duke parents: diff changeset	651 guarantee(iframe->is_interpreted_frame(), "Wrong frame type");
a61af66fc99e Initial load duke parents: diff changeset	652
a61af66fc99e Initial load duke parents: diff changeset	653 // Get the oop map for this bci
a61af66fc99e Initial load duke parents: diff changeset	654 InterpreterOopMap mask;
a61af66fc99e Initial load duke parents: diff changeset	655 int cur_invoke_parameter_size = 0;
a61af66fc99e Initial load duke parents: diff changeset	656 bool try_next_mask = false;
a61af66fc99e Initial load duke parents: diff changeset	657 int next_mask_expression_stack_size = -1;
a61af66fc99e Initial load duke parents: diff changeset	658 int top_frame_expression_stack_adjustment = 0;
a61af66fc99e Initial load duke parents: diff changeset	659 methodHandle mh(thread, iframe->interpreter_frame_method());
a61af66fc99e Initial load duke parents: diff changeset	660 OopMapCache::compute_one_oop_map(mh, iframe->interpreter_frame_bci(), &mask);
a61af66fc99e Initial load duke parents: diff changeset	661 BytecodeStream str(mh);
a61af66fc99e Initial load duke parents: diff changeset	662 str.set_start(iframe->interpreter_frame_bci());
a61af66fc99e Initial load duke parents: diff changeset	663 int max_bci = mh->code_size();
a61af66fc99e Initial load duke parents: diff changeset	664 // Get to the next bytecode if possible
a61af66fc99e Initial load duke parents: diff changeset	665 assert(str.bci() < max_bci, "bci in interpreter frame out of bounds");
a61af66fc99e Initial load duke parents: diff changeset	666 // Check to see if we can grab the number of outgoing arguments
a61af66fc99e Initial load duke parents: diff changeset	667 // at an uncommon trap for an invoke (where the compiler
a61af66fc99e Initial load duke parents: diff changeset	668 // generates debug info before the invoke has executed)
a61af66fc99e Initial load duke parents: diff changeset	669 Bytecodes::Code cur_code = str.next();
a61af66fc99e Initial load duke parents: diff changeset	670 if (cur_code == Bytecodes::_invokevirtual \|\|
a61af66fc99e Initial load duke parents: diff changeset	671 cur_code == Bytecodes::_invokespecial \|\|
a61af66fc99e Initial load duke parents: diff changeset	672 cur_code == Bytecodes::_invokestatic \|\|
a61af66fc99e Initial load duke parents: diff changeset	673 cur_code == Bytecodes::_invokeinterface) {
2142 8012aa3ccede 4926272: methodOopDesc::method_from_bcp is unsafe never parents: 1972 diff changeset	674 Bytecode_invoke invoke(mh, iframe->interpreter_frame_bci());
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2142 diff changeset	675 Symbol* signature = invoke.signature();
0 a61af66fc99e Initial load duke parents: diff changeset	676 ArgumentSizeComputer asc(signature);
a61af66fc99e Initial load duke parents: diff changeset	677 cur_invoke_parameter_size = asc.size();
a61af66fc99e Initial load duke parents: diff changeset	678 if (cur_code != Bytecodes::_invokestatic) {
a61af66fc99e Initial load duke parents: diff changeset	679 // Add in receiver
a61af66fc99e Initial load duke parents: diff changeset	680 ++cur_invoke_parameter_size;
a61af66fc99e Initial load duke parents: diff changeset	681 }
a61af66fc99e Initial load duke parents: diff changeset	682 }
a61af66fc99e Initial load duke parents: diff changeset	683 if (str.bci() < max_bci) {
a61af66fc99e Initial load duke parents: diff changeset	684 Bytecodes::Code bc = str.next();
a61af66fc99e Initial load duke parents: diff changeset	685 if (bc >= 0) {
a61af66fc99e Initial load duke parents: diff changeset	686 // The interpreter oop map generator reports results before
a61af66fc99e Initial load duke parents: diff changeset	687 // the current bytecode has executed except in the case of
a61af66fc99e Initial load duke parents: diff changeset	688 // calls. It seems to be hard to tell whether the compiler
a61af66fc99e Initial load duke parents: diff changeset	689 // has emitted debug information matching the "state before"
a61af66fc99e Initial load duke parents: diff changeset	690 // a given bytecode or the state after, so we try both
a61af66fc99e Initial load duke parents: diff changeset	691 switch (cur_code) {
a61af66fc99e Initial load duke parents: diff changeset	692 case Bytecodes::_invokevirtual:
a61af66fc99e Initial load duke parents: diff changeset	693 case Bytecodes::_invokespecial:
a61af66fc99e Initial load duke parents: diff changeset	694 case Bytecodes::_invokestatic:
a61af66fc99e Initial load duke parents: diff changeset	695 case Bytecodes::_invokeinterface:
a61af66fc99e Initial load duke parents: diff changeset	696 case Bytecodes::_athrow:
a61af66fc99e Initial load duke parents: diff changeset	697 break;
a61af66fc99e Initial load duke parents: diff changeset	698 default: {
a61af66fc99e Initial load duke parents: diff changeset	699 InterpreterOopMap next_mask;
a61af66fc99e Initial load duke parents: diff changeset	700 OopMapCache::compute_one_oop_map(mh, str.bci(), &next_mask);
a61af66fc99e Initial load duke parents: diff changeset	701 next_mask_expression_stack_size = next_mask.expression_stack_size();
a61af66fc99e Initial load duke parents: diff changeset	702 // Need to subtract off the size of the result type of
a61af66fc99e Initial load duke parents: diff changeset	703 // the bytecode because this is not described in the
a61af66fc99e Initial load duke parents: diff changeset	704 // debug info but returned to the interpreter in the TOS
a61af66fc99e Initial load duke parents: diff changeset	705 // caching register
a61af66fc99e Initial load duke parents: diff changeset	706 BasicType bytecode_result_type = Bytecodes::result_type(cur_code);
a61af66fc99e Initial load duke parents: diff changeset	707 if (bytecode_result_type != T_ILLEGAL) {
a61af66fc99e Initial load duke parents: diff changeset	708 top_frame_expression_stack_adjustment = type2size[bytecode_result_type];
a61af66fc99e Initial load duke parents: diff changeset	709 }
a61af66fc99e Initial load duke parents: diff changeset	710 assert(top_frame_expression_stack_adjustment >= 0, "");
a61af66fc99e Initial load duke parents: diff changeset	711 try_next_mask = true;
a61af66fc99e Initial load duke parents: diff changeset	712 break;
a61af66fc99e Initial load duke parents: diff changeset	713 }
a61af66fc99e Initial load duke parents: diff changeset	714 }
a61af66fc99e Initial load duke parents: diff changeset	715 }
a61af66fc99e Initial load duke parents: diff changeset	716 }
a61af66fc99e Initial load duke parents: diff changeset	717
a61af66fc99e Initial load duke parents: diff changeset	718 // Verify stack depth and oops in frame
a61af66fc99e Initial load duke parents: diff changeset	719 // This assertion may be dependent on the platform we're running on and may need modification (tested on x86 and sparc)
a61af66fc99e Initial load duke parents: diff changeset	720 if (!(
a61af66fc99e Initial load duke parents: diff changeset	721 /* SPARC */
a61af66fc99e Initial load duke parents: diff changeset	722 (iframe->interpreter_frame_expression_stack_size() == mask.expression_stack_size() + callee_size_of_parameters) \|\|
a61af66fc99e Initial load duke parents: diff changeset	723 /* x86 */
a61af66fc99e Initial load duke parents: diff changeset	724 (iframe->interpreter_frame_expression_stack_size() == mask.expression_stack_size() + callee_max_locals) \|\|
a61af66fc99e Initial load duke parents: diff changeset	725 (try_next_mask &&
a61af66fc99e Initial load duke parents: diff changeset	726 (iframe->interpreter_frame_expression_stack_size() == (next_mask_expression_stack_size -
a61af66fc99e Initial load duke parents: diff changeset	727 top_frame_expression_stack_adjustment))) \|\|
a61af66fc99e Initial load duke parents: diff changeset	728 (is_top_frame && (exec_mode == Unpack_exception) && iframe->interpreter_frame_expression_stack_size() == 0) \|\|
a61af66fc99e Initial load duke parents: diff changeset	729 (is_top_frame && (exec_mode == Unpack_uncommon_trap \|\| exec_mode == Unpack_reexecute) &&
a61af66fc99e Initial load duke parents: diff changeset	730 (iframe->interpreter_frame_expression_stack_size() == mask.expression_stack_size() + cur_invoke_parameter_size))
a61af66fc99e Initial load duke parents: diff changeset	731 )) {
a61af66fc99e Initial load duke parents: diff changeset	732 ttyLocker ttyl;
a61af66fc99e Initial load duke parents: diff changeset	733
a61af66fc99e Initial load duke parents: diff changeset	734 // Print out some information that will help us debug the problem
a61af66fc99e Initial load duke parents: diff changeset	735 tty->print_cr("Wrong number of expression stack elements during deoptimization");
a61af66fc99e Initial load duke parents: diff changeset	736 tty->print_cr(" Error occurred while verifying frame %d (0..%d, 0 is topmost)", i, cur_array->frames() - 1);
a61af66fc99e Initial load duke parents: diff changeset	737 tty->print_cr(" Fabricated interpreter frame had %d expression stack elements",
a61af66fc99e Initial load duke parents: diff changeset	738 iframe->interpreter_frame_expression_stack_size());
a61af66fc99e Initial load duke parents: diff changeset	739 tty->print_cr(" Interpreter oop map had %d expression stack elements", mask.expression_stack_size());
a61af66fc99e Initial load duke parents: diff changeset	740 tty->print_cr(" try_next_mask = %d", try_next_mask);
a61af66fc99e Initial load duke parents: diff changeset	741 tty->print_cr(" next_mask_expression_stack_size = %d", next_mask_expression_stack_size);
a61af66fc99e Initial load duke parents: diff changeset	742 tty->print_cr(" callee_size_of_parameters = %d", callee_size_of_parameters);
a61af66fc99e Initial load duke parents: diff changeset	743 tty->print_cr(" callee_max_locals = %d", callee_max_locals);
a61af66fc99e Initial load duke parents: diff changeset	744 tty->print_cr(" top_frame_expression_stack_adjustment = %d", top_frame_expression_stack_adjustment);
a61af66fc99e Initial load duke parents: diff changeset	745 tty->print_cr(" exec_mode = %d", exec_mode);
a61af66fc99e Initial load duke parents: diff changeset	746 tty->print_cr(" cur_invoke_parameter_size = %d", cur_invoke_parameter_size);
a61af66fc99e Initial load duke parents: diff changeset	747 tty->print_cr(" Thread = " INTPTR_FORMAT ", thread ID = " UINTX_FORMAT, thread, thread->osthread()->thread_id());
a61af66fc99e Initial load duke parents: diff changeset	748 tty->print_cr(" Interpreted frames:");
a61af66fc99e Initial load duke parents: diff changeset	749 for (int k = 0; k < cur_array->frames(); k++) {
a61af66fc99e Initial load duke parents: diff changeset	750 vframeArrayElement* el = cur_array->element(k);
a61af66fc99e Initial load duke parents: diff changeset	751 tty->print_cr(" %s (bci %d)", el->method()->name_and_sig_as_C_string(), el->bci());
a61af66fc99e Initial load duke parents: diff changeset	752 }
a61af66fc99e Initial load duke parents: diff changeset	753 cur_array->print_on_2(tty);
a61af66fc99e Initial load duke parents: diff changeset	754 guarantee(false, "wrong number of expression stack elements during deopt");
a61af66fc99e Initial load duke parents: diff changeset	755 }
a61af66fc99e Initial load duke parents: diff changeset	756 VerifyOopClosure verify;
7179 d0aa87f04bd5 8003720: NPG: Method in interpreter stack frame can be deallocated stefank parents: 6940 diff changeset	757 iframe->oops_interpreted_do(&verify, NULL, &rm, false);
0 a61af66fc99e Initial load duke parents: diff changeset	758 callee_size_of_parameters = mh->size_of_parameters();
a61af66fc99e Initial load duke parents: diff changeset	759 callee_max_locals = mh->max_locals();
a61af66fc99e Initial load duke parents: diff changeset	760 is_top_frame = false;
a61af66fc99e Initial load duke parents: diff changeset	761 }
a61af66fc99e Initial load duke parents: diff changeset	762 }
a61af66fc99e Initial load duke parents: diff changeset	763 #endif /* !PRODUCT */
a61af66fc99e Initial load duke parents: diff changeset	764
a61af66fc99e Initial load duke parents: diff changeset	765
a61af66fc99e Initial load duke parents: diff changeset	766 return bt;
a61af66fc99e Initial load duke parents: diff changeset	767 JRT_END
a61af66fc99e Initial load duke parents: diff changeset	768
a61af66fc99e Initial load duke parents: diff changeset	769
a61af66fc99e Initial load duke parents: diff changeset	770 int Deoptimization::deoptimize_dependents() {
a61af66fc99e Initial load duke parents: diff changeset	771 Threads::deoptimized_wrt_marked_nmethods();
a61af66fc99e Initial load duke parents: diff changeset	772 return 0;
a61af66fc99e Initial load duke parents: diff changeset	773 }
a61af66fc99e Initial load duke parents: diff changeset	774
a61af66fc99e Initial load duke parents: diff changeset	775
4978 99d3d8a72252 More ifdef GRAAL usage. Thomas Wuerthinger <thomas.wuerthinger@oracle.com> parents: 4970 diff changeset	776 #if defined(COMPILER2) \|\| defined(GRAAL)
0 a61af66fc99e Initial load duke parents: diff changeset	777 bool Deoptimization::realloc_objects(JavaThread* thread, frame* fr, GrowableArray<ScopeValue> objects, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	778 Handle pending_exception(thread->pending_exception());
a61af66fc99e Initial load duke parents: diff changeset	779 const char* exception_file = thread->exception_file();
a61af66fc99e Initial load duke parents: diff changeset	780 int exception_line = thread->exception_line();
a61af66fc99e Initial load duke parents: diff changeset	781 thread->clear_pending_exception();
a61af66fc99e Initial load duke parents: diff changeset	782
a61af66fc99e Initial load duke parents: diff changeset	783 for (int i = 0; i < objects->length(); i++) {
a61af66fc99e Initial load duke parents: diff changeset	784 assert(objects->at(i)->is_object(), "invalid debug information");
a61af66fc99e Initial load duke parents: diff changeset	785 ObjectValue* sv = (ObjectValue*) objects->at(i);
a61af66fc99e Initial load duke parents: diff changeset	786
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	787 KlassHandle k(java_lang_Class::as_Klass(sv->klass()->as_ConstantOopReadValue()->value()()));
0 a61af66fc99e Initial load duke parents: diff changeset	788 oop obj = NULL;
a61af66fc99e Initial load duke parents: diff changeset	789
a61af66fc99e Initial load duke parents: diff changeset	790 if (k->oop_is_instance()) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	791 InstanceKlass* ik = InstanceKlass::cast(k());
0 a61af66fc99e Initial load duke parents: diff changeset	792 obj = ik->allocate_instance(CHECK_(false));
a61af66fc99e Initial load duke parents: diff changeset	793 } else if (k->oop_is_typeArray()) {
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	794 TypeArrayKlass* ak = TypeArrayKlass::cast(k());
0 a61af66fc99e Initial load duke parents: diff changeset	795 assert(sv->field_size() % type2size[ak->element_type()] == 0, "non-integral array length");
a61af66fc99e Initial load duke parents: diff changeset	796 int len = sv->field_size() / type2size[ak->element_type()];
a61af66fc99e Initial load duke parents: diff changeset	797 obj = ak->allocate(len, CHECK_(false));
a61af66fc99e Initial load duke parents: diff changeset	798 } else if (k->oop_is_objArray()) {
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	799 ObjArrayKlass* ak = ObjArrayKlass::cast(k());
0 a61af66fc99e Initial load duke parents: diff changeset	800 obj = ak->allocate(sv->field_size(), CHECK_(false));
a61af66fc99e Initial load duke parents: diff changeset	801 }
a61af66fc99e Initial load duke parents: diff changeset	802
a61af66fc99e Initial load duke parents: diff changeset	803 assert(obj != NULL, "allocation failed");
a61af66fc99e Initial load duke parents: diff changeset	804 assert(sv->value().is_null(), "redundant reallocation");
a61af66fc99e Initial load duke parents: diff changeset	805 sv->set_value(obj);
a61af66fc99e Initial load duke parents: diff changeset	806 }
a61af66fc99e Initial load duke parents: diff changeset	807
a61af66fc99e Initial load duke parents: diff changeset	808 if (pending_exception.not_null()) {
a61af66fc99e Initial load duke parents: diff changeset	809 thread->set_pending_exception(pending_exception(), exception_file, exception_line);
a61af66fc99e Initial load duke parents: diff changeset	810 }
a61af66fc99e Initial load duke parents: diff changeset	811
a61af66fc99e Initial load duke parents: diff changeset	812 return true;
a61af66fc99e Initial load duke parents: diff changeset	813 }
a61af66fc99e Initial load duke parents: diff changeset	814
a61af66fc99e Initial load duke parents: diff changeset	815 // restore elements of an eliminated type array
a61af66fc99e Initial load duke parents: diff changeset	816 void Deoptimization::reassign_type_array_elements(frame* fr, RegisterMap* reg_map, ObjectValue* sv, typeArrayOop obj, BasicType type) {
a61af66fc99e Initial load duke parents: diff changeset	817 int index = 0;
44 52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	818 intptr_t val;
0 a61af66fc99e Initial load duke parents: diff changeset	819
a61af66fc99e Initial load duke parents: diff changeset	820 for (int i = 0; i < sv->field_size(); i++) {
a61af66fc99e Initial load duke parents: diff changeset	821 StackValue* value = StackValue::create_stack_value(fr, reg_map, sv->field_at(i));
a61af66fc99e Initial load duke parents: diff changeset	822 switch(type) {
44 52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	823 case T_LONG: case T_DOUBLE: {
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	824 assert(value->type() == T_INT, "Agreement.");
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	825 StackValue* low =
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	826 StackValue::create_stack_value(fr, reg_map, sv->field_at(++i));
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	827 #ifdef _LP64
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	828 jlong res = (jlong)low->get_int();
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	829 #else
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	830 #ifdef SPARC
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	831 // For SPARC we have to swap high and low words.
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	832 jlong res = jlong_from((jint)low->get_int(), (jint)value->get_int());
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	833 #else
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	834 jlong res = jlong_from((jint)value->get_int(), (jint)low->get_int());
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	835 #endif //SPARC
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	836 #endif
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	837 obj->long_at_put(index, res);
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	838 break;
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	839 }
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	840
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	841 // Have to cast to INT (32 bits) pointer to avoid little/big-endian problem.
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	842 case T_INT: case T_FLOAT: // 4 bytes.
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	843 assert(value->type() == T_INT, "Agreement.");
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	844 val = value->get_int();
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	845 obj->int_at_put(index, (jint)((jint)&val));
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	846 break;
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	847
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	848 case T_SHORT: case T_CHAR: // 2 bytes
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	849 assert(value->type() == T_INT, "Agreement.");
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	850 val = value->get_int();
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	851 obj->short_at_put(index, (jshort)((jint)&val));
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	852 break;
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	853
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	854 case T_BOOLEAN: case T_BYTE: // 1 byte
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	855 assert(value->type() == T_INT, "Agreement.");
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	856 val = value->get_int();
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	857 obj->bool_at_put(index, (jboolean)((jint)&val));
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	858 break;
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	859
0 a61af66fc99e Initial load duke parents: diff changeset	860 default:
a61af66fc99e Initial load duke parents: diff changeset	861 ShouldNotReachHere();
a61af66fc99e Initial load duke parents: diff changeset	862 }
a61af66fc99e Initial load duke parents: diff changeset	863 index++;
a61af66fc99e Initial load duke parents: diff changeset	864 }
a61af66fc99e Initial load duke parents: diff changeset	865 }
a61af66fc99e Initial load duke parents: diff changeset	866
a61af66fc99e Initial load duke parents: diff changeset	867 // restore fields of an eliminated object array
a61af66fc99e Initial load duke parents: diff changeset	868 void Deoptimization::reassign_object_array_elements(frame* fr, RegisterMap* reg_map, ObjectValue* sv, objArrayOop obj) {
a61af66fc99e Initial load duke parents: diff changeset	869 for (int i = 0; i < sv->field_size(); i++) {
a61af66fc99e Initial load duke parents: diff changeset	870 StackValue* value = StackValue::create_stack_value(fr, reg_map, sv->field_at(i));
a61af66fc99e Initial load duke parents: diff changeset	871 assert(value->type() == T_OBJECT, "object element expected");
a61af66fc99e Initial load duke parents: diff changeset	872 obj->obj_at_put(i, value->get_obj()());
a61af66fc99e Initial load duke parents: diff changeset	873 }
a61af66fc99e Initial load duke parents: diff changeset	874 }
a61af66fc99e Initial load duke parents: diff changeset	875
7222 720925633b3a fixes after merge Christian Haeubl <haeubl@ssw.jku.at> parents: 7137 diff changeset	876 class ReassignedField {
720925633b3a fixes after merge Christian Haeubl <haeubl@ssw.jku.at> parents: 7137 diff changeset	877 public:
720925633b3a fixes after merge Christian Haeubl <haeubl@ssw.jku.at> parents: 7137 diff changeset	878 int _offset;
720925633b3a fixes after merge Christian Haeubl <haeubl@ssw.jku.at> parents: 7137 diff changeset	879 BasicType _type;
720925633b3a fixes after merge Christian Haeubl <haeubl@ssw.jku.at> parents: 7137 diff changeset	880 public:
720925633b3a fixes after merge Christian Haeubl <haeubl@ssw.jku.at> parents: 7137 diff changeset	881 ReassignedField() {
720925633b3a fixes after merge Christian Haeubl <haeubl@ssw.jku.at> parents: 7137 diff changeset	882 _offset = 0;
720925633b3a fixes after merge Christian Haeubl <haeubl@ssw.jku.at> parents: 7137 diff changeset	883 _type = T_ILLEGAL;
720925633b3a fixes after merge Christian Haeubl <haeubl@ssw.jku.at> parents: 7137 diff changeset	884 }
720925633b3a fixes after merge Christian Haeubl <haeubl@ssw.jku.at> parents: 7137 diff changeset	885 };
7137 a818db37b7be unify object reallocation code for c2 and Graal Lukas Stadler <lukas.stadler@jku.at> parents: 7084 diff changeset	886
a818db37b7be unify object reallocation code for c2 and Graal Lukas Stadler <lukas.stadler@jku.at> parents: 7084 diff changeset	887 int compare(ReassignedField* left, ReassignedField* right) {
7222 720925633b3a fixes after merge Christian Haeubl <haeubl@ssw.jku.at> parents: 7137 diff changeset	888 return left->_offset - right->_offset;
7137 a818db37b7be unify object reallocation code for c2 and Graal Lukas Stadler <lukas.stadler@jku.at> parents: 7084 diff changeset	889 }
a818db37b7be unify object reallocation code for c2 and Graal Lukas Stadler <lukas.stadler@jku.at> parents: 7084 diff changeset	890
6948 e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 6428 6940 diff changeset	891 // Restore fields of an eliminated instance object using the same field order
7084 9ba90252ce08 HotSpotResolvedJavaType is now the HotSpot implementation of ResolvedJavaType, Gilles Duboscq <duboscq@ssw.jku.at> parents: 6948 diff changeset	892 // returned by HotSpotResolvedObjectType.getInstanceFields(true)
6948 e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 6428 6940 diff changeset	893 static int reassign_fields_by_klass(InstanceKlass* klass, frame* fr, RegisterMap* reg_map, ObjectValue* sv, int svIndex, oop obj) {
e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 6428 6940 diff changeset	894 if (klass->superklass() != NULL) {
e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 6428 6940 diff changeset	895 svIndex = reassign_fields_by_klass(klass->superklass(), fr, reg_map, sv, svIndex, obj);
e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 6428 6940 diff changeset	896 }
e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 6428 6940 diff changeset	897
7137 a818db37b7be unify object reallocation code for c2 and Graal Lukas Stadler <lukas.stadler@jku.at> parents: 7084 diff changeset	898 GrowableArray<ReassignedField>* fields = new GrowableArray<ReassignedField>();
6948 e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 6428 6940 diff changeset	899 for (AllFieldStream fs(klass); !fs.done(); fs.next()) {
7137 a818db37b7be unify object reallocation code for c2 and Graal Lukas Stadler <lukas.stadler@jku.at> parents: 7084 diff changeset	900 if (!fs.access_flags().is_static()) {
a818db37b7be unify object reallocation code for c2 and Graal Lukas Stadler <lukas.stadler@jku.at> parents: 7084 diff changeset	901 ReassignedField field;
7222 720925633b3a fixes after merge Christian Haeubl <haeubl@ssw.jku.at> parents: 7137 diff changeset	902 field._offset = fs.offset();
720925633b3a fixes after merge Christian Haeubl <haeubl@ssw.jku.at> parents: 7137 diff changeset	903 field._type = FieldType::basic_type(fs.signature());
7137 a818db37b7be unify object reallocation code for c2 and Graal Lukas Stadler <lukas.stadler@jku.at> parents: 7084 diff changeset	904 fields->append(field);
6948 e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 6428 6940 diff changeset	905 }
7137 a818db37b7be unify object reallocation code for c2 and Graal Lukas Stadler <lukas.stadler@jku.at> parents: 7084 diff changeset	906 }
a818db37b7be unify object reallocation code for c2 and Graal Lukas Stadler <lukas.stadler@jku.at> parents: 7084 diff changeset	907 fields->sort(compare);
a818db37b7be unify object reallocation code for c2 and Graal Lukas Stadler <lukas.stadler@jku.at> parents: 7084 diff changeset	908 for (int i = 0; i < fields->length(); i++) {
6948 e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 6428 6940 diff changeset	909 intptr_t val;
e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 6428 6940 diff changeset	910 StackValue* value = StackValue::create_stack_value(fr, reg_map, sv->field_at(svIndex));
7222 720925633b3a fixes after merge Christian Haeubl <haeubl@ssw.jku.at> parents: 7137 diff changeset	911 int offset = fields->at(i)._offset;
720925633b3a fixes after merge Christian Haeubl <haeubl@ssw.jku.at> parents: 7137 diff changeset	912 BasicType type = fields->at(i)._type;
6948 e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 6428 6940 diff changeset	913 switch (type) {
e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 6428 6940 diff changeset	914 case T_OBJECT: case T_ARRAY:
e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 6428 6940 diff changeset	915 assert(value->type() == T_OBJECT, "Agreement.");
e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 6428 6940 diff changeset	916 obj->obj_field_put(offset, value->get_obj()());
e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 6428 6940 diff changeset	917 break;
e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 6428 6940 diff changeset	918
e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 6428 6940 diff changeset	919 case T_LONG: case T_DOUBLE: {
e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 6428 6940 diff changeset	920 assert(value->type() == T_INT, "Agreement.");
e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 6428 6940 diff changeset	921 StackValue* low = StackValue::create_stack_value(fr, reg_map, sv->field_at(++svIndex));
e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 6428 6940 diff changeset	922 #ifdef _LP64
e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 6428 6940 diff changeset	923 jlong res = (jlong)low->get_int();
e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 6428 6940 diff changeset	924 #else
e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 6428 6940 diff changeset	925 #ifdef SPARC
e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 6428 6940 diff changeset	926 // For SPARC we have to swap high and low words.
e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 6428 6940 diff changeset	927 jlong res = jlong_from((jint)low->get_int(), (jint)value->get_int());
e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 6428 6940 diff changeset	928 #else
e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 6428 6940 diff changeset	929 jlong res = jlong_from((jint)value->get_int(), (jint)low->get_int());
e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 6428 6940 diff changeset	930 #endif //SPARC
e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 6428 6940 diff changeset	931 #endif
e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 6428 6940 diff changeset	932 obj->long_field_put(offset, res);
e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 6428 6940 diff changeset	933 break;
e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 6428 6940 diff changeset	934 }
e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 6428 6940 diff changeset	935 // Have to cast to INT (32 bits) pointer to avoid little/big-endian problem.
e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 6428 6940 diff changeset	936 case T_INT: case T_FLOAT: // 4 bytes.
e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 6428 6940 diff changeset	937 assert(value->type() == T_INT, "Agreement.");
e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 6428 6940 diff changeset	938 val = value->get_int();
e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 6428 6940 diff changeset	939 obj->int_field_put(offset, (jint)((jint)&val));
e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 6428 6940 diff changeset	940 break;
e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 6428 6940 diff changeset	941
e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 6428 6940 diff changeset	942 case T_SHORT: case T_CHAR: // 2 bytes
e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 6428 6940 diff changeset	943 assert(value->type() == T_INT, "Agreement.");
e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 6428 6940 diff changeset	944 val = value->get_int();
e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 6428 6940 diff changeset	945 obj->short_field_put(offset, (jshort)((jint)&val));
e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 6428 6940 diff changeset	946 break;
e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 6428 6940 diff changeset	947
e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 6428 6940 diff changeset	948 case T_BOOLEAN: case T_BYTE: // 1 byte
e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 6428 6940 diff changeset	949 assert(value->type() == T_INT, "Agreement.");
e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 6428 6940 diff changeset	950 val = value->get_int();
e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 6428 6940 diff changeset	951 obj->bool_field_put(offset, (jboolean)((jint)&val));
e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 6428 6940 diff changeset	952 break;
e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 6428 6940 diff changeset	953
e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 6428 6940 diff changeset	954 default:
e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 6428 6940 diff changeset	955 ShouldNotReachHere();
e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 6428 6940 diff changeset	956 }
e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 6428 6940 diff changeset	957 svIndex++;
e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 6428 6940 diff changeset	958 }
e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 6428 6940 diff changeset	959 return svIndex;
e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 6428 6940 diff changeset	960 }
0 a61af66fc99e Initial load duke parents: diff changeset	961
a61af66fc99e Initial load duke parents: diff changeset	962 // restore fields of all eliminated objects and arrays
a61af66fc99e Initial load duke parents: diff changeset	963 void Deoptimization::reassign_fields(frame* fr, RegisterMap* reg_map, GrowableArray<ScopeValue> objects) {
a61af66fc99e Initial load duke parents: diff changeset	964 for (int i = 0; i < objects->length(); i++) {
a61af66fc99e Initial load duke parents: diff changeset	965 ObjectValue* sv = (ObjectValue*) objects->at(i);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	966 KlassHandle k(java_lang_Class::as_Klass(sv->klass()->as_ConstantOopReadValue()->value()()));
0 a61af66fc99e Initial load duke parents: diff changeset	967 Handle obj = sv->value();
a61af66fc99e Initial load duke parents: diff changeset	968 assert(obj.not_null(), "reallocation was missed");
4668 3dbcd1013cc8 added flag PrintDeoptimizationDetails Christian Haeubl <christian.haeubl@oracle.com> parents: 4661 diff changeset	969 if (PrintDeoptimizationDetails) {
3134 4b63eb1197ca Various fixes around escape analysis. Thomas Wuerthinger <thomas@wuerthinger.net> parents: 3090 diff changeset	970 tty->print_cr("reassign fields for object of type %s!", k->name()->as_C_string());
4b63eb1197ca Various fixes around escape analysis. Thomas Wuerthinger <thomas@wuerthinger.net> parents: 3090 diff changeset	971 }
0 a61af66fc99e Initial load duke parents: diff changeset	972
a61af66fc99e Initial load duke parents: diff changeset	973 if (k->oop_is_instance()) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	974 InstanceKlass* ik = InstanceKlass::cast(k());
6948 e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 6428 6940 diff changeset	975 reassign_fields_by_klass(ik, fr, reg_map, sv, 0, obj());
0 a61af66fc99e Initial load duke parents: diff changeset	976 } else if (k->oop_is_typeArray()) {
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	977 TypeArrayKlass* ak = TypeArrayKlass::cast(k());
0 a61af66fc99e Initial load duke parents: diff changeset	978 reassign_type_array_elements(fr, reg_map, sv, (typeArrayOop) obj(), ak->element_type());
a61af66fc99e Initial load duke parents: diff changeset	979 } else if (k->oop_is_objArray()) {
a61af66fc99e Initial load duke parents: diff changeset	980 reassign_object_array_elements(fr, reg_map, sv, (objArrayOop) obj());
a61af66fc99e Initial load duke parents: diff changeset	981 }
a61af66fc99e Initial load duke parents: diff changeset	982 }
a61af66fc99e Initial load duke parents: diff changeset	983 }
a61af66fc99e Initial load duke parents: diff changeset	984
a61af66fc99e Initial load duke parents: diff changeset	985
a61af66fc99e Initial load duke parents: diff changeset	986 // relock objects for which synchronization was eliminated
83 d3cd40645d0d 6681646: Relocking of a scalar replaced object during deoptimization is broken kvn parents: 44 diff changeset	987 void Deoptimization::relock_objects(GrowableArray<MonitorInfo> monitors, JavaThread* thread) {
0 a61af66fc99e Initial load duke parents: diff changeset	988 for (int i = 0; i < monitors->length(); i++) {
83 d3cd40645d0d 6681646: Relocking of a scalar replaced object during deoptimization is broken kvn parents: 44 diff changeset	989 MonitorInfo* mon_info = monitors->at(i);
d3cd40645d0d 6681646: Relocking of a scalar replaced object during deoptimization is broken kvn parents: 44 diff changeset	990 if (mon_info->eliminated()) {
d3cd40645d0d 6681646: Relocking of a scalar replaced object during deoptimization is broken kvn parents: 44 diff changeset	991 assert(mon_info->owner() != NULL, "reallocation was missed");
d3cd40645d0d 6681646: Relocking of a scalar replaced object during deoptimization is broken kvn parents: 44 diff changeset	992 Handle obj = Handle(mon_info->owner());
d3cd40645d0d 6681646: Relocking of a scalar replaced object during deoptimization is broken kvn parents: 44 diff changeset	993 markOop mark = obj->mark();
d3cd40645d0d 6681646: Relocking of a scalar replaced object during deoptimization is broken kvn parents: 44 diff changeset	994 if (UseBiasedLocking && mark->has_bias_pattern()) {
d3cd40645d0d 6681646: Relocking of a scalar replaced object during deoptimization is broken kvn parents: 44 diff changeset	995 // New allocated objects may have the mark set to anonymously biased.
d3cd40645d0d 6681646: Relocking of a scalar replaced object during deoptimization is broken kvn parents: 44 diff changeset	996 // Also the deoptimized method may called methods with synchronization
d3cd40645d0d 6681646: Relocking of a scalar replaced object during deoptimization is broken kvn parents: 44 diff changeset	997 // where the thread-local object is bias locked to the current thread.
d3cd40645d0d 6681646: Relocking of a scalar replaced object during deoptimization is broken kvn parents: 44 diff changeset	998 assert(mark->is_biased_anonymously() \|\|
d3cd40645d0d 6681646: Relocking of a scalar replaced object during deoptimization is broken kvn parents: 44 diff changeset	999 mark->biased_locker() == thread, "should be locked to current thread");
d3cd40645d0d 6681646: Relocking of a scalar replaced object during deoptimization is broken kvn parents: 44 diff changeset	1000 // Reset mark word to unbiased prototype.
d3cd40645d0d 6681646: Relocking of a scalar replaced object during deoptimization is broken kvn parents: 44 diff changeset	1001 markOop unbiased_prototype = markOopDesc::prototype()->set_age(mark->age());
d3cd40645d0d 6681646: Relocking of a scalar replaced object during deoptimization is broken kvn parents: 44 diff changeset	1002 obj->set_mark(unbiased_prototype);
d3cd40645d0d 6681646: Relocking of a scalar replaced object during deoptimization is broken kvn parents: 44 diff changeset	1003 }
d3cd40645d0d 6681646: Relocking of a scalar replaced object during deoptimization is broken kvn parents: 44 diff changeset	1004 BasicLock* lock = mon_info->lock();
d3cd40645d0d 6681646: Relocking of a scalar replaced object during deoptimization is broken kvn parents: 44 diff changeset	1005 ObjectSynchronizer::slow_enter(obj, lock, thread);
0 a61af66fc99e Initial load duke parents: diff changeset	1006 }
83 d3cd40645d0d 6681646: Relocking of a scalar replaced object during deoptimization is broken kvn parents: 44 diff changeset	1007 assert(mon_info->owner()->is_locked(), "object must be locked now");
0 a61af66fc99e Initial load duke parents: diff changeset	1008 }
a61af66fc99e Initial load duke parents: diff changeset	1009 }
a61af66fc99e Initial load duke parents: diff changeset	1010
a61af66fc99e Initial load duke parents: diff changeset	1011
a61af66fc99e Initial load duke parents: diff changeset	1012 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	1013 // print information about reallocated objects
a61af66fc99e Initial load duke parents: diff changeset	1014 void Deoptimization::print_objects(GrowableArray<ScopeValue> objects) {
a61af66fc99e Initial load duke parents: diff changeset	1015 fieldDescriptor fd;
a61af66fc99e Initial load duke parents: diff changeset	1016
a61af66fc99e Initial load duke parents: diff changeset	1017 for (int i = 0; i < objects->length(); i++) {
a61af66fc99e Initial load duke parents: diff changeset	1018 ObjectValue* sv = (ObjectValue*) objects->at(i);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1019 KlassHandle k(java_lang_Class::as_Klass(sv->klass()->as_ConstantOopReadValue()->value()()));
0 a61af66fc99e Initial load duke parents: diff changeset	1020 Handle obj = sv->value();
a61af66fc99e Initial load duke parents: diff changeset	1021
a61af66fc99e Initial load duke parents: diff changeset	1022 tty->print(" object <" INTPTR_FORMAT "> of type ", sv->value()());
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1023 k->print_value();
0 a61af66fc99e Initial load duke parents: diff changeset	1024 tty->print(" allocated (%d bytes)", obj->size() * HeapWordSize);
a61af66fc99e Initial load duke parents: diff changeset	1025 tty->cr();
a61af66fc99e Initial load duke parents: diff changeset	1026
a61af66fc99e Initial load duke parents: diff changeset	1027 if (Verbose) {
a61af66fc99e Initial load duke parents: diff changeset	1028 k->oop_print_on(obj(), tty);
a61af66fc99e Initial load duke parents: diff changeset	1029 }
a61af66fc99e Initial load duke parents: diff changeset	1030 }
a61af66fc99e Initial load duke parents: diff changeset	1031 }
a61af66fc99e Initial load duke parents: diff changeset	1032 #endif
4978 99d3d8a72252 More ifdef GRAAL usage. Thomas Wuerthinger <thomas.wuerthinger@oracle.com> parents: 4970 diff changeset	1033 #endif // COMPILER2 \|\| GRAAL
0 a61af66fc99e Initial load duke parents: diff changeset	1034
a61af66fc99e Initial load duke parents: diff changeset	1035 vframeArray* Deoptimization::create_vframeArray(JavaThread* thread, frame fr, RegisterMap reg_map, GrowableArray<compiledVFrame>* chunk) {
4872 aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4777 diff changeset	1036 Events::log(thread, "DEOPT PACKING pc=" INTPTR_FORMAT " sp=" INTPTR_FORMAT, fr.pc(), fr.sp());
0 a61af66fc99e Initial load duke parents: diff changeset	1037
a61af66fc99e Initial load duke parents: diff changeset	1038 #ifndef PRODUCT
4668 3dbcd1013cc8 added flag PrintDeoptimizationDetails Christian Haeubl <christian.haeubl@oracle.com> parents: 4661 diff changeset	1039 if (PrintDeoptimizationDetails) {
0 a61af66fc99e Initial load duke parents: diff changeset	1040 ttyLocker ttyl;
a61af66fc99e Initial load duke parents: diff changeset	1041 tty->print("DEOPT PACKING thread " INTPTR_FORMAT " ", thread);
a61af66fc99e Initial load duke parents: diff changeset	1042 fr.print_on(tty);
a61af66fc99e Initial load duke parents: diff changeset	1043 tty->print_cr(" Virtual frames (innermost first):");
a61af66fc99e Initial load duke parents: diff changeset	1044 for (int index = 0; index < chunk->length(); index++) {
a61af66fc99e Initial load duke parents: diff changeset	1045 compiledVFrame* vf = chunk->at(index);
a61af66fc99e Initial load duke parents: diff changeset	1046 tty->print(" %2d - ", index);
a61af66fc99e Initial load duke parents: diff changeset	1047 vf->print_value();
a61af66fc99e Initial load duke parents: diff changeset	1048 int bci = chunk->at(index)->raw_bci();
a61af66fc99e Initial load duke parents: diff changeset	1049 const char* code_name;
a61af66fc99e Initial load duke parents: diff changeset	1050 if (bci == SynchronizationEntryBCI) {
a61af66fc99e Initial load duke parents: diff changeset	1051 code_name = "sync entry";
a61af66fc99e Initial load duke parents: diff changeset	1052 } else {
2142 8012aa3ccede 4926272: methodOopDesc::method_from_bcp is unsafe never parents: 1972 diff changeset	1053 Bytecodes::Code code = vf->method()->code_at(bci);
0 a61af66fc99e Initial load duke parents: diff changeset	1054 code_name = Bytecodes::name(code);
a61af66fc99e Initial load duke parents: diff changeset	1055 }
a61af66fc99e Initial load duke parents: diff changeset	1056 tty->print(" - %s", code_name);
a61af66fc99e Initial load duke parents: diff changeset	1057 tty->print_cr(" @ bci %d ", bci);
a61af66fc99e Initial load duke parents: diff changeset	1058 if (Verbose) {
a61af66fc99e Initial load duke parents: diff changeset	1059 vf->print();
a61af66fc99e Initial load duke parents: diff changeset	1060 tty->cr();
a61af66fc99e Initial load duke parents: diff changeset	1061 }
a61af66fc99e Initial load duke parents: diff changeset	1062 }
a61af66fc99e Initial load duke parents: diff changeset	1063 }
a61af66fc99e Initial load duke parents: diff changeset	1064 #endif
a61af66fc99e Initial load duke parents: diff changeset	1065
a61af66fc99e Initial load duke parents: diff changeset	1066 // Register map for next frame (used for stack crawl). We capture
a61af66fc99e Initial load duke parents: diff changeset	1067 // the state of the deopt'ing frame's caller. Thus if we need to
a61af66fc99e Initial load duke parents: diff changeset	1068 // stuff a C2I adapter we can properly fill in the callee-save
a61af66fc99e Initial load duke parents: diff changeset	1069 // register locations.
a61af66fc99e Initial load duke parents: diff changeset	1070 frame caller = fr.sender(reg_map);
a61af66fc99e Initial load duke parents: diff changeset	1071 int frame_size = caller.sp() - fr.sp();
a61af66fc99e Initial load duke parents: diff changeset	1072
a61af66fc99e Initial load duke parents: diff changeset	1073 frame sender = caller;
a61af66fc99e Initial load duke parents: diff changeset	1074
a61af66fc99e Initial load duke parents: diff changeset	1075 // Since the Java thread being deoptimized will eventually adjust it's own stack,
a61af66fc99e Initial load duke parents: diff changeset	1076 // the vframeArray containing the unpacking information is allocated in the C heap.
a61af66fc99e Initial load duke parents: diff changeset	1077 // For Compiler1, the caller of the deoptimized frame is saved for use by unpack_frames().
a61af66fc99e Initial load duke parents: diff changeset	1078 vframeArray* array = vframeArray::allocate(thread, frame_size, chunk, reg_map, sender, caller, fr);
a61af66fc99e Initial load duke parents: diff changeset	1079
a61af66fc99e Initial load duke parents: diff changeset	1080 // Compare the vframeArray to the collected vframes
a61af66fc99e Initial load duke parents: diff changeset	1081 assert(array->structural_compare(thread, chunk), "just checking");
a61af66fc99e Initial load duke parents: diff changeset	1082
a61af66fc99e Initial load duke parents: diff changeset	1083 #ifndef PRODUCT
4668 3dbcd1013cc8 added flag PrintDeoptimizationDetails Christian Haeubl <christian.haeubl@oracle.com> parents: 4661 diff changeset	1084 if (PrintDeoptimizationDetails) {
0 a61af66fc99e Initial load duke parents: diff changeset	1085 ttyLocker ttyl;
a61af66fc99e Initial load duke parents: diff changeset	1086 tty->print_cr(" Created vframeArray " INTPTR_FORMAT, array);
a61af66fc99e Initial load duke parents: diff changeset	1087 }
a61af66fc99e Initial load duke parents: diff changeset	1088 #endif // PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	1089
a61af66fc99e Initial load duke parents: diff changeset	1090 return array;
a61af66fc99e Initial load duke parents: diff changeset	1091 }
a61af66fc99e Initial load duke parents: diff changeset	1092
a61af66fc99e Initial load duke parents: diff changeset	1093
a61af66fc99e Initial load duke parents: diff changeset	1094 static void collect_monitors(compiledVFrame* cvf, GrowableArray<Handle>* objects_to_revoke) {
a61af66fc99e Initial load duke parents: diff changeset	1095 GrowableArray<MonitorInfo> monitors = cvf->monitors();
a61af66fc99e Initial load duke parents: diff changeset	1096 for (int i = 0; i < monitors->length(); i++) {
a61af66fc99e Initial load duke parents: diff changeset	1097 MonitorInfo* mon_info = monitors->at(i);
818 b109e761e927 6837472: com/sun/jdi/MonitorFrameInfo.java fails with AggressiveOpts in 6u14 kvn parents: 196 diff changeset	1098 if (!mon_info->eliminated() && mon_info->owner() != NULL) {
0 a61af66fc99e Initial load duke parents: diff changeset	1099 objects_to_revoke->append(Handle(mon_info->owner()));
a61af66fc99e Initial load duke parents: diff changeset	1100 }
a61af66fc99e Initial load duke parents: diff changeset	1101 }
a61af66fc99e Initial load duke parents: diff changeset	1102 }
a61af66fc99e Initial load duke parents: diff changeset	1103
a61af66fc99e Initial load duke parents: diff changeset	1104
a61af66fc99e Initial load duke parents: diff changeset	1105 void Deoptimization::revoke_biases_of_monitors(JavaThread* thread, frame fr, RegisterMap* map) {
a61af66fc99e Initial load duke parents: diff changeset	1106 if (!UseBiasedLocking) {
a61af66fc99e Initial load duke parents: diff changeset	1107 return;
a61af66fc99e Initial load duke parents: diff changeset	1108 }
a61af66fc99e Initial load duke parents: diff changeset	1109
a61af66fc99e Initial load duke parents: diff changeset	1110 GrowableArray<Handle>* objects_to_revoke = new GrowableArray<Handle>();
a61af66fc99e Initial load duke parents: diff changeset	1111
a61af66fc99e Initial load duke parents: diff changeset	1112 // Unfortunately we don't have a RegisterMap available in most of
a61af66fc99e Initial load duke parents: diff changeset	1113 // the places we want to call this routine so we need to walk the
a61af66fc99e Initial load duke parents: diff changeset	1114 // stack again to update the register map.
a61af66fc99e Initial load duke parents: diff changeset	1115 if (map == NULL \|\| !map->update_map()) {
a61af66fc99e Initial load duke parents: diff changeset	1116 StackFrameStream sfs(thread, true);
a61af66fc99e Initial load duke parents: diff changeset	1117 bool found = false;
a61af66fc99e Initial load duke parents: diff changeset	1118 while (!found && !sfs.is_done()) {
a61af66fc99e Initial load duke parents: diff changeset	1119 frame* cur = sfs.current();
a61af66fc99e Initial load duke parents: diff changeset	1120 sfs.next();
a61af66fc99e Initial load duke parents: diff changeset	1121 found = cur->id() == fr.id();
a61af66fc99e Initial load duke parents: diff changeset	1122 }
a61af66fc99e Initial load duke parents: diff changeset	1123 assert(found, "frame to be deoptimized not found on target thread's stack");
a61af66fc99e Initial load duke parents: diff changeset	1124 map = sfs.register_map();
a61af66fc99e Initial load duke parents: diff changeset	1125 }
a61af66fc99e Initial load duke parents: diff changeset	1126
a61af66fc99e Initial load duke parents: diff changeset	1127 vframe* vf = vframe::new_vframe(&fr, map, thread);
a61af66fc99e Initial load duke parents: diff changeset	1128 compiledVFrame* cvf = compiledVFrame::cast(vf);
a61af66fc99e Initial load duke parents: diff changeset	1129 // Revoke monitors' biases in all scopes
a61af66fc99e Initial load duke parents: diff changeset	1130 while (!cvf->is_top()) {
a61af66fc99e Initial load duke parents: diff changeset	1131 collect_monitors(cvf, objects_to_revoke);
a61af66fc99e Initial load duke parents: diff changeset	1132 cvf = compiledVFrame::cast(cvf->sender());
a61af66fc99e Initial load duke parents: diff changeset	1133 }
a61af66fc99e Initial load duke parents: diff changeset	1134 collect_monitors(cvf, objects_to_revoke);
a61af66fc99e Initial load duke parents: diff changeset	1135
a61af66fc99e Initial load duke parents: diff changeset	1136 if (SafepointSynchronize::is_at_safepoint()) {
a61af66fc99e Initial load duke parents: diff changeset	1137 BiasedLocking::revoke_at_safepoint(objects_to_revoke);
a61af66fc99e Initial load duke parents: diff changeset	1138 } else {
a61af66fc99e Initial load duke parents: diff changeset	1139 BiasedLocking::revoke(objects_to_revoke);
a61af66fc99e Initial load duke parents: diff changeset	1140 }
a61af66fc99e Initial load duke parents: diff changeset	1141 }
a61af66fc99e Initial load duke parents: diff changeset	1142
a61af66fc99e Initial load duke parents: diff changeset	1143
a61af66fc99e Initial load duke parents: diff changeset	1144 void Deoptimization::revoke_biases_of_monitors(CodeBlob* cb) {
a61af66fc99e Initial load duke parents: diff changeset	1145 if (!UseBiasedLocking) {
a61af66fc99e Initial load duke parents: diff changeset	1146 return;
a61af66fc99e Initial load duke parents: diff changeset	1147 }
a61af66fc99e Initial load duke parents: diff changeset	1148
a61af66fc99e Initial load duke parents: diff changeset	1149 assert(SafepointSynchronize::is_at_safepoint(), "must only be called from safepoint");
a61af66fc99e Initial load duke parents: diff changeset	1150 GrowableArray<Handle>* objects_to_revoke = new GrowableArray<Handle>();
a61af66fc99e Initial load duke parents: diff changeset	1151 for (JavaThread* jt = Threads::first(); jt != NULL ; jt = jt->next()) {
a61af66fc99e Initial load duke parents: diff changeset	1152 if (jt->has_last_Java_frame()) {
a61af66fc99e Initial load duke parents: diff changeset	1153 StackFrameStream sfs(jt, true);
a61af66fc99e Initial load duke parents: diff changeset	1154 while (!sfs.is_done()) {
a61af66fc99e Initial load duke parents: diff changeset	1155 frame* cur = sfs.current();
a61af66fc99e Initial load duke parents: diff changeset	1156 if (cb->contains(cur->pc())) {
a61af66fc99e Initial load duke parents: diff changeset	1157 vframe* vf = vframe::new_vframe(cur, sfs.register_map(), jt);
a61af66fc99e Initial load duke parents: diff changeset	1158 compiledVFrame* cvf = compiledVFrame::cast(vf);
a61af66fc99e Initial load duke parents: diff changeset	1159 // Revoke monitors' biases in all scopes
a61af66fc99e Initial load duke parents: diff changeset	1160 while (!cvf->is_top()) {
a61af66fc99e Initial load duke parents: diff changeset	1161 collect_monitors(cvf, objects_to_revoke);
a61af66fc99e Initial load duke parents: diff changeset	1162 cvf = compiledVFrame::cast(cvf->sender());
a61af66fc99e Initial load duke parents: diff changeset	1163 }
a61af66fc99e Initial load duke parents: diff changeset	1164 collect_monitors(cvf, objects_to_revoke);
a61af66fc99e Initial load duke parents: diff changeset	1165 }
a61af66fc99e Initial load duke parents: diff changeset	1166 sfs.next();
a61af66fc99e Initial load duke parents: diff changeset	1167 }
a61af66fc99e Initial load duke parents: diff changeset	1168 }
a61af66fc99e Initial load duke parents: diff changeset	1169 }
a61af66fc99e Initial load duke parents: diff changeset	1170 BiasedLocking::revoke_at_safepoint(objects_to_revoke);
a61af66fc99e Initial load duke parents: diff changeset	1171 }
a61af66fc99e Initial load duke parents: diff changeset	1172
a61af66fc99e Initial load duke parents: diff changeset	1173
5110 0ebca2e35ca5 more preparations for disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 5038 diff changeset	1174 void Deoptimization::deoptimize_single_frame(JavaThread* thread, frame fr, Deoptimization::DeoptReason reason) {
0 a61af66fc99e Initial load duke parents: diff changeset	1175 assert(fr.can_be_deoptimized(), "checking frame type");
a61af66fc99e Initial load duke parents: diff changeset	1176
5110 0ebca2e35ca5 more preparations for disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 5038 diff changeset	1177 gather_statistics(reason, Action_none, Bytecodes::_illegal);
0 a61af66fc99e Initial load duke parents: diff changeset	1178
a61af66fc99e Initial load duke parents: diff changeset	1179 // Patch the nmethod so that when execution returns to it we will
a61af66fc99e Initial load duke parents: diff changeset	1180 // deopt the execution state and return to the interpreter.
a61af66fc99e Initial load duke parents: diff changeset	1181 fr.deoptimize(thread);
a61af66fc99e Initial load duke parents: diff changeset	1182 }
a61af66fc99e Initial load duke parents: diff changeset	1183
5110 0ebca2e35ca5 more preparations for disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 5038 diff changeset	1184 void Deoptimization::deoptimize(JavaThread* thread, frame fr, RegisterMap *map, DeoptReason reason) {
0 a61af66fc99e Initial load duke parents: diff changeset	1185 // Deoptimize only if the frame comes from compile code.
a61af66fc99e Initial load duke parents: diff changeset	1186 // Do not deoptimize the frame which is already patched
a61af66fc99e Initial load duke parents: diff changeset	1187 // during the execution of the loops below.
a61af66fc99e Initial load duke parents: diff changeset	1188 if (!fr.is_compiled_frame() \|\| fr.is_deoptimized_frame()) {
a61af66fc99e Initial load duke parents: diff changeset	1189 return;
a61af66fc99e Initial load duke parents: diff changeset	1190 }
a61af66fc99e Initial load duke parents: diff changeset	1191 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	1192 DeoptimizationMarker dm;
a61af66fc99e Initial load duke parents: diff changeset	1193 if (UseBiasedLocking) {
a61af66fc99e Initial load duke parents: diff changeset	1194 revoke_biases_of_monitors(thread, fr, map);
a61af66fc99e Initial load duke parents: diff changeset	1195 }
5110 0ebca2e35ca5 more preparations for disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 5038 diff changeset	1196 deoptimize_single_frame(thread, fr, reason);
0 a61af66fc99e Initial load duke parents: diff changeset	1197
a61af66fc99e Initial load duke parents: diff changeset	1198 }
a61af66fc99e Initial load duke parents: diff changeset	1199
a61af66fc99e Initial load duke parents: diff changeset	1200
5110 0ebca2e35ca5 more preparations for disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 5038 diff changeset	1201 void Deoptimization::deoptimize_frame_internal(JavaThread* thread, intptr_t* id, DeoptReason reason) {
1905 ce6848d0666d 6968367: can_post_on_exceptions is still using VM_DeoptimizeFrame in some places never parents: 1814 diff changeset	1202 assert(thread == Thread::current() \|\| SafepointSynchronize::is_at_safepoint(),
ce6848d0666d 6968367: can_post_on_exceptions is still using VM_DeoptimizeFrame in some places never parents: 1814 diff changeset	1203 "can only deoptimize other thread at a safepoint");
0 a61af66fc99e Initial load duke parents: diff changeset	1204 // Compute frame and register map based on thread and sp.
a61af66fc99e Initial load duke parents: diff changeset	1205 RegisterMap reg_map(thread, UseBiasedLocking);
a61af66fc99e Initial load duke parents: diff changeset	1206 frame fr = thread->last_frame();
a61af66fc99e Initial load duke parents: diff changeset	1207 while (fr.id() != id) {
a61af66fc99e Initial load duke parents: diff changeset	1208 fr = fr.sender(&reg_map);
a61af66fc99e Initial load duke parents: diff changeset	1209 }
5110 0ebca2e35ca5 more preparations for disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 5038 diff changeset	1210 deoptimize(thread, fr, &reg_map, reason);
0 a61af66fc99e Initial load duke parents: diff changeset	1211 }
a61af66fc99e Initial load duke parents: diff changeset	1212
a61af66fc99e Initial load duke parents: diff changeset	1213
5110 0ebca2e35ca5 more preparations for disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 5038 diff changeset	1214 void Deoptimization::deoptimize_frame(JavaThread* thread, intptr_t* id, DeoptReason reason) {
1905 ce6848d0666d 6968367: can_post_on_exceptions is still using VM_DeoptimizeFrame in some places never parents: 1814 diff changeset	1215 if (thread == Thread::current()) {
5110 0ebca2e35ca5 more preparations for disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 5038 diff changeset	1216 Deoptimization::deoptimize_frame_internal(thread, id, reason);
1905 ce6848d0666d 6968367: can_post_on_exceptions is still using VM_DeoptimizeFrame in some places never parents: 1814 diff changeset	1217 } else {
5110 0ebca2e35ca5 more preparations for disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 5038 diff changeset	1218 VM_DeoptimizeFrame deopt(thread, id, reason);
1905 ce6848d0666d 6968367: can_post_on_exceptions is still using VM_DeoptimizeFrame in some places never parents: 1814 diff changeset	1219 VMThread::execute(&deopt);
ce6848d0666d 6968367: can_post_on_exceptions is still using VM_DeoptimizeFrame in some places never parents: 1814 diff changeset	1220 }
ce6848d0666d 6968367: can_post_on_exceptions is still using VM_DeoptimizeFrame in some places never parents: 1814 diff changeset	1221 }
ce6848d0666d 6968367: can_post_on_exceptions is still using VM_DeoptimizeFrame in some places never parents: 1814 diff changeset	1222
ce6848d0666d 6968367: can_post_on_exceptions is still using VM_DeoptimizeFrame in some places never parents: 1814 diff changeset	1223
0 a61af66fc99e Initial load duke parents: diff changeset	1224 // JVMTI PopFrame support
a61af66fc99e Initial load duke parents: diff changeset	1225 JRT_LEAF(void, Deoptimization::popframe_preserve_args(JavaThread* thread, int bytes_to_save, void* start_address))
a61af66fc99e Initial load duke parents: diff changeset	1226 {
a61af66fc99e Initial load duke parents: diff changeset	1227 thread->popframe_preserve_args(in_ByteSize(bytes_to_save), start_address);
a61af66fc99e Initial load duke parents: diff changeset	1228 }
a61af66fc99e Initial load duke parents: diff changeset	1229 JRT_END
a61af66fc99e Initial load duke parents: diff changeset	1230
a61af66fc99e Initial load duke parents: diff changeset	1231
4978 99d3d8a72252 More ifdef GRAAL usage. Thomas Wuerthinger <thomas.wuerthinger@oracle.com> parents: 4970 diff changeset	1232 #if defined(COMPILER2) \|\| defined(SHARK) \|\| defined(GRAAL)
0 a61af66fc99e Initial load duke parents: diff changeset	1233 void Deoptimization::load_class_by_index(constantPoolHandle constant_pool, int index, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	1234 // in case of an unresolved klass entry, load the class.
a61af66fc99e Initial load duke parents: diff changeset	1235 if (constant_pool->tag_at(index).is_unresolved_klass()) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1236 Klass* tk = constant_pool->klass_at(index, CHECK);
0 a61af66fc99e Initial load duke parents: diff changeset	1237 return;
a61af66fc99e Initial load duke parents: diff changeset	1238 }
a61af66fc99e Initial load duke parents: diff changeset	1239
a61af66fc99e Initial load duke parents: diff changeset	1240 if (!constant_pool->tag_at(index).is_symbol()) return;
a61af66fc99e Initial load duke parents: diff changeset	1241
6940 18fb7da42534 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass coleenp parents: 6853 diff changeset	1242 Handle class_loader (THREAD, constant_pool->pool_holder()->class_loader());
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2142 diff changeset	1243 Symbol* symbol = constant_pool->symbol_at(index);
0 a61af66fc99e Initial load duke parents: diff changeset	1244
a61af66fc99e Initial load duke parents: diff changeset	1245 // class name?
a61af66fc99e Initial load duke parents: diff changeset	1246 if (symbol->byte_at(0) != '(') {
6940 18fb7da42534 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass coleenp parents: 6853 diff changeset	1247 Handle protection_domain (THREAD, constant_pool->pool_holder()->protection_domain());
0 a61af66fc99e Initial load duke parents: diff changeset	1248 SystemDictionary::resolve_or_null(symbol, class_loader, protection_domain, CHECK);
a61af66fc99e Initial load duke parents: diff changeset	1249 return;
a61af66fc99e Initial load duke parents: diff changeset	1250 }
a61af66fc99e Initial load duke parents: diff changeset	1251
a61af66fc99e Initial load duke parents: diff changeset	1252 // then it must be a signature!
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2142 diff changeset	1253 ResourceMark rm(THREAD);
0 a61af66fc99e Initial load duke parents: diff changeset	1254 for (SignatureStream ss(symbol); !ss.is_done(); ss.next()) {
a61af66fc99e Initial load duke parents: diff changeset	1255 if (ss.is_object()) {
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2142 diff changeset	1256 Symbol* class_name = ss.as_symbol(CHECK);
6940 18fb7da42534 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass coleenp parents: 6853 diff changeset	1257 Handle protection_domain (THREAD, constant_pool->pool_holder()->protection_domain());
0 a61af66fc99e Initial load duke parents: diff changeset	1258 SystemDictionary::resolve_or_null(class_name, class_loader, protection_domain, CHECK);
a61af66fc99e Initial load duke parents: diff changeset	1259 }
a61af66fc99e Initial load duke parents: diff changeset	1260 }
a61af66fc99e Initial load duke parents: diff changeset	1261 }
a61af66fc99e Initial load duke parents: diff changeset	1262
a61af66fc99e Initial load duke parents: diff changeset	1263
a61af66fc99e Initial load duke parents: diff changeset	1264 void Deoptimization::load_class_by_index(constantPoolHandle constant_pool, int index) {
a61af66fc99e Initial load duke parents: diff changeset	1265 EXCEPTION_MARK;
a61af66fc99e Initial load duke parents: diff changeset	1266 load_class_by_index(constant_pool, index, THREAD);
a61af66fc99e Initial load duke parents: diff changeset	1267 if (HAS_PENDING_EXCEPTION) {
a61af66fc99e Initial load duke parents: diff changeset	1268 // Exception happened during classloading. We ignore the exception here, since it
a61af66fc99e Initial load duke parents: diff changeset	1269 // is going to be rethrown since the current activation is going to be deoptimzied and
a61af66fc99e Initial load duke parents: diff changeset	1270 // the interpreter will re-execute the bytecode.
a61af66fc99e Initial load duke parents: diff changeset	1271 CLEAR_PENDING_EXCEPTION;
a61af66fc99e Initial load duke parents: diff changeset	1272 }
a61af66fc99e Initial load duke parents: diff changeset	1273 }
a61af66fc99e Initial load duke parents: diff changeset	1274
a61af66fc99e Initial load duke parents: diff changeset	1275 JRT_ENTRY(void, Deoptimization::uncommon_trap_inner(JavaThread* thread, jint trap_request)) {
a61af66fc99e Initial load duke parents: diff changeset	1276 HandleMark hm;
a61af66fc99e Initial load duke parents: diff changeset	1277
a61af66fc99e Initial load duke parents: diff changeset	1278 // uncommon_trap() is called at the beginning of the uncommon trap
a61af66fc99e Initial load duke parents: diff changeset	1279 // handler. Note this fact before we start generating temporary frames
a61af66fc99e Initial load duke parents: diff changeset	1280 // that can confuse an asynchronous stack walker. This counter is
a61af66fc99e Initial load duke parents: diff changeset	1281 // decremented at the end of unpack_frames().
a61af66fc99e Initial load duke parents: diff changeset	1282 thread->inc_in_deopt_handler();
a61af66fc99e Initial load duke parents: diff changeset	1283
a61af66fc99e Initial load duke parents: diff changeset	1284 // We need to update the map if we have biased locking.
6428 6278ac5829ce fix for deopt issue with -XX:-UseBiasedLocking (plus a cosmetic fix in graalCodeInstaller.cpp) Lukas Stadler <lukas.stadler@jku.at> parents: 6275 diff changeset	1285 #ifdef GRAAL
6278ac5829ce fix for deopt issue with -XX:-UseBiasedLocking (plus a cosmetic fix in graalCodeInstaller.cpp) Lukas Stadler <lukas.stadler@jku.at> parents: 6275 diff changeset	1286 // (lstadler) Graal might need to get an exception from the stack, which in turn requires the register map to be valid
6278ac5829ce fix for deopt issue with -XX:-UseBiasedLocking (plus a cosmetic fix in graalCodeInstaller.cpp) Lukas Stadler <lukas.stadler@jku.at> parents: 6275 diff changeset	1287 RegisterMap reg_map(thread, true);
6278ac5829ce fix for deopt issue with -XX:-UseBiasedLocking (plus a cosmetic fix in graalCodeInstaller.cpp) Lukas Stadler <lukas.stadler@jku.at> parents: 6275 diff changeset	1288 #else
0 a61af66fc99e Initial load duke parents: diff changeset	1289 RegisterMap reg_map(thread, UseBiasedLocking);
6428 6278ac5829ce fix for deopt issue with -XX:-UseBiasedLocking (plus a cosmetic fix in graalCodeInstaller.cpp) Lukas Stadler <lukas.stadler@jku.at> parents: 6275 diff changeset	1290 #endif
0 a61af66fc99e Initial load duke parents: diff changeset	1291 frame stub_frame = thread->last_frame();
a61af66fc99e Initial load duke parents: diff changeset	1292 frame fr = stub_frame.sender(&reg_map);
a61af66fc99e Initial load duke parents: diff changeset	1293 // Make sure the calling nmethod is not getting deoptimized and removed
a61af66fc99e Initial load duke parents: diff changeset	1294 // before we are done with it.
a61af66fc99e Initial load duke parents: diff changeset	1295 nmethodLocker nl(fr.pc());
a61af66fc99e Initial load duke parents: diff changeset	1296
4872 aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4777 diff changeset	1297 // Log a message
7193 ee32440febeb 8001538: hs_err file does not list anymore compiled methods in compilation events vlivanov parents: 6940 diff changeset	1298 Events::log(thread, "Uncommon trap: trap_request=" PTR32_FORMAT " fr.pc=" INTPTR_FORMAT,
ee32440febeb 8001538: hs_err file does not list anymore compiled methods in compilation events vlivanov parents: 6940 diff changeset	1299 trap_request, fr.pc());
4872 aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4777 diff changeset	1300
0 a61af66fc99e Initial load duke parents: diff changeset	1301 {
a61af66fc99e Initial load duke parents: diff changeset	1302 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	1303
a61af66fc99e Initial load duke parents: diff changeset	1304 // Revoke biases of any monitors in the frame to ensure we can migrate them
a61af66fc99e Initial load duke parents: diff changeset	1305 revoke_biases_of_monitors(thread, fr, &reg_map);
a61af66fc99e Initial load duke parents: diff changeset	1306
a61af66fc99e Initial load duke parents: diff changeset	1307 DeoptReason reason = trap_request_reason(trap_request);
a61af66fc99e Initial load duke parents: diff changeset	1308 DeoptAction action = trap_request_action(trap_request);
a61af66fc99e Initial load duke parents: diff changeset	1309 jint unloaded_class_index = trap_request_index(trap_request); // CP idx or -1
a61af66fc99e Initial load duke parents: diff changeset	1310
a61af66fc99e Initial load duke parents: diff changeset	1311 vframe* vf = vframe::new_vframe(&fr, &reg_map, thread);
a61af66fc99e Initial load duke parents: diff changeset	1312 compiledVFrame* cvf = compiledVFrame::cast(vf);
a61af66fc99e Initial load duke parents: diff changeset	1313
a61af66fc99e Initial load duke parents: diff changeset	1314 nmethod* nm = cvf->code();
a61af66fc99e Initial load duke parents: diff changeset	1315
a61af66fc99e Initial load duke parents: diff changeset	1316 ScopeDesc* trap_scope = cvf->scope();
3017 b4ba003eb11d Fixed unnecessary node in the graph builder. Thomas Wuerthinger <thomas@wuerthinger.net> parents: 2938 diff changeset	1317
b4ba003eb11d Fixed unnecessary node in the graph builder. Thomas Wuerthinger <thomas@wuerthinger.net> parents: 2938 diff changeset	1318 if (TraceDeoptimization) {
4674 e1c053324210 changed TraceDeoptimization output Christian Haeubl <christian.haeubl@oracle.com> parents: 4668 diff changeset	1319 tty->print_cr(" bci=%d pc=%d, relative_pc=%d, method=%s", trap_scope->bci(), fr.pc(), fr.pc() - nm->code_begin(), trap_scope->method()->name()->as_C_string());
3017 b4ba003eb11d Fixed unnecessary node in the graph builder. Thomas Wuerthinger <thomas@wuerthinger.net> parents: 2938 diff changeset	1320 }
0 a61af66fc99e Initial load duke parents: diff changeset	1321
a61af66fc99e Initial load duke parents: diff changeset	1322 methodHandle trap_method = trap_scope->method();
a61af66fc99e Initial load duke parents: diff changeset	1323 int trap_bci = trap_scope->bci();
8328 6b6cbd8b8914 Support deoptimizing before the entry to a synchronized method. Thomas Wuerthinger <thomas.wuerthinger@oracle.com> parents: 8151 diff changeset	1324 if (trap_bci == SynchronizationEntryBCI) {
6b6cbd8b8914 Support deoptimizing before the entry to a synchronized method. Thomas Wuerthinger <thomas.wuerthinger@oracle.com> parents: 8151 diff changeset	1325 trap_bci = 0;
6b6cbd8b8914 Support deoptimizing before the entry to a synchronized method. Thomas Wuerthinger <thomas.wuerthinger@oracle.com> parents: 8151 diff changeset	1326 Thread::current()->set_pending_monitorenter(true);
6b6cbd8b8914 Support deoptimizing before the entry to a synchronized method. Thomas Wuerthinger <thomas.wuerthinger@oracle.com> parents: 8151 diff changeset	1327 }
2142 8012aa3ccede 4926272: methodOopDesc::method_from_bcp is unsafe never parents: 1972 diff changeset	1328 Bytecodes::Code trap_bc = trap_method->java_code_at(trap_bci);
0 a61af66fc99e Initial load duke parents: diff changeset	1329
3018 5857923e563c Fixed an issue with frame states in exception dispatch chains (now we are correctly rethrowing the exception immediately at entering the interpreter). Thomas Wuerthinger <thomas@wuerthinger.net> parents: 3017 diff changeset	1330 if (trap_scope->rethrow_exception()) {
4668 3dbcd1013cc8 added flag PrintDeoptimizationDetails Christian Haeubl <christian.haeubl@oracle.com> parents: 4661 diff changeset	1331 if (PrintDeoptimizationDetails) {
6948 e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 6428 6940 diff changeset	1332 tty->print_cr("Exception to be rethrown in the interpreter for method %s::%s at bci %d", trap_method->method_holder()->name()->as_C_string(), trap_method->name()->as_C_string(), trap_bci);
3019 77bb196828cb Fixed an issue with accessing non-initialized static fields. Thomas Wuerthinger <thomas@wuerthinger.net> parents: 3018 diff changeset	1333 }
3018 5857923e563c Fixed an issue with frame states in exception dispatch chains (now we are correctly rethrowing the exception immediately at entering the interpreter). Thomas Wuerthinger <thomas@wuerthinger.net> parents: 3017 diff changeset	1334 GrowableArray<ScopeValue> expressions = trap_scope->expressions();
3167 132aa6f2bbc0 Fixed rethrow exception frame state (again.. and this time added some useful assertions). Thomas Wuerthinger <thomas@wuerthinger.net> parents: 3153 diff changeset	1335 guarantee(expressions != NULL, "must have exception to throw");
3018 5857923e563c Fixed an issue with frame states in exception dispatch chains (now we are correctly rethrowing the exception immediately at entering the interpreter). Thomas Wuerthinger <thomas@wuerthinger.net> parents: 3017 diff changeset	1336 ScopeValue* topOfStack = expressions->top();
8151 b8f261ba79c6 Minimize diff to plain HotSpot version. Thomas Wuerthinger <thomas.wuerthinger@oracle.com> parents: 8124 diff changeset	1337 Handle topOfStackObj = StackValue::create_stack_value(&fr, &reg_map, topOfStack)->get_obj();
3018 5857923e563c Fixed an issue with frame states in exception dispatch chains (now we are correctly rethrowing the exception immediately at entering the interpreter). Thomas Wuerthinger <thomas@wuerthinger.net> parents: 3017 diff changeset	1338 THREAD->set_pending_exception(topOfStackObj(), NULL, 0);
5857923e563c Fixed an issue with frame states in exception dispatch chains (now we are correctly rethrowing the exception immediately at entering the interpreter). Thomas Wuerthinger <thomas@wuerthinger.net> parents: 3017 diff changeset	1339 }
5857923e563c Fixed an issue with frame states in exception dispatch chains (now we are correctly rethrowing the exception immediately at entering the interpreter). Thomas Wuerthinger <thomas@wuerthinger.net> parents: 3017 diff changeset	1340
0 a61af66fc99e Initial load duke parents: diff changeset	1341 // Record this event in the histogram.
a61af66fc99e Initial load duke parents: diff changeset	1342 gather_statistics(reason, action, trap_bc);
a61af66fc99e Initial load duke parents: diff changeset	1343
a61af66fc99e Initial load duke parents: diff changeset	1344 // Ensure that we can record deopt. history:
a61af66fc99e Initial load duke parents: diff changeset	1345 bool create_if_missing = ProfileTraps;
a61af66fc99e Initial load duke parents: diff changeset	1346
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1347 MethodData* trap_mdo =
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1348 get_method_data(thread, trap_method, create_if_missing);
0 a61af66fc99e Initial load duke parents: diff changeset	1349
7193 ee32440febeb 8001538: hs_err file does not list anymore compiled methods in compilation events vlivanov parents: 6940 diff changeset	1350 // Log a message
ee32440febeb 8001538: hs_err file does not list anymore compiled methods in compilation events vlivanov parents: 6940 diff changeset	1351 Events::log_deopt_message(thread, "Uncommon trap: reason=%s action=%s pc=" INTPTR_FORMAT " method=%s @ %d",
ee32440febeb 8001538: hs_err file does not list anymore compiled methods in compilation events vlivanov parents: 6940 diff changeset	1352 trap_reason_name(reason), trap_action_name(action), fr.pc(),
ee32440febeb 8001538: hs_err file does not list anymore compiled methods in compilation events vlivanov parents: 6940 diff changeset	1353 trap_method->name_and_sig_as_C_string(), trap_bci);
ee32440febeb 8001538: hs_err file does not list anymore compiled methods in compilation events vlivanov parents: 6940 diff changeset	1354
0 a61af66fc99e Initial load duke parents: diff changeset	1355 // Print a bunch of diagnostics, if requested.
a61af66fc99e Initial load duke parents: diff changeset	1356 if (TraceDeoptimization \|\| LogCompilation) {
a61af66fc99e Initial load duke parents: diff changeset	1357 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	1358 ttyLocker ttyl;
a61af66fc99e Initial load duke parents: diff changeset	1359 char buf[100];
a61af66fc99e Initial load duke parents: diff changeset	1360 if (xtty != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	1361 xtty->begin_head("uncommon_trap thread='" UINTX_FORMAT"' %s",
a61af66fc99e Initial load duke parents: diff changeset	1362 os::current_thread_id(),
a61af66fc99e Initial load duke parents: diff changeset	1363 format_trap_request(buf, sizeof(buf), trap_request));
a61af66fc99e Initial load duke parents: diff changeset	1364 nm->log_identity(xtty);
a61af66fc99e Initial load duke parents: diff changeset	1365 }
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2142 diff changeset	1366 Symbol* class_name = NULL;
0 a61af66fc99e Initial load duke parents: diff changeset	1367 bool unresolved = false;
a61af66fc99e Initial load duke parents: diff changeset	1368 if (unloaded_class_index >= 0) {
a61af66fc99e Initial load duke parents: diff changeset	1369 constantPoolHandle constants (THREAD, trap_method->constants());
a61af66fc99e Initial load duke parents: diff changeset	1370 if (constants->tag_at(unloaded_class_index).is_unresolved_klass()) {
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2142 diff changeset	1371 class_name = constants->klass_name_at(unloaded_class_index);
0 a61af66fc99e Initial load duke parents: diff changeset	1372 unresolved = true;
a61af66fc99e Initial load duke parents: diff changeset	1373 if (xtty != NULL)
a61af66fc99e Initial load duke parents: diff changeset	1374 xtty->print(" unresolved='1'");
a61af66fc99e Initial load duke parents: diff changeset	1375 } else if (constants->tag_at(unloaded_class_index).is_symbol()) {
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2142 diff changeset	1376 class_name = constants->symbol_at(unloaded_class_index);
0 a61af66fc99e Initial load duke parents: diff changeset	1377 }
a61af66fc99e Initial load duke parents: diff changeset	1378 if (xtty != NULL)
a61af66fc99e Initial load duke parents: diff changeset	1379 xtty->name(class_name);
a61af66fc99e Initial load duke parents: diff changeset	1380 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1381 if (xtty != NULL && trap_mdo != NULL) {
0 a61af66fc99e Initial load duke parents: diff changeset	1382 // Dump the relevant MDO state.
a61af66fc99e Initial load duke parents: diff changeset	1383 // This is the deopt count for the current reason, any previous
a61af66fc99e Initial load duke parents: diff changeset	1384 // reasons or recompiles seen at this point.
a61af66fc99e Initial load duke parents: diff changeset	1385 int dcnt = trap_mdo->trap_count(reason);
a61af66fc99e Initial load duke parents: diff changeset	1386 if (dcnt != 0)
a61af66fc99e Initial load duke parents: diff changeset	1387 xtty->print(" count='%d'", dcnt);
a61af66fc99e Initial load duke parents: diff changeset	1388 ProfileData* pdata = trap_mdo->bci_to_data(trap_bci);
a61af66fc99e Initial load duke parents: diff changeset	1389 int dos = (pdata == NULL)? 0: pdata->trap_state();
a61af66fc99e Initial load duke parents: diff changeset	1390 if (dos != 0) {
a61af66fc99e Initial load duke parents: diff changeset	1391 xtty->print(" state='%s'", format_trap_state(buf, sizeof(buf), dos));
a61af66fc99e Initial load duke parents: diff changeset	1392 if (trap_state_is_recompiled(dos)) {
a61af66fc99e Initial load duke parents: diff changeset	1393 int recnt2 = trap_mdo->overflow_recompile_count();
a61af66fc99e Initial load duke parents: diff changeset	1394 if (recnt2 != 0)
a61af66fc99e Initial load duke parents: diff changeset	1395 xtty->print(" recompiles2='%d'", recnt2);
a61af66fc99e Initial load duke parents: diff changeset	1396 }
a61af66fc99e Initial load duke parents: diff changeset	1397 }
a61af66fc99e Initial load duke parents: diff changeset	1398 }
a61af66fc99e Initial load duke parents: diff changeset	1399 if (xtty != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	1400 xtty->stamp();
a61af66fc99e Initial load duke parents: diff changeset	1401 xtty->end_head();
a61af66fc99e Initial load duke parents: diff changeset	1402 }
a61af66fc99e Initial load duke parents: diff changeset	1403 if (TraceDeoptimization) { // make noise on the tty
a61af66fc99e Initial load duke parents: diff changeset	1404 tty->print("Uncommon trap occurred in");
a61af66fc99e Initial load duke parents: diff changeset	1405 nm->method()->print_short_name(tty);
6843 c3e799c37717 7177003: C1: LogCompilation support vlivanov parents: 6725 diff changeset	1406 tty->print(" (@" INTPTR_FORMAT ") thread=" UINTX_FORMAT " reason=%s action=%s unloaded_class_index=%d",
0 a61af66fc99e Initial load duke parents: diff changeset	1407 fr.pc(),
6843 c3e799c37717 7177003: C1: LogCompilation support vlivanov parents: 6725 diff changeset	1408 os::current_thread_id(),
0 a61af66fc99e Initial load duke parents: diff changeset	1409 trap_reason_name(reason),
a61af66fc99e Initial load duke parents: diff changeset	1410 trap_action_name(action),
a61af66fc99e Initial load duke parents: diff changeset	1411 unloaded_class_index);
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2142 diff changeset	1412 if (class_name != NULL) {
0 a61af66fc99e Initial load duke parents: diff changeset	1413 tty->print(unresolved ? " unresolved class: " : " symbol: ");
a61af66fc99e Initial load duke parents: diff changeset	1414 class_name->print_symbol_on(tty);
a61af66fc99e Initial load duke parents: diff changeset	1415 }
a61af66fc99e Initial load duke parents: diff changeset	1416 tty->cr();
a61af66fc99e Initial load duke parents: diff changeset	1417 }
a61af66fc99e Initial load duke parents: diff changeset	1418 if (xtty != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	1419 // Log the precise location of the trap.
a61af66fc99e Initial load duke parents: diff changeset	1420 for (ScopeDesc* sd = trap_scope; ; sd = sd->sender()) {
a61af66fc99e Initial load duke parents: diff changeset	1421 xtty->begin_elem("jvms bci='%d'", sd->bci());
a61af66fc99e Initial load duke parents: diff changeset	1422 xtty->method(sd->method());
a61af66fc99e Initial load duke parents: diff changeset	1423 xtty->end_elem();
a61af66fc99e Initial load duke parents: diff changeset	1424 if (sd->is_top()) break;
a61af66fc99e Initial load duke parents: diff changeset	1425 }
a61af66fc99e Initial load duke parents: diff changeset	1426 xtty->tail("uncommon_trap");
a61af66fc99e Initial load duke parents: diff changeset	1427 }
a61af66fc99e Initial load duke parents: diff changeset	1428 }
a61af66fc99e Initial load duke parents: diff changeset	1429 // (End diagnostic printout.)
a61af66fc99e Initial load duke parents: diff changeset	1430
a61af66fc99e Initial load duke parents: diff changeset	1431 // Load class if necessary
a61af66fc99e Initial load duke parents: diff changeset	1432 if (unloaded_class_index >= 0) {
a61af66fc99e Initial load duke parents: diff changeset	1433 constantPoolHandle constants(THREAD, trap_method->constants());
a61af66fc99e Initial load duke parents: diff changeset	1434 load_class_by_index(constants, unloaded_class_index);
a61af66fc99e Initial load duke parents: diff changeset	1435 }
a61af66fc99e Initial load duke parents: diff changeset	1436
a61af66fc99e Initial load duke parents: diff changeset	1437 // Flush the nmethod if necessary and desirable.
a61af66fc99e Initial load duke parents: diff changeset	1438 //
a61af66fc99e Initial load duke parents: diff changeset	1439 // We need to avoid situations where we are re-flushing the nmethod
a61af66fc99e Initial load duke parents: diff changeset	1440 // because of a hot deoptimization site. Repeated flushes at the same
a61af66fc99e Initial load duke parents: diff changeset	1441 // point need to be detected by the compiler and avoided. If the compiler
a61af66fc99e Initial load duke parents: diff changeset	1442 // cannot avoid them (or has a bug and "refuses" to avoid them), this
a61af66fc99e Initial load duke parents: diff changeset	1443 // module must take measures to avoid an infinite cycle of recompilation
a61af66fc99e Initial load duke parents: diff changeset	1444 // and deoptimization. There are several such measures:
a61af66fc99e Initial load duke parents: diff changeset	1445 //
a61af66fc99e Initial load duke parents: diff changeset	1446 // 1. If a recompilation is ordered a second time at some site X
a61af66fc99e Initial load duke parents: diff changeset	1447 // and for the same reason R, the action is adjusted to 'reinterpret',
a61af66fc99e Initial load duke parents: diff changeset	1448 // to give the interpreter time to exercise the method more thoroughly.
a61af66fc99e Initial load duke parents: diff changeset	1449 // If this happens, the method's overflow_recompile_count is incremented.
a61af66fc99e Initial load duke parents: diff changeset	1450 //
a61af66fc99e Initial load duke parents: diff changeset	1451 // 2. If the compiler fails to reduce the deoptimization rate, then
a61af66fc99e Initial load duke parents: diff changeset	1452 // the method's overflow_recompile_count will begin to exceed the set
a61af66fc99e Initial load duke parents: diff changeset	1453 // limit PerBytecodeRecompilationCutoff. If this happens, the action
a61af66fc99e Initial load duke parents: diff changeset	1454 // is adjusted to 'make_not_compilable', and the method is abandoned
a61af66fc99e Initial load duke parents: diff changeset	1455 // to the interpreter. This is a performance hit for hot methods,
a61af66fc99e Initial load duke parents: diff changeset	1456 // but is better than a disastrous infinite cycle of recompilations.
a61af66fc99e Initial load duke parents: diff changeset	1457 // (Actually, only the method containing the site X is abandoned.)
a61af66fc99e Initial load duke parents: diff changeset	1458 //
a61af66fc99e Initial load duke parents: diff changeset	1459 // 3. In parallel with the previous measures, if the total number of
a61af66fc99e Initial load duke parents: diff changeset	1460 // recompilations of a method exceeds the much larger set limit
a61af66fc99e Initial load duke parents: diff changeset	1461 // PerMethodRecompilationCutoff, the method is abandoned.
a61af66fc99e Initial load duke parents: diff changeset	1462 // This should only happen if the method is very large and has
a61af66fc99e Initial load duke parents: diff changeset	1463 // many "lukewarm" deoptimizations. The code which enforces this
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1464 // limit is elsewhere (class nmethod, class Method).
0 a61af66fc99e Initial load duke parents: diff changeset	1465 //
a61af66fc99e Initial load duke parents: diff changeset	1466 // Note that the per-BCI 'is_recompiled' bit gives the compiler one chance
a61af66fc99e Initial load duke parents: diff changeset	1467 // to recompile at each bytecode independently of the per-BCI cutoff.
a61af66fc99e Initial load duke parents: diff changeset	1468 //
a61af66fc99e Initial load duke parents: diff changeset	1469 // The decision to update code is up to the compiler, and is encoded
a61af66fc99e Initial load duke parents: diff changeset	1470 // in the Action_xxx code. If the compiler requests Action_none
a61af66fc99e Initial load duke parents: diff changeset	1471 // no trap state is changed, no compiled code is changed, and the
a61af66fc99e Initial load duke parents: diff changeset	1472 // computation suffers along in the interpreter.
a61af66fc99e Initial load duke parents: diff changeset	1473 //
a61af66fc99e Initial load duke parents: diff changeset	1474 // The other action codes specify various tactics for decompilation
a61af66fc99e Initial load duke parents: diff changeset	1475 // and recompilation. Action_maybe_recompile is the loosest, and
a61af66fc99e Initial load duke parents: diff changeset	1476 // allows the compiled code to stay around until enough traps are seen,
a61af66fc99e Initial load duke parents: diff changeset	1477 // and until the compiler gets around to recompiling the trapping method.
a61af66fc99e Initial load duke parents: diff changeset	1478 //
a61af66fc99e Initial load duke parents: diff changeset	1479 // The other actions cause immediate removal of the present code.
a61af66fc99e Initial load duke parents: diff changeset	1480
a61af66fc99e Initial load duke parents: diff changeset	1481 bool update_trap_state = true;
a61af66fc99e Initial load duke parents: diff changeset	1482 bool make_not_entrant = false;
a61af66fc99e Initial load duke parents: diff changeset	1483 bool make_not_compilable = false;
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1692 diff changeset	1484 bool reprofile = false;
0 a61af66fc99e Initial load duke parents: diff changeset	1485 switch (action) {
a61af66fc99e Initial load duke parents: diff changeset	1486 case Action_none:
a61af66fc99e Initial load duke parents: diff changeset	1487 // Keep the old code.
a61af66fc99e Initial load duke parents: diff changeset	1488 update_trap_state = false;
a61af66fc99e Initial load duke parents: diff changeset	1489 break;
a61af66fc99e Initial load duke parents: diff changeset	1490 case Action_maybe_recompile:
a61af66fc99e Initial load duke parents: diff changeset	1491 // Do not need to invalidate the present code, but we can
a61af66fc99e Initial load duke parents: diff changeset	1492 // initiate another
a61af66fc99e Initial load duke parents: diff changeset	1493 // Start compiler without (necessarily) invalidating the nmethod.
a61af66fc99e Initial load duke parents: diff changeset	1494 // The system will tolerate the old code, but new code should be
a61af66fc99e Initial load duke parents: diff changeset	1495 // generated when possible.
a61af66fc99e Initial load duke parents: diff changeset	1496 break;
a61af66fc99e Initial load duke parents: diff changeset	1497 case Action_reinterpret:
a61af66fc99e Initial load duke parents: diff changeset	1498 // Go back into the interpreter for a while, and then consider
a61af66fc99e Initial load duke parents: diff changeset	1499 // recompiling form scratch.
a61af66fc99e Initial load duke parents: diff changeset	1500 make_not_entrant = true;
a61af66fc99e Initial load duke parents: diff changeset	1501 // Reset invocation counter for outer most method.
a61af66fc99e Initial load duke parents: diff changeset	1502 // This will allow the interpreter to exercise the bytecodes
a61af66fc99e Initial load duke parents: diff changeset	1503 // for a while before recompiling.
a61af66fc99e Initial load duke parents: diff changeset	1504 // By contrast, Action_make_not_entrant is immediate.
a61af66fc99e Initial load duke parents: diff changeset	1505 //
a61af66fc99e Initial load duke parents: diff changeset	1506 // Note that the compiler will track null_check, null_assert,
a61af66fc99e Initial load duke parents: diff changeset	1507 // range_check, and class_check events and log them as if they
a61af66fc99e Initial load duke parents: diff changeset	1508 // had been traps taken from compiled code. This will update
a61af66fc99e Initial load duke parents: diff changeset	1509 // the MDO trap history so that the next compilation will
a61af66fc99e Initial load duke parents: diff changeset	1510 // properly detect hot trap sites.
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1692 diff changeset	1511 reprofile = true;
0 a61af66fc99e Initial load duke parents: diff changeset	1512 break;
a61af66fc99e Initial load duke parents: diff changeset	1513 case Action_make_not_entrant:
a61af66fc99e Initial load duke parents: diff changeset	1514 // Request immediate recompilation, and get rid of the old code.
a61af66fc99e Initial load duke parents: diff changeset	1515 // Make them not entrant, so next time they are called they get
a61af66fc99e Initial load duke parents: diff changeset	1516 // recompiled. Unloaded classes are loaded now so recompile before next
a61af66fc99e Initial load duke parents: diff changeset	1517 // time they are called. Same for uninitialized. The interpreter will
a61af66fc99e Initial load duke parents: diff changeset	1518 // link the missing class, if any.
a61af66fc99e Initial load duke parents: diff changeset	1519 make_not_entrant = true;
a61af66fc99e Initial load duke parents: diff changeset	1520 break;
a61af66fc99e Initial load duke parents: diff changeset	1521 case Action_make_not_compilable:
a61af66fc99e Initial load duke parents: diff changeset	1522 // Give up on compiling this method at all.
a61af66fc99e Initial load duke parents: diff changeset	1523 make_not_entrant = true;
a61af66fc99e Initial load duke parents: diff changeset	1524 make_not_compilable = true;
a61af66fc99e Initial load duke parents: diff changeset	1525 break;
a61af66fc99e Initial load duke parents: diff changeset	1526 default:
a61af66fc99e Initial load duke parents: diff changeset	1527 ShouldNotReachHere();
a61af66fc99e Initial load duke parents: diff changeset	1528 }
a61af66fc99e Initial load duke parents: diff changeset	1529
a61af66fc99e Initial load duke parents: diff changeset	1530 // Setting +ProfileTraps fixes the following, on all platforms:
a61af66fc99e Initial load duke parents: diff changeset	1531 // 4852688: ProfileInterpreter is off by default for ia64. The result is
a61af66fc99e Initial load duke parents: diff changeset	1532 // infinite heroic-opt-uncommon-trap/deopt/recompile cycles, since the
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1533 // recompile relies on a MethodData* to record heroic opt failures.
0 a61af66fc99e Initial load duke parents: diff changeset	1534
a61af66fc99e Initial load duke parents: diff changeset	1535 // Whether the interpreter is producing MDO data or not, we also need
a61af66fc99e Initial load duke parents: diff changeset	1536 // to use the MDO to detect hot deoptimization points and control
a61af66fc99e Initial load duke parents: diff changeset	1537 // aggressive optimization.
1206 87684f1a88b5 6614597: Performance variability in jvm2008 xml.validation kvn parents: 1204 diff changeset	1538 bool inc_recompile_count = false;
87684f1a88b5 6614597: Performance variability in jvm2008 xml.validation kvn parents: 1204 diff changeset	1539 ProfileData* pdata = NULL;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1540 if (ProfileTraps && update_trap_state && trap_mdo != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1541 assert(trap_mdo == get_method_data(thread, trap_method, false), "sanity");
0 a61af66fc99e Initial load duke parents: diff changeset	1542 uint this_trap_count = 0;
a61af66fc99e Initial load duke parents: diff changeset	1543 bool maybe_prior_trap = false;
a61af66fc99e Initial load duke parents: diff changeset	1544 bool maybe_prior_recompile = false;
5114 dad1ac9dba7d finished first implementation of disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 5110 diff changeset	1545 pdata = query_update_method_data(trap_mdo, trap_bci, reason, true,
0 a61af66fc99e Initial load duke parents: diff changeset	1546 //outputs:
a61af66fc99e Initial load duke parents: diff changeset	1547 this_trap_count,
a61af66fc99e Initial load duke parents: diff changeset	1548 maybe_prior_trap,
a61af66fc99e Initial load duke parents: diff changeset	1549 maybe_prior_recompile);
a61af66fc99e Initial load duke parents: diff changeset	1550 // Because the interpreter also counts null, div0, range, and class
a61af66fc99e Initial load duke parents: diff changeset	1551 // checks, these traps from compiled code are double-counted.
a61af66fc99e Initial load duke parents: diff changeset	1552 // This is harmless; it just means that the PerXTrapLimit values
a61af66fc99e Initial load duke parents: diff changeset	1553 // are in effect a little smaller than they look.
a61af66fc99e Initial load duke parents: diff changeset	1554
a61af66fc99e Initial load duke parents: diff changeset	1555 DeoptReason per_bc_reason = reason_recorded_per_bytecode_if_any(reason);
a61af66fc99e Initial load duke parents: diff changeset	1556 if (per_bc_reason != Reason_none) {
a61af66fc99e Initial load duke parents: diff changeset	1557 // Now take action based on the partially known per-BCI history.
a61af66fc99e Initial load duke parents: diff changeset	1558 if (maybe_prior_trap
a61af66fc99e Initial load duke parents: diff changeset	1559 && this_trap_count >= (uint)PerBytecodeTrapLimit) {
a61af66fc99e Initial load duke parents: diff changeset	1560 // If there are too many traps at this BCI, force a recompile.
a61af66fc99e Initial load duke parents: diff changeset	1561 // This will allow the compiler to see the limit overflow, and
a61af66fc99e Initial load duke parents: diff changeset	1562 // take corrective action, if possible. The compiler generally
a61af66fc99e Initial load duke parents: diff changeset	1563 // does not use the exact PerBytecodeTrapLimit value, but instead
a61af66fc99e Initial load duke parents: diff changeset	1564 // changes its tactics if it sees any traps at all. This provides
a61af66fc99e Initial load duke parents: diff changeset	1565 // a little hysteresis, delaying a recompile until a trap happens
a61af66fc99e Initial load duke parents: diff changeset	1566 // several times.
a61af66fc99e Initial load duke parents: diff changeset	1567 //
a61af66fc99e Initial load duke parents: diff changeset	1568 // Actually, since there is only one bit of counter per BCI,
a61af66fc99e Initial load duke parents: diff changeset	1569 // the possible per-BCI counts are {0,1,(per-method count)}.
a61af66fc99e Initial load duke parents: diff changeset	1570 // This produces accurate results if in fact there is only
a61af66fc99e Initial load duke parents: diff changeset	1571 // one hot trap site, but begins to get fuzzy if there are
a61af66fc99e Initial load duke parents: diff changeset	1572 // many sites. For example, if there are ten sites each
a61af66fc99e Initial load duke parents: diff changeset	1573 // trapping two or more times, they each get the blame for
a61af66fc99e Initial load duke parents: diff changeset	1574 // all of their traps.
a61af66fc99e Initial load duke parents: diff changeset	1575 make_not_entrant = true;
a61af66fc99e Initial load duke parents: diff changeset	1576 }
a61af66fc99e Initial load duke parents: diff changeset	1577
a61af66fc99e Initial load duke parents: diff changeset	1578 // Detect repeated recompilation at the same BCI, and enforce a limit.
a61af66fc99e Initial load duke parents: diff changeset	1579 if (make_not_entrant && maybe_prior_recompile) {
a61af66fc99e Initial load duke parents: diff changeset	1580 // More than one recompile at this point.
1206 87684f1a88b5 6614597: Performance variability in jvm2008 xml.validation kvn parents: 1204 diff changeset	1581 inc_recompile_count = maybe_prior_trap;
0 a61af66fc99e Initial load duke parents: diff changeset	1582 }
a61af66fc99e Initial load duke parents: diff changeset	1583 } else {
a61af66fc99e Initial load duke parents: diff changeset	1584 // For reasons which are not recorded per-bytecode, we simply
a61af66fc99e Initial load duke parents: diff changeset	1585 // force recompiles unconditionally.
a61af66fc99e Initial load duke parents: diff changeset	1586 // (Note that PerMethodRecompilationCutoff is enforced elsewhere.)
a61af66fc99e Initial load duke parents: diff changeset	1587 make_not_entrant = true;
a61af66fc99e Initial load duke parents: diff changeset	1588 }
a61af66fc99e Initial load duke parents: diff changeset	1589
a61af66fc99e Initial load duke parents: diff changeset	1590 // Go back to the compiler if there are too many traps in this method.
a61af66fc99e Initial load duke parents: diff changeset	1591 if (this_trap_count >= (uint)PerMethodTrapLimit) {
a61af66fc99e Initial load duke parents: diff changeset	1592 // If there are too many traps in this method, force a recompile.
a61af66fc99e Initial load duke parents: diff changeset	1593 // This will allow the compiler to see the limit overflow, and
a61af66fc99e Initial load duke parents: diff changeset	1594 // take corrective action, if possible.
a61af66fc99e Initial load duke parents: diff changeset	1595 // (This condition is an unlikely backstop only, because the
a61af66fc99e Initial load duke parents: diff changeset	1596 // PerBytecodeTrapLimit is more likely to take effect first,
a61af66fc99e Initial load duke parents: diff changeset	1597 // if it is applicable.)
a61af66fc99e Initial load duke parents: diff changeset	1598 make_not_entrant = true;
a61af66fc99e Initial load duke parents: diff changeset	1599 }
a61af66fc99e Initial load duke parents: diff changeset	1600
a61af66fc99e Initial load duke parents: diff changeset	1601 // Here's more hysteresis: If there has been a recompile at
a61af66fc99e Initial load duke parents: diff changeset	1602 // this trap point already, run the method in the interpreter
a61af66fc99e Initial load duke parents: diff changeset	1603 // for a while to exercise it more thoroughly.
a61af66fc99e Initial load duke parents: diff changeset	1604 if (make_not_entrant && maybe_prior_recompile && maybe_prior_trap) {
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1692 diff changeset	1605 reprofile = true;
0 a61af66fc99e Initial load duke parents: diff changeset	1606 }
a61af66fc99e Initial load duke parents: diff changeset	1607
1206 87684f1a88b5 6614597: Performance variability in jvm2008 xml.validation kvn parents: 1204 diff changeset	1608 }
87684f1a88b5 6614597: Performance variability in jvm2008 xml.validation kvn parents: 1204 diff changeset	1609
87684f1a88b5 6614597: Performance variability in jvm2008 xml.validation kvn parents: 1204 diff changeset	1610 // Take requested actions on the method:
87684f1a88b5 6614597: Performance variability in jvm2008 xml.validation kvn parents: 1204 diff changeset	1611
87684f1a88b5 6614597: Performance variability in jvm2008 xml.validation kvn parents: 1204 diff changeset	1612 // Recompile
87684f1a88b5 6614597: Performance variability in jvm2008 xml.validation kvn parents: 1204 diff changeset	1613 if (make_not_entrant) {
87684f1a88b5 6614597: Performance variability in jvm2008 xml.validation kvn parents: 1204 diff changeset	1614 if (!nm->make_not_entrant()) {
87684f1a88b5 6614597: Performance variability in jvm2008 xml.validation kvn parents: 1204 diff changeset	1615 return; // the call did not change nmethod's state
87684f1a88b5 6614597: Performance variability in jvm2008 xml.validation kvn parents: 1204 diff changeset	1616 }
87684f1a88b5 6614597: Performance variability in jvm2008 xml.validation kvn parents: 1204 diff changeset	1617
87684f1a88b5 6614597: Performance variability in jvm2008 xml.validation kvn parents: 1204 diff changeset	1618 if (pdata != NULL) {
0 a61af66fc99e Initial load duke parents: diff changeset	1619 // Record the recompilation event, if any.
a61af66fc99e Initial load duke parents: diff changeset	1620 int tstate0 = pdata->trap_state();
a61af66fc99e Initial load duke parents: diff changeset	1621 int tstate1 = trap_state_set_recompiled(tstate0, true);
a61af66fc99e Initial load duke parents: diff changeset	1622 if (tstate1 != tstate0)
a61af66fc99e Initial load duke parents: diff changeset	1623 pdata->set_trap_state(tstate1);
a61af66fc99e Initial load duke parents: diff changeset	1624 }
a61af66fc99e Initial load duke parents: diff changeset	1625 }
a61af66fc99e Initial load duke parents: diff changeset	1626
1206 87684f1a88b5 6614597: Performance variability in jvm2008 xml.validation kvn parents: 1204 diff changeset	1627 if (inc_recompile_count) {
87684f1a88b5 6614597: Performance variability in jvm2008 xml.validation kvn parents: 1204 diff changeset	1628 trap_mdo->inc_overflow_recompile_count();
87684f1a88b5 6614597: Performance variability in jvm2008 xml.validation kvn parents: 1204 diff changeset	1629 if ((uint)trap_mdo->overflow_recompile_count() >
87684f1a88b5 6614597: Performance variability in jvm2008 xml.validation kvn parents: 1204 diff changeset	1630 (uint)PerBytecodeRecompilationCutoff) {
87684f1a88b5 6614597: Performance variability in jvm2008 xml.validation kvn parents: 1204 diff changeset	1631 // Give up on the method containing the bad BCI.
87684f1a88b5 6614597: Performance variability in jvm2008 xml.validation kvn parents: 1204 diff changeset	1632 if (trap_method() == nm->method()) {
87684f1a88b5 6614597: Performance variability in jvm2008 xml.validation kvn parents: 1204 diff changeset	1633 make_not_compilable = true;
87684f1a88b5 6614597: Performance variability in jvm2008 xml.validation kvn parents: 1204 diff changeset	1634 } else {
7998 6a51fc70a15e 8006613: adding reason to made_not_compilable vlivanov parents: 7206 diff changeset	1635 trap_method->set_not_compilable(CompLevel_full_optimization, true, "overflow_recompile_count > PerBytecodeRecompilationCutoff");
1206 87684f1a88b5 6614597: Performance variability in jvm2008 xml.validation kvn parents: 1204 diff changeset	1636 // But give grace to the enclosing nm->method().
87684f1a88b5 6614597: Performance variability in jvm2008 xml.validation kvn parents: 1204 diff changeset	1637 }
87684f1a88b5 6614597: Performance variability in jvm2008 xml.validation kvn parents: 1204 diff changeset	1638 }
87684f1a88b5 6614597: Performance variability in jvm2008 xml.validation kvn parents: 1204 diff changeset	1639 }
0 a61af66fc99e Initial load duke parents: diff changeset	1640
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1692 diff changeset	1641 // Reprofile
d5d065957597 6953144: Tiered compilation iveresov parents: 1692 diff changeset	1642 if (reprofile) {
d5d065957597 6953144: Tiered compilation iveresov parents: 1692 diff changeset	1643 CompilationPolicy::policy()->reprofile(trap_scope, nm->is_osr_method());
0 a61af66fc99e Initial load duke parents: diff changeset	1644 }
a61af66fc99e Initial load duke parents: diff changeset	1645
a61af66fc99e Initial load duke parents: diff changeset	1646 // Give up compiling
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1692 diff changeset	1647 if (make_not_compilable && !nm->method()->is_not_compilable(CompLevel_full_optimization)) {
0 a61af66fc99e Initial load duke parents: diff changeset	1648 assert(make_not_entrant, "consistent");
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1692 diff changeset	1649 nm->method()->set_not_compilable(CompLevel_full_optimization);
0 a61af66fc99e Initial load duke parents: diff changeset	1650 }
a61af66fc99e Initial load duke parents: diff changeset	1651
a61af66fc99e Initial load duke parents: diff changeset	1652 } // Free marked resources
a61af66fc99e Initial load duke parents: diff changeset	1653
a61af66fc99e Initial load duke parents: diff changeset	1654 }
a61af66fc99e Initial load duke parents: diff changeset	1655 JRT_END
a61af66fc99e Initial load duke parents: diff changeset	1656
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1657 MethodData*
0 a61af66fc99e Initial load duke parents: diff changeset	1658 Deoptimization::get_method_data(JavaThread* thread, methodHandle m,
a61af66fc99e Initial load duke parents: diff changeset	1659 bool create_if_missing) {
a61af66fc99e Initial load duke parents: diff changeset	1660 Thread* THREAD = thread;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1661 MethodData* mdo = m()->method_data();
0 a61af66fc99e Initial load duke parents: diff changeset	1662 if (mdo == NULL && create_if_missing && !HAS_PENDING_EXCEPTION) {
a61af66fc99e Initial load duke parents: diff changeset	1663 // Build an MDO. Ignore errors like OutOfMemory;
a61af66fc99e Initial load duke parents: diff changeset	1664 // that simply means we won't have an MDO to update.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1665 Method::build_interpreter_method_data(m, THREAD);
0 a61af66fc99e Initial load duke parents: diff changeset	1666 if (HAS_PENDING_EXCEPTION) {
a61af66fc99e Initial load duke parents: diff changeset	1667 assert((PENDING_EXCEPTION->is_a(SystemDictionary::OutOfMemoryError_klass())), "we expect only an OOM error here");
a61af66fc99e Initial load duke parents: diff changeset	1668 CLEAR_PENDING_EXCEPTION;
a61af66fc99e Initial load duke parents: diff changeset	1669 }
a61af66fc99e Initial load duke parents: diff changeset	1670 mdo = m()->method_data();
a61af66fc99e Initial load duke parents: diff changeset	1671 }
a61af66fc99e Initial load duke parents: diff changeset	1672 return mdo;
a61af66fc99e Initial load duke parents: diff changeset	1673 }
a61af66fc99e Initial load duke parents: diff changeset	1674
a61af66fc99e Initial load duke parents: diff changeset	1675 ProfileData*
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1676 Deoptimization::query_update_method_data(MethodData* trap_mdo,
0 a61af66fc99e Initial load duke parents: diff changeset	1677 int trap_bci,
a61af66fc99e Initial load duke parents: diff changeset	1678 Deoptimization::DeoptReason reason,
5114 dad1ac9dba7d finished first implementation of disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 5110 diff changeset	1679 bool update_total_trap_count,
0 a61af66fc99e Initial load duke parents: diff changeset	1680 //outputs:
a61af66fc99e Initial load duke parents: diff changeset	1681 uint& ret_this_trap_count,
a61af66fc99e Initial load duke parents: diff changeset	1682 bool& ret_maybe_prior_trap,
a61af66fc99e Initial load duke parents: diff changeset	1683 bool& ret_maybe_prior_recompile) {
5114 dad1ac9dba7d finished first implementation of disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 5110 diff changeset	1684 bool maybe_prior_trap = false;
dad1ac9dba7d finished first implementation of disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 5110 diff changeset	1685 bool maybe_prior_recompile = false;
dad1ac9dba7d finished first implementation of disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 5110 diff changeset	1686 uint this_trap_count = 0;
dad1ac9dba7d finished first implementation of disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 5110 diff changeset	1687 if (update_total_trap_count) {
dad1ac9dba7d finished first implementation of disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 5110 diff changeset	1688 uint prior_trap_count = trap_mdo->trap_count(reason);
dad1ac9dba7d finished first implementation of disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 5110 diff changeset	1689 this_trap_count = trap_mdo->inc_trap_count(reason);
0 a61af66fc99e Initial load duke parents: diff changeset	1690
5114 dad1ac9dba7d finished first implementation of disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 5110 diff changeset	1691 // If the runtime cannot find a place to store trap history,
dad1ac9dba7d finished first implementation of disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 5110 diff changeset	1692 // it is estimated based on the general condition of the method.
dad1ac9dba7d finished first implementation of disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 5110 diff changeset	1693 // If the method has ever been recompiled, or has ever incurred
dad1ac9dba7d finished first implementation of disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 5110 diff changeset	1694 // a trap with the present reason , then this BCI is assumed
dad1ac9dba7d finished first implementation of disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 5110 diff changeset	1695 // (pessimistically) to be the culprit.
dad1ac9dba7d finished first implementation of disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 5110 diff changeset	1696 maybe_prior_trap = (prior_trap_count != 0);
dad1ac9dba7d finished first implementation of disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 5110 diff changeset	1697 maybe_prior_recompile = (trap_mdo->decompile_count() != 0);
dad1ac9dba7d finished first implementation of disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 5110 diff changeset	1698 }
0 a61af66fc99e Initial load duke parents: diff changeset	1699
a61af66fc99e Initial load duke parents: diff changeset	1700 // For reasons which are recorded per bytecode, we check per-BCI data.
5114 dad1ac9dba7d finished first implementation of disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 5110 diff changeset	1701 ProfileData* pdata = NULL;
0 a61af66fc99e Initial load duke parents: diff changeset	1702 DeoptReason per_bc_reason = reason_recorded_per_bytecode_if_any(reason);
5121 34518fd74518 fixed fastdebug C++ issue Christian Haeubl <christian.haeubl@oracle.com> parents: 5114 diff changeset	1703 assert(per_bc_reason != Reason_none \|\| update_total_trap_count, "must be");
0 a61af66fc99e Initial load duke parents: diff changeset	1704 if (per_bc_reason != Reason_none) {
a61af66fc99e Initial load duke parents: diff changeset	1705 // Find the profile data for this BCI. If there isn't one,
a61af66fc99e Initial load duke parents: diff changeset	1706 // try to allocate one from the MDO's set of spares.
a61af66fc99e Initial load duke parents: diff changeset	1707 // This will let us detect a repeated trap at this point.
a61af66fc99e Initial load duke parents: diff changeset	1708 pdata = trap_mdo->allocate_bci_to_data(trap_bci);
a61af66fc99e Initial load duke parents: diff changeset	1709
a61af66fc99e Initial load duke parents: diff changeset	1710 if (pdata != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	1711 // Query the trap state of this profile datum.
a61af66fc99e Initial load duke parents: diff changeset	1712 int tstate0 = pdata->trap_state();
a61af66fc99e Initial load duke parents: diff changeset	1713 if (!trap_state_has_reason(tstate0, per_bc_reason))
a61af66fc99e Initial load duke parents: diff changeset	1714 maybe_prior_trap = false;
a61af66fc99e Initial load duke parents: diff changeset	1715 if (!trap_state_is_recompiled(tstate0))
a61af66fc99e Initial load duke parents: diff changeset	1716 maybe_prior_recompile = false;
a61af66fc99e Initial load duke parents: diff changeset	1717
a61af66fc99e Initial load duke parents: diff changeset	1718 // Update the trap state of this profile datum.
a61af66fc99e Initial load duke parents: diff changeset	1719 int tstate1 = tstate0;
a61af66fc99e Initial load duke parents: diff changeset	1720 // Record the reason.
a61af66fc99e Initial load duke parents: diff changeset	1721 tstate1 = trap_state_add_reason(tstate1, per_bc_reason);
a61af66fc99e Initial load duke parents: diff changeset	1722 // Store the updated state on the MDO, for next time.
a61af66fc99e Initial load duke parents: diff changeset	1723 if (tstate1 != tstate0)
a61af66fc99e Initial load duke parents: diff changeset	1724 pdata->set_trap_state(tstate1);
a61af66fc99e Initial load duke parents: diff changeset	1725 } else {
1206 87684f1a88b5 6614597: Performance variability in jvm2008 xml.validation kvn parents: 1204 diff changeset	1726 if (LogCompilation && xtty != NULL) {
87684f1a88b5 6614597: Performance variability in jvm2008 xml.validation kvn parents: 1204 diff changeset	1727 ttyLocker ttyl;
0 a61af66fc99e Initial load duke parents: diff changeset	1728 // Missing MDP? Leave a small complaint in the log.
a61af66fc99e Initial load duke parents: diff changeset	1729 xtty->elem("missing_mdp bci='%d'", trap_bci);
1206 87684f1a88b5 6614597: Performance variability in jvm2008 xml.validation kvn parents: 1204 diff changeset	1730 }
0 a61af66fc99e Initial load duke parents: diff changeset	1731 }
a61af66fc99e Initial load duke parents: diff changeset	1732 }
a61af66fc99e Initial load duke parents: diff changeset	1733
a61af66fc99e Initial load duke parents: diff changeset	1734 // Return results:
a61af66fc99e Initial load duke parents: diff changeset	1735 ret_this_trap_count = this_trap_count;
a61af66fc99e Initial load duke parents: diff changeset	1736 ret_maybe_prior_trap = maybe_prior_trap;
a61af66fc99e Initial load duke parents: diff changeset	1737 ret_maybe_prior_recompile = maybe_prior_recompile;
a61af66fc99e Initial load duke parents: diff changeset	1738 return pdata;
a61af66fc99e Initial load duke parents: diff changeset	1739 }
a61af66fc99e Initial load duke parents: diff changeset	1740
a61af66fc99e Initial load duke parents: diff changeset	1741 void
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1742 Deoptimization::update_method_data_from_interpreter(MethodData* trap_mdo, int trap_bci, int reason) {
0 a61af66fc99e Initial load duke parents: diff changeset	1743 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	1744 // Ignored outputs:
a61af66fc99e Initial load duke parents: diff changeset	1745 uint ignore_this_trap_count;
a61af66fc99e Initial load duke parents: diff changeset	1746 bool ignore_maybe_prior_trap;
a61af66fc99e Initial load duke parents: diff changeset	1747 bool ignore_maybe_prior_recompile;
5114 dad1ac9dba7d finished first implementation of disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 5110 diff changeset	1748 // Graal uses the total counts to determine if deoptimizations are happening too frequently -> do not adjust total counts
5130 ab038e0d6b43 Merge Lukas Stadler <lukas.stadler@jku.at> parents: 5129 5121 diff changeset	1749 bool update_total_counts = GRAAL_ONLY(false) NOT_GRAAL(true);
0 a61af66fc99e Initial load duke parents: diff changeset	1750 query_update_method_data(trap_mdo, trap_bci,
a61af66fc99e Initial load duke parents: diff changeset	1751 (DeoptReason)reason,
5114 dad1ac9dba7d finished first implementation of disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 5110 diff changeset	1752 update_total_counts,
0 a61af66fc99e Initial load duke parents: diff changeset	1753 ignore_this_trap_count,
a61af66fc99e Initial load duke parents: diff changeset	1754 ignore_maybe_prior_trap,
a61af66fc99e Initial load duke parents: diff changeset	1755 ignore_maybe_prior_recompile);
a61af66fc99e Initial load duke parents: diff changeset	1756 }
a61af66fc99e Initial load duke parents: diff changeset	1757
a61af66fc99e Initial load duke parents: diff changeset	1758 Deoptimization::UnrollBlock* Deoptimization::uncommon_trap(JavaThread* thread, jint trap_request) {
4674 e1c053324210 changed TraceDeoptimization output Christian Haeubl <christian.haeubl@oracle.com> parents: 4668 diff changeset	1759 if (TraceDeoptimization) {
e1c053324210 changed TraceDeoptimization output Christian Haeubl <christian.haeubl@oracle.com> parents: 4668 diff changeset	1760 tty->print("Uncommon trap ");
e1c053324210 changed TraceDeoptimization output Christian Haeubl <christian.haeubl@oracle.com> parents: 4668 diff changeset	1761 }
0 a61af66fc99e Initial load duke parents: diff changeset	1762 // Still in Java no safepoints
a61af66fc99e Initial load duke parents: diff changeset	1763 {
a61af66fc99e Initial load duke parents: diff changeset	1764 // This enters VM and may safepoint
a61af66fc99e Initial load duke parents: diff changeset	1765 uncommon_trap_inner(thread, trap_request);
a61af66fc99e Initial load duke parents: diff changeset	1766 }
a61af66fc99e Initial load duke parents: diff changeset	1767 return fetch_unroll_info_helper(thread);
a61af66fc99e Initial load duke parents: diff changeset	1768 }
a61af66fc99e Initial load duke parents: diff changeset	1769
a61af66fc99e Initial load duke parents: diff changeset	1770 // Local derived constants.
a61af66fc99e Initial load duke parents: diff changeset	1771 // Further breakdown of DataLayout::trap_state, as promised by DataLayout.
a61af66fc99e Initial load duke parents: diff changeset	1772 const int DS_REASON_MASK = DataLayout::trap_mask >> 1;
a61af66fc99e Initial load duke parents: diff changeset	1773 const int DS_RECOMPILE_BIT = DataLayout::trap_mask - DS_REASON_MASK;
a61af66fc99e Initial load duke parents: diff changeset	1774
a61af66fc99e Initial load duke parents: diff changeset	1775 //---------------------------trap_state_reason---------------------------------
a61af66fc99e Initial load duke parents: diff changeset	1776 Deoptimization::DeoptReason
a61af66fc99e Initial load duke parents: diff changeset	1777 Deoptimization::trap_state_reason(int trap_state) {
a61af66fc99e Initial load duke parents: diff changeset	1778 // This assert provides the link between the width of DataLayout::trap_bits
a61af66fc99e Initial load duke parents: diff changeset	1779 // and the encoding of "recorded" reasons. It ensures there are enough
a61af66fc99e Initial load duke parents: diff changeset	1780 // bits to store all needed reasons in the per-BCI MDO profile.
a61af66fc99e Initial load duke parents: diff changeset	1781 assert(DS_REASON_MASK >= Reason_RECORDED_LIMIT, "enough bits");
a61af66fc99e Initial load duke parents: diff changeset	1782 int recompile_bit = (trap_state & DS_RECOMPILE_BIT);
a61af66fc99e Initial load duke parents: diff changeset	1783 trap_state -= recompile_bit;
a61af66fc99e Initial load duke parents: diff changeset	1784 if (trap_state == DS_REASON_MASK) {
a61af66fc99e Initial load duke parents: diff changeset	1785 return Reason_many;
a61af66fc99e Initial load duke parents: diff changeset	1786 } else {
a61af66fc99e Initial load duke parents: diff changeset	1787 assert((int)Reason_none == 0, "state=0 => Reason_none");
a61af66fc99e Initial load duke parents: diff changeset	1788 return (DeoptReason)trap_state;
a61af66fc99e Initial load duke parents: diff changeset	1789 }
a61af66fc99e Initial load duke parents: diff changeset	1790 }
a61af66fc99e Initial load duke parents: diff changeset	1791 //-------------------------trap_state_has_reason-------------------------------
a61af66fc99e Initial load duke parents: diff changeset	1792 int Deoptimization::trap_state_has_reason(int trap_state, int reason) {
a61af66fc99e Initial load duke parents: diff changeset	1793 assert(reason_is_recorded_per_bytecode((DeoptReason)reason), "valid reason");
a61af66fc99e Initial load duke parents: diff changeset	1794 assert(DS_REASON_MASK >= Reason_RECORDED_LIMIT, "enough bits");
a61af66fc99e Initial load duke parents: diff changeset	1795 int recompile_bit = (trap_state & DS_RECOMPILE_BIT);
a61af66fc99e Initial load duke parents: diff changeset	1796 trap_state -= recompile_bit;
a61af66fc99e Initial load duke parents: diff changeset	1797 if (trap_state == DS_REASON_MASK) {
a61af66fc99e Initial load duke parents: diff changeset	1798 return -1; // true, unspecifically (bottom of state lattice)
a61af66fc99e Initial load duke parents: diff changeset	1799 } else if (trap_state == reason) {
a61af66fc99e Initial load duke parents: diff changeset	1800 return 1; // true, definitely
a61af66fc99e Initial load duke parents: diff changeset	1801 } else if (trap_state == 0) {
a61af66fc99e Initial load duke parents: diff changeset	1802 return 0; // false, definitely (top of state lattice)
a61af66fc99e Initial load duke parents: diff changeset	1803 } else {
a61af66fc99e Initial load duke parents: diff changeset	1804 return 0; // false, definitely
a61af66fc99e Initial load duke parents: diff changeset	1805 }
a61af66fc99e Initial load duke parents: diff changeset	1806 }
a61af66fc99e Initial load duke parents: diff changeset	1807 //-------------------------trap_state_add_reason-------------------------------
a61af66fc99e Initial load duke parents: diff changeset	1808 int Deoptimization::trap_state_add_reason(int trap_state, int reason) {
a61af66fc99e Initial load duke parents: diff changeset	1809 assert(reason_is_recorded_per_bytecode((DeoptReason)reason) \|\| reason == Reason_many, "valid reason");
a61af66fc99e Initial load duke parents: diff changeset	1810 int recompile_bit = (trap_state & DS_RECOMPILE_BIT);
a61af66fc99e Initial load duke parents: diff changeset	1811 trap_state -= recompile_bit;
a61af66fc99e Initial load duke parents: diff changeset	1812 if (trap_state == DS_REASON_MASK) {
a61af66fc99e Initial load duke parents: diff changeset	1813 return trap_state + recompile_bit; // already at state lattice bottom
a61af66fc99e Initial load duke parents: diff changeset	1814 } else if (trap_state == reason) {
a61af66fc99e Initial load duke parents: diff changeset	1815 return trap_state + recompile_bit; // the condition is already true
a61af66fc99e Initial load duke parents: diff changeset	1816 } else if (trap_state == 0) {
a61af66fc99e Initial load duke parents: diff changeset	1817 return reason + recompile_bit; // no condition has yet been true
a61af66fc99e Initial load duke parents: diff changeset	1818 } else {
a61af66fc99e Initial load duke parents: diff changeset	1819 return DS_REASON_MASK + recompile_bit; // fall to state lattice bottom
a61af66fc99e Initial load duke parents: diff changeset	1820 }
a61af66fc99e Initial load duke parents: diff changeset	1821 }
a61af66fc99e Initial load duke parents: diff changeset	1822 //-----------------------trap_state_is_recompiled------------------------------
a61af66fc99e Initial load duke parents: diff changeset	1823 bool Deoptimization::trap_state_is_recompiled(int trap_state) {
a61af66fc99e Initial load duke parents: diff changeset	1824 return (trap_state & DS_RECOMPILE_BIT) != 0;
a61af66fc99e Initial load duke parents: diff changeset	1825 }
a61af66fc99e Initial load duke parents: diff changeset	1826 //-----------------------trap_state_set_recompiled-----------------------------
a61af66fc99e Initial load duke parents: diff changeset	1827 int Deoptimization::trap_state_set_recompiled(int trap_state, bool z) {
a61af66fc99e Initial load duke parents: diff changeset	1828 if (z) return trap_state \| DS_RECOMPILE_BIT;
a61af66fc99e Initial load duke parents: diff changeset	1829 else return trap_state & ~DS_RECOMPILE_BIT;
a61af66fc99e Initial load duke parents: diff changeset	1830 }
a61af66fc99e Initial load duke parents: diff changeset	1831 //---------------------------format_trap_state---------------------------------
a61af66fc99e Initial load duke parents: diff changeset	1832 // This is used for debugging and diagnostics, including hotspot.log output.
a61af66fc99e Initial load duke parents: diff changeset	1833 const char* Deoptimization::format_trap_state(char* buf, size_t buflen,
a61af66fc99e Initial load duke parents: diff changeset	1834 int trap_state) {
a61af66fc99e Initial load duke parents: diff changeset	1835 DeoptReason reason = trap_state_reason(trap_state);
a61af66fc99e Initial load duke parents: diff changeset	1836 bool recomp_flag = trap_state_is_recompiled(trap_state);
a61af66fc99e Initial load duke parents: diff changeset	1837 // Re-encode the state from its decoded components.
a61af66fc99e Initial load duke parents: diff changeset	1838 int decoded_state = 0;
a61af66fc99e Initial load duke parents: diff changeset	1839 if (reason_is_recorded_per_bytecode(reason) \|\| reason == Reason_many)
a61af66fc99e Initial load duke parents: diff changeset	1840 decoded_state = trap_state_add_reason(decoded_state, reason);
a61af66fc99e Initial load duke parents: diff changeset	1841 if (recomp_flag)
a61af66fc99e Initial load duke parents: diff changeset	1842 decoded_state = trap_state_set_recompiled(decoded_state, recomp_flag);
a61af66fc99e Initial load duke parents: diff changeset	1843 // If the state re-encodes properly, format it symbolically.
a61af66fc99e Initial load duke parents: diff changeset	1844 // Because this routine is used for debugging and diagnostics,
a61af66fc99e Initial load duke parents: diff changeset	1845 // be robust even if the state is a strange value.
a61af66fc99e Initial load duke parents: diff changeset	1846 size_t len;
a61af66fc99e Initial load duke parents: diff changeset	1847 if (decoded_state != trap_state) {
a61af66fc99e Initial load duke parents: diff changeset	1848 // Random buggy state that doesn't decode??
a61af66fc99e Initial load duke parents: diff changeset	1849 len = jio_snprintf(buf, buflen, "#%d", trap_state);
a61af66fc99e Initial load duke parents: diff changeset	1850 } else {
a61af66fc99e Initial load duke parents: diff changeset	1851 len = jio_snprintf(buf, buflen, "%s%s",
a61af66fc99e Initial load duke parents: diff changeset	1852 trap_reason_name(reason),
a61af66fc99e Initial load duke parents: diff changeset	1853 recomp_flag ? " recompiled" : "");
a61af66fc99e Initial load duke parents: diff changeset	1854 }
a61af66fc99e Initial load duke parents: diff changeset	1855 if (len >= buflen)
a61af66fc99e Initial load duke parents: diff changeset	1856 buf[buflen-1] = '\0';
a61af66fc99e Initial load duke parents: diff changeset	1857 return buf;
a61af66fc99e Initial load duke parents: diff changeset	1858 }
a61af66fc99e Initial load duke parents: diff changeset	1859
a61af66fc99e Initial load duke parents: diff changeset	1860
a61af66fc99e Initial load duke parents: diff changeset	1861 //--------------------------------statics--------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	1862 Deoptimization::DeoptAction Deoptimization::_unloaded_action
a61af66fc99e Initial load duke parents: diff changeset	1863 = Deoptimization::Action_reinterpret;
a61af66fc99e Initial load duke parents: diff changeset	1864 const char* Deoptimization::_trap_reason_name[Reason_LIMIT] = {
a61af66fc99e Initial load duke parents: diff changeset	1865 // Note: Keep this in sync. with enum DeoptReason.
a61af66fc99e Initial load duke parents: diff changeset	1866 "none",
a61af66fc99e Initial load duke parents: diff changeset	1867 "null_check",
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: 7137 diff changeset	1868 "null_assert" GRAAL_ONLY("\|unreached0"),
0 a61af66fc99e Initial load duke parents: diff changeset	1869 "range_check",
a61af66fc99e Initial load duke parents: diff changeset	1870 "class_check",
a61af66fc99e Initial load duke parents: diff changeset	1871 "array_check",
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: 7137 diff changeset	1872 "intrinsic" GRAAL_ONLY("\|type_checked_inlining"),
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: 7137 diff changeset	1873 "bimorphic" GRAAL_ONLY("\|optimized_type_check"),
0 a61af66fc99e Initial load duke parents: diff changeset	1874 "unloaded",
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: 7137 diff changeset	1875 "uninitialized" GRAAL_ONLY("\|unresolved"),
0 a61af66fc99e Initial load duke parents: diff changeset	1876 "unreached",
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: 7137 diff changeset	1877 "unhandled" GRAAL_ONLY("\|not_compiled_exception_handler"),
0 a61af66fc99e Initial load duke parents: diff changeset	1878 "constraint",
a61af66fc99e Initial load duke parents: diff changeset	1879 "div0_check",
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: 7137 diff changeset	1880 "age" GRAAL_ONLY("\|jsr_mismatch"),
3345 bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 3336 diff changeset	1881 "predicate",
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 3336 diff changeset	1882 "loop_limit_check"
0 a61af66fc99e Initial load duke parents: diff changeset	1883 };
a61af66fc99e Initial load duke parents: diff changeset	1884 const char* Deoptimization::_trap_action_name[Action_LIMIT] = {
a61af66fc99e Initial load duke parents: diff changeset	1885 // Note: Keep this in sync. with enum DeoptAction.
a61af66fc99e Initial load duke parents: diff changeset	1886 "none",
a61af66fc99e Initial load duke parents: diff changeset	1887 "maybe_recompile",
a61af66fc99e Initial load duke parents: diff changeset	1888 "reinterpret",
a61af66fc99e Initial load duke parents: diff changeset	1889 "make_not_entrant",
a61af66fc99e Initial load duke parents: diff changeset	1890 "make_not_compilable"
a61af66fc99e Initial load duke parents: diff changeset	1891 };
a61af66fc99e Initial load duke parents: diff changeset	1892
a61af66fc99e Initial load duke parents: diff changeset	1893 const char* Deoptimization::trap_reason_name(int reason) {
a61af66fc99e Initial load duke parents: diff changeset	1894 if (reason == Reason_many) return "many";
a61af66fc99e Initial load duke parents: diff changeset	1895 if ((uint)reason < Reason_LIMIT)
a61af66fc99e Initial load duke parents: diff changeset	1896 return _trap_reason_name[reason];
a61af66fc99e Initial load duke parents: diff changeset	1897 static char buf[20];
a61af66fc99e Initial load duke parents: diff changeset	1898 sprintf(buf, "reason%d", reason);
a61af66fc99e Initial load duke parents: diff changeset	1899 return buf;
a61af66fc99e Initial load duke parents: diff changeset	1900 }
a61af66fc99e Initial load duke parents: diff changeset	1901 const char* Deoptimization::trap_action_name(int action) {
a61af66fc99e Initial load duke parents: diff changeset	1902 if ((uint)action < Action_LIMIT)
a61af66fc99e Initial load duke parents: diff changeset	1903 return _trap_action_name[action];
a61af66fc99e Initial load duke parents: diff changeset	1904 static char buf[20];
a61af66fc99e Initial load duke parents: diff changeset	1905 sprintf(buf, "action%d", action);
a61af66fc99e Initial load duke parents: diff changeset	1906 return buf;
a61af66fc99e Initial load duke parents: diff changeset	1907 }
a61af66fc99e Initial load duke parents: diff changeset	1908
a61af66fc99e Initial load duke parents: diff changeset	1909 // This is used for debugging and diagnostics, including hotspot.log output.
a61af66fc99e Initial load duke parents: diff changeset	1910 const char* Deoptimization::format_trap_request(char* buf, size_t buflen,
a61af66fc99e Initial load duke parents: diff changeset	1911 int trap_request) {
a61af66fc99e Initial load duke parents: diff changeset	1912 jint unloaded_class_index = trap_request_index(trap_request);
a61af66fc99e Initial load duke parents: diff changeset	1913 const char* reason = trap_reason_name(trap_request_reason(trap_request));
a61af66fc99e Initial load duke parents: diff changeset	1914 const char* action = trap_action_name(trap_request_action(trap_request));
a61af66fc99e Initial load duke parents: diff changeset	1915 size_t len;
a61af66fc99e Initial load duke parents: diff changeset	1916 if (unloaded_class_index < 0) {
a61af66fc99e Initial load duke parents: diff changeset	1917 len = jio_snprintf(buf, buflen, "reason='%s' action='%s'",
a61af66fc99e Initial load duke parents: diff changeset	1918 reason, action);
a61af66fc99e Initial load duke parents: diff changeset	1919 } else {
a61af66fc99e Initial load duke parents: diff changeset	1920 len = jio_snprintf(buf, buflen, "reason='%s' action='%s' index='%d'",
a61af66fc99e Initial load duke parents: diff changeset	1921 reason, action, unloaded_class_index);
a61af66fc99e Initial load duke parents: diff changeset	1922 }
a61af66fc99e Initial load duke parents: diff changeset	1923 if (len >= buflen)
a61af66fc99e Initial load duke parents: diff changeset	1924 buf[buflen-1] = '\0';
a61af66fc99e Initial load duke parents: diff changeset	1925 return buf;
a61af66fc99e Initial load duke parents: diff changeset	1926 }
a61af66fc99e Initial load duke parents: diff changeset	1927
a61af66fc99e Initial load duke parents: diff changeset	1928 juint Deoptimization::_deoptimization_hist
a61af66fc99e Initial load duke parents: diff changeset	1929 [Deoptimization::Reason_LIMIT]
a61af66fc99e Initial load duke parents: diff changeset	1930 [1 + Deoptimization::Action_LIMIT]
a61af66fc99e Initial load duke parents: diff changeset	1931 [Deoptimization::BC_CASE_LIMIT]
a61af66fc99e Initial load duke parents: diff changeset	1932 = {0};
a61af66fc99e Initial load duke parents: diff changeset	1933
a61af66fc99e Initial load duke parents: diff changeset	1934 enum {
a61af66fc99e Initial load duke parents: diff changeset	1935 LSB_BITS = 8,
a61af66fc99e Initial load duke parents: diff changeset	1936 LSB_MASK = right_n_bits(LSB_BITS)
a61af66fc99e Initial load duke parents: diff changeset	1937 };
a61af66fc99e Initial load duke parents: diff changeset	1938
a61af66fc99e Initial load duke parents: diff changeset	1939 void Deoptimization::gather_statistics(DeoptReason reason, DeoptAction action,
a61af66fc99e Initial load duke parents: diff changeset	1940 Bytecodes::Code bc) {
a61af66fc99e Initial load duke parents: diff changeset	1941 assert(reason >= 0 && reason < Reason_LIMIT, "oob");
a61af66fc99e Initial load duke parents: diff changeset	1942 assert(action >= 0 && action < Action_LIMIT, "oob");
a61af66fc99e Initial load duke parents: diff changeset	1943 _deoptimization_hist[Reason_none][0][0] += 1; // total
a61af66fc99e Initial load duke parents: diff changeset	1944 _deoptimization_hist[reason][0][0] += 1; // per-reason total
a61af66fc99e Initial load duke parents: diff changeset	1945 juint* cases = _deoptimization_hist[reason][1+action];
a61af66fc99e Initial load duke parents: diff changeset	1946 juint* bc_counter_addr = NULL;
a61af66fc99e Initial load duke parents: diff changeset	1947 juint bc_counter = 0;
a61af66fc99e Initial load duke parents: diff changeset	1948 // Look for an unused counter, or an exact match to this BC.
a61af66fc99e Initial load duke parents: diff changeset	1949 if (bc != Bytecodes::_illegal) {
a61af66fc99e Initial load duke parents: diff changeset	1950 for (int bc_case = 0; bc_case < BC_CASE_LIMIT; bc_case++) {
a61af66fc99e Initial load duke parents: diff changeset	1951 juint* counter_addr = &cases[bc_case];
a61af66fc99e Initial load duke parents: diff changeset	1952 juint counter = *counter_addr;
a61af66fc99e Initial load duke parents: diff changeset	1953 if ((counter == 0 && bc_counter_addr == NULL)
a61af66fc99e Initial load duke parents: diff changeset	1954 \|\| (Bytecodes::Code)(counter & LSB_MASK) == bc) {
a61af66fc99e Initial load duke parents: diff changeset	1955 // this counter is either free or is already devoted to this BC
a61af66fc99e Initial load duke parents: diff changeset	1956 bc_counter_addr = counter_addr;
a61af66fc99e Initial load duke parents: diff changeset	1957 bc_counter = counter \| bc;
a61af66fc99e Initial load duke parents: diff changeset	1958 }
a61af66fc99e Initial load duke parents: diff changeset	1959 }
a61af66fc99e Initial load duke parents: diff changeset	1960 }
a61af66fc99e Initial load duke parents: diff changeset	1961 if (bc_counter_addr == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	1962 // Overflow, or no given bytecode.
a61af66fc99e Initial load duke parents: diff changeset	1963 bc_counter_addr = &cases[BC_CASE_LIMIT-1];
a61af66fc99e Initial load duke parents: diff changeset	1964 bc_counter = (*bc_counter_addr & ~LSB_MASK); // clear LSB
a61af66fc99e Initial load duke parents: diff changeset	1965 }
a61af66fc99e Initial load duke parents: diff changeset	1966 *bc_counter_addr = bc_counter + (1 << LSB_BITS);
a61af66fc99e Initial load duke parents: diff changeset	1967 }
a61af66fc99e Initial load duke parents: diff changeset	1968
a61af66fc99e Initial load duke parents: diff changeset	1969 jint Deoptimization::total_deoptimization_count() {
a61af66fc99e Initial load duke parents: diff changeset	1970 return _deoptimization_hist[Reason_none][0][0];
a61af66fc99e Initial load duke parents: diff changeset	1971 }
a61af66fc99e Initial load duke parents: diff changeset	1972
a61af66fc99e Initial load duke parents: diff changeset	1973 jint Deoptimization::deoptimization_count(DeoptReason reason) {
a61af66fc99e Initial load duke parents: diff changeset	1974 assert(reason >= 0 && reason < Reason_LIMIT, "oob");
a61af66fc99e Initial load duke parents: diff changeset	1975 return _deoptimization_hist[reason][0][0];
a61af66fc99e Initial load duke parents: diff changeset	1976 }
a61af66fc99e Initial load duke parents: diff changeset	1977
a61af66fc99e Initial load duke parents: diff changeset	1978 void Deoptimization::print_statistics() {
a61af66fc99e Initial load duke parents: diff changeset	1979 juint total = total_deoptimization_count();
a61af66fc99e Initial load duke parents: diff changeset	1980 juint account = total;
a61af66fc99e Initial load duke parents: diff changeset	1981 if (total != 0) {
a61af66fc99e Initial load duke parents: diff changeset	1982 ttyLocker ttyl;
a61af66fc99e Initial load duke parents: diff changeset	1983 if (xtty != NULL) xtty->head("statistics type='deoptimization'");
a61af66fc99e Initial load duke parents: diff changeset	1984 tty->print_cr("Deoptimization traps recorded:");
a61af66fc99e Initial load duke parents: diff changeset	1985 #define PRINT_STAT_LINE(name, r) \
a61af66fc99e Initial load duke parents: diff changeset	1986 tty->print_cr(" %4d (%4.1f%%) %s", (int)(r), ((r) * 100.0) / total, name);
a61af66fc99e Initial load duke parents: diff changeset	1987 PRINT_STAT_LINE("total", total);
a61af66fc99e Initial load duke parents: diff changeset	1988 // For each non-zero entry in the histogram, print the reason,
a61af66fc99e Initial load duke parents: diff changeset	1989 // the action, and (if specifically known) the type of bytecode.
a61af66fc99e Initial load duke parents: diff changeset	1990 for (int reason = 0; reason < Reason_LIMIT; reason++) {
a61af66fc99e Initial load duke parents: diff changeset	1991 for (int action = 0; action < Action_LIMIT; action++) {
a61af66fc99e Initial load duke parents: diff changeset	1992 juint* cases = _deoptimization_hist[reason][1+action];
a61af66fc99e Initial load duke parents: diff changeset	1993 for (int bc_case = 0; bc_case < BC_CASE_LIMIT; bc_case++) {
a61af66fc99e Initial load duke parents: diff changeset	1994 juint counter = cases[bc_case];
a61af66fc99e Initial load duke parents: diff changeset	1995 if (counter != 0) {
a61af66fc99e Initial load duke parents: diff changeset	1996 char name[1*K];
a61af66fc99e Initial load duke parents: diff changeset	1997 Bytecodes::Code bc = (Bytecodes::Code)(counter & LSB_MASK);
a61af66fc99e Initial load duke parents: diff changeset	1998 if (bc_case == BC_CASE_LIMIT && (int)bc == 0)
a61af66fc99e Initial load duke parents: diff changeset	1999 bc = Bytecodes::_illegal;
a61af66fc99e Initial load duke parents: diff changeset	2000 sprintf(name, "%s/%s/%s",
a61af66fc99e Initial load duke parents: diff changeset	2001 trap_reason_name(reason),
a61af66fc99e Initial load duke parents: diff changeset	2002 trap_action_name(action),
a61af66fc99e Initial load duke parents: diff changeset	2003 Bytecodes::is_defined(bc)? Bytecodes::name(bc): "other");
a61af66fc99e Initial load duke parents: diff changeset	2004 juint r = counter >> LSB_BITS;
a61af66fc99e Initial load duke parents: diff changeset	2005 tty->print_cr(" %40s: " UINT32_FORMAT " (%.1f%%)", name, r, (r * 100.0) / total);
a61af66fc99e Initial load duke parents: diff changeset	2006 account -= r;
a61af66fc99e Initial load duke parents: diff changeset	2007 }
a61af66fc99e Initial load duke parents: diff changeset	2008 }
a61af66fc99e Initial load duke parents: diff changeset	2009 }
a61af66fc99e Initial load duke parents: diff changeset	2010 }
a61af66fc99e Initial load duke parents: diff changeset	2011 if (account != 0) {
a61af66fc99e Initial load duke parents: diff changeset	2012 PRINT_STAT_LINE("unaccounted", account);
a61af66fc99e Initial load duke parents: diff changeset	2013 }
a61af66fc99e Initial load duke parents: diff changeset	2014 #undef PRINT_STAT_LINE
a61af66fc99e Initial load duke parents: diff changeset	2015 if (xtty != NULL) xtty->tail("statistics");
a61af66fc99e Initial load duke parents: diff changeset	2016 }
a61af66fc99e Initial load duke parents: diff changeset	2017 }
4978 99d3d8a72252 More ifdef GRAAL usage. Thomas Wuerthinger <thomas.wuerthinger@oracle.com> parents: 4970 diff changeset	2018 #else // COMPILER2 \|\| SHARK \|\| GRAAL
0 a61af66fc99e Initial load duke parents: diff changeset	2019
a61af66fc99e Initial load duke parents: diff changeset	2020
a61af66fc99e Initial load duke parents: diff changeset	2021 // Stubs for C1 only system.
a61af66fc99e Initial load duke parents: diff changeset	2022 bool Deoptimization::trap_state_is_recompiled(int trap_state) {
a61af66fc99e Initial load duke parents: diff changeset	2023 return false;
a61af66fc99e Initial load duke parents: diff changeset	2024 }
a61af66fc99e Initial load duke parents: diff changeset	2025
a61af66fc99e Initial load duke parents: diff changeset	2026 const char* Deoptimization::trap_reason_name(int reason) {
a61af66fc99e Initial load duke parents: diff changeset	2027 return "unknown";
a61af66fc99e Initial load duke parents: diff changeset	2028 }
a61af66fc99e Initial load duke parents: diff changeset	2029
a61af66fc99e Initial load duke parents: diff changeset	2030 void Deoptimization::print_statistics() {
a61af66fc99e Initial load duke parents: diff changeset	2031 // no output
a61af66fc99e Initial load duke parents: diff changeset	2032 }
a61af66fc99e Initial load duke parents: diff changeset	2033
a61af66fc99e Initial load duke parents: diff changeset	2034 void
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2035 Deoptimization::update_method_data_from_interpreter(MethodData* trap_mdo, int trap_bci, int reason) {
0 a61af66fc99e Initial load duke parents: diff changeset	2036 // no udpate
a61af66fc99e Initial load duke parents: diff changeset	2037 }
a61af66fc99e Initial load duke parents: diff changeset	2038
a61af66fc99e Initial load duke parents: diff changeset	2039 int Deoptimization::trap_state_has_reason(int trap_state, int reason) {
a61af66fc99e Initial load duke parents: diff changeset	2040 return 0;
a61af66fc99e Initial load duke parents: diff changeset	2041 }
a61af66fc99e Initial load duke parents: diff changeset	2042
a61af66fc99e Initial load duke parents: diff changeset	2043 void Deoptimization::gather_statistics(DeoptReason reason, DeoptAction action,
a61af66fc99e Initial load duke parents: diff changeset	2044 Bytecodes::Code bc) {
a61af66fc99e Initial load duke parents: diff changeset	2045 // no update
a61af66fc99e Initial load duke parents: diff changeset	2046 }
a61af66fc99e Initial load duke parents: diff changeset	2047
a61af66fc99e Initial load duke parents: diff changeset	2048 const char* Deoptimization::format_trap_state(char* buf, size_t buflen,
a61af66fc99e Initial load duke parents: diff changeset	2049 int trap_state) {
a61af66fc99e Initial load duke parents: diff changeset	2050 jio_snprintf(buf, buflen, "#%d", trap_state);
a61af66fc99e Initial load duke parents: diff changeset	2051 return buf;
a61af66fc99e Initial load duke parents: diff changeset	2052 }
a61af66fc99e Initial load duke parents: diff changeset	2053
4978 99d3d8a72252 More ifdef GRAAL usage. Thomas Wuerthinger <thomas.wuerthinger@oracle.com> parents: 4970 diff changeset	2054 #endif // COMPILER2 \|\| SHARK \|\| GRAAL

Mercurial > hg > truffle

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