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