path: root/coregrind/m_syswrap/.svn/text-base/syswrap-ppc64-aix5.c.svn-base

/*--------------------------------------------------------------------*/
/*--- Platform-specific syscalls stuff.       syswrap-ppc64-aix5.c ---*/
/*--------------------------------------------------------------------*/

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

   Copyright (C) 2006-2009 OpenWorks LLP
      info@open-works.co.uk

   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.

   Neither the names of the U.S. Department of Energy nor the
   University of California nor the names of its contributors may be
   used to endorse or promote products derived from this software
   without prior written permission.
*/

#include "pub_core_basics.h"
#include "pub_core_vki.h"
#include "pub_core_vkiscnums.h"
#include "pub_core_threadstate.h"
#include "pub_core_debuglog.h"
#include "pub_core_libcassert.h"
#include "pub_core_libcprint.h"
#include "pub_core_libcproc.h"
#include "pub_core_options.h"
#include "pub_core_scheduler.h"
#include "pub_core_sigframe.h"      // For VG_(sigframe_destroy)()
#include "pub_core_signals.h"
#include "pub_core_syscall.h"
#include "pub_core_syswrap.h"
#include "pub_core_tooliface.h"

#include "priv_types_n_macros.h"
#include "priv_syswrap-aix5.h"      /* for decls of aix5-common wrappers */
#include "priv_syswrap-main.h"


/* --------- HACKS --------- */
/* XXXXXXXXXXXX these HACKS are copies of stuff in syswrap-linux.c;
   check for duplication. */
/* HACK: is in syswrap-generic.c, but that doesn't get build on AIX. */
/* Dump out a summary, and a more detailed list, of open file descriptors. */
void VG_(show_open_fds) ( void )
{
  I_die_here;
}
static Bool i_am_the_only_thread ( void )
{
   Int c = VG_(count_living_threads)();
   vg_assert(c >= 1); /* stay sane */
   return c == 1;
}
void VG_(reap_threads)(ThreadId self)
{
   while (!i_am_the_only_thread()) {
      /* Let other thread(s) run */
      VG_(vg_yield)();
      VG_(poll_signals)(self);
   }
   vg_assert(i_am_the_only_thread());
}
void VG_(init_preopened_fds) ( void )
{
   I_die_here;
}


// Run a thread from beginning to end and return the thread's
// scheduler-return-code.
static VgSchedReturnCode thread_wrapper(Word /*ThreadId*/ tidW)
{
   VgSchedReturnCode ret;
   ThreadId     tid = (ThreadId)tidW;
   ThreadState* tst = VG_(get_ThreadState)(tid);

   VG_(debugLog)(1, "syswrap-aix64",
                    "thread_wrapper(tid=%lld): entry\n",
                    (ULong)tidW);

   vg_assert(tst->status == VgTs_Init);

   /* make sure we get the CPU lock before doing anything significant */
   VG_(acquire_BigLock)(tid, "thread_wrapper(starting new thread)");

   if (0)
      VG_(printf)("thread tid %d started: stack = %p\n",
                  tid, &tid);

   VG_TRACK( pre_thread_first_insn, tid );

   tst->os_state.lwpid = VG_(gettid)();
   tst->os_state.threadgroup = VG_(getpid)();

   /* Thread created with all signals blocked; scheduler will set the
      appropriate mask */
   ret = VG_(scheduler)(tid);

   vg_assert(VG_(is_exiting)(tid));

   vg_assert(tst->status == VgTs_Runnable);
   vg_assert(VG_(is_running_thread)(tid));

   VG_(debugLog)(1, "syswrap-aix64",
                    "thread_wrapper(tid=%lld): exit\n",
                    (ULong)tidW);

   /* Return to caller, still holding the lock. */
   return ret;
}


/* Run a thread all the way to the end, then do appropriate exit actions
   (this is the last-one-out-turn-off-the-lights bit).  */
