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