jdk-sandbox: comparison hotspot/src/share/vm/utilities/vmError.cpp

equal deleted inserted replaced

-:67e9ed945358
+:fe1677e95252
 int          VMError::_current_step;
 const char*  VMError::_current_step_info;
 void VMError::report(outputStream* st, bool _verbose) {
-# define BEGIN if (_current_step == 0) { _current_step = 1;
+# define BEGIN if (_current_step == 0) { _current_step = __LINE__;
-# define STEP(n, s) } if (_current_step < n) { _current_step = n; _current_step_info = s;
+# define STEP(s) } if (_current_step < __LINE__) { _current_step = __LINE__; _current_step_info = s;
 # define END }
 // don't allocate large buffer on stack
 static char buf[O_BUFLEN];
 BEGIN
-STEP(10, "(printing fatal error message)")
+STEP("printing fatal error message")
 st->print_cr("#");
 if (should_report_bug(_id)) {
 st->print_cr("# A fatal error has been detected by the Java Runtime Environment:");
 } else {
 #ifndef PRODUCT
 // Error handler self tests
 // test secondary error handling. Test it twice, to test that resetting
 // error handler after a secondary crash works.
-STEP(20, "(test secondary crash 1)")
+STEP("test secondary crash 1")
 if (_verbose && TestCrashInErrorHandler != 0) {
 st->print_cr("Will crash now (TestCrashInErrorHandler=" UINTX_FORMAT ")...",
 TestCrashInErrorHandler);
 controlled_crash(TestCrashInErrorHandler);
 }
-STEP(30, "(test secondary crash 2)")
+STEP("test secondary crash 2")
 if (_verbose && TestCrashInErrorHandler != 0) {
 st->print_cr("Will crash now (TestCrashInErrorHandler=" UINTX_FORMAT ")...",
 TestCrashInErrorHandler);
 controlled_crash(TestCrashInErrorHandler);
 }
-STEP(40, "(test safefetch in error handler)")
+STEP("test safefetch in error handler")
 // test whether it is safe to use SafeFetch32 in Crash Handler. Test twice
 // to test that resetting the signal handler works correctly.
 if (_verbose && TestSafeFetchInErrorHandler) {
 st->print_cr("Will test SafeFetch...");
 if (CanUseSafeFetch32()) {
 st->print_cr("not possible; skipped.");
 }
 }
 #endif // PRODUCT
-STEP(50, "(printing type of error)")
+STEP("printing type of error")
 switch(_id) {
 case OOM_MALLOC_ERROR:
 case OOM_MMAP_ERROR:
 if (_size) {
 case INTERNAL_ERROR:
 default:
 break;
 }
-STEP(60, "(printing exception/signal name)")
+STEP("printing exception/signal name")
 st->print_cr("#");
 st->print("#  ");
 // Is it an OS exception/signal?
 if (os::exception_name(_id, buf, sizeof(buf))) {
 } else {
 st->print(" (0x%x)", _id);
 }
 }
-STEP(70, "(printing current thread and pid)")
+STEP("printing current thread and pid")
 // process id, thread id
 st->print(", pid=%d", os::current_process_id());
 st->print(", tid=" UINTX_FORMAT, os::current_thread_id());
 st->cr();
-STEP(80, "(printing error message)")
+STEP("printing error message")
 if (should_report_bug(_id)) {  // already printed the message.
 // error message
 if (strlen(_detail_msg) > 0) {
 st->print_cr("#  %s: %s", _message ? _message : "Error", _detail_msg);
 } else if (_message) {
 st->print_cr("#  Error: %s", _message);
 }
 }
-STEP(90, "(printing Java version string)")
+STEP("printing Java version string")
 report_vm_version(st, buf, sizeof(buf));
-STEP(100, "(printing problematic frame)")
+STEP("printing problematic frame")
 // Print current frame if we have a context (i.e. it's a crash)
 if (_context) {
 st->print_cr("# Problematic frame:");
 st->print("# ");
 fr.print_on_error(st, buf, sizeof(buf));
 st->cr();
 st->print_cr("#");
 }
-STEP(110, "(printing core file information)")
+STEP("printing core file information")
 st->print("# ");
 if (CreateCoredumpOnCrash) {
 if (coredump_status) {
 st->print("Core dump will be written. Default location: %s", coredump_message);
 } else {
 st->print("CreateCoredumpOnCrash turned off, no core file dumped");
 }
 st->cr();
 st->print_cr("#");
-STEP(120, "(printing bug submit message)")
+STEP("printing bug submit message")
 if (should_report_bug(_id) && _verbose) {
 print_bug_submit_message(st, _thread);
 }
-STEP(130, "(printing summary)" )
+STEP("printing summary")
 if (_verbose) {
 st->cr();
 st->print_cr("---------------  S U M M A R Y ------------");
 st->cr();
 }
-STEP(140, "(printing VM option summary)" )
+STEP("printing VM option summary")
 if (_verbose) {
 // VM options
 Arguments::print_summary_on(st);
 st->cr();
 }
-STEP(150, "(printing summary machine and OS info)")
+STEP("printing summary machine and OS info")
 if (_verbose) {
 os::print_summary_info(st, buf, sizeof(buf));
 }
-STEP(160, "(printing date and time)" )
+STEP("printing date and time")
 if (_verbose) {
 os::print_date_and_time(st, buf, sizeof(buf));
 }
-STEP(170, "(printing thread)" )
+STEP("printing thread")
 if (_verbose) {
 st->cr();
 st->print_cr("---------------  T H R E A D  ---------------");
 st->cr();
 }
-STEP(180, "(printing current thread)" )
+STEP("printing current thread")
 // current thread
 if (_verbose) {
 if (_thread) {
 st->print("Current thread (" PTR_FORMAT "):  ", p2i(_thread));
 st->print_cr("Current thread is native thread");
 }
 st->cr();
 }
-STEP(190, "(printing current compile task)" )
+STEP("printing current compile task")
 if (_verbose && _thread && _thread->is_Compiler_thread()) {
 CompilerThread* t = (CompilerThread*)_thread;
 if (t->task()) {
 st->cr();
 st->cr();
 }
 }
-STEP(200, "(printing stack bounds)" )
+STEP("printing stack bounds")
 if (_verbose) {
 st->print("Stack: ");
 address stack_top;
 }
 st->cr();
 }
-STEP(210, "(printing native stack)" )
+STEP("printing native stack")
 if (_verbose) {
 if (os::platform_print_native_stack(st, _context, buf, sizeof(buf))) {
 // We have printed the native stack in platform-specific code
 // Windows/x64 needs special handling.
 print_native_stack(st, fr, _thread, buf, sizeof(buf));
 }
 }
-STEP(220, "(printing Java stack)" )
+STEP("printing Java stack")
 if (_verbose && _thread && _thread->is_Java_thread()) {
 print_stack_trace(st, (JavaThread*)_thread, buf, sizeof(buf));
 }
-STEP(230, "(printing target Java thread stack)" )
+STEP("printing target Java thread stack")
 // printing Java thread stack trace if it is involved in GC crash
 if (_verbose && _thread && (_thread->is_Named_thread())) {
 JavaThread*  jt = ((NamedThread *)_thread)->processed_thread();
 if (jt != NULL) {
 st->print_cr("JavaThread " PTR_FORMAT " (nid = %d) was being processed", p2i(jt), jt->osthread()->thread_id());
 print_stack_trace(st, jt, buf, sizeof(buf), true);
 }
 }
-STEP(240, "(printing siginfo)" )
+STEP("printing siginfo")
 // signal no, signal code, address that caused the fault
 if (_verbose && _siginfo) {
 st->cr();
 os::print_siginfo(st, _siginfo);
 st->cr();
 }
-STEP(245, "(CDS archive access warning)" )
+STEP("CDS archive access warning")
 // Print an explicit hint if we crashed on access to the CDS archive.
 if (_verbose && _siginfo) {
 check_failing_cds_access(st, _siginfo);
 st->cr();
 }
-STEP(250, "(printing register info)")
+STEP("printing register info")
 // decode register contents if possible
 if (_verbose && _context && Universe::is_fully_initialized()) {
 os::print_register_info(st, _context);
 st->cr();
 }
-STEP(260, "(printing registers, top of stack, instructions near pc)")
+STEP("printing registers, top of stack, instructions near pc")
 // registers, top of stack, instructions near pc
 if (_verbose && _context) {
 os::print_context(st, _context);
 st->cr();
 }
-STEP(265, "(printing code blob if possible)")
+STEP("printing code blob if possible")
 if (_verbose && _context) {
 CodeBlob* cb = CodeCache::find_blob(_pc);
 if (cb != NULL) {
 if (Interpreter::contains(_pc)) {
 }
 }
 }
 }
-STEP(270, "(printing VM operation)" )
+STEP("printing VM operation")
 if (_verbose && _thread && _thread->is_VM_thread()) {
 VMThread* t = (VMThread*)_thread;
 VM_Operation* op = t->vm_operation();
 if (op) {
 st->cr();
 st->cr();
 }
 }
-STEP(280, "(printing process)" )
+STEP("printing process")
 if (_verbose) {
 st->cr();
 st->print_cr("---------------  P R O C E S S  ---------------");
 st->cr();
 }
-STEP(290, "(printing all threads)" )
+STEP("printing all threads")
 // all threads
 if (_verbose && _thread) {
 Threads::print_on_error(st, _thread, buf, sizeof(buf));
 st->cr();
 }
-STEP(300, "(printing VM state)" )
+STEP("printing VM state")
 if (_verbose) {
 // Safepoint state
 st->print("VM state:");
 }
 st->cr();
 st->cr();
 }
