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