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
get_pc(void)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
set_pc(CORE_ADDR newpc)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
transfer_register(ThreadId tid,int abs_regno,void * buf,transfer_direction dir,int size,Bool * mod)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
target_xml(Bool shadow_mode)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
target_get_dtv(ThreadState * tst)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
x86_init_architecture(struct valgrind_target_ops * target)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