1 /* PPC GNU/Linux native support.
3 Copyright 1988, 1989, 1991, 1992, 1994, 1996, 2000, 2001, 2002,
4 2003 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
24 #include "gdb_string.h"
30 #include <sys/types.h>
31 #include <sys/param.h>
34 #include <sys/ioctl.h>
37 #include <sys/procfs.h>
38 #include <sys/ptrace.h>
40 /* Prototypes for supply_gregset etc. */
45 #define PT_READ_U PTRACE_PEEKUSR
48 #define PT_WRITE_U PTRACE_POKEUSR
51 /* Default the type of the ptrace transfer to int. */
52 #ifndef PTRACE_XFER_TYPE
53 #define PTRACE_XFER_TYPE int
56 /* Glibc's headers don't define PTRACE_GETVRREGS so we cannot use a
57 configure time check. Some older glibc's (for instance 2.2.1)
58 don't have a specific powerpc version of ptrace.h, and fall back on
59 a generic one. In such cases, sys/ptrace.h defines
60 PTRACE_GETFPXREGS and PTRACE_SETFPXREGS to the same numbers that
61 ppc kernel's asm/ptrace.h defines PTRACE_GETVRREGS and
62 PTRACE_SETVRREGS to be. This also makes a configury check pretty
65 /* These definitions should really come from the glibc header files,
66 but Glibc doesn't know about the vrregs yet. */
67 #ifndef PTRACE_GETVRREGS
68 #define PTRACE_GETVRREGS 18
69 #define PTRACE_SETVRREGS 19
72 /* This oddity is because the Linux kernel defines elf_vrregset_t as
73 an array of 33 16 bytes long elements. I.e. it leaves out vrsave.
74 However the PTRACE_GETVRREGS and PTRACE_SETVRREGS requests return
75 the vrsave as an extra 4 bytes at the end. I opted for creating a
76 flat array of chars, so that it is easier to manipulate for gdb.
78 There are 32 vector registers 16 bytes longs, plus a VSCR register
79 which is only 4 bytes long, but is fetched as a 16 bytes
80 quantity. Up to here we have the elf_vrregset_t structure.
81 Appended to this there is space for the VRSAVE register: 4 bytes.
82 Even though this vrsave register is not included in the regset
83 typedef, it is handled by the ptrace requests.
85 Note that GNU/Linux doesn't support little endian PPC hardware,
86 therefore the offset at which the real value of the VSCR register
87 is located will be always 12 bytes.
89 The layout is like this (where x is the actual value of the vscr reg): */
93 |.|.|.|.|.....|.|.|.|.||.|.|.|x||.|
94 <-------> <-------><-------><->
99 #define SIZEOF_VRREGS 33*16+4
101 typedef char gdb_vrregset_t
[SIZEOF_VRREGS
];
103 /* For runtime check of ptrace support for VRREGS. */
104 int have_ptrace_getvrregs
= 1;
109 return (sizeof (struct user
));
113 /* registers layout, as presented by the ptrace interface:
114 PT_R0, PT_R1, PT_R2, PT_R3, PT_R4, PT_R5, PT_R6, PT_R7,
115 PT_R8, PT_R9, PT_R10, PT_R11, PT_R12, PT_R13, PT_R14, PT_R15,
116 PT_R16, PT_R17, PT_R18, PT_R19, PT_R20, PT_R21, PT_R22, PT_R23,
117 PT_R24, PT_R25, PT_R26, PT_R27, PT_R28, PT_R29, PT_R30, PT_R31,
118 PT_FPR0, PT_FPR0 + 2, PT_FPR0 + 4, PT_FPR0 + 6, PT_FPR0 + 8, PT_FPR0 + 10, PT_FPR0 + 12, PT_FPR0 + 14,
119 PT_FPR0 + 16, PT_FPR0 + 18, PT_FPR0 + 20, PT_FPR0 + 22, PT_FPR0 + 24, PT_FPR0 + 26, PT_FPR0 + 28, PT_FPR0 + 30,
120 PT_FPR0 + 32, PT_FPR0 + 34, PT_FPR0 + 36, PT_FPR0 + 38, PT_FPR0 + 40, PT_FPR0 + 42, PT_FPR0 + 44, PT_FPR0 + 46,
121 PT_FPR0 + 48, PT_FPR0 + 50, PT_FPR0 + 52, PT_FPR0 + 54, PT_FPR0 + 56, PT_FPR0 + 58, PT_FPR0 + 60, PT_FPR0 + 62,
122 PT_NIP, PT_MSR, PT_CCR, PT_LNK, PT_CTR, PT_XER, PT_MQ */
126 ppc_register_u_addr (int regno
)
129 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
131 /* General purpose registers occupy 1 slot each in the buffer */
132 if (regno
>= tdep
->ppc_gp0_regnum
&& regno
<= tdep
->ppc_gplast_regnum
)
133 u_addr
= ((PT_R0
+ regno
) * 4);
135 /* Floating point regs: 2 slots each */
136 if (regno
>= FP0_REGNUM
&& regno
<= FPLAST_REGNUM
)
137 u_addr
= ((PT_FPR0
+ (regno
- FP0_REGNUM
) * 2) * 4);
139 /* UISA special purpose registers: 1 slot each */
140 if (regno
== PC_REGNUM
)
142 if (regno
== tdep
->ppc_lr_regnum
)
144 if (regno
== tdep
->ppc_cr_regnum
)
146 if (regno
== tdep
->ppc_xer_regnum
)
148 if (regno
== tdep
->ppc_ctr_regnum
)
150 if (regno
== tdep
->ppc_mq_regnum
)
152 if (regno
== tdep
->ppc_ps_regnum
)
154 if (regno
== tdep
->ppc_fpscr_regnum
)
155 u_addr
= PT_FPSCR
* 4;
161 ppc_ptrace_cannot_fetch_store_register (int regno
)
163 return (ppc_register_u_addr (regno
) == -1);
166 /* The Linux kernel ptrace interface for AltiVec registers uses the
167 registers set mechanism, as opposed to the interface for all the
168 other registers, that stores/fetches each register individually. */
170 fetch_altivec_register (int tid
, int regno
)
175 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
176 int vrregsize
= REGISTER_RAW_SIZE (tdep
->ppc_vr0_regnum
);
178 ret
= ptrace (PTRACE_GETVRREGS
, tid
, 0, ®s
);
183 have_ptrace_getvrregs
= 0;
186 perror_with_name ("Unable to fetch AltiVec register");
189 /* VSCR is fetched as a 16 bytes quantity, but it is really 4 bytes
190 long on the hardware. We deal only with the lower 4 bytes of the
191 vector. VRSAVE is at the end of the array in a 4 bytes slot, so
192 there is no need to define an offset for it. */
193 if (regno
== (tdep
->ppc_vrsave_regnum
- 1))
194 offset
= vrregsize
- REGISTER_RAW_SIZE (tdep
->ppc_vrsave_regnum
);
196 supply_register (regno
,
197 regs
+ (regno
- tdep
->ppc_vr0_regnum
) * vrregsize
+ offset
);
201 fetch_register (int tid
, int regno
)
203 /* This isn't really an address. But ptrace thinks of it as one. */
204 char mess
[128]; /* For messages */
206 unsigned int offset
; /* Offset of registers within the u area. */
207 char *buf
= alloca (MAX_REGISTER_RAW_SIZE
);
208 CORE_ADDR regaddr
= ppc_register_u_addr (regno
);
210 if (altivec_register_p (regno
))
212 /* If this is the first time through, or if it is not the first
213 time through, and we have comfirmed that there is kernel
214 support for such a ptrace request, then go and fetch the
216 if (have_ptrace_getvrregs
)
218 fetch_altivec_register (tid
, regno
);
221 /* If we have discovered that there is no ptrace support for
222 AltiVec registers, fall through and return zeroes, because
223 regaddr will be -1 in this case. */
228 memset (buf
, '\0', REGISTER_RAW_SIZE (regno
)); /* Supply zeroes */
229 supply_register (regno
, buf
);
233 for (i
= 0; i
< REGISTER_RAW_SIZE (regno
); i
+= sizeof (PTRACE_XFER_TYPE
))
236 *(PTRACE_XFER_TYPE
*) & buf
[i
] = ptrace (PT_READ_U
, tid
,
237 (PTRACE_ARG3_TYPE
) regaddr
, 0);
238 regaddr
+= sizeof (PTRACE_XFER_TYPE
);
241 sprintf (mess
, "reading register %s (#%d)",
242 REGISTER_NAME (regno
), regno
);
243 perror_with_name (mess
);
246 supply_register (regno
, buf
);
250 supply_vrregset (gdb_vrregset_t
*vrregsetp
)
253 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
254 int num_of_vrregs
= tdep
->ppc_vrsave_regnum
- tdep
->ppc_vr0_regnum
+ 1;
255 int vrregsize
= REGISTER_RAW_SIZE (tdep
->ppc_vr0_regnum
);
256 int offset
= vrregsize
- REGISTER_RAW_SIZE (tdep
->ppc_vrsave_regnum
);
258 for (i
= 0; i
< num_of_vrregs
; i
++)
260 /* The last 2 registers of this set are only 32 bit long, not
261 128. However an offset is necessary only for VSCR because it
262 occupies a whole vector, while VRSAVE occupies a full 4 bytes
264 if (i
== (num_of_vrregs
- 2))
265 supply_register (tdep
->ppc_vr0_regnum
+ i
,
266 *vrregsetp
+ i
* vrregsize
+ offset
);
268 supply_register (tdep
->ppc_vr0_regnum
+ i
, *vrregsetp
+ i
* vrregsize
);
273 fetch_altivec_registers (int tid
)
278 ret
= ptrace (PTRACE_GETVRREGS
, tid
, 0, ®s
);
283 have_ptrace_getvrregs
= 0;
286 perror_with_name ("Unable to fetch AltiVec registers");
288 supply_vrregset (®s
);
292 fetch_ppc_registers (int tid
)
295 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
297 for (i
= 0; i
<= tdep
->ppc_fpscr_regnum
; i
++)
298 fetch_register (tid
, i
);
299 if (tdep
->ppc_mq_regnum
!= -1)
300 fetch_register (tid
, tdep
->ppc_mq_regnum
);
301 if (have_ptrace_getvrregs
)
302 if (tdep
->ppc_vr0_regnum
!= -1 && tdep
->ppc_vrsave_regnum
!= -1)
303 fetch_altivec_registers (tid
);
306 /* Fetch registers from the child process. Fetch all registers if
307 regno == -1, otherwise fetch all general registers or all floating
308 point registers depending upon the value of regno. */
310 fetch_inferior_registers (int regno
)
312 /* Overload thread id onto process id */
313 int tid
= TIDGET (inferior_ptid
);
315 /* No thread id, just use process id */
317 tid
= PIDGET (inferior_ptid
);
320 fetch_ppc_registers (tid
);
322 fetch_register (tid
, regno
);
325 /* Store one register. */
327 store_altivec_register (int tid
, int regno
)
332 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
333 int vrregsize
= REGISTER_RAW_SIZE (tdep
->ppc_vr0_regnum
);
335 ret
= ptrace (PTRACE_GETVRREGS
, tid
, 0, ®s
);
340 have_ptrace_getvrregs
= 0;
343 perror_with_name ("Unable to fetch AltiVec register");
346 /* VSCR is fetched as a 16 bytes quantity, but it is really 4 bytes
347 long on the hardware. */
348 if (regno
== (tdep
->ppc_vrsave_regnum
- 1))
349 offset
= vrregsize
- REGISTER_RAW_SIZE (tdep
->ppc_vrsave_regnum
);
351 regcache_collect (regno
,
352 regs
+ (regno
- tdep
->ppc_vr0_regnum
) * vrregsize
+ offset
);
354 ret
= ptrace (PTRACE_SETVRREGS
, tid
, 0, ®s
);
356 perror_with_name ("Unable to store AltiVec register");
360 store_register (int tid
, int regno
)
362 /* This isn't really an address. But ptrace thinks of it as one. */
363 CORE_ADDR regaddr
= ppc_register_u_addr (regno
);
364 char mess
[128]; /* For messages */
366 unsigned int offset
; /* Offset of registers within the u area. */
367 char *buf
= alloca (MAX_REGISTER_RAW_SIZE
);
369 if (altivec_register_p (regno
))
371 store_altivec_register (tid
, regno
);
378 regcache_collect (regno
, buf
);
379 for (i
= 0; i
< REGISTER_RAW_SIZE (regno
); i
+= sizeof (PTRACE_XFER_TYPE
))
382 ptrace (PT_WRITE_U
, tid
, (PTRACE_ARG3_TYPE
) regaddr
,
383 *(PTRACE_XFER_TYPE
*) & buf
[i
]);
384 regaddr
+= sizeof (PTRACE_XFER_TYPE
);
387 && regno
== gdbarch_tdep (current_gdbarch
)->ppc_fpscr_regnum
)
389 /* Some older kernel versions don't allow fpscr to be written. */
395 sprintf (mess
, "writing register %s (#%d)",
396 REGISTER_NAME (regno
), regno
);
397 perror_with_name (mess
);
403 fill_vrregset (gdb_vrregset_t
*vrregsetp
)
406 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
407 int num_of_vrregs
= tdep
->ppc_vrsave_regnum
- tdep
->ppc_vr0_regnum
+ 1;
408 int vrregsize
= REGISTER_RAW_SIZE (tdep
->ppc_vr0_regnum
);
409 int offset
= vrregsize
- REGISTER_RAW_SIZE (tdep
->ppc_vrsave_regnum
);
411 for (i
= 0; i
< num_of_vrregs
; i
++)
413 /* The last 2 registers of this set are only 32 bit long, not
414 128, but only VSCR is fetched as a 16 bytes quantity. */
415 if (i
== (num_of_vrregs
- 2))
416 regcache_collect (tdep
->ppc_vr0_regnum
+ i
,
417 *vrregsetp
+ i
* vrregsize
+ offset
);
419 regcache_collect (tdep
->ppc_vr0_regnum
+ i
, *vrregsetp
+ i
* vrregsize
);
424 store_altivec_registers (int tid
)
429 ret
= ptrace (PTRACE_GETVRREGS
, tid
, 0, (int) ®s
);
434 have_ptrace_getvrregs
= 0;
437 perror_with_name ("Couldn't get AltiVec registers");
440 fill_vrregset (®s
);
442 if (ptrace (PTRACE_SETVRREGS
, tid
, 0, (int) ®s
) < 0)
443 perror_with_name ("Couldn't write AltiVec registers");
447 store_ppc_registers (int tid
)
450 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
452 for (i
= 0; i
<= tdep
->ppc_fpscr_regnum
; i
++)
453 store_register (tid
, i
);
454 if (tdep
->ppc_mq_regnum
!= -1)
455 store_register (tid
, tdep
->ppc_mq_regnum
);
456 if (have_ptrace_getvrregs
)
457 if (tdep
->ppc_vr0_regnum
!= -1 && tdep
->ppc_vrsave_regnum
!= -1)
458 store_altivec_registers (tid
);
462 store_inferior_registers (int regno
)
464 /* Overload thread id onto process id */
465 int tid
= TIDGET (inferior_ptid
);
467 /* No thread id, just use process id */
469 tid
= PIDGET (inferior_ptid
);
472 store_register (tid
, regno
);
474 store_ppc_registers (tid
);
478 supply_gregset (gdb_gregset_t
*gregsetp
)
480 ppc_linux_supply_gregset ((char *) gregsetp
);
484 fill_gregset (gdb_gregset_t
*gregsetp
, int regno
)
487 elf_greg_t
*regp
= (elf_greg_t
*) gregsetp
;
488 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
490 for (regi
= 0; regi
< 32; regi
++)
492 if ((regno
== -1) || regno
== regi
)
493 regcache_collect (regi
, regp
+ PT_R0
+ regi
);
496 if ((regno
== -1) || regno
== PC_REGNUM
)
497 regcache_collect (PC_REGNUM
, regp
+ PT_NIP
);
498 if ((regno
== -1) || regno
== tdep
->ppc_lr_regnum
)
499 regcache_collect (tdep
->ppc_lr_regnum
, regp
+ PT_LNK
);
500 if ((regno
== -1) || regno
== tdep
->ppc_cr_regnum
)
501 regcache_collect (tdep
->ppc_cr_regnum
, regp
+ PT_CCR
);
502 if ((regno
== -1) || regno
== tdep
->ppc_xer_regnum
)
503 regcache_collect (tdep
->ppc_xer_regnum
, regp
+ PT_XER
);
504 if ((regno
== -1) || regno
== tdep
->ppc_ctr_regnum
)
505 regcache_collect (tdep
->ppc_ctr_regnum
, regp
+ PT_CTR
);
506 if (((regno
== -1) || regno
== tdep
->ppc_mq_regnum
)
507 && (tdep
->ppc_mq_regnum
!= -1))
508 regcache_collect (tdep
->ppc_mq_regnum
, regp
+ PT_MQ
);
509 if ((regno
== -1) || regno
== tdep
->ppc_ps_regnum
)
510 regcache_collect (tdep
->ppc_ps_regnum
, regp
+ PT_MSR
);
514 supply_fpregset (gdb_fpregset_t
* fpregsetp
)
516 ppc_linux_supply_fpregset ((char *) fpregsetp
);
519 /* Given a pointer to a floating point register set in /proc format
520 (fpregset_t *), update the register specified by REGNO from gdb's
521 idea of the current floating point register set. If REGNO is -1,
524 fill_fpregset (gdb_fpregset_t
*fpregsetp
, int regno
)
527 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
529 for (regi
= 0; regi
< 32; regi
++)
531 if ((regno
== -1) || (regno
== FP0_REGNUM
+ regi
))
532 regcache_collect (FP0_REGNUM
+ regi
, (char *) (*fpregsetp
+ regi
));
534 if ((regno
== -1) || regno
== tdep
->ppc_fpscr_regnum
)
535 regcache_collect (tdep
->ppc_fpscr_regnum
, (char *) (*fpregsetp
+ regi
));
This page took 0.040659 seconds and 4 git commands to generate.