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 
  81 PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
  82 
  83 FormatBufferResource::FormatBufferResource(const char * format, ...)
  84   : FormatBufferBase((char*)resource_allocate_bytes(BUFSZ)) {
  85   va_list argp;
  86   va_start(argp, format);
  87   jio_vsnprintf(_buf, BUFSZ, 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()) {
 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(ThreadLocalStorage::get_thread_slow(), file, line, error_msg, detail_fmt, detail_args);
 221   va_end(detail_args);
 222 }
 223 
 224 void 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 
 233 void 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 
 246 void report_should_not_call(const char* file, int line) {
 247   report_vm_error(file, line, "ShouldNotCall()");
 248 }
 249 
 250 void report_should_not_reach_here(const char* file, int line) {
 251   report_vm_error(file, line, "ShouldNotReachHere()");
 252 }
 253 
 254 void report_unimplemented(const char* file, int line) {
 255   report_vm_error(file, line, "Unimplemented()");
 256 }
 257 
 258 void 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 
 264 void 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 
 285 void 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 
 293 void 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 
 313 static bool error_reported = false;
 314 
 315 // call this when the VM is dying--it might loosen some asserts
 316 void set_error_reported() {
 317   error_reported = true;
 318 }
 319 
 320 bool is_error_reported() {
 321     return error_reported;
 322 }
 323 
 324 #ifndef PRODUCT
 325 #include <signal.h>
 326 
 327 typedef void (*voidfun_t)();
 328 // Crash with an authentic sigfpe
 329 static 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.
 341 static 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
 350 void* get_segfault_address() {
 351   return (void*)
 352 #ifdef _LP64
 353     0xABC0000000000ABCULL;
 354 #else
 355     0x00000ABC;
 356 #endif
 357 }
 358 
 359 void test_error_handler() {
 360   controlled_crash(ErrorHandlerTest);
 361 }
 362 
 363 void 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 
 418 class 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 
 441 int Command::level = 0;
 442 
 443 #ifndef PRODUCT
 444 
 445 extern "C" void blob(CodeBlob* cb) {
 446   Command c("blob");
 447   cb->print();
 448 }
 449 
 450 
 451 extern "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 
 458 extern "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 
 470 extern "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 
 484 extern "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 
 496 extern "C" void universe() {
 497   Command c("universe");
 498   Universe::print();
 499 }
 500 
 501 
 502 extern "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 
 519 extern "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
 533 extern "C" void pa(intptr_t p)   { ((AllocatedObj*) p)->print(); }
 534 extern "C" void findpc(intptr_t x);
 535 
 536 #endif // !PRODUCT
 537 
 538 extern "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(&reg_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, &reg_map, p));
 564   pd_ps(f);
 565 #endif // PRODUCT
 566   }
 567 
 568 }
 569 
 570 extern "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 
 584 extern "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 
 598 extern "C" void threads() {
 599   Command c("threads");
 600   Threads::print(false, true);
 601 }
 602 
 603 
 604 extern "C" void psd() {
 605   Command c("psd");
 606   SystemDictionary::print();
 607 }
 608 
 609 
 610 extern "C" void safepoints() {
 611   Command c("safepoints");
 612   SafepointSynchronize::print_state();
 613 }
 614 
 615 #endif // !PRODUCT
 616 
 617 extern "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 
 625 extern "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 
 634 extern "C" void ndebug() {              // undo debug()
 635   Command c("ndebug");
 636   PrintCompilation = false;
 637   PrintInlining = PrintAssembly = false;
 638   tty->flush();
 639 }
 640 
 641 
 642 extern "C" void flush()  {
 643   Command c("flush");
 644   tty->flush();
 645 }
 646 
 647 extern "C" void events() {
 648   Command c("events");
 649   Events::print();
 650 }
 651 
 652 extern "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 
 659 extern "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?
 666 extern "C" void hsfind(intptr_t x) {
 667   Command c("hsfind");
 668   os::print_location(tty, x, false);
 669 }
 670 
 671 
 672 extern "C" void find(intptr_t x) {
 673   Command c("find");
 674   os::print_location(tty, x, false);
 675 }
 676 
 677 
 678 extern "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.
 685 extern "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 
 697 void pp(intptr_t p)          { pp((void*)p); }
 698 void pp(oop p)               { pp((void*)p); }
 699 
 700 void 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 
 730 void 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 
 772 extern "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
 789 STATIC_ASSERT(true);
 790 STATIC_ASSERT(true);
 791 STATIC_ASSERT(1 == 1);
 792 STATIC_ASSERT(0 == 0);
 793 
 794 void 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
 802 struct TestMultipleStaticAssertFormsInClassScope {
 803   STATIC_ASSERT(true);
 804   STATIC_ASSERT(true);
 805   STATIC_ASSERT(0 == 0);
 806   STATIC_ASSERT(1 == 1);
 807 };
 808 
 809 #endif // !PRODUCT