1 /* 2 * Copyright (c) 1997, 2015, 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_insufficient_metaspace(size_t required_size) { 277 warning("\nThe MaxMetaspaceSize of " UINTX_FORMAT " bytes is not large enough.\n" 278 "Either don't specify the -XX:MaxMetaspaceSize=<size>\n" 279 "or increase the size to at least " SIZE_FORMAT ".\n", 280 MaxMetaspaceSize, required_size); 281 exit(2); 282 } 283 284 void report_java_out_of_memory(const char* message) { 285 static jint out_of_memory_reported = 0; 286 287 // A number of threads may attempt to report OutOfMemoryError at around the 288 // same time. To avoid dumping the heap or executing the data collection 289 // commands multiple times we just do it once when the first threads reports 290 // the error. 291 if (Atomic::cmpxchg(1, &out_of_memory_reported, 0) == 0) { 292 // create heap dump before OnOutOfMemoryError commands are executed 293 if (HeapDumpOnOutOfMemoryError) { 294 tty->print_cr("java.lang.OutOfMemoryError: %s", message); 295 HeapDumper::dump_heap_from_oome(); 296 } 297 298 if (OnOutOfMemoryError && OnOutOfMemoryError[0]) { 299 VMError err(message); 300 err.report_java_out_of_memory(); 301 } 302 } 303 } 304 305 static bool error_reported = false; 306 307 // call this when the VM is dying--it might loosen some asserts 308 void set_error_reported() { 309 error_reported = true; 310 } 311 312 bool is_error_reported() { 313 return error_reported; 314 } 315 316 #ifndef PRODUCT 317 #include <signal.h> 318 319 typedef void (*voidfun_t)(); 320 // Crash with an authentic sigfpe 321 static void crash_with_sigfpe() { 322 // generate a native synchronous SIGFPE where possible; 323 // if that did not cause a signal (e.g. on ppc), just 324 // raise the signal. 325 volatile int x = 0; 326 volatile int y = 1/x; 327 printf("%d", y); 328 #ifndef _WIN32 329 raise(SIGFPE); 330 #endif 331 } // end: crash_with_sigfpe 332 333 // crash with sigsegv at non-null address. 334 static void crash_with_segfault() { 335 336 char* const crash_addr = (char*) get_segfault_address(); 337 338 tty->print_cr("will access address " PTR_FORMAT 339 ", which should cause a SIGSEGV.", crash_addr); 340 tty->flush(); 341 342 *crash_addr = 'X'; 343 344 } // end: crash_with_segfault 345 346 // returns an address which is guaranteed to generate a SIGSEGV on read, 347 // for test purposes, which is not NULL and contains bits in every word 348 void* get_segfault_address() { 349 return (void*) 350 #ifdef _LP64 351 0xABC0000000000ABCULL; 352 #else 353 0x00000ABC; 354 #endif 355 } 356 357 void test_error_handler() { 358 controlled_crash(ErrorHandlerTest); 359 } 360 361 void controlled_crash(int how) { 362 if (how == 0) return; 363 364 // If asserts are disabled, use the corresponding guarantee instead. 365 NOT_DEBUG(if (how <= 2) how += 2); 366 367 const char* const str = "hello"; 368 const size_t num = (size_t)os::vm_page_size(); 369 370 const char* const eol = os::line_separator(); 371 const char* const msg = "this message should be truncated during formatting"; 372 char * const dataPtr = NULL; // bad data pointer 373 const void (*funcPtr)(void) = (const void(*)()) 0xF; // bad function pointer 374 375 // Keep this in sync with test/runtime/6888954/vmerrors.sh. 376 switch (how) { 377 case 1: vmassert(str == NULL, "expected null"); 378 case 2: vmassert(num == 1023 && *str == 'X', 379 err_msg("num=" SIZE_FORMAT " str=\"%s\"", num, str)); 380 case 3: guarantee(str == NULL, "expected null"); 381 case 4: guarantee(num == 1023 && *str == 'X', 382 err_msg("num=" SIZE_FORMAT " str=\"%s\"", num, str)); 383 case 5: fatal("expected null"); 384 case 6: fatal(err_msg("num=" SIZE_FORMAT " str=\"%s\"", num, str)); 385 case 7: fatal(err_msg("%s%s# %s%s# %s%s# %s%s# %s%s# " 386 "%s%s# %s%s# %s%s# %s%s# %s%s# " 387 "%s%s# %s%s# %s%s# %s%s# %s", 388 msg, eol, msg, eol, msg, eol, msg, eol, msg, eol, 389 msg, eol, msg, eol, msg, eol, msg, eol, msg, eol, 390 msg, eol, msg, eol, msg, eol, msg, eol, msg)); 391 case 8: vm_exit_out_of_memory(num, OOM_MALLOC_ERROR, "ChunkPool::allocate"); 392 case 9: ShouldNotCallThis(); 393 case 10: ShouldNotReachHere(); 394 case 11: Unimplemented(); 395 // There's no guarantee the bad data pointer will crash us 396 // so "break" out to the ShouldNotReachHere(). 397 case 12: *dataPtr = '\0'; break; 398 // There's no guarantee the bad function pointer will crash us 399 // so "break" out to the ShouldNotReachHere(). 400 case 13: (*funcPtr)(); break; 401 case 14: crash_with_segfault(); break; 402 case 15: crash_with_sigfpe(); break; 403 404 default: tty->print_cr("ERROR: %d: unexpected test_num value.", how); 405 } 406 ShouldNotReachHere(); 407 } 408 #endif // !PRODUCT 409 410 // ------ helper functions for debugging go here ------------ 411 412 // All debug entries should be wrapped with a stack allocated 413 // Command object. It makes sure a resource mark is set and 414 // flushes the logfile to prevent file sharing problems. 415 416 class Command : public StackObj { 417 private: 418 ResourceMark rm; 419 ResetNoHandleMark rnhm; 420 HandleMark hm; 421 bool debug_save; 422 public: 423 static int level; 424 Command(const char* str) { 425 debug_save = Debugging; 426 Debugging = true; 427 if (level++ > 0) return; 428 tty->cr(); 429 tty->print_cr("\"Executing %s\"", str); 430 } 431 432 ~Command() { 433 tty->flush(); 434 Debugging = debug_save; 435 level--; 436 } 437 }; 438 439 int Command::level = 0; 440 441 #ifndef PRODUCT 442 443 extern "C" void blob(CodeBlob* cb) { 444 Command c("blob"); 445 cb->print(); 446 } 447 448 449 extern "C" void dump_vtable(address p) { 450 Command c("dump_vtable"); 451 Klass* k = (Klass*)p; 452 InstanceKlass::cast(k)->vtable()->print(); 453 } 454 455 456 extern "C" void nm(intptr_t p) { 457 // Actually we look through all CodeBlobs (the nm name has been kept for backwards compatability) 458 Command c("nm"); 459 CodeBlob* cb = CodeCache::find_blob((address)p); 460 if (cb == NULL) { 461 tty->print_cr("NULL"); 462 } else { 463 cb->print(); 464 } 465 } 466 467 468 extern "C" void disnm(intptr_t p) { 469 Command c("disnm"); 470 CodeBlob* cb = CodeCache::find_blob((address) p); 471 nmethod* nm = cb->as_nmethod_or_null(); 472 if (nm) { 473 nm->print(); 474 Disassembler::decode(nm); 475 } else { 476 cb->print(); 477 Disassembler::decode(cb); 478 } 479 } 480 481 482 extern "C" void printnm(intptr_t p) { 483 char buffer[256]; 484 sprintf(buffer, "printnm: " INTPTR_FORMAT, p); 485 Command c(buffer); 486 CodeBlob* cb = CodeCache::find_blob((address) p); 487 if (cb->is_nmethod()) { 488 nmethod* nm = (nmethod*)cb; 489 nm->print_nmethod(true); 490 } 491 } 492 493 494 extern "C" void universe() { 495 Command c("universe"); 496 Universe::print(); 497 } 498 499 500 extern "C" void verify() { 501 // try to run a verify on the entire system 502 // note: this may not be safe if we're not at a safepoint; for debugging, 503 // this manipulates the safepoint settings to avoid assertion failures 504 Command c("universe verify"); 505 bool safe = SafepointSynchronize::is_at_safepoint(); 506 if (!safe) { 507 tty->print_cr("warning: not at safepoint -- verify may fail"); 508 SafepointSynchronize::set_is_at_safepoint(); 509 } 510 // Ensure Eden top is correct before verification 511 Universe::heap()->prepare_for_verify(); 512 Universe::verify(); 513 if (!safe) SafepointSynchronize::set_is_not_at_safepoint(); 514 } 515 516 517 extern "C" void pp(void* p) { 518 Command c("pp"); 519 FlagSetting fl(PrintVMMessages, true); 520 FlagSetting f2(DisplayVMOutput, true); 521 if (Universe::heap()->is_in(p)) { 522 oop obj = oop(p); 523 obj->print(); 524 } else { 525 tty->print(PTR_FORMAT, p); 526 } 527 } 528 529 530 // pv: print vm-printable object 531 extern "C" void pa(intptr_t p) { ((AllocatedObj*) p)->print(); } 532 extern "C" void findpc(intptr_t x); 533 534 #endif // !PRODUCT 535 536 extern "C" void ps() { // print stack 537 if (Thread::current() == NULL) return; 538 Command c("ps"); 539 540 541 // Prints the stack of the current Java thread 542 JavaThread* p = JavaThread::active(); 543 tty->print(" for thread: "); 544 p->print(); 545 tty->cr(); 546 547 if (p->has_last_Java_frame()) { 548 // If the last_Java_fp is set we are in C land and 549 // can call the standard stack_trace function. 550 #ifdef PRODUCT 551 p->print_stack(); 552 } else { 553 tty->print_cr("Cannot find the last Java frame, printing stack disabled."); 554 #else // !PRODUCT 555 p->trace_stack(); 556 } else { 557 frame f = os::current_frame(); 558 RegisterMap reg_map(p); 559 f = f.sender(®_map); 560 tty->print("(guessing starting frame id=%#p based on current fp)\n", f.id()); 561 p->trace_stack_from(vframe::new_vframe(&f, ®_map, p)); 562 pd_ps(f); 563 #endif // PRODUCT 564 } 565 566 } 567 568 extern "C" void pfl() { 569 // print frame layout 570 Command c("pfl"); 571 JavaThread* p = JavaThread::active(); 572 tty->print(" for thread: "); 573 p->print(); 574 tty->cr(); 575 if (p->has_last_Java_frame()) { 576 p->print_frame_layout(); 577 } 578 } 579 580 #ifndef PRODUCT 581 582 extern "C" void psf() { // print stack frames 583 { 584 Command c("psf"); 585 JavaThread* p = JavaThread::active(); 586 tty->print(" for thread: "); 587 p->print(); 588 tty->cr(); 589 if (p->has_last_Java_frame()) { 590 p->trace_frames(); 591 } 592 } 593 } 594 595 596 extern "C" void threads() { 597 Command c("threads"); 598 Threads::print(false, true); 599 } 600 601 602 extern "C" void psd() { 603 Command c("psd"); 604 SystemDictionary::print(); 605 } 606 607 608 extern "C" void safepoints() { 609 Command c("safepoints"); 610 SafepointSynchronize::print_state(); 611 } 612 613 #endif // !PRODUCT 614 615 extern "C" void pss() { // print all stacks 616 if (Thread::current() == NULL) return; 617 Command c("pss"); 618 Threads::print(true, PRODUCT_ONLY(false) NOT_PRODUCT(true)); 619 } 620 621 #ifndef PRODUCT 622 623 extern "C" void debug() { // to set things up for compiler debugging 624 Command c("debug"); 625 WizardMode = true; 626 PrintVMMessages = PrintCompilation = true; 627 PrintInlining = PrintAssembly = true; 628 tty->flush(); 629 } 630 631 632 extern "C" void ndebug() { // undo debug() 633 Command c("ndebug"); 634 PrintCompilation = false; 635 PrintInlining = PrintAssembly = false; 636 tty->flush(); 637 } 638 639 640 extern "C" void flush() { 641 Command c("flush"); 642 tty->flush(); 643 } 644 645 extern "C" void events() { 646 Command c("events"); 647 Events::print(); 648 } 649 650 extern "C" Method* findm(intptr_t pc) { 651 Command c("findm"); 652 nmethod* nm = CodeCache::find_nmethod((address)pc); 653 return (nm == NULL) ? (Method*)NULL : nm->method(); 654 } 655 656 657 extern "C" nmethod* findnm(intptr_t addr) { 658 Command c("findnm"); 659 return CodeCache::find_nmethod((address)addr); 660 } 661 662 // Another interface that isn't ambiguous in dbx. 663 // Can we someday rename the other find to hsfind? 664 extern "C" void hsfind(intptr_t x) { 665 Command c("hsfind"); 666 os::print_location(tty, x, false); 667 } 668 669 670 extern "C" void find(intptr_t x) { 671 Command c("find"); 672 os::print_location(tty, x, false); 673 } 674 675 676 extern "C" void findpc(intptr_t x) { 677 Command c("findpc"); 678 os::print_location(tty, x, true); 679 } 680 681 682 // Need method pointer to find bcp, when not in permgen. 683 extern "C" void findbcp(intptr_t method, intptr_t bcp) { 684 Command c("findbcp"); 685 Method* mh = (Method*)method; 686 if (!mh->is_native()) { 687 tty->print_cr("bci_from(%p) = %d; print_codes():", 688 mh, mh->bci_from(address(bcp))); 689 mh->print_codes_on(tty); 690 } 691 } 692 693 // int versions of all methods to avoid having to type type casts in the debugger 694 695 void pp(intptr_t p) { pp((void*)p); } 696 void pp(oop p) { pp((void*)p); } 697 698 void help() { 699 Command c("help"); 700 tty->print_cr("basic"); 701 tty->print_cr(" pp(void* p) - try to make sense of p"); 702 tty->print_cr(" pv(intptr_t p)- ((PrintableResourceObj*) p)->print()"); 703 tty->print_cr(" ps() - print current thread stack"); 704 tty->print_cr(" pss() - print all thread stacks"); 705 tty->print_cr(" pm(int pc) - print Method* given compiled PC"); 706 tty->print_cr(" findm(intptr_t pc) - finds Method*"); 707 tty->print_cr(" find(intptr_t x) - finds & prints nmethod/stub/bytecode/oop based on pointer into it"); 708 tty->print_cr(" pns(void* sp, void* fp, void* pc) - print native (i.e. mixed) stack trace. E.g."); 709 tty->print_cr(" pns($sp, $rbp, $pc) on Linux/amd64 and Solaris/amd64 or"); 710 tty->print_cr(" pns($sp, $ebp, $pc) on Linux/x86 or"); 711 tty->print_cr(" pns($sp, 0, $pc) on Linux/ppc64 or"); 712 tty->print_cr(" pns($sp + 0x7ff, 0, $pc) on Solaris/SPARC"); 713 tty->print_cr(" - in gdb do 'set overload-resolution off' before calling pns()"); 714 tty->print_cr(" - in dbx do 'frame 1' before calling pns()"); 715 716 tty->print_cr("misc."); 717 tty->print_cr(" flush() - flushes the log file"); 718 tty->print_cr(" events() - dump events from ring buffers"); 719 720 721 tty->print_cr("compiler debugging"); 722 tty->print_cr(" debug() - to set things up for compiler debugging"); 723 tty->print_cr(" ndebug() - undo debug"); 724 } 725 726 #endif // !PRODUCT 727 728 void print_native_stack(outputStream* st, frame fr, Thread* t, char* buf, int buf_size) { 729 730 // see if it's a valid frame 731 if (fr.pc()) { 732 st->print_cr("Native frames: (J=compiled Java code, j=interpreted, Vv=VM code, C=native code)"); 733 734 int count = 0; 735 while (count++ < StackPrintLimit) { 736 fr.print_on_error(st, buf, buf_size); 737 st->cr(); 738 // Compiled code may use EBP register on x86 so it looks like 739 // non-walkable C frame. Use frame.sender() for java frames. 740 if (t && t->is_Java_thread()) { 741 // Catch very first native frame by using stack address. 742 // For JavaThread stack_base and stack_size should be set. 743 if (!t->on_local_stack((address)(fr.real_fp() + 1))) { 744 break; 745 } 746 if (fr.is_java_frame() || fr.is_native_frame() || fr.is_runtime_frame()) { 747 RegisterMap map((JavaThread*)t, false); // No update 748 fr = fr.sender(&map); 749 } else { 750 fr = os::get_sender_for_C_frame(&fr); 751 } 752 } else { 753 // is_first_C_frame() does only simple checks for frame pointer, 754 // it will pass if java compiled code has a pointer in EBP. 755 if (os::is_first_C_frame(&fr)) break; 756 fr = os::get_sender_for_C_frame(&fr); 757 } 758 } 759 760 if (count > StackPrintLimit) { 761 st->print_cr("...<more frames>..."); 762 } 763 764 st->cr(); 765 } 766 } 767 768 #ifndef PRODUCT 769 770 extern "C" void pns(void* sp, void* fp, void* pc) { // print native stack 771 Command c("pns"); 772 static char buf[O_BUFLEN]; 773 Thread* t = ThreadLocalStorage::get_thread_slow(); 774 // Call generic frame constructor (certain arguments may be ignored) 775 frame fr(sp, fp, pc); 776 print_native_stack(tty, fr, t, buf, sizeof(buf)); 777 } 778 779 #endif // !PRODUCT