1 /* 2 * Copyright (c) 1997, 2019, Oracle and/or its affiliates. All rights reserved. 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 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 * 23 */ 24 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/frame.inline.hpp" 40 #include "runtime/handles.inline.hpp" 41 #include "runtime/objectMonitor.hpp" 42 #include "runtime/objectMonitor.inline.hpp" 43 #include "runtime/signature.hpp" 44 #include "runtime/stubRoutines.hpp" 45 #include "runtime/synchronizer.hpp" 46 #include "runtime/thread.inline.hpp" 47 #include "runtime/vframe.inline.hpp" 48 #include "runtime/vframeArray.hpp" 49 #include "runtime/vframe_hp.hpp" 50 51 vframe::vframe(const frame* fr, const RegisterMap* reg_map, JavaThread* thread) 52 : _reg_map(reg_map), _thread(thread) { 53 assert(fr != NULL, "must have frame"); 54 _fr = *fr; 55 } 56 57 vframe::vframe(const frame* fr, JavaThread* thread) 58 : _reg_map(thread), _thread(thread) { 59 assert(fr != NULL, "must have frame"); 60 _fr = *fr; 61 } 62 63 vframe* vframe::new_vframe(const frame* f, const RegisterMap* reg_map, JavaThread* thread) { 64 // Interpreter frame 65 if (f->is_interpreted_frame()) { 66 return new interpretedVFrame(f, reg_map, thread); 67 } 68 69 // Compiled frame 70 CodeBlob* cb = f->cb(); 71 if (cb != NULL) { 72 if (cb->is_compiled()) { 73 CompiledMethod* nm = (CompiledMethod*)cb; 74 return new compiledVFrame(f, reg_map, thread, nm); 75 } 76 77 if (f->is_runtime_frame()) { 78 // Skip this frame and try again. 79 RegisterMap temp_map = *reg_map; 80 frame s = f->sender(&temp_map); 81 return new_vframe(&s, &temp_map, thread); 82 } 83 } 84 85 // External frame 86 return new externalVFrame(f, reg_map, thread); 87 } 88 89 vframe* vframe::sender() const { 90 RegisterMap temp_map = *register_map(); 91 assert(is_top(), "just checking"); 92 if (_fr.is_entry_frame() && _fr.is_first_frame()) return NULL; 93 frame s = _fr.real_sender(&temp_map); 94 if (s.is_first_frame()) return NULL; 95 return vframe::new_vframe(&s, &temp_map, thread()); 96 } 97 98 vframe* vframe::top() const { 99 vframe* vf = (vframe*) this; 100 while (!vf->is_top()) vf = vf->sender(); 101 return vf; 102 } 103 104 105 javaVFrame* vframe::java_sender() const { 106 vframe* f = sender(); 107 while (f != NULL) { 108 if (f->is_java_frame()) return javaVFrame::cast(f); 109 f = f->sender(); 110 } 111 return NULL; 112 } 113 114 // ------------- javaVFrame -------------- 115 116 GrowableArray<MonitorInfo*>* javaVFrame::locked_monitors() { 117 assert(SafepointSynchronize::is_at_safepoint() || JavaThread::current() == thread(), 118 "must be at safepoint or it's a java frame of the current thread"); 119 120 GrowableArray<MonitorInfo*>* mons = monitors(); 121 GrowableArray<MonitorInfo*>* result = new GrowableArray<MonitorInfo*>(mons->length()); 122 if (mons->is_empty()) return result; 123 124 bool found_first_monitor = false; 125 // For all of the javaVFrame::locked_monitors()() call sites, we 126 // are either at a safepoint or the calling thread is operating 127 // on itself so this ObjectMonitorHandle is not strictly necessary. 128 ObjectMonitorHandle omh; 129 ObjectMonitor *waiting_monitor = thread()->current_waiting_monitor(&omh); 130 ObjectMonitor *pending_monitor = NULL; 131 if (waiting_monitor == NULL) { 132 pending_monitor = thread()->current_pending_monitor(&omh); 133 } 134 oop pending_obj = (pending_monitor != NULL ? (oop) pending_monitor->object() : (oop) NULL); 135 oop waiting_obj = (waiting_monitor != NULL ? (oop) waiting_monitor->object() : (oop) NULL); 136 137 for (int index = (mons->length()-1); index >= 0; index--) { 138 MonitorInfo* monitor = mons->at(index); 139 if (monitor->eliminated() && is_compiled_frame()) continue; // skip eliminated monitor 140 oop obj = monitor->owner(); 141 if (obj == NULL) continue; // skip unowned monitor 142 // 143 // Skip the monitor that the thread is blocked to enter or waiting on 144 // 145 if (!found_first_monitor && (obj == pending_obj || obj == waiting_obj)) { 146 continue; 147 } 148 found_first_monitor = true; 149 result->append(monitor); 150 } 151 return result; 152 } 153 154 void javaVFrame::print_locked_object_class_name(outputStream* st, Handle obj, const char* lock_state) { 155 if (obj.not_null()) { 156 st->print("\t- %s <" INTPTR_FORMAT "> ", lock_state, p2i(obj())); 157 if (obj->klass() == SystemDictionary::Class_klass()) { 158 st->print_cr("(a java.lang.Class for %s)", java_lang_Class::as_external_name(obj())); 159 } else { 160 Klass* k = obj->klass(); 161 st->print_cr("(a %s)", k->external_name()); 162 } 163 } 164 } 165 166 void javaVFrame::print_lock_info_on(outputStream* st, int frame_count) { 167 Thread* THREAD = Thread::current(); 168 ResourceMark rm(THREAD); 169 170 // If this is the first frame and it is java.lang.Object.wait(...) 171 // then print out the receiver. Locals are not always available, 172 // e.g., compiled native frames have no scope so there are no locals. 173 if (frame_count == 0) { 174 if (method()->name() == vmSymbols::wait_name() && 175 method()->method_holder()->name() == vmSymbols::java_lang_Object()) { 176 const char *wait_state = "waiting on"; // assume we are waiting 177 // If earlier in the output we reported java.lang.Thread.State == 178 // "WAITING (on object monitor)" and now we report "waiting on", then 179 // we are still waiting for notification or timeout. Otherwise if 180 // we earlier reported java.lang.Thread.State == "BLOCKED (on object 181 // monitor)", then we are actually waiting to re-lock the monitor. 182 StackValueCollection* locs = locals(); 183 if (!locs->is_empty()) { 184 StackValue* sv = locs->at(0); 185 if (sv->type() == T_OBJECT) { 186 Handle o = locs->at(0)->get_obj(); 187 if (java_lang_Thread::get_thread_status(thread()->threadObj()) == 188 java_lang_Thread::BLOCKED_ON_MONITOR_ENTER) { 189 wait_state = "waiting to re-lock in wait()"; 190 } 191 print_locked_object_class_name(st, o, wait_state); 192 } 193 } else { 194 st->print_cr("\t- %s <no object reference available>", wait_state); 195 } 196 } else if (thread()->current_park_blocker() != NULL) { 197 oop obj = thread()->current_park_blocker(); 198 Klass* k = obj->klass(); 199 st->print_cr("\t- %s <" INTPTR_FORMAT "> (a %s)", "parking to wait for ", p2i(obj), k->external_name()); 200 } 201 else if (thread()->osthread()->get_state() == OBJECT_WAIT) { 202 // We are waiting on an Object monitor but Object.wait() isn't the 203 // top-frame, so we should be waiting on a Class initialization monitor. 204 InstanceKlass* k = thread()->class_to_be_initialized(); 205 if (k != NULL) { 206 st->print_cr("\t- waiting on the Class initialization monitor for %s", k->external_name()); 207 } 208 } 209 } 210 211 // Print out all monitors that we have locked, or are trying to lock, 212 // including re-locking after being notified or timing out in a wait(). 213 GrowableArray<MonitorInfo*>* mons = monitors(); 214 if (!mons->is_empty()) { 215 bool found_first_monitor = false; 216 for (int index = (mons->length()-1); index >= 0; index--) { 217 MonitorInfo* monitor = mons->at(index); 218 if (monitor->eliminated() && is_compiled_frame()) { // Eliminated in compiled code 219 if (monitor->owner_is_scalar_replaced()) { 220 Klass* k = java_lang_Class::as_Klass(monitor->owner_klass()); 221 st->print("\t- eliminated <owner is scalar replaced> (a %s)", k->external_name()); 222 } else { 223 Handle obj(THREAD, monitor->owner()); 224 if (obj() != NULL) { 225 print_locked_object_class_name(st, obj, "eliminated"); 226 } 227 } 228 continue; 229 } 230 if (monitor->owner() != NULL) { 231 // the monitor is associated with an object, i.e., it is locked 232 233 const char *lock_state = "locked"; // assume we have the monitor locked 234 if (!found_first_monitor && frame_count == 0) { 235 // If this is the first frame and we haven't found an owned 236 // monitor before, then we need to see if we have completed 237 // the lock or if we are blocked trying to acquire it. Only 238 // an inflated monitor that is first on the monitor list in 239 // the first frame can block us on a monitor enter. 240 markWord mark = monitor->owner()->mark(); 241 // The calling thread is operating on itself so this 242 // ObjectMonitorHandle is not strictly necessary. 243 ObjectMonitorHandle omh; 244 if (mark.has_monitor() && 245 ( // we have marked ourself as pending on this monitor 246 mark.monitor() == thread()->current_pending_monitor(&omh) || 247 // we are not the owner of this monitor 248 !mark.monitor()->is_entered(thread()) 249 )) { 250 lock_state = "waiting to lock"; 251 } 252 } 253 print_locked_object_class_name(st, Handle(THREAD, monitor->owner()), lock_state); 254 255 found_first_monitor = true; 256 } 257 } 258 } 259 } 260 261 // ------------- interpretedVFrame -------------- 262 263 u_char* interpretedVFrame::bcp() const { 264 return fr().interpreter_frame_bcp(); 265 } 266 267 void interpretedVFrame::set_bcp(u_char* bcp) { 268 fr().interpreter_frame_set_bcp(bcp); 269 } 270 271 intptr_t* interpretedVFrame::locals_addr_at(int offset) const { 272 assert(fr().is_interpreted_frame(), "frame should be an interpreted frame"); 273 return fr().interpreter_frame_local_at(offset); 274 } 275 276 277 GrowableArray<MonitorInfo*>* interpretedVFrame::monitors() const { 278 GrowableArray<MonitorInfo*>* result = new GrowableArray<MonitorInfo*>(5); 279 for (BasicObjectLock* current = (fr().previous_monitor_in_interpreter_frame(fr().interpreter_frame_monitor_begin())); 280 current >= fr().interpreter_frame_monitor_end(); 281 current = fr().previous_monitor_in_interpreter_frame(current)) { 282 result->push(new MonitorInfo(current->obj(), current->lock(), false, false)); 283 } 284 return result; 285 } 286 287 int interpretedVFrame::bci() const { 288 return method()->bci_from(bcp()); 289 } 290 291 Method* interpretedVFrame::method() const { 292 return fr().interpreter_frame_method(); 293 } 294 295 static StackValue* create_stack_value_from_oop_map(const InterpreterOopMap& oop_mask, 296 int index, 297 const intptr_t* const addr) { 298 299 assert(index >= 0 && 300 index < oop_mask.number_of_entries(), "invariant"); 301 302 // categorize using oop_mask 303 if (oop_mask.is_oop(index)) { 304 // reference (oop) "r" 305 Handle h(Thread::current(), addr != NULL ? (*(oop*)addr) : (oop)NULL); 306 return new StackValue(h); 307 } 308 // value (integer) "v" 309 return new StackValue(addr != NULL ? *addr : 0); 310 } 311 312 static bool is_in_expression_stack(const frame& fr, const intptr_t* const addr) { 313 assert(addr != NULL, "invariant"); 314 315 // Ensure to be 'inside' the expresion stack (i.e., addr >= sp for Intel). 316 // In case of exceptions, the expression stack is invalid and the sp 317 // will be reset to express this condition. 318 if (frame::interpreter_frame_expression_stack_direction() > 0) { 319 return addr <= fr.interpreter_frame_tos_address(); 320 } 321 322 return addr >= fr.interpreter_frame_tos_address(); 323 } 324 325 static void stack_locals(StackValueCollection* result, 326 int length, 327 const InterpreterOopMap& oop_mask, 328 const frame& fr) { 329 330 assert(result != NULL, "invariant"); 331 332 for (int i = 0; i < length; ++i) { 333 const intptr_t* const addr = fr.interpreter_frame_local_at(i); 334 assert(addr != NULL, "invariant"); 335 assert(addr >= fr.sp(), "must be inside the frame"); 336 337 StackValue* const sv = create_stack_value_from_oop_map(oop_mask, i, addr); 338 assert(sv != NULL, "sanity check"); 339 340 result->add(sv); 341 } 342 } 343 344 static void stack_expressions(StackValueCollection* result, 345 int length, 346 int max_locals, 347 const InterpreterOopMap& oop_mask, 348 const frame& fr) { 349 350 assert(result != NULL, "invariant"); 351 352 for (int i = 0; i < length; ++i) { 353 const intptr_t* addr = fr.interpreter_frame_expression_stack_at(i); 354 assert(addr != NULL, "invariant"); 355 if (!is_in_expression_stack(fr, addr)) { 356 // Need to ensure no bogus escapes. 357 addr = NULL; 358 } 359 360 StackValue* const sv = create_stack_value_from_oop_map(oop_mask, 361 i + max_locals, 362 addr); 363 assert(sv != NULL, "sanity check"); 364 365 result->add(sv); 366 } 367 } 368 369 StackValueCollection* interpretedVFrame::locals() const { 370 return stack_data(false); 371 } 372 373 StackValueCollection* interpretedVFrame::expressions() const { 374 return stack_data(true); 375 } 376 377 /* 378 * Worker routine for fetching references and/or values 379 * for a particular bci in the interpretedVFrame. 380 * 381 * Returns data for either "locals" or "expressions", 382 * using bci relative oop_map (oop_mask) information. 383 * 384 * @param expressions bool switch controlling what data to return 385 (false == locals / true == expression) 386 * 387 */ 388 StackValueCollection* interpretedVFrame::stack_data(bool expressions) const { 389 390 InterpreterOopMap oop_mask; 391 method()->mask_for(bci(), &oop_mask); 392 const int mask_len = oop_mask.number_of_entries(); 393 394 // If the method is native, method()->max_locals() is not telling the truth. 395 // For our purposes, max locals instead equals the size of parameters. 396 const int max_locals = method()->is_native() ? 397 method()->size_of_parameters() : method()->max_locals(); 398 399 assert(mask_len >= max_locals, "invariant"); 400 401 const int length = expressions ? mask_len - max_locals : max_locals; 402 assert(length >= 0, "invariant"); 403 404 StackValueCollection* const result = new StackValueCollection(length); 405 406 if (0 == length) { 407 return result; 408 } 409 410 if (expressions) { 411 stack_expressions(result, length, max_locals, oop_mask, fr()); 412 } else { 413 stack_locals(result, length, oop_mask, fr()); 414 } 415 416 assert(length == result->size(), "invariant"); 417 418 return result; 419 } 420 421 void interpretedVFrame::set_locals(StackValueCollection* values) const { 422 if (values == NULL || values->size() == 0) return; 423 424 // If the method is native, max_locals is not telling the truth. 425 // maxlocals then equals the size of parameters 426 const int max_locals = method()->is_native() ? 427 method()->size_of_parameters() : method()->max_locals(); 428 429 assert(max_locals == values->size(), "Mismatch between actual stack format and supplied data"); 430 431 // handle locals 432 for (int i = 0; i < max_locals; i++) { 433 // Find stack location 434 intptr_t *addr = locals_addr_at(i); 435 436 // Depending on oop/int put it in the right package 437 const StackValue* const sv = values->at(i); 438 assert(sv != NULL, "sanity check"); 439 if (sv->type() == T_OBJECT) { 440 *(oop *) addr = (sv->get_obj())(); 441 } else { // integer 442 *addr = sv->get_int(); 443 } 444 } 445 } 446 447 // ------------- cChunk -------------- 448 449 entryVFrame::entryVFrame(const frame* fr, const RegisterMap* reg_map, JavaThread* thread) 450 : externalVFrame(fr, reg_map, thread) {} 451 452 #ifdef ASSERT 453 void vframeStreamCommon::found_bad_method_frame() const { 454 // 6379830 Cut point for an assertion that occasionally fires when 455 // we are using the performance analyzer. 456 // Disable this assert when testing the analyzer with fastdebug. 457 // -XX:SuppressErrorAt=vframe.cpp:XXX (XXX=following line number) 458 fatal("invalid bci or invalid scope desc"); 459 } 460 #endif 461 462 // top-frame will be skipped 463 vframeStream::vframeStream(JavaThread* thread, frame top_frame, 464 bool stop_at_java_call_stub) : vframeStreamCommon(thread) { 465 _stop_at_java_call_stub = stop_at_java_call_stub; 466 467 // skip top frame, as it may not be at safepoint 468 _prev_frame = top_frame; 469 _frame = top_frame.sender(&_reg_map); 470 while (!fill_from_frame()) { 471 _prev_frame = _frame; 472 _frame = _frame.sender(&_reg_map); 473 } 474 } 475 476 477 // Step back n frames, skip any pseudo frames in between. 478 // This function is used in Class.forName, Class.newInstance, Method.Invoke, 479 // AccessController.doPrivileged. 480 void vframeStreamCommon::security_get_caller_frame(int depth) { 481 assert(depth >= 0, "invalid depth: %d", depth); 482 for (int n = 0; !at_end(); security_next()) { 483 if (!method()->is_ignored_by_security_stack_walk()) { 484 if (n == depth) { 485 // We have reached the desired depth; return. 486 return; 487 } 488 n++; // this is a non-skipped frame; count it against the depth 489 } 490 } 491 // NOTE: At this point there were not enough frames on the stack 492 // to walk to depth. Callers of this method have to check for at_end. 493 } 494 495 496 void vframeStreamCommon::security_next() { 497 if (method()->is_prefixed_native()) { 498 skip_prefixed_method_and_wrappers(); // calls next() 499 } else { 500 next(); 501 } 502 } 503 504 505 void vframeStreamCommon::skip_prefixed_method_and_wrappers() { 506 ResourceMark rm; 507 HandleMark hm; 508 509 int method_prefix_count = 0; 510 char** method_prefixes = JvmtiExport::get_all_native_method_prefixes(&method_prefix_count); 511 Klass* prefixed_klass = method()->method_holder(); 512 const char* prefixed_name = method()->name()->as_C_string(); 513 size_t prefixed_name_len = strlen(prefixed_name); 514 int prefix_index = method_prefix_count-1; 515 516 while (!at_end()) { 517 next(); 518 if (method()->method_holder() != prefixed_klass) { 519 break; // classes don't match, can't be a wrapper 520 } 521 const char* name = method()->name()->as_C_string(); 522 size_t name_len = strlen(name); 523 size_t prefix_len = prefixed_name_len - name_len; 524 if (prefix_len <= 0 || strcmp(name, prefixed_name + prefix_len) != 0) { 525 break; // prefixed name isn't prefixed version of method name, can't be a wrapper 526 } 527 for (; prefix_index >= 0; --prefix_index) { 528 const char* possible_prefix = method_prefixes[prefix_index]; 529 size_t possible_prefix_len = strlen(possible_prefix); 530 if (possible_prefix_len == prefix_len && 531 strncmp(possible_prefix, prefixed_name, prefix_len) == 0) { 532 break; // matching prefix found 533 } 534 } 535 if (prefix_index < 0) { 536 break; // didn't find the prefix, can't be a wrapper 537 } 538 prefixed_name = name; 539 prefixed_name_len = name_len; 540 } 541 } 542 543 544 void vframeStreamCommon::skip_reflection_related_frames() { 545 while (!at_end() && 546 (method()->method_holder()->is_subclass_of(SystemDictionary::reflect_MethodAccessorImpl_klass()) || 547 method()->method_holder()->is_subclass_of(SystemDictionary::reflect_ConstructorAccessorImpl_klass()))) { 548 next(); 549 } 550 } 551 552 javaVFrame* vframeStreamCommon::asJavaVFrame() { 553 javaVFrame* result = NULL; 554 if (_mode == compiled_mode) { 555 guarantee(_frame.is_compiled_frame(), "expected compiled Java frame"); 556 557 // lazy update to register map 558 bool update_map = true; 559 RegisterMap map(_thread, update_map); 560 frame f = _prev_frame.sender(&map); 561 562 guarantee(f.is_compiled_frame(), "expected compiled Java frame"); 563 564 compiledVFrame* cvf = compiledVFrame::cast(vframe::new_vframe(&f, &map, _thread)); 565 566 guarantee(cvf->cb() == cb(), "wrong code blob"); 567 568 // get the same scope as this stream 569 cvf = cvf->at_scope(_decode_offset, _vframe_id); 570 571 guarantee(cvf->scope()->decode_offset() == _decode_offset, "wrong scope"); 572 guarantee(cvf->scope()->sender_decode_offset() == _sender_decode_offset, "wrong scope"); 573 guarantee(cvf->vframe_id() == _vframe_id, "wrong vframe"); 574 575 result = cvf; 576 } else { 577 result = javaVFrame::cast(vframe::new_vframe(&_frame, &_reg_map, _thread)); 578 } 579 guarantee(result->method() == method(), "wrong method"); 580 return result; 581 } 582 583 584 #ifndef PRODUCT 585 void vframe::print() { 586 if (WizardMode) _fr.print_value_on(tty,NULL); 587 } 588 589 590 void vframe::print_value() const { 591 ((vframe*)this)->print(); 592 } 593 594 595 void entryVFrame::print_value() const { 596 ((entryVFrame*)this)->print(); 597 } 598 599 void entryVFrame::print() { 600 vframe::print(); 601 tty->print_cr("C Chunk inbetween Java"); 602 tty->print_cr("C link " INTPTR_FORMAT, p2i(_fr.link())); 603 } 604 605 606 // ------------- javaVFrame -------------- 607 608 static void print_stack_values(const char* title, StackValueCollection* values) { 609 if (values->is_empty()) return; 610 tty->print_cr("\t%s:", title); 611 values->print(); 612 } 613 614 615 void javaVFrame::print() { 616 ResourceMark rm; 617 vframe::print(); 618 tty->print("\t"); 619 method()->print_value(); 620 tty->cr(); 621 tty->print_cr("\tbci: %d", bci()); 622 623 print_stack_values("locals", locals()); 624 print_stack_values("expressions", expressions()); 625 626 GrowableArray<MonitorInfo*>* list = monitors(); 627 if (list->is_empty()) return; 628 tty->print_cr("\tmonitor list:"); 629 for (int index = (list->length()-1); index >= 0; index--) { 630 MonitorInfo* monitor = list->at(index); 631 tty->print("\t obj\t"); 632 if (monitor->owner_is_scalar_replaced()) { 633 Klass* k = java_lang_Class::as_Klass(monitor->owner_klass()); 634 tty->print("( is scalar replaced %s)", k->external_name()); 635 } else if (monitor->owner() == NULL) { 636 tty->print("( null )"); 637 } else { 638 monitor->owner()->print_value(); 639 tty->print("(owner=" INTPTR_FORMAT ")", p2i(monitor->owner())); 640 } 641 if (monitor->eliminated()) { 642 if(is_compiled_frame()) { 643 tty->print(" ( lock is eliminated in compiled frame )"); 644 } else { 645 tty->print(" ( lock is eliminated, frame not compiled )"); 646 } 647 } 648 tty->cr(); 649 tty->print("\t "); 650 monitor->lock()->print_on(tty); 651 tty->cr(); 652 } 653 } 654 655 656 void javaVFrame::print_value() const { 657 Method* m = method(); 658 InstanceKlass* k = m->method_holder(); 659 tty->print_cr("frame( sp=" INTPTR_FORMAT ", unextended_sp=" INTPTR_FORMAT ", fp=" INTPTR_FORMAT ", pc=" INTPTR_FORMAT ")", 660 p2i(_fr.sp()), p2i(_fr.unextended_sp()), p2i(_fr.fp()), p2i(_fr.pc())); 661 tty->print("%s.%s", k->internal_name(), m->name()->as_C_string()); 662 663 if (!m->is_native()) { 664 Symbol* source_name = k->source_file_name(); 665 int line_number = m->line_number_from_bci(bci()); 666 if (source_name != NULL && (line_number != -1)) { 667 tty->print("(%s:%d)", source_name->as_C_string(), line_number); 668 } 669 } else { 670 tty->print("(Native Method)"); 671 } 672 // Check frame size and print warning if it looks suspiciously large 673 if (fr().sp() != NULL) { 674 RegisterMap map = *register_map(); 675 uint size = fr().frame_size(&map); 676 #ifdef _LP64 677 if (size > 8*K) warning("SUSPICIOUSLY LARGE FRAME (%d)", size); 678 #else 679 if (size > 4*K) warning("SUSPICIOUSLY LARGE FRAME (%d)", size); 680 #endif 681 } 682 } 683 684 685 bool javaVFrame::structural_compare(javaVFrame* other) { 686 // Check static part 687 if (method() != other->method()) return false; 688 if (bci() != other->bci()) return false; 689 690 // Check locals 691 StackValueCollection *locs = locals(); 692 StackValueCollection *other_locs = other->locals(); 693 assert(locs->size() == other_locs->size(), "sanity check"); 694 int i; 695 for(i = 0; i < locs->size(); i++) { 696 // it might happen the compiler reports a conflict and 697 // the interpreter reports a bogus int. 698 if ( is_compiled_frame() && locs->at(i)->type() == T_CONFLICT) continue; 699 if (other->is_compiled_frame() && other_locs->at(i)->type() == T_CONFLICT) continue; 700 701 if (!locs->at(i)->equal(other_locs->at(i))) 702 return false; 703 } 704 705 // Check expressions 706 StackValueCollection* exprs = expressions(); 707 StackValueCollection* other_exprs = other->expressions(); 708 assert(exprs->size() == other_exprs->size(), "sanity check"); 709 for(i = 0; i < exprs->size(); i++) { 710 if (!exprs->at(i)->equal(other_exprs->at(i))) 711 return false; 712 } 713 714 return true; 715 } 716 717 718 void javaVFrame::print_activation(int index) const { 719 // frame number and method 720 tty->print("%2d - ", index); 721 ((vframe*)this)->print_value(); 722 tty->cr(); 723 724 if (WizardMode) { 725 ((vframe*)this)->print(); 726 tty->cr(); 727 } 728 } 729 730 731 void javaVFrame::verify() const { 732 } 733 734 735 void interpretedVFrame::verify() const { 736 } 737 738 739 // ------------- externalVFrame -------------- 740 741 void externalVFrame::print() { 742 _fr.print_value_on(tty,NULL); 743 } 744 745 746 void externalVFrame::print_value() const { 747 ((vframe*)this)->print(); 748 } 749 #endif // PRODUCT