-STEP(310, "(printing owned locks on error)" )
+STEP("printing owned locks on error")
 // mutexes/monitors that currently have an owner
 if (_verbose) {
 print_owned_locks_on_error(st);
 st->cr();
 }
-STEP(320, "(printing number of OutOfMemoryError and StackOverflow exceptions)")
+STEP("printing number of OutOfMemoryError and StackOverflow exceptions")
 if (_verbose && Exceptions::has_exception_counts()) {
 st->print_cr("OutOfMemory and StackOverflow Exception counts:");
 Exceptions::print_exception_counts_on_error(st);
 st->cr();
 }
-STEP(330, "(printing compressed oops mode")
+STEP("printing compressed oops mode")
 if (_verbose && UseCompressedOops) {
 Universe::print_compressed_oops_mode(st);
 if (UseCompressedClassPointers) {
 Metaspace::print_compressed_class_space(st);
 }
 st->cr();
 }
-STEP(340, "(printing heap information)" )
+STEP("printing heap information")
 if (_verbose && Universe::is_fully_initialized()) {
 Universe::heap()->print_on_error(st);
 st->cr();
 st->print_cr("Polling page: " INTPTR_FORMAT, p2i(os::get_polling_page()));
 st->cr();
 }
-STEP(350, "(printing code cache information)" )
+STEP("printing code cache information")
 if (_verbose && Universe::is_fully_initialized()) {
 // print code cache information before vm abort
 CodeCache::print_summary(st);
 st->cr();
 }
