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