truffle: src/share/vm/runtime/os.cpp comparison

comparison src/share/vm/runtime/os.cpp @ 14518:d8041d695d19

Merged with jdk9/dev/hotspot changeset 3812c088b945

author	twisti
date	Tue, 11 Mar 2014 18:45:59 -0700
parents	cefad50507d8 8a9bb7821e28
children	4ca6dc0799b6

comparison

equal deleted inserted replaced

-:f97c5ec83832
+:d8041d695d19
 static void signal_thread_entry(JavaThread* thread, TRAPS) {
 os::set_priority(thread, NearMaxPriority);
 while (true) {
 int sig;
 {
-// FIXME : Currently we have not decieded what should be the status
+// FIXME : Currently we have not decided what should be the status
 //         for this java thread blocked here. Once we decide about
 //         that we should fix this.
 sig = os::signal_wait();
 }
 if (sig == os::sigexitnum_pd()) {
 // JavaThread due to lack of memory. We would have to throw an exception
 // in that case. However, since this must work and we do not allow
 // exceptions anyway, check and abort if this fails.
 if (signal_thread == NULL || signal_thread->osthread() == NULL) {
 vm_exit_during_initialization("java.lang.OutOfMemoryError",
-"unable to create new native thread");
+os::native_thread_creation_failed_msg());
 }
 java_lang_Thread::set_thread(thread_oop(), signal_thread);
 java_lang_Thread::set_priority(thread_oop(), NearMaxPriority);
 java_lang_Thread::set_daemon(thread_oop());
 // look for cushion in front of prev. block
 u_char* start_of_prev_block = find_cushion_backwards(end_of_prev_block_data);
 ptrdiff_t size = *size_addr_from_base(start_of_prev_block);
 u_char* obj = start_of_prev_block + space_before;
 if (size <= 0 ) {
-// start is bad; mayhave been confused by OS data inbetween objects
+// start is bad; may have been confused by OS data in between objects
 // search one more backwards
 start_of_prev_block = find_cushion_backwards(start_of_prev_block);
 size = *size_addr_from_base(start_of_prev_block);
 obj = start_of_prev_block + space_before;
 }
 }
 if (Universe::heap()->is_in(addr)) {
 HeapWord* p = Universe::heap()->block_start(addr);
 bool print = false;
-// If we couldn't find it it just may mean that heap wasn't parseable
+// If we couldn't find it it just may mean that heap wasn't parsable
 // See if we were just given an oop directly
 if (p != NULL && Universe::heap()->block_is_obj(p)) {
 print = true;
 } else if (p == NULL && ((oopDesc*)addr)->is_oop()) {
 p = (HeapWord*) addr;
 return;
 }
 }
-#ifndef PRODUCT
 // Check if in metaspace.
 if (ClassLoaderDataGraph::contains((address)addr)) {
 // Use addr->print() from the debugger instead (not here)
 st->print_cr(INTPTR_FORMAT
 " is pointing into metadata", addr);
 return;
 }
-#endif
 // Try an OS specific find
 if (os::find(addr, st)) {
 return;
 }
 // Looks like all platforms except IA64 can use the same function to check
 // if C stack is walkable beyond current frame. The check for fp() is not
 // necessary on Sparc, but it's harmless.
 bool os::is_first_C_frame(frame* fr) {
-#if defined(IA64) && !defined(_WIN32)
+#if (defined(IA64) && !defined(AIX)) && !defined(_WIN32)
 // On IA64 we have to check if the callers bsp is still valid
 // (i.e. within the register stack bounds).
 // Notice: this only works for threads created by the VM and only if
 // we walk the current stack!!! If we want to be able to walk
 // arbitrary other threads, we'll have to somehow store the thread
 const char* home,
 int home_len,
 char fileSep,
 char pathSep) {
 assert((fileSep == '/' && pathSep == ':') ||
-(fileSep == '\\' && pathSep == ';'), "unexpected seperator chars");
+(fileSep == '\\' && pathSep == ';'), "unexpected separator chars");
 // Scan the format string to determine the length of the actual
 // boot classpath, and handle platform dependencies as well.
 int formatted_path_len = 0;
 const char* p;
 "%/lib/sunrsasign.jar:"
 "%/lib/jsse.jar:"
 "%/lib/jce.jar:"
 "%/lib/charsets.jar:"
 "%/lib/jfr.jar:"
-#ifdef __APPLE__
-"%/lib/JObjC.jar:"
-#endif
 #ifdef GRAAL
 "%/lib/graal.jar:"
 #endif
 "%/classes";
 char* sysclasspath = format_boot_path(classpath_format, home, home_len, fileSep, pathSep);
 // This is the working definition of a server class machine:
 // >= 2 physical CPU's and >=2GB of memory, with some fuzz
 // because the graphics memory (?) sometimes masks physical memory.
 // If you want to change the definition of a server class machine
-// on some OS or platform, e.g., >=4GB on Windohs platforms,
+// on some OS or platform, e.g., >=4GB on Windows platforms,
 // then you'll have to parameterize this method based on that state,
 // as was done for logical processors here, or replicate and
 // specialize this method for each platform.  (Or fix os to have
 // some inheritance structure and use subclassing.  Sigh.)
 // If you want some platform to always or never behave as a server

Mercurial > hg > truffle

comparison src/share/vm/runtime/os.cpp @ 14518:d8041d695d19