1 /* PPC GNU/Linux native support.
2 Copyright 1988, 1989, 1991, 1992, 1994, 1996, 2000, 2001, 2002
3 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program 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
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
23 #include "gdb_string.h"
29 #include <sys/types.h>
30 #include <sys/param.h>
33 #include <sys/ioctl.h>
36 #include <sys/procfs.h>
37 #include <sys/ptrace.h>
39 /* Prototypes for supply_gregset etc. */
44 #define PT_READ_U PTRACE_PEEKUSR
47 #define PT_WRITE_U PTRACE_POKEUSR
50 /* Default the type of the ptrace transfer to int. */
51 #ifndef PTRACE_XFER_TYPE
52 #define PTRACE_XFER_TYPE int
55 /* Glibc's headers don't define PTRACE_GETVRREGS so we cannot use a
56 configure time check. Some older glibc's (for instance 2.2.1)
57 don't have a specific powerpc version of ptrace.h, and fall back on
58 a generic one. In such cases, sys/ptrace.h defines
59 PTRACE_GETFPXREGS and PTRACE_SETFPXREGS to the same numbers that
60 ppc kernel's asm/ptrace.h defines PTRACE_GETVRREGS and
61 PTRACE_SETVRREGS to be. This also makes a configury check pretty
64 /* These definitions should really come from the glibc header files,
65 but Glibc doesn't know about the vrregs yet. */
66 #ifndef PTRACE_GETVRREGS
67 #define PTRACE_GETVRREGS 18
68 #define PTRACE_SETVRREGS 19
71 /* This oddity is because the Linux kernel defines elf_vrregset_t as
72 an array of 33 16 bytes long elements. I.e. it leaves out vrsave.
73 However the PTRACE_GETVRREGS and PTRACE_SETVRREGS requests return
74 the vrsave as an extra 4 bytes at the end. I opted for creating a
75 flat array of chars, so that it is easier to manipulate for gdb.
77 There are 32 vector registers 16 bytes longs, plus a VSCR register
78 which is only 4 bytes long, but is fetched as a 16 bytes
79 quantity. Up to here we have the elf_vrregset_t structure.
80 Appended to this there is space for the VRSAVE register: 4 bytes.
81 Even though this vrsave register is not included in the regset
82 typedef, it is handled by the ptrace requests.
84 Note that GNU/Linux doesn't support little endian PPC hardware,
85 therefore the offset at which the real value of the VSCR register
86 is located will be always 12 bytes.
88 The layout is like this (where x is the actual value of the vscr reg): */
92 |.|.|.|.|.....|.|.|.|.||.|.|.|x||.|
93 <-------> <-------><-------><->
98 #define SIZEOF_VRREGS 33*16+4
100 typedef char gdb_vrregset_t
[SIZEOF_VRREGS
];
102 /* For runtime check of ptrace support for VRREGS. */
103 int have_ptrace_getvrregs
= 1;
108 return (sizeof (struct user
));
112 /* registers layout, as presented by the ptrace interface:
113 PT_R0, PT_R1, PT_R2, PT_R3, PT_R4, PT_R5, PT_R6, PT_R7,
114 PT_R8, PT_R9, PT_R10, PT_R11, PT_R12, PT_R13, PT_R14, PT_R15,
115 PT_R16, PT_R17, PT_R18, PT_R19, PT_R20, PT_R21, PT_R22, PT_R23,
116 PT_R24, PT_R25, PT_R26, PT_R27, PT_R28, PT_R29, PT_R30, PT_R31,
117 PT_FPR0, PT_FPR0 + 2, PT_FPR0 + 4, PT_FPR0 + 6, PT_FPR0 + 8, PT_FPR0 + 10, PT_FPR0 + 12, PT_FPR0 + 14,
118 PT_FPR0 + 16, PT_FPR0 + 18, PT_FPR0 + 20, PT_FPR0 + 22, PT_FPR0 + 24, PT_FPR0 + 26, PT_FPR0 + 28, PT_FPR0 + 30,
119 PT_FPR0 + 32, PT_FPR0 + 34, PT_FPR0 + 36, PT_FPR0 + 38, PT_FPR0 + 40, PT_FPR0 + 42, PT_FPR0 + 44, PT_FPR0 + 46,
120 PT_FPR0 + 48, PT_FPR0 + 50, PT_FPR0 + 52, PT_FPR0 + 54, PT_FPR0 + 56, PT_FPR0 + 58, PT_FPR0 + 60, PT_FPR0 + 62,
121 PT_NIP, PT_MSR, PT_CCR, PT_LNK, PT_CTR, PT_XER, PT_MQ */
125 ppc_register_u_addr (int regno
)
128 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
130 /* General purpose registers occupy 1 slot each in the buffer */
131 if (regno
>= tdep
->ppc_gp0_regnum
&& regno
<= tdep
->ppc_gplast_regnum
)
132 u_addr
= ((PT_R0
+ regno
) * 4);
134 /* Floating point regs: 2 slots each */
135 if (regno
>= FP0_REGNUM
&& regno
<= FPLAST_REGNUM
)
136 u_addr
= ((PT_FPR0
+ (regno
- FP0_REGNUM
) * 2) * 4);
138 /* UISA special purpose registers: 1 slot each */
139 if (regno
== PC_REGNUM
)
141 if (regno
== tdep
->ppc_lr_regnum
)
143 if (regno
== tdep
->ppc_cr_regnum
)
145 if (regno
== tdep
->ppc_xer_regnum
)
147 if (regno
== tdep
->ppc_ctr_regnum
)
149 if (regno
== tdep
->ppc_mq_regnum
)
151 if (regno
== tdep
->ppc_ps_regnum
)
153 if (regno
== tdep
->ppc_fpscr_regnum
)
154 u_addr
= PT_FPSCR
* 4;
160 ppc_ptrace_cannot_fetch_store_register (int regno
)
162 return (ppc_register_u_addr (regno
) == -1);
165 /* The Linux kernel ptrace interface for AltiVec registers uses the
166 registers set mechanism, as opposed to the interface for all the
167 other registers, that stores/fetches each register individually. */
169 fetch_altivec_register (int tid
, int regno
)
174 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
175 int vrregsize
= REGISTER_RAW_SIZE (tdep
->ppc_vr0_regnum
);
177 ret
= ptrace (PTRACE_GETVRREGS
, tid
, 0, ®s
);
182 have_ptrace_getvrregs
= 0;
185 perror_with_name ("Unable to fetch AltiVec register");
188 /* VSCR is fetched as a 16 bytes quantity, but it is really 4 bytes
189 long on the hardware. We deal only with the lower 4 bytes of the
190 vector. VRSAVE is at the end of the array in a 4 bytes slot, so
191 there is no need to define an offset for it. */
192 if (regno
== (tdep
->ppc_vrsave_regnum
- 1))
193 offset
= vrregsize
- REGISTER_RAW_SIZE (tdep
->ppc_vrsave_regnum
);
195 supply_register (regno
,
196 regs
+ (regno
- tdep
->ppc_vr0_regnum
) * vrregsize
+ offset
);
200 fetch_register (int tid
, int regno
)
202 /* This isn't really an address. But ptrace thinks of it as one. */
203 char mess
[128]; /* For messages */
205 unsigned int offset
; /* Offset of registers within the u area. */
206 char *buf
= alloca (MAX_REGISTER_RAW_SIZE
);
207 CORE_ADDR regaddr
= ppc_register_u_addr (regno
);
209 if (altivec_register_p (regno
))
211 /* If this is the first time through, or if it is not the first
212 time through, and we have comfirmed that there is kernel
213 support for such a ptrace request, then go and fetch the
215 if (have_ptrace_getvrregs
)
217 fetch_altivec_register (tid
, regno
);
220 /* If we have discovered that there is no ptrace support for
221 AltiVec registers, fall through and return zeroes, because
222 regaddr will be -1 in this case. */
227 memset (buf
, '\0', REGISTER_RAW_SIZE (regno
)); /* Supply zeroes */
228 supply_register (regno
, buf
);
232 for (i
= 0; i
< REGISTER_RAW_SIZE (regno
); i
+= sizeof (PTRACE_XFER_TYPE
))
235 *(PTRACE_XFER_TYPE
*) & buf
[i
] = ptrace (PT_READ_U
, tid
,
236 (PTRACE_ARG3_TYPE
) regaddr
, 0);
237 regaddr
+= sizeof (PTRACE_XFER_TYPE
);
240 sprintf (mess
, "reading register %s (#%d)",
241 REGISTER_NAME (regno
), regno
);
242 perror_with_name (mess
);
245 supply_register (regno
, buf
);
249 supply_vrregset (gdb_vrregset_t
*vrregsetp
)
252 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
253 int num_of_vrregs
= tdep
->ppc_vrsave_regnum
- tdep
->ppc_vr0_regnum
+ 1;
254 int vrregsize
= REGISTER_RAW_SIZE (tdep
->ppc_vr0_regnum
);
255 int offset
= vrregsize
- REGISTER_RAW_SIZE (tdep
->ppc_vrsave_regnum
);
257 for (i
= 0; i
< num_of_vrregs
; i
++)
259 /* The last 2 registers of this set are only 32 bit long, not
260 128. However an offset is necessary only for VSCR because it
261 occupies a whole vector, while VRSAVE occupies a full 4 bytes
263 if (i
== (num_of_vrregs
- 2))
264 supply_register (tdep
->ppc_vr0_regnum
+ i
,
265 *vrregsetp
+ i
* vrregsize
+ offset
);
267 supply_register (tdep
->ppc_vr0_regnum
+ i
, *vrregsetp
+ i
* vrregsize
);
272 fetch_altivec_registers (int tid
)
277 ret
= ptrace (PTRACE_GETVRREGS
, tid
, 0, ®s
);
282 have_ptrace_getvrregs
= 0;
285 perror_with_name ("Unable to fetch AltiVec registers");
287 supply_vrregset (®s
);
291 fetch_ppc_registers (int tid
)
294 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
296 for (i
= 0; i
<= tdep
->ppc_fpscr_regnum
; i
++)
297 fetch_register (tid
, i
);
298 if (tdep
->ppc_mq_regnum
!= -1)
299 fetch_register (tid
, tdep
->ppc_mq_regnum
);
300 if (have_ptrace_getvrregs
)
301 if (tdep
->ppc_vr0_regnum
!= -1 && tdep
->ppc_vrsave_regnum
!= -1)
302 fetch_altivec_registers (tid
);
305 /* Fetch registers from the child process. Fetch all registers if
306 regno == -1, otherwise fetch all general registers or all floating
307 point registers depending upon the value of regno. */
309 fetch_inferior_registers (int regno
)
311 /* Overload thread id onto process id */
312 int tid
= TIDGET (inferior_ptid
);
314 /* No thread id, just use process id */
316 tid
= PIDGET (inferior_ptid
);
319 fetch_ppc_registers (tid
);
321 fetch_register (tid
, regno
);
324 /* Store one register. */
326 store_altivec_register (int tid
, int regno
)
331 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
332 int vrregsize
= REGISTER_RAW_SIZE (tdep
->ppc_vr0_regnum
);
334 ret
= ptrace (PTRACE_GETVRREGS
, tid
, 0, ®s
);
339 have_ptrace_getvrregs
= 0;
342 perror_with_name ("Unable to fetch AltiVec register");
345 /* VSCR is fetched as a 16 bytes quantity, but it is really 4 bytes
346 long on the hardware. */
347 if (regno
== (tdep
->ppc_vrsave_regnum
- 1))
348 offset
= vrregsize
- REGISTER_RAW_SIZE (tdep
->ppc_vrsave_regnum
);
350 regcache_collect (regno
,
351 regs
+ (regno
- tdep
->ppc_vr0_regnum
) * vrregsize
+ offset
);
353 ret
= ptrace (PTRACE_SETVRREGS
, tid
, 0, ®s
);
355 perror_with_name ("Unable to store AltiVec register");
359 store_register (int tid
, int regno
)
361 /* This isn't really an address. But ptrace thinks of it as one. */
362 CORE_ADDR regaddr
= ppc_register_u_addr (regno
);
363 char mess
[128]; /* For messages */
365 unsigned int offset
; /* Offset of registers within the u area. */
366 char *buf
= alloca (MAX_REGISTER_RAW_SIZE
);
368 if (altivec_register_p (regno
))
370 store_altivec_register (tid
, regno
);
377 regcache_collect (regno
, buf
);
378 for (i
= 0; i
< REGISTER_RAW_SIZE (regno
); i
+= sizeof (PTRACE_XFER_TYPE
))
381 ptrace (PT_WRITE_U
, tid
, (PTRACE_ARG3_TYPE
) regaddr
,
382 *(PTRACE_XFER_TYPE
*) & buf
[i
]);
383 regaddr
+= sizeof (PTRACE_XFER_TYPE
);
386 && regno
== gdbarch_tdep (current_gdbarch
)->ppc_fpscr_regnum
)
388 /* Some older kernel versions don't allow fpscr to be written. */
394 sprintf (mess
, "writing register %s (#%d)",
395 REGISTER_NAME (regno
), regno
);
396 perror_with_name (mess
);
402 fill_vrregset (gdb_vrregset_t
*vrregsetp
)
405 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
406 int num_of_vrregs
= tdep
->ppc_vrsave_regnum
- tdep
->ppc_vr0_regnum
+ 1;
407 int vrregsize
= REGISTER_RAW_SIZE (tdep
->ppc_vr0_regnum
);
408 int offset
= vrregsize
- REGISTER_RAW_SIZE (tdep
->ppc_vrsave_regnum
);
410 for (i
= 0; i
< num_of_vrregs
; i
++)
412 /* The last 2 registers of this set are only 32 bit long, not
413 128, but only VSCR is fetched as a 16 bytes quantity. */
414 if (i
== (num_of_vrregs
- 2))
415 regcache_collect (tdep
->ppc_vr0_regnum
+ i
,
416 *vrregsetp
+ i
* vrregsize
+ offset
);
418 regcache_collect (tdep
->ppc_vr0_regnum
+ i
, *vrregsetp
+ i
* vrregsize
);
423 store_altivec_registers (int tid
)
428 ret
= ptrace (PTRACE_GETVRREGS
, tid
, 0, (int) ®s
);
433 have_ptrace_getvrregs
= 0;
436 perror_with_name ("Couldn't get AltiVec registers");
439 fill_vrregset (®s
);
441 if (ptrace (PTRACE_SETVRREGS
, tid
, 0, (int) ®s
) < 0)
442 perror_with_name ("Couldn't write AltiVec registers");
446 store_ppc_registers (int tid
)
449 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
451 for (i
= 0; i
<= tdep
->ppc_fpscr_regnum
; i
++)
452 store_register (tid
, i
);
453 if (tdep
->ppc_mq_regnum
!= -1)
454 store_register (tid
, tdep
->ppc_mq_regnum
);
455 if (have_ptrace_getvrregs
)
456 if (tdep
->ppc_vr0_regnum
!= -1 && tdep
->ppc_vrsave_regnum
!= -1)
457 store_altivec_registers (tid
);
461 store_inferior_registers (int regno
)
463 /* Overload thread id onto process id */
464 int tid
= TIDGET (inferior_ptid
);
466 /* No thread id, just use process id */
468 tid
= PIDGET (inferior_ptid
);
471 store_register (tid
, regno
);
473 store_ppc_registers (tid
);
477 supply_gregset (gdb_gregset_t
*gregsetp
)
479 ppc_linux_supply_gregset ((char *) gregsetp
);
483 fill_gregset (gdb_gregset_t
*gregsetp
, int regno
)
486 elf_greg_t
*regp
= (elf_greg_t
*) gregsetp
;
487 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
489 for (regi
= 0; regi
< 32; regi
++)
491 if ((regno
== -1) || regno
== regi
)
492 regcache_collect (regi
, regp
+ PT_R0
+ regi
);
495 if ((regno
== -1) || regno
== PC_REGNUM
)
496 regcache_collect (PC_REGNUM
, regp
+ PT_NIP
);
497 if ((regno
== -1) || regno
== tdep
->ppc_lr_regnum
)
498 regcache_collect (tdep
->ppc_lr_regnum
, regp
+ PT_LNK
);
499 if ((regno
== -1) || regno
== tdep
->ppc_cr_regnum
)
500 regcache_collect (tdep
->ppc_cr_regnum
, regp
+ PT_CCR
);
501 if ((regno
== -1) || regno
== tdep
->ppc_xer_regnum
)
502 regcache_collect (tdep
->ppc_xer_regnum
, regp
+ PT_XER
);
503 if ((regno
== -1) || regno
== tdep
->ppc_ctr_regnum
)
504 regcache_collect (tdep
->ppc_ctr_regnum
, regp
+ PT_CTR
);
505 if (((regno
== -1) || regno
== tdep
->ppc_mq_regnum
)
506 && (tdep
->ppc_mq_regnum
!= -1))
507 regcache_collect (tdep
->ppc_mq_regnum
, regp
+ PT_MQ
);
508 if ((regno
== -1) || regno
== tdep
->ppc_ps_regnum
)
509 regcache_collect (tdep
->ppc_ps_regnum
, regp
+ PT_MSR
);
513 supply_fpregset (gdb_fpregset_t
* fpregsetp
)
515 ppc_linux_supply_fpregset ((char *) fpregsetp
);
518 /* Given a pointer to a floating point register set in /proc format
519 (fpregset_t *), update the register specified by REGNO from gdb's
520 idea of the current floating point register set. If REGNO is -1,
523 fill_fpregset (gdb_fpregset_t
*fpregsetp
, int regno
)
526 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
528 for (regi
= 0; regi
< 32; regi
++)
530 if ((regno
== -1) || (regno
== FP0_REGNUM
+ regi
))
531 regcache_collect (FP0_REGNUM
+ regi
, (char *) (*fpregsetp
+ regi
));
533 if ((regno
== -1) || regno
== tdep
->ppc_fpscr_regnum
)
534 regcache_collect (tdep
->ppc_fpscr_regnum
, (char *) (*fpregsetp
+ regi
));
This page took 0.040785 seconds and 4 git commands to generate.