
/*--------------------------------------------------------------------*/
/*--- Platform-specific syscalls stuff.      syswrap-x86-solaris.c ---*/
/*--------------------------------------------------------------------*/

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

   Copyright (C) 2011-2017 Petr Pavlu
      setup@dagobah.cz

   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.
*/

#if defined(VGP_x86_solaris)

#include "libvex_guest_offsets.h"
#include "pub_core_basics.h"
#include "pub_core_vki.h"
#include "pub_core_threadstate.h"
#include "pub_core_aspacemgr.h"
#include "pub_core_xarray.h"
#include "pub_core_clientstate.h"
#include "pub_core_debuglog.h"
#include "pub_core_libcassert.h"
#include "pub_core_libcbase.h"
#include "pub_core_libcfile.h"
#include "pub_core_libcprint.h"
#include "pub_core_libcsignal.h"
#include "pub_core_machine.h"           // VG_(get_SP)
#include "pub_core_mallocfree.h"
#include "pub_core_options.h"
#include "pub_core_tooliface.h"
#include "pub_core_signals.h"
#include "pub_core_syscall.h"
#include "pub_core_syswrap.h"

#include "priv_types_n_macros.h"
#include "priv_syswrap-generic.h"
#include "priv_syswrap-solaris.h"

/* Call f(arg1), but first switch stacks, using 'stack' as the new stack, and
   use 'retaddr' as f's return-to address.  Also, clear all the integer
   registers before entering f. */
__attribute__((noreturn))
void ML_(call_on_new_stack_0_1)(Addr stack,             /* 4(%esp) */
                                Addr retaddr,           /* 8(%esp) */
                                void (*f)(Word),        /* 12(%esp) */
                                Word arg1);             /* 16(%esp) */
__asm__ (
".text\n"
".globl vgModuleLocal_call_on_new_stack_0_1\n"
"vgModuleLocal_call_on_new_stack_0_1:\n"
"   movl  %esp, %esi\n"         /* remember old stack pointer */
"   movl  4(%esi), %esp\n"      /* set stack */
"   pushl $0\n"                 /* align stack */
"   pushl $0\n"                 /* align stack */
"   pushl $0\n"                 /* align stack */
"   pushl 16(%esi)\n"           /* arg1 to stack */
"   pushl 8(%esi)\n"            /* retaddr to stack */
"   pushl 12(%esi)\n"           /* f to stack */
"   movl  $0, %eax\n"           /* zero all GP regs */
"   movl  $0, %ebx\n"
"   movl  $0, %ecx\n"
"   movl  $0, %edx\n"
"   movl  $0, %esi\n"
"   movl  $0, %edi\n"
"   movl  $0, %ebp\n"
"   ret\n"                      /* jump to f */
"   ud2\n"                      /* should never get here */
".previous\n"
);

/* This function is called to setup a context of a new Valgrind thread (which
   will run the client code). */
void ML_(setup_start_thread_context)(ThreadId tid, vki_ucontext_t *uc)
{
   ThreadState *tst = VG_(get_ThreadState)(tid);
   UWord *stack = (UWord*)tst->os_state.valgrind_stack_init_SP;
   UShort cs, ds, ss, es, fs, gs;

   VG_(memset)(uc, 0, sizeof(*uc));
   uc->uc_flags = VKI_UC_CPU | VKI_UC_SIGMASK;

   /* Start the thread with everything blocked. */
   VG_(sigfillset)(&uc->uc_sigmask);

   /* Set up the stack, it should be always 16-byte aligned before doing
      a function call, i.e. the first parameter is also 16-byte aligned. */
   vg_assert(VG_IS_16_ALIGNED(stack));
   stack -= 1;
   stack[0] = 0; /* bogus return value */
   stack[1] = (UWord)tst; /* the parameter */

   /* Set up the registers. */
   uc->uc_mcontext.gregs[VKI_EIP] = (UWord)ML_(start_thread_NORETURN);
   uc->uc_mcontext.gregs[VKI_UESP] = (UWord)stack;

   /* Copy segment registers. */
   __asm__ __volatile__(
      "movw %%cs, %[cs]\n"
      "movw %%ds, %[ds]\n"
      "movw %%ss, %[ss]\n"
      "movw %%es, %[es]\n"
      "movw %%fs, %[fs]\n"
      "movw %%gs, %[gs]\n"
      : [cs] "=m" (cs), [ds] "=m" (ds), [ss] "=m" (ss), [es] "=m" (es),
        [fs] "=m" (fs), [gs] "=m" (gs));
   uc->uc_mcontext.gregs[VKI_CS] = cs;
   uc->uc_mcontext.gregs[VKI_DS] = ds;
   uc->uc_mcontext.gregs[VKI_SS] = ss;
   uc->uc_mcontext.gregs[VKI_ES] = es;
   uc->uc_mcontext.gregs[VKI_FS] = fs;
   uc->uc_mcontext.gregs[VKI_GS] = gs;
}

