rev 47445 : 8171853: Remove Shark compiler

   1 /*
   2  * Copyright (c) 2003, 2017, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #include "precompiled.hpp"
  26 #include "code/codeCache.hpp"
  27 #include "compiler/compileBroker.hpp"
  28 #include "compiler/disassembler.hpp"
  29 #include "gc/shared/collectedHeap.hpp"
  30 #include "logging/logConfiguration.hpp"
  31 #include "prims/jvm.h"
  32 #include "prims/whitebox.hpp"
  33 #include "runtime/arguments.hpp"
  34 #include "runtime/atomic.hpp"
  35 #include "runtime/frame.inline.hpp"
  36 #include "runtime/init.hpp"
  37 #include "runtime/os.hpp"
  38 #include "runtime/thread.inline.hpp"
  39 #include "runtime/vmThread.hpp"
  40 #include "runtime/vm_operations.hpp"
  41 #include "runtime/vm_version.hpp"
  42 #include "services/memTracker.hpp"
  43 #include "trace/traceMacros.hpp"
  44 #include "utilities/debug.hpp"
  45 #include "utilities/decoder.hpp"
  46 #include "utilities/defaultStream.hpp"
  47 #include "utilities/errorReporter.hpp"
  48 #include "utilities/events.hpp"
  49 #include "utilities/vmError.hpp"
  50 
  51 #ifndef PRODUCT
  52 #include <signal.h>
  53 #endif // PRODUCT
  54 
  55 bool VMError::_error_reported = false;
  56 
  57 // call this when the VM is dying--it might loosen some asserts
  58 bool VMError::is_error_reported() { return _error_reported; }
  59 
  60 // returns an address which is guaranteed to generate a SIGSEGV on read,
  61 // for test purposes, which is not NULL and contains bits in every word
  62 void* VMError::get_segfault_address() {
  63   return (void*)
  64 #ifdef _LP64
  65     0xABC0000000000ABCULL;
  66 #else
  67     0x00000ABC;
  68 #endif
  69 }
  70 
  71 // List of environment variables that should be reported in error log file.
  72 const char *env_list[] = {
  73   // All platforms
  74   "JAVA_HOME", "JRE_HOME", "JAVA_TOOL_OPTIONS", "_JAVA_OPTIONS", "CLASSPATH",
  75   "JAVA_COMPILER", "PATH", "USERNAME",
  76 
  77   // Env variables that are defined on Solaris/Linux/BSD
  78   "LD_LIBRARY_PATH", "LD_PRELOAD", "SHELL", "DISPLAY",
  79   "HOSTTYPE", "OSTYPE", "ARCH", "MACHTYPE",
  80 
  81   // defined on Linux
  82   "LD_ASSUME_KERNEL", "_JAVA_SR_SIGNUM",
  83 
  84   // defined on Darwin
  85   "DYLD_LIBRARY_PATH", "DYLD_FALLBACK_LIBRARY_PATH",
  86   "DYLD_FRAMEWORK_PATH", "DYLD_FALLBACK_FRAMEWORK_PATH",
  87   "DYLD_INSERT_LIBRARIES",
  88 
  89   // defined on Windows
  90   "OS", "PROCESSOR_IDENTIFIER", "_ALT_JAVA_HOME_DIR",
  91 
  92   (const char *)0
  93 };
  94 
  95 // A simple parser for -XX:OnError, usage:
  96 //  ptr = OnError;
  97 //  while ((cmd = next_OnError_command(buffer, sizeof(buffer), &ptr) != NULL)
  98 //     ... ...
  99 static char* next_OnError_command(char* buf, int buflen, const char** ptr) {
 100   if (ptr == NULL || *ptr == NULL) return NULL;
 101 
 102   const char* cmd = *ptr;
 103 
 104   // skip leading blanks or ';'
 105   while (*cmd == ' ' || *cmd == ';') cmd++;
 106 
 107   if (*cmd == '\0') return NULL;
 108 
 109   const char * cmdend = cmd;
 110   while (*cmdend != '\0' && *cmdend != ';') cmdend++;
 111 
 112   Arguments::copy_expand_pid(cmd, cmdend - cmd, buf, buflen);
 113 
 114   *ptr = (*cmdend == '\0' ? cmdend : cmdend + 1);
 115   return buf;
 116 }
 117 
 118 static void print_bug_submit_message(outputStream *out, Thread *thread) {
 119   if (out == NULL) return;
 120   out->print_raw_cr("# If you would like to submit a bug report, please visit:");
 121   out->print_raw   ("#   ");
 122   out->print_raw_cr(Arguments::java_vendor_url_bug());
 123   // If the crash is in native code, encourage user to submit a bug to the
 124   // provider of that code.
 125   if (thread && thread->is_Java_thread() &&
 126       !thread->is_hidden_from_external_view()) {
 127     JavaThread* jt = (JavaThread*)thread;
 128     if (jt->thread_state() == _thread_in_native) {
 129       out->print_cr("# The crash happened outside the Java Virtual Machine in native code.\n# See problematic frame for where to report the bug.");
 130     }
 131   }
 132   out->print_raw_cr("#");
 133 }
 134 
 135 bool VMError::coredump_status;
 136 char VMError::coredump_message[O_BUFLEN];
 137 
 138 void VMError::record_coredump_status(const char* message, bool status) {
 139   coredump_status = status;
 140   strncpy(coredump_message, message, sizeof(coredump_message));
 141   coredump_message[sizeof(coredump_message)-1] = 0;
 142 }
 143 
 144 // Return a string to describe the error
 145 char* VMError::error_string(char* buf, int buflen) {
 146   char signame_buf[64];
 147   const char *signame = os::exception_name(_id, signame_buf, sizeof(signame_buf));
 148 
 149   if (signame) {
 150     jio_snprintf(buf, buflen,
 151                  "%s (0x%x) at pc=" PTR_FORMAT ", pid=%d, tid=" UINTX_FORMAT,
 152                  signame, _id, _pc,
 153                  os::current_process_id(), os::current_thread_id());
 154   } else if (_filename != NULL && _lineno > 0) {
 155     // skip directory names
 156     char separator = os::file_separator()[0];
 157     const char *p = strrchr(_filename, separator);
 158     int n = jio_snprintf(buf, buflen,
 159                          "Internal Error at %s:%d, pid=%d, tid=" UINTX_FORMAT,
 160                          p ? p + 1 : _filename, _lineno,
 161                          os::current_process_id(), os::current_thread_id());
 162     if (n >= 0 && n < buflen && _message) {
 163       if (strlen(_detail_msg) > 0) {
 164         jio_snprintf(buf + n, buflen - n, "%s%s: %s",
 165         os::line_separator(), _message, _detail_msg);
 166       } else {
 167         jio_snprintf(buf + n, buflen - n, "%sError: %s",
 168                      os::line_separator(), _message);
 169       }
 170     }
 171   } else {
 172     jio_snprintf(buf, buflen,
 173                  "Internal Error (0x%x), pid=%d, tid=" UINTX_FORMAT,
 174                  _id, os::current_process_id(), os::current_thread_id());
 175   }
 176 
 177   return buf;
 178 }
 179 
 180 void VMError::print_stack_trace(outputStream* st, JavaThread* jt,
 181                                 char* buf, int buflen, bool verbose) {
 182 #ifdef ZERO
 183   if (jt->zero_stack()->sp() && jt->top_zero_frame()) {
 184     // StackFrameStream uses the frame anchor, which may not have
 185     // been set up.  This can be done at any time in Zero, however,
 186     // so if it hasn't been set up then we just set it up now and
 187     // clear it again when we're done.
 188     bool has_last_Java_frame = jt->has_last_Java_frame();
 189     if (!has_last_Java_frame)
 190       jt->set_last_Java_frame();
 191     st->print("Java frames:");











 192     st->cr();
 193 
 194     // Print the frames
 195     StackFrameStream sfs(jt);
 196     for(int i = 0; !sfs.is_done(); sfs.next(), i++) {
 197       sfs.current()->zero_print_on_error(i, st, buf, buflen);
 198       st->cr();
 199     }
 200 
 201     // Reset the frame anchor if necessary
 202     if (!has_last_Java_frame)
 203       jt->reset_last_Java_frame();
 204   }
 205 #else
 206   if (jt->has_last_Java_frame()) {
 207     st->print_cr("Java frames: (J=compiled Java code, j=interpreted, Vv=VM code)");
 208     for(StackFrameStream sfs(jt); !sfs.is_done(); sfs.next()) {
 209       sfs.current()->print_on_error(st, buf, buflen, verbose);
 210       st->cr();
 211     }
 212   }
 213 #endif // ZERO
 214 }
 215 
 216 void VMError::print_native_stack(outputStream* st, frame fr, Thread* t, char* buf, int buf_size) {
 217 
 218   // see if it's a valid frame
 219   if (fr.pc()) {
 220     st->print_cr("Native frames: (J=compiled Java code, A=aot compiled Java code, j=interpreted, Vv=VM code, C=native code)");
 221 
 222     int count = 0;
 223     while (count++ < StackPrintLimit) {
 224       fr.print_on_error(st, buf, buf_size);
 225       st->cr();
 226       // Compiled code may use EBP register on x86 so it looks like
 227       // non-walkable C frame. Use frame.sender() for java frames.
 228       if (t && t->is_Java_thread()) {
 229         // Catch very first native frame by using stack address.
 230         // For JavaThread stack_base and stack_size should be set.
 231         if (!t->on_local_stack((address)(fr.real_fp() + 1))) {
 232           break;
 233         }
 234         if (fr.is_java_frame() || fr.is_native_frame() || fr.is_runtime_frame()) {
 235           RegisterMap map((JavaThread*)t, false); // No update
 236           fr = fr.sender(&map);
 237         } else {
 238           fr = os::get_sender_for_C_frame(&fr);
 239         }
 240       } else {
 241         // is_first_C_frame() does only simple checks for frame pointer,
 242         // it will pass if java compiled code has a pointer in EBP.
 243         if (os::is_first_C_frame(&fr)) break;
 244         fr = os::get_sender_for_C_frame(&fr);
 245       }
 246     }
 247 
 248     if (count > StackPrintLimit) {
 249       st->print_cr("...<more frames>...");
 250     }
 251 
 252     st->cr();
 253   }
 254 }
 255 
 256 static void print_oom_reasons(outputStream* st) {
 257   st->print_cr("# Possible reasons:");
 258   st->print_cr("#   The system is out of physical RAM or swap space");
 259   if (UseCompressedOops) {
 260     st->print_cr("#   The process is running with CompressedOops enabled, and the Java Heap may be blocking the growth of the native heap");
 261   }
 262   if (LogBytesPerWord == 2) {
 263     st->print_cr("#   In 32 bit mode, the process size limit was hit");
 264   }
 265   st->print_cr("# Possible solutions:");
 266   st->print_cr("#   Reduce memory load on the system");
 267   st->print_cr("#   Increase physical memory or swap space");
 268   st->print_cr("#   Check if swap backing store is full");
 269   if (LogBytesPerWord == 2) {
 270     st->print_cr("#   Use 64 bit Java on a 64 bit OS");
 271   }
 272   st->print_cr("#   Decrease Java heap size (-Xmx/-Xms)");
 273   st->print_cr("#   Decrease number of Java threads");
 274   st->print_cr("#   Decrease Java thread stack sizes (-Xss)");
 275   st->print_cr("#   Set larger code cache with -XX:ReservedCodeCacheSize=");
 276   if (UseCompressedOops) {
 277     switch (Universe::narrow_oop_mode()) {
 278       case Universe::UnscaledNarrowOop:
 279         st->print_cr("#   JVM is running with Unscaled Compressed Oops mode in which the Java heap is");
 280         st->print_cr("#     placed in the first 4GB address space. The Java Heap base address is the");
 281         st->print_cr("#     maximum limit for the native heap growth. Please use -XX:HeapBaseMinAddress");
 282         st->print_cr("#     to set the Java Heap base and to place the Java Heap above 4GB virtual address.");
 283         break;
 284       case Universe::ZeroBasedNarrowOop:
 285         st->print_cr("#   JVM is running with Zero Based Compressed Oops mode in which the Java heap is");
 286         st->print_cr("#     placed in the first 32GB address space. The Java Heap base address is the");
 287         st->print_cr("#     maximum limit for the native heap growth. Please use -XX:HeapBaseMinAddress");
 288         st->print_cr("#     to set the Java Heap base and to place the Java Heap above 32GB virtual address.");
 289         break;
 290       default:
 291         break;
 292     }
 293   }
 294   st->print_cr("# This output file may be truncated or incomplete.");
 295 }
 296 
 297 static const char* gc_mode() {
 298   if (UseG1GC)            return "g1 gc";
 299   if (UseParallelGC)      return "parallel gc";
 300   if (UseConcMarkSweepGC) return "concurrent mark sweep gc";
 301   if (UseSerialGC)        return "serial gc";
 302   return "ERROR in GC mode";
 303 }
 304 
 305 static void report_vm_version(outputStream* st, char* buf, int buflen) {
 306    // VM version
 307    st->print_cr("#");
 308    JDK_Version::current().to_string(buf, buflen);
 309    const char* runtime_name = JDK_Version::runtime_name() != NULL ?
 310                                 JDK_Version::runtime_name() : "";
 311    const char* runtime_version = JDK_Version::runtime_version() != NULL ?
 312                                    JDK_Version::runtime_version() : "";
 313    const char* jdk_debug_level = Abstract_VM_Version::printable_jdk_debug_level() != NULL ?
 314                                    Abstract_VM_Version::printable_jdk_debug_level() : "";
 315 
 316    st->print_cr("# JRE version: %s (%s) (%sbuild %s)", runtime_name, buf,
 317                  jdk_debug_level, runtime_version);
 318 
 319    // This is the long version with some default settings added
 320    st->print_cr("# Java VM: %s (%s%s, %s%s%s%s%s, %s, %s)",
 321                  Abstract_VM_Version::vm_name(),
 322                  jdk_debug_level,
 323                  Abstract_VM_Version::vm_release(),
 324                  Abstract_VM_Version::vm_info_string(),
 325                  TieredCompilation ? ", tiered" : "",
 326 #if INCLUDE_JVMCI
 327                  EnableJVMCI ? ", jvmci" : "",
 328                  UseJVMCICompiler ? ", jvmci compiler" : "",
 329 #else
 330                  "", "",
 331 #endif
 332                  UseCompressedOops ? ", compressed oops" : "",
 333                  gc_mode(),
 334                  Abstract_VM_Version::vm_platform_string()
 335                );
 336 }
 337 
 338 // This is the main function to report a fatal error. Only one thread can
 339 // call this function, so we don't need to worry about MT-safety. But it's
 340 // possible that the error handler itself may crash or die on an internal
 341 // error, for example, when the stack/heap is badly damaged. We must be
 342 // able to handle recursive errors that happen inside error handler.
 343 //
 344 // Error reporting is done in several steps. If a crash or internal error
 345 // occurred when reporting an error, the nested signal/exception handler
 346 // can skip steps that are already (or partially) done. Error reporting will
 347 // continue from the next step. This allows us to retrieve and print
 348 // information that may be unsafe to get after a fatal error. If it happens,
 349 // you may find nested report_and_die() frames when you look at the stack
 350 // in a debugger.
 351 //
 352 // In general, a hang in error handler is much worse than a crash or internal
 353 // error, as it's harder to recover from a hang. Deadlock can happen if we
 354 // try to grab a lock that is already owned by current thread, or if the
 355 // owner is blocked forever (e.g. in os::infinite_sleep()). If possible, the
 356 // error handler and all the functions it called should avoid grabbing any
 357 // lock. An important thing to notice is that memory allocation needs a lock.
 358 //
 359 // We should avoid using large stack allocated buffers. Many errors happen
 360 // when stack space is already low. Making things even worse is that there
 361 // could be nested report_and_die() calls on stack (see above). Only one
 362 // thread can report error, so large buffers are statically allocated in data
 363 // segment.
 364 
 365 int          VMError::_current_step;
 366 const char*  VMError::_current_step_info;
 367 
 368 volatile jlong VMError::_reporting_start_time = -1;
 369 volatile bool VMError::_reporting_did_timeout = false;
 370 volatile jlong VMError::_step_start_time = -1;
 371 volatile bool VMError::_step_did_timeout = false;
 372 
 373 // Helper, return current timestamp for timeout handling.
 374 jlong VMError::get_current_timestamp() {
 375   return os::javaTimeNanos();
 376 }
 377 // Factor to translate the timestamp to seconds.
 378 #define TIMESTAMP_TO_SECONDS_FACTOR (1000 * 1000 * 1000)
 379 
 380 void VMError::record_reporting_start_time() {
 381   const jlong now = get_current_timestamp();
 382   Atomic::store(now, &_reporting_start_time);
 383 }
 384 
 385 jlong VMError::get_reporting_start_time() {
 386   return Atomic::load(&_reporting_start_time);
 387 }
 388 
 389 void VMError::record_step_start_time() {
 390   const jlong now = get_current_timestamp();
 391   Atomic::store(now, &_step_start_time);
 392 }
 393 
 394 jlong VMError::get_step_start_time() {
 395   return Atomic::load(&_step_start_time);
 396 }
 397 
 398 void VMError::report(outputStream* st, bool _verbose) {
 399 
 400 # define BEGIN if (_current_step == 0) { _current_step = __LINE__;
 401 # define STEP(s) } if (_current_step < __LINE__) { _current_step = __LINE__; _current_step_info = s; \
 402   record_step_start_time(); _step_did_timeout = false;
 403 # define END }
 404 
 405   // don't allocate large buffer on stack
 406   static char buf[O_BUFLEN];
 407 
 408   BEGIN
 409 
 410   STEP("printing fatal error message")
 411 
 412     st->print_cr("#");
 413     if (should_report_bug(_id)) {
 414       st->print_cr("# A fatal error has been detected by the Java Runtime Environment:");
 415     } else {
 416       st->print_cr("# There is insufficient memory for the Java "
 417                    "Runtime Environment to continue.");
 418     }
 419 
 420 #ifndef PRODUCT
 421   // Error handler self tests
 422 
 423   // test secondary error handling. Test it twice, to test that resetting
 424   // error handler after a secondary crash works.
 425   STEP("test secondary crash 1")
 426     if (_verbose && TestCrashInErrorHandler != 0) {
 427       st->print_cr("Will crash now (TestCrashInErrorHandler=" UINTX_FORMAT ")...",
 428         TestCrashInErrorHandler);
 429       controlled_crash(TestCrashInErrorHandler);
 430     }
 431 
 432   STEP("test secondary crash 2")
 433     if (_verbose && TestCrashInErrorHandler != 0) {
 434       st->print_cr("Will crash now (TestCrashInErrorHandler=" UINTX_FORMAT ")...",
 435         TestCrashInErrorHandler);
 436       controlled_crash(TestCrashInErrorHandler);
 437     }
 438 
 439   // TestUnresponsiveErrorHandler: We want to test both step timeouts and global timeout.
 440   // Step to global timeout ratio is 4:1, so in order to be absolutely sure we hit the
 441   // global timeout, let's execute the timeout step five times.
 442   // See corresponding test in test/runtime/ErrorHandling/TimeoutInErrorHandlingTest.java
 443   #define TIMEOUT_TEST_STEP STEP("test unresponsive error reporting step") \
 444     if (_verbose && TestUnresponsiveErrorHandler) { os::infinite_sleep(); }
 445   TIMEOUT_TEST_STEP
 446   TIMEOUT_TEST_STEP
 447   TIMEOUT_TEST_STEP
 448   TIMEOUT_TEST_STEP
 449   TIMEOUT_TEST_STEP
 450 
 451   STEP("test safefetch in error handler")
 452     // test whether it is safe to use SafeFetch32 in Crash Handler. Test twice
 453     // to test that resetting the signal handler works correctly.
 454     if (_verbose && TestSafeFetchInErrorHandler) {
 455       st->print_cr("Will test SafeFetch...");
 456       if (CanUseSafeFetch32()) {
 457         int* const invalid_pointer = (int*) get_segfault_address();
 458         const int x = 0x76543210;
 459         int i1 = SafeFetch32(invalid_pointer, x);
 460         int i2 = SafeFetch32(invalid_pointer, x);
 461         if (i1 == x && i2 == x) {
 462           st->print_cr("SafeFetch OK."); // Correctly deflected and returned default pattern
 463         } else {
 464           st->print_cr("??");
 465         }
 466       } else {
 467         st->print_cr("not possible; skipped.");
 468       }
 469     }
 470 #endif // PRODUCT
 471 
 472   STEP("printing type of error")
 473 
 474      switch(_id) {
 475        case OOM_MALLOC_ERROR:
 476        case OOM_MMAP_ERROR:
 477          if (_size) {
 478            st->print("# Native memory allocation ");
 479            st->print((_id == (int)OOM_MALLOC_ERROR) ? "(malloc) failed to allocate " :
 480                                                  "(mmap) failed to map ");
 481            jio_snprintf(buf, sizeof(buf), SIZE_FORMAT, _size);
 482            st->print("%s", buf);
 483            st->print(" bytes");
 484            if (strlen(_detail_msg) > 0) {
 485              st->print(" for ");
 486              st->print("%s", _detail_msg);
 487            }
 488            st->cr();
 489          } else {
 490            if (strlen(_detail_msg) > 0) {
 491              st->print("# ");
 492              st->print_cr("%s", _detail_msg);
 493            }
 494          }
 495          // In error file give some solutions
 496          if (_verbose) {
 497            print_oom_reasons(st);
 498          } else {
 499            return;  // that's enough for the screen
 500          }
 501          break;
 502        case INTERNAL_ERROR:
 503        default:
 504          break;
 505      }
 506 
 507   STEP("printing exception/signal name")
 508 
 509      st->print_cr("#");
 510      st->print("#  ");
 511      // Is it an OS exception/signal?
 512      if (os::exception_name(_id, buf, sizeof(buf))) {
 513        st->print("%s", buf);
 514        st->print(" (0x%x)", _id);                // signal number
 515        st->print(" at pc=" PTR_FORMAT, p2i(_pc));
 516      } else {
 517        if (should_report_bug(_id)) {
 518          st->print("Internal Error");
 519        } else {
 520          st->print("Out of Memory Error");
 521        }
 522        if (_filename != NULL && _lineno > 0) {
 523 #ifdef PRODUCT
 524          // In product mode chop off pathname?
 525          char separator = os::file_separator()[0];
 526          const char *p = strrchr(_filename, separator);
 527          const char *file = p ? p+1 : _filename;
 528 #else
 529          const char *file = _filename;
 530 #endif
 531          st->print(" (%s:%d)", file, _lineno);
 532        } else {
 533          st->print(" (0x%x)", _id);
 534        }
 535      }
 536 
 537   STEP("printing current thread and pid")
 538 
 539      // process id, thread id
 540      st->print(", pid=%d", os::current_process_id());
 541      st->print(", tid=" UINTX_FORMAT, os::current_thread_id());
 542      st->cr();
 543 
 544   STEP("printing error message")
 545 
 546      if (should_report_bug(_id)) {  // already printed the message.
 547        // error message
 548        if (strlen(_detail_msg) > 0) {
 549          st->print_cr("#  %s: %s", _message ? _message : "Error", _detail_msg);
 550        } else if (_message) {
 551          st->print_cr("#  Error: %s", _message);
 552        }
 553      }
 554 
 555   STEP("printing Java version string")
 556 
 557      report_vm_version(st, buf, sizeof(buf));
 558 
 559   STEP("printing problematic frame")
 560 
 561      // Print current frame if we have a context (i.e. it's a crash)
 562      if (_context) {
 563        st->print_cr("# Problematic frame:");
 564        st->print("# ");
 565        frame fr = os::fetch_frame_from_context(_context);
 566        fr.print_on_error(st, buf, sizeof(buf));
 567        st->cr();
 568        st->print_cr("#");
 569      }
 570 
 571   STEP("printing core file information")
 572     st->print("# ");
 573     if (CreateCoredumpOnCrash) {
 574       if (coredump_status) {
 575         st->print("Core dump will be written. Default location: %s", coredump_message);
 576       } else {
 577         st->print("No core dump will be written. %s", coredump_message);
 578       }
 579     } else {
 580       st->print("CreateCoredumpOnCrash turned off, no core file dumped");
 581     }
 582     st->cr();
 583     st->print_cr("#");
 584 
 585   STEP("printing bug submit message")
 586 
 587      if (should_report_bug(_id) && _verbose) {
 588        print_bug_submit_message(st, _thread);
 589      }
 590 
 591   STEP("printing summary")
 592 
 593      if (_verbose) {
 594        st->cr();
 595        st->print_cr("---------------  S U M M A R Y ------------");
 596        st->cr();
 597      }
 598 
 599   STEP("printing VM option summary")
 600 
 601      if (_verbose) {
 602        // VM options
 603        Arguments::print_summary_on(st);
 604        st->cr();
 605      }
 606 
 607   STEP("printing summary machine and OS info")
 608 
 609      if (_verbose) {
 610        os::print_summary_info(st, buf, sizeof(buf));
 611      }
 612 
 613 
 614   STEP("printing date and time")
 615 
 616      if (_verbose) {
 617        os::print_date_and_time(st, buf, sizeof(buf));
 618      }
 619 
 620   STEP("printing thread")
 621 
 622      if (_verbose) {
 623        st->cr();
 624        st->print_cr("---------------  T H R E A D  ---------------");
 625        st->cr();
 626      }
 627 
 628   STEP("printing current thread")
 629 
 630      // current thread
 631      if (_verbose) {
 632        if (_thread) {
 633          st->print("Current thread (" PTR_FORMAT "):  ", p2i(_thread));
 634          _thread->print_on_error(st, buf, sizeof(buf));
 635          st->cr();
 636        } else {
 637          st->print_cr("Current thread is native thread");
 638        }
 639        st->cr();
 640      }
 641 
 642   STEP("printing current compile task")
 643 
 644      if (_verbose && _thread && _thread->is_Compiler_thread()) {
 645         CompilerThread* t = (CompilerThread*)_thread;
 646         if (t->task()) {
 647            st->cr();
 648            st->print_cr("Current CompileTask:");
 649            t->task()->print_line_on_error(st, buf, sizeof(buf));
 650            st->cr();
 651         }
 652      }
 653 
 654 
 655   STEP("printing stack bounds")
 656 
 657      if (_verbose) {
 658        st->print("Stack: ");
 659 
 660        address stack_top;
 661        size_t stack_size;
 662 
 663        if (_thread) {
 664           stack_top = _thread->stack_base();
 665           stack_size = _thread->stack_size();
 666        } else {
 667           stack_top = os::current_stack_base();
 668           stack_size = os::current_stack_size();
 669        }
 670 
 671        address stack_bottom = stack_top - stack_size;
 672        st->print("[" PTR_FORMAT "," PTR_FORMAT "]", p2i(stack_bottom), p2i(stack_top));
 673 
 674        frame fr = _context ? os::fetch_frame_from_context(_context)
 675                            : os::current_frame();
 676 
 677        if (fr.sp()) {
 678          st->print(",  sp=" PTR_FORMAT, p2i(fr.sp()));
 679          size_t free_stack_size = pointer_delta(fr.sp(), stack_bottom, 1024);
 680          st->print(",  free space=" SIZE_FORMAT "k", free_stack_size);
 681        }
 682 
 683        st->cr();
 684      }
 685 
 686   STEP("printing native stack")
 687 
 688    if (_verbose) {
 689      if (os::platform_print_native_stack(st, _context, buf, sizeof(buf))) {
 690        // We have printed the native stack in platform-specific code
 691        // Windows/x64 needs special handling.
 692      } else {
 693        frame fr = _context ? os::fetch_frame_from_context(_context)
 694                            : os::current_frame();
 695 
 696        print_native_stack(st, fr, _thread, buf, sizeof(buf));
 697      }
 698    }
 699 
 700   STEP("printing Java stack")
 701 
 702      if (_verbose && _thread && _thread->is_Java_thread()) {
 703        print_stack_trace(st, (JavaThread*)_thread, buf, sizeof(buf));
 704      }
 705 
 706   STEP("printing target Java thread stack")
 707 
 708      // printing Java thread stack trace if it is involved in GC crash
 709      if (_verbose && _thread && (_thread->is_Named_thread())) {
 710        JavaThread*  jt = ((NamedThread *)_thread)->processed_thread();
 711        if (jt != NULL) {
 712          st->print_cr("JavaThread " PTR_FORMAT " (nid = %d) was being processed", p2i(jt), jt->osthread()->thread_id());
 713          print_stack_trace(st, jt, buf, sizeof(buf), true);
 714        }
 715      }
 716 
 717   STEP("printing siginfo")
 718 
 719      // signal no, signal code, address that caused the fault
 720      if (_verbose && _siginfo) {
 721        st->cr();
 722        os::print_siginfo(st, _siginfo);
 723        st->cr();
 724      }
 725 
 726   STEP("CDS archive access warning")
 727 
 728      // Print an explicit hint if we crashed on access to the CDS archive.
 729      if (_verbose && _siginfo) {
 730        check_failing_cds_access(st, _siginfo);
 731        st->cr();
 732      }
 733 
 734   STEP("printing register info")
 735 
 736      // decode register contents if possible
 737      if (_verbose && _context && Universe::is_fully_initialized()) {
 738        os::print_register_info(st, _context);
 739        st->cr();
 740      }
 741 
 742   STEP("printing registers, top of stack, instructions near pc")
 743 
 744      // registers, top of stack, instructions near pc
 745      if (_verbose && _context) {
 746        os::print_context(st, _context);
 747        st->cr();
 748      }
 749 
 750   STEP("printing code blob if possible")
 751 
 752      if (_verbose && _context) {
 753        CodeBlob* cb = CodeCache::find_blob(_pc);
 754        if (cb != NULL) {
 755          if (Interpreter::contains(_pc)) {
 756            // The interpreter CodeBlob is very large so try to print the codelet instead.
 757            InterpreterCodelet* codelet = Interpreter::codelet_containing(_pc);
 758            if (codelet != NULL) {
 759              codelet->print_on(st);
 760              Disassembler::decode(codelet->code_begin(), codelet->code_end(), st);
 761            }
 762          } else {
 763            StubCodeDesc* desc = StubCodeDesc::desc_for(_pc);
 764            if (desc != NULL) {
 765              desc->print_on(st);
 766              Disassembler::decode(desc->begin(), desc->end(), st);
 767            } else {
 768              Disassembler::decode(cb, st);
 769              st->cr();
 770            }
 771          }
 772        }
 773      }
 774 
 775   STEP("printing VM operation")
 776 
 777      if (_verbose && _thread && _thread->is_VM_thread()) {
 778         VMThread* t = (VMThread*)_thread;
 779         VM_Operation* op = t->vm_operation();
 780         if (op) {
 781           op->print_on_error(st);
 782           st->cr();
 783           st->cr();
 784         }
 785      }
 786 
 787   STEP("printing process")
 788 
 789      if (_verbose) {
 790        st->cr();
 791        st->print_cr("---------------  P R O C E S S  ---------------");
 792        st->cr();
 793      }
 794 
 795   STEP("printing all threads")
 796 
 797      // all threads
 798      if (_verbose && _thread) {
 799        Threads::print_on_error(st, _thread, buf, sizeof(buf));
 800        st->cr();
 801      }
 802 
 803   STEP("printing VM state")
 804 
 805      if (_verbose) {
 806        // Safepoint state
 807        st->print("VM state:");
 808 
 809        if (SafepointSynchronize::is_synchronizing()) st->print("synchronizing");
 810        else if (SafepointSynchronize::is_at_safepoint()) st->print("at safepoint");
 811        else st->print("not at safepoint");
 812 
 813        // Also see if error occurred during initialization or shutdown
 814        if (!Universe::is_fully_initialized()) {
 815          st->print(" (not fully initialized)");
 816        } else if (VM_Exit::vm_exited()) {
 817          st->print(" (shutting down)");
 818        } else {
 819          st->print(" (normal execution)");
 820        }
 821        st->cr();
 822        st->cr();
 823      }
 824 
 825   STEP("printing owned locks on error")
 826 
 827      // mutexes/monitors that currently have an owner
 828      if (_verbose) {
 829        print_owned_locks_on_error(st);
 830        st->cr();
 831      }
 832 
 833   STEP("printing number of OutOfMemoryError and StackOverflow exceptions")
 834 
 835      if (_verbose && Exceptions::has_exception_counts()) {
 836        st->print_cr("OutOfMemory and StackOverflow Exception counts:");
 837        Exceptions::print_exception_counts_on_error(st);
 838        st->cr();
 839      }
 840 
 841   STEP("printing compressed oops mode")
 842 
 843      if (_verbose && UseCompressedOops) {
 844        Universe::print_compressed_oops_mode(st);
 845        if (UseCompressedClassPointers) {
 846          Metaspace::print_compressed_class_space(st);
 847        }
 848        st->cr();
 849      }
 850 
 851   STEP("printing heap information")
 852 
 853      if (_verbose && Universe::is_fully_initialized()) {
 854        Universe::heap()->print_on_error(st);
 855        st->cr();
 856        st->print_cr("Polling page: " INTPTR_FORMAT, p2i(os::get_polling_page()));
 857        st->cr();
 858      }
 859 
 860   STEP("printing code cache information")
 861 
 862      if (_verbose && Universe::is_fully_initialized()) {
 863        // print code cache information before vm abort
 864        CodeCache::print_summary(st);
 865        st->cr();
 866      }
 867 
 868   STEP("printing ring buffers")
 869 
 870      if (_verbose) {
 871        Events::print_all(st);
 872        st->cr();
 873      }
 874 
 875   STEP("printing dynamic libraries")
 876 
 877      if (_verbose) {
 878        // dynamic libraries, or memory map
 879        os::print_dll_info(st);
 880        st->cr();
 881      }
 882 
 883   STEP("printing native decoder state")
 884 
 885      if (_verbose) {
 886        Decoder::print_state_on(st);
 887        st->cr();
 888      }
 889 
 890   STEP("printing VM options")
 891 
 892      if (_verbose) {
 893        // VM options
 894        Arguments::print_on(st);
 895        st->cr();
 896      }
 897 
 898   STEP("printing warning if internal testing API used")
 899 
 900      if (WhiteBox::used()) {
 901        st->print_cr("Unsupported internal testing APIs have been used.");
 902        st->cr();
 903      }
 904 
 905   STEP("printing log configuration")
 906     if (_verbose){
 907       st->print_cr("Logging:");
 908       LogConfiguration::describe_current_configuration(st);
 909       st->cr();
 910     }
 911 
 912   STEP("printing all environment variables")
 913 
 914      if (_verbose) {
 915        os::print_environment_variables(st, env_list);
 916        st->cr();
 917      }
 918 
 919   STEP("printing signal handlers")
 920 
 921      if (_verbose) {
 922        os::print_signal_handlers(st, buf, sizeof(buf));
 923        st->cr();
 924      }
 925 
 926   STEP("Native Memory Tracking")
 927      if (_verbose) {
 928        MemTracker::error_report(st);
 929      }
 930 
 931   STEP("printing system")
 932 
 933      if (_verbose) {
 934        st->cr();
 935        st->print_cr("---------------  S Y S T E M  ---------------");
 936        st->cr();
 937      }
 938 
 939   STEP("printing OS information")
 940 
 941      if (_verbose) {
 942        os::print_os_info(st);
 943        st->cr();
 944      }
 945 
 946   STEP("printing CPU info")
 947      if (_verbose) {
 948        os::print_cpu_info(st, buf, sizeof(buf));
 949        st->cr();
 950      }
 951 
 952   STEP("printing memory info")
 953 
 954      if (_verbose) {
 955        os::print_memory_info(st);
 956        st->cr();
 957      }
 958 
 959   STEP("printing internal vm info")
 960 
 961      if (_verbose) {
 962        st->print_cr("vm_info: %s", Abstract_VM_Version::internal_vm_info_string());
 963        st->cr();
 964      }
 965 
 966   // print a defined marker to show that error handling finished correctly.
 967   STEP("printing end marker")
 968 
 969      if (_verbose) {
 970        st->print_cr("END.");
 971      }
 972 
 973   END
 974 
 975 # undef BEGIN
 976 # undef STEP
 977 # undef END
 978 }
 979 
 980 // Report for the vm_info_cmd. This prints out the information above omitting
 981 // crash and thread specific information.  If output is added above, it should be added
 982 // here also, if it is safe to call during a running process.
 983 void VMError::print_vm_info(outputStream* st) {
 984 
 985   char buf[O_BUFLEN];
 986   report_vm_version(st, buf, sizeof(buf));
 987 
 988   // STEP("printing summary")
 989 
 990   st->cr();
 991   st->print_cr("---------------  S U M M A R Y ------------");
 992   st->cr();
 993 
 994   // STEP("printing VM option summary")
 995 
 996   // VM options
 997   Arguments::print_summary_on(st);
 998   st->cr();
 999 
1000   // STEP("printing summary machine and OS info")
1001 
1002   os::print_summary_info(st, buf, sizeof(buf));
1003 
1004   // STEP("printing date and time")
1005 
1006   os::print_date_and_time(st, buf, sizeof(buf));
1007 
1008   // Skip: STEP("printing thread")
1009 
1010   // STEP("printing process")
1011 
1012   st->cr();
1013   st->print_cr("---------------  P R O C E S S  ---------------");
1014   st->cr();
1015 
1016   // STEP("printing number of OutOfMemoryError and StackOverflow exceptions")
1017 
1018   if (Exceptions::has_exception_counts()) {
1019     st->print_cr("OutOfMemory and StackOverflow Exception counts:");
1020     Exceptions::print_exception_counts_on_error(st);
1021     st->cr();
1022   }
1023 
1024   // STEP("printing compressed oops mode")
1025 
1026   if (UseCompressedOops) {
1027     Universe::print_compressed_oops_mode(st);
1028     if (UseCompressedClassPointers) {
1029       Metaspace::print_compressed_class_space(st);
1030     }
1031     st->cr();
1032   }
1033 
1034   // STEP("printing heap information")
1035 
1036   if (Universe::is_fully_initialized()) {
1037     MutexLocker hl(Heap_lock);
1038     Universe::heap()->print_on_error(st);
1039     st->cr();
1040     st->print_cr("Polling page: " INTPTR_FORMAT, p2i(os::get_polling_page()));
1041     st->cr();
1042   }
1043 
1044   // STEP("printing code cache information")
1045 
1046   if (Universe::is_fully_initialized()) {
1047     // print code cache information before vm abort
1048     CodeCache::print_summary(st);
1049     st->cr();
1050   }
1051 
1052   // STEP("printing ring buffers")
1053 
1054   Events::print_all(st);
1055   st->cr();
1056 
1057   // STEP("printing dynamic libraries")
1058 
1059   // dynamic libraries, or memory map
1060   os::print_dll_info(st);
1061   st->cr();
1062 
1063   // STEP("printing VM options")
1064 
1065   // VM options
1066   Arguments::print_on(st);
1067   st->cr();
1068 
1069   // STEP("printing warning if internal testing API used")
1070 
1071   if (WhiteBox::used()) {
1072     st->print_cr("Unsupported internal testing APIs have been used.");
1073     st->cr();
1074   }
1075 
1076   // STEP("printing log configuration")
1077   st->print_cr("Logging:");
1078   LogConfiguration::describe(st);
1079   st->cr();
1080 
1081   // STEP("printing all environment variables")
1082 
1083   os::print_environment_variables(st, env_list);
1084   st->cr();
1085 
1086   // STEP("printing signal handlers")
1087 
1088   os::print_signal_handlers(st, buf, sizeof(buf));
1089   st->cr();
1090 
1091   // STEP("Native Memory Tracking")
1092 
1093   MemTracker::error_report(st);
1094 
1095   // STEP("printing system")
1096 
1097   st->cr();
1098   st->print_cr("---------------  S Y S T E M  ---------------");
1099   st->cr();
1100 
1101   // STEP("printing OS information")
1102 
1103   os::print_os_info(st);
1104   st->cr();
1105 
1106   // STEP("printing CPU info")
1107 
1108   os::print_cpu_info(st, buf, sizeof(buf));
1109   st->cr();
1110 
1111   // STEP("printing memory info")
1112 
1113   os::print_memory_info(st);
1114   st->cr();
1115 
1116   // STEP("printing internal vm info")
1117 
1118   st->print_cr("vm_info: %s", Abstract_VM_Version::internal_vm_info_string());
1119   st->cr();
1120 
1121   // print a defined marker to show that error handling finished correctly.
1122   // STEP("printing end marker")
1123 
1124   st->print_cr("END.");
1125 }
1126 
1127 volatile intptr_t VMError::first_error_tid = -1;
1128 
1129 // An error could happen before tty is initialized or after it has been
1130 // destroyed.
1131 // Please note: to prevent large stack allocations, the log- and
1132 // output-stream use a global scratch buffer for format printing.
1133 // (see VmError::report_and_die(). Access to those streams is synchronized
1134 // in  VmError::report_and_die() - there is only one reporting thread at
1135 // any given time.
1136 fdStream VMError::out(defaultStream::output_fd());
1137 fdStream VMError::log; // error log used by VMError::report_and_die()
1138 
1139 /** Expand a pattern into a buffer starting at pos and open a file using constructed path */
1140 static int expand_and_open(const char* pattern, char* buf, size_t buflen, size_t pos) {
1141   int fd = -1;
1142   if (Arguments::copy_expand_pid(pattern, strlen(pattern), &buf[pos], buflen - pos)) {
1143     // the O_EXCL flag will cause the open to fail if the file exists
1144     fd = open(buf, O_RDWR | O_CREAT | O_EXCL, 0666);
1145   }
1146   return fd;
1147 }
1148 
1149 /**
1150  * Construct file name for a log file and return it's file descriptor.
1151  * Name and location depends on pattern, default_pattern params and access
1152  * permissions.
1153  */
1154 static int prepare_log_file(const char* pattern, const char* default_pattern, char* buf, size_t buflen) {
1155   int fd = -1;
1156 
1157   // If possible, use specified pattern to construct log file name
1158   if (pattern != NULL) {
1159     fd = expand_and_open(pattern, buf, buflen, 0);
1160   }
1161 
1162   // Either user didn't specify, or the user's location failed,
1163   // so use the default name in the current directory
1164   if (fd == -1) {
1165     const char* cwd = os::get_current_directory(buf, buflen);
1166     if (cwd != NULL) {
1167       size_t pos = strlen(cwd);
1168       int fsep_len = jio_snprintf(&buf[pos], buflen-pos, "%s", os::file_separator());
1169       pos += fsep_len;
1170       if (fsep_len > 0) {
1171         fd = expand_and_open(default_pattern, buf, buflen, pos);
1172       }
1173     }
1174   }
1175 
1176    // try temp directory if it exists.
1177    if (fd == -1) {
1178      const char* tmpdir = os::get_temp_directory();
1179      if (tmpdir != NULL && strlen(tmpdir) > 0) {
1180        int pos = jio_snprintf(buf, buflen, "%s%s", tmpdir, os::file_separator());
1181        if (pos > 0) {
1182          fd = expand_and_open(default_pattern, buf, buflen, pos);
1183        }
1184      }
1185    }
1186 
1187   return fd;
1188 }
1189 
1190 int         VMError::_id;
1191 const char* VMError::_message;
1192 char        VMError::_detail_msg[1024];
1193 Thread*     VMError::_thread;
1194 address     VMError::_pc;
1195 void*       VMError::_siginfo;
1196 void*       VMError::_context;
1197 const char* VMError::_filename;
1198 int         VMError::_lineno;
1199 size_t      VMError::_size;
1200 
1201 void VMError::report_and_die(Thread* thread, unsigned int sig, address pc, void* siginfo,
1202                              void* context, const char* detail_fmt, ...)
1203 {
1204   va_list detail_args;
1205   va_start(detail_args, detail_fmt);
1206   report_and_die(sig, NULL, detail_fmt, detail_args, thread, pc, siginfo, context, NULL, 0, 0);
1207   va_end(detail_args);
1208 }
1209 
1210 void VMError::report_and_die(Thread* thread, unsigned int sig, address pc, void* siginfo, void* context)
1211 {
1212   report_and_die(thread, sig, pc, siginfo, context, "%s", "");
1213 }
1214 
1215 void VMError::report_and_die(const char* message, const char* detail_fmt, ...)
1216 {
1217   va_list detail_args;
1218   va_start(detail_args, detail_fmt);
1219   report_and_die(INTERNAL_ERROR, message, detail_fmt, detail_args, NULL, NULL, NULL, NULL, NULL, 0, 0);
1220   va_end(detail_args);
1221 }
1222 
1223 void VMError::report_and_die(const char* message)
1224 {
1225   report_and_die(message, "%s", "");
1226 }
1227 
1228 void VMError::report_and_die(Thread* thread, const char* filename, int lineno, const char* message,
1229                              const char* detail_fmt, va_list detail_args)
1230 {
1231   report_and_die(INTERNAL_ERROR, message, detail_fmt, detail_args, thread, NULL, NULL, NULL, filename, lineno, 0);
1232 }
1233 
1234 void VMError::report_and_die(Thread* thread, const char* filename, int lineno, size_t size,
1235                              VMErrorType vm_err_type, const char* detail_fmt, va_list detail_args) {
1236   report_and_die(vm_err_type, NULL, detail_fmt, detail_args, thread, NULL, NULL, NULL, filename, lineno, size);
1237 }
1238 
1239 void VMError::report_and_die(int id, const char* message, const char* detail_fmt, va_list detail_args,
1240                              Thread* thread, address pc, void* siginfo, void* context, const char* filename,
1241                              int lineno, size_t size)
1242 {
1243   // Don't allocate large buffer on stack
1244   static char buffer[O_BUFLEN];
1245   out.set_scratch_buffer(buffer, sizeof(buffer));
1246   log.set_scratch_buffer(buffer, sizeof(buffer));
1247 
1248   // How many errors occurred in error handler when reporting first_error.
1249   static int recursive_error_count;
1250 
1251   // We will first print a brief message to standard out (verbose = false),
1252   // then save detailed information in log file (verbose = true).
1253   static bool out_done = false;         // done printing to standard out
1254   static bool log_done = false;         // done saving error log
1255   static bool transmit_report_done = false; // done error reporting
1256 
1257   if (SuppressFatalErrorMessage) {
1258       os::abort(CreateCoredumpOnCrash);
1259   }
1260   intptr_t mytid = os::current_thread_id();
1261   if (first_error_tid == -1 &&
1262       Atomic::cmpxchg_ptr(mytid, &first_error_tid, -1) == -1) {
1263 
1264     // Initialize time stamps to use the same base.
1265     out.time_stamp().update_to(1);
1266     log.time_stamp().update_to(1);
1267 
1268     _id = id;
1269     _message = message;
1270     _thread = thread;
1271     _pc = pc;
1272     _siginfo = siginfo;
1273     _context = context;
1274     _filename = filename;
1275     _lineno = lineno;
1276     _size = size;
1277     jio_vsnprintf(_detail_msg, sizeof(_detail_msg), detail_fmt, detail_args);
1278 
1279     // first time
1280     _error_reported = true;
1281 
1282     reporting_started();
1283     record_reporting_start_time();
1284 
1285     if (ShowMessageBoxOnError || PauseAtExit) {
1286       show_message_box(buffer, sizeof(buffer));
1287 
1288       // User has asked JVM to abort. Reset ShowMessageBoxOnError so the
1289       // WatcherThread can kill JVM if the error handler hangs.
1290       ShowMessageBoxOnError = false;
1291     }
1292 
1293     os::check_dump_limit(buffer, sizeof(buffer));
1294 
1295     // reset signal handlers or exception filter; make sure recursive crashes
1296     // are handled properly.
1297     reset_signal_handlers();
1298 
1299     TRACE_VM_ERROR();
1300 
1301   } else {
1302     // If UseOsErrorReporting we call this for each level of the call stack
1303     // while searching for the exception handler.  Only the first level needs
1304     // to be reported.
1305     if (UseOSErrorReporting && log_done) return;
1306 
1307     // This is not the first error, see if it happened in a different thread
1308     // or in the same thread during error reporting.
1309     if (first_error_tid != mytid) {
1310       char msgbuf[64];
1311       jio_snprintf(msgbuf, sizeof(msgbuf),
1312                    "[thread " INTX_FORMAT " also had an error]",
1313                    mytid);
1314       out.print_raw_cr(msgbuf);
1315 
1316       // error reporting is not MT-safe, block current thread
1317       os::infinite_sleep();
1318 
1319     } else {
1320       if (recursive_error_count++ > 30) {
1321         out.print_raw_cr("[Too many errors, abort]");
1322         os::die();
1323       }
1324 
1325       outputStream* const st = log.is_open() ? &log : &out;
1326       st->cr();
1327 
1328       // Timeout handling.
1329       if (_step_did_timeout) {
1330         // The current step had a timeout. Lets continue reporting with the next step.
1331         st->print_raw("[timeout occurred during error reporting in step \"");
1332         st->print_raw(_current_step_info);
1333         st->print_cr("\"] after " INT64_FORMAT " s.",
1334                      (int64_t)
1335                      ((get_current_timestamp() - _step_start_time) / TIMESTAMP_TO_SECONDS_FACTOR));
1336       } else if (_reporting_did_timeout) {
1337         // We hit ErrorLogTimeout. Reporting will stop altogether. Let's wrap things
1338         // up, the process is about to be stopped by the WatcherThread.
1339         st->print_cr("------ Timeout during error reporting after " INT64_FORMAT " s. ------",
1340                      (int64_t)
1341                      ((get_current_timestamp() - _reporting_start_time) / TIMESTAMP_TO_SECONDS_FACTOR));
1342         st->flush();
1343         // Watcherthread is about to call os::die. Lets just wait.
1344         os::infinite_sleep();
1345       } else {
1346         // Crash or assert during error reporting. Lets continue reporting with the next step.
1347         jio_snprintf(buffer, sizeof(buffer),
1348            "[error occurred during error reporting (%s), id 0x%x]",
1349                    _current_step_info, _id);
1350         st->print_raw_cr(buffer);
1351         st->cr();
1352       }
1353     }
1354   }
1355 
1356   // print to screen
1357   if (!out_done) {
1358     report(&out, false);
1359 
1360     out_done = true;
1361 
1362     _current_step = 0;
1363     _current_step_info = "";
1364   }
1365 
1366   // print to error log file
1367   if (!log_done) {
1368     // see if log file is already open
1369     if (!log.is_open()) {
1370       // open log file
1371       int fd = prepare_log_file(ErrorFile, "hs_err_pid%p.log", buffer, sizeof(buffer));
1372       if (fd != -1) {
1373         out.print_raw("# An error report file with more information is saved as:\n# ");
1374         out.print_raw_cr(buffer);
1375 
1376         log.set_fd(fd);
1377       } else {
1378         out.print_raw_cr("# Can not save log file, dump to screen..");
1379         log.set_fd(defaultStream::output_fd());
1380         /* Error reporting currently needs dumpfile.
1381          * Maybe implement direct streaming in the future.*/
1382         transmit_report_done = true;
1383       }
1384     }
1385 
1386     report(&log, true);
1387     log_done = true;
1388     _current_step = 0;
1389     _current_step_info = "";
1390 
1391     // Run error reporting to determine whether or not to report the crash.
1392     if (!transmit_report_done && should_report_bug(_id)) {
1393       transmit_report_done = true;
1394       const int fd2 = ::dup(log.fd());
1395       if (fd2 != -1) {
1396         FILE* const hs_err = ::fdopen(fd2, "r");
1397         if (NULL != hs_err) {
1398           ErrorReporter er;
1399           er.call(hs_err, buffer, O_BUFLEN);
1400           ::fclose(hs_err);
1401         }
1402       }
1403     }
1404 
1405     if (log.fd() != defaultStream::output_fd()) {
1406       close(log.fd());
1407     }
1408 
1409     log.set_fd(-1);
1410   }
1411 
1412   static bool skip_replay = ReplayCompiles; // Do not overwrite file during replay
1413   if (DumpReplayDataOnError && _thread && _thread->is_Compiler_thread() && !skip_replay) {
1414     skip_replay = true;
1415     ciEnv* env = ciEnv::current();
1416     if (env != NULL) {
1417       int fd = prepare_log_file(ReplayDataFile, "replay_pid%p.log", buffer, sizeof(buffer));
1418       if (fd != -1) {
1419         FILE* replay_data_file = os::open(fd, "w");
1420         if (replay_data_file != NULL) {
1421           fileStream replay_data_stream(replay_data_file, /*need_close=*/true);
1422           env->dump_replay_data_unsafe(&replay_data_stream);
1423           out.print_raw("#\n# Compiler replay data is saved as:\n# ");
1424           out.print_raw_cr(buffer);
1425         } else {
1426           int e = errno;
1427           out.print_raw("#\n# Can't open file to dump replay data. Error: ");
1428           out.print_raw_cr(os::strerror(e));
1429         }
1430       }
1431     }
1432   }
1433 
1434   static bool skip_bug_url = !should_report_bug(_id);
1435   if (!skip_bug_url) {
1436     skip_bug_url = true;
1437 
1438     out.print_raw_cr("#");
1439     print_bug_submit_message(&out, _thread);
1440   }
1441 
1442   static bool skip_OnError = false;
1443   if (!skip_OnError && OnError && OnError[0]) {
1444     skip_OnError = true;
1445 
1446     // Flush output and finish logs before running OnError commands.
1447     ostream_abort();
1448 
1449     out.print_raw_cr("#");
1450     out.print_raw   ("# -XX:OnError=\"");
1451     out.print_raw   (OnError);
1452     out.print_raw_cr("\"");
1453 
1454     char* cmd;
1455     const char* ptr = OnError;
1456     while ((cmd = next_OnError_command(buffer, sizeof(buffer), &ptr)) != NULL){
1457       out.print_raw   ("#   Executing ");
1458 #if defined(LINUX) || defined(_ALLBSD_SOURCE)
1459       out.print_raw   ("/bin/sh -c ");
1460 #elif defined(SOLARIS)
1461       out.print_raw   ("/usr/bin/sh -c ");
1462 #elif defined(WINDOWS)
1463       out.print_raw   ("cmd /C ");
1464 #endif
1465       out.print_raw   ("\"");
1466       out.print_raw   (cmd);
1467       out.print_raw_cr("\" ...");
1468 
1469       if (os::fork_and_exec(cmd) < 0) {
1470         out.print_cr("os::fork_and_exec failed: %s (%s=%d)",
1471                      os::strerror(errno), os::errno_name(errno), errno);
1472       }
1473     }
1474 
1475     // done with OnError
1476     OnError = NULL;
1477   }
1478 
1479   if (!UseOSErrorReporting) {
1480     // os::abort() will call abort hooks, try it first.
1481     static bool skip_os_abort = false;
1482     if (!skip_os_abort) {
1483       skip_os_abort = true;
1484       bool dump_core = should_report_bug(_id);
1485       os::abort(dump_core && CreateCoredumpOnCrash, _siginfo, _context);
1486     }
1487 
1488     // if os::abort() doesn't abort, try os::die();
1489     os::die();
1490   }
1491 }
1492 
1493 /*
1494  * OnOutOfMemoryError scripts/commands executed while VM is a safepoint - this
1495  * ensures utilities such as jmap can observe the process is a consistent state.
1496  */
1497 class VM_ReportJavaOutOfMemory : public VM_Operation {
1498  private:
1499   const char* _message;
1500  public:
1501   VM_ReportJavaOutOfMemory(const char* message) { _message = message; }
1502   VMOp_Type type() const                        { return VMOp_ReportJavaOutOfMemory; }
1503   void doit();
1504 };
1505 
1506 void VM_ReportJavaOutOfMemory::doit() {
1507   // Don't allocate large buffer on stack
1508   static char buffer[O_BUFLEN];
1509 
1510   tty->print_cr("#");
1511   tty->print_cr("# java.lang.OutOfMemoryError: %s", _message);
1512   tty->print_cr("# -XX:OnOutOfMemoryError=\"%s\"", OnOutOfMemoryError);
1513 
1514   // make heap parsability
1515   Universe::heap()->ensure_parsability(false);  // no need to retire TLABs
1516 
1517   char* cmd;
1518   const char* ptr = OnOutOfMemoryError;
1519   while ((cmd = next_OnError_command(buffer, sizeof(buffer), &ptr)) != NULL){
1520     tty->print("#   Executing ");
1521 #if defined(LINUX)
1522     tty->print  ("/bin/sh -c ");
1523 #elif defined(SOLARIS)
1524     tty->print  ("/usr/bin/sh -c ");
1525 #endif
1526     tty->print_cr("\"%s\"...", cmd);
1527 
1528     if (os::fork_and_exec(cmd) < 0) {
1529       tty->print_cr("os::fork_and_exec failed: %s (%s=%d)",
1530                      os::strerror(errno), os::errno_name(errno), errno);
1531     }
1532   }
1533 }
1534 
1535 void VMError::report_java_out_of_memory(const char* message) {
1536   if (OnOutOfMemoryError && OnOutOfMemoryError[0]) {
1537     MutexLocker ml(Heap_lock);
1538     VM_ReportJavaOutOfMemory op(message);
1539     VMThread::execute(&op);
1540   }
1541 }
1542 
1543 void VMError::show_message_box(char *buf, int buflen) {
1544   bool yes;
1545   do {
1546     error_string(buf, buflen);
1547     yes = os::start_debugging(buf,buflen);
1548   } while (yes);
1549 }
1550 
1551 // Timeout handling: check if a timeout happened (either a single step did
1552 // timeout or the whole of error reporting hit ErrorLogTimeout). Interrupt
1553 // the reporting thread if that is the case.
1554 bool VMError::check_timeout() {
1555 
1556   if (ErrorLogTimeout == 0) {
1557     return false;
1558   }
1559 
1560   // Do not check for timeouts if we still have a message box to show to the
1561   // user or if there are OnError handlers to be run.
1562   if (ShowMessageBoxOnError
1563       || (OnError != NULL && OnError[0] != '\0')
1564       || Arguments::abort_hook() != NULL) {
1565     return false;
1566   }
1567 
1568   const jlong reporting_start_time_l = get_reporting_start_time();
1569   const jlong now = get_current_timestamp();
1570   // Timestamp is stored in nanos.
1571   if (reporting_start_time_l > 0) {
1572     const jlong end = reporting_start_time_l + (jlong)ErrorLogTimeout * TIMESTAMP_TO_SECONDS_FACTOR;
1573     if (end <= now) {
1574       _reporting_did_timeout = true;
1575       interrupt_reporting_thread();
1576       return true; // global timeout
1577     }
1578   }
1579 
1580   const jlong step_start_time_l = get_step_start_time();
1581   if (step_start_time_l > 0) {
1582     // A step times out after a quarter of the total timeout. Steps are mostly fast unless they
1583     // hang for some reason, so this simple rule allows for three hanging step and still
1584     // hopefully leaves time enough for the rest of the steps to finish.
1585     const jlong end = step_start_time_l + (jlong)ErrorLogTimeout * TIMESTAMP_TO_SECONDS_FACTOR / 4;
1586     if (end <= now) {
1587       _step_did_timeout = true;
1588       interrupt_reporting_thread();
1589       return false; // (Not a global timeout)
1590     }
1591   }
1592 
1593   return false;
1594 
1595 }
1596 
1597 #ifndef PRODUCT
1598 typedef void (*voidfun_t)();
1599 // Crash with an authentic sigfpe
1600 static void crash_with_sigfpe() {
1601   // generate a native synchronous SIGFPE where possible;
1602   // if that did not cause a signal (e.g. on ppc), just
1603   // raise the signal.
1604   volatile int x = 0;
1605   volatile int y = 1/x;
1606 #ifndef _WIN32
1607   // OSX implements raise(sig) incorrectly so we need to
1608   // explicitly target the current thread
1609   pthread_kill(pthread_self(), SIGFPE);
1610 #endif
1611 } // end: crash_with_sigfpe
1612 
1613 // crash with sigsegv at non-null address.
1614 static void crash_with_segfault() {
1615 
1616   char* const crash_addr = (char*) VMError::get_segfault_address();
1617   *crash_addr = 'X';
1618 
1619 } // end: crash_with_segfault
1620 
1621 void VMError::test_error_handler() {
1622   controlled_crash(ErrorHandlerTest);
1623 }
1624 
1625 // crash in a controlled way:
1626 // how can be one of:
1627 // 1,2 - asserts
1628 // 3,4 - guarantee
1629 // 5-7 - fatal
1630 // 8 - vm_exit_out_of_memory
1631 // 9 - ShouldNotCallThis
1632 // 10 - ShouldNotReachHere
1633 // 11 - Unimplemented
1634 // 12,13 - (not guaranteed) crashes
1635 // 14 - SIGSEGV
1636 // 15 - SIGFPE
1637 void VMError::controlled_crash(int how) {
1638   if (how == 0) return;
1639 
1640   // If asserts are disabled, use the corresponding guarantee instead.
1641   NOT_DEBUG(if (how <= 2) how += 2);
1642 
1643   const char* const str = "hello";
1644   const size_t      num = (size_t)os::vm_page_size();
1645 
1646   const char* const eol = os::line_separator();
1647   const char* const msg = "this message should be truncated during formatting";
1648   char * const dataPtr = NULL;  // bad data pointer
1649   const void (*funcPtr)(void) = (const void(*)()) 0xF;  // bad function pointer
1650 
1651   // Keep this in sync with test/runtime/ErrorHandling/ErrorHandler.java
1652   switch (how) {
1653     case  1: vmassert(str == NULL, "expected null");
1654     case  2: vmassert(num == 1023 && *str == 'X',
1655                       "num=" SIZE_FORMAT " str=\"%s\"", num, str);
1656     case  3: guarantee(str == NULL, "expected null");
1657     case  4: guarantee(num == 1023 && *str == 'X',
1658                        "num=" SIZE_FORMAT " str=\"%s\"", num, str);
1659     case  5: fatal("expected null");
1660     case  6: fatal("num=" SIZE_FORMAT " str=\"%s\"", num, str);
1661     case  7: fatal("%s%s#    %s%s#    %s%s#    %s%s#    %s%s#    "
1662                    "%s%s#    %s%s#    %s%s#    %s%s#    %s%s#    "
1663                    "%s%s#    %s%s#    %s%s#    %s%s#    %s",
1664                    msg, eol, msg, eol, msg, eol, msg, eol, msg, eol,
1665                    msg, eol, msg, eol, msg, eol, msg, eol, msg, eol,
1666                    msg, eol, msg, eol, msg, eol, msg, eol, msg);
1667     case  8: vm_exit_out_of_memory(num, OOM_MALLOC_ERROR, "ChunkPool::allocate");
1668     case  9: ShouldNotCallThis();
1669     case 10: ShouldNotReachHere();
1670     case 11: Unimplemented();
1671     // There's no guarantee the bad data pointer will crash us
1672     // so "break" out to the ShouldNotReachHere().
1673     case 12: *dataPtr = '\0'; break;
1674     // There's no guarantee the bad function pointer will crash us
1675     // so "break" out to the ShouldNotReachHere().
1676     case 13: (*funcPtr)(); break;
1677     case 14: crash_with_segfault(); break;
1678     case 15: crash_with_sigfpe(); break;
1679 
1680     default: tty->print_cr("ERROR: %d: unexpected test_num value.", how);
1681   }
1682   ShouldNotReachHere();
1683 }
1684 #endif // !PRODUCT
1685 
--- EOF ---