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(&reg_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, &reg_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