1 /* 2 * Copyright (c) 1997, 2014, 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/systemDictionary.hpp" 27 #include "code/codeCache.hpp" 28 #include "code/icBuffer.hpp" 29 #include "code/nmethod.hpp" 30 #include "code/vtableStubs.hpp" 31 #include "compiler/compileBroker.hpp" 32 #include "compiler/disassembler.hpp" 33 #include "gc_implementation/shared/markSweep.hpp" 34 #include "gc_interface/collectedHeap.hpp" 35 #include "interpreter/bytecodeHistogram.hpp" 36 #include "interpreter/interpreter.hpp" 37 #include "memory/resourceArea.hpp" 38 #include "memory/universe.hpp" 39 #include "oops/oop.inline.hpp" 40 #include "prims/privilegedStack.hpp" 41 #include "runtime/arguments.hpp" 42 #include "runtime/atomic.inline.hpp" 43 #include "runtime/frame.hpp" 44 #include "runtime/java.hpp" 45 #include "runtime/os.hpp" 46 #include "runtime/sharedRuntime.hpp" 47 #include "runtime/stubCodeGenerator.hpp" 48 #include "runtime/stubRoutines.hpp" 49 #include "runtime/thread.inline.hpp" 50 #include "runtime/vframe.hpp" 51 #include "runtime/vm_version.hpp" 52 #include "services/heapDumper.hpp" 53 #include "utilities/defaultStream.hpp" 54 #include "utilities/events.hpp" 55 #include "utilities/top.hpp" 56 #include "utilities/vmError.hpp" 57 58 #ifndef ASSERT 59 # ifdef _DEBUG 60 // NOTE: don't turn the lines below into a comment -- if you're getting 61 // a compile error here, change the settings to define ASSERT 62 ASSERT should be defined when _DEBUG is defined. It is not intended to be used for debugging 63 functions that do not slow down the system too much and thus can be left in optimized code. 64 On the other hand, the code should not be included in a production version. 65 # endif // _DEBUG 66 #endif // ASSERT 67 68 69 #ifdef _DEBUG 70 # ifndef ASSERT 71 configuration error: ASSERT must be defined in debug version 72 # endif // ASSERT 73 #endif // _DEBUG 74 75 76 #ifdef PRODUCT 77 # if -defined _DEBUG || -defined ASSERT 78 configuration error: ASSERT et al. must not be defined in PRODUCT version 79 # endif 80 #endif // PRODUCT 81 82 PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC 83 84 FormatBufferResource::FormatBufferResource(const char * format, ...) 85 : FormatBufferBase((char*)resource_allocate_bytes(RES_BUFSZ)) { 86 va_list argp; 87 va_start(argp, format); 88 jio_vsnprintf(_buf, RES_BUFSZ, format, argp); 89 va_end(argp); 90 } 91 92 ATTRIBUTE_PRINTF(1, 2) 93 void warning(const char* format, ...) { 94 if (PrintWarnings) { 95 FILE* const err = defaultStream::error_stream(); 96 jio_fprintf(err, "%s warning: ", VM_Version::vm_name()); 97 va_list ap; 98 va_start(ap, format); 99 vfprintf(err, format, ap); 100 va_end(ap); 101 fputc('\n', err); 102 } 103 if (BreakAtWarning) BREAKPOINT; 104 } 105 106 #ifndef PRODUCT 107 108 #define is_token_break(ch) (isspace(ch) || (ch) == ',') 109 110 static const char* last_file_name = NULL; 111 static int last_line_no = -1; 112 113 // assert/guarantee/... may happen very early during VM initialization. 114 // Don't rely on anything that is initialized by Threads::create_vm(). For 115 // example, don't use tty. 116 bool error_is_suppressed(const char* file_name, int line_no) { 117 // The following 1-element cache requires that passed-in 118 // file names are always only constant literals. 119 if (file_name == last_file_name && line_no == last_line_no) return true; 120 121 int file_name_len = (int)strlen(file_name); 122 char separator = os::file_separator()[0]; 123 const char* base_name = strrchr(file_name, separator); 124 if (base_name == NULL) 125 base_name = file_name; 126 127 // scan the SuppressErrorAt option 128 const char* cp = SuppressErrorAt; 129 for (;;) { 130 const char* sfile; 131 int sfile_len; 132 int sline; 133 bool noisy; 134 while ((*cp) != '\0' && is_token_break(*cp)) cp++; 135 if ((*cp) == '\0') break; 136 sfile = cp; 137 while ((*cp) != '\0' && !is_token_break(*cp) && (*cp) != ':') cp++; 138 sfile_len = cp - sfile; 139 if ((*cp) == ':') cp++; 140 sline = 0; 141 while ((*cp) != '\0' && isdigit(*cp)) { 142 sline *= 10; 143 sline += (*cp) - '0'; 144 cp++; 145 } 146 // "file:line!" means the assert suppression is not silent 147 noisy = ((*cp) == '!'); 148 while ((*cp) != '\0' && !is_token_break(*cp)) cp++; 149 // match the line 150 if (sline != 0) { 151 if (sline != line_no) continue; 152 } 153 // match the file 154 if (sfile_len > 0) { 155 const char* look = file_name; 156 const char* look_max = file_name + file_name_len - sfile_len; 157 const char* foundp; 158 bool match = false; 159 while (!match 160 && (foundp = strchr(look, sfile[0])) != NULL 161 && foundp <= look_max) { 162 match = true; 163 for (int i = 1; i < sfile_len; i++) { 164 if (sfile[i] != foundp[i]) { 165 match = false; 166 break; 167 } 168 } 169 look = foundp + 1; 170 } 171 if (!match) continue; 172 } 173 // got a match! 174 if (noisy) { 175 fdStream out(defaultStream::output_fd()); 176 out.print_raw("[error suppressed at "); 177 out.print_raw(base_name); 178 char buf[16]; 179 jio_snprintf(buf, sizeof(buf), ":%d]", line_no); 180 out.print_raw_cr(buf); 181 } else { 182 // update 1-element cache for fast silent matches 183 last_file_name = file_name; 184 last_line_no = line_no; 185 } 186 return true; 187 } 188 189 if (!is_error_reported()) { 190 // print a friendly hint: 191 fdStream out(defaultStream::output_fd()); 192 out.print_raw_cr("# To suppress the following error report, specify this argument"); 193 out.print_raw ("# after -XX: or in .hotspotrc: SuppressErrorAt="); 194 out.print_raw (base_name); 195 char buf[16]; 196 jio_snprintf(buf, sizeof(buf), ":%d", line_no); 197 out.print_raw_cr(buf); 198 } 199 return false; 200 } 201 202 #undef is_token_break 203 204 #else 205 206 // Place-holder for non-existent suppression check: 207 #define error_is_suppressed(file_name, line_no) (false) 208 209 #endif // !PRODUCT 210 211 void report_vm_error(const char* file, int line, const char* error_msg, 212 const char* detail_msg) 213 { 214 if (Debugging || error_is_suppressed(file, line)) return; 215 Thread* const thread = ThreadLocalStorage::get_thread_slow(); 216 VMError err(thread, file, line, error_msg, detail_msg); 217 err.report_and_die(); 218 } 219 220 void report_fatal(const char* file, int line, const char* message) 221 { 222 report_vm_error(file, line, "fatal error", message); 223 } 224 225 void report_vm_out_of_memory(const char* file, int line, size_t size, 226 VMErrorType vm_err_type, const char* message) { 227 if (Debugging) return; 228 229 Thread* thread = ThreadLocalStorage::get_thread_slow(); 230 VMError(thread, file, line, size, vm_err_type, message).report_and_die(); 231 232 // The UseOSErrorReporting option in report_and_die() may allow a return 233 // to here. If so then we'll have to figure out how to handle it. 234 guarantee(false, "report_and_die() should not return here"); 235 } 236 237 void report_should_not_call(const char* file, int line) { 238 report_vm_error(file, line, "ShouldNotCall()"); 239 } 240 241 void report_should_not_reach_here(const char* file, int line) { 242 report_vm_error(file, line, "ShouldNotReachHere()"); 243 } 244 245 void report_unimplemented(const char* file, int line) { 246 report_vm_error(file, line, "Unimplemented()"); 247 } 248 249 void report_untested(const char* file, int line, const char* message) { 250 #ifndef PRODUCT 251 warning("Untested: %s in %s: %d\n", message, file, line); 252 #endif // !PRODUCT 253 } 254 255 void report_out_of_shared_space(SharedSpaceType shared_space) { 256 static const char* name[] = { 257 "shared read only space", 258 "shared read write space", 259 "shared miscellaneous data space", 260 "shared miscellaneous code space" 261 }; 262 static const char* flag[] = { 263 "SharedReadOnlySize", 264 "SharedReadWriteSize", 265 "SharedMiscDataSize", 266 "SharedMiscCodeSize" 267 }; 268 269 warning("\nThe %s is not large enough\n" 270 "to preload requested classes. Use -XX:%s=<size>\n" 271 "to increase the initial size of %s.\n", 272 name[shared_space], flag[shared_space], name[shared_space]); 273 exit(2); 274 } 275 276 void report_java_out_of_memory(const char* message) { 277 static jint out_of_memory_reported = 0; 278 279 // A number of threads may attempt to report OutOfMemoryError at around the 280 // same time. To avoid dumping the heap or executing the data collection 281 // commands multiple times we just do it once when the first threads reports 282 // the error. 283 if (Atomic::cmpxchg(1, &out_of_memory_reported, 0) == 0) { 284 // create heap dump before OnOutOfMemoryError commands are executed 285 if (HeapDumpOnOutOfMemoryError) { 286 tty->print_cr("java.lang.OutOfMemoryError: %s", message); 287 HeapDumper::dump_heap_from_oome(); 288 } 289 290 if (OnOutOfMemoryError && OnOutOfMemoryError[0]) { 291 VMError err(message); 292 err.report_java_out_of_memory(); 293 } 294 } 295 } 296 297 static bool error_reported = false; 298 299 // call this when the VM is dying--it might loosen some asserts 300 void set_error_reported() { 301 error_reported = true; 302 } 303 304 bool is_error_reported() { 305 return error_reported; 306 } 307 308 #ifndef PRODUCT 309 #include <signal.h> 310 311 typedef void (*voidfun_t)(); 312 // Crash with an authentic sigill at a known PC. 313 static void crash_with_sigill() { 314 bool rc = false; 315 const size_t size = os::vm_page_size(); 316 static void* pc = NULL; 317 318 // prepare a "blob" with an illegal instruction sequence which 319 // we then execute. Have to use os::reserve_memory to be able to 320 // make the memory executable. 321 if (!pc) { 322 void* p = os::reserve_memory(size, NULL, 0); 323 if (p) { 324 bool rc = os::commit_memory((char*)p, size, true); 325 if (rc) { 326 if (get_illegal_instruction_sequence((uint8_t*)p)) { 327 pc = p; 328 } 329 } 330 } 331 } 332 333 // Fallback: if there is no implementation for get_illegal_instruction_sequence 334 // for the current platform, just do a raise(SIGILL). Raising a signal is 335 // different from triggering it naturaly (e.g. raised synchronous signals can 336 // be blocked) but for the test purposes it is better than nothing. 337 if (pc == NULL) { 338 tty->print_cr("will raise a SIGILL"); 339 tty->flush(); 340 raise(SIGILL); 341 ShouldNotReachHere(); 342 } 343 344 tty->print_cr("will jump to PC " PTR_FORMAT 345 ", which should cause a SIGILL.", pc); 346 tty->flush(); 347 348 volatile voidfun_t g_voidfun = NULL; 349 350 #if defined(IA64) || defined(PPC64) 351 // on ia64 and on ppc we have function descriptors. 352 struct { void* p1; void* p2; } fundes = 353 { pc, pc }; 354 void* p = (void*)(&fundes); 355 g_voidfun = (voidfun_t) (p); 356 #else 357 g_voidfun = (voidfun_t)pc; 358 #endif 359 360 g_voidfun(); // boom. 361 362 } // end: crash_with_sigill 363 364 // crash with sigsegv at non-null address. 365 static void crash_with_segfault() { 366 367 char* const crash_addr = (char*) get_segfault_address(); 368 369 tty->print_cr("will access address " PTR_FORMAT 370 ", which should cause a SIGSEGV.", crash_addr); 371 tty->flush(); 372 373 *crash_addr = 'X'; 374 375 } // end: crash_with_segfault 376 377 // returns an address which is guaranteed to generate a SIGSEGV on read, 378 // for test purposes, which is not NULL and contains bits in every word 379 void* get_segfault_address() { 380 return (void*) 381 #ifdef _LP64 382 0xABC0000000000ABCULL; 383 #else 384 0x00000ABC; 385 #endif 386 } 387 388 void test_error_handler() { 389 controlled_crash(ErrorHandlerTest); 390 } 391 392 void controlled_crash(int how) { 393 if (how == 0) return; 394 395 // If asserts are disabled, use the corresponding guarantee instead. 396 NOT_DEBUG(if (how <= 2) how += 2); 397 398 const char* const str = "hello"; 399 const size_t num = (size_t)os::vm_page_size(); 400 401 const char* const eol = os::line_separator(); 402 const char* const msg = "this message should be truncated during formatting"; 403 char * const dataPtr = NULL; // bad data pointer 404 const void (*funcPtr)(void) = (const void(*)()) 0xF; // bad function pointer 405 406 // Keep this in sync with test/runtime/6888954/vmerrors.sh. 407 switch (how) { 408 case 1: assert(str == NULL, "expected null"); 409 case 2: assert(num == 1023 && *str == 'X', 410 err_msg("num=" SIZE_FORMAT " str=\"%s\"", num, str)); 411 case 3: guarantee(str == NULL, "expected null"); 412 case 4: guarantee(num == 1023 && *str == 'X', 413 err_msg("num=" SIZE_FORMAT " str=\"%s\"", num, str)); 414 case 5: fatal("expected null"); 415 case 6: fatal(err_msg("num=" SIZE_FORMAT " str=\"%s\"", num, str)); 416 case 7: fatal(err_msg("%s%s# %s%s# %s%s# %s%s# %s%s# " 417 "%s%s# %s%s# %s%s# %s%s# %s%s# " 418 "%s%s# %s%s# %s%s# %s%s# %s", 419 msg, eol, msg, eol, msg, eol, msg, eol, msg, eol, 420 msg, eol, msg, eol, msg, eol, msg, eol, msg, eol, 421 msg, eol, msg, eol, msg, eol, msg, eol, msg)); 422 case 8: vm_exit_out_of_memory(num, OOM_MALLOC_ERROR, "ChunkPool::allocate"); 423 case 9: ShouldNotCallThis(); 424 case 10: ShouldNotReachHere(); 425 case 11: Unimplemented(); 426 // There's no guarantee the bad data pointer will crash us 427 // so "break" out to the ShouldNotReachHere(). 428 case 12: *dataPtr = '\0'; break; 429 // There's no guarantee the bad function pointer will crash us 430 // so "break" out to the ShouldNotReachHere(). 431 case 13: (*funcPtr)(); break; 432 case 14: crash_with_segfault(); break; 433 case 15: crash_with_sigill(); break; 434 435 default: tty->print_cr("ERROR: %d: unexpected test_num value.", how); 436 } 437 ShouldNotReachHere(); 438 } 439 #endif // !PRODUCT 440 441 // ------ helper functions for debugging go here ------------ 442 443 // All debug entries should be wrapped with a stack allocated 444 // Command object. It makes sure a resource mark is set and 445 // flushes the logfile to prevent file sharing problems. 446 447 class Command : public StackObj { 448 private: 449 ResourceMark rm; 450 ResetNoHandleMark rnhm; 451 HandleMark hm; 452 bool debug_save; 453 public: 454 static int level; 455 Command(const char* str) { 456 debug_save = Debugging; 457 Debugging = true; 458 if (level++ > 0) return; 459 tty->cr(); 460 tty->print_cr("\"Executing %s\"", str); 461 } 462 463 ~Command() { 464 tty->flush(); 465 Debugging = debug_save; 466 level--; 467 } 468 }; 469 470 int Command::level = 0; 471 472 #ifndef PRODUCT 473 474 extern "C" void blob(CodeBlob* cb) { 475 Command c("blob"); 476 cb->print(); 477 } 478 479 480 extern "C" void dump_vtable(address p) { 481 Command c("dump_vtable"); 482 Klass* k = (Klass*)p; 483 InstanceKlass::cast(k)->vtable()->print(); 484 } 485 486 487 extern "C" void nm(intptr_t p) { 488 // Actually we look through all CodeBlobs (the nm name has been kept for backwards compatability) 489 Command c("nm"); 490 CodeBlob* cb = CodeCache::find_blob((address)p); 491 if (cb == NULL) { 492 tty->print_cr("NULL"); 493 } else { 494 cb->print(); 495 } 496 } 497 498 499 extern "C" void disnm(intptr_t p) { 500 Command c("disnm"); 501 CodeBlob* cb = CodeCache::find_blob((address) p); 502 nmethod* nm = cb->as_nmethod_or_null(); 503 if (nm) { 504 nm->print(); 505 Disassembler::decode(nm); 506 } else { 507 cb->print(); 508 Disassembler::decode(cb); 509 } 510 } 511 512 513 extern "C" void printnm(intptr_t p) { 514 char buffer[256]; 515 sprintf(buffer, "printnm: " INTPTR_FORMAT, p); 516 Command c(buffer); 517 CodeBlob* cb = CodeCache::find_blob((address) p); 518 if (cb->is_nmethod()) { 519 nmethod* nm = (nmethod*)cb; 520 nm->print_nmethod(true); 521 } 522 } 523 524 525 extern "C" void universe() { 526 Command c("universe"); 527 Universe::print(); 528 } 529 530 531 extern "C" void verify() { 532 // try to run a verify on the entire system 533 // note: this may not be safe if we're not at a safepoint; for debugging, 534 // this manipulates the safepoint settings to avoid assertion failures 535 Command c("universe verify"); 536 bool safe = SafepointSynchronize::is_at_safepoint(); 537 if (!safe) { 538 tty->print_cr("warning: not at safepoint -- verify may fail"); 539 SafepointSynchronize::set_is_at_safepoint(); 540 } 541 // Ensure Eden top is correct before verification 542 Universe::heap()->prepare_for_verify(); 543 Universe::verify(); 544 if (!safe) SafepointSynchronize::set_is_not_at_safepoint(); 545 } 546 547 548 extern "C" void pp(void* p) { 549 Command c("pp"); 550 FlagSetting fl(PrintVMMessages, true); 551 FlagSetting f2(DisplayVMOutput, true); 552 if (Universe::heap()->is_in(p)) { 553 oop obj = oop(p); 554 obj->print(); 555 } else { 556 tty->print(PTR_FORMAT, p); 557 } 558 } 559 560 561 // pv: print vm-printable object 562 extern "C" void pa(intptr_t p) { ((AllocatedObj*) p)->print(); } 563 extern "C" void findpc(intptr_t x); 564 565 #endif // !PRODUCT 566 567 extern "C" void ps() { // print stack 568 if (Thread::current() == NULL) return; 569 Command c("ps"); 570 571 572 // Prints the stack of the current Java thread 573 JavaThread* p = JavaThread::active(); 574 tty->print(" for thread: "); 575 p->print(); 576 tty->cr(); 577 578 if (p->has_last_Java_frame()) { 579 // If the last_Java_fp is set we are in C land and 580 // can call the standard stack_trace function. 581 #ifdef PRODUCT 582 p->print_stack(); 583 } else { 584 tty->print_cr("Cannot find the last Java frame, printing stack disabled."); 585 #else // !PRODUCT 586 p->trace_stack(); 587 } else { 588 frame f = os::current_frame(); 589 RegisterMap reg_map(p); 590 f = f.sender(®_map); 591 tty->print("(guessing starting frame id=%#p based on current fp)\n", f.id()); 592 p->trace_stack_from(vframe::new_vframe(&f, ®_map, p)); 593 pd_ps(f); 594 #endif // PRODUCT 595 } 596 597 } 598 599 extern "C" void pfl() { 600 // print frame layout 601 Command c("pfl"); 602 JavaThread* p = JavaThread::active(); 603 tty->print(" for thread: "); 604 p->print(); 605 tty->cr(); 606 if (p->has_last_Java_frame()) { 607 p->print_frame_layout(); 608 } 609 } 610 611 #ifndef PRODUCT 612 613 extern "C" void psf() { // print stack frames 614 { 615 Command c("psf"); 616 JavaThread* p = JavaThread::active(); 617 tty->print(" for thread: "); 618 p->print(); 619 tty->cr(); 620 if (p->has_last_Java_frame()) { 621 p->trace_frames(); 622 } 623 } 624 } 625 626 627 extern "C" void threads() { 628 Command c("threads"); 629 Threads::print(false, true); 630 } 631 632 633 extern "C" void psd() { 634 Command c("psd"); 635 SystemDictionary::print(); 636 } 637 638 639 extern "C" void safepoints() { 640 Command c("safepoints"); 641 SafepointSynchronize::print_state(); 642 } 643 644 #endif // !PRODUCT 645 646 extern "C" void pss() { // print all stacks 647 if (Thread::current() == NULL) return; 648 Command c("pss"); 649 Threads::print(true, PRODUCT_ONLY(false) NOT_PRODUCT(true)); 650 } 651 652 #ifndef PRODUCT 653 654 extern "C" void debug() { // to set things up for compiler debugging 655 Command c("debug"); 656 WizardMode = true; 657 PrintVMMessages = PrintCompilation = true; 658 PrintInlining = PrintAssembly = true; 659 tty->flush(); 660 } 661 662 663 extern "C" void ndebug() { // undo debug() 664 Command c("ndebug"); 665 PrintCompilation = false; 666 PrintInlining = PrintAssembly = false; 667 tty->flush(); 668 } 669 670 671 extern "C" void flush() { 672 Command c("flush"); 673 tty->flush(); 674 } 675 676 extern "C" void events() { 677 Command c("events"); 678 Events::print(); 679 } 680 681 extern "C" Method* findm(intptr_t pc) { 682 Command c("findm"); 683 nmethod* nm = CodeCache::find_nmethod((address)pc); 684 return (nm == NULL) ? (Method*)NULL : nm->method(); 685 } 686 687 688 extern "C" nmethod* findnm(intptr_t addr) { 689 Command c("findnm"); 690 return CodeCache::find_nmethod((address)addr); 691 } 692 693 // Another interface that isn't ambiguous in dbx. 694 // Can we someday rename the other find to hsfind? 695 extern "C" void hsfind(intptr_t x) { 696 Command c("hsfind"); 697 os::print_location(tty, x, false); 698 } 699 700 701 extern "C" void find(intptr_t x) { 702 Command c("find"); 703 os::print_location(tty, x, false); 704 } 705 706 707 extern "C" void findpc(intptr_t x) { 708 Command c("findpc"); 709 os::print_location(tty, x, true); 710 } 711 712 713 // Need method pointer to find bcp, when not in permgen. 714 extern "C" void findbcp(intptr_t method, intptr_t bcp) { 715 Command c("findbcp"); 716 Method* mh = (Method*)method; 717 if (!mh->is_native()) { 718 tty->print_cr("bci_from(%p) = %d; print_codes():", 719 mh, mh->bci_from(address(bcp))); 720 mh->print_codes_on(tty); 721 } 722 } 723 724 // int versions of all methods to avoid having to type type casts in the debugger 725 726 void pp(intptr_t p) { pp((void*)p); } 727 void pp(oop p) { pp((void*)p); } 728 729 void help() { 730 Command c("help"); 731 tty->print_cr("basic"); 732 tty->print_cr(" pp(void* p) - try to make sense of p"); 733 tty->print_cr(" pv(intptr_t p)- ((PrintableResourceObj*) p)->print()"); 734 tty->print_cr(" ps() - print current thread stack"); 735 tty->print_cr(" pss() - print all thread stacks"); 736 tty->print_cr(" pm(int pc) - print Method* given compiled PC"); 737 tty->print_cr(" findm(intptr_t pc) - finds Method*"); 738 tty->print_cr(" find(intptr_t x) - finds & prints nmethod/stub/bytecode/oop based on pointer into it"); 739 tty->print_cr(" pns(void* sp, void* fp, void* pc) - print native (i.e. mixed) stack trace. E.g."); 740 tty->print_cr(" pns($sp, $rbp, $pc) on Linux/amd64 and Solaris/amd64 or"); 741 tty->print_cr(" pns($sp, $ebp, $pc) on Linux/x86 or"); 742 tty->print_cr(" pns($sp, 0, $pc) on Linux/ppc64 or"); 743 tty->print_cr(" pns($sp + 0x7ff, 0, $pc) on Solaris/SPARC"); 744 tty->print_cr(" - in gdb do 'set overload-resolution off' before calling pns()"); 745 tty->print_cr(" - in dbx do 'frame 1' before calling pns()"); 746 747 tty->print_cr("misc."); 748 tty->print_cr(" flush() - flushes the log file"); 749 tty->print_cr(" events() - dump events from ring buffers"); 750 751 752 tty->print_cr("compiler debugging"); 753 tty->print_cr(" debug() - to set things up for compiler debugging"); 754 tty->print_cr(" ndebug() - undo debug"); 755 } 756 757 #endif // !PRODUCT 758 759 void print_native_stack(outputStream* st, frame fr, Thread* t, char* buf, int buf_size) { 760 761 // see if it's a valid frame 762 if (fr.pc()) { 763 st->print_cr("Native frames: (J=compiled Java code, j=interpreted, Vv=VM code, C=native code)"); 764 765 int count = 0; 766 while (count++ < StackPrintLimit) { 767 fr.print_on_error(st, buf, buf_size); 768 st->cr(); 769 // Compiled code may use EBP register on x86 so it looks like 770 // non-walkable C frame. Use frame.sender() for java frames. 771 if (t && t->is_Java_thread()) { 772 // Catch very first native frame by using stack address. 773 // For JavaThread stack_base and stack_size should be set. 774 if (!t->on_local_stack((address)(fr.real_fp() + 1))) { 775 break; 776 } 777 if (fr.is_java_frame() || fr.is_native_frame() || fr.is_runtime_frame()) { 778 RegisterMap map((JavaThread*)t, false); // No update 779 fr = fr.sender(&map); 780 } else { 781 fr = os::get_sender_for_C_frame(&fr); 782 } 783 } else { 784 // is_first_C_frame() does only simple checks for frame pointer, 785 // it will pass if java compiled code has a pointer in EBP. 786 if (os::is_first_C_frame(&fr)) break; 787 fr = os::get_sender_for_C_frame(&fr); 788 } 789 } 790 791 if (count > StackPrintLimit) { 792 st->print_cr("...<more frames>..."); 793 } 794 795 st->cr(); 796 } 797 } 798 799 #ifndef PRODUCT 800 801 extern "C" void pns(void* sp, void* fp, void* pc) { // print native stack 802 Command c("pns"); 803 static char buf[O_BUFLEN]; 804 Thread* t = ThreadLocalStorage::get_thread_slow(); 805 // Call generic frame constructor (certain arguments may be ignored) 806 frame fr(sp, fp, pc); 807 print_native_stack(tty, fr, t, buf, sizeof(buf)); 808 } 809 810 #endif // !PRODUCT