*** old/src/share/vm/utilities/vmError.cpp	Fri Jul 17 15:15:09 2015
--- new/src/share/vm/utilities/vmError.cpp	Fri Jul 17 15:15:08 2015

*** 304,313 ****
--- 304,337 ----
      }
    }
  #endif // ZERO
  }
  
+ void VMError::print_oom_reasons(outputStream* st) {
+   st->print_cr("# Possible reasons:");
+   st->print_cr("#   The system is out of physical RAM or swap space");
+   st->print_cr("#   In 32 bit mode, the process size limit was hit");
+   st->print_cr("# Possible solutions:");
+   st->print_cr("#   Reduce memory load on the system");
+   st->print_cr("#   Increase physical memory or swap space");
+   st->print_cr("#   Check if swap backing store is full");
+   st->print_cr("#   Use 64 bit Java on a 64 bit OS");
+   st->print_cr("#   Decrease Java heap size (-Xmx/-Xms)");
+   st->print_cr("#   Decrease number of Java threads");
+   st->print_cr("#   Decrease Java thread stack sizes (-Xss)");
+   st->print_cr("#   Set larger code cache with -XX:ReservedCodeCacheSize=");
+   st->print_cr("# This output file may be truncated or incomplete.");
+ }
+ 
+ const char* VMError::gc_mode() {
+   if (UseG1GC)            return "g1 gc";
+   if (UseParallelGC)      return "parallel gc";
+   if (UseConcMarkSweepGC) return "concurrent mark sweep gc";
+   if (UseSerialGC)        return "serial gc";
+   return "ERROR in GC mode";
+ }
+ 
  // This is the main function to report a fatal error. Only one thread can
  // call this function, so we don't need to worry about MT-safety. But it's
  // possible that the error handler itself may crash or die on an internal
  // error, for example, when the stack/heap is badly damaged. We must be
  // able to handle recursive errors that happen inside error handler.

*** 356,380 ****
--- 380,404 ----
  #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(11, "(test secondary crash 1)")
!   STEP(20, "(test secondary crash 1)")
      if (_verbose && TestCrashInErrorHandler != 0) {
        st->print_cr("Will crash now (TestCrashInErrorHandler=%d)...",
          TestCrashInErrorHandler);
        controlled_crash(TestCrashInErrorHandler);
      }
  
!   STEP(12, "(test secondary crash 2)")
!   STEP(30, "(test secondary crash 2)")
      if (_verbose && TestCrashInErrorHandler != 0) {
        st->print_cr("Will crash now (TestCrashInErrorHandler=%d)...",
          TestCrashInErrorHandler);
        controlled_crash(TestCrashInErrorHandler);
      }
  
!   STEP(13, "(test safefetch in error handler)")
!   STEP(40, "(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()) {

*** 391,401 ****
--- 415,425 ----
          st->print_cr("not possible; skipped.");
        }
      }
  #endif // PRODUCT
  
!   STEP(15, "(printing type of error)")
!   STEP(50, "(printing type of error)")
  
       switch(_id) {
         case OOM_MALLOC_ERROR:
         case OOM_MMAP_ERROR:
           if (_size) {

*** 416,448 ****
--- 440,460 ----
               st->print_cr("%s", _message);
             }
           }
           // In error file give some solutions
           if (_verbose) {
!            st->print_cr("# Possible reasons:");
             st->print_cr("#   The system is out of physical RAM or swap space");
             st->print_cr("#   In 32 bit mode, the process size limit was hit");
             st->print_cr("# Possible solutions:");
             st->print_cr("#   Reduce memory load on the system");
             st->print_cr("#   Increase physical memory or swap space");
             st->print_cr("#   Check if swap backing store is full");
             st->print_cr("#   Use 64 bit Java on a 64 bit OS");
             st->print_cr("#   Decrease Java heap size (-Xmx/-Xms)");
             st->print_cr("#   Decrease number of Java threads");
             st->print_cr("#   Decrease Java thread stack sizes (-Xss)");
             st->print_cr("#   Set larger code cache with -XX:ReservedCodeCacheSize=");
             st->print_cr("# This output file may be truncated or incomplete.");
!            print_oom_reasons(st);
           } else {
             return;  // that's enough for the screen
           }
           break;
         case INTERNAL_ERROR:
         default:
           break;
       }
  
