xref: /qemu/target/ppc/gdbstub.c (revision dbd9e084) 
1 /*
2  * PowerPC gdb server stub
3  *
4  * Copyright (c) 2003-2005 Fabrice Bellard
5  * Copyright (c) 2013 SUSE LINUX Products GmbH
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
19  */
20 #include "qemu/osdep.h"
21 #include "cpu.h"
22 #include "exec/gdbstub.h"
23 #include "internal.h"
24 
25 static int ppc_gdb_register_len_apple(int n)
26 {
27     switch (n) {
28     case 0 ... 31:
29         /* gprs */
30         return 8;
31     case 32 ... 63:
32         /* fprs */
33         return 8;
34     case 64 ... 95:
35         return 16;
36     case 64 + 32: /* nip */
37     case 65 + 32: /* msr */
38     case 67 + 32: /* lr */
39     case 68 + 32: /* ctr */
40     case 70 + 32: /* fpscr */
41         return 8;
42     case 66 + 32: /* cr */
43     case 69 + 32: /* xer */
44         return 4;
45     default:
46         return 0;
47     }
48 }
49 
50 static int ppc_gdb_register_len(int n)
51 {
52     switch (n) {
53     case 0 ... 31:
54         /* gprs */
55         return sizeof(target_ulong);
56     case 32 ... 63:
57         /* fprs */
58         if (gdb_has_xml) {
59             return 0;
60         }
61         return 8;
62     case 66:
63         /* cr */
64     case 69:
65         /* xer */
66         return 4;
67     case 64:
68         /* nip */
69     case 65:
70         /* msr */
71     case 67:
72         /* lr */
73     case 68:
74         /* ctr */
75         return sizeof(target_ulong);
76     case 70:
77         /* fpscr */
78         if (gdb_has_xml) {
79             return 0;
80         }
81         return sizeof(target_ulong);
82     default:
83         return 0;
84     }
85 }
86 
87 /*
88  * We need to present the registers to gdb in the "current" memory
89  * ordering.  For user-only mode we get this for free;
90  * TARGET_WORDS_BIGENDIAN is set to the proper ordering for the
91  * binary, and cannot be changed.  For system mode,
92  * TARGET_WORDS_BIGENDIAN is always set, and we must check the current
93  * mode of the chip to see if we're running in little-endian.
94  */
95 void ppc_maybe_bswap_register(CPUPPCState *env, uint8_t *mem_buf, int len)
96 {
97 #ifndef CONFIG_USER_ONLY
98     if (!msr_le) {
99         /* do nothing */
100     } else if (len == 4) {
101         bswap32s((uint32_t *)mem_buf);
102     } else if (len == 8) {
103         bswap64s((uint64_t *)mem_buf);
104     } else if (len == 16) {
105         bswap128s((Int128 *)mem_buf);
106     } else {
107         g_assert_not_reached();
108     }
109 #endif
110 }
111 
112 /*
113  * Old gdb always expects FP registers.  Newer (xml-aware) gdb only
114  * expects whatever the target description contains.  Due to a
115  * historical mishap the FP registers appear in between core integer
116  * regs and PC, MSR, CR, and so forth.  We hack round this by giving
117  * the FP regs zero size when talking to a newer gdb.
118  */
119 
120 int ppc_cpu_gdb_read_register(CPUState *cs, GByteArray *buf, int n)
121 {
122     PowerPCCPU *cpu = POWERPC_CPU(cs);
123     CPUPPCState *env = &cpu->env;
124     uint8_t *mem_buf;
125     int r = ppc_gdb_register_len(n);
126 
127     if (!r) {
128         return r;
129     }
130 
131     if (n < 32) {
132         /* gprs */
133         gdb_get_regl(buf, env->gpr[n]);
134     } else if (n < 64) {
135         /* fprs */
136         gdb_get_reg64(buf, *cpu_fpr_ptr(env, n - 32));
137     } else {
138         switch (n) {
139         case 64:
140             gdb_get_regl(buf, env->nip);
141             break;
142         case 65:
143             gdb_get_regl(buf, env->msr);
144             break;
145         case 66:
146             {
147                 uint32_t cr = 0;
148                 int i;
149                 for (i = 0; i < 8; i++) {
150                     cr |= env->crf[i] << (32 - ((i + 1) * 4));
151                 }
152                 gdb_get_reg32(buf, cr);
153                 break;
154             }
155         case 67:
156             gdb_get_regl(buf, env->lr);
157             break;
158         case 68:
159             gdb_get_regl(buf, env->ctr);
160             break;
161         case 69:
162             gdb_get_reg32(buf, cpu_read_xer(env));
163             break;
164         case 70:
165             gdb_get_reg32(buf, env->fpscr);
166             break;
167         }
168     }
169     mem_buf = buf->data + buf->len - r;
170     ppc_maybe_bswap_register(env, mem_buf, r);
171     return r;
172 }
173 
174 int ppc_cpu_gdb_read_register_apple(CPUState *cs, GByteArray *buf, int n)
175 {
176     PowerPCCPU *cpu = POWERPC_CPU(cs);
177     CPUPPCState *env = &cpu->env;
178     uint8_t *mem_buf;
179     int r = ppc_gdb_register_len_apple(n);
180 
181     if (!r) {
182         return r;
183     }
184 
185     if (n < 32) {
186         /* gprs */
187         gdb_get_reg64(buf, env->gpr[n]);
188     } else if (n < 64) {
189         /* fprs */
190         gdb_get_reg64(buf, *cpu_fpr_ptr(env, n - 32));
191     } else if (n < 96) {
192         /* Altivec */
193         gdb_get_reg64(buf, n - 64);
194         gdb_get_reg64(buf, 0);
195     } else {
196         switch (n) {
197         case 64 + 32:
198             gdb_get_reg64(buf, env->nip);
199             break;
200         case 65 + 32:
201             gdb_get_reg64(buf, env->msr);
202             break;
203         case 66 + 32:
204             {
205                 uint32_t cr = 0;
206                 int i;
207                 for (i = 0; i < 8; i++) {
208                     cr |= env->crf[i] << (32 - ((i + 1) * 4));
209                 }
210                 gdb_get_reg32(buf, cr);
211                 break;
212             }
213         case 67 + 32:
214             gdb_get_reg64(buf, env->lr);
215             break;
216         case 68 + 32:
217             gdb_get_reg64(buf, env->ctr);
218             break;
219         case 69 + 32:
220             gdb_get_reg32(buf, cpu_read_xer(env));
221             break;
222         case 70 + 32:
223             gdb_get_reg64(buf, env->fpscr);
224             break;
225         }
226     }
227     mem_buf = buf->data + buf->len - r;
228     ppc_maybe_bswap_register(env, mem_buf, r);
229     return r;
230 }
231 
232 int ppc_cpu_gdb_write_register(CPUState *cs, uint8_t *mem_buf, int n)
233 {
234     PowerPCCPU *cpu = POWERPC_CPU(cs);
235     CPUPPCState *env = &cpu->env;
236     int r = ppc_gdb_register_len(n);
237 
238     if (!r) {
239         return r;
240     }
241     ppc_maybe_bswap_register(env, mem_buf, r);
242     if (n < 32) {
243         /* gprs */
244         env->gpr[n] = ldtul_p(mem_buf);
245     } else if (n < 64) {
246         /* fprs */
247         *cpu_fpr_ptr(env, n - 32) = ldq_p(mem_buf);
248     } else {
249         switch (n) {
250         case 64:
251             env->nip = ldtul_p(mem_buf);
252             break;
253         case 65:
254             ppc_store_msr(env, ldtul_p(mem_buf));
255             break;
256         case 66:
257             {
258                 uint32_t cr = ldl_p(mem_buf);
259                 int i;
260                 for (i = 0; i < 8; i++) {
261                     env->crf[i] = (cr >> (32 - ((i + 1) * 4))) & 0xF;
262                 }
263                 break;
264             }
265         case 67:
266             env->lr = ldtul_p(mem_buf);
267             break;
268         case 68:
269             env->ctr = ldtul_p(mem_buf);
270             break;
271         case 69:
272             cpu_write_xer(env, ldl_p(mem_buf));
273             break;
274         case 70:
275             /* fpscr */
276             ppc_store_fpscr(env, ldtul_p(mem_buf));
277             break;
278         }
279     }
280     return r;
281 }
282 int ppc_cpu_gdb_write_register_apple(CPUState *cs, uint8_t *mem_buf, int n)
283 {
284     PowerPCCPU *cpu = POWERPC_CPU(cs);
285     CPUPPCState *env = &cpu->env;
286     int r = ppc_gdb_register_len_apple(n);
287 
288     if (!r) {
289         return r;
290     }
291     ppc_maybe_bswap_register(env, mem_buf, r);
292     if (n < 32) {
293         /* gprs */
294         env->gpr[n] = ldq_p(mem_buf);
295     } else if (n < 64) {
296         /* fprs */
297         *cpu_fpr_ptr(env, n - 32) = ldq_p(mem_buf);
298     } else {
299         switch (n) {
300         case 64 + 32:
301             env->nip = ldq_p(mem_buf);
302             break;
303         case 65 + 32:
304             ppc_store_msr(env, ldq_p(mem_buf));
305             break;
306         case 66 + 32:
307             {
308                 uint32_t cr = ldl_p(mem_buf);
309                 int i;
310                 for (i = 0; i < 8; i++) {
311                     env->crf[i] = (cr >> (32 - ((i + 1) * 4))) & 0xF;
312                 }
313                 break;
314             }
315         case 67 + 32:
316             env->lr = ldq_p(mem_buf);
317             break;
318         case 68 + 32:
319             env->ctr = ldq_p(mem_buf);
320             break;
321         case 69 + 32:
322             cpu_write_xer(env, ldl_p(mem_buf));
323             break;
324         case 70 + 32:
325             /* fpscr */
326             ppc_store_fpscr(env, ldq_p(mem_buf));
327             break;
328         }
329     }
330     return r;
331 }
332 
333 #ifndef CONFIG_USER_ONLY
334 void ppc_gdb_gen_spr_xml(PowerPCCPU *cpu)
335 {
336     PowerPCCPUClass *pcc = POWERPC_CPU_GET_CLASS(cpu);
337     CPUPPCState *env = &cpu->env;
338     GString *xml;
339     char *spr_name;
340     unsigned int num_regs = 0;
341     int i;
342 
343     if (pcc->gdb_spr_xml) {
344         return;
345     }
346 
347     xml = g_string_new("<?xml version=\"1.0\"?>");
348     g_string_append(xml, "<!DOCTYPE target SYSTEM \"gdb-target.dtd\">");
349     g_string_append(xml, "<feature name=\"org.qemu.power.spr\">");
350 
351     for (i = 0; i < ARRAY_SIZE(env->spr_cb); i++) {
352         ppc_spr_t *spr = &env->spr_cb[i];
353 
354         if (!spr->name) {
355             continue;
356         }
357 
358         spr_name = g_ascii_strdown(spr->name, -1);
359         g_string_append_printf(xml, "<reg name=\"%s\"", spr_name);
360         g_free(spr_name);
361 
362         g_string_append_printf(xml, " bitsize=\"%d\"", TARGET_LONG_BITS);
363         g_string_append(xml, " group=\"spr\"/>");
364 
365         /*
366          * GDB identifies registers based on the order they are
367          * presented in the XML. These ids will not match QEMU's
368          * representation (which follows the PowerISA).
369          *
370          * Store the position of the current register description so
371          * we can make the correspondence later.
372          */
373         spr->gdb_id = num_regs;
374         num_regs++;
375     }
376 
377     g_string_append(xml, "</feature>");
378 
379     pcc->gdb_num_sprs = num_regs;
380     pcc->gdb_spr_xml = g_string_free(xml, false);
381 }
382 
383 const char *ppc_gdb_get_dynamic_xml(CPUState *cs, const char *xml_name)
384 {
385     PowerPCCPUClass *pcc = POWERPC_CPU_GET_CLASS(cs);
386 
387     if (strcmp(xml_name, "power-spr.xml") == 0) {
388         return pcc->gdb_spr_xml;
389     }
390     return NULL;
391 }
392 #endif
393 
394 #if !defined(CONFIG_USER_ONLY)
395 static int gdb_find_spr_idx(CPUPPCState *env, int n)
396 {
397     int i;
398 
399     for (i = 0; i < ARRAY_SIZE(env->spr_cb); i++) {
400         ppc_spr_t *spr = &env->spr_cb[i];
401 
402         if (spr->name && spr->gdb_id == n) {
403             return i;
404         }
405     }
406     return -1;
407 }
408 
409 static int gdb_get_spr_reg(CPUPPCState *env, GByteArray *buf, int n)
410 {
411     int reg;
412     int len;
413 
414     reg = gdb_find_spr_idx(env, n);
415     if (reg < 0) {
416         return 0;
417     }
418 
419     len = TARGET_LONG_SIZE;
420     gdb_get_regl(buf, env->spr[reg]);
421     ppc_maybe_bswap_register(env, gdb_get_reg_ptr(buf, len), len);
422     return len;
423 }
424 
425 static int gdb_set_spr_reg(CPUPPCState *env, uint8_t *mem_buf, int n)
426 {
427     int reg;
428     int len;
429 
430     reg = gdb_find_spr_idx(env, n);
431     if (reg < 0) {
432         return 0;
433     }
434 
435     len = TARGET_LONG_SIZE;
436     ppc_maybe_bswap_register(env, mem_buf, len);
437     env->spr[reg] = ldn_p(mem_buf, len);
438 
439     return len;
440 }
441 #endif
442 
443 static int gdb_get_float_reg(CPUPPCState *env, GByteArray *buf, int n)
444 {
445     uint8_t *mem_buf;
446     if (n < 32) {
447         gdb_get_reg64(buf, *cpu_fpr_ptr(env, n));
448         mem_buf = gdb_get_reg_ptr(buf, 8);
449         ppc_maybe_bswap_register(env, mem_buf, 8);
450         return 8;
451     }
452     if (n == 32) {
453         gdb_get_reg32(buf, env->fpscr);
454         mem_buf = gdb_get_reg_ptr(buf, 4);
455         ppc_maybe_bswap_register(env, mem_buf, 4);
456         return 4;
457     }
458     return 0;
459 }
460 
461 static int gdb_set_float_reg(CPUPPCState *env, uint8_t *mem_buf, int n)
462 {
463     if (n < 32) {
464         ppc_maybe_bswap_register(env, mem_buf, 8);
465         *cpu_fpr_ptr(env, n) = ldq_p(mem_buf);
466         return 8;
467     }
468     if (n == 32) {
469         ppc_maybe_bswap_register(env, mem_buf, 4);
470         ppc_store_fpscr(env, ldl_p(mem_buf));
471         return 4;
472     }
473     return 0;
474 }
475 
476 static int gdb_get_avr_reg(CPUPPCState *env, GByteArray *buf, int n)
477 {
478     uint8_t *mem_buf;
479 
480     if (n < 32) {
481         ppc_avr_t *avr = cpu_avr_ptr(env, n);
482         gdb_get_reg128(buf, avr->VsrD(0), avr->VsrD(1));
483         mem_buf = gdb_get_reg_ptr(buf, 16);
484         ppc_maybe_bswap_register(env, mem_buf, 16);
485         return 16;
486     }
487     if (n == 32) {
488         gdb_get_reg32(buf, ppc_get_vscr(env));
489         mem_buf = gdb_get_reg_ptr(buf, 4);
490         ppc_maybe_bswap_register(env, mem_buf, 4);
491         return 4;
492     }
493     if (n == 33) {
494         gdb_get_reg32(buf, (uint32_t)env->spr[SPR_VRSAVE]);
495         mem_buf = gdb_get_reg_ptr(buf, 4);
496         ppc_maybe_bswap_register(env, mem_buf, 4);
497         return 4;
498     }
499     return 0;
500 }
501 
502 static int gdb_set_avr_reg(CPUPPCState *env, uint8_t *mem_buf, int n)
503 {
504     if (n < 32) {
505         ppc_avr_t *avr = cpu_avr_ptr(env, n);
506         ppc_maybe_bswap_register(env, mem_buf, 16);
507         avr->VsrD(0) = ldq_p(mem_buf);
508         avr->VsrD(1) = ldq_p(mem_buf + 8);
509         return 16;
510     }
511     if (n == 32) {
512         ppc_maybe_bswap_register(env, mem_buf, 4);
513         ppc_store_vscr(env, ldl_p(mem_buf));
514         return 4;
515     }
516     if (n == 33) {
517         ppc_maybe_bswap_register(env, mem_buf, 4);
518         env->spr[SPR_VRSAVE] = (target_ulong)ldl_p(mem_buf);
519         return 4;
520     }
521     return 0;
522 }
523 
524 static int gdb_get_spe_reg(CPUPPCState *env, GByteArray *buf, int n)
525 {
526     if (n < 32) {
527 #if defined(TARGET_PPC64)
528         gdb_get_reg32(buf, env->gpr[n] >> 32);
529         ppc_maybe_bswap_register(env, gdb_get_reg_ptr(buf, 4), 4);
530 #else
531         gdb_get_reg32(buf, env->gprh[n]);
532 #endif
533         return 4;
534     }
535     if (n == 32) {
536         gdb_get_reg64(buf, env->spe_acc);
537         ppc_maybe_bswap_register(env, gdb_get_reg_ptr(buf, 8), 8);
538         return 8;
539     }
540     if (n == 33) {
541         gdb_get_reg32(buf, env->spe_fscr);
542         ppc_maybe_bswap_register(env, gdb_get_reg_ptr(buf, 4), 4);
543         return 4;
544     }
545     return 0;
546 }
547 
548 static int gdb_set_spe_reg(CPUPPCState *env, uint8_t *mem_buf, int n)
549 {
550     if (n < 32) {
551 #if defined(TARGET_PPC64)
552         target_ulong lo = (uint32_t)env->gpr[n];
553         target_ulong hi;
554 
555         ppc_maybe_bswap_register(env, mem_buf, 4);
556 
557         hi = (target_ulong)ldl_p(mem_buf) << 32;
558         env->gpr[n] = lo | hi;
559 #else
560         env->gprh[n] = ldl_p(mem_buf);
561 #endif
562         return 4;
563     }
564     if (n == 32) {
565         ppc_maybe_bswap_register(env, mem_buf, 8);
566         env->spe_acc = ldq_p(mem_buf);
567         return 8;
568     }
569     if (n == 33) {
570         ppc_maybe_bswap_register(env, mem_buf, 4);
571         env->spe_fscr = ldl_p(mem_buf);
572         return 4;
573     }
574     return 0;
575 }
576 
577 static int gdb_get_vsx_reg(CPUPPCState *env, GByteArray *buf, int n)
578 {
579     if (n < 32) {
580         gdb_get_reg64(buf, *cpu_vsrl_ptr(env, n));
581         ppc_maybe_bswap_register(env, gdb_get_reg_ptr(buf, 8), 8);
582         return 8;
583     }
584     return 0;
585 }
586 
587 static int gdb_set_vsx_reg(CPUPPCState *env, uint8_t *mem_buf, int n)
588 {
589     if (n < 32) {
590         ppc_maybe_bswap_register(env, mem_buf, 8);
591         *cpu_vsrl_ptr(env, n) = ldq_p(mem_buf);
592         return 8;
593     }
594     return 0;
595 }
596 
597 gchar *ppc_gdb_arch_name(CPUState *cs)
598 {
599 #if defined(TARGET_PPC64)
600     return g_strdup("powerpc:common64");
601 #else
602     return g_strdup("powerpc:common");
603 #endif
604 }
605 
606 void ppc_gdb_init(CPUState *cs, PowerPCCPUClass *pcc)
607 {
608     if (pcc->insns_flags & PPC_FLOAT) {
609         gdb_register_coprocessor(cs, gdb_get_float_reg, gdb_set_float_reg,
610                                  33, "power-fpu.xml", 0);
611     }
612     if (pcc->insns_flags & PPC_ALTIVEC) {
613         gdb_register_coprocessor(cs, gdb_get_avr_reg, gdb_set_avr_reg,
614                                  34, "power-altivec.xml", 0);
615     }
616     if (pcc->insns_flags & PPC_SPE) {
617         gdb_register_coprocessor(cs, gdb_get_spe_reg, gdb_set_spe_reg,
618                                  34, "power-spe.xml", 0);
619     }
620     if (pcc->insns_flags2 & PPC2_VSX) {
621         gdb_register_coprocessor(cs, gdb_get_vsx_reg, gdb_set_vsx_reg,
622                                  32, "power-vsx.xml", 0);
623     }
624 #ifndef CONFIG_USER_ONLY
625     gdb_register_coprocessor(cs, gdb_get_spr_reg, gdb_set_spr_reg,
626                              pcc->gdb_num_sprs, "power-spr.xml", 0);
627 #endif
628 }
629