coregrind/m_gdbserver/valgrind-low-x86.c

   1 /* Low level interface to valgrind, for the remote server for GDB integrated
   2    in valgrind.
   3    Copyright (C) 2011
   4    Free Software Foundation, Inc.
   5
   6    This file is part of VALGRIND.
   7    It has been inspired from a file from gdbserver in gdb 6.6.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 2 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 51 Franklin Street, Fifth Floor,
  22    Boston, MA 02110-1301, USA.  */
  23
  24 #include "server.h"
  25 #include "target.h"
  26 #include "regdef.h"
  27 #include "regcache.h"
  28
  29 #include "pub_core_machine.h"
  30 #include "pub_core_threadstate.h"
  31 #include "pub_core_transtab.h"
  32 #include "pub_core_gdbserver.h"
  33
  34 #include "valgrind_low.h"
  35
  36 #include "libvex_guest_x86.h"
  37 /* GDBTD: ??? have a cleaner way to get the f80 <> f64 conversion functions */
  38 /* below include needed for conversion f80 <> f64 */
  39 #include "../../VEX/priv/guest_generic_x87.h"
  40
  41
  42 /* below loosely inspired from  file generated with gdb regdat.sh  */
  43
  44 static struct reg regs[] = {
  45    { "eax", 0, 32 },
  46    { "ecx", 32, 32 },
  47    { "edx", 64, 32 },
  48    { "ebx", 96, 32 },
  49    { "esp", 128, 32 },
  50    { "ebp", 160, 32 },
  51    { "esi", 192, 32 },
  52    { "edi", 224, 32 },
  53    { "eip", 256, 32 },
  54    { "eflags", 288, 32 },
  55    { "cs", 320, 32 },
  56    { "ss", 352, 32 },
  57    { "ds", 384, 32 },
  58    { "es", 416, 32 },
  59    { "fs", 448, 32 },
  60    { "gs", 480, 32 },
  61    { "st0", 512, 80 },
  62    { "st1", 592, 80 },
  63    { "st2", 672, 80 },
  64    { "st3", 752, 80 },
  65    { "st4", 832, 80 },
  66    { "st5", 912, 80 },
  67    { "st6", 992, 80 },
  68    { "st7", 1072, 80 },
  69    { "fctrl", 1152, 32 },
  70    { "fstat", 1184, 32 },
  71    { "ftag", 1216, 32 },
  72    { "fiseg", 1248, 32 },
  73    { "fioff", 1280, 32 },
  74    { "foseg", 1312, 32 },
  75    { "fooff", 1344, 32 },
  76    { "fop", 1376, 32 },
  77    { "xmm0", 1408, 128 },
  78    { "xmm1", 1536, 128 },
  79    { "xmm2", 1664, 128 },
  80    { "xmm3", 1792, 128 },
  81    { "xmm4", 1920, 128 },
  82    { "xmm5", 2048, 128 },
  83    { "xmm6", 2176, 128 },
  84    { "xmm7", 2304, 128 },
  85    { "mxcsr", 2432, 32 },
  86 #if defined(VGO_linux)
  87    { "orig_eax", 2464, 32 }
  88 #endif
  89 };
  90 static const char *expedite_regs[] = { "ebp", "esp", "eip", 0 };
  91 #define num_regs (sizeof (regs) / sizeof (regs[0]))
  92
  93 static
  94 CORE_ADDR get_pc (void)
  95 {
  96    unsigned long pc;
  97
  98    collect_register_by_name ("eip", &pc);
  99
 100    dlog(1, "stop pc is %p\n", (void *) pc);
 101    return pc;
 102 }
 103
 104 static
 105 void set_pc (CORE_ADDR newpc)
 106 {
 107    Bool mod;
 108    supply_register_by_name ("eip", &newpc, &mod);
 109    if (mod)
 110       dlog(1, "set pc to %p\n", C2v (newpc));
 111    else
 112       dlog(1, "set pc not changed %p\n", C2v (newpc));
 113 }
 114
 115 /* store registers in the guest state (gdbserver_to_valgrind)
 116    or fetch register from the guest state (valgrind_to_gdbserver). */
 117 static
 118 void transfer_register (ThreadId tid, int abs_regno, void * buf,
 119                         transfer_direction dir, int size, Bool *mod)
 120 {
 121    ThreadState* tst = VG_(get_ThreadState)(tid);
 122    int set = abs_regno / num_regs;
 123    int regno = abs_regno % num_regs;
 124    *mod = False;
 125
 126    VexGuestX86State* x86 = (VexGuestX86State*) get_arch (set, tst);
 127
 128    switch (regno) {
 129    // numbers here have to match the order of regs above
 130    // Attention: gdb order does not match valgrind order.
 131    case 0:  VG_(transfer) (&x86->guest_EAX, buf, dir, size, mod); break;
 132    case 1:  VG_(transfer) (&x86->guest_ECX, buf, dir, size, mod); break;
 133    case 2:  VG_(transfer) (&x86->guest_EDX, buf, dir, size, mod); break;
 134    case 3:  VG_(transfer) (&x86->guest_EBX, buf, dir, size, mod); break;
 135    case 4:  VG_(transfer) (&x86->guest_ESP, buf, dir, size, mod); break;
 136    case 5:  VG_(transfer) (&x86->guest_EBP, buf, dir, size, mod); break;
 137    case 6:  VG_(transfer) (&x86->guest_ESI, buf, dir, size, mod); break;
 138    case 7:  VG_(transfer) (&x86->guest_EDI, buf, dir, size, mod); break;
 139    case 8:  VG_(transfer) (&x86->guest_EIP, buf, dir, size, mod); break;
 140    case 9:
 141       if (dir == valgrind_to_gdbserver) {
 142          UInt eflags;
 143          /* we can only retrieve the real flags (set 0)
 144             retrieving shadow flags is not ok */
 145          if (set == 0)
 146             eflags = LibVEX_GuestX86_get_eflags (x86);
 147          else
 148             eflags = 0;
 149          VG_(transfer) (&eflags, buf, dir, size, mod); break;
 150       } else {
 151          *mod = False; //GDBTD? how do we store eflags in libvex_guest_x86.h ???
 152       }
 153       break;
 154    case 10: VG_(transfer) (&x86->guest_CS, buf, dir, size, mod); break;
 155    case 11: VG_(transfer) (&x86->guest_SS, buf, dir, size, mod); break;
 156    case 12: VG_(transfer) (&x86->guest_DS, buf, dir, size, mod); break;
 157    case 13: VG_(transfer) (&x86->guest_ES, buf, dir, size, mod); break;
 158    case 14: VG_(transfer) (&x86->guest_FS, buf, dir, size, mod); break;
 159    case 15: VG_(transfer) (&x86->guest_GS, buf, dir, size, mod); break;
 160    case 16:
 161    case 17:
 162    case 18:
 163    case 19: /* register 16 to 23 are float registers 80 bits but 64 bits in valgrind */
 164    case 20:
 165    case 21:
 166    case 22:
 167    case 23: {
 168       if (dir == valgrind_to_gdbserver) {
 169          UChar fpreg80[10];
 170          convert_f64le_to_f80le ((UChar *)&x86->guest_FPREG[regno-16],
 171                                  fpreg80);
 172          VG_(transfer) (&fpreg80, buf, dir, sizeof(fpreg80), mod);
 173       } else {
 174          ULong fpreg64;
 175          convert_f80le_to_f64le (buf, (UChar *)&fpreg64);
 176          VG_(transfer) (&x86->guest_FPREG[regno-16], &fpreg64,
 177                         dir, sizeof(fpreg64), mod);
 178       }
 179       break;
 180    }
 181    case 24:
 182       if (dir == valgrind_to_gdbserver) {
 183          // vex only models the rounding bits (see libvex_guest_x86.h)
 184          UWord value = 0x037f;
 185          value |= x86->guest_FPROUND << 10;
 186          VG_(transfer)(&value, buf, dir, size, mod);
 187       } else {
 188          *mod = False; // GDBTD???? VEX { "fctrl", 1152, 32 },
 189       }
 190       break;
 191    case 25:
 192       if (dir == valgrind_to_gdbserver) {
 193          UWord value = x86->guest_FC3210;
 194          value |= (x86->guest_FTOP & 7) << 11;
 195          VG_(transfer)(&value, buf, dir, size, mod);
 196       } else {
 197          *mod = False; // GDBTD???? VEX { "fstat", 1184, 32 },
 198       }
 199       break;
 200    case 26:
 201       if (dir == valgrind_to_gdbserver) {
 202          // vex doesn't model these precisely
 203          UWord value =
 204             ((x86->guest_FPTAG[0] ? 0 : 3) << 0)  |
 205             ((x86->guest_FPTAG[1] ? 0 : 3) << 2)  |
 206             ((x86->guest_FPTAG[2] ? 0 : 3) << 4)  |
 207             ((x86->guest_FPTAG[3] ? 0 : 3) << 6)  |
 208             ((x86->guest_FPTAG[4] ? 0 : 3) << 8)  |
 209             ((x86->guest_FPTAG[5] ? 0 : 3) << 10) |
 210             ((x86->guest_FPTAG[6] ? 0 : 3) << 12) |
 211             ((x86->guest_FPTAG[7] ? 0 : 3) << 14);
 212          VG_(transfer)(&value, buf, dir, size, mod);
 213       } else {
 214          *mod = False;  // GDBTD???? VEX { "ftag", 1216, 32 },
 215       }
 216       break;
 217    case 27: *mod = False; break; // GDBTD???? VEX { "fiseg", 1248, 32 },
 218    case 28: *mod = False; break; // GDBTD???? VEX { "fioff", 1280, 32 },
 219    case 29: *mod = False; break; // GDBTD???? VEX { "foseg", 1312, 32 },
 220    case 30: *mod = False; break; // GDBTD???? VEX { "fooff", 1344, 32 },
 221    case 31: *mod = False; break; // GDBTD???? VEX { "fop", 1376, 32 },
 222    case 32: VG_(transfer) (&x86->guest_XMM0, buf, dir, size, mod); break;
 223    case 33: VG_(transfer) (&x86->guest_XMM1, buf, dir, size, mod); break;
 224    case 34: VG_(transfer) (&x86->guest_XMM2, buf, dir, size, mod); break;
 225    case 35: VG_(transfer) (&x86->guest_XMM3, buf, dir, size, mod); break;
 226    case 36: VG_(transfer) (&x86->guest_XMM4, buf, dir, size, mod); break;
 227    case 37: VG_(transfer) (&x86->guest_XMM5, buf, dir, size, mod); break;
 228    case 38: VG_(transfer) (&x86->guest_XMM6, buf, dir, size, mod); break;
 229    case 39: VG_(transfer) (&x86->guest_XMM7, buf, dir, size, mod); break;
 230    case 40:
 231       if (dir == valgrind_to_gdbserver) {
 232          // vex only models the rounding bits (see libvex_guest_x86.h)
 233          UWord value = 0x1f80;
 234          value |= x86->guest_SSEROUND << 13;
 235          VG_(transfer)(&value, buf, dir, size, mod);
 236       } else {
 237          *mod = False; // GDBTD???? VEX { "mxcsr", 2432, 32 },
 238       }
 239       break;
 240    case 41: *mod = False; break; // GDBTD???? VEX { "orig_eax", 2464, 32 },
 241    default: vg_assert(0);
 242    }
 243 }
 244
 245 static
 246 const char* target_xml (Bool shadow_mode)
 247 {
 248    if (shadow_mode) {
 249 #if defined(VGO_linux)
 250    return "i386-linux-valgrind.xml";
 251 #else
 252    return "i386-coresse-valgrind.xml";
 253 #endif
 254    } else {
 255       return NULL;
 256    }
 257 }
 258
 259 static CORE_ADDR** target_get_dtv (ThreadState *tst)
 260 {
 261    VexGuestX86State* x86 = (VexGuestX86State*)&tst->arch.vex;
 262    // FIXME: should make the below formally visible from VEX.
 263    extern ULong x86g_use_seg_selector ( HWord ldt, HWord gdt,
 264                                         UInt seg_selector, UInt virtual_addr );
 265
 266    ULong dtv_loc_g = x86g_use_seg_selector (x86->guest_LDT,
 267                                             x86->guest_GDT,
 268                                             x86->guest_GS,
 269                                             0x4);
 270    if (dtv_loc_g == 1ULL << 32) {
 271       dlog(0, "Error getting x86 dtv\n");
 272       return NULL;
 273    } else {
 274       CORE_ADDR dtv_loc = dtv_loc_g;
 275       return (CORE_ADDR**)dtv_loc;
 276    }
 277 }
 278
 279 static struct valgrind_target_ops low_target = {
 280    num_regs,
 281    regs,
 282    4, //ESP
 283    transfer_register,
 284    get_pc,
 285    set_pc,
 286    "i386",
 287    target_xml,
 288    target_get_dtv
 289 };
 290
 291 void x86_init_architecture (struct valgrind_target_ops *target)
 292 {
 293    *target = low_target;
 294    set_register_cache (regs, num_regs);
 295    gdbserver_expedite_regs = expedite_regs;
 296 }