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