static void run_a_thread_NORETURN ( Word tidW )
{
   ThreadId          tid = (ThreadId)tidW;
   VgSchedReturnCode src;
   Int               c;

   VG_(debugLog)(1, "syswrap-aix64",
                    "run_a_thread_NORETURN(tid=%lld): pre-thread_wrapper\n",
                    (ULong)tidW);

   /* Run the thread all the way through. */
   src = thread_wrapper(tid);

   VG_(debugLog)(1, "syswrap-aix64",
                    "run_a_thread_NORETURN(tid=%lld): post-thread_wrapper\n",
                    (ULong)tidW);

   c = VG_(count_living_threads)();
   vg_assert(c >= 1); /* stay sane */

   vg_assert(src == VgSrc_ExitThread 
             || src == VgSrc_ExitProcess
             || src == VgSrc_FatalSig);

   if (c == 1 || src == VgSrc_ExitProcess) {

      VG_(debugLog)(1, "syswrap-aix64",
                       "run_a_thread_NORETURN(tid=%lld): "
                          "exit process (%d threads remaining)\n",
                          (ULong)tidW, c);

      /* We are the last one standing.  Keep hold of the lock and
         carry on to show final tool results, then exit the entire system.
         Use the continuation pointer set at startup in m_main. */
      ( * VG_(address_of_m_main_shutdown_actions_NORETURN) ) (tid, src);

   } else {

      ThreadState *tst;

      VG_(debugLog)(1, "syswrap-aix64",
                       "run_a_thread_NORETURN(tid=%lld): "
                          "not last one standing\n",
                          (ULong)tidW);

      /* OK, thread is dead, but others still exist.  Just exit. */
      vg_assert(c >= 2);
      tst = VG_(get_ThreadState)(tid);

      /* This releases the run lock */
      VG_(exit_thread)(tid);
      vg_assert(tst->status == VgTs_Zombie);

      /* We have to use this sequence to terminate the thread to
         prevent a subtle race.  If VG_(exit_thread)() had left the
         ThreadState as Empty, then it could have been reallocated,
         reusing the stack while we're doing these last cleanups.
         Instead, VG_(exit_thread) leaves it as Zombie to prevent
         reallocation.  We need to make sure we don't touch the stack
         between marking it Empty and exiting.  Hence the
         assembler. */
      { ULong block[4];
        vg_assert(sizeof(tst->status == 8));
        vg_assert(__NR_AIX5_thread_terminate
                  != __NR_AIX5_UNKNOWN);
        block[0] = (ULong)VgTs_Empty;
        block[1] = (ULong) & (tst->status);
        block[2] = (ULong) tst->os_state.exitcode;
        block[3] = __NR_AIX5_thread_terminate;
        asm volatile (
          "mr 29,%0\n\t"           /* r29 = &block[0] */
          "ld 20, 0(29)\n\t"       /* r20 = VgTs_Empty */
          "ld 21, 8(29)\n\t"       /* r21 = & (tst->status) */
          "ld 22, 16(29)\n\t"      /* r22 = tst->os_state.exitcode */
          "ld 23, 24(29)\n\t"      /* r23 = __NR_exit */
          /* after this point we can't safely use the stack. */
          "std 20, 0(21)\n\t"      /* tst->status = VgTs_Empty */
          "mr 2,23\n\t"            /* r2 = __NR_exit */
          "mr 3,22\n\t"            /* set r3 = tst->os_state.exitcode */
          /* set up for syscall */
          "crorc 6,6,6\n\t"
          ".long 0x48000005\n\t"   /* "bl here+4" */
          "mflr 29\n\t"
          "addi 29,29,16\n\t"
          "mtlr 29\n\t"
          "sc\n\t"                 /* exit(tst->os_state.exitcode) */
          :
          : "b" (&block[0])
          : "lr", "memory", "r2", "r3", "r20", "r21", "r22", "r23", "r29"
        );
      }

      VG_(core_panic)("Thread exit failed?\n");
   }

   /*NOTREACHED*/
   vg_assert(0);
}


static Word start_thread_NORETURN ( void* arg )
{
   ThreadState* tst = (ThreadState*)arg;
   ThreadId     tid = tst->tid;

   run_a_thread_NORETURN ( (Word)tid );
   /*NOTREACHED*/
   vg_assert(0);
}


/* Call f(arg1), but first switch stacks, using 'stack' as the new
   stack.  f itself needs to never return. */
__attribute__((noreturn))
static
void call_on_new_stack_0_1_NORETURN ( Addr stack,
                                      void (*f_NORETURN)(Word),
                                      Word arg1 )
{
   UWord* fdescr = (UWord*)f_NORETURN;
   volatile UWord block[5];
   block[0] = fdescr[0];  /* nia */
   block[1] = stack;      /* r1 */
   block[2] = fdescr[1];  /* r2 */
   block[3] = arg1;       /* r3 */
   block[4] = fdescr[2];  /* r11 */
   __asm__ __volatile__(
      "mr  4,%0\n\t" /* r4 = block */
      "ld 1, 8(4)\n\t"
      "ld 2, 16(4)\n\t"
      "ld 3, 24(4)\n\t"
      "ld 11,32(4)\n\t"
      "ld 4, 0(4)\n\t"
      "mtctr 4\n\t"
      "bctr\n"
      : /*out*/ : /*in*/ "b"(&block[0]) 
   );
   /*NOTREACHED*/
   __asm__ __volatile__("trap");
   while (1) {} /* convince gcc that this really doesn't return */
}


