Mercurial > hg > truffle
annotate src/share/vm/runtime/vframe.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 | 18fb7da42534 |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
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:
1547
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1547
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:
1547
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #include "precompiled.hpp" |
| 26 #include "classfile/javaClasses.hpp" | |
| 27 #include "classfile/systemDictionary.hpp" | |
| 28 #include "classfile/vmSymbols.hpp" | |
| 29 #include "code/codeCache.hpp" | |
| 30 #include "code/debugInfoRec.hpp" | |
| 31 #include "code/nmethod.hpp" | |
| 32 #include "code/pcDesc.hpp" | |
| 33 #include "code/scopeDesc.hpp" | |
| 34 #include "interpreter/interpreter.hpp" | |
| 35 #include "interpreter/oopMapCache.hpp" | |
| 36 #include "memory/resourceArea.hpp" | |
| 37 #include "oops/instanceKlass.hpp" | |
| 38 #include "oops/oop.inline.hpp" | |
| 39 #include "runtime/handles.inline.hpp" | |
| 40 #include "runtime/objectMonitor.hpp" | |
| 41 #include "runtime/objectMonitor.inline.hpp" | |
| 42 #include "runtime/signature.hpp" | |
| 43 #include "runtime/stubRoutines.hpp" | |
| 44 #include "runtime/synchronizer.hpp" | |
| 45 #include "runtime/vframe.hpp" | |
| 46 #include "runtime/vframeArray.hpp" | |
| 47 #include "runtime/vframe_hp.hpp" | |
| 0 | 48 |
| 49 vframe::vframe(const frame* fr, const RegisterMap* reg_map, JavaThread* thread) | |
| 50 : _reg_map(reg_map), _thread(thread) { | |
| 51 assert(fr != NULL, "must have frame"); | |
| 52 _fr = *fr; | |
| 53 } | |
| 54 | |
| 55 vframe::vframe(const frame* fr, JavaThread* thread) | |
| 56 : _reg_map(thread), _thread(thread) { | |
| 57 assert(fr != NULL, "must have frame"); | |
| 58 _fr = *fr; | |
| 59 } | |
| 60 | |
| 61 vframe* vframe::new_vframe(const frame* f, const RegisterMap* reg_map, JavaThread* thread) { | |
| 62 // Interpreter frame | |
| 63 if (f->is_interpreted_frame()) { | |
| 64 return new interpretedVFrame(f, reg_map, thread); | |
| 65 } | |
| 66 | |
| 67 // Compiled frame | |
| 68 CodeBlob* cb = f->cb(); | |
| 69 if (cb != NULL) { | |
| 70 if (cb->is_nmethod()) { | |
| 71 nmethod* nm = (nmethod*)cb; | |
| 72 return new compiledVFrame(f, reg_map, thread, nm); | |
| 73 } | |
| 74 | |
| 75 if (f->is_runtime_frame()) { | |
| 76 // Skip this frame and try again. | |
| 77 RegisterMap temp_map = *reg_map; | |
| 78 frame s = f->sender(&temp_map); | |
| 79 return new_vframe(&s, &temp_map, thread); | |
| 80 } | |
| 81 } | |
| 82 | |
| 83 // External frame | |
| 84 return new externalVFrame(f, reg_map, thread); | |
| 85 } | |
| 86 | |
| 87 vframe* vframe::sender() const { | |
| 88 RegisterMap temp_map = *register_map(); | |
| 89 assert(is_top(), "just checking"); | |
| 90 if (_fr.is_entry_frame() && _fr.is_first_frame()) return NULL; | |
| 91 frame s = _fr.real_sender(&temp_map); | |
| 92 if (s.is_first_frame()) return NULL; | |
| 93 return vframe::new_vframe(&s, &temp_map, thread()); | |
| 94 } | |
| 95 | |
| 96 vframe* vframe::top() const { | |
| 97 vframe* vf = (vframe*) this; | |
| 98 while (!vf->is_top()) vf = vf->sender(); | |
| 99 return vf; | |
| 100 } | |
| 101 | |
| 102 | |
| 103 javaVFrame* vframe::java_sender() const { | |
| 104 vframe* f = sender(); | |
| 105 while (f != NULL) { | |
| 106 if (f->is_java_frame()) return javaVFrame::cast(f); | |
| 107 f = f->sender(); | |
| 108 } | |
| 109 return NULL; | |
| 110 } | |
| 111 | |
| 112 // ------------- javaVFrame -------------- | |
| 113 | |
| 114 GrowableArray<MonitorInfo*>* javaVFrame::locked_monitors() { | |
| 115 assert(SafepointSynchronize::is_at_safepoint() || JavaThread::current() == thread(), | |
| 116 "must be at safepoint or it's a java frame of the current thread"); | |
| 117 | |
| 118 GrowableArray<MonitorInfo*>* mons = monitors(); | |
| 119 GrowableArray<MonitorInfo*>* result = new GrowableArray<MonitorInfo*>(mons->length()); | |
| 120 if (mons->is_empty()) return result; | |
| 121 | |
| 122 bool found_first_monitor = false; | |
| 123 ObjectMonitor *pending_monitor = thread()->current_pending_monitor(); | |
| 124 ObjectMonitor *waiting_monitor = thread()->current_waiting_monitor(); | |
|
1547
fb1a39993f69
6951319: enable solaris builds using Sun Studio 12 update 1
jcoomes
parents:
1506
diff
changeset
|
125 oop pending_obj = (pending_monitor != NULL ? (oop) pending_monitor->object() : (oop) NULL); |
|
fb1a39993f69
6951319: enable solaris builds using Sun Studio 12 update 1
jcoomes
parents:
1506
diff
changeset
|
126 oop waiting_obj = (waiting_monitor != NULL ? (oop) waiting_monitor->object() : (oop) NULL); |
| 0 | 127 |
| 128 for (int index = (mons->length()-1); index >= 0; index--) { | |
| 129 MonitorInfo* monitor = mons->at(index); | |
|
818
b109e761e927
6837472: com/sun/jdi/MonitorFrameInfo.java fails with AggressiveOpts in 6u14
kvn
parents:
793
diff
changeset
|
130 if (monitor->eliminated() && is_compiled_frame()) continue; // skip eliminated monitor |
| 0 | 131 oop obj = monitor->owner(); |
| 132 if (obj == NULL) continue; // skip unowned monitor | |
| 133 // | |
| 134 // Skip the monitor that the thread is blocked to enter or waiting on | |
| 135 // | |
| 136 if (!found_first_monitor && (obj == pending_obj || obj == waiting_obj)) { | |
| 137 continue; | |
| 138 } | |
| 139 found_first_monitor = true; | |
| 140 result->append(monitor); | |
| 141 } | |
| 142 return result; | |
| 143 } | |
| 144 | |
| 145 static void print_locked_object_class_name(outputStream* st, Handle obj, const char* lock_state) { | |
| 146 if (obj.not_null()) { | |
| 147 st->print("\t- %s <" INTPTR_FORMAT "> ", lock_state, (address)obj()); | |
| 1142 | 148 if (obj->klass() == SystemDictionary::Class_klass()) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
149 Klass* target_klass = java_lang_Class::as_Klass(obj()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
150 st->print_cr("(a java.lang.Class for %s)", InstanceKlass::cast(target_klass)->external_name()); |
| 0 | 151 } else { |
| 152 Klass* k = Klass::cast(obj->klass()); | |
| 153 st->print_cr("(a %s)", k->external_name()); | |
| 154 } | |
| 155 } | |
| 156 } | |
| 157 | |
| 158 void javaVFrame::print_lock_info_on(outputStream* st, int frame_count) { | |
| 159 ResourceMark rm; | |
| 160 | |
| 161 // If this is the first frame, and java.lang.Object.wait(...) then print out the receiver. | |
| 162 if (frame_count == 0) { | |
| 163 if (method()->name() == vmSymbols::wait_name() && | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
164 InstanceKlass::cast(method()->method_holder())->name() == vmSymbols::java_lang_Object()) { |
| 0 | 165 StackValueCollection* locs = locals(); |
| 166 if (!locs->is_empty()) { | |
| 167 StackValue* sv = locs->at(0); | |
| 168 if (sv->type() == T_OBJECT) { | |
| 169 Handle o = locs->at(0)->get_obj(); | |
| 170 print_locked_object_class_name(st, o, "waiting on"); | |
| 171 } | |
| 172 } | |
| 173 } else if (thread()->current_park_blocker() != NULL) { | |
| 174 oop obj = thread()->current_park_blocker(); | |
| 175 Klass* k = Klass::cast(obj->klass()); | |
| 176 st->print_cr("\t- %s <" INTPTR_FORMAT "> (a %s)", "parking to wait for ", (address)obj, k->external_name()); | |
| 177 } | |
| 178 } | |
| 179 | |
| 180 | |
| 181 // Print out all monitors that we have locked or are trying to lock | |
| 182 GrowableArray<MonitorInfo*>* mons = monitors(); | |
| 183 if (!mons->is_empty()) { | |
| 184 bool found_first_monitor = false; | |
| 185 for (int index = (mons->length()-1); index >= 0; index--) { | |
| 186 MonitorInfo* monitor = mons->at(index); | |
|
818
b109e761e927
6837472: com/sun/jdi/MonitorFrameInfo.java fails with AggressiveOpts in 6u14
kvn
parents:
793
diff
changeset
|
187 if (monitor->eliminated() && is_compiled_frame()) { // Eliminated in compiled code |
|
b109e761e927
6837472: com/sun/jdi/MonitorFrameInfo.java fails with AggressiveOpts in 6u14
kvn
parents:
793
diff
changeset
|
188 if (monitor->owner_is_scalar_replaced()) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
189 Klass* k = java_lang_Class::as_Klass(monitor->owner_klass()); |
|
818
b109e761e927
6837472: com/sun/jdi/MonitorFrameInfo.java fails with AggressiveOpts in 6u14
kvn
parents:
793
diff
changeset
|
190 st->print("\t- eliminated <owner is scalar replaced> (a %s)", k->external_name()); |
|
b109e761e927
6837472: com/sun/jdi/MonitorFrameInfo.java fails with AggressiveOpts in 6u14
kvn
parents:
793
diff
changeset
|
191 } else { |
|
b109e761e927
6837472: com/sun/jdi/MonitorFrameInfo.java fails with AggressiveOpts in 6u14
kvn
parents:
793
diff
changeset
|
192 oop obj = monitor->owner(); |
|
b109e761e927
6837472: com/sun/jdi/MonitorFrameInfo.java fails with AggressiveOpts in 6u14
kvn
parents:
793
diff
changeset
|
193 if (obj != NULL) { |
|
b109e761e927
6837472: com/sun/jdi/MonitorFrameInfo.java fails with AggressiveOpts in 6u14
kvn
parents:
793
diff
changeset
|
194 print_locked_object_class_name(st, obj, "eliminated"); |
|
b109e761e927
6837472: com/sun/jdi/MonitorFrameInfo.java fails with AggressiveOpts in 6u14
kvn
parents:
793
diff
changeset
|
195 } |
|
b109e761e927
6837472: com/sun/jdi/MonitorFrameInfo.java fails with AggressiveOpts in 6u14
kvn
parents:
793
diff
changeset
|
196 } |
|
b109e761e927
6837472: com/sun/jdi/MonitorFrameInfo.java fails with AggressiveOpts in 6u14
kvn
parents:
793
diff
changeset
|
197 continue; |
|
b109e761e927
6837472: com/sun/jdi/MonitorFrameInfo.java fails with AggressiveOpts in 6u14
kvn
parents:
793
diff
changeset
|
198 } |
| 0 | 199 if (monitor->owner() != NULL) { |
| 200 | |
| 201 // First, assume we have the monitor locked. If we haven't found an | |
| 202 // owned monitor before and this is the first frame, then we need to | |
| 203 // see if we have completed the lock or we are blocked trying to | |
| 204 // acquire it - we can only be blocked if the monitor is inflated | |
| 205 | |
| 206 const char *lock_state = "locked"; // assume we have the monitor locked | |
| 207 if (!found_first_monitor && frame_count == 0) { | |
|
818
b109e761e927
6837472: com/sun/jdi/MonitorFrameInfo.java fails with AggressiveOpts in 6u14
kvn
parents:
793
diff
changeset
|
208 markOop mark = monitor->owner()->mark(); |
|
b109e761e927
6837472: com/sun/jdi/MonitorFrameInfo.java fails with AggressiveOpts in 6u14
kvn
parents:
793
diff
changeset
|
209 if (mark->has_monitor() && |
|
b109e761e927
6837472: com/sun/jdi/MonitorFrameInfo.java fails with AggressiveOpts in 6u14
kvn
parents:
793
diff
changeset
|
210 mark->monitor() == thread()->current_pending_monitor()) { |
| 0 | 211 lock_state = "waiting to lock"; |
|
818
b109e761e927
6837472: com/sun/jdi/MonitorFrameInfo.java fails with AggressiveOpts in 6u14
kvn
parents:
793
diff
changeset
|
212 } |
| 0 | 213 } |
| 214 | |
| 215 found_first_monitor = true; | |
| 216 print_locked_object_class_name(st, monitor->owner(), lock_state); | |
| 217 } | |
| 218 } | |
| 219 } | |
| 220 } | |
| 221 | |
| 222 // ------------- interpretedVFrame -------------- | |
| 223 | |
| 224 u_char* interpretedVFrame::bcp() const { | |
| 225 return fr().interpreter_frame_bcp(); | |
| 226 } | |
| 227 | |
| 228 void interpretedVFrame::set_bcp(u_char* bcp) { | |
| 229 fr().interpreter_frame_set_bcp(bcp); | |
| 230 } | |
| 231 | |
| 232 intptr_t* interpretedVFrame::locals_addr_at(int offset) const { | |
| 233 assert(fr().is_interpreted_frame(), "frame should be an interpreted frame"); | |
| 234 return fr().interpreter_frame_local_at(offset); | |
| 235 } | |
| 236 | |
| 237 | |
| 238 GrowableArray<MonitorInfo*>* interpretedVFrame::monitors() const { | |
| 239 GrowableArray<MonitorInfo*>* result = new GrowableArray<MonitorInfo*>(5); | |
| 240 for (BasicObjectLock* current = (fr().previous_monitor_in_interpreter_frame(fr().interpreter_frame_monitor_begin())); | |
| 241 current >= fr().interpreter_frame_monitor_end(); | |
| 242 current = fr().previous_monitor_in_interpreter_frame(current)) { | |
|
818
b109e761e927
6837472: com/sun/jdi/MonitorFrameInfo.java fails with AggressiveOpts in 6u14
kvn
parents:
793
diff
changeset
|
243 result->push(new MonitorInfo(current->obj(), current->lock(), false, false)); |
| 0 | 244 } |
| 245 return result; | |
| 246 } | |
| 247 | |
| 248 int interpretedVFrame::bci() const { | |
| 249 return method()->bci_from(bcp()); | |
| 250 } | |
| 251 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
252 Method* interpretedVFrame::method() const { |
| 0 | 253 return fr().interpreter_frame_method(); |
| 254 } | |
| 255 | |
| 256 StackValueCollection* interpretedVFrame::locals() const { | |
| 257 int length = method()->max_locals(); | |
| 258 | |
| 259 if (method()->is_native()) { | |
| 260 // If the method is native, max_locals is not telling the truth. | |
| 261 // maxlocals then equals the size of parameters | |
| 262 length = method()->size_of_parameters(); | |
| 263 } | |
| 264 | |
| 265 StackValueCollection* result = new StackValueCollection(length); | |
| 266 | |
| 267 // Get oopmap describing oops and int for current bci | |
| 1506 | 268 InterpreterOopMap oop_mask; |
| 269 if (TraceDeoptimization && Verbose) { | |
| 270 methodHandle m_h(thread(), method()); | |
| 271 OopMapCache::compute_one_oop_map(m_h, bci(), &oop_mask); | |
| 0 | 272 } else { |
| 1506 | 273 method()->mask_for(bci(), &oop_mask); |
| 274 } | |
| 275 // handle locals | |
| 276 for(int i=0; i < length; i++) { | |
| 277 // Find stack location | |
| 278 intptr_t *addr = locals_addr_at(i); | |
| 0 | 279 |
| 1506 | 280 // Depending on oop/int put it in the right package |
| 281 StackValue *sv; | |
| 282 if (oop_mask.is_oop(i)) { | |
| 283 // oop value | |
| 284 Handle h(*(oop *)addr); | |
| 285 sv = new StackValue(h); | |
| 286 } else { | |
| 287 // integer | |
| 288 sv = new StackValue(*addr); | |
| 0 | 289 } |
| 1506 | 290 assert(sv != NULL, "sanity check"); |
| 291 result->add(sv); | |
| 0 | 292 } |
| 293 return result; | |
| 294 } | |
| 295 | |
| 296 void interpretedVFrame::set_locals(StackValueCollection* values) const { | |
| 297 if (values == NULL || values->size() == 0) return; | |
| 298 | |
| 299 int length = method()->max_locals(); | |
| 300 if (method()->is_native()) { | |
| 301 // If the method is native, max_locals is not telling the truth. | |
| 302 // maxlocals then equals the size of parameters | |
| 303 length = method()->size_of_parameters(); | |
| 304 } | |
| 305 | |
| 306 assert(length == values->size(), "Mismatch between actual stack format and supplied data"); | |
| 307 | |
| 308 // handle locals | |
| 309 for (int i = 0; i < length; i++) { | |
| 310 // Find stack location | |
| 311 intptr_t *addr = locals_addr_at(i); | |
| 312 | |
| 313 // Depending on oop/int put it in the right package | |
| 314 StackValue *sv = values->at(i); | |
| 315 assert(sv != NULL, "sanity check"); | |
| 316 if (sv->type() == T_OBJECT) { | |
| 317 *(oop *) addr = (sv->get_obj())(); | |
| 318 } else { // integer | |
| 319 *addr = sv->get_int(); | |
| 320 } | |
| 321 } | |
| 322 } | |
| 323 | |
| 324 StackValueCollection* interpretedVFrame::expressions() const { | |
| 325 int length = fr().interpreter_frame_expression_stack_size(); | |
| 326 if (method()->is_native()) { | |
| 327 // If the method is native, there is no expression stack | |
| 328 length = 0; | |
| 329 } | |
| 330 | |
| 331 int nof_locals = method()->max_locals(); | |
| 332 StackValueCollection* result = new StackValueCollection(length); | |
| 333 | |
| 1506 | 334 InterpreterOopMap oop_mask; |
| 335 // Get oopmap describing oops and int for current bci | |
| 336 if (TraceDeoptimization && Verbose) { | |
| 337 methodHandle m_h(method()); | |
| 338 OopMapCache::compute_one_oop_map(m_h, bci(), &oop_mask); | |
| 0 | 339 } else { |
| 1506 | 340 method()->mask_for(bci(), &oop_mask); |
| 341 } | |
| 342 // handle expressions | |
| 343 for(int i=0; i < length; i++) { | |
| 344 // Find stack location | |
| 345 intptr_t *addr = fr().interpreter_frame_expression_stack_at(i); | |
| 0 | 346 |
| 1506 | 347 // Depending on oop/int put it in the right package |
| 348 StackValue *sv; | |
| 349 if (oop_mask.is_oop(i + nof_locals)) { | |
| 350 // oop value | |
| 351 Handle h(*(oop *)addr); | |
| 352 sv = new StackValue(h); | |
| 353 } else { | |
| 354 // integer | |
| 355 sv = new StackValue(*addr); | |
| 0 | 356 } |
| 1506 | 357 assert(sv != NULL, "sanity check"); |
| 358 result->add(sv); | |
| 0 | 359 } |
| 360 return result; | |
| 361 } | |
| 362 | |
| 363 | |
| 364 // ------------- cChunk -------------- | |
| 365 | |
| 366 entryVFrame::entryVFrame(const frame* fr, const RegisterMap* reg_map, JavaThread* thread) | |
| 367 : externalVFrame(fr, reg_map, thread) {} | |
| 368 | |
| 369 | |
| 370 void vframeStreamCommon::found_bad_method_frame() { | |
| 371 // 6379830 Cut point for an assertion that occasionally fires when | |
| 372 // we are using the performance analyzer. | |
| 373 // Disable this assert when testing the analyzer with fastdebug. | |
| 374 // -XX:SuppressErrorAt=vframe.cpp:XXX (XXX=following line number) | |
| 375 assert(false, "invalid bci or invalid scope desc"); | |
| 376 } | |
| 377 | |
| 378 // top-frame will be skipped | |
| 379 vframeStream::vframeStream(JavaThread* thread, frame top_frame, | |
| 380 bool stop_at_java_call_stub) : vframeStreamCommon(thread) { | |
| 381 _stop_at_java_call_stub = stop_at_java_call_stub; | |
| 382 | |
| 383 // skip top frame, as it may not be at safepoint | |
| 384 _frame = top_frame.sender(&_reg_map); | |
| 385 while (!fill_from_frame()) { | |
| 386 _frame = _frame.sender(&_reg_map); | |
| 387 } | |
| 388 } | |
| 389 | |
| 390 | |
| 391 // Step back n frames, skip any pseudo frames in between. | |
| 392 // This function is used in Class.forName, Class.newInstance, Method.Invoke, | |
| 393 // AccessController.doPrivileged. | |
| 394 // | |
| 395 // NOTE that in JDK 1.4 this has been exposed to Java as | |
| 396 // sun.reflect.Reflection.getCallerClass(), which can be inlined. | |
| 397 // Inlined versions must match this routine's logic. | |
| 398 // Native method prefixing logic does not need to match since | |
| 399 // the method names don't match and inlining will not occur. | |
| 400 // See, for example, | |
| 401 // Parse::inline_native_Reflection_getCallerClass in | |
| 402 // opto/library_call.cpp. | |
| 403 void vframeStreamCommon::security_get_caller_frame(int depth) { | |
| 404 bool use_new_reflection = JDK_Version::is_gte_jdk14x_version() && UseNewReflection; | |
| 405 | |
| 406 while (!at_end()) { | |
| 407 if (Universe::reflect_invoke_cache()->is_same_method(method())) { | |
| 408 // This is Method.invoke() -- skip it | |
| 409 } else if (use_new_reflection && | |
| 410 Klass::cast(method()->method_holder()) | |
| 1142 | 411 ->is_subclass_of(SystemDictionary::reflect_MethodAccessorImpl_klass())) { |
| 0 | 412 // This is an auxilary frame -- skip it |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
2426
diff
changeset
|
413 } else if (method()->is_method_handle_intrinsic() || |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
2426
diff
changeset
|
414 method()->is_compiled_lambda_form()) { |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
2426
diff
changeset
|
415 // This is an internal adapter frame for method handles -- skip it |
| 0 | 416 } else { |
| 417 // This is non-excluded frame, we need to count it against the depth | |
| 418 if (depth-- <= 0) { | |
| 419 // we have reached the desired depth, we are done | |
| 420 break; | |
| 421 } | |
| 422 } | |
| 423 if (method()->is_prefixed_native()) { | |
| 424 skip_prefixed_method_and_wrappers(); | |
| 425 } else { | |
| 426 next(); | |
| 427 } | |
| 428 } | |
| 429 } | |
| 430 | |
| 431 | |
| 432 void vframeStreamCommon::skip_prefixed_method_and_wrappers() { | |
| 433 ResourceMark rm; | |
| 434 HandleMark hm; | |
| 435 | |
| 436 int method_prefix_count = 0; | |
| 437 char** method_prefixes = JvmtiExport::get_all_native_method_prefixes(&method_prefix_count); | |
| 438 KlassHandle prefixed_klass(method()->method_holder()); | |
| 439 const char* prefixed_name = method()->name()->as_C_string(); | |
| 440 size_t prefixed_name_len = strlen(prefixed_name); | |
| 441 int prefix_index = method_prefix_count-1; | |
| 442 | |
| 443 while (!at_end()) { | |
| 444 next(); | |
| 445 if (method()->method_holder() != prefixed_klass()) { | |
| 446 break; // classes don't match, can't be a wrapper | |
| 447 } | |
| 448 const char* name = method()->name()->as_C_string(); | |
| 449 size_t name_len = strlen(name); | |
| 450 size_t prefix_len = prefixed_name_len - name_len; | |
| 451 if (prefix_len <= 0 || strcmp(name, prefixed_name + prefix_len) != 0) { | |
| 452 break; // prefixed name isn't prefixed version of method name, can't be a wrapper | |
| 453 } | |
| 454 for (; prefix_index >= 0; --prefix_index) { | |
| 455 const char* possible_prefix = method_prefixes[prefix_index]; | |
| 456 size_t possible_prefix_len = strlen(possible_prefix); | |
| 457 if (possible_prefix_len == prefix_len && | |
| 458 strncmp(possible_prefix, prefixed_name, prefix_len) == 0) { | |
| 459 break; // matching prefix found | |
| 460 } | |
| 461 } | |
| 462 if (prefix_index < 0) { | |
| 463 break; // didn't find the prefix, can't be a wrapper | |
| 464 } | |
| 465 prefixed_name = name; | |
| 466 prefixed_name_len = name_len; | |
| 467 } | |
| 468 } | |
| 469 | |
| 470 | |
| 471 void vframeStreamCommon::skip_reflection_related_frames() { | |
| 472 while (!at_end() && | |
| 473 (JDK_Version::is_gte_jdk14x_version() && UseNewReflection && | |
| 1142 | 474 (Klass::cast(method()->method_holder())->is_subclass_of(SystemDictionary::reflect_MethodAccessorImpl_klass()) || |
| 475 Klass::cast(method()->method_holder())->is_subclass_of(SystemDictionary::reflect_ConstructorAccessorImpl_klass())))) { | |
| 0 | 476 next(); |
| 477 } | |
| 478 } | |
| 479 | |
| 480 | |
| 481 #ifndef PRODUCT | |
| 482 void vframe::print() { | |
| 483 if (WizardMode) _fr.print_value_on(tty,NULL); | |
| 484 } | |
| 485 | |
| 486 | |
| 487 void vframe::print_value() const { | |
| 488 ((vframe*)this)->print(); | |
| 489 } | |
| 490 | |
| 491 | |
| 492 void entryVFrame::print_value() const { | |
| 493 ((entryVFrame*)this)->print(); | |
| 494 } | |
| 495 | |
| 496 void entryVFrame::print() { | |
| 497 vframe::print(); | |
| 498 tty->print_cr("C Chunk inbetween Java"); | |
| 499 tty->print_cr("C link " INTPTR_FORMAT, _fr.link()); | |
| 500 } | |
| 501 | |
| 502 | |
| 503 // ------------- javaVFrame -------------- | |
| 504 | |
| 505 static void print_stack_values(const char* title, StackValueCollection* values) { | |
| 506 if (values->is_empty()) return; | |
| 507 tty->print_cr("\t%s:", title); | |
| 508 values->print(); | |
| 509 } | |
| 510 | |
| 511 | |
| 512 void javaVFrame::print() { | |
| 513 ResourceMark rm; | |
| 514 vframe::print(); | |
| 515 tty->print("\t"); | |
| 516 method()->print_value(); | |
| 517 tty->cr(); | |
| 518 tty->print_cr("\tbci: %d", bci()); | |
| 519 | |
| 520 print_stack_values("locals", locals()); | |
| 521 print_stack_values("expressions", expressions()); | |
| 522 | |
| 523 GrowableArray<MonitorInfo*>* list = monitors(); | |
| 524 if (list->is_empty()) return; | |
| 525 tty->print_cr("\tmonitor list:"); | |
| 526 for (int index = (list->length()-1); index >= 0; index--) { | |
| 527 MonitorInfo* monitor = list->at(index); | |
|
818
b109e761e927
6837472: com/sun/jdi/MonitorFrameInfo.java fails with AggressiveOpts in 6u14
kvn
parents:
793
diff
changeset
|
528 tty->print("\t obj\t"); |
|
b109e761e927
6837472: com/sun/jdi/MonitorFrameInfo.java fails with AggressiveOpts in 6u14
kvn
parents:
793
diff
changeset
|
529 if (monitor->owner_is_scalar_replaced()) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
530 Klass* k = java_lang_Class::as_Klass(monitor->owner_klass()); |
|
818
b109e761e927
6837472: com/sun/jdi/MonitorFrameInfo.java fails with AggressiveOpts in 6u14
kvn
parents:
793
diff
changeset
|
531 tty->print("( is scalar replaced %s)", k->external_name()); |
|
b109e761e927
6837472: com/sun/jdi/MonitorFrameInfo.java fails with AggressiveOpts in 6u14
kvn
parents:
793
diff
changeset
|
532 } else if (monitor->owner() == NULL) { |
|
b109e761e927
6837472: com/sun/jdi/MonitorFrameInfo.java fails with AggressiveOpts in 6u14
kvn
parents:
793
diff
changeset
|
533 tty->print("( null )"); |
|
b109e761e927
6837472: com/sun/jdi/MonitorFrameInfo.java fails with AggressiveOpts in 6u14
kvn
parents:
793
diff
changeset
|
534 } else { |
|
b109e761e927
6837472: com/sun/jdi/MonitorFrameInfo.java fails with AggressiveOpts in 6u14
kvn
parents:
793
diff
changeset
|
535 monitor->owner()->print_value(); |
|
b109e761e927
6837472: com/sun/jdi/MonitorFrameInfo.java fails with AggressiveOpts in 6u14
kvn
parents:
793
diff
changeset
|
536 tty->print("(" INTPTR_FORMAT ")", (address)monitor->owner()); |
|
b109e761e927
6837472: com/sun/jdi/MonitorFrameInfo.java fails with AggressiveOpts in 6u14
kvn
parents:
793
diff
changeset
|
537 } |
|
b109e761e927
6837472: com/sun/jdi/MonitorFrameInfo.java fails with AggressiveOpts in 6u14
kvn
parents:
793
diff
changeset
|
538 if (monitor->eliminated() && is_compiled_frame()) |
|
b109e761e927
6837472: com/sun/jdi/MonitorFrameInfo.java fails with AggressiveOpts in 6u14
kvn
parents:
793
diff
changeset
|
539 tty->print(" ( lock is eliminated )"); |
| 0 | 540 tty->cr(); |
| 541 tty->print("\t "); | |
| 542 monitor->lock()->print_on(tty); | |
| 543 tty->cr(); | |
| 544 } | |
| 545 } | |
| 546 | |
| 547 | |
| 548 void javaVFrame::print_value() const { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
549 Method* m = method(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
550 Klass* k = m->method_holder(); |
| 0 | 551 tty->print_cr("frame( sp=" INTPTR_FORMAT ", unextended_sp=" INTPTR_FORMAT ", fp=" INTPTR_FORMAT ", pc=" INTPTR_FORMAT ")", |
| 552 _fr.sp(), _fr.unextended_sp(), _fr.fp(), _fr.pc()); | |
| 553 tty->print("%s.%s", Klass::cast(k)->internal_name(), m->name()->as_C_string()); | |
| 554 | |
| 555 if (!m->is_native()) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
556 Symbol* source_name = InstanceKlass::cast(k)->source_file_name(); |
| 0 | 557 int line_number = m->line_number_from_bci(bci()); |
| 558 if (source_name != NULL && (line_number != -1)) { | |
| 559 tty->print("(%s:%d)", source_name->as_C_string(), line_number); | |
| 560 } | |
| 561 } else { | |
| 562 tty->print("(Native Method)"); | |
| 563 } | |
| 564 // Check frame size and print warning if it looks suspiciously large | |
| 565 if (fr().sp() != NULL) { | |
|
793
eacd97c88873
6848466: frame::frame_size() assertion failure with -XX:+DebugDeoptimization
cfang
parents:
196
diff
changeset
|
566 RegisterMap map = *register_map(); |
|
eacd97c88873
6848466: frame::frame_size() assertion failure with -XX:+DebugDeoptimization
cfang
parents:
196
diff
changeset
|
567 uint size = fr().frame_size(&map); |
| 0 | 568 #ifdef _LP64 |
| 569 if (size > 8*K) warning("SUSPICIOUSLY LARGE FRAME (%d)", size); | |
| 570 #else | |
| 571 if (size > 4*K) warning("SUSPICIOUSLY LARGE FRAME (%d)", size); | |
| 572 #endif | |
| 573 } | |
| 574 } | |
| 575 | |
| 576 | |
| 577 bool javaVFrame::structural_compare(javaVFrame* other) { | |
| 578 // Check static part | |
| 579 if (method() != other->method()) return false; | |
| 580 if (bci() != other->bci()) return false; | |
| 581 | |
| 582 // Check locals | |
| 583 StackValueCollection *locs = locals(); | |
| 584 StackValueCollection *other_locs = other->locals(); | |
| 585 assert(locs->size() == other_locs->size(), "sanity check"); | |
| 586 int i; | |
| 587 for(i = 0; i < locs->size(); i++) { | |
| 588 // it might happen the compiler reports a conflict and | |
| 589 // the interpreter reports a bogus int. | |
| 590 if ( is_compiled_frame() && locs->at(i)->type() == T_CONFLICT) continue; | |
| 591 if (other->is_compiled_frame() && other_locs->at(i)->type() == T_CONFLICT) continue; | |
| 592 | |
| 593 if (!locs->at(i)->equal(other_locs->at(i))) | |
| 594 return false; | |
| 595 } | |
| 596 | |
| 597 // Check expressions | |
| 598 StackValueCollection* exprs = expressions(); | |
| 599 StackValueCollection* other_exprs = other->expressions(); | |
| 600 assert(exprs->size() == other_exprs->size(), "sanity check"); | |
| 601 for(i = 0; i < exprs->size(); i++) { | |
| 602 if (!exprs->at(i)->equal(other_exprs->at(i))) | |
| 603 return false; | |
| 604 } | |
| 605 | |
| 606 return true; | |
| 607 } | |
| 608 | |
| 609 | |
| 610 void javaVFrame::print_activation(int index) const { | |
| 611 // frame number and method | |
| 612 tty->print("%2d - ", index); | |
| 613 ((vframe*)this)->print_value(); | |
| 614 tty->cr(); | |
| 615 | |
| 616 if (WizardMode) { | |
| 617 ((vframe*)this)->print(); | |
| 618 tty->cr(); | |
| 619 } | |
| 620 } | |
| 621 | |
| 622 | |
| 623 void javaVFrame::verify() const { | |
| 624 } | |
| 625 | |
| 626 | |
| 627 void interpretedVFrame::verify() const { | |
| 628 } | |
| 629 | |
| 630 | |
| 631 // ------------- externalVFrame -------------- | |
| 632 | |
| 633 void externalVFrame::print() { | |
| 634 _fr.print_value_on(tty,NULL); | |
| 635 } | |
| 636 | |
| 637 | |
| 638 void externalVFrame::print_value() const { | |
| 639 ((vframe*)this)->print(); | |
| 640 } | |
| 641 #endif // PRODUCT |