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