/* Allocate a stack for the main thread, and run it all the way to the
   end.  Although we already have a working VgStack
   (VG_(interim_stack)) it's better to allocate a new one, so that
   overflow detection works uniformly for all threads.
*/
void VG_(main_thread_wrapper_NORETURN)(ThreadId tid)
{
   Addr sp;
   VG_(debugLog)(1, "syswrap-aix64",
                    "entering VG_(main_thread_wrapper_NORETURN)\n");

   sp = ML_(allocstack)(tid);

   /* If we can't even allocate the first thread's stack, we're hosed.
      Give up. */
   vg_assert2(sp != 0, "Cannot allocate main thread's stack.");

   /* shouldn't be any other threads around yet */
   vg_assert( VG_(count_living_threads)() == 1 );

   /* make a stack frame */
   sp -= 16;
   sp &= ~0xF;
   *(UWord *)sp = 0;

   call_on_new_stack_0_1_NORETURN(
      (Addr)sp,               /* stack */
      run_a_thread_NORETURN,  /* fn to call */
      (Word)tid               /* arg to give it */
   );

   /*NOTREACHED*/
   vg_assert(0);
}

/* --------- end HACKS --------- */


/* ---------------------------------------------------------------------
   More thread stuff
   ------------------------------------------------------------------ */

void VG_(cleanup_thread) ( ThreadArchState* arch )
{
}  


/* ---------------------------------------------------------------------
   PRE/POST wrappers for ppc64/AIX5-specific syscalls
   ------------------------------------------------------------------ */

/* --- !!! --- EXTERNAL HEADERS start --- !!! --- */
#include <sys/thread.h>
/* --- !!! --- EXTERNAL HEADERS end --- !!! --- */


/* Add prototypes for the wrappers declared here, so that gcc doesn't
   harass us for not having prototypes.  Really this is a kludge --
   the right thing to do is to make these wrappers 'static' since they
   aren't visible outside this file, but that requires even more macro
   magic. */

#define PRE(name)       DEFN_PRE_TEMPLATE(ppc64_aix5, name)
#define POST(name)      DEFN_POST_TEMPLATE(ppc64_aix5, name)

DECL_TEMPLATE(ppc64_aix5, sys__clock_gettime);
DECL_TEMPLATE(ppc64_aix5, sys__fp_fpscrx64_);
DECL_TEMPLATE(ppc64_aix5, sys_kload);
DECL_TEMPLATE(ppc64_aix5, sys_kunload64);
DECL_TEMPLATE(ppc64_aix5, sys_thread_setstate);
DECL_TEMPLATE(ppc64_aix5, sys_FAKE_SIGRETURN);


PRE(sys__clock_gettime)
{
   /* Seems like ARG2 points at a destination buffer? */
   /* _clock_gettime (UNDOCUMENTED) ( 0, 0xA, 0x2FF21808 ) */
   PRINT("_clock_gettime (UNDOCUMENTED) ( %ld, %#lx, %#lx )", ARG1, ARG2, ARG3 );
   PRE_REG_READ3(int, "_clock_gettime", int, arg1, int, arg2, void*, arg3);
   PRE_MEM_WRITE( "_clock_gettime(dst)", ARG2, sizeof(struct timespec) );
}
POST(sys__clock_gettime)
{
   vg_assert(SUCCESS);
   POST_MEM_WRITE( ARG2, sizeof(struct timespec) );
}

PRE(sys__fp_fpscrx64_)
{
   PRINT("_fp_fpscrx64_ (BOGUS HANDLER)");
}

PRE(sys_kload)
{
   PRINT("kload (UNDOCUMENTED)( %#lx(%s), %ld, %ld )", 
         ARG1,(Char*)ARG1, ARG2, ARG3 );
   PRE_REG_READ3(void*, "kload", char*, name, long, arg2, char*, arg3);
}
POST(sys_kload)
{
   vg_assert(SUCCESS);
   if (0) VG_(printf)("kload result = %#lx\n", RES);
   if (RES)
      POST_MEM_WRITE( RES, 64 );
   ML_(aix5_rescan_procmap_after_load_or_unload)();
}

