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