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