PRE(sys_kunload64)
{
   PRINT("kunload64 (UNDOCUMENTED)( %#lx, %ld, %ld, %#lx )", 
         ARG1, ARG2, ARG3, ARG4 );
   PRE_REG_READ4(long, "kunload64",
                 void*, arg1, long, arg2, long, arg3, void*, arg4);
}
POST(sys_kunload64)
{
   vg_assert(SUCCESS);
   ML_(aix5_rescan_procmap_after_load_or_unload)();
}

PRE(sys_thread_setstate)
{
   UWord          dst_lwpid = (UWord)ARG1;
   struct tstate* ats_new   = (struct tstate*)ARG2;
   struct tstate* ats_old   = (struct tstate*)ARG3;
   ThreadId       dst_tid   = VG_INVALID_THREADID;
   ThreadState*   dst_ts    = NULL;
   Int i;

   /* Arrgh.  We MUST retain the lock during this syscall.  Reason is
      that this is sometimes used for asynchronous thread cancellation
      (nuking other threads).  If we don't have the lock during the
      syscall, then it's possible that the thread we're nuking might
      get the lock before it gets killed off, and so we can never
      re-acquire the lock after this syscall, and the system
      deadlocks. */

   /* 10 July 06: above comment is a misdiagnosis.  It appears that
      for thread cancellation (that is, with ->flags == TSTATE_INTR)
      the target thread is has its PC changed by the the kernel to
      something else, possibly to pthread_exit(), so that it can run
      its cancellation handlers and exit.  Currently is unknown how
      the kernel knows what to set the target thread's PC to.  I did
      establish that all the other data passed in the struct is not
      relevant: when ->flags == TSTATE_INTR, all the other words can
      be set to 0x0 or 0xFFFFFFFF and the syscall still works.  So the
      address is not passed like that.  Also I looked at args to
      thread_setmystate_fast, which is used when a thread sets its
      cancellation state, but none of those are code addresses.

      Also, it's ok for the kernel to simply change the target
      thread's PC to something else for async thread cancellation, but
      for deferred cancellation something else is needed, and I can't
      see how that would work either.

      Anyway, net result is, target thread ends up not running on the
      simulator (not dead), which is why it's necessary to hold onto
      the lock at this point. */

   /* 30 July 06: added kludge to intercept attempts to cancel another
      thread and instead just force that thread to run
      pthread_exit(PTHREAD_CANCELED).  This allows V to keep
      control. */

   PRINT("thread_setstate (BOGUS HANDLER) "
         "( %ld, %p,%p )", dst_lwpid, ats_new, ats_old);
   if (1 && VG_(clo_trace_syscalls) && ats_new)
      ML_(aix5debugstuff_show_tstate)((Addr)ats_new, 
                                      "thread_setstate (NEW)");

   /* Intercept and handle ourselves any attempts to cancel 
      another thread (including this one). */

   if (ats_new && (!ats_old) && ats_new->flags == TSTATE_INTR) {
      dst_ts = NULL;
      if (VG_(clo_trace_syscalls))
         VG_(printf)("(INTR for lwpid %ld)", dst_lwpid);
      dst_tid = VG_INVALID_THREADID;
      for (i = 0; i < VG_N_THREADS; i++) {
         dst_ts = VG_(get_ThreadState)(i);
         if ((dst_ts->status == VgTs_Runnable 
              || dst_ts->status == VgTs_Yielding
              || dst_ts->status == VgTs_WaitSys)
             && dst_ts->os_state.lwpid == dst_lwpid) {
            dst_tid = i;
            break;
         }
      }
      if (VG_(clo_trace_syscalls)) {
         if (dst_tid == VG_INVALID_THREADID)
            VG_(printf)("(== unknown tid)");
         else 
            VG_(printf)("(== tid %d)", (Int)dst_tid);
      }
      if (dst_tid != VG_INVALID_THREADID) {
         /* A cancel has been requested for ctid.  If the target
            thread has cancellation enabled, honour it right now.  If
            not, mark the thread as having a cancellation request, so
            that if it later enables cancellation then the
            cancellation will take effect. */
         vg_assert(dst_ts);
         if (dst_ts->os_state.cancel_progress == Canc_NoRequest) {
            if (dst_ts->os_state.cancel_disabled) {
               if (VG_(clo_trace_syscalls))
                  VG_(printf)("(target has cancel disabled"
                              "; request lodged)");
               dst_ts->os_state.cancel_progress = Canc_Requested;
            } else {
               if (VG_(clo_trace_syscalls))
                  VG_(printf)("(forcing target into pthread_exit)");
               dst_ts->os_state.cancel_progress = Canc_Actioned;
               Bool ok = ML_(aix5_force_thread_into_pthread_exit)(dst_tid);
               if (!ok) {
                  /* now at serious risk of deadlock/livelock.  Give up
                     rather than continue. */
                  ML_(aix5_set_threadstate_for_emergency_exit)
                     (tid, "pthread_cancel(case2-64): "
                           "cannot find pthread_exit; aborting");
                  SET_STATUS_Success(0);
                  return;
               }
            }
         }
         SET_STATUS_Success(0);
         return;
      }
   }

   /* Well, it's not a cancellation request.  Maybe it is the
      initialisation of a previously created thread? */

   if (ats_new && !ats_old) {
      dst_tid = VG_INVALID_THREADID;
      for (i = 0; i < VG_N_THREADS; i++) {
         dst_ts = VG_(get_ThreadState)(i);
         if (dst_ts->status == VgTs_Init 
             && dst_ts->os_state.lwpid == dst_lwpid) {
            dst_tid = i;
            break;
         }
      }
      if (dst_tid != VG_INVALID_THREADID) {
         /* Found the associated child */
         if (VG_(clo_trace_syscalls)) 
            VG_(printf)("(initialised child tid %d)", (Int)dst_tid);
         dst_ts = VG_(get_ThreadState)(dst_tid);
         UWord* stack = (UWord*)ML_(allocstack)(dst_tid);
         /* XXX TODO: check allocstack failure */

         /* copy the specified child register state into the guest
            slot (we need that context to run on the simulated CPU,
            not the real one) and put pointers to our own
            run-the-simulator function into what we'll hand off to the
            kernel instead. */

         /* The guest thread is to start running whatever context
            this syscall showed up with. */
         dst_ts->arch.vex.guest_GPR0  = ats_new->mst.gpr[0];
         dst_ts->arch.vex.guest_GPR1  = ats_new->mst.gpr[1]; /* sp */
         dst_ts->arch.vex.guest_GPR2  = ats_new->mst.gpr[2]; /* toc */
         dst_ts->arch.vex.guest_GPR3  = ats_new->mst.gpr[3]; /* initarg */
         dst_ts->arch.vex.guest_GPR4  = ats_new->mst.gpr[4];
         dst_ts->arch.vex.guest_GPR5  = ats_new->mst.gpr[5];
         dst_ts->arch.vex.guest_GPR6  = ats_new->mst.gpr[6];
         dst_ts->arch.vex.guest_GPR7  = ats_new->mst.gpr[7];
         dst_ts->arch.vex.guest_GPR8  = ats_new->mst.gpr[8];
         dst_ts->arch.vex.guest_GPR9  = ats_new->mst.gpr[9];
         dst_ts->arch.vex.guest_GPR10 = ats_new->mst.gpr[10];
         dst_ts->arch.vex.guest_GPR11 = ats_new->mst.gpr[11]; /* ?? */
         dst_ts->arch.vex.guest_GPR12 = ats_new->mst.gpr[12];
         dst_ts->arch.vex.guest_GPR13 = ats_new->mst.gpr[13];
         dst_ts->arch.vex.guest_GPR14 = ats_new->mst.gpr[14];
         dst_ts->arch.vex.guest_GPR15 = ats_new->mst.gpr[15];
         dst_ts->arch.vex.guest_GPR16 = ats_new->mst.gpr[16];
         dst_ts->arch.vex.guest_GPR17 = ats_new->mst.gpr[17];
         dst_ts->arch.vex.guest_GPR18 = ats_new->mst.gpr[18];
         dst_ts->arch.vex.guest_GPR19 = ats_new->mst.gpr[19];
         dst_ts->arch.vex.guest_GPR20 = ats_new->mst.gpr[20];
         dst_ts->arch.vex.guest_GPR21 = ats_new->mst.gpr[21];
         dst_ts->arch.vex.guest_GPR22 = ats_new->mst.gpr[22];
         dst_ts->arch.vex.guest_GPR23 = ats_new->mst.gpr[23];
         dst_ts->arch.vex.guest_GPR24 = ats_new->mst.gpr[24];
         dst_ts->arch.vex.guest_GPR25 = ats_new->mst.gpr[25];
         dst_ts->arch.vex.guest_GPR26 = ats_new->mst.gpr[26];
         dst_ts->arch.vex.guest_GPR27 = ats_new->mst.gpr[27];
         dst_ts->arch.vex.guest_GPR28 = ats_new->mst.gpr[28];
         dst_ts->arch.vex.guest_GPR29 = ats_new->mst.gpr[29];
         dst_ts->arch.vex.guest_GPR30 = ats_new->mst.gpr[30];
         dst_ts->arch.vex.guest_GPR31 = ats_new->mst.gpr[31];
         dst_ts->arch.vex.guest_CIA   = ats_new->mst.iar; /* pc */
         dst_ts->arch.vex.guest_LR    = ats_new->mst.lr;
         dst_ts->arch.vex.guest_CTR   = ats_new->mst.ctr;
         LibVEX_GuestPPC64_put_CR( ats_new->mst.cr, &dst_ts->arch.vex );
         LibVEX_GuestPPC64_put_XER( ats_new->mst.xer, &dst_ts->arch.vex );

         /* Record what seems like the highest legitimate stack
            address for this thread, so that the stack unwinder works
            properly.  It seems reasonable to use the R1 value
            supplied here. */
         dst_ts->client_stack_highest_word = dst_ts->arch.vex.guest_GPR1;

         /* The host thread is to start running
            start_thread_NORETURN */
         UWord* wrapper_fdescr = (UWord*) & start_thread_NORETURN;
         ats_new->mst.gpr[1] = (UWord)stack;
         ats_new->mst.gpr[2] = wrapper_fdescr[1];
         ats_new->mst.iar    = wrapper_fdescr[0];
         ats_new->mst.gpr[3] = (UWord)dst_ts;

         /* Set initial cancellation status for the thread. */
         dst_ts->os_state.cancel_async    = False;
         dst_ts->os_state.cancel_disabled = False;
         dst_ts->os_state.cancel_progress = Canc_NoRequest;
      }
   }
}
POST(sys_thread_setstate)
{
   if (ARG3)
      POST_MEM_WRITE( ARG3, sizeof(struct tstate) );
   if (0 && VG_(clo_trace_syscalls) && ARG3)
      ML_(aix5debugstuff_show_tstate)(ARG3, "thread_setstate (OLD)");
}