/* Architecture-specific part of VG_(save_context). */
void ML_(save_machine_context)(ThreadId tid, vki_ucontext_t *uc,
                               CorePart part)
{
   ThreadState *tst = VG_(get_ThreadState)(tid);
   struct vki_fpchip_state *fs
      = &uc->uc_mcontext.fpregs.fp_reg_set.fpchip_state;
   SizeT i;

   /* CPU */
   /* Common registers */
   uc->uc_mcontext.gregs[VKI_EIP] = tst->arch.vex.guest_EIP;
   VG_TRACK(copy_reg_to_mem, part, tid, OFFSET_x86_EIP,
            (Addr)&uc->uc_mcontext.gregs[VKI_EIP], sizeof(UWord));
   uc->uc_mcontext.gregs[VKI_EAX] = tst->arch.vex.guest_EAX;
   VG_TRACK(copy_reg_to_mem, part, tid, OFFSET_x86_EAX,
            (Addr)&uc->uc_mcontext.gregs[VKI_EAX], sizeof(UWord));
   uc->uc_mcontext.gregs[VKI_EBX] = tst->arch.vex.guest_EBX;
   VG_TRACK(copy_reg_to_mem, part, tid, OFFSET_x86_EBX,
            (Addr)&uc->uc_mcontext.gregs[VKI_EBX], sizeof(UWord));
   uc->uc_mcontext.gregs[VKI_ECX] = tst->arch.vex.guest_ECX;
   VG_TRACK(copy_reg_to_mem, part, tid, OFFSET_x86_ECX,
            (Addr)&uc->uc_mcontext.gregs[VKI_ECX], sizeof(UWord));
   uc->uc_mcontext.gregs[VKI_EDX] = tst->arch.vex.guest_EDX;
   VG_TRACK(copy_reg_to_mem, part, tid, OFFSET_x86_EDX,
            (Addr)&uc->uc_mcontext.gregs[VKI_EDX], sizeof(UWord));
   uc->uc_mcontext.gregs[VKI_EBP] = tst->arch.vex.guest_EBP;
   VG_TRACK(copy_reg_to_mem, part, tid, OFFSET_x86_EBP,
            (Addr)&uc->uc_mcontext.gregs[VKI_EBP], sizeof(UWord));
   uc->uc_mcontext.gregs[VKI_ESI] = tst->arch.vex.guest_ESI;
   VG_TRACK(copy_reg_to_mem, part, tid, OFFSET_x86_ESI,
            (Addr)&uc->uc_mcontext.gregs[VKI_ESI], sizeof(UWord));
   uc->uc_mcontext.gregs[VKI_EDI] = tst->arch.vex.guest_EDI;
   VG_TRACK(copy_reg_to_mem, part, tid, OFFSET_x86_EDI,
            (Addr)&uc->uc_mcontext.gregs[VKI_EDI], sizeof(UWord));
   uc->uc_mcontext.gregs[VKI_UESP] = tst->arch.vex.guest_ESP;
   VG_TRACK(copy_reg_to_mem, part, tid, OFFSET_x86_ESP,
            (Addr)&uc->uc_mcontext.gregs[VKI_UESP], sizeof(UWord));
   uc->uc_mcontext.gregs[VKI_ESP] = 0;
   VG_TRACK(post_mem_write, part, tid, (Addr)&uc->uc_mcontext.gregs[VKI_ESP],
            sizeof(UWord));

   /* ERR and TRAPNO */
   uc->uc_mcontext.gregs[VKI_ERR] = 0;
   VG_TRACK(post_mem_write, part, tid, (Addr)&uc->uc_mcontext.gregs[VKI_ERR],
            sizeof(UWord));
   uc->uc_mcontext.gregs[VKI_TRAPNO] = 0;
   VG_TRACK(post_mem_write, part, tid, (Addr)&uc->uc_mcontext.gregs[VKI_TRAPNO],
            sizeof(UWord));

   /* Segment registers */
   /* Note that segment registers are 16b in VEX, but 32b in mcontext.  Thus
      we tell a tool that the lower 16 bits were copied and that the higher 16
      bits were set (to zero).  (This assumes a little-endian
      architecture.) */
   uc->uc_mcontext.gregs[VKI_CS] = tst->arch.vex.guest_CS;
   VG_TRACK(copy_reg_to_mem, part, tid, OFFSET_x86_CS,
            (Addr)&uc->uc_mcontext.gregs[VKI_CS], sizeof(UShort));
   VG_TRACK(post_mem_write, part, tid,
            (Addr)(&uc->uc_mcontext.gregs[VKI_CS]) + 2, sizeof(UShort));
   uc->uc_mcontext.gregs[VKI_DS] = tst->arch.vex.guest_DS;
   VG_TRACK(copy_reg_to_mem, part, tid, OFFSET_x86_DS,
            (Addr)&uc->uc_mcontext.gregs[VKI_DS], sizeof(UShort));
   VG_TRACK(post_mem_write, part, tid,
            (Addr)(&uc->uc_mcontext.gregs[VKI_DS]) + 2, sizeof(UShort));
   uc->uc_mcontext.gregs[VKI_SS] = tst->arch.vex.guest_SS;
   VG_TRACK(copy_reg_to_mem, part, tid, OFFSET_x86_SS,
            (Addr)&uc->uc_mcontext.gregs[VKI_SS], sizeof(UShort));
   VG_TRACK(post_mem_write, part, tid,
            (Addr)(&uc->uc_mcontext.gregs[VKI_SS]) + 2, sizeof(UShort));
   uc->uc_mcontext.gregs[VKI_ES] = tst->arch.vex.guest_ES;
   VG_TRACK(copy_reg_to_mem, part, tid, OFFSET_x86_ES,
            (Addr)&uc->uc_mcontext.gregs[VKI_ES], sizeof(UShort));
   VG_TRACK(post_mem_write, part, tid,
            (Addr)(&uc->uc_mcontext.gregs[VKI_ES]) + 2, sizeof(UShort));
   uc->uc_mcontext.gregs[VKI_FS] = tst->arch.vex.guest_FS;
   VG_TRACK(copy_reg_to_mem, part, tid, OFFSET_x86_FS,
            (Addr)&uc->uc_mcontext.gregs[VKI_FS], sizeof(UShort));
   VG_TRACK(post_mem_write, part, tid,
            (Addr)(&uc->uc_mcontext.gregs[VKI_FS]) + 2, sizeof(UShort));
   uc->uc_mcontext.gregs[VKI_GS] = tst->arch.vex.guest_GS;
   VG_TRACK(copy_reg_to_mem, part, tid, OFFSET_x86_GS,
            (Addr)&uc->uc_mcontext.gregs[VKI_GS], sizeof(UShort));
   VG_TRACK(post_mem_write, part, tid,
            (Addr)(&uc->uc_mcontext.gregs[VKI_GS]) + 2, sizeof(UShort));

   /* Handle eflags (optimistically make all flags defined). */
   uc->uc_mcontext.gregs[VKI_EFL] =
      LibVEX_GuestX86_get_eflags(&tst->arch.vex);
   VG_TRACK(post_mem_write, part, tid, (Addr)&uc->uc_mcontext.gregs[VKI_EFL],
         sizeof(UWord));
   /* The LibVEX_GuestX86_get_eflags() call calculates eflags value from the
      CC_OP, CC_DEP1, CC_DEP2, CC_NDEP, DFLAG, IDFLAG and ACFLAG guest state
      values.  The *FLAG values represent one-bit information and are saved
      without loss of precision into eflags.  However when CC_* values are
      converted into eflags then precision is lost.  What we do here is to
      save unmodified CC_* values into unused ucontext members (the 'long
      uc_filler[5] and 'int fs->__pad[2]' arrays) so we can then restore the
      context in ML_(restore_machine_context)() without the loss of precision.
      This imposes a requirement on client programs to not use these two
      members. Luckily this is never a case in Solaris-gate programs and
      libraries. */
   /* CC_OP and CC_NDEP are always defined, but we don't want to tell a tool
      that we just defined uc_filler[0,1].  This helps if someone uses an
      uninitialized ucontext and tries to read (use) uc_filler[0,1].  Memcheck
      in such a case should detect this error. */
   VKI_UC_GUEST_CC_OP(uc) = tst->arch.vex.guest_CC_OP;
   VKI_UC_GUEST_CC_NDEP(uc) = tst->arch.vex.guest_CC_NDEP;
   /* We want to copy shadow values of CC_DEP1 and CC_DEP2 so we have to tell
      a tool about this copy. */
   VKI_UC_GUEST_CC_DEP1(uc) = tst->arch.vex.guest_CC_DEP1;
   VG_TRACK(copy_reg_to_mem, part, tid,
            offsetof(VexGuestX86State, guest_CC_DEP1),
            (Addr)&VKI_UC_GUEST_CC_DEP1(uc), sizeof(UWord));
   VKI_UC_GUEST_CC_DEP2(uc) = tst->arch.vex.guest_CC_DEP2;
   VG_TRACK(copy_reg_to_mem, part, tid,
            offsetof(VexGuestX86State, guest_CC_DEP2),
            (Addr)&VKI_UC_GUEST_CC_DEP2(uc), sizeof(UWord));
   /* Make another copy of eflags. */
   VKI_UC_GUEST_EFLAGS_NEG(uc) = ~uc->uc_mcontext.gregs[VKI_EFL];
   /* Calculate a checksum. */
   {
      UInt buf[5];
      UInt checksum;

      buf[0] = VKI_UC_GUEST_CC_OP(uc);
      buf[1] = VKI_UC_GUEST_CC_NDEP(uc);
      buf[2] = VKI_UC_GUEST_CC_DEP1(uc);
      buf[3] = VKI_UC_GUEST_CC_DEP2(uc);
      buf[4] = uc->uc_mcontext.gregs[VKI_EFL];
      checksum = ML_(fletcher32)((UShort*)&buf, sizeof(buf) / sizeof(UShort));
      /* Store the checksum. */
      VKI_UC_GUEST_EFLAGS_CHECKSUM(uc) = checksum;
   }

   /* FPU */
   /* x87 */
   vg_assert(sizeof(fs->state) == 108);
   LibVEX_GuestX86_get_x87(&tst->arch.vex, (UChar*)&fs->state);

   /* Flags and control words */
   VG_TRACK(post_mem_write, part, tid, (Addr)&fs->state, 28);
   /* ST registers */
   for (i = 0; i < 8; i++) {
      Addr addr = (Addr)&fs->state + 28 + i * 10;
      /* x87 uses 80b FP registers but VEX uses only 64b registers, thus we
         have to lie here. :< */
      VG_TRACK(copy_reg_to_mem, part, tid, offsetof(VexGuestX86State,
               guest_FPREG[i]), addr, sizeof(ULong));
      VG_TRACK(copy_reg_to_mem, part, tid, offsetof(VexGuestX86State,
               guest_FPREG[i]), addr + 8, sizeof(UShort));
      }

   /* Status word (sw) at exception */
   fs->status = 0;
   VG_TRACK(post_mem_write, part, tid, (Addr)&fs->status, sizeof(fs->status));

   /* SSE */
   fs->mxcsr = LibVEX_GuestX86_get_mxcsr(&tst->arch.vex);
   VG_TRACK(post_mem_write, part, tid, (Addr)&fs->mxcsr, sizeof(fs->mxcsr));

   /* MXCSR at exception */
   fs->xstatus = 0;
   VG_TRACK(post_mem_write, part, tid, (Addr)&fs->xstatus,
            sizeof(fs->xstatus));

   /* XMM registers */
#define COPY_OUT_XMM(dest, src) \
   do {                         \
      dest._l[0] = src[0];      \
      dest._l[1] = src[1];      \
      dest._l[2] = src[2];      \
      dest._l[3] = src[3];      \
   } while (0)
   COPY_OUT_XMM(fs->xmm[0], tst->arch.vex.guest_XMM0);
   VG_TRACK(copy_reg_to_mem, part, tid, offsetof(VexGuestX86State,
            guest_XMM0), (Addr)&fs->xmm[0], sizeof(U128));
   COPY_OUT_XMM(fs->xmm[1], tst->arch.vex.guest_XMM1);
   VG_TRACK(copy_reg_to_mem, part, tid, offsetof(VexGuestX86State,
            guest_XMM1), (Addr)&fs->xmm[1], sizeof(U128));
   COPY_OUT_XMM(fs->xmm[2], tst->arch.vex.guest_XMM2);
   VG_TRACK(copy_reg_to_mem, part, tid, offsetof(VexGuestX86State,
            guest_XMM2), (Addr)&fs->xmm[2], sizeof(U128));
   COPY_OUT_XMM(fs->xmm[3], tst->arch.vex.guest_XMM3);
   VG_TRACK(copy_reg_to_mem, part, tid, offsetof(VexGuestX86State,
            guest_XMM3), (Addr)&fs->xmm[3], sizeof(U128));
   COPY_OUT_XMM(fs->xmm[4], tst->arch.vex.guest_XMM4);
   VG_TRACK(copy_reg_to_mem, part, tid, offsetof(VexGuestX86State,
            guest_XMM4), (Addr)&fs->xmm[4], sizeof(U128));
   COPY_OUT_XMM(fs->xmm[5], tst->arch.vex.guest_XMM5);
   VG_TRACK(copy_reg_to_mem, part, tid, offsetof(VexGuestX86State,
            guest_XMM5), (Addr)&fs->xmm[5], sizeof(U128));
   COPY_OUT_XMM(fs->xmm[6], tst->arch.vex.guest_XMM6);
   VG_TRACK(copy_reg_to_mem, part, tid, offsetof(VexGuestX86State,
            guest_XMM6), (Addr)&fs->xmm[6], sizeof(U128));
   COPY_OUT_XMM(fs->xmm[7], tst->arch.vex.guest_XMM7);
   VG_TRACK(copy_reg_to_mem, part, tid, offsetof(VexGuestX86State,
            guest_XMM7), (Addr)&fs->xmm[7], sizeof(U128));
#undef COPY_OUT_XMM
}

