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_amd64.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 /* below loosely inspired from file generated with gdb regdat.sh */
42
43 static struct reg regs[] = {
44 { "rax", 0, 64 },
45 { "rbx", 64, 64 },
46 { "rcx", 128, 64 },
47 { "rdx", 192, 64 },
48 { "rsi", 256, 64 },
49 { "rdi", 320, 64 },
50 { "rbp", 384, 64 },
51 { "rsp", 448, 64 },
52 { "r8", 512, 64 },
53 { "r9", 576, 64 },
54 { "r10", 640, 64 },
55 { "r11", 704, 64 },
56 { "r12", 768, 64 },
57 { "r13", 832, 64 },
58 { "r14", 896, 64 },
59 { "r15", 960, 64 },
60 { "rip", 1024, 64 },
61 { "eflags", 1088, 32 },
62 { "cs", 1120, 32 },
63 { "ss", 1152, 32 },
64 { "ds", 1184, 32 },
65 { "es", 1216, 32 },
66 { "fs", 1248, 32 },
67 { "gs", 1280, 32 },
68 { "st0", 1312, 80 },
69 { "st1", 1392, 80 },
70 { "st2", 1472, 80 },
71 { "st3", 1552, 80 },
72 { "st4", 1632, 80 },
73 { "st5", 1712, 80 },
74 { "st6", 1792, 80 },
75 { "st7", 1872, 80 },
76 { "fctrl", 1952, 32 },
77 { "fstat", 1984, 32 },
78 { "ftag", 2016, 32 },
79 { "fiseg", 2048, 32 },
80 { "fioff", 2080, 32 },
81 { "foseg", 2112, 32 },
82 { "fooff", 2144, 32 },
83 { "fop", 2176, 32 },
84 { "xmm0", 2208, 128 },
85 { "xmm1", 2336, 128 },
86 { "xmm2", 2464, 128 },
87 { "xmm3", 2592, 128 },
88 { "xmm4", 2720, 128 },
89 { "xmm5", 2848, 128 },
90 { "xmm6", 2976, 128 },
91 { "xmm7", 3104, 128 },
92 { "xmm8", 3232, 128 },
93 { "xmm9", 3360, 128 },
94 { "xmm10", 3488, 128 },
95 { "xmm11", 3616, 128 },
96 { "xmm12", 3744, 128 },
97 { "xmm13", 3872, 128 },
98 { "xmm14", 4000, 128 },
99 { "xmm15", 4128, 128 },
100 { "mxcsr", 4256, 32 },
101 #if defined(VGO_linux)
102 { "orig_rax", 4288, 64 },
103 #endif
104 { "ymm0h", 4352, 128 }, // The ymm?h registers only to be given to GDB
105 { "ymm1h", 4480, 128 }, // if Valgrind is running with AVX instructions.
106 { "ymm2h", 4608, 128 },
107 { "ymm3h", 4736, 128 },
108 { "ymm4h", 4864, 128 },
109 { "ymm5h", 4992, 128 },
110 { "ymm6h", 5120, 128 },
111 { "ymm7h", 5248, 128 },
112 { "ymm8h", 5376, 128 },
113 { "ymm9h", 5504, 128 },
114 { "ymm10h", 5632, 128 },
115 { "ymm11h", 5760, 128 },
116 { "ymm12h", 5888, 128 },
117 { "ymm13h", 6016, 128 },
118 { "ymm14h", 6144, 128 },
119 { "ymm15h", 6272, 128 }
120 };
121 static const char *expedite_regs[] = { "rbp", "rsp", "rip", 0 };
122 #define max_num_regs (sizeof (regs) / sizeof (regs[0]))
123 static int dyn_num_regs; // if no AVX, we have to give less registers to gdb.
124
125
126 static
get_pc(void)127 CORE_ADDR get_pc (void)
128 {
129 unsigned long pc;
130
131 collect_register_by_name ("rip", &pc);
132
133 dlog(1, "stop pc is %p\n", (void *) pc);
134 return pc;
135 }
136
137 static
set_pc(CORE_ADDR newpc)138 void set_pc (CORE_ADDR newpc)
139 {
140 Bool mod;
141 supply_register_by_name ("rip", &newpc, &mod);
142 if (mod)
143 dlog(1, "set pc to %p\n", C2v (newpc));
144 else
145 dlog(1, "set pc not changed %p\n", C2v (newpc));
146 }
147
148 /* store registers in the guest state (gdbserver_to_valgrind)
149 or fetch register from the guest state (valgrind_to_gdbserver). */
150 static
transfer_register(ThreadId tid,int abs_regno,void * buf,transfer_direction dir,int size,Bool * mod)151 void transfer_register (ThreadId tid, int abs_regno, void * buf,
152 transfer_direction dir, int size, Bool *mod)
153 {
154 ThreadState* tst = VG_(get_ThreadState)(tid);
155 int set = abs_regno / dyn_num_regs;
156 int regno = abs_regno % dyn_num_regs;
157 *mod = False;
158
159 VexGuestAMD64State* amd64 = (VexGuestAMD64State*) get_arch (set, tst);
160
161 switch (regno) {
162 // numbers here have to match the order of regs above.
163 // Attention: gdb order does not match valgrind order.
164 case 0: VG_(transfer) (&amd64->guest_RAX, buf, dir, size, mod); break;
165 case 1: VG_(transfer) (&amd64->guest_RBX, buf, dir, size, mod); break;
166 case 2: VG_(transfer) (&amd64->guest_RCX, buf, dir, size, mod); break;
167 case 3: VG_(transfer) (&amd64->guest_RDX, buf, dir, size, mod); break;
168 case 4: VG_(transfer) (&amd64->guest_RSI, buf, dir, size, mod); break;
169 case 5: VG_(transfer) (&amd64->guest_RDI, buf, dir, size, mod); break;
170 case 6: VG_(transfer) (&amd64->guest_RBP, buf, dir, size, mod); break;
171 case 7: VG_(transfer) (&amd64->guest_RSP, buf, dir, size, mod); break;
172 case 8: VG_(transfer) (&amd64->guest_R8, buf, dir, size, mod); break;
173 case 9: VG_(transfer) (&amd64->guest_R9, buf, dir, size, mod); break;
174 case 10: VG_(transfer) (&amd64->guest_R10, buf, dir, size, mod); break;
175 case 11: VG_(transfer) (&amd64->guest_R11, buf, dir, size, mod); break;
176 case 12: VG_(transfer) (&amd64->guest_R12, buf, dir, size, mod); break;
177 case 13: VG_(transfer) (&amd64->guest_R13, buf, dir, size, mod); break;
178 case 14: VG_(transfer) (&amd64->guest_R14, buf, dir, size, mod); break;
179 case 15: VG_(transfer) (&amd64->guest_R15, buf, dir, size, mod); break;
180 case 16: VG_(transfer) (&amd64->guest_RIP, buf, dir, size, mod); break;
181 case 17:
182 if (dir == valgrind_to_gdbserver) {
183 ULong rflags;
184 /* we can only retrieve the real flags (set 0)
185 retrieving shadow flags is not ok */
186 if (set == 0)
187 rflags = LibVEX_GuestAMD64_get_rflags (amd64);
188 else
189 rflags = 0;
190 VG_(transfer) (&rflags, buf, dir, size, mod);
191 } else {
192 *mod = False; //GDBTD? how do we store rflags in libvex_guest_amd64.h ???
193 }
194 break;
195 case 18: *mod = False; break; //GDBTD VG_(transfer) (&amd64->guest_CS, buf, dir, size, mod);
196 case 19: *mod = False; break; //GDBTD VG_(transfer) (&amd64->guest_SS, buf, dir, size, mod);
197 case 20: *mod = False; break; //GDBTD VG_(transfer) (&amd64->guest_DS, buf, dir, size, mod);
198 case 21: *mod = False; break; //GDBTD VG_(transfer) (&amd64->guest_ES, buf, dir, size, mod);
199 case 22: *mod = False; break; //GDBTD VG_(transfer) (&amd64->guest_FS, buf, dir, size, mod);
200 case 23: VG_(transfer) (&amd64->guest_GS_CONST, buf, dir, size, mod); break;
201 case 24:
202 case 25:
203 case 26:
204 case 27: /* register 24 to 31 are float registers 80 bits but 64 bits in valgrind */
205 case 28:
206 case 29:
207 case 30:
208 case 31:
209 if (dir == valgrind_to_gdbserver) {
210 UChar fpreg80[10];
211 convert_f64le_to_f80le ((UChar *)&amd64->guest_FPREG[regno-24],
212 fpreg80);
213 VG_(transfer) (&fpreg80, buf, dir, sizeof(fpreg80), mod);
214 } else {
215 ULong fpreg64;
216 convert_f80le_to_f64le (buf, (UChar *)&fpreg64);
217 VG_(transfer) (&amd64->guest_FPREG[regno-24], &fpreg64,
218 dir, sizeof(fpreg64), mod);
219 }
220 break;
221 case 32:
222 if (dir == valgrind_to_gdbserver) {
223 // vex only models the rounding bits (see libvex_guest_amd64.h)
224 UWord value = 0x037f;
225 value |= amd64->guest_FPROUND << 10;
226 VG_(transfer)(&value, buf, dir, size, mod);
227 } else {
228 *mod = False; // GDBTD???? VEX equivalent fcrtl
229 }
230 break;
231 case 33:
232 if (dir == valgrind_to_gdbserver) {
233 UWord value = amd64->guest_FC3210;
234 value |= (amd64->guest_FTOP & 7) << 11;
235 VG_(transfer)(&value, buf, dir, size, mod);
236 } else {
237 *mod = False; // GDBTD???? VEX equivalent fstat
238 }
239 break;
240 case 34:
241 if (dir == valgrind_to_gdbserver) {
242 // vex doesn't model these precisely
243 UWord value =
244 ((amd64->guest_FPTAG[0] ? 0 : 3) << 0) |
245 ((amd64->guest_FPTAG[1] ? 0 : 3) << 2) |
246 ((amd64->guest_FPTAG[2] ? 0 : 3) << 4) |
247 ((amd64->guest_FPTAG[3] ? 0 : 3) << 6) |
248 ((amd64->guest_FPTAG[4] ? 0 : 3) << 8) |
249 ((amd64->guest_FPTAG[5] ? 0 : 3) << 10) |
250 ((amd64->guest_FPTAG[6] ? 0 : 3) << 12) |
251 ((amd64->guest_FPTAG[7] ? 0 : 3) << 14);
252 VG_(transfer)(&value, buf, dir, size, mod);
253 } else {
254 *mod = False; // GDBTD???? VEX equivalent ftag
255 }
256 break;
257 case 35: *mod = False; break; // GDBTD ??? equivalent of fiseg
258 case 36: *mod = False; break; // GDBTD ??? equivalent of fioff
259 case 37: *mod = False; break; // GDBTD ??? equivalent of foseg
260 case 38: *mod = False; break; // GDBTD ??? equivalent of fooff
261 case 39: *mod = False; break; // GDBTD ??? equivalent of fop
262 case 40: VG_(transfer) (&amd64->guest_YMM0[0], buf, dir, size, mod); break;
263 case 41: VG_(transfer) (&amd64->guest_YMM1[0], buf, dir, size, mod); break;
264 case 42: VG_(transfer) (&amd64->guest_YMM2[0], buf, dir, size, mod); break;
265 case 43: VG_(transfer) (&amd64->guest_YMM3[0], buf, dir, size, mod); break;
266 case 44: VG_(transfer) (&amd64->guest_YMM4[0], buf, dir, size, mod); break;
267 case 45: VG_(transfer) (&amd64->guest_YMM5[0], buf, dir, size, mod); break;
268 case 46: VG_(transfer) (&amd64->guest_YMM6[0], buf, dir, size, mod); break;
269 case 47: VG_(transfer) (&amd64->guest_YMM7[0], buf, dir, size, mod); break;
270 case 48: VG_(transfer) (&amd64->guest_YMM8[0], buf, dir, size, mod); break;
271 case 49: VG_(transfer) (&amd64->guest_YMM9[0], buf, dir, size, mod); break;
272 case 50: VG_(transfer) (&amd64->guest_YMM10[0], buf, dir, size, mod); break;
273 case 51: VG_(transfer) (&amd64->guest_YMM11[0], buf, dir, size, mod); break;
274 case 52: VG_(transfer) (&amd64->guest_YMM12[0], buf, dir, size, mod); break;
275 case 53: VG_(transfer) (&amd64->guest_YMM13[0], buf, dir, size, mod); break;
276 case 54: VG_(transfer) (&amd64->guest_YMM14[0], buf, dir, size, mod); break;
277 case 55: VG_(transfer) (&amd64->guest_YMM15[0], buf, dir, size, mod); break;
278 case 56:
279 if (dir == valgrind_to_gdbserver) {
280 // vex only models the rounding bits (see libvex_guest_x86.h)
281 UWord value = 0x1f80;
282 value |= amd64->guest_SSEROUND << 13;
283 VG_(transfer)(&value, buf, dir, size, mod);
284 } else {
285 *mod = False; // GDBTD???? VEX equivalent mxcsr
286 }
287 break;
288 case 57: *mod = False; break; // GDBTD???? VEX equivalent { "orig_rax"},
289 case 58: VG_(transfer) (&amd64->guest_YMM0[4], buf, dir, size, mod); break;
290 case 59: VG_(transfer) (&amd64->guest_YMM1[4], buf, dir, size, mod); break;
291 case 60: VG_(transfer) (&amd64->guest_YMM2[4], buf, dir, size, mod); break;
292 case 61: VG_(transfer) (&amd64->guest_YMM3[4], buf, dir, size, mod); break;
293 case 62: VG_(transfer) (&amd64->guest_YMM4[4], buf, dir, size, mod); break;
294 case 63: VG_(transfer) (&amd64->guest_YMM5[4], buf, dir, size, mod); break;
295 case 64: VG_(transfer) (&amd64->guest_YMM6[4], buf, dir, size, mod); break;
296 case 65: VG_(transfer) (&amd64->guest_YMM7[4], buf, dir, size, mod); break;
297 case 66: VG_(transfer) (&amd64->guest_YMM8[4], buf, dir, size, mod); break;
298 case 67: VG_(transfer) (&amd64->guest_YMM9[4], buf, dir, size, mod); break;
299 case 68: VG_(transfer) (&amd64->guest_YMM10[4], buf, dir, size, mod); break;
300 case 69: VG_(transfer) (&amd64->guest_YMM11[4], buf, dir, size, mod); break;
301 case 70: VG_(transfer) (&amd64->guest_YMM12[4], buf, dir, size, mod); break;
302 case 71: VG_(transfer) (&amd64->guest_YMM13[4], buf, dir, size, mod); break;
303 case 72: VG_(transfer) (&amd64->guest_YMM14[4], buf, dir, size, mod); break;
304 case 73: VG_(transfer) (&amd64->guest_YMM15[4], buf, dir, size, mod); break;
305 default: vg_assert(0);
306 }
307 }
308
309 static
have_avx(void)310 Bool have_avx(void)
311 {
312 VexArch va;
313 VexArchInfo vai;
314 VG_(machine_get_VexArchInfo) (&va, &vai);
315 return (vai.hwcaps & VEX_HWCAPS_AMD64_AVX ? True : False);
316 }
317
318 static
target_xml(Bool shadow_mode)319 const char* target_xml (Bool shadow_mode)
320 {
321 if (shadow_mode) {
322 #if defined(VGO_linux)
323 if (have_avx())
324 return "amd64-avx-linux-valgrind.xml";
325 else
326 return "amd64-linux-valgrind.xml";
327 #else
328 if (have_avx())
329 return "amd64-avx-coresse-valgrind.xml";
330 else
331 return "amd64-coresse-valgrind.xml";
332 #endif
333 } else {
334 #if defined(VGO_linux)
335 if (have_avx())
336 return "amd64-avx-linux.xml";
337 else
338 return NULL;
339 #else
340 if (have_avx())
341 return "amd64-avx-coresse.xml";
342 else
343 return NULL;
344 #endif
345 }
346 }
347
target_get_dtv(ThreadState * tst)348 static CORE_ADDR** target_get_dtv (ThreadState *tst)
349 {
350 VexGuestAMD64State* amd64 = (VexGuestAMD64State*)&tst->arch.vex;
351 return (CORE_ADDR**)((CORE_ADDR)amd64->guest_FS_CONST + 0x8);
352 }
353
354 static struct valgrind_target_ops low_target = {
355 -1, // Must be computed at init time.
356 regs,
357 7, //RSP
358 transfer_register,
359 get_pc,
360 set_pc,
361 "amd64",
362 target_xml,
363 target_get_dtv
364 };
365
amd64_init_architecture(struct valgrind_target_ops * target)366 void amd64_init_architecture (struct valgrind_target_ops *target)
367 {
368 *target = low_target;
369 if (have_avx())
370 dyn_num_regs = max_num_regs;
371 else
372 dyn_num_regs = max_num_regs - 16; // remove the AVX "high" registers.
373 target->num_regs = dyn_num_regs;
374 set_register_cache (regs, dyn_num_regs);
375 gdbserver_expedite_regs = expedite_regs;
376 }
377