!   STEP(20, "(printing exception/signal name)")
!   STEP(60, "(printing exception/signal name)")
  
       st->print_cr("#");
       st->print("#  ");
       // Is it an OS exception/signal?
       if (os::exception_name(_id, buf, sizeof(buf))) {

*** 468,525 ****
--- 480,541 ----
         } else {
           st->print(" (0x%x)", _id);
         }
       }
  
!   STEP(30, "(printing current thread and pid)")
!   STEP(70, "(printing current thread and pid)")
  
       // process id, thread id
       st->print(", pid=%d", os::current_process_id());
       st->print(", tid=" INTPTR_FORMAT, os::current_thread_id());
       st->cr();
  
!   STEP(40, "(printing error message)")
!   STEP(80, "(printing error message)")
  
       if (should_report_bug(_id)) {  // already printed the message.
         // error message
         if (_detail_msg) {
           st->print_cr("#  %s: %s", _message ? _message : "Error", _detail_msg);
         } else if (_message) {
           st->print_cr("#  Error: %s", _message);
         }
      }
  
!   STEP(50, "(printing Java version string)")
!   STEP(90, "(printing Java version string)")
  
       // VM version
       st->print_cr("#");
       JDK_Version::current().to_string(buf, sizeof(buf));
       const char* runtime_name = JDK_Version::runtime_name() != NULL ?
                                    JDK_Version::runtime_name() : "";
       const char* runtime_version = JDK_Version::runtime_version() != NULL ?
                                    JDK_Version::runtime_version() : "";
       st->print_cr("# JRE version: %s (%s) (build %s)", runtime_name, buf, runtime_version);
       st->print_cr("# Java VM: %s (%s %s %s %s)",
+      // This is the long version with some default settings added
+      st->print_cr("# Java VM: %s (%s, %s%s%s, %s, %s)",
                     Abstract_VM_Version::vm_name(),
                     Abstract_VM_Version::vm_release(),
                     Abstract_VM_Version::vm_info_string(),
!                    Abstract_VM_Version::vm_platform_string(),
!                    UseCompressedOops ? "compressed oops" : ""
!                    TieredCompilation ? ", tiered" : "",
!                    UseCompressedOops ? ", compressed oops" : "",
+                    gc_mode(),
+                    Abstract_VM_Version::vm_platform_string()
                   );
  
!   STEP(60, "(printing problematic frame)")
!   STEP(100, "(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("# ");
         frame fr = os::fetch_frame_from_context(_context);
         fr.print_on_error(st, buf, sizeof(buf));
         st->cr();
         st->print_cr("#");
       }
    STEP(63, "(printing core file information)")
+ 
+   STEP(110, "(printing core file information)")
      st->print("# ");
      if (CreateCoredumpOnCrash) {
        if (coredump_status) {
          st->print("Core dump will be written. Default location: %s", coredump_message);
        } else {

*** 529,553 ****
--- 545,598 ----
        st->print("CreateCoredumpOnCrash turned off, no core file dumped");
      }
      st->cr();
      st->print_cr("#");
  
!   STEP(65, "(printing bug submit message)")
!   STEP(120, "(printing bug submit message)")
  
       if (should_report_bug(_id) && _verbose) {
         print_bug_submit_message(st, _thread);
       }
  
!   STEP(70, "(printing thread)" )
!   STEP(130, "(printing summary)" )
+ 
+      if (_verbose) {
+        st->cr();
+        st->print_cr("---------------  S U M M A R Y ------------");
+        st->cr();
+      }
+ 
+   STEP(140, "(printing VM option summary)" )
+ 
+      if (_verbose) {
+        // VM options
+        Arguments::print_summary_on(st);
+        st->cr();
+      }
+ 
+   STEP(150, "(printing summary machine and OS info)")
+ 
+      if (_verbose) {
+        os::print_summary_info(st, buf, sizeof(buf));
+      }
+ 
+ 
+   STEP(160, "(printing date and time)" )
+ 
+      if (_verbose) {
+        os::print_date_and_time(st, buf, sizeof(buf));
+      }
+ 
+   STEP(170, "(printing thread)" )
  
       if (_verbose) {
         st->cr();
         st->print_cr("---------------  T H R E A D  ---------------");
         st->cr();
       }
  
!   STEP(180, "(printing current thread)" )
  
       // current thread
       if (_verbose) {
         if (_thread) {
           st->print("Current thread (" PTR_FORMAT "):  ", _thread);

*** 557,591 ****
--- 602,625 ----
           st->print_cr("Current thread is native thread");
         }
         st->cr();
       }
  
!   STEP(90, "(printing siginfo)" )
!   STEP(190, "(printing current compile task)" )
  
       // signal no, signal code, address that caused the fault
       if (_verbose && _siginfo) {
         os::print_siginfo(st, _siginfo);
+      if (_verbose && _thread && _thread->is_Compiler_thread()) {
+         CompilerThread* t = (CompilerThread*)_thread;
+         if (t->task()) {
             st->cr();
       }
  
    STEP(100, "(printing registers, top of stack, instructions near pc)")
  
       // registers, top of stack, instructions near pc
       if (_verbose && _context) {
         os::print_context(st, _context);
+            st->print_cr("Current CompileTask:");
+            t->task()->print_line_on_error(st, buf, sizeof(buf));
             st->cr();
          }
  
    STEP(105, "(printing register info)")
  
       // decode register contents if possible
       if (_verbose && _context && Universe::is_fully_initialized()) {
         os::print_register_info(st, _context);
         st->cr();
       }
  
    STEP(110, "(printing stack bounds)" )
+ 
+   STEP(200, "(printing stack bounds)" )
  
       if (_verbose) {
         st->print("Stack: ");
  
         address stack_top;

*** 612,622 ****
--- 646,656 ----
         }
  
         st->cr();
       }
  
!   STEP(120, "(printing native stack)" )
!   STEP(210, "(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.

*** 626,693 ****
--- 660,740 ----
  
         print_native_stack(st, fr, _thread, buf, sizeof(buf));
       }
     }
  
!   STEP(130, "(printing Java stack)" )
!   STEP(220, "(printing Java stack)" )
  
       if (_verbose && _thread && _thread->is_Java_thread()) {
         print_stack_trace(st, (JavaThread*)_thread, buf, sizeof(buf));
       }
  
!   STEP(135, "(printing target Java thread stack)" )
!   STEP(230, "(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 = " UINTX_FORMAT ") was being processed", jt, jt->osthread()->thread_id());
           print_stack_trace(st, jt, buf, sizeof(buf), true);
         }
       }
  
