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