coregrind/m_syswrap/syswrap-amd64-solaris.c

   1
   2 /*--------------------------------------------------------------------*/
   3 /*--- Platform-specific syscalls stuff.    syswrap-amd64-solaris.c ---*/
   4 /*--------------------------------------------------------------------*/
   5
   6 /*
   7    This file is part of Valgrind, a dynamic binary instrumentation
   8    framework.
   9
  10    Copyright (C) 2014-2017 Petr Pavlu
  11       setup@dagobah.cz
  12
  13    This program is free software; you can redistribute it and/or
  14    modify it under the terms of the GNU General Public License as
  15    published by the Free Software Foundation; either version 2 of the
  16    License, or (at your option) any later version.
  17
  18    This program is distributed in the hope that it will be useful, but
  19    WITHOUT ANY WARRANTY; without even the implied warranty of
  20    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  21    General Public License for more details.
  22
  23    You should have received a copy of the GNU General Public License
  24    along with this program; if not, write to the Free Software
  25    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  26    02111-1307, USA.
  27
  28    The GNU General Public License is contained in the file COPYING.
  29 */
  30
  31 #if defined(VGP_amd64_solaris)
  32
  33 #include "libvex_guest_offsets.h"
  34 #include "pub_core_basics.h"
  35 #include "pub_core_debuglog.h"
  36 #include "pub_core_vki.h"
  37 #include "pub_core_libcassert.h"
  38 #include "pub_core_libcbase.h"
  39 #include "pub_core_libcprint.h"
  40 #include "pub_core_libcsignal.h"
  41 #include "pub_core_tooliface.h"
  42 #include "pub_core_syswrap.h"
  43
  44 #include "priv_types_n_macros.h"
  45 #include "priv_syswrap-generic.h"
  46 #include "priv_syswrap-solaris.h"
  47
  48
  49 /* Call f(arg1), but first switch stacks, using 'stack' as the new stack, and
  50    use 'retaddr' as f's return-to address.  Also, clear all the integer
  51    registers before entering f. */
  52 __attribute__((noreturn))
  53 void ML_(call_on_new_stack_0_1)(Addr stack,             /* %rdi */
  54                                 Addr retaddr,           /* %rsi */
  55                                 void (*f)(Word),        /* %rdx */
  56                                 Word arg1);             /* %rcx */
  57 __asm__ (
  58 ".text\n"
  59 ".globl vgModuleLocal_call_on_new_stack_0_1\n"
  60 "vgModuleLocal_call_on_new_stack_0_1:\n"
  61 "   movq  %rdi, %rsp\n"         /* set stack */
  62 "   movq  %rcx, %rdi\n"         /* set arg1 */
  63 "   pushq %rsi\n"               /* retaddr to stack */
  64 "   pushq %rdx\n"               /* f to stack */
  65 "   movq  $0, %rax\n"           /* zero all GP regs (except %rdi) */
  66 "   movq  $0, %rbx\n"
  67 "   movq  $0, %rcx\n"
  68 "   movq  $0, %rdx\n"
  69 "   movq  $0, %rsi\n"
  70 "   movq  $0, %rbp\n"
  71 "   movq  $0, %r8\n"
  72 "   movq  $0, %r9\n"
  73 "   movq  $0, %r10\n"
  74 "   movq  $0, %r11\n"
  75 "   movq  $0, %r12\n"
  76 "   movq  $0, %r13\n"
  77 "   movq  $0, %r14\n"
  78 "   movq  $0, %r15\n"
  79 "   ret\n"                      /* jump to f */
  80 "   ud2\n"                      /* should never get here */
  81 ".previous\n"
  82 );
  83
  84 /* This function is called to setup a context of a new Valgrind thread (which
  85    will run the client code). */
  86 void ML_(setup_start_thread_context)(ThreadId tid, vki_ucontext_t *uc)
  87 {
  88    ThreadState *tst = VG_(get_ThreadState)(tid);
  89    UWord *stack = (UWord*)tst->os_state.valgrind_stack_init_SP;
  90
  91    VG_(memset)(uc, 0, sizeof(*uc));
  92    uc->uc_flags = VKI_UC_CPU | VKI_UC_SIGMASK;
  93
  94    /* Start the thread with everything blocked. */
  95    VG_(sigfillset)(&uc->uc_sigmask);
  96
  97    /* Set up the stack, it should be always 16-byte aligned before doing
  98       a function call, i.e. the first parameter is also 16-byte aligned. */
  99    vg_assert(VG_IS_16_ALIGNED(stack));
 100    stack -= 1;
 101    stack[0] = 0; /* bogus return value */
 102
 103    /* Set up the registers. */
 104    uc->uc_mcontext.gregs[VKI_REG_RDI] = (UWord)tst; /* the parameter */
 105    uc->uc_mcontext.gregs[VKI_REG_RIP] = (UWord)ML_(start_thread_NORETURN);
 106    uc->uc_mcontext.gregs[VKI_REG_RSP] = (UWord)stack;
 107 }
 108
 109 /* Architecture-specific part of VG_(save_context). */
 110 void ML_(save_machine_context)(ThreadId tid, vki_ucontext_t *uc,
 111                                CorePart part)
 112 {
 113    ThreadState *tst = VG_(get_ThreadState)(tid);
 114    struct vki_fpchip_state *fs
 115       = &uc->uc_mcontext.fpregs.fp_reg_set.fpchip_state;
 116    SizeT i;
 117
 118    /* CPU */
 119    /* Common registers */
 120    uc->uc_mcontext.gregs[VKI_REG_RIP] = tst->arch.vex.guest_RIP;
 121    VG_TRACK(copy_reg_to_mem, part, tid, OFFSET_amd64_RIP,
 122             (Addr)&uc->uc_mcontext.gregs[VKI_REG_RIP], sizeof(UWord));
 123    uc->uc_mcontext.gregs[VKI_REG_RAX] = tst->arch.vex.guest_RAX;
 124    VG_TRACK(copy_reg_to_mem, part, tid, OFFSET_amd64_RAX,
 125             (Addr)&uc->uc_mcontext.gregs[VKI_REG_RAX], sizeof(UWord));
 126    uc->uc_mcontext.gregs[VKI_REG_RBX] = tst->arch.vex.guest_RBX;
 127    VG_TRACK(copy_reg_to_mem, part, tid, OFFSET_amd64_RBX,
 128             (Addr)&uc->uc_mcontext.gregs[VKI_REG_RBX], sizeof(UWord));
 129    uc->uc_mcontext.gregs[VKI_REG_RCX] = tst->arch.vex.guest_RCX;
 130    VG_TRACK(copy_reg_to_mem, part, tid, OFFSET_amd64_RCX,
 131             (Addr)&uc->uc_mcontext.gregs[VKI_REG_RCX], sizeof(UWord));
 132    uc->uc_mcontext.gregs[VKI_REG_RDX] = tst->arch.vex.guest_RDX;
 133    VG_TRACK(copy_reg_to_mem, part, tid, OFFSET_amd64_RDX,
 134             (Addr)&uc->uc_mcontext.gregs[VKI_REG_RDX], sizeof(UWord));
 135    uc->uc_mcontext.gregs[VKI_REG_RBP] = tst->arch.vex.guest_RBP;
 136    VG_TRACK(copy_reg_to_mem, part, tid, OFFSET_amd64_RBP,
 137             (Addr)&uc->uc_mcontext.gregs[VKI_REG_RBP], sizeof(UWord));
 138    uc->uc_mcontext.gregs[VKI_REG_RSI] = tst->arch.vex.guest_RSI;
 139    VG_TRACK(copy_reg_to_mem, part, tid, OFFSET_amd64_RSI,
 140             (Addr)&uc->uc_mcontext.gregs[VKI_REG_RSI], sizeof(UWord));
 141    uc->uc_mcontext.gregs[VKI_REG_RDI] = tst->arch.vex.guest_RDI;
 142    VG_TRACK(copy_reg_to_mem, part, tid, OFFSET_amd64_RDI,
 143             (Addr)&uc->uc_mcontext.gregs[VKI_REG_RDI], sizeof(UWord));
 144    uc->uc_mcontext.gregs[VKI_REG_R8] = tst->arch.vex.guest_R8;
 145    VG_TRACK(copy_reg_to_mem, part, tid, OFFSET_amd64_R8,
 146             (Addr)&uc->uc_mcontext.gregs[VKI_REG_R8], sizeof(UWord));
 147    uc->uc_mcontext.gregs[VKI_REG_R9] = tst->arch.vex.guest_R9;
 148    VG_TRACK(copy_reg_to_mem, part, tid, OFFSET_amd64_R9,
 149             (Addr)&uc->uc_mcontext.gregs[VKI_REG_R9], sizeof(UWord));
 150    uc->uc_mcontext.gregs[VKI_REG_R10] = tst->arch.vex.guest_R10;
 151    VG_TRACK(copy_reg_to_mem, part, tid, OFFSET_amd64_R10,
 152             (Addr)&uc->uc_mcontext.gregs[VKI_REG_R10], sizeof(UWord));
 153    uc->uc_mcontext.gregs[VKI_REG_R11] = tst->arch.vex.guest_R11;
 154    VG_TRACK(copy_reg_to_mem, part, tid, OFFSET_amd64_R11,
 155             (Addr)&uc->uc_mcontext.gregs[VKI_REG_R11], sizeof(UWord));
 156    uc->uc_mcontext.gregs[VKI_REG_R12] = tst->arch.vex.guest_R12;
 157    VG_TRACK(copy_reg_to_mem, part, tid, OFFSET_amd64_R12,
 158             (Addr)&uc->uc_mcontext.gregs[VKI_REG_R12], sizeof(UWord));
 159    uc->uc_mcontext.gregs[VKI_REG_R13] = tst->arch.vex.guest_R13;
 160    VG_TRACK(copy_reg_to_mem, part, tid, OFFSET_amd64_R13,
 161             (Addr)&uc->uc_mcontext.gregs[VKI_REG_R13], sizeof(UWord));
 162    uc->uc_mcontext.gregs[VKI_REG_R14] = tst->arch.vex.guest_R14;
 163    VG_TRACK(copy_reg_to_mem, part, tid, OFFSET_amd64_R14,
 164             (Addr)&uc->uc_mcontext.gregs[VKI_REG_R14], sizeof(UWord));
 165    uc->uc_mcontext.gregs[VKI_REG_R15] = tst->arch.vex.guest_R15;
 166    VG_TRACK(copy_reg_to_mem, part, tid, OFFSET_amd64_R15,
 167             (Addr)&uc->uc_mcontext.gregs[VKI_REG_R15], sizeof(UWord));
 168    uc->uc_mcontext.gregs[VKI_REG_RSP] = tst->arch.vex.guest_RSP;
 169    VG_TRACK(copy_reg_to_mem, part, tid, OFFSET_amd64_RSP,
 170             (Addr)&uc->uc_mcontext.gregs[VKI_REG_RSP], sizeof(UWord));
 171
 172    /* ERR and TRAPNO */
 173    uc->uc_mcontext.gregs[VKI_REG_ERR] = 0;
 174    VG_TRACK(post_mem_write, part, tid,
 175             (Addr)&uc->uc_mcontext.gregs[VKI_REG_ERR], sizeof(UWord));
 176    uc->uc_mcontext.gregs[VKI_REG_TRAPNO] = 0;
 177    VG_TRACK(post_mem_write, part, tid,
 178             (Addr)&uc->uc_mcontext.gregs[VKI_REG_TRAPNO], sizeof(UWord));
 179
 180    /* Segment registers */
 181    /* Valgrind does not support moves from/to segment registers on AMD64.  The
 182       values returned below are the ones that are set by the kernel when
 183       a program is started. */
 184    uc->uc_mcontext.gregs[VKI_REG_CS] = VKI_UCS_SEL;
 185    VG_TRACK(post_mem_write, part, tid,
 186             (Addr)&uc->uc_mcontext.gregs[VKI_REG_CS], sizeof(UWord));
 187    uc->uc_mcontext.gregs[VKI_REG_DS] = 0;
 188    VG_TRACK(post_mem_write, part, tid,
 189             (Addr)&uc->uc_mcontext.gregs[VKI_REG_DS], sizeof(UWord));
 190    uc->uc_mcontext.gregs[VKI_REG_SS] = VKI_UDS_SEL;
 191    VG_TRACK(post_mem_write, part, tid,
 192             (Addr)&uc->uc_mcontext.gregs[VKI_REG_SS], sizeof(UWord));
 193    uc->uc_mcontext.gregs[VKI_REG_ES] = 0;
 194    VG_TRACK(post_mem_write, part, tid,
 195             (Addr)&uc->uc_mcontext.gregs[VKI_REG_ES], sizeof(UWord));
 196    uc->uc_mcontext.gregs[VKI_REG_FS] = 0;
 197    VG_TRACK(post_mem_write, part, tid,
 198             (Addr)&uc->uc_mcontext.gregs[VKI_REG_FS], sizeof(UWord));
 199    uc->uc_mcontext.gregs[VKI_REG_GS] = 0;
 200    VG_TRACK(post_mem_write, part, tid,
 201             (Addr)&uc->uc_mcontext.gregs[VKI_REG_GS], sizeof(UWord));
 202
 203    /* Segment bases */
 204    uc->uc_mcontext.gregs[VKI_REG_FSBASE] = tst->arch.vex.guest_FS_CONST;
 205    VG_TRACK(post_mem_write, part, tid,
 206             (Addr)&uc->uc_mcontext.gregs[VKI_REG_FSBASE], sizeof(UWord));
 207    uc->uc_mcontext.gregs[VKI_REG_GSBASE] = 0;
 208    VG_TRACK(post_mem_write, part, tid,
 209             (Addr)&uc->uc_mcontext.gregs[VKI_REG_GSBASE], sizeof(UWord));
 210
 211    /* Handle rflags.  Refer to the x86-solaris variant of this code for
 212       a detailed description. */
 213    uc->uc_mcontext.gregs[VKI_REG_RFL] =
 214       LibVEX_GuestAMD64_get_rflags(&tst->arch.vex);
 215    VG_TRACK(post_mem_write, part, tid,
 216          (Addr)&uc->uc_mcontext.gregs[VKI_REG_RFL], sizeof(UWord));
 217    VKI_UC_GUEST_CC_OP(uc) = tst->arch.vex.guest_CC_OP;
 218    VKI_UC_GUEST_CC_NDEP(uc) = tst->arch.vex.guest_CC_NDEP;
 219    VKI_UC_GUEST_CC_DEP1(uc) = tst->arch.vex.guest_CC_DEP1;
 220    VG_TRACK(copy_reg_to_mem, part, tid,
 221             offsetof(VexGuestAMD64State, guest_CC_DEP1),
 222             (Addr)&VKI_UC_GUEST_CC_DEP1(uc), sizeof(UWord));
 223    VKI_UC_GUEST_CC_DEP2(uc) = tst->arch.vex.guest_CC_DEP2;
 224    VG_TRACK(copy_reg_to_mem, part, tid,
 225             offsetof(VexGuestAMD64State, guest_CC_DEP2),
 226             (Addr)&VKI_UC_GUEST_CC_DEP2(uc), sizeof(UWord));
 227    VKI_UC_GUEST_RFLAGS_NEG(uc) = ~uc->uc_mcontext.gregs[VKI_REG_RFL];
 228    /* Calculate a checksum. */
 229    {
 230       ULong buf[5];
 231       ULong checksum;
 232
 233       buf[0] = VKI_UC_GUEST_CC_OP(uc);
 234       buf[1] = VKI_UC_GUEST_CC_NDEP(uc);
 235       buf[2] = VKI_UC_GUEST_CC_DEP1(uc);
 236       buf[3] = VKI_UC_GUEST_CC_DEP2(uc);
 237       buf[4] = uc->uc_mcontext.gregs[VKI_REG_RFL];
 238       checksum = ML_(fletcher64)((UInt*)&buf, sizeof(buf) / sizeof(UInt));
 239       VKI_UC_GUEST_RFLAGS_CHECKSUM(uc) = checksum;
 240    }
 241
 242    /* FPU */
 243    /* The fpregset_t structure on amd64 follows the layout that is used by the
 244       FXSAVE instruction, therefore it is only necessary to call a VEX
 245       function that simulates this instruction. */
 246    LibVEX_GuestAMD64_fxsave(&tst->arch.vex, (HWord)fs);
 247
 248    /* Control word */
 249    VG_TRACK(post_mem_write, part, tid, (Addr)&fs->cw, sizeof(fs->cw));
 250    /* Status word */
 251    VG_TRACK(post_mem_write, part, tid, (Addr)&fs->sw, sizeof(fs->sw));
 252    /* Compressed tag word */
 253    VG_TRACK(post_mem_write, part, tid, (Addr)&fs->fctw, sizeof(fs->fctw));
 254    /* Unused */
 255    VG_TRACK(post_mem_write, part, tid, (Addr)&fs->__fx_rsvd,
 256             sizeof(fs->__fx_rsvd));
 257    vg_assert(fs->__fx_rsvd == 0);
 258    /* Last x87 opcode */
 259    VG_TRACK(post_mem_write, part, tid, (Addr)&fs->fop, sizeof(fs->fop));
 260    vg_assert(fs->fop == 0);
 261    /* Last x87 instruction pointer */
 262    VG_TRACK(post_mem_write, part, tid, (Addr)&fs->rip, sizeof(fs->rip));
 263    vg_assert(fs->rip == 0);
 264    /* Last x87 data pointer */
 265    VG_TRACK(post_mem_write, part, tid, (Addr)&fs->rdp, sizeof(fs->rdp));
 266    vg_assert(fs->rdp == 0);
 267    /* Media-instruction control and status register */
 268    VG_TRACK(post_mem_write, part, tid, (Addr)&fs->mxcsr, sizeof(fs->mxcsr));
 269    /* Supported features in MXCSR */
 270    VG_TRACK(post_mem_write, part, tid, (Addr)&fs->mxcsr_mask,
 271             sizeof(fs->mxcsr_mask));
 272
 273    /* ST registers */
 274    for (i = 0; i < 8; i++) {
 275       Addr addr = (Addr)&fs->st[i];
 276       /* x87 uses 80b FP registers but VEX uses only 64b registers, thus we
 277          have to lie here. :< */
 278       VG_TRACK(copy_reg_to_mem, part, tid, offsetof(VexGuestAMD64State,
 279                guest_FPREG[i]), addr, sizeof(ULong));
 280       VG_TRACK(copy_reg_to_mem, part, tid, offsetof(VexGuestAMD64State,
 281                guest_FPREG[i]), addr + 8, sizeof(UShort));
 282    }
 283
 284    /* XMM registers */
 285    VG_TRACK(copy_reg_to_mem, part, tid, offsetof(VexGuestAMD64State,
 286             guest_YMM0), (Addr)&fs->xmm[0], sizeof(U128));
 287    VG_TRACK(copy_reg_to_mem, part, tid, offsetof(VexGuestAMD64State,
 288             guest_YMM1), (Addr)&fs->xmm[1], sizeof(U128));
 289    VG_TRACK(copy_reg_to_mem, part, tid, offsetof(VexGuestAMD64State,
 290             guest_YMM2), (Addr)&fs->xmm[2], sizeof(U128));
 291    VG_TRACK(copy_reg_to_mem, part, tid, offsetof(VexGuestAMD64State,
 292             guest_YMM3), (Addr)&fs->xmm[3], sizeof(U128));
 293    VG_TRACK(copy_reg_to_mem, part, tid, offsetof(VexGuestAMD64State,
 294             guest_YMM4), (Addr)&fs->xmm[4], sizeof(U128));
 295    VG_TRACK(copy_reg_to_mem, part, tid, offsetof(VexGuestAMD64State,
 296             guest_YMM5), (Addr)&fs->xmm[5], sizeof(U128));
 297    VG_TRACK(copy_reg_to_mem, part, tid, offsetof(VexGuestAMD64State,
 298             guest_YMM6), (Addr)&fs->xmm[6], sizeof(U128));
 299    VG_TRACK(copy_reg_to_mem, part, tid, offsetof(VexGuestAMD64State,
 300             guest_YMM7), (Addr)&fs->xmm[7], sizeof(U128));
 301
 302    /* Status word (sw) at exception */
 303    fs->status = 0;
 304    VG_TRACK(post_mem_write, part, tid, (Addr)&fs->status, sizeof(fs->status));
 305
 306    /* MXCSR at exception */
 307    fs->xstatus = 0;
 308    VG_TRACK(post_mem_write, part, tid, (Addr)&fs->xstatus,
 309             sizeof(fs->xstatus));
 310 }
 311
 312 /* Architecture-specific part of VG_(restore_context). */
 313 void ML_(restore_machine_context)(ThreadId tid, vki_ucontext_t *uc,
 314                                   CorePart part, Bool esp_is_thrptr)
 315 {
 316    ThreadState *tst = VG_(get_ThreadState)(tid);
 317    struct vki_fpchip_state *fs
 318       = &uc->uc_mcontext.fpregs.fp_reg_set.fpchip_state;
 319
 320    /* CPU */
 321    if (uc->uc_flags & VKI_UC_CPU) {
 322       /* Common registers */
 323       tst->arch.vex.guest_RIP = uc->uc_mcontext.gregs[VKI_REG_RIP];
 324       VG_TRACK(copy_mem_to_reg, part, tid,
 325                (Addr)&uc->uc_mcontext.gregs[VKI_REG_RIP], OFFSET_amd64_RIP,
 326                sizeof(UWord));
 327       tst->arch.vex.guest_RAX = uc->uc_mcontext.gregs[VKI_REG_RAX];
 328       VG_TRACK(copy_mem_to_reg, part, tid,
 329                (Addr)&uc->uc_mcontext.gregs[VKI_REG_RAX], OFFSET_amd64_RAX,
 330                sizeof(UWord));
 331       tst->arch.vex.guest_RBX = uc->uc_mcontext.gregs[VKI_REG_RBX];
 332       VG_TRACK(copy_mem_to_reg, part, tid,
 333                (Addr)&uc->uc_mcontext.gregs[VKI_REG_RBX], OFFSET_amd64_RBX,
 334                sizeof(UWord));
 335       tst->arch.vex.guest_RCX = uc->uc_mcontext.gregs[VKI_REG_RCX];
 336       VG_TRACK(copy_mem_to_reg, part, tid,
 337                (Addr)&uc->uc_mcontext.gregs[VKI_REG_RCX], OFFSET_amd64_RCX,
 338                sizeof(UWord));
 339       tst->arch.vex.guest_RDX = uc->uc_mcontext.gregs[VKI_REG_RDX];
 340       VG_TRACK(copy_mem_to_reg, part, tid,
 341                (Addr)&uc->uc_mcontext.gregs[VKI_REG_RDX], OFFSET_amd64_RDX,
 342                sizeof(UWord));
 343       tst->arch.vex.guest_RBP = uc->uc_mcontext.gregs[VKI_REG_RBP];
 344       VG_TRACK(copy_mem_to_reg, part, tid,
 345                (Addr)&uc->uc_mcontext.gregs[VKI_REG_RBP], OFFSET_amd64_RBP,
 346                sizeof(UWord));
 347       tst->arch.vex.guest_RSI = uc->uc_mcontext.gregs[VKI_REG_RSI];
 348       VG_TRACK(copy_mem_to_reg, part, tid,
 349                (Addr)&uc->uc_mcontext.gregs[VKI_REG_RSI], OFFSET_amd64_RSI,
 350                sizeof(UWord));
 351       tst->arch.vex.guest_RDI = uc->uc_mcontext.gregs[VKI_REG_RDI];
 352       VG_TRACK(copy_mem_to_reg, part, tid,
 353                (Addr)&uc->uc_mcontext.gregs[VKI_REG_RDI], OFFSET_amd64_RDI,
 354                sizeof(UWord));
 355       tst->arch.vex.guest_R8 = uc->uc_mcontext.gregs[VKI_REG_R8];
 356       VG_TRACK(copy_mem_to_reg, part, tid,
 357                (Addr)&uc->uc_mcontext.gregs[VKI_REG_R8], OFFSET_amd64_R8,
 358                sizeof(UWord));
 359       tst->arch.vex.guest_R9 = uc->uc_mcontext.gregs[VKI_REG_R9];
 360       VG_TRACK(copy_mem_to_reg, part, tid,
 361                (Addr)&uc->uc_mcontext.gregs[VKI_REG_R9], OFFSET_amd64_R9,
 362                sizeof(UWord));
 363       tst->arch.vex.guest_R10 = uc->uc_mcontext.gregs[VKI_REG_R10];
 364       VG_TRACK(copy_mem_to_reg, part, tid,
 365                (Addr)&uc->uc_mcontext.gregs[VKI_REG_R10], OFFSET_amd64_R10,
 366                sizeof(UWord));
 367       tst->arch.vex.guest_R11 = uc->uc_mcontext.gregs[VKI_REG_R11];
 368       VG_TRACK(copy_mem_to_reg, part, tid,
 369                (Addr)&uc->uc_mcontext.gregs[VKI_REG_R11], OFFSET_amd64_R11,
 370                sizeof(UWord));
 371       tst->arch.vex.guest_R12 = uc->uc_mcontext.gregs[VKI_REG_R12];
 372       VG_TRACK(copy_mem_to_reg, part, tid,
 373                (Addr)&uc->uc_mcontext.gregs[VKI_REG_R12], OFFSET_amd64_R12,
 374                sizeof(UWord));
 375       tst->arch.vex.guest_R13 = uc->uc_mcontext.gregs[VKI_REG_R13];
 376       VG_TRACK(copy_mem_to_reg, part, tid,
 377                (Addr)&uc->uc_mcontext.gregs[VKI_REG_R13], OFFSET_amd64_R13,
 378                sizeof(UWord));
 379       tst->arch.vex.guest_R14 = uc->uc_mcontext.gregs[VKI_REG_R14];
 380       VG_TRACK(copy_mem_to_reg, part, tid,
 381                (Addr)&uc->uc_mcontext.gregs[VKI_REG_R14], OFFSET_amd64_R14,
 382                sizeof(UWord));
 383       tst->arch.vex.guest_R15 = uc->uc_mcontext.gregs[VKI_REG_R15];
 384       VG_TRACK(copy_mem_to_reg, part, tid,
 385                (Addr)&uc->uc_mcontext.gregs[VKI_REG_R15], OFFSET_amd64_R15,
 386                sizeof(UWord));
 387       tst->arch.vex.guest_RSP = uc->uc_mcontext.gregs[VKI_REG_RSP];
 388       VG_TRACK(copy_mem_to_reg, part, tid,
 389                (Addr)&uc->uc_mcontext.gregs[VKI_REG_RSP], OFFSET_amd64_RSP,
 390                sizeof(UWord));
 391
 392       /* Ignore ERR and TRAPNO. */
 393
 394       /* Ignore segment registers. */
 395
 396       /* Segment bases */
 397       tst->arch.vex.guest_FS_CONST = uc->uc_mcontext.gregs[VKI_REG_FSBASE];
 398       VG_TRACK(copy_mem_to_reg, part, tid,
 399                (Addr)&uc->uc_mcontext.gregs[VKI_REG_FSBASE],
 400                offsetof(VexGuestAMD64State, guest_FS_CONST), sizeof(UWord));
 401
 402       /* Rflags.  Refer to the x86-solaris variant of this code for a detailed
 403          description. */
 404       {
 405          ULong rflags;
 406          ULong orig_rflags;
 407          ULong new_rflags;
 408          Bool ok_restore = False;
 409
 410          VG_TRACK(pre_mem_read, part, tid,
 411                   "restore_machine_context(uc->uc_mcontext.gregs[VKI_REG_RFL])",
 412                   (Addr)&uc->uc_mcontext.gregs[VKI_REG_RFL], sizeof(UWord));
 413          rflags = uc->uc_mcontext.gregs[VKI_REG_RFL];
 414          orig_rflags = LibVEX_GuestAMD64_get_rflags(&tst->arch.vex);
 415          new_rflags = rflags;
 416          /* The kernel disallows the ID flag to be changed via the setcontext
 417             call, thus do the same. */
 418          if (orig_rflags & VKI_RFLAGS_ID_BIT)
 419             new_rflags |= VKI_RFLAGS_ID_BIT;
 420          else
 421             new_rflags &= ~VKI_RFLAGS_ID_BIT;
 422          LibVEX_GuestAMD64_put_rflags(new_rflags, &tst->arch.vex);
 423          VG_TRACK(post_reg_write, part, tid,
 424                   offsetof(VexGuestAMD64State, guest_CC_DEP1), sizeof(UWord));
 425          VG_TRACK(post_reg_write, part, tid,
 426                   offsetof(VexGuestAMD64State, guest_CC_DEP2), sizeof(UWord));
 427
 428          if (rflags != ~VKI_UC_GUEST_RFLAGS_NEG(uc)) {
 429             VG_(debugLog)(1, "syswrap-solaris",
 430                              "The rflags value was restored from an "
 431                              "explicitly set value in thread %u.\n", tid);
 432             ok_restore = True;
 433          }
 434          else {
 435             ULong buf[5];
 436             ULong checksum;
 437
 438             buf[0] = VKI_UC_GUEST_CC_OP(uc);
 439             buf[1] = VKI_UC_GUEST_CC_NDEP(uc);
 440             buf[2] = VKI_UC_GUEST_CC_DEP1(uc);
 441             buf[3] = VKI_UC_GUEST_CC_DEP2(uc);
 442             buf[4] = rflags;
 443             checksum = ML_(fletcher64)((UInt*)&buf,
 444                                        sizeof(buf) / sizeof(UInt));
 445             if (checksum == VKI_UC_GUEST_RFLAGS_CHECKSUM(uc)) {
 446                /* Check ok, the full restoration is possible. */
 447                VG_(debugLog)(1, "syswrap-solaris",
 448                                 "The CC_* guest state values were fully "
 449                                 "restored in thread %u.\n", tid);
 450                ok_restore = True;
 451
 452                tst->arch.vex.guest_CC_OP = VKI_UC_GUEST_CC_OP(uc);
 453                tst->arch.vex.guest_CC_NDEP = VKI_UC_GUEST_CC_NDEP(uc);
 454                tst->arch.vex.guest_CC_DEP1 = VKI_UC_GUEST_CC_DEP1(uc);
 455                VG_TRACK(copy_mem_to_reg, part, tid,
 456                         (Addr)&VKI_UC_GUEST_CC_DEP1(uc),
 457                         offsetof(VexGuestAMD64State, guest_CC_DEP1),
 458                         sizeof(UWord));
 459                tst->arch.vex.guest_CC_DEP2 = VKI_UC_GUEST_CC_DEP2(uc);
 460                VG_TRACK(copy_mem_to_reg, part, tid,
 461                         (Addr)&VKI_UC_GUEST_CC_DEP2(uc),
 462                         offsetof(VexGuestAMD64State, guest_CC_DEP2),
 463                         sizeof(UWord));
 464             }
 465          }
 466
 467          if (!ok_restore)
 468             VG_(debugLog)(1, "syswrap-solaris",
 469                              "Cannot fully restore the CC_* guest state "
 470                              "values, using approximate rflags in thread "
 471                              "%u.\n", tid);
 472       }
 473    }
 474
 475    if (uc->uc_flags & VKI_UC_FPU) {
 476       /* FPU */
 477       VexEmNote note;
 478       SizeT i;
 479
 480       /* x87 */
 481       /* Control word */
 482       VG_TRACK(pre_mem_read, part, tid,
 483                "restore_machine_context(uc->uc_mcontext.fpregs..cw)",
 484                (Addr)&fs->cw, sizeof(fs->cw));
 485       /* Status word */
 486       VG_TRACK(pre_mem_read, part, tid,
 487                "restore_machine_context(uc->uc_mcontext.fpregs..sw)",
 488                (Addr)&fs->sw, sizeof(fs->sw));
 489       /* Compressed tag word */
 490       VG_TRACK(pre_mem_read, part, tid,
 491                "restore_machine_context(uc->uc_mcontext.fpregs..fctw)",
 492                (Addr)&fs->fctw, sizeof(fs->fctw));
 493       /* Last x87 opcode */
 494       VG_TRACK(pre_mem_read, part, tid,
 495                "restore_machine_context(uc->uc_mcontext.fpregs..fop)",
 496                (Addr)&fs->fop, sizeof(fs->fop));
 497       /* Last x87 instruction pointer */
 498       VG_TRACK(pre_mem_read, part, tid,
 499                "restore_machine_context(uc->uc_mcontext.fpregs..rip)",
 500                (Addr)&fs->rip, sizeof(fs->rip));
 501       /* Last x87 data pointer */
 502       VG_TRACK(pre_mem_read, part, tid,
 503                "restore_machine_context(uc->uc_mcontext.fpregs..rdp)",
 504                (Addr)&fs->rdp, sizeof(fs->rdp));
 505       /* Media-instruction control and status register */
 506       VG_TRACK(pre_mem_read, part, tid,
 507                "restore_machine_context(uc->uc_mcontext.fpregs..mxcsr)",
 508                (Addr)&fs->mxcsr, sizeof(fs->mxcsr));
 509       /* Supported features in MXCSR */
 510       VG_TRACK(pre_mem_read, part, tid,
 511                "restore_machine_context(uc->uc_mcontext.fpregs..mxcsr_mask)",
 512                (Addr)&fs->mxcsr_mask, sizeof(fs->mxcsr_mask));
 513
 514       /* ST registers */
 515       for (i = 0; i < 8; i++) {
 516          Addr addr = (Addr)&fs->st[i];
 517          VG_TRACK(copy_mem_to_reg, part, tid, addr,
 518                   offsetof(VexGuestAMD64State, guest_FPREG[i]), sizeof(ULong));
 519       }
 520
 521       /* XMM registers */
 522       VG_TRACK(copy_mem_to_reg, part, tid, (Addr)&fs->xmm[0],
 523                offsetof(VexGuestAMD64State, guest_YMM0), sizeof(U128));
 524       VG_TRACK(copy_mem_to_reg, part, tid, (Addr)&fs->xmm[1],
 525                offsetof(VexGuestAMD64State, guest_YMM1), sizeof(U128));
 526       VG_TRACK(copy_mem_to_reg, part, tid, (Addr)&fs->xmm[2],
 527                offsetof(VexGuestAMD64State, guest_YMM2), sizeof(U128));
 528       VG_TRACK(copy_mem_to_reg, part, tid, (Addr)&fs->xmm[3],
 529                offsetof(VexGuestAMD64State, guest_YMM3), sizeof(U128));
 530       VG_TRACK(copy_mem_to_reg, part, tid, (Addr)&fs->xmm[4],
 531                offsetof(VexGuestAMD64State, guest_YMM4), sizeof(U128));
 532       VG_TRACK(copy_mem_to_reg, part, tid, (Addr)&fs->xmm[5],
 533                offsetof(VexGuestAMD64State, guest_YMM5), sizeof(U128));
 534       VG_TRACK(copy_mem_to_reg, part, tid, (Addr)&fs->xmm[6],
 535                offsetof(VexGuestAMD64State, guest_YMM6), sizeof(U128));
 536       VG_TRACK(copy_mem_to_reg, part, tid, (Addr)&fs->xmm[7],
 537                offsetof(VexGuestAMD64State, guest_YMM7), sizeof(U128));
 538
 539       note = LibVEX_GuestAMD64_fxrstor((HWord)fs, &tst->arch.vex);
 540       if (note != EmNote_NONE)
 541          VG_(message)(Vg_UserMsg,
 542                       "Error restoring FP state in thread %u: %s.\n",
 543                       tid, LibVEX_EmNote_string(note));
 544    }
 545 }
 546
 547
 548 /* ---------------------------------------------------------------------
 549    PRE/POST wrappers for AMD64/Solaris-specific syscalls
 550    ------------------------------------------------------------------ */
 551
 552 #define PRE(name)       DEFN_PRE_TEMPLATE(amd64_solaris, name)
 553 #define POST(name)      DEFN_POST_TEMPLATE(amd64_solaris, name)
 554
 555 /* implementation */
 556
 557 #undef PRE
 558 #undef POST
 559
 560 #endif // defined(VGP_amd64_solaris)
 561
 562 /*--------------------------------------------------------------------*/
 563 /*--- end                                                          ---*/
 564 /*--------------------------------------------------------------------*/