1 /*
   2  * Copyright (c) 1997, 2015, Oracle and/or its affiliates. All rights reserved.
   3  * Copyright 2012, 2015 SAP AG. All rights reserved.
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * This code is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License version 2 only, as
   8  * published by the Free Software Foundation.
   9  *
  10  * This code is distributed in the hope that it will be useful, but WITHOUT
  11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  13  * version 2 for more details (a copy is included in the LICENSE file hat
  14  * accompanied this code).
  15  *
  16  * You should have received a copy of the GNU General Public License version
  17  * 2 along with this work; if not, write to the Free Software Foundation,
  18  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  19  *
  20  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  21  * or visit www.oracle.com if you need additional information or have any
  22  * questions.
  23  *
  24  */
  25 
  26 // no precompiled headers
  27 #include "assembler_ppc.inline.hpp"
  28 #include "classfile/classLoader.hpp"
  29 #include "classfile/systemDictionary.hpp"
  30 #include "classfile/vmSymbols.hpp"
  31 #include "code/icBuffer.hpp"
  32 #include "code/vtableStubs.hpp"
  33 #include "interpreter/interpreter.hpp"
  34 #include "jvm_linux.h"
  35 #include "memory/allocation.inline.hpp"
  36 #include "mutex_linux.inline.hpp"
  37 #include "nativeInst_ppc.hpp"
  38 #include "os_share_linux.hpp"
  39 #include "prims/jniFastGetField.hpp"
  40 #include "prims/jvm.h"
  41 #include "prims/jvm_misc.hpp"
  42 #include "runtime/arguments.hpp"
  43 #include "runtime/extendedPC.hpp"
  44 #include "runtime/frame.inline.hpp"
  45 #include "runtime/interfaceSupport.hpp"
  46 #include "runtime/java.hpp"
  47 #include "runtime/javaCalls.hpp"
  48 #include "runtime/mutexLocker.hpp"
  49 #include "runtime/osThread.hpp"
  50 #include "runtime/sharedRuntime.hpp"
  51 #include "runtime/stubRoutines.hpp"
  52 #include "runtime/thread.inline.hpp"
  53 #include "runtime/timer.hpp"
  54 #include "utilities/events.hpp"
  55 #include "utilities/vmError.hpp"
  56 
  57 // put OS-includes here
  58 # include <sys/types.h>
  59 # include <sys/mman.h>
  60 # include <pthread.h>
  61 # include <signal.h>
  62 # include <errno.h>
  63 # include <dlfcn.h>
  64 # include <stdlib.h>
  65 # include <stdio.h>
  66 # include <unistd.h>
  67 # include <sys/resource.h>
  68 # include <pthread.h>
  69 # include <sys/stat.h>
  70 # include <sys/time.h>
  71 # include <sys/utsname.h>
  72 # include <sys/socket.h>
  73 # include <sys/wait.h>
  74 # include <pwd.h>
  75 # include <poll.h>
  76 # include <ucontext.h>
  77 
  78 
  79 address os::current_stack_pointer() {
  80   intptr_t* csp;
  81 
  82   // inline assembly `mr regno(csp), R1_SP':
  83   __asm__ __volatile__ ("mr %0, 1":"=r"(csp):);
  84 
  85   return (address) csp;
  86 }
  87 
  88 char* os::non_memory_address_word() {
  89   // Must never look like an address returned by reserve_memory,
  90   // even in its subfields (as defined by the CPU immediate fields,
  91   // if the CPU splits constants across multiple instructions).
  92 
  93   return (char*) -1;
  94 }
  95 
  96 void os::initialize_thread(Thread *thread) { }
  97 
  98 // Frame information (pc, sp, fp) retrieved via ucontext
  99 // always looks like a C-frame according to the frame
 100 // conventions in frame_ppc64.hpp.
 101 address os::Linux::ucontext_get_pc(ucontext_t * uc) {
 102   // On powerpc64, ucontext_t is not selfcontained but contains
 103   // a pointer to an optional substructure (mcontext_t.regs) containing the volatile
 104   // registers - NIP, among others.
 105   // This substructure may or may not be there depending where uc came from:
 106   // - if uc was handed over as the argument to a sigaction handler, a pointer to the
 107   //   substructure was provided by the kernel when calling the signal handler, and
 108   //   regs->nip can be accessed.
 109   // - if uc was filled by getcontext(), it is undefined - getcontext() does not fill
 110   //   it because the volatile registers are not needed to make setcontext() work.
 111   //   Hopefully it was zero'd out beforehand.
 112   guarantee(uc->uc_mcontext.regs != NULL, "only use ucontext_get_pc in sigaction context");
 113   return (address)uc->uc_mcontext.regs->nip;
 114 }
 115 
 116 intptr_t* os::Linux::ucontext_get_sp(ucontext_t * uc) {
 117   return (intptr_t*)uc->uc_mcontext.regs->gpr[1/*REG_SP*/];
 118 }
 119 
 120 intptr_t* os::Linux::ucontext_get_fp(ucontext_t * uc) {
 121   return NULL;
 122 }
 123 
 124 ExtendedPC os::fetch_frame_from_context(void* ucVoid,
 125                     intptr_t** ret_sp, intptr_t** ret_fp) {
 126 
 127   ExtendedPC  epc;
 128   ucontext_t* uc = (ucontext_t*)ucVoid;
 129 
 130   if (uc != NULL) {
 131     epc = ExtendedPC(os::Linux::ucontext_get_pc(uc));
 132     if (ret_sp) *ret_sp = os::Linux::ucontext_get_sp(uc);
 133     if (ret_fp) *ret_fp = os::Linux::ucontext_get_fp(uc);
 134   } else {
 135     // construct empty ExtendedPC for return value checking
 136     epc = ExtendedPC(NULL);
 137     if (ret_sp) *ret_sp = (intptr_t *)NULL;
 138     if (ret_fp) *ret_fp = (intptr_t *)NULL;
 139   }
 140 
 141   return epc;
 142 }
 143 
 144 frame os::fetch_frame_from_context(void* ucVoid) {
 145   intptr_t* sp;
 146   intptr_t* fp;
 147   ExtendedPC epc = fetch_frame_from_context(ucVoid, &sp, &fp);
 148   return frame(sp, epc.pc());
 149 }
 150 
 151 frame os::get_sender_for_C_frame(frame* fr) {
 152   if (*fr->sp() == 0) {
 153     // fr is the last C frame
 154     return frame(NULL, NULL);
 155   }
 156   return frame(fr->sender_sp(), fr->sender_pc());
 157 }
 158 
 159 
 160 frame os::current_frame() {
 161   intptr_t* csp = (intptr_t*) *((intptr_t*) os::current_stack_pointer());
 162   // hack.
 163   frame topframe(csp, (address)0x8);
 164   // return sender of current topframe which hopefully has pc != NULL.
 165   return os::get_sender_for_C_frame(&topframe);
 166 }
 167 
 168 // Utility functions
 169 
 170 extern "C" JNIEXPORT int
 171 JVM_handle_linux_signal(int sig,
 172                         siginfo_t* info,
 173                         void* ucVoid,
 174                         int abort_if_unrecognized) {
 175   ucontext_t* uc = (ucontext_t*) ucVoid;
 176 
 177   Thread* t = ThreadLocalStorage::get_thread_slow();
 178 
 179   SignalHandlerMark shm(t);
 180 
 181   // Note: it's not uncommon that JNI code uses signal/sigset to install
 182   // then restore certain signal handler (e.g. to temporarily block SIGPIPE,
 183   // or have a SIGILL handler when detecting CPU type). When that happens,
 184   // JVM_handle_linux_signal() might be invoked with junk info/ucVoid. To
 185   // avoid unnecessary crash when libjsig is not preloaded, try handle signals
 186   // that do not require siginfo/ucontext first.
 187 
 188   if (sig == SIGPIPE) {
 189     if (os::Linux::chained_handler(sig, info, ucVoid)) {
 190       return true;
 191     } else {
 192       if (PrintMiscellaneous && (WizardMode || Verbose)) {
 193         warning("Ignoring SIGPIPE - see bug 4229104");
 194       }
 195       return true;
 196     }
 197   }
 198 
 199   JavaThread* thread = NULL;
 200   VMThread* vmthread = NULL;
 201   if (os::Linux::signal_handlers_are_installed) {
 202     if (t != NULL) {
 203       if(t->is_Java_thread()) {
 204         thread = (JavaThread*)t;
 205       } else if(t->is_VM_thread()) {
 206         vmthread = (VMThread *)t;
 207       }
 208     }
 209   }
 210 
 211   // Moved SafeFetch32 handling outside thread!=NULL conditional block to make
 212   // it work if no associated JavaThread object exists.
 213   if (uc) {
 214     address const pc = os::Linux::ucontext_get_pc(uc);
 215     if (pc && StubRoutines::is_safefetch_fault(pc)) {
 216       uc->uc_mcontext.regs->nip = (unsigned long)StubRoutines::continuation_for_safefetch_fault(pc);
 217       return true;
 218     }
 219   }
 220 
 221   // decide if this trap can be handled by a stub
 222   address stub = NULL;
 223   address pc   = NULL;
 224 
 225   //%note os_trap_1
 226   if (info != NULL && uc != NULL && thread != NULL) {
 227     pc = (address) os::Linux::ucontext_get_pc(uc);
 228 
 229     // Handle ALL stack overflow variations here
 230     if (sig == SIGSEGV) {
 231       // Si_addr may not be valid due to a bug in the linux-ppc64 kernel (see
 232       // comment below). Use get_stack_bang_address instead of si_addr.
 233       address addr = ((NativeInstruction*)pc)->get_stack_bang_address(uc);
 234 
 235       // Check if fault address is within thread stack.
 236       if (addr < thread->stack_base() &&
 237           addr >= thread->stack_base() - thread->stack_size()) {
 238         // stack overflow
 239         if (thread->in_stack_yellow_zone(addr)) {
 240           thread->disable_stack_yellow_zone();
 241           if (thread->thread_state() == _thread_in_Java) {
 242             // Throw a stack overflow exception.
 243             // Guard pages will be reenabled while unwinding the stack.
 244             stub = SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW);
 245           } else {
 246             // Thread was in the vm or native code. Return and try to finish.
 247             return 1;
 248           }
 249         } else if (thread->in_stack_red_zone(addr)) {
 250           // Fatal red zone violation.  Disable the guard pages and fall through
 251           // to handle_unexpected_exception way down below.
 252           thread->disable_stack_red_zone();
 253           tty->print_raw_cr("An irrecoverable stack overflow has occurred.");
 254 
 255           // This is a likely cause, but hard to verify. Let's just print
 256           // it as a hint.
 257           tty->print_raw_cr("Please check if any of your loaded .so files has "
 258                             "enabled executable stack (see man page execstack(8))");
 259         } else {
 260           // Accessing stack address below sp may cause SEGV if current
 261           // thread has MAP_GROWSDOWN stack. This should only happen when
 262           // current thread was created by user code with MAP_GROWSDOWN flag
 263           // and then attached to VM. See notes in os_linux.cpp.
 264           if (thread->osthread()->expanding_stack() == 0) {
 265              thread->osthread()->set_expanding_stack();
 266              if (os::Linux::manually_expand_stack(thread, addr)) {
 267                thread->osthread()->clear_expanding_stack();
 268                return 1;
 269              }
 270              thread->osthread()->clear_expanding_stack();
 271           } else {
 272              fatal("recursive segv. expanding stack.");
 273           }
 274         }
 275       }
 276     }
 277 
 278     if (thread->thread_state() == _thread_in_Java) {
 279       // Java thread running in Java code => find exception handler if any
 280       // a fault inside compiled code, the interpreter, or a stub
 281 
 282       // A VM-related SIGILL may only occur if we are not in the zero page.
 283       // On AIX, we get a SIGILL if we jump to 0x0 or to somewhere else
 284       // in the zero page, because it is filled with 0x0. We ignore
 285       // explicit SIGILLs in the zero page.
 286       if (sig == SIGILL && (pc < (address) 0x200)) {
 287         if (TraceTraps) {
 288           tty->print_raw_cr("SIGILL happened inside zero page.");
 289         }
 290         goto report_and_die;
 291       }
 292 
 293       CodeBlob *cb = NULL;
 294       // Handle signal from NativeJump::patch_verified_entry().
 295       if (( TrapBasedNotEntrantChecks && sig == SIGTRAP && nativeInstruction_at(pc)->is_sigtrap_zombie_not_entrant()) ||
 296           (!TrapBasedNotEntrantChecks && sig == SIGILL  && nativeInstruction_at(pc)->is_sigill_zombie_not_entrant())) {
 297         if (TraceTraps) {
 298           tty->print_cr("trap: zombie_not_entrant (%s)", (sig == SIGTRAP) ? "SIGTRAP" : "SIGILL");
 299         }
 300         stub = SharedRuntime::get_handle_wrong_method_stub();
 301       }
 302 
 303       else if (sig == SIGSEGV &&
 304                // A linux-ppc64 kernel before 2.6.6 doesn't set si_addr on some segfaults
 305                // in 64bit mode (cf. http://www.kernel.org/pub/linux/kernel/v2.6/ChangeLog-2.6.6),
 306                // especially when we try to read from the safepoint polling page. So the check
 307                //   (address)info->si_addr == os::get_standard_polling_page()
 308                // doesn't work for us. We use:
 309                ((NativeInstruction*)pc)->is_safepoint_poll() &&
 310                CodeCache::contains((void*) pc) &&
 311                ((cb = CodeCache::find_blob(pc)) != NULL) &&
 312                cb->is_nmethod()) {
 313         if (TraceTraps) {
 314           tty->print_cr("trap: safepoint_poll at " INTPTR_FORMAT " (SIGSEGV)", p2i(pc));
 315         }
 316         stub = SharedRuntime::get_poll_stub(pc);
 317       }
 318 
 319       // SIGTRAP-based ic miss check in compiled code.
 320       else if (sig == SIGTRAP && TrapBasedICMissChecks &&
 321                nativeInstruction_at(pc)->is_sigtrap_ic_miss_check()) {
 322         if (TraceTraps) {
 323           tty->print_cr("trap: ic_miss_check at " INTPTR_FORMAT " (SIGTRAP)", p2i(pc));
 324         }
 325         stub = SharedRuntime::get_ic_miss_stub();
 326       }
 327 
 328       // SIGTRAP-based implicit null check in compiled code.
 329       else if (sig == SIGTRAP && TrapBasedNullChecks &&
 330                nativeInstruction_at(pc)->is_sigtrap_null_check()) {
 331         if (TraceTraps) {
 332           tty->print_cr("trap: null_check at " INTPTR_FORMAT " (SIGTRAP)", p2i(pc));
 333         }
 334         stub = SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::IMPLICIT_NULL);
 335       }
 336 
 337       // SIGSEGV-based implicit null check in compiled code.
 338       else if (sig == SIGSEGV && ImplicitNullChecks &&
 339                CodeCache::contains((void*) pc) &&
 340                !MacroAssembler::needs_explicit_null_check((intptr_t) info->si_addr)) {
 341         if (TraceTraps) {
 342           tty->print_cr("trap: null_check at " INTPTR_FORMAT " (SIGSEGV)", p2i(pc));
 343         }
 344         stub = SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::IMPLICIT_NULL);
 345       }
 346 
 347 #ifdef COMPILER2
 348       // SIGTRAP-based implicit range check in compiled code.
 349       else if (sig == SIGTRAP && TrapBasedRangeChecks &&
 350                nativeInstruction_at(pc)->is_sigtrap_range_check()) {
 351         if (TraceTraps) {
 352           tty->print_cr("trap: range_check at " INTPTR_FORMAT " (SIGTRAP)", p2i(pc));
 353         }
 354         stub = SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::IMPLICIT_NULL);
 355       }
 356 #endif
 357       else if (sig == SIGBUS) {
 358         // BugId 4454115: A read from a MappedByteBuffer can fault here if the
 359         // underlying file has been truncated. Do not crash the VM in such a case.
 360         CodeBlob* cb = CodeCache::find_blob_unsafe(pc);
 361         nmethod* nm = (cb != NULL && cb->is_nmethod()) ? (nmethod*)cb : NULL;
 362         if (nm != NULL && nm->has_unsafe_access()) {
 363           // We don't really need a stub here! Just set the pending exeption and
 364           // continue at the next instruction after the faulting read. Returning
 365           // garbage from this read is ok.
 366           thread->set_pending_unsafe_access_error();
 367           uc->uc_mcontext.regs->nip = ((unsigned long)pc) + 4;
 368           return true;
 369         }
 370       }
 371     }
 372 
 373     else { // thread->thread_state() != _thread_in_Java
 374       if (sig == SIGILL && VM_Version::is_determine_features_test_running()) {
 375         // SIGILL must be caused by VM_Version::determine_features().
 376         *(int *)pc = 0; // patch instruction to 0 to indicate that it causes a SIGILL,
 377                         // flushing of icache is not necessary.
 378         stub = pc + 4;  // continue with next instruction.
 379       }
 380       else if (thread->thread_state() == _thread_in_vm &&
 381                sig == SIGBUS && thread->doing_unsafe_access()) {
 382         // We don't really need a stub here! Just set the pending exeption and
 383         // continue at the next instruction after the faulting read. Returning
 384         // garbage from this read is ok.
 385         thread->set_pending_unsafe_access_error();
 386         uc->uc_mcontext.regs->nip = ((unsigned long)pc) + 4;
 387         return true;
 388       }
 389     }
 390 
 391     // Check to see if we caught the safepoint code in the
 392     // process of write protecting the memory serialization page.
 393     // It write enables the page immediately after protecting it
 394     // so we can just return to retry the write.
 395     if ((sig == SIGSEGV) &&
 396         // Si_addr may not be valid due to a bug in the linux-ppc64 kernel (see comment above).
 397         // Use is_memory_serialization instead of si_addr.
 398         ((NativeInstruction*)pc)->is_memory_serialization(thread, ucVoid)) {
 399       // Synchronization problem in the pseudo memory barrier code (bug id 6546278)
 400       // Block current thread until the memory serialize page permission restored.
 401       os::block_on_serialize_page_trap();
 402       return true;
 403     }
 404   }
 405 
 406   if (stub != NULL) {
 407     // Save all thread context in case we need to restore it.
 408     if (thread != NULL) thread->set_saved_exception_pc(pc);
 409     uc->uc_mcontext.regs->nip = (unsigned long)stub;
 410     return true;
 411   }
 412 
 413   // signal-chaining
 414   if (os::Linux::chained_handler(sig, info, ucVoid)) {
 415     return true;
 416   }
 417 
 418   if (!abort_if_unrecognized) {
 419     // caller wants another chance, so give it to him
 420     return false;
 421   }
 422 
 423   if (pc == NULL && uc != NULL) {
 424     pc = os::Linux::ucontext_get_pc(uc);
 425   }
 426 
 427 report_and_die:
 428   // unmask current signal
 429   sigset_t newset;
 430   sigemptyset(&newset);
 431   sigaddset(&newset, sig);
 432   sigprocmask(SIG_UNBLOCK, &newset, NULL);
 433 
 434   VMError err(t, sig, pc, info, ucVoid);
 435   err.report_and_die();
 436 
 437   ShouldNotReachHere();
 438   return false;
 439 }
 440 
 441 void os::Linux::init_thread_fpu_state(void) {
 442   // Disable FP exceptions.
 443   __asm__ __volatile__ ("mtfsfi 6,0");
 444 }
 445 
 446 int os::Linux::get_fpu_control_word(void) {
 447   // x86 has problems with FPU precision after pthread_cond_timedwait().
 448   // nothing to do on ppc64.
 449   return 0;
 450 }
 451 
 452 void os::Linux::set_fpu_control_word(int fpu_control) {
 453   // x86 has problems with FPU precision after pthread_cond_timedwait().
 454   // nothing to do on ppc64.
 455 }
 456 
 457 ////////////////////////////////////////////////////////////////////////////////
 458 // thread stack
 459 
 460 size_t os::Linux::min_stack_allowed = 128*K;
 461 
 462 bool os::Linux::supports_variable_stack_size() { return true; }
 463 
 464 // return default stack size for thr_type
 465 size_t os::Linux::default_stack_size(os::ThreadType thr_type) {
 466   // default stack size (compiler thread needs larger stack)
 467   // Notice that the setting for compiler threads here have no impact
 468   // because of the strange 'fallback logic' in os::create_thread().
 469   // Better set CompilerThreadStackSize in globals_<os_cpu>.hpp if you want to
 470   // specify a different stack size for compiler threads!
 471   size_t s = (thr_type == os::compiler_thread ? 4 * M : 1024 * K);
 472   return s;
 473 }
 474 
 475 size_t os::Linux::default_guard_size(os::ThreadType thr_type) {
 476   return 2 * page_size();
 477 }
 478 
 479 // Java thread:
 480 //
 481 //   Low memory addresses
 482 //    +------------------------+
 483 //    |                        |\  JavaThread created by VM does not have glibc
 484 //    |    glibc guard page    | - guard, attached Java thread usually has
 485 //    |                        |/  1 page glibc guard.
 486 // P1 +------------------------+ Thread::stack_base() - Thread::stack_size()
 487 //    |                        |\
 488 //    |  HotSpot Guard Pages   | - red and yellow pages
 489 //    |                        |/
 490 //    +------------------------+ JavaThread::stack_yellow_zone_base()
 491 //    |                        |\
 492 //    |      Normal Stack      | -
 493 //    |                        |/
 494 // P2 +------------------------+ Thread::stack_base()
 495 //
 496 // Non-Java thread:
 497 //
 498 //   Low memory addresses
 499 //    +------------------------+
 500 //    |                        |\
 501 //    |  glibc guard page      | - usually 1 page
 502 //    |                        |/
 503 // P1 +------------------------+ Thread::stack_base() - Thread::stack_size()
 504 //    |                        |\
 505 //    |      Normal Stack      | -
 506 //    |                        |/
 507 // P2 +------------------------+ Thread::stack_base()
 508 //
 509 // ** P1 (aka bottom) and size ( P2 = P1 - size) are the address and stack size returned from
 510 //    pthread_attr_getstack()
 511 
 512 static void current_stack_region(address * bottom, size_t * size) {
 513   if (os::Linux::is_initial_thread()) {
 514      // initial thread needs special handling because pthread_getattr_np()
 515      // may return bogus value.
 516     *bottom = os::Linux::initial_thread_stack_bottom();
 517     *size   = os::Linux::initial_thread_stack_size();
 518   } else {
 519     pthread_attr_t attr;
 520 
 521     int rslt = pthread_getattr_np(pthread_self(), &attr);
 522 
 523     // JVM needs to know exact stack location, abort if it fails
 524     if (rslt != 0) {
 525       if (rslt == ENOMEM) {
 526         vm_exit_out_of_memory(0, OOM_MMAP_ERROR, "pthread_getattr_np");
 527       } else {
 528         fatal(err_msg("pthread_getattr_np failed with errno = %d", rslt));
 529       }
 530     }
 531 
 532     if (pthread_attr_getstack(&attr, (void **)bottom, size) != 0) {
 533       fatal("Can not locate current stack attributes!");
 534     }
 535 
 536     pthread_attr_destroy(&attr);
 537 
 538   }
 539   assert(os::current_stack_pointer() >= *bottom &&
 540          os::current_stack_pointer() < *bottom + *size, "just checking");
 541 }
 542 
 543 address os::current_stack_base() {
 544   address bottom;
 545   size_t size;
 546   current_stack_region(&bottom, &size);
 547   return (bottom + size);
 548 }
 549 
 550 size_t os::current_stack_size() {
 551   // stack size includes normal stack and HotSpot guard pages
 552   address bottom;
 553   size_t size;
 554   current_stack_region(&bottom, &size);
 555   return size;
 556 }
 557 
 558 /////////////////////////////////////////////////////////////////////////////
 559 // helper functions for fatal error handler
 560 
 561 void os::print_context(outputStream *st, void *context) {
 562   if (context == NULL) return;
 563 
 564   ucontext_t* uc = (ucontext_t*)context;
 565 
 566   st->print_cr("Registers:");
 567   st->print("pc =" INTPTR_FORMAT "  ", uc->uc_mcontext.regs->nip);
 568   st->print("lr =" INTPTR_FORMAT "  ", uc->uc_mcontext.regs->link);
 569   st->print("ctr=" INTPTR_FORMAT "  ", uc->uc_mcontext.regs->ctr);
 570   st->cr();
 571   for (int i = 0; i < 32; i++) {
 572     st->print("r%-2d=" INTPTR_FORMAT "  ", i, uc->uc_mcontext.regs->gpr[i]);
 573     if (i % 3 == 2) st->cr();
 574   }
 575   st->cr();
 576   st->cr();
 577 
 578   intptr_t *sp = (intptr_t *)os::Linux::ucontext_get_sp(uc);
 579   st->print_cr("Top of Stack: (sp=" PTR_FORMAT ")", p2i(sp));
 580   print_hex_dump(st, (address)sp, (address)(sp + 128), sizeof(intptr_t));
 581   st->cr();
 582 
 583   // Note: it may be unsafe to inspect memory near pc. For example, pc may
 584   // point to garbage if entry point in an nmethod is corrupted. Leave
 585   // this at the end, and hope for the best.
 586   address pc = os::Linux::ucontext_get_pc(uc);
 587   st->print_cr("Instructions: (pc=" PTR_FORMAT ")", p2i(pc));
 588   print_hex_dump(st, pc - 64, pc + 64, /*instrsize=*/4);
 589   st->cr();
 590 }
 591 
 592 void os::print_register_info(outputStream *st, void *context) {
 593   if (context == NULL) return;
 594 
 595   ucontext_t *uc = (ucontext_t*)context;
 596 
 597   st->print_cr("Register to memory mapping:");
 598   st->cr();
 599 
 600   // this is only for the "general purpose" registers
 601   for (int i = 0; i < 32; i++) {
 602     st->print("r%-2d=", i);
 603     print_location(st, uc->uc_mcontext.regs->gpr[i]);
 604   }
 605   st->cr();
 606 }
 607 
 608 extern "C" {
 609   int SpinPause() {
 610     return 0;
 611   }
 612 }
 613 
 614 #ifndef PRODUCT
 615 void os::verify_stack_alignment() {
 616   assert(((intptr_t)os::current_stack_pointer() & (StackAlignmentInBytes-1)) == 0, "incorrect stack alignment");
 617 }
 618 #endif