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