PRE(sys_FAKE_SIGRETURN)
{
   /* See comments on PRE(sys_rt_sigreturn) in syswrap-amd64-linux.c for
      an explanation of what follows. */
   /* This handles the fake signal-return system call created by
      sigframe-ppc64-aix5.c. */

   PRINT("FAKE_SIGRETURN ( )");

   vg_assert(VG_(is_valid_tid)(tid));
   vg_assert(tid >= 1 && tid < VG_N_THREADS);
   vg_assert(VG_(is_running_thread)(tid));

   /* Remove the signal frame from this thread's (guest) stack,
      in the process restoring the pre-signal guest state. */
   VG_(sigframe_destroy)(tid, True);

   /* Tell the driver not to update the guest state with the "result",
      and set a bogus result to keep it happy. */
   *flags |= SfNoWriteResult;
   SET_STATUS_Success(0);

   /* Check to see if any signals arose as a result of this. */
   *flags |= SfPollAfter;
}


/* ---------------------------------------------------------------------
   The ppc64/AIX5 syscall table
   ------------------------------------------------------------------ */

typedef
   struct {
      UInt* pSysNo;
      SyscallTableEntry wrappers;
   }
   AIX5SCTabEntry;

#undef PLAXY
#undef PLAX_

#define PLAXY(sysno, name)                     \
   { & sysno,                                  \
     { & WRAPPER_PRE_NAME(ppc64_aix5, name),   \
       & WRAPPER_POST_NAME(ppc64_aix5, name) }} 

