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 } 297