-STEP(360, "(printing ring buffers)" )
+STEP("printing ring buffers")
 if (_verbose) {
 Events::print_all(st);
 st->cr();
 }
-STEP(370, "(printing dynamic libraries)" )
+STEP("printing dynamic libraries")
 if (_verbose) {
 // dynamic libraries, or memory map
 os::print_dll_info(st);
 st->cr();
 }
-STEP(380, "(printing VM options)" )
+STEP("printing VM options")
 if (_verbose) {
 // VM options
 Arguments::print_on(st);
 st->cr();
 }
-STEP(390, "(printing warning if internal testing API used)" )
+STEP("printing warning if internal testing API used")
 if (WhiteBox::used()) {
 st->print_cr("Unsupported internal testing APIs have been used.");
 st->cr();
 }
-STEP(395, "(printing log configuration)")
+STEP("printing log configuration")
 if (_verbose){
 st->print_cr("Logging:");
 LogConfiguration::describe_current_configuration(st);
 st->cr();
 }
-STEP(400, "(printing all environment variables)" )
+STEP("printing all environment variables")
 if (_verbose) {
 os::print_environment_variables(st, env_list);
 st->cr();
 }
-STEP(410, "(printing signal handlers)" )
+STEP("printing signal handlers")
 if (_verbose) {
 os::print_signal_handlers(st, buf, sizeof(buf));
 st->cr();
 }
-STEP(420, "(Native Memory Tracking)" )
+STEP("Native Memory Tracking")
 if (_verbose) {
 MemTracker::error_report(st);
 }
-STEP(430, "(printing system)" )
+STEP("printing system")
 if (_verbose) {
 st->cr();
 st->print_cr("---------------  S Y S T E M  ---------------");
 st->cr();
 }
-STEP(440, "(printing OS information)" )
+STEP("printing OS information")
 if (_verbose) {
 os::print_os_info(st);
 st->cr();
 }
-STEP(450, "(printing CPU info)" )
+STEP("printing CPU info")
 if (_verbose) {
 os::print_cpu_info(st, buf, sizeof(buf));
 st->cr();
 }
-STEP(460, "(printing memory info)" )
+STEP("printing memory info")
 if (_verbose) {
 os::print_memory_info(st);
 st->cr();
 }
-STEP(470, "(printing internal vm info)" )
+STEP("printing internal vm info")
 if (_verbose) {
 st->print_cr("vm_info: %s", Abstract_VM_Version::internal_vm_info_string());
 st->cr();
 }
 // print a defined marker to show that error handling finished correctly.
