coregrind/m_sigframe/sigframe-ppc64-linux.c - platform/external/valgrind - Gitiles


 /*--------------------------------------------------------------------*/
 /*--- Create/destroy signal delivery frames.                       ---*/
 /*---                                       sigframe-ppc64-linux.c ---*/
 /*--------------------------------------------------------------------*/

 /*
    This file is part of Valgrind, a dynamic binary instrumentation
    framework.

    Copyright (C) 2000-2005 Nicholas Nethercote
       njn@valgrind.org
    Copyright (C) 2004-2005 Paul Mackerras
       paulus@samba.org

    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU General Public License as
    published by the Free Software Foundation; either version 2 of the
    License, or (at your option) any later version.

    This program is distributed in the hope that it will be useful, but
    WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
    02111-1307, USA.

    The GNU General Public License is contained in the file COPYING.
 */

 #include "pub_core_basics.h"
 #include "pub_core_threadstate.h"
 #include "pub_core_aspacemgr.h"
 #include "pub_core_libcbase.h"
 #include "pub_core_libcassert.h"
 #include "pub_core_libcprint.h"
 #include "pub_core_machine.h"
 #include "pub_core_options.h"
 #include "pub_core_sigframe.h"
 #include "pub_core_signals.h"
 #include "pub_core_tooliface.h"
 #include "pub_core_trampoline.h"
 #include "pub_core_transtab.h"      // VG_(discard_translations)
 #include "vki_unistd-ppc64-linux.h" // __NR_rt_sigreturn


 /* This module creates and removes signal frames for signal deliveries
    on ppc64-linux.

    Note, this file contains kernel-specific knowledge in the form of
    'struct sigframe' and 'struct rt_sigframe'.  How does that relate
    to the vki kernel interface stuff?

    Either a 'struct sigframe' or a 'struct rtsigframe' is pushed
    onto the client's stack.  This contains a subsidiary
    vki_ucontext.  That holds the vcpu's state across the signal,
    so that the sighandler can mess with the vcpu state if it
    really wants.

    FIXME: sigcontexting is basically broken for the moment.  When
    delivering a signal, the integer registers and %eflags are
    correctly written into the sigcontext, however the FP and SSE state
    is not.  When returning from a signal, only the integer registers
    are restored from the sigcontext; the rest of the CPU state is
    restored to what it was before the signal.

    This will be fixed.
 */


 /*------------------------------------------------------------*/
 /*--- Signal frame layouts                                 ---*/
 /*------------------------------------------------------------*/

 // A structure in which to save the application's registers
 // during the execution of signal handlers.

 // Linux has 2 signal frame structures: one for normal signal
 // deliveries, and one for SA_SIGINFO deliveries (also known as RT
 // signals).
 //
 // In theory, so long as we get the arguments to the handler function
 // right, it doesn't matter what the exact layout of the rest of the
 // frame is.  Unfortunately, things like gcc's exception unwinding
 // make assumptions about the locations of various parts of the frame,
 // so we need to duplicate it exactly.

 /* Structure containing bits of information that we want to save
    on signal delivery. */
 //zz struct vg_sig_private {
 //zz    UInt magicPI;
 //zz    UInt sigNo_private;
 //zz    VexGuestPPC32State shadow;
 //zz };
 //zz
 //zz /* Structure put on stack for signal handlers with SA_SIGINFO clear. */
 //zz struct nonrt_sigframe {
 //zz    UInt gap1[16];
 //zz    struct vki_sigcontext sigcontext;
 //zz    struct vki_mcontext mcontext;
 //zz    struct vg_sig_private priv;
 //zz    unsigned char abigap[224];
 //zz };
 //zz
 //zz /* Structure put on stack for signal handlers with SA_SIGINFO set. */
 //zz struct rt_sigframe {
 //zz    UInt gap1[20];
 //zz    vki_siginfo_t siginfo;
 //zz    struct vki_ucontext ucontext;
 //zz    struct vg_sig_private priv;
 //zz    unsigned char abigap[224];
 //zz };

 #define SET_SIGNAL_LR(zztst, zzval)                          \
    do { tst->arch.vex.guest_LR = (zzval);                    \
       VG_TRACK( post_reg_write, Vg_CoreSignal, tst->tid,     \
                 offsetof(VexGuestPPC32State,guest_LR),       \
                 sizeof(UWord) );                             \
    } while (0)

 #define SET_SIGNAL_GPR(zztst, zzn, zzval)                    \
    do { tst->arch.vex.guest_GPR##zzn = (zzval);              \
       VG_TRACK( post_reg_write, Vg_CoreSignal, tst->tid,     \
                 offsetof(VexGuestPPC32State,guest_GPR##zzn), \
                 sizeof(UWord) );                             \
    } while (0)


 static
 void stack_mcontext ( struct vki_mcontext *mc,
                       ThreadState* tst,
                       Int ret,
                       UInt fault_addr )
 {
 //   VG_TRACK( pre_mem_write, Vg_CoreSignal, tst->tid, "signal frame mcontext",
 //             (Addr)mc, sizeof(struct vki_pt_regs) );
 //
 //#  define DO(gpr)  mc->mc_gregs[VKI_PT_R0+gpr] = tst->arch.vex.guest_GPR##gpr
 //   DO(0);  DO(1);  DO(2);  DO(3);  DO(4);  DO(5);  DO(6);  DO(7);
 //   DO(8);  DO(9);  DO(10); DO(11); DO(12); DO(13); DO(14); DO(15);
 //   DO(16); DO(17); DO(18); DO(19); DO(20); DO(21); DO(22); DO(23);
 //   DO(24); DO(25); DO(26); DO(27); DO(28); DO(29); DO(30); DO(31);
 //#  undef DO
 //
 //   mc->mc_gregs[VKI_PT_NIP]     = tst->arch.vex.guest_CIA;
 //   mc->mc_gregs[VKI_PT_MSR]     = 0xf032;   /* pretty arbitrary */
 //   mc->mc_gregs[VKI_PT_ORIG_R3] = tst->arch.vex.guest_GPR3;
 //   mc->mc_gregs[VKI_PT_CTR]     = tst->arch.vex.guest_CTR;
 //   mc->mc_gregs[VKI_PT_LNK]     = tst->arch.vex.guest_LR;
 //   mc->mc_gregs[VKI_PT_XER]     = LibVEX_GuestPPC32_get_XER(&tst->arch.vex);
 //   mc->mc_gregs[VKI_PT_CCR]     = LibVEX_GuestPPC32_get_CR(&tst->arch.vex);
 //   mc->mc_gregs[VKI_PT_MQ]      = 0;
 //   mc->mc_gregs[VKI_PT_TRAP]    = 0;
 //   mc->mc_gregs[VKI_PT_DAR]     = fault_addr;
 //   mc->mc_gregs[VKI_PT_DSISR]   = 0;
 //   mc->mc_gregs[VKI_PT_RESULT]  = 0;
 //   VG_TRACK( post_mem_write, Vg_CoreSignal, tst->tid,
 //             (Addr)mc, sizeof(struct vki_pt_regs) );
 //
 //   /* XXX should do FP and vector regs */
 //
 //   /* set up signal return trampoline */
 //   VG_TRACK(pre_mem_write, Vg_CoreSignal, tst->tid, "signal frame mcontext",
 //            (Addr)&mc->mc_pad, sizeof(mc->mc_pad));
 //   mc->mc_pad[0] = 0x38000000U + ret;   /* li 0,ret */
 //   mc->mc_pad[1] = 0x44000002U;         /* sc */
 //   VG_TRACK( post_mem_write,  Vg_CoreSignal, tst->tid,
 //             (Addr)&mc->mc_pad, sizeof(mc->mc_pad) );
 //   /* invalidate any translation of this area */
 //   VG_(discard_translations)( (Addr64)(Addr)&mc->mc_pad,
 //                              sizeof(mc->mc_pad), "stack_mcontext" );
 //
 //   /* set the signal handler to return to the trampoline */
 //   SET_SIGNAL_LR(tst, (Addr) &mc->mc_pad[0]);
 }


 /* Extend the stack segment downwards if needed so as to ensure the
    new signal frames are mapped to something.  Return a Bool
    indicating whether or not the operation was successful.
 */
 static Bool extend ( ThreadState *tst, Addr addr, SizeT size )
 {
    I_die_here;
 //   ThreadId tid = tst->tid;
 //   NSegment *stackseg = NULL;
 //
 //   if (VG_(extend_stack)(addr, tst->client_stack_szB)) {
 //      stackseg = VG_(am_find_nsegment)(addr);
 //      if (0 && stackseg)
 //	 VG_(printf)("frame=%p seg=%p-%p\n",
 //		     addr, stackseg->start, stackseg->end);
 //   }
 //
 //   if (stackseg == NULL || !stackseg->hasR || !stackseg->hasW) {
 //      VG_(message)(
 //         Vg_UserMsg,
 //         "Can't extend stack to %p during signal delivery for thread %d:",
 //         addr, tid);
 //      if (stackseg == NULL)
 //         VG_(message)(Vg_UserMsg, "  no stack segment");
 //      else
 //         VG_(message)(Vg_UserMsg, "  too small or bad protection modes");
 //
 //      /* set SIGSEGV to default handler */
 //      VG_(set_default_handler)(VKI_SIGSEGV);
 //      VG_(synth_fault_mapping)(tid, addr);
 //
 //      /* The whole process should be about to die, since the default
 //	 action of SIGSEGV to kill the whole process. */
 //      return False;
 //   }
 //
 //   /* For tracking memory events, indicate the entire frame has been
 //      allocated. */
 //   VG_TRACK( new_mem_stack_signal, addr - VG_STACK_REDZONE_SZB,
 //             size + VG_STACK_REDZONE_SZB );
 //
 //   return True;
 }


 /* EXPORTED */
 void VG_(sigframe_create)( ThreadId tid,
                            Addr sp_top_of_frame,
                            const vki_siginfo_t *siginfo,
                            void *handler,
                            UInt flags,
                            const vki_sigset_t *mask,
 		           void *restorer )
 {
    I_die_here;
 //   struct vg_sig_private *priv;
 //   Addr sp;
 //   ThreadState *tst;
 //   Int sigNo = siginfo->si_signo;
 //   Addr faultaddr;
 //
 //   /* Stack must be 16-byte aligned */
 //   sp_top_of_frame &= ~0xf;
 //
 //   if (flags & VKI_SA_SIGINFO) {
 //      sp = sp_top_of_frame - sizeof(struct rt_sigframe);
 //   } else {
 //      sp = sp_top_of_frame - sizeof(struct nonrt_sigframe);
 //   }
 //
 //   tst = VG_(get_ThreadState)(tid);
 //
 //   if (!extend(tst, sp, sp_top_of_frame - sp))
 //      return;
 //
 //   vg_assert(VG_IS_16_ALIGNED(sp));
 //
 //   /* Set up the stack chain pointer */
 //   VG_TRACK( pre_mem_write, Vg_CoreSignal, tid, "signal handler frame",
 //             sp, sizeof(UWord) );
 //   *(Addr *)sp = tst->arch.vex.guest_GPR1;
 //   VG_TRACK( post_mem_write, Vg_CoreSignal, tid,
 //             sp, sizeof(UWord) );
 //
 //   faultaddr = (Addr)siginfo->_sifields._sigfault._addr;
 //   if (sigNo == VKI_SIGILL && siginfo->si_code > 0)
 //      faultaddr = tst->arch.vex.guest_CIA;
 //
 //   if (flags & VKI_SA_SIGINFO) {
 //      struct rt_sigframe *frame = (struct rt_sigframe *) sp;
 //      struct vki_ucontext *ucp = &frame->ucontext;
 //
 //      VG_TRACK( pre_mem_write, Vg_CoreSignal, tid, "signal frame siginfo",
 //                (Addr)&frame->siginfo, sizeof(frame->siginfo) );
 //      VG_(memcpy)(&frame->siginfo, siginfo, sizeof(*siginfo));
 //      VG_TRACK( post_mem_write, Vg_CoreSignal, tid,
 //                (Addr)&frame->siginfo, sizeof(frame->siginfo) );
 //
 //      VG_TRACK( pre_mem_write, Vg_CoreSignal, tid, "signal frame ucontext",
 //                (Addr)ucp, offsetof(struct vki_ucontext, uc_pad) );
 //      ucp->uc_flags = 0;
 //      ucp->uc_link = 0;
 //      ucp->uc_stack = tst->altstack;
 //      VG_TRACK( post_mem_write, Vg_CoreSignal, tid, (Addr)ucp,
 //                offsetof(struct vki_ucontext, uc_pad) );
 //
 //      VG_TRACK( pre_mem_write, Vg_CoreSignal, tid, "signal frame ucontext",
 //                (Addr)&ucp->uc_regs,
 //                sizeof(ucp->uc_regs) + sizeof(ucp->uc_sigmask) );
 //      ucp->uc_regs = &ucp->uc_mcontext;
 //      ucp->uc_sigmask = tst->sig_mask;
 //      VG_TRACK( post_mem_write, Vg_CoreSignal, tid,
 //                (Addr)&ucp->uc_regs,
 //                sizeof(ucp->uc_regs) + sizeof(ucp->uc_sigmask) );
 //
 //      stack_mcontext(&ucp->uc_mcontext, tst, __NR_rt_sigreturn, faultaddr);
 //      priv = &frame->priv;
 //
 //      SET_SIGNAL_GPR(tid, 4, (Addr) &frame->siginfo);
 //      SET_SIGNAL_GPR(tid, 5, (Addr) ucp);
 //      /* the kernel sets this, though it doesn't seem to be in the ABI */
 //      SET_SIGNAL_GPR(tid, 6, (Addr) &frame->siginfo);
 //
 //   } else {
 //      /* non-RT signal delivery */
 //      struct nonrt_sigframe *frame = (struct nonrt_sigframe *) sp;
 //      struct vki_sigcontext *scp = &frame->sigcontext;
 //
 //      VG_TRACK( pre_mem_write, Vg_CoreSignal, tid, "signal frame sigcontext",
 //                (Addr)&scp->_unused[3], sizeof(*scp) - 3 * sizeof(UInt) );
 //      scp->signal = sigNo;
 //      scp->handler = (Addr) handler;
 //      scp->oldmask = tst->sig_mask.sig[0];
 //      scp->_unused[3] = tst->sig_mask.sig[1];
 //      VG_TRACK( post_mem_write, Vg_CoreSignal, tid,
 //                (Addr)&scp->_unused[3], sizeof(*scp) - 3 * sizeof(UInt) );
 //
 //      stack_mcontext(&frame->mcontext, tst, __NR_sigreturn, faultaddr);
 //      priv = &frame->priv;
 //
 //      SET_SIGNAL_GPR(tid, 4, (Addr) scp);
 //   }
 //
 //   priv->magicPI       = 0x31415927;
 //   priv->sigNo_private = sigNo;
 //   priv->shadow        = tst->arch.vex_shadow;
 //
 //   SET_SIGNAL_GPR(tid, 1, sp);
 //   SET_SIGNAL_GPR(tid, 3, sigNo);
 //   tst->arch.vex.guest_CIA = (Addr) handler;
 //
 //   if (0)
 //      VG_(printf)("pushed signal frame; %R1 now = %p, "
 //                  "next %%CIA = %p, status=%d\n",
 //		  sp, tst->arch.vex.guest_CIA, tst->status);
 }


 /*------------------------------------------------------------*/
 /*--- Destroying signal frames                             ---*/
 /*------------------------------------------------------------*/

 /* EXPORTED */
 void VG_(sigframe_destroy)( ThreadId tid, Bool isRT )
 {
    I_die_here;
 //   ThreadState *tst;
 //   struct vg_sig_private *priv;
 //   Addr sp;
 //   UInt frame_size;
 //   struct vki_mcontext *mc;
 //   Int sigNo;
 //   Bool has_siginfo = isRT;
 //
 //   vg_assert(VG_(is_valid_tid)(tid));
 //   tst = VG_(get_ThreadState)(tid);
 //
 //   /* Check that the stack frame looks valid */
 //   sp = tst->arch.vex.guest_GPR1;
 //   vg_assert(VG_IS_16_ALIGNED(sp));
 //   /* JRS 17 Nov 05: This code used to check that *sp -- which should
 //      have been set by the stwu at the start of the handler -- points
 //      to just above the frame (ie, the previous frame).  However, that
 //      isn't valid when delivering signals on alt stacks.  So I removed
 //      it.  The frame is still sanity-checked using the priv->magicPI
 //      field. */
 //
 //   if (has_siginfo) {
 //      struct rt_sigframe *frame = (struct rt_sigframe *)sp;
 //      frame_size = sizeof(*frame);
 //      mc = &frame->ucontext.uc_mcontext;
 //      priv = &frame->priv;
 //      vg_assert(priv->magicPI == 0x31415927);
 //      tst->sig_mask = frame->ucontext.uc_sigmask;
 //   } else {
 //      struct nonrt_sigframe *frame = (struct nonrt_sigframe *)sp;
 //      frame_size = sizeof(*frame);
 //      mc = &frame->mcontext;
 //      priv = &frame->priv;
 //      vg_assert(priv->magicPI == 0x31415927);
 //      tst->sig_mask.sig[0] = frame->sigcontext.oldmask;
 //      tst->sig_mask.sig[1] = frame->sigcontext._unused[3];
 //   }
 //   tst->tmp_sig_mask = tst->sig_mask;
 //
 //   sigNo = priv->sigNo_private;
 //
 //#  define DO(gpr)  tst->arch.vex.guest_GPR##gpr = mc->mc_gregs[VKI_PT_R0+gpr]
 //   DO(0);  DO(1);  DO(2);  DO(3);  DO(4);  DO(5);  DO(6);  DO(7);
 //   DO(8);  DO(9);  DO(10); DO(11); DO(12); DO(13); DO(14); DO(15);
 //   DO(16); DO(17); DO(18); DO(19); DO(20); DO(21); DO(22); DO(23);
 //   DO(24); DO(25); DO(26); DO(27); DO(28); DO(29); DO(30); DO(31);
 //#  undef DO
 //
 //   tst->arch.vex.guest_CIA = mc->mc_gregs[VKI_PT_NIP];
 //
 //   // Umm ... ? (jrs 2005 July 8)
 //   // tst->arch.m_orig_gpr3 = mc->mc_gregs[VKI_PT_ORIG_R3];
 //
 //   LibVEX_GuestPPC32_put_CR( mc->mc_gregs[VKI_PT_CCR], &tst->arch.vex );
 //
 //   tst->arch.vex.guest_LR  = mc->mc_gregs[VKI_PT_LNK];
 //   tst->arch.vex.guest_CTR = mc->mc_gregs[VKI_PT_CTR];
 //   LibVEX_GuestPPC32_put_XER( mc->mc_gregs[VKI_PT_XER], &tst->arch.vex );
 //
 //   tst->arch.vex_shadow = priv->shadow;
 //
 //   VG_TRACK(die_mem_stack_signal, sp, frame_size);
 //
 //   if (VG_(clo_trace_signals))
 //      VG_(message)(Vg_DebugMsg,
 //                   "vg_pop_signal_frame (thread %d): isRT=%d valid magic; EIP=%p",
 //                   tid, has_siginfo, tst->arch.vex.guest_CIA);
 //
 //   /* tell the tools */
 //   VG_TRACK( post_deliver_signal, tid, sigNo );
 }

 /*--------------------------------------------------------------------*/
 /*--- end                                   sigframe-ppc64-linux.c ---*/
 /*--------------------------------------------------------------------*/

	/--------------------------------------------------------------------/
	/--- Create/destroy signal delivery frames. ---/
	/--- sigframe-ppc64-linux.c ---/
	/--------------------------------------------------------------------/

	/*
	This file is part of Valgrind, a dynamic binary instrumentation
	framework.

	Copyright (C) 2000-2005 Nicholas Nethercote
	njn@valgrind.org
	Copyright (C) 2004-2005 Paul Mackerras
	paulus@samba.org

	This program is free software; you can redistribute it and/or
	modify it under the terms of the GNU General Public License as
	published by the Free Software Foundation; either version 2 of the
	License, or (at your option) any later version.

	This program is distributed in the hope that it will be useful, but
	WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	General Public License for more details.

	You should have received a copy of the GNU General Public License
	along with this program; if not, write to the Free Software
	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
	02111-1307, USA.

	The GNU General Public License is contained in the file COPYING.
	*/

	#include "pub_core_basics.h"
	#include "pub_core_threadstate.h"
	#include "pub_core_aspacemgr.h"
	#include "pub_core_libcbase.h"
	#include "pub_core_libcassert.h"
	#include "pub_core_libcprint.h"
	#include "pub_core_machine.h"
	#include "pub_core_options.h"
	#include "pub_core_sigframe.h"
	#include "pub_core_signals.h"
	#include "pub_core_tooliface.h"
	#include "pub_core_trampoline.h"
	#include "pub_core_transtab.h" // VG_(discard_translations)
	#include "vki_unistd-ppc64-linux.h" // __NR_rt_sigreturn


	/* This module creates and removes signal frames for signal deliveries
	on ppc64-linux.

	Note, this file contains kernel-specific knowledge in the form of
	'struct sigframe' and 'struct rt_sigframe'. How does that relate
	to the vki kernel interface stuff?

	Either a 'struct sigframe' or a 'struct rtsigframe' is pushed
	onto the client's stack. This contains a subsidiary
	vki_ucontext. That holds the vcpu's state across the signal,
	so that the sighandler can mess with the vcpu state if it
	really wants.

	FIXME: sigcontexting is basically broken for the moment. When
	delivering a signal, the integer registers and %eflags are
	correctly written into the sigcontext, however the FP and SSE state
	is not. When returning from a signal, only the integer registers
	are restored from the sigcontext; the rest of the CPU state is
	restored to what it was before the signal.

	This will be fixed.
	*/


	/------------------------------------------------------------/
	/--- Signal frame layouts ---/
	/------------------------------------------------------------/

	// A structure in which to save the application's registers
	// during the execution of signal handlers.

	// Linux has 2 signal frame structures: one for normal signal
	// deliveries, and one for SA_SIGINFO deliveries (also known as RT
	// signals).
	//
	// In theory, so long as we get the arguments to the handler function
	// right, it doesn't matter what the exact layout of the rest of the
	// frame is. Unfortunately, things like gcc's exception unwinding
	// make assumptions about the locations of various parts of the frame,
	// so we need to duplicate it exactly.

	/* Structure containing bits of information that we want to save
	on signal delivery. */
	//zz struct vg_sig_private {
	//zz UInt magicPI;
	//zz UInt sigNo_private;
	//zz VexGuestPPC32State shadow;
	//zz };
	//zz
	//zz /* Structure put on stack for signal handlers with SA_SIGINFO clear. */
	//zz struct nonrt_sigframe {
	//zz UInt gap1[16];
	//zz struct vki_sigcontext sigcontext;
	//zz struct vki_mcontext mcontext;
	//zz struct vg_sig_private priv;
	//zz unsigned char abigap[224];
	//zz };
	//zz
	//zz /* Structure put on stack for signal handlers with SA_SIGINFO set. */
	//zz struct rt_sigframe {
	//zz UInt gap1[20];
	//zz vki_siginfo_t siginfo;
	//zz struct vki_ucontext ucontext;
	//zz struct vg_sig_private priv;
	//zz unsigned char abigap[224];
	//zz };

	#define SET_SIGNAL_LR(zztst, zzval) \
	do { tst->arch.vex.guest_LR = (zzval); \
	VG_TRACK( post_reg_write, Vg_CoreSignal, tst->tid, \
	offsetof(VexGuestPPC32State,guest_LR), \
	sizeof(UWord) ); \
	} while (0)

	#define SET_SIGNAL_GPR(zztst, zzn, zzval) \
	do { tst->arch.vex.guest_GPR##zzn = (zzval); \
	VG_TRACK( post_reg_write, Vg_CoreSignal, tst->tid, \
	offsetof(VexGuestPPC32State,guest_GPR##zzn), \
	sizeof(UWord) ); \
	} while (0)


	static
	void stack_mcontext ( struct vki_mcontext *mc,
	ThreadState* tst,
	Int ret,
	UInt fault_addr )
	{
	// VG_TRACK( pre_mem_write, Vg_CoreSignal, tst->tid, "signal frame mcontext",
	// (Addr)mc, sizeof(struct vki_pt_regs) );
	//
	//# define DO(gpr) mc->mc_gregs[VKI_PT_R0+gpr] = tst->arch.vex.guest_GPR##gpr
	// DO(0); DO(1); DO(2); DO(3); DO(4); DO(5); DO(6); DO(7);
	// DO(8); DO(9); DO(10); DO(11); DO(12); DO(13); DO(14); DO(15);
	// DO(16); DO(17); DO(18); DO(19); DO(20); DO(21); DO(22); DO(23);
	// DO(24); DO(25); DO(26); DO(27); DO(28); DO(29); DO(30); DO(31);
	//# undef DO
	//
	// mc->mc_gregs[VKI_PT_NIP] = tst->arch.vex.guest_CIA;
	// mc->mc_gregs[VKI_PT_MSR] = 0xf032; /* pretty arbitrary */
	// mc->mc_gregs[VKI_PT_ORIG_R3] = tst->arch.vex.guest_GPR3;
	// mc->mc_gregs[VKI_PT_CTR] = tst->arch.vex.guest_CTR;
	// mc->mc_gregs[VKI_PT_LNK] = tst->arch.vex.guest_LR;
	// mc->mc_gregs[VKI_PT_XER] = LibVEX_GuestPPC32_get_XER(&tst->arch.vex);
	// mc->mc_gregs[VKI_PT_CCR] = LibVEX_GuestPPC32_get_CR(&tst->arch.vex);
	// mc->mc_gregs[VKI_PT_MQ] = 0;
	// mc->mc_gregs[VKI_PT_TRAP] = 0;
	// mc->mc_gregs[VKI_PT_DAR] = fault_addr;
	// mc->mc_gregs[VKI_PT_DSISR] = 0;
	// mc->mc_gregs[VKI_PT_RESULT] = 0;
	// VG_TRACK( post_mem_write, Vg_CoreSignal, tst->tid,
	// (Addr)mc, sizeof(struct vki_pt_regs) );
	//
	// /* XXX should do FP and vector regs */
	//
	// /* set up signal return trampoline */
	// VG_TRACK(pre_mem_write, Vg_CoreSignal, tst->tid, "signal frame mcontext",
	// (Addr)&mc->mc_pad, sizeof(mc->mc_pad));
	// mc->mc_pad[0] = 0x38000000U + ret; /* li 0,ret */
	// mc->mc_pad[1] = 0x44000002U; /* sc */
	// VG_TRACK( post_mem_write, Vg_CoreSignal, tst->tid,
	// (Addr)&mc->mc_pad, sizeof(mc->mc_pad) );
	// /* invalidate any translation of this area */
	// VG_(discard_translations)( (Addr64)(Addr)&mc->mc_pad,
	// sizeof(mc->mc_pad), "stack_mcontext" );
	//
	// /* set the signal handler to return to the trampoline */
	// SET_SIGNAL_LR(tst, (Addr) &mc->mc_pad[0]);
	}


	/* Extend the stack segment downwards if needed so as to ensure the
	new signal frames are mapped to something. Return a Bool
	indicating whether or not the operation was successful.
	*/
	static Bool extend ( ThreadState *tst, Addr addr, SizeT size )
	{
	I_die_here;
	// ThreadId tid = tst->tid;
	// NSegment *stackseg = NULL;
	//
	// if (VG_(extend_stack)(addr, tst->client_stack_szB)) {
	// stackseg = VG_(am_find_nsegment)(addr);
	// if (0 && stackseg)
	// VG_(printf)("frame=%p seg=%p-%p\n",
	// addr, stackseg->start, stackseg->end);
	// }
	//
	// if (stackseg == NULL \|\| !stackseg->hasR \|\| !stackseg->hasW) {
	// VG_(message)(
	// Vg_UserMsg,
	// "Can't extend stack to %p during signal delivery for thread %d:",
	// addr, tid);
	// if (stackseg == NULL)
	// VG_(message)(Vg_UserMsg, " no stack segment");
	// else
	// VG_(message)(Vg_UserMsg, " too small or bad protection modes");
	//
	// /* set SIGSEGV to default handler */
	// VG_(set_default_handler)(VKI_SIGSEGV);
	// VG_(synth_fault_mapping)(tid, addr);
	//
	// /* The whole process should be about to die, since the default
	// action of SIGSEGV to kill the whole process. */
	// return False;
	// }
	//
	// /* For tracking memory events, indicate the entire frame has been
	// allocated. */
	// VG_TRACK( new_mem_stack_signal, addr - VG_STACK_REDZONE_SZB,
	// size + VG_STACK_REDZONE_SZB );
	//
	// return True;
	}


	/* EXPORTED */
	void VG_(sigframe_create)( ThreadId tid,
	Addr sp_top_of_frame,
	const vki_siginfo_t *siginfo,
	void *handler,
	UInt flags,
	const vki_sigset_t *mask,
	void *restorer )
	{
	I_die_here;
	// struct vg_sig_private *priv;
	// Addr sp;
	// ThreadState *tst;
	// Int sigNo = siginfo->si_signo;
	// Addr faultaddr;
	//
	// /* Stack must be 16-byte aligned */
	// sp_top_of_frame &= ~0xf;
	//
	// if (flags & VKI_SA_SIGINFO) {
	// sp = sp_top_of_frame - sizeof(struct rt_sigframe);
	// } else {
	// sp = sp_top_of_frame - sizeof(struct nonrt_sigframe);
	// }
	//
	// tst = VG_(get_ThreadState)(tid);
	//
	// if (!extend(tst, sp, sp_top_of_frame - sp))
	// return;
	//
	// vg_assert(VG_IS_16_ALIGNED(sp));
	//
	// /* Set up the stack chain pointer */
	// VG_TRACK( pre_mem_write, Vg_CoreSignal, tid, "signal handler frame",
	// sp, sizeof(UWord) );
	// (Addr )sp = tst->arch.vex.guest_GPR1;
	// VG_TRACK( post_mem_write, Vg_CoreSignal, tid,
	// sp, sizeof(UWord) );
	//
	// faultaddr = (Addr)siginfo->_sifields._sigfault._addr;
	// if (sigNo == VKI_SIGILL && siginfo->si_code > 0)
	// faultaddr = tst->arch.vex.guest_CIA;
	//
	// if (flags & VKI_SA_SIGINFO) {
	// struct rt_sigframe frame = (struct rt_sigframe ) sp;
	// struct vki_ucontext *ucp = &frame->ucontext;
	//
	// VG_TRACK( pre_mem_write, Vg_CoreSignal, tid, "signal frame siginfo",
	// (Addr)&frame->siginfo, sizeof(frame->siginfo) );
	// VG_(memcpy)(&frame->siginfo, siginfo, sizeof(*siginfo));
	// VG_TRACK( post_mem_write, Vg_CoreSignal, tid,
	// (Addr)&frame->siginfo, sizeof(frame->siginfo) );
	//
	// VG_TRACK( pre_mem_write, Vg_CoreSignal, tid, "signal frame ucontext",
	// (Addr)ucp, offsetof(struct vki_ucontext, uc_pad) );
	// ucp->uc_flags = 0;
	// ucp->uc_link = 0;
	// ucp->uc_stack = tst->altstack;
	// VG_TRACK( post_mem_write, Vg_CoreSignal, tid, (Addr)ucp,
	// offsetof(struct vki_ucontext, uc_pad) );
	//
	// VG_TRACK( pre_mem_write, Vg_CoreSignal, tid, "signal frame ucontext",
	// (Addr)&ucp->uc_regs,
	// sizeof(ucp->uc_regs) + sizeof(ucp->uc_sigmask) );
	// ucp->uc_regs = &ucp->uc_mcontext;
	// ucp->uc_sigmask = tst->sig_mask;
	// VG_TRACK( post_mem_write, Vg_CoreSignal, tid,
	// (Addr)&ucp->uc_regs,
	// sizeof(ucp->uc_regs) + sizeof(ucp->uc_sigmask) );
	//
	// stack_mcontext(&ucp->uc_mcontext, tst, __NR_rt_sigreturn, faultaddr);
	// priv = &frame->priv;
	//
	// SET_SIGNAL_GPR(tid, 4, (Addr) &frame->siginfo);
	// SET_SIGNAL_GPR(tid, 5, (Addr) ucp);
	// /* the kernel sets this, though it doesn't seem to be in the ABI */
	// SET_SIGNAL_GPR(tid, 6, (Addr) &frame->siginfo);
	//
	// } else {
	// /* non-RT signal delivery */
	// struct nonrt_sigframe frame = (struct nonrt_sigframe ) sp;
	// struct vki_sigcontext *scp = &frame->sigcontext;
	//
	// VG_TRACK( pre_mem_write, Vg_CoreSignal, tid, "signal frame sigcontext",
	// (Addr)&scp->_unused[3], sizeof(scp) - 3 sizeof(UInt) );
	// scp->signal = sigNo;
	// scp->handler = (Addr) handler;
	// scp->oldmask = tst->sig_mask.sig[0];
	// scp->_unused[3] = tst->sig_mask.sig[1];
	// VG_TRACK( post_mem_write, Vg_CoreSignal, tid,
	// (Addr)&scp->_unused[3], sizeof(scp) - 3 sizeof(UInt) );
	//
	// stack_mcontext(&frame->mcontext, tst, __NR_sigreturn, faultaddr);
	// priv = &frame->priv;
	//
	// SET_SIGNAL_GPR(tid, 4, (Addr) scp);
	// }
	//
	// priv->magicPI = 0x31415927;
	// priv->sigNo_private = sigNo;
	// priv->shadow = tst->arch.vex_shadow;
	//
	// SET_SIGNAL_GPR(tid, 1, sp);
	// SET_SIGNAL_GPR(tid, 3, sigNo);
	// tst->arch.vex.guest_CIA = (Addr) handler;
	//
	// if (0)
	// VG_(printf)("pushed signal frame; %R1 now = %p, "
	// "next %%CIA = %p, status=%d\n",
	// sp, tst->arch.vex.guest_CIA, tst->status);
	}


	/------------------------------------------------------------/
	/--- Destroying signal frames ---/
	/------------------------------------------------------------/

	/* EXPORTED */
	void VG_(sigframe_destroy)( ThreadId tid, Bool isRT )
	{
	I_die_here;
	// ThreadState *tst;
	// struct vg_sig_private *priv;
	// Addr sp;
	// UInt frame_size;
	// struct vki_mcontext *mc;
	// Int sigNo;
	// Bool has_siginfo = isRT;
	//
	// vg_assert(VG_(is_valid_tid)(tid));
	// tst = VG_(get_ThreadState)(tid);
	//
	// /* Check that the stack frame looks valid */
	// sp = tst->arch.vex.guest_GPR1;
	// vg_assert(VG_IS_16_ALIGNED(sp));
	// /* JRS 17 Nov 05: This code used to check that *sp -- which should
	// have been set by the stwu at the start of the handler -- points
	// to just above the frame (ie, the previous frame). However, that
	// isn't valid when delivering signals on alt stacks. So I removed
	// it. The frame is still sanity-checked using the priv->magicPI
	// field. */
	//
	// if (has_siginfo) {
	// struct rt_sigframe frame = (struct rt_sigframe )sp;
	// frame_size = sizeof(*frame);
	// mc = &frame->ucontext.uc_mcontext;
	// priv = &frame->priv;
	// vg_assert(priv->magicPI == 0x31415927);
	// tst->sig_mask = frame->ucontext.uc_sigmask;
	// } else {
	// struct nonrt_sigframe frame = (struct nonrt_sigframe )sp;
	// frame_size = sizeof(*frame);
	// mc = &frame->mcontext;
	// priv = &frame->priv;
	// vg_assert(priv->magicPI == 0x31415927);
	// tst->sig_mask.sig[0] = frame->sigcontext.oldmask;
	// tst->sig_mask.sig[1] = frame->sigcontext._unused[3];
	// }
	// tst->tmp_sig_mask = tst->sig_mask;
	//
	// sigNo = priv->sigNo_private;
	//
	//# define DO(gpr) tst->arch.vex.guest_GPR##gpr = mc->mc_gregs[VKI_PT_R0+gpr]
	// DO(0); DO(1); DO(2); DO(3); DO(4); DO(5); DO(6); DO(7);
	// DO(8); DO(9); DO(10); DO(11); DO(12); DO(13); DO(14); DO(15);
	// DO(16); DO(17); DO(18); DO(19); DO(20); DO(21); DO(22); DO(23);
	// DO(24); DO(25); DO(26); DO(27); DO(28); DO(29); DO(30); DO(31);
	//# undef DO
	//
	// tst->arch.vex.guest_CIA = mc->mc_gregs[VKI_PT_NIP];
	//
	// // Umm ... ? (jrs 2005 July 8)
	// // tst->arch.m_orig_gpr3 = mc->mc_gregs[VKI_PT_ORIG_R3];
	//
	// LibVEX_GuestPPC32_put_CR( mc->mc_gregs[VKI_PT_CCR], &tst->arch.vex );
	//
	// tst->arch.vex.guest_LR = mc->mc_gregs[VKI_PT_LNK];
	// tst->arch.vex.guest_CTR = mc->mc_gregs[VKI_PT_CTR];
	// LibVEX_GuestPPC32_put_XER( mc->mc_gregs[VKI_PT_XER], &tst->arch.vex );
	//
	// tst->arch.vex_shadow = priv->shadow;
	//
	// VG_TRACK(die_mem_stack_signal, sp, frame_size);
	//
	// if (VG_(clo_trace_signals))
	// VG_(message)(Vg_DebugMsg,
	// "vg_pop_signal_frame (thread %d): isRT=%d valid magic; EIP=%p",
	// tid, has_siginfo, tst->arch.vex.guest_CIA);
	//
	// /* tell the tools */
	// VG_TRACK( post_deliver_signal, tid, sigNo );
	}

	/--------------------------------------------------------------------/
	/--- end sigframe-ppc64-linux.c ---/
	/--------------------------------------------------------------------/