!   STEP(140, "(printing VM operation)" )
!   STEP(240, "(printing siginfo)" )
  
       if (_verbose && _thread && _thread->is_VM_thread()) {
          VMThread* t = (VMThread*)_thread;
          VM_Operation* op = t->vm_operation();
          if (op) {
            op->print_on_error(st);
+      // signal no, signal code, address that caused the fault
+      if (_verbose && _siginfo) {
         st->cr();
+        os::print_siginfo(st, _siginfo);
         st->cr();
       }
+ 
+   STEP(250, "(printing register info)")
+ 
+      // decode register contents if possible
+      if (_verbose && _context && Universe::is_fully_initialized()) {
+        os::print_register_info(st, _context);
+        st->cr();
       }
  
!   STEP(150, "(printing current compile task)" )
!   STEP(260, "(printing registers, top of stack, instructions near pc)")
  
       if (_verbose && _thread && _thread->is_Compiler_thread()) {
          CompilerThread* t = (CompilerThread*)_thread;
          if (t->task()) {
+      // registers, top of stack, instructions near pc
+      if (_verbose && _context) {
+        os::print_context(st, _context);
+        st->cr();
+      }
+ 
+   STEP(270, "(printing VM operation)" )
+ 
+      if (_verbose && _thread && _thread->is_VM_thread()) {
+         VMThread* t = (VMThread*)_thread;
+         VM_Operation* op = t->vm_operation();
+         if (op) {
+           op->print_on_error(st);
            st->cr();
             st->print_cr("Current CompileTask:");
             t->task()->print_line_on_error(st, buf, sizeof(buf));
            st->cr();
          }
       }
  
!   STEP(160, "(printing process)" )
!   STEP(280, "(printing process)" )
  
       if (_verbose) {
         st->cr();
         st->print_cr("---------------  P R O C E S S  ---------------");
         st->cr();
       }
  
!   STEP(170, "(printing all threads)" )
!   STEP(290, "(printing all threads)" )
  
       // all threads
       if (_verbose && _thread) {
         Threads::print_on_error(st, _thread, buf, sizeof(buf));
         st->cr();
       }
  
!   STEP(175, "(printing VM state)" )
!   STEP(300, "(printing VM state)" )
  
       if (_verbose) {
         // Safepoint state
         st->print("VM state:");
  

*** 705,857 ****
--- 752,896 ----
         }
         st->cr();
         st->cr();
       }
  
!   STEP(180, "(printing owned locks on error)" )
!   STEP(310, "(printing owned locks on error)" )
  
       // mutexes/monitors that currently have an owner
       if (_verbose) {
         print_owned_locks_on_error(st);
         st->cr();
       }
  
!   STEP(182, "(printing number of OutOfMemoryError and StackOverflow exceptions)")
!   STEP(320, "(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(185, "(printing compressed oops mode")
!   STEP(330, "(printing compressed oops mode")
  
       if (_verbose && UseCompressedOops) {
         Universe::print_compressed_oops_mode(st);
         if (UseCompressedClassPointers) {
           Metaspace::print_compressed_class_space(st);
         }
         st->cr();
       }
  
!   STEP(190, "(printing heap information)" )
!   STEP(340, "(printing heap information)" )
  
       if (_verbose && Universe::is_fully_initialized()) {
         Universe::heap()->print_on_error(st);
         st->cr();
  
         st->print_cr("Polling page: " INTPTR_FORMAT, os::get_polling_page());
         st->cr();
       }
  
!   STEP(195, "(printing code cache information)" )
!   STEP(350, "(printing code cache information)" )
  
       if (_verbose && Universe::is_fully_initialized()) {
         // print code cache information before vm abort
         CodeCache::print_summary(st);
         st->cr();
       }
  
!   STEP(200, "(printing ring buffers)" )
!   STEP(360, "(printing ring buffers)" )
  
       if (_verbose) {
         Events::print_all(st);
         st->cr();
       }
  
!   STEP(205, "(printing dynamic libraries)" )
!   STEP(370, "(printing dynamic libraries)" )
  
       if (_verbose) {
         // dynamic libraries, or memory map
         os::print_dll_info(st);
         st->cr();
       }
  
!   STEP(210, "(printing VM options)" )
!   STEP(380, "(printing VM options)" )
  
       if (_verbose) {
         // VM options
         Arguments::print_on(st);
         st->cr();
       }
    
    STEP(215, "(printing warning if internal testing API used)" )
+ 
+   STEP(390, "(printing warning if internal testing API used)" )
  
       if (WhiteBox::used()) {
         st->print_cr("Unsupported internal testing APIs have been used.");
         st->cr();
       }
  
!   STEP(220, "(printing environment variables)" )
!   STEP(400, "(printing all environment variables)" )
  
       if (_verbose) {
         os::print_environment_variables(st, env_list);
         st->cr();
       }
  
!   STEP(225, "(printing signal handlers)" )
!   STEP(410, "(printing signal handlers)" )
  
       if (_verbose) {
         os::print_signal_handlers(st, buf, sizeof(buf));
         st->cr();
       }
  
!   STEP(228, "(Native Memory Tracking)" )
!   STEP(420, "(Native Memory Tracking)" )
       if (_verbose) {
         MemTracker::error_report(st);
       }
  
!   STEP(230, "" )
!   STEP(430, "(printing system)" )
  
       if (_verbose) {
         st->cr();
         st->print_cr("---------------  S Y S T E M  ---------------");
         st->cr();
       }
  
!   STEP(240, "(printing OS information)" )
!   STEP(440, "(printing OS information)" )
  
       if (_verbose) {
         os::print_os_info(st);
         st->cr();
       }
  
!   STEP(250, "(printing CPU info)" )
!   STEP(450, "(printing CPU info)" )
       if (_verbose) {
         os::print_cpu_info(st, buf, sizeof(buf));
         st->cr();
       }
  
!   STEP(260, "(printing memory info)" )
!   STEP(460, "(printing memory info)" )
  
       if (_verbose) {
         os::print_memory_info(st);
         st->cr();
       }
  
!   STEP(270, "(printing internal vm info)" )
!   STEP(470, "(printing internal vm info)" )
  
       if (_verbose) {
         st->print_cr("vm_info: %s", Abstract_VM_Version::internal_vm_info_string());
         st->cr();
       }
  
    STEP(280, "(printing date and time)" )
  
       if (_verbose) {
         os::print_date_and_time(st, buf, sizeof(buf));
         st->cr();
       }
  
  #ifndef PRODUCT
    // print a defined marker to show that error handling finished correctly.
!   STEP(290, "(printing end marker)" )
!   STEP(480, "(printing end marker)" )
  
       if (_verbose) {
         st->print_cr("END.");
       }
  #endif
  
    END
  
  # undef BEGIN
  # undef STEP