-STEP(480, "(printing end marker)" )
+STEP("printing end marker")
 if (_verbose) {
 st->print_cr("END.");
 }
 void VMError::print_vm_info(outputStream* st) {
 char buf[O_BUFLEN];
 report_vm_version(st, buf, sizeof(buf));
-// STEP("(printing summary)")
+// STEP("printing summary")
 st->cr();
 st->print_cr("---------------  S U M M A R Y ------------");
 st->cr();
-// STEP("(printing VM option summary)")
+// STEP("printing VM option summary")
 // VM options
 Arguments::print_summary_on(st);
 st->cr();
-// STEP("(printing summary machine and OS info)")
+// STEP("printing summary machine and OS info")
 os::print_summary_info(st, buf, sizeof(buf));
-// STEP("(printing date and time)")
+// STEP("printing date and time")
 os::print_date_and_time(st, buf, sizeof(buf));
-// Skip: STEP("(printing thread)")
+// Skip: STEP("printing thread")
-// STEP("(printing process)")
+// STEP("printing process")
 st->cr();
 st->print_cr("---------------  P R O C E S S  ---------------");
 st->cr();
-// STEP("(printing number of OutOfMemoryError and StackOverflow exceptions)")
+// STEP("printing number of OutOfMemoryError and StackOverflow exceptions")
 if (Exceptions::has_exception_counts()) {
 st->print_cr("OutOfMemory and StackOverflow Exception counts:");
 Exceptions::print_exception_counts_on_error(st);
 st->cr();
 }
-// STEP("(printing compressed oops mode")
+// STEP("printing compressed oops mode")
 if (UseCompressedOops) {
 Universe::print_compressed_oops_mode(st);
 if (UseCompressedClassPointers) {
 Metaspace::print_compressed_class_space(st);
 }
 st->cr();
 }
-// STEP("(printing heap information)")
+// STEP("printing heap information")
 if (Universe::is_fully_initialized()) {
 Universe::heap()->print_on_error(st);
 st->cr();
 st->print_cr("Polling page: " INTPTR_FORMAT, p2i(os::get_polling_page()));
 st->cr();
 }
-// STEP("(printing code cache information)")
+// STEP("printing code cache information")
 if (Universe::is_fully_initialized()) {
 // print code cache information before vm abort
 CodeCache::print_summary(st);
 st->cr();
 }
-// STEP("(printing ring buffers)")
+// STEP("printing ring buffers")
 Events::print_all(st);
 st->cr();
-// STEP("(printing dynamic libraries)")
+// STEP("printing dynamic libraries")
 // dynamic libraries, or memory map
 os::print_dll_info(st);
 st->cr();
-// STEP("(printing VM options)")
+// STEP("printing VM options")
 // VM options
 Arguments::print_on(st);
 st->cr();
-// STEP("(printing warning if internal testing API used)")
+// STEP("printing warning if internal testing API used")
 if (WhiteBox::used()) {
 st->print_cr("Unsupported internal testing APIs have been used.");
 st->cr();
 }
-// STEP("(printing log configuration)")
+// STEP("printing log configuration")
 st->print_cr("Logging:");
 LogConfiguration::describe(st);
 st->cr();
-// STEP("(printing all environment variables)")
+// STEP("printing all environment variables")
 os::print_environment_variables(st, env_list);
 st->cr();
-// STEP("(printing signal handlers)")
+// STEP("printing signal handlers")
 os::print_signal_handlers(st, buf, sizeof(buf));
 st->cr();
-// STEP("(Native Memory Tracking)")
+// STEP("Native Memory Tracking")
 MemTracker::error_report(st);
-// STEP("(printing system)")
+// STEP("printing system")
 st->cr();
 st->print_cr("---------------  S Y S T E M  ---------------");
 st->cr();
-// STEP("(printing OS information)")
+// STEP("printing OS information")
 os::print_os_info(st);
 st->cr();
-// STEP("(printing CPU info)")
+// STEP("printing CPU info")
 os::print_cpu_info(st, buf, sizeof(buf));
 st->cr();
-// STEP("(printing memory info)")
+// STEP("printing memory info")
 os::print_memory_info(st);
 st->cr();
-// STEP("(printing internal vm info)")
+// STEP("printing internal vm info")
 st->print_cr("vm_info: %s", Abstract_VM_Version::internal_vm_info_string());
 st->cr();
 // print a defined marker to show that error handling finished correctly.
-// STEP("(printing end marker)")
+// STEP("printing end marker")
 st->print_cr("END.");
 }
 volatile intptr_t VMError::first_error_tid = -1;
 out.print_raw_cr("[Too many errors, abort]");
 os::die();
 }
 jio_snprintf(buffer, sizeof(buffer),
-"[error occurred during error reporting %s, id 0x%x]",
+"[error occurred during error reporting (%s), id 0x%x]",
 _current_step_info, _id);
 if (log.is_open()) {
 log.cr();
 log.print_raw_cr(buffer);
 log.cr();

changeset 38215	fe1677e95252
parent 37994	1a816b464178
child 39274	940f0e8e9ec2