#define PLAX_(sysno, name)                     \
   { & sysno,                                  \
     { & WRAPPER_PRE_NAME(ppc64_aix5, name),   \
       NULL }} 

static /* but not const */
AIX5SCTabEntry aix5_ppc64_syscall_table[]
= {
    AIXXY(__NR_AIX5___libc_sbrk,        sys___libc_sbrk),
    AIXX_(__NR_AIX5___msleep,           sys___msleep),
    PLAXY(__NR_AIX5__clock_gettime,     sys__clock_gettime),
    AIXX_(__NR_AIX5__exit,              sys__exit),
    PLAX_(__NR_AIX5__fp_fpscrx64_,      sys__fp_fpscrx64_),
    AIXX_(__NR_AIX5__getpid,            sys__getpid),
    AIXXY(__NR_AIX5__nsleep,            sys__nsleep),
    AIXX_(__NR_AIX5__pause,             sys__pause),
    AIXXY(__NR_AIX5__poll,              sys__poll),
    AIXX_(__NR_AIX5__select,            sys__select),
    AIXX_(__NR_AIX5__sem_wait,          sys__sem_wait),
    AIXXY(__NR_AIX5__sigaction,         sys__sigaction),
    AIXX_(__NR_AIX5__thread_self,       sys__thread_self),
    AIXX_(__NR_AIX5_access,             sys_access),
    AIXX_(__NR_AIX5_accessx,            sys_accessx),
    AIXXY(__NR_AIX5_appgetrlimit,       sys_appgetrlimit),
    AIXXY(__NR_AIX5_appgetrusage,       sys_appgetrusage),
    AIXX_(__NR_AIX5_appsetrlimit,       sys_appsetrlimit),
    AIXX_(__NR_AIX5_appulimit,          sys_appulimit),
    AIXX_(__NR_AIX5_bind,               sys_bind),
    AIXX_(__NR_AIX5_chdir,              sys_chdir),
    AIXX_(__NR_AIX5_chmod,              sys_chmod),
    AIXX_(__NR_AIX5_chown,              sys_chown),
    AIXX_(__NR_AIX5_close,              sys_close),
    AIXX_(__NR_AIX5_connext,            sys_connext),
    AIXX_(__NR_AIX5_execve,             sys_execve),
    AIXXY(__NR_AIX5_finfo,              sys_finfo),
    AIXXY(__NR_AIX5_fstatfs,            sys_fstatfs),
    AIXXY(__NR_AIX5_fstatx,             sys_fstatx),
    AIXXY(__NR_AIX5_getdirent,          sys_getdirent),
    AIXXY(__NR_AIX5_getdirent64,        sys_getdirent64),
    AIXXY(__NR_AIX5_getdomainname,      sys_getdomainname),
    AIXX_(__NR_AIX5_getgidx,            sys_getgidx),
    AIXXY(__NR_AIX5_gethostname,        sys_gethostname),
    AIXXY(__NR_AIX5_getpriv,            sys_getpriv),
    AIXXY(__NR_AIX5_getprocs,           sys_getprocs),
    AIXXY(__NR_AIX5_getprocs64,         sys_getprocs), /* XXX: correct? */
    AIXX_(__NR_AIX5_getrpid,            sys_getrpid),
    AIXXY(__NR_AIX5_getsockopt,         sys_getsockopt),
    AIXX_(__NR_AIX5_gettimerid,         sys_gettimerid),
    AIXX_(__NR_AIX5_getuidx,            sys_getuidx),
    AIXXY(__NR_AIX5_incinterval,        sys_incinterval),
    AIXXY(__NR_AIX5_kfcntl,             sys_kfcntl),
    AIXX_(__NR_AIX5_kfork,              sys_kfork),
    AIXX_(__NR_AIX5_kill,               sys_kill),
    AIXXY(__NR_AIX5_kioctl,             sys_kioctl),
    PLAXY(__NR_AIX5_kload,              sys_kload),
    AIXX_(__NR_AIX5_klseek,             sys_klseek),
    AIXXY(__NR_AIX5_kread,              sys_kread),
    AIXXY(__NR_AIX5_kreadv,             sys_kreadv),
    AIXX_(__NR_AIX5_kthread_ctl,        sys_kthread_ctl),
    AIXX_(__NR_AIX5_ktruncate,          sys_ktruncate),
    PLAXY(__NR_AIX5_kunload64,          sys_kunload64),
    AIXXY(__NR_AIX5_kwaitpid,           sys_kwaitpid),
    AIXX_(__NR_AIX5_kwrite,             sys_kwrite),
    AIXX_(__NR_AIX5_kwritev,            sys_kwritev),
    AIXX_(__NR_AIX5_lseek,              sys_lseek),
    AIXX_(__NR_AIX5_mkdir,              sys_mkdir),
    AIXXY(__NR_AIX5_mmap,               sys_mmap),
    AIXXY(__NR_AIX5_mntctl,             sys_mntctl),
    AIXXY(__NR_AIX5_mprotect,           sys_mprotect),
    AIXXY(__NR_AIX5_munmap,             sys_munmap),
    AIXXY(__NR_AIX5_ngetpeername,       sys_ngetpeername),
    AIXXY(__NR_AIX5_ngetsockname,       sys_ngetsockname),
    AIXXY(__NR_AIX5_nrecvfrom,          sys_nrecvfrom),
    AIXX_(__NR_AIX5_nrecvmsg,           sys_nrecvmsg),
    AIXX_(__NR_AIX5_open,               sys_open),
    AIXXY(__NR_AIX5_pipe,               sys_pipe),
    AIXX_(__NR_AIX5_privcheck,          sys_privcheck),
    AIXX_(__NR_AIX5_rename,             sys_rename),
    AIXXY(__NR_AIX5_sbrk,               sys_sbrk),
    AIXXY(__NR_AIX5_sem_init,           sys_sem_init),
    AIXXY(__NR_AIX5_sem_post,           sys_sem_post),
    AIXX_(__NR_AIX5_send,               sys_send),
    AIXX_(__NR_AIX5_setgid,             sys_setgid),
    AIXX_(__NR_AIX5_setsockopt,         sys_setsockopt),
    AIXX_(__NR_AIX5_setuid,             sys_setuid),
    AIXXY(__NR_AIX5_shmat,              sys_shmat),
    AIXXY(__NR_AIX5_shmctl,             sys_shmctl),
    AIXXY(__NR_AIX5_shmdt,              sys_shmdt),
    AIXX_(__NR_AIX5_shmget,             sys_shmget),
    AIXX_(__NR_AIX5_shutdown,           sys_shutdown),
    AIXX_(__NR_AIX5_sigcleanup,         sys_sigcleanup),
    AIXXY(__NR_AIX5_sigprocmask,        sys_sigprocmask),
    AIXXY(__NR_AIX5_sys_parm,           sys_sys_parm),
    AIXXY(__NR_AIX5_sysconfig,          sys_sysconfig),
    AIXX_(__NR_AIX5_socket,             sys_socket),
    AIXXY(__NR_AIX5_statx,              sys_statx),
    AIXXY(__NR_AIX5_thread_create,      sys_thread_create),
    AIXX_(__NR_AIX5_thread_init,        sys_thread_init),
    AIXX_(__NR_AIX5_thread_kill,        sys_thread_kill),
    AIXXY(__NR_AIX5_thread_setmystate,  sys_thread_setmystate),
    AIXX_(__NR_AIX5_thread_setmystate_fast, sys_thread_setmystate_fast),
    PLAXY(__NR_AIX5_thread_setstate,    sys_thread_setstate),
    AIXX_(__NR_AIX5_thread_terminate_unlock, sys_thread_terminate_unlock),
    AIXX_(__NR_AIX5_thread_tsleep,      sys_thread_tsleep),
    AIXX_(__NR_AIX5_thread_twakeup,     sys_thread_twakeup),
    AIXX_(__NR_AIX5_thread_unlock,      sys_thread_unlock),
    AIXX_(__NR_AIX5_thread_waitlock_,   sys_thread_waitlock_),
    AIXXY(__NR_AIX5_times,              sys_times),
    AIXXY(__NR_AIX5_uname,              sys_uname),
    AIXX_(__NR_AIX5_unlink,             sys_unlink),
    AIXX_(__NR_AIX5_utimes,             sys_utimes),
    AIXXY(__NR_AIX5_vmgetinfo,          sys_vmgetinfo),
    AIXX_(__NR_AIX5_yield,              sys_yield),
    PLAX_(__NR_AIX5_FAKE_SIGRETURN,     sys_FAKE_SIGRETURN)
  };

SyscallTableEntry* ML_(get_ppc64_aix5_syscall_entry) ( UInt sysno )
{
   Int            i;
   AIX5SCTabEntry tmp;

   const Int tab_size = sizeof(aix5_ppc64_syscall_table) 
                        / sizeof(aix5_ppc64_syscall_table[0]);

   for (i = 0; i < tab_size; i++)
      if (sysno == *(aix5_ppc64_syscall_table[i].pSysNo))
         break;

   vg_assert(i >= 0 && i <= tab_size);
   if (i == tab_size)
      return NULL; /* can't find a wrapper */

   /* Move found one a bit closer to the front, so as to
      make future searches cheaper. */
   if (i > 0) {
      tmp = aix5_ppc64_syscall_table[i-1];
      aix5_ppc64_syscall_table[i-1] = aix5_ppc64_syscall_table[i];
      aix5_ppc64_syscall_table[i] = tmp;
      i--;
   }

   vg_assert(i >= 0 && i < tab_size);
   return &aix5_ppc64_syscall_table[i].wrappers;
}

/*--------------------------------------------------------------------*/
/*--- end                                                          ---*/
/*--------------------------------------------------------------------*/