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