/* Architecture-specific part of VG_(restore_context). */
void ML_(restore_machine_context)(ThreadId tid, vki_ucontext_t *uc,
                                  CorePart part, Bool esp_is_thrptr)
{
   ThreadState *tst = VG_(get_ThreadState)(tid);
   struct vki_fpchip_state *fs
      = &uc->uc_mcontext.fpregs.fp_reg_set.fpchip_state;

   /* CPU */
   if (uc->uc_flags & VKI_UC_CPU) {
      /* Common registers */
      tst->arch.vex.guest_EIP = uc->uc_mcontext.gregs[VKI_EIP];
      VG_TRACK(copy_mem_to_reg, part, tid,
               (Addr)&uc->uc_mcontext.gregs[VKI_EIP], OFFSET_x86_EIP,
               sizeof(UWord));
      tst->arch.vex.guest_EAX = uc->uc_mcontext.gregs[VKI_EAX];
      VG_TRACK(copy_mem_to_reg, part, tid,
               (Addr)&uc->uc_mcontext.gregs[VKI_EAX], OFFSET_x86_EAX,
               sizeof(UWord));
      tst->arch.vex.guest_EBX = uc->uc_mcontext.gregs[VKI_EBX];
      VG_TRACK(copy_mem_to_reg, part, tid,
               (Addr)&uc->uc_mcontext.gregs[VKI_EBX], OFFSET_x86_EBX,
               sizeof(UWord));
      tst->arch.vex.guest_ECX = uc->uc_mcontext.gregs[VKI_ECX];
      VG_TRACK(copy_mem_to_reg, part, tid,
               (Addr)&uc->uc_mcontext.gregs[VKI_ECX], OFFSET_x86_ECX,
               sizeof(UWord));
      tst->arch.vex.guest_EDX = uc->uc_mcontext.gregs[VKI_EDX];
      VG_TRACK(copy_mem_to_reg, part, tid,
               (Addr)&uc->uc_mcontext.gregs[VKI_EDX], OFFSET_x86_EDX,
               sizeof(UWord));
      tst->arch.vex.guest_EBP = uc->uc_mcontext.gregs[VKI_EBP];
      VG_TRACK(copy_mem_to_reg, part, tid,
               (Addr)&uc->uc_mcontext.gregs[VKI_EBP], OFFSET_x86_EBP,
               sizeof(UWord));
      tst->arch.vex.guest_ESI = uc->uc_mcontext.gregs[VKI_ESI];
      VG_TRACK(copy_mem_to_reg, part, tid,
               (Addr)&uc->uc_mcontext.gregs[VKI_ESI], OFFSET_x86_ESI,
               sizeof(UWord));
      tst->arch.vex.guest_EDI = uc->uc_mcontext.gregs[VKI_EDI];
      VG_TRACK(copy_mem_to_reg, part, tid,
               (Addr)&uc->uc_mcontext.gregs[VKI_EDI], OFFSET_x86_EDI,
               sizeof(UWord));
      tst->arch.vex.guest_ESP = uc->uc_mcontext.gregs[VKI_UESP];
      VG_TRACK(copy_mem_to_reg, part, tid,
               (Addr)&uc->uc_mcontext.gregs[VKI_UESP], OFFSET_x86_ESP,
               sizeof(UWord));

      if (esp_is_thrptr) {
         /* The thrptr value is passed by libc to the kernel in the otherwise
            unused ESP field.  This is used when a new thread is created. */
         VG_TRACK(pre_mem_read, part, tid,
                  "restore_machine_context(uc->uc_mcontext.gregs[VKI_ESP])",
                  (Addr)&uc->uc_mcontext.gregs[VKI_ESP], sizeof(UWord));
         if (uc->uc_mcontext.gregs[VKI_ESP]) {
            tst->os_state.thrptr = uc->uc_mcontext.gregs[VKI_ESP];
            ML_(update_gdt_lwpgs)(tid);
         }
      }

      /* Ignore ERR and TRAPNO. */

      /* Segment registers */
      tst->arch.vex.guest_CS = uc->uc_mcontext.gregs[VKI_CS];
      VG_TRACK(copy_mem_to_reg, part, tid,
               (Addr)&uc->uc_mcontext.gregs[VKI_CS], OFFSET_x86_CS,
               sizeof(UShort));
      tst->arch.vex.guest_DS = uc->uc_mcontext.gregs[VKI_DS];
      VG_TRACK(copy_mem_to_reg, part, tid,
               (Addr)&uc->uc_mcontext.gregs[VKI_DS], OFFSET_x86_DS,
               sizeof(UShort));
      tst->arch.vex.guest_SS = uc->uc_mcontext.gregs[VKI_SS];
      VG_TRACK(copy_mem_to_reg, part, tid,
               (Addr)&uc->uc_mcontext.gregs[VKI_SS], OFFSET_x86_SS,
               sizeof(UShort));
      tst->arch.vex.guest_ES = uc->uc_mcontext.gregs[VKI_ES];
      VG_TRACK(copy_mem_to_reg, part, tid,
               (Addr)&uc->uc_mcontext.gregs[VKI_ES], OFFSET_x86_ES,
               sizeof(UShort));
      tst->arch.vex.guest_FS = uc->uc_mcontext.gregs[VKI_FS];
      VG_TRACK(copy_mem_to_reg, part, tid,
               (Addr)&uc->uc_mcontext.gregs[VKI_FS], OFFSET_x86_FS,
               sizeof(UShort));
      tst->arch.vex.guest_GS = uc->uc_mcontext.gregs[VKI_GS];
      VG_TRACK(copy_mem_to_reg, part, tid,
               (Addr)&uc->uc_mcontext.gregs[VKI_GS], OFFSET_x86_GS,
               sizeof(UShort));

      /* Eflags */
      {
         UInt eflags;
         UInt orig_eflags;
         UInt new_eflags;
         Bool ok_restore = False;

         VG_TRACK(pre_mem_read, part, tid,
                  "restore_machine_context(uc->uc_mcontext.gregs[VKI_EFL])",
                  (Addr)&uc->uc_mcontext.gregs[VKI_EFL], sizeof(UWord));
         eflags = uc->uc_mcontext.gregs[VKI_EFL];
         orig_eflags = LibVEX_GuestX86_get_eflags(&tst->arch.vex);
         new_eflags = eflags;
         /* The kernel disallows the ID flag to be changed via the setcontext
            call, thus do the same. */
         if (orig_eflags & VKI_EFLAGS_ID_BIT)
            new_eflags |= VKI_EFLAGS_ID_BIT;
         else
            new_eflags &= ~VKI_EFLAGS_ID_BIT;
         LibVEX_GuestX86_put_eflags(new_eflags, &tst->arch.vex);
         VG_TRACK(post_reg_write, part, tid,
                  offsetof(VexGuestX86State, guest_CC_DEP1), sizeof(UWord));
         VG_TRACK(post_reg_write, part, tid,
                  offsetof(VexGuestX86State, guest_CC_DEP2), sizeof(UWord));

         /* Check if this context was created by us in VG_(save_context). In
            that case, try to restore the CC_OP, CC_DEP1, CC_DEP2 and CC_NDEP
            values which we previously stashed into unused members of the
            context. */
         if (eflags != ~VKI_UC_GUEST_EFLAGS_NEG(uc)) {
            VG_(debugLog)(1, "syswrap-solaris",
                             "The eflags value was restored from an "
                             "explicitly set value in thread %u.\n", tid);
            ok_restore = True;
         }
         else {
            UInt buf[5];
            UInt checksum;

            buf[0] = VKI_UC_GUEST_CC_OP(uc);
            buf[1] = VKI_UC_GUEST_CC_NDEP(uc);
            buf[2] = VKI_UC_GUEST_CC_DEP1(uc);
            buf[3] = VKI_UC_GUEST_CC_DEP2(uc);
            buf[4] = eflags;
            checksum = ML_(fletcher32)((UShort*)&buf,
                                       sizeof(buf) / sizeof(UShort));
            if (checksum == VKI_UC_GUEST_EFLAGS_CHECKSUM(uc)) {
               /* Check ok, the full restoration is possible. */
               VG_(debugLog)(1, "syswrap-solaris",
                                "The CC_* guest state values were fully "
                                "restored in thread %u.\n", tid);
               ok_restore = True;

               tst->arch.vex.guest_CC_OP = VKI_UC_GUEST_CC_OP(uc);
               tst->arch.vex.guest_CC_NDEP = VKI_UC_GUEST_CC_NDEP(uc);
               tst->arch.vex.guest_CC_DEP1 = VKI_UC_GUEST_CC_DEP1(uc);
               VG_TRACK(copy_mem_to_reg, part, tid,
                        (Addr)&VKI_UC_GUEST_CC_DEP1(uc),
                        offsetof(VexGuestX86State, guest_CC_DEP1),
                        sizeof(UWord));
               tst->arch.vex.guest_CC_DEP2 = VKI_UC_GUEST_CC_DEP2(uc);
               VG_TRACK(copy_mem_to_reg, part, tid,
                        (Addr)&VKI_UC_GUEST_CC_DEP2(uc),
                        offsetof(VexGuestX86State, guest_CC_DEP2),
                        sizeof(UWord));
            }
         }

         if (!ok_restore)
            VG_(debugLog)(1, "syswrap-solaris",
                             "Cannot fully restore the CC_* guest state "
                             "values, using approximate eflags in thread "
                             "%u.\n", tid);
      }
   }

   if (uc->uc_flags & VKI_UC_FPU) {
      /* FPU */
      VexEmNote note;
      SizeT i;

      /* x87 */
      /* Flags and control words */
      VG_TRACK(pre_mem_read, part, tid,
               "restore_machine_context(uc->uc_mcontext.fpregs..x87_state)",
               (Addr)&fs->state, 28);
      /* ST registers */
      for (i = 0; i < 8; i++) {
         Addr addr = (Addr)&fs->state + 28 + i * 10;
         VG_TRACK(copy_mem_to_reg, part, tid, addr,
                  offsetof(VexGuestX86State, guest_FPREG[i]), sizeof(ULong));
      }
      note = LibVEX_GuestX86_put_x87((UChar*)&fs->state, &tst->arch.vex);
      if (note != EmNote_NONE)
         VG_(message)(Vg_UserMsg,
                      "Error restoring x87 state in thread %u: %s.\n",
                      tid, LibVEX_EmNote_string(note));

      /* SSE */
      VG_TRACK(pre_mem_read, part, tid,
               "restore_machine_context(uc->uc_mcontext.fpregs..mxcsr)",
               (Addr)&fs->mxcsr, sizeof(fs->mxcsr));
      note = LibVEX_GuestX86_put_mxcsr(fs->mxcsr, &tst->arch.vex);
      if (note != EmNote_NONE)
         VG_(message)(Vg_UserMsg,
                      "Error restoring mxcsr state in thread %u: %s.\n",
                      tid, LibVEX_EmNote_string(note));
      /* XMM registers */
#define COPY_IN_XMM(src, dest) \
      do {                     \
         dest[0] = src._l[0];  \
         dest[1] = src._l[1];  \
         dest[2] = src._l[2];  \
         dest[3] = src._l[3];  \
      } while (0)
      COPY_IN_XMM(fs->xmm[0], tst->arch.vex.guest_XMM0);
      VG_TRACK(copy_mem_to_reg, part, tid, (Addr)&fs->xmm[0],
               offsetof(VexGuestX86State, guest_XMM0), sizeof(U128));
      COPY_IN_XMM(fs->xmm[1], tst->arch.vex.guest_XMM1);
      VG_TRACK(copy_mem_to_reg, part, tid, (Addr)&fs->xmm[1],
               offsetof(VexGuestX86State, guest_XMM1), sizeof(U128));
      COPY_IN_XMM(fs->xmm[2], tst->arch.vex.guest_XMM2);
      VG_TRACK(copy_mem_to_reg, part, tid, (Addr)&fs->xmm[2],
               offsetof(VexGuestX86State, guest_XMM2), sizeof(U128));
      COPY_IN_XMM(fs->xmm[3], tst->arch.vex.guest_XMM3);
      VG_TRACK(copy_mem_to_reg, part, tid, (Addr)&fs->xmm[3],
               offsetof(VexGuestX86State, guest_XMM3), sizeof(U128));
      COPY_IN_XMM(fs->xmm[4], tst->arch.vex.guest_XMM4);
      VG_TRACK(copy_mem_to_reg, part, tid, (Addr)&fs->xmm[4],
               offsetof(VexGuestX86State, guest_XMM4), sizeof(U128));
      COPY_IN_XMM(fs->xmm[5], tst->arch.vex.guest_XMM5);
      VG_TRACK(copy_mem_to_reg, part, tid, (Addr)&fs->xmm[5],
               offsetof(VexGuestX86State, guest_XMM5), sizeof(U128));
      COPY_IN_XMM(fs->xmm[6], tst->arch.vex.guest_XMM6);
      VG_TRACK(copy_mem_to_reg, part, tid, (Addr)&fs->xmm[6],
               offsetof(VexGuestX86State, guest_XMM6), sizeof(U128));
      COPY_IN_XMM(fs->xmm[7], tst->arch.vex.guest_XMM7);
      VG_TRACK(copy_mem_to_reg, part, tid, (Addr)&fs->xmm[7],
               offsetof(VexGuestX86State, guest_XMM7), sizeof(U128));
#undef COPY_IN_XMM
   }
}

/* Allocate GDT for a given thread. */
void ML_(setup_gdt)(VexGuestX86State *vex)
{
   Addr gdt = (Addr)VG_(calloc)("syswrap-solaris-x86.gdt",
                                VEX_GUEST_X86_GDT_NENT,
                                sizeof(VexGuestX86SegDescr));
   vex->guest_GDT = gdt;
}

/* Deallocate GDT for a given thread. */
void ML_(cleanup_gdt)(VexGuestX86State *vex)
{
   if (!vex->guest_GDT)
      return;
   VG_(free)((void *) (HWord) vex->guest_GDT);
   vex->guest_GDT = 0;
}

/* For a given thread, update the LWPGS descriptor in the thread's GDT
   according to the thread pointer. */
void ML_(update_gdt_lwpgs)(ThreadId tid)
{
   ThreadState *tst = VG_(get_ThreadState)(tid);
   Addr base = tst->os_state.thrptr;
   VexGuestX86SegDescr *gdt
      = (VexGuestX86SegDescr *) (HWord) tst->arch.vex.guest_GDT;
   VexGuestX86SegDescr desc;

   vg_assert(gdt);

   VG_(memset)(&desc, 0, sizeof(desc));
   if (base) {
      desc.LdtEnt.Bits.LimitLow = -1;
      desc.LdtEnt.Bits.LimitHi = -1;
      desc.LdtEnt.Bits.BaseLow = base & 0xffff;
      desc.LdtEnt.Bits.BaseMid = (base >> 16) & 0xff;
      desc.LdtEnt.Bits.BaseHi = (base >> 24) & 0xff;
      desc.LdtEnt.Bits.Pres = 1;
      desc.LdtEnt.Bits.Dpl = 3; /* SEL_UPL */
      desc.LdtEnt.Bits.Type = 19; /* SDT_MEMRWA */
      desc.LdtEnt.Bits.Granularity = 1; /* SDP_PAGES */
      desc.LdtEnt.Bits.Default_Big = 1; /* SDP_OP32 */
   }

   gdt[VKI_GDT_LWPGS] = desc;

   /* Write %gs. */
   tst->arch.vex.guest_GS = VKI_LWPGS_SEL;
   VG_TRACK(post_reg_write, Vg_CoreSysCall, tid, OFFSET_x86_GS,
            sizeof(UShort));
}


/* ---------------------------------------------------------------------
   PRE/POST wrappers for x86/Solaris-specific syscalls
   ------------------------------------------------------------------ */

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

/* implementation */

PRE(sys_fstatat64)
{
   /* int fstatat64(int fildes, const char *path, struct stat64 *buf,
                    int flag); */
   PRINT("sys_fstatat64 ( %ld, %#lx(%s), %#lx, %ld )", SARG1, ARG2,
         (HChar*)ARG2, ARG3, SARG4);
   PRE_REG_READ4(long, "fstatat64", int, fildes, const char *, path,
                 struct stat64 *, buf, int, flag);
   if (ARG2)
      PRE_MEM_RASCIIZ("fstatat64(path)", ARG2);
   PRE_MEM_WRITE("fstatat64(buf)", ARG3, sizeof(struct vki_stat64));

   /* Be strict. */
   if (ARG1 != VKI_AT_FDCWD &&
       !ML_(fd_allowed)(ARG1, "fstatat64", tid, False))
      SET_STATUS_Failure(VKI_EBADF);
}

POST(sys_fstatat64)
{
   POST_MEM_WRITE(ARG3, sizeof(struct vki_stat64));
}

PRE(sys_openat64)
{
   /* int openat64(int fildes, const char *filename, int flags);
      int openat64(int fildes, const char *filename, int flags, mode_t mode);
    */
   *flags |= SfMayBlock;

   if (ARG3 & VKI_O_CREAT) {
      /* 4-arg version */
      PRINT("sys_openat64 ( %ld, %#lx(%s), %ld, %ld )", SARG1, ARG2,
            (HChar*)ARG2, SARG3, SARG4);
      PRE_REG_READ4(long, "openat64", int, fildes, const char *, filename,
                    int, flags, vki_mode_t, mode);
   }
   else {
      /* 3-arg version */
      PRINT("sys_openat64 ( %ld, %#lx(%s), %ld )", SARG1, ARG2, (HChar*)ARG2,
            SARG3);
      PRE_REG_READ3(long, "openat64", int, fildes, const char *, filename,
                    int, flags);
   }

   PRE_MEM_RASCIIZ("openat64(filename)", ARG2);

   /* Be strict. */
   if (ARG1 != VKI_AT_FDCWD && !ML_(fd_allowed)(ARG1, "openat64", tid, False))
      SET_STATUS_Failure(VKI_EBADF);
}

POST(sys_openat64)
{
   if (!ML_(fd_allowed)(RES, "openat64", tid, True)) {
      VG_(close)(RES);
      SET_STATUS_Failure(VKI_EMFILE);
   }
   else if (VG_(clo_track_fds))
      ML_(record_fd_open_with_given_name)(tid, RES, (HChar*)ARG2);
}

PRE(sys_llseek32)
{
   /* offset_t llseek(int fildes, offset_t offset, int whence); */
   PRINT("sys_llseek32 ( %ld, %#lx, %#lx, %ld )", SARG1, ARG2, ARG3, SARG4);
   PRE_REG_READ4(long, "llseek", int, fildes, vki_u32, offset_low,
                 vki_u32, offset_high, int, whence);

   /* Stay sane. */
   if (!ML_(fd_allowed)(ARG1, "llseek", tid, False))
      SET_STATUS_Failure(VKI_EBADF);
}

PRE(sys_mmap64)
{
   /* void *mmap64(void *addr, size_t len, int prot, int flags,
                   int fildes, uint32_t offlo, uint32_t offhi); */
   /* Note this wrapper assumes a little-endian architecture, offlo and offhi
      have to be swapped if a big-endian architecture is present. */
#if !defined(VG_LITTLEENDIAN)
#error "Unexpected endianness."
#endif /* !VG_LITTLEENDIAN */

   SysRes r;
   ULong u;
   Off64T offset;

   /* Stay sane. */
   vg_assert(VKI_PAGE_SIZE == 4096);
   vg_assert(sizeof(u) == sizeof(offset));

   PRINT("sys_mmap ( %#lx, %#lx, %#lx, %#lx, %ld, %#lx, %#lx )",
         ARG1, ARG2, ARG3, ARG4, SARG5, ARG6, ARG7);
   PRE_REG_READ7(long, "mmap", void *, start, vki_size_t, length,
                 int, prot, int, flags, int, fd, uint32_t, offlo,
                 uint32_t, offhi);

   /* The offlo and offhi values can actually represent a negative value.
      Make sure it's passed correctly to the generic mmap wrapper. */
   u = ((ULong)ARG7 << 32) + ARG6;
   offset = *(Off64T*)&u;

   r = ML_(generic_PRE_sys_mmap)(tid, ARG1, ARG2, ARG3, ARG4, ARG5, offset);
   SET_STATUS_from_SysRes(r);
}

PRE(sys_stat64)
{
   /* int stat64(const char *path, struct stat64 *buf); */
   PRINT("sys_stat64 ( %#lx(%s), %#lx )", ARG1, (HChar*)ARG1, ARG2);
   PRE_REG_READ2(long, "stat64", const char *, path, struct stat64 *, buf);

   PRE_MEM_RASCIIZ("stat64(path)", ARG1);
   PRE_MEM_WRITE("stat64(buf)", ARG2, sizeof(struct vki_stat64));
}

POST(sys_stat64)
{
   POST_MEM_WRITE(ARG2, sizeof(struct vki_stat64));
}

PRE(sys_lstat64)
{
   /* int lstat64(const char *path, struct stat64 *buf); */
   PRINT("sys_lstat64 ( %#lx(%s), %#lx )", ARG1, (HChar*)ARG1, ARG2);
   PRE_REG_READ2(long, "lstat64", const char *, path, struct stat64 *, buf);

   PRE_MEM_RASCIIZ("lstat64(path)", ARG1);
   PRE_MEM_WRITE("lstat64(buf)", ARG2, sizeof(struct vki_stat64));
}

POST(sys_lstat64)
{
   POST_MEM_WRITE(ARG2, sizeof(struct vki_stat64));
}

PRE(sys_fstat64)
{
   /* int fstat64(int fildes, struct stat64 *buf); */
   PRINT("sys_fstat64 ( %ld, %#lx )", SARG1, ARG2);
   PRE_REG_READ2(long, "fstat64", int, fildes, struct stat64 *, buf);
   PRE_MEM_WRITE("fstat64(buf)", ARG2, sizeof(struct vki_stat64));

   /* Be strict. */
   if (!ML_(fd_allowed)(ARG1, "fstat64", tid, False))
      SET_STATUS_Failure(VKI_EBADF);
}

POST(sys_fstat64)
{
   POST_MEM_WRITE(ARG2, sizeof(struct vki_stat64));
}

static void do_statvfs64_post(struct vki_statvfs64 *stats, ThreadId tid)
{
   POST_FIELD_WRITE(stats->f_bsize);
   POST_FIELD_WRITE(stats->f_frsize);
   POST_FIELD_WRITE(stats->f_blocks);
   POST_FIELD_WRITE(stats->f_bfree);
   POST_FIELD_WRITE(stats->f_bavail);
   POST_FIELD_WRITE(stats->f_files);
   POST_FIELD_WRITE(stats->f_ffree);
   POST_FIELD_WRITE(stats->f_favail);
   POST_FIELD_WRITE(stats->f_fsid);
   POST_MEM_WRITE((Addr) stats->f_basetype, VG_(strlen)(stats->f_basetype) + 1);
   POST_FIELD_WRITE(stats->f_flag);
   POST_FIELD_WRITE(stats->f_namemax);
   POST_MEM_WRITE((Addr) stats->f_fstr, VG_(strlen)(stats->f_fstr) + 1);
}

PRE(sys_statvfs64)
{
   /* int statvfs64(const char *path, struct statvfs64 *buf); */
   *flags |= SfMayBlock;
   PRINT("sys_statvfs64 ( %#lx(%s), %#lx )", ARG1, (HChar *) ARG1, ARG2);
   PRE_REG_READ2(long, "statvfs64", const char *, path,
                 struct vki_statvfs64 *, buf);
   PRE_MEM_RASCIIZ("statvfs64(path)", ARG1);
   PRE_MEM_WRITE("statvfs64(buf)", ARG2, sizeof(struct vki_statvfs64));
}

POST(sys_statvfs64)
{
   do_statvfs64_post((struct vki_statvfs64 *) ARG2, tid);
}

PRE(sys_fstatvfs64)
{
   /* int fstatvfs64(int fd, struct statvfs64 *buf); */
   *flags |= SfMayBlock;
   PRINT("sys_fstatvfs64 ( %ld, %#lx )", SARG1, ARG2);
   PRE_REG_READ2(long, "fstatvfs64", int, fd, struct vki_statvfs64 *, buf);
   PRE_MEM_WRITE("fstatvfs64(buf)", ARG2, sizeof(struct vki_statvfs64));

   /* Be strict. */
   if (!ML_(fd_allowed)(ARG1, "fstatvfs64", tid, False))
      SET_STATUS_Failure(VKI_EBADF);
}

POST(sys_fstatvfs64)
{
   do_statvfs64_post((struct vki_statvfs64 *) ARG2, tid);
}

PRE(sys_setrlimit64)
{
   /* int setrlimit64(int resource, struct rlimit64 *rlim); */
   struct vki_rlimit64 *limit = (struct vki_rlimit64 *)ARG2;
   PRINT("sys_setrlimit64 ( %ld, %#lx )", SARG1, ARG2);
   PRE_REG_READ2(long, "setrlimit64", int, resource, struct rlimit64 *, rlim);
   PRE_MEM_READ("setrlimit64(rlim)", ARG2, sizeof(struct vki_rlimit64));

   if (limit && limit->rlim_cur > limit->rlim_max)
      SET_STATUS_Failure(VKI_EINVAL);
   else if (ARG1 == VKI_RLIMIT_NOFILE) {
      if (limit->rlim_cur > VG_(fd_hard_limit) ||
          limit->rlim_max != VG_(fd_hard_limit)) {
         SET_STATUS_Failure(VKI_EPERM);
      }
      else {
         VG_(fd_soft_limit) = limit->rlim_cur;
         SET_STATUS_Success(0);
      }
   }
   else if (ARG1 == VKI_RLIMIT_DATA) {
      if (limit->rlim_cur > VG_(client_rlimit_data).rlim_max ||
          limit->rlim_max > VG_(client_rlimit_data).rlim_max) {
         SET_STATUS_Failure(VKI_EPERM);
      }
      else {
         VG_(client_rlimit_data).rlim_max = limit->rlim_max;
         VG_(client_rlimit_data).rlim_cur = limit->rlim_cur;
         SET_STATUS_Success(0);
      }
   }
   else if (ARG1 == VKI_RLIMIT_STACK && tid == 1) {
      if (limit->rlim_cur > VG_(client_rlimit_stack).rlim_max ||
          limit->rlim_max > VG_(client_rlimit_stack).rlim_max) {
         SET_STATUS_Failure(VKI_EPERM);
      }
      else {
         /* Change the value of client_stack_szB to the rlim_cur value but
            only if it is smaller than the size of the allocated stack for the
            client. */
         if (limit->rlim_cur <= VG_(clstk_max_size))
            VG_(threads)[tid].client_stack_szB = limit->rlim_cur;

         VG_(client_rlimit_stack).rlim_max = limit->rlim_max;
         VG_(client_rlimit_stack).rlim_cur = limit->rlim_cur;
         SET_STATUS_Success(0);
      }
   }
}

PRE(sys_getrlimit64)
{
   /* int getrlimit64(int resource, struct rlimit64 *rlim); */
   PRINT("sys_getrlimit64 ( %ld, %#lx )", SARG1, ARG2);
   PRE_REG_READ2(long, "getrlimit64",
                 int, resource, struct rlimit64 *, rlim);
   PRE_MEM_WRITE("getrlimit64(rlim)", ARG2, sizeof(struct vki_rlimit64));
}

POST(sys_getrlimit64)
{
   /* Based on common_post_getrlimit() from syswrap-generic.c. */
   struct vki_rlimit64 *rlim = (struct vki_rlimit64*)ARG2;

   POST_MEM_WRITE(ARG2, sizeof(struct vki_rlimit64));

   switch (ARG1 /*resource*/) {
   case VKI_RLIMIT_NOFILE:
      rlim->rlim_cur = VG_(fd_soft_limit);
      rlim->rlim_max = VG_(fd_hard_limit);
      break;
   case VKI_RLIMIT_DATA:
      rlim->rlim_cur = VG_(client_rlimit_data).rlim_cur;
      rlim->rlim_max = VG_(client_rlimit_data).rlim_max;
      break;
   case VKI_RLIMIT_STACK:
      rlim->rlim_cur = VG_(client_rlimit_stack).rlim_cur;
      rlim->rlim_max = VG_(client_rlimit_stack).rlim_max;
      break;
   }
}

PRE(sys_pread64)
{
   /* ssize32_t pread64(int fd, void *buf, size32_t count,
                        uint32_t offset_1, uint32_t offset_2);
    */
   *flags |= SfMayBlock;
   PRINT("sys_pread64 ( %ld, %#lx, %lu, %#lx, %#lx )",
         SARG1, ARG2, ARG3, ARG4, ARG5);
   PRE_REG_READ5(long, "pread64", int, fd, void *, buf, vki_size32_t, count,
                 vki_uint32_t, offset_1, vki_uint32_t, offset_2);
   PRE_MEM_WRITE("pread64(buf)", ARG2, ARG3);

   /* Be strict. */
   if (!ML_(fd_allowed)(ARG1, "pread64", tid, False))
      SET_STATUS_Failure(VKI_EBADF);
}

POST(sys_pread64)
{
   POST_MEM_WRITE(ARG2, RES);
}

PRE(sys_pwrite64)
{
   /* ssize32_t pwrite64(int fd, void *buf, size32_t count,
                         uint32_t offset_1, uint32_t offset_2);
    */
   *flags |= SfMayBlock;
   PRINT("sys_pwrite64 ( %ld, %#lx, %lu, %#lx, %#lx )",
         SARG1, ARG2, ARG3, ARG4, ARG5);
   PRE_REG_READ5(long, "pwrite64", int, fd, void *, buf, vki_size32_t, count,
                 vki_uint32_t, offset_1, vki_uint32_t, offset_2);
   PRE_MEM_READ("pwrite64(buf)", ARG2, ARG3);

   /* Be strict. */
   if (!ML_(fd_allowed)(ARG1, "pwrite64", tid, False))
      SET_STATUS_Failure(VKI_EBADF);
}

PRE(sys_open64)
{
   /* int open64(const char *filename, int flags);
      int open64(const char *filename, int flags, mode_t mode); */
   *flags |= SfMayBlock;

   if (ARG2 & VKI_O_CREAT) {
      /* 3-arg version */
      PRINT("sys_open64 ( %#lx(%s), %#lx, %ld )", ARG1, (HChar*)ARG1, ARG2,
            SARG3);
      PRE_REG_READ3(long, "open64", const char *, filename, int, flags,
                    vki_mode_t, mode);
   }
   else {
      /* 2-arg version */
      PRINT("sys_open64 ( %#lx(%s), %#lx )", ARG1, (HChar*)ARG1, ARG2);
      PRE_REG_READ2(long, "open64", const char *, filename, int, flags);
   }
   PRE_MEM_RASCIIZ("open(filename)", ARG1);
}

POST(sys_open64)
{
   if (!ML_(fd_allowed)(RES, "open64", tid, True)) {
      VG_(close)(RES);
      SET_STATUS_Failure(VKI_EMFILE);
   }
   else if (VG_(clo_track_fds))
      ML_(record_fd_open_with_given_name)(tid, RES, (HChar*)ARG1);
}

#undef PRE
#undef POST

#endif // defined(VGP_x86_solaris)

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