fc8508d64f3dccc5f1dc6664d3857bc4efd2a604
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
);
130 /* NOTE: cagney/2003-11-25: This is the word size used by the ptrace
131 interface, and not the wordsize of the program's ABI. */
132 int wordsize
= sizeof (PTRACE_XFER_TYPE
);
134 /* General purpose registers occupy 1 slot each in the buffer */
135 if (regno
>= tdep
->ppc_gp0_regnum
136 && regno
< tdep
->ppc_gp0_regnum
+ ppc_num_gprs
)
137 u_addr
= ((regno
- tdep
->ppc_gp0_regnum
+ PT_R0
) * wordsize
);
139 /* Floating point regs: eight bytes each in both 32- and 64-bit
140 ptrace interfaces. Thus, two slots each in 32-bit interface, one
141 slot each in 64-bit interface. */
142 if (regno
>= FP0_REGNUM
&& regno
< FP0_REGNUM
+ ppc_num_fprs
)
143 u_addr
= (PT_FPR0
* wordsize
) + ((regno
- FP0_REGNUM
) * 8);
145 /* UISA special purpose registers: 1 slot each */
146 if (regno
== PC_REGNUM
)
147 u_addr
= PT_NIP
* wordsize
;
148 if (regno
== tdep
->ppc_lr_regnum
)
149 u_addr
= PT_LNK
* wordsize
;
150 if (regno
== tdep
->ppc_cr_regnum
)
151 u_addr
= PT_CCR
* wordsize
;
152 if (regno
== tdep
->ppc_xer_regnum
)
153 u_addr
= PT_XER
* wordsize
;
154 if (regno
== tdep
->ppc_ctr_regnum
)
155 u_addr
= PT_CTR
* wordsize
;
157 if (regno
== tdep
->ppc_mq_regnum
)
158 u_addr
= PT_MQ
* wordsize
;
160 if (regno
== tdep
->ppc_ps_regnum
)
161 u_addr
= PT_MSR
* wordsize
;
162 if (regno
== tdep
->ppc_fpscr_regnum
)
163 u_addr
= PT_FPSCR
* wordsize
;
168 /* The Linux kernel ptrace interface for AltiVec registers uses the
169 registers set mechanism, as opposed to the interface for all the
170 other registers, that stores/fetches each register individually. */
172 fetch_altivec_register (int tid
, int regno
)
177 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
178 int vrregsize
= DEPRECATED_REGISTER_RAW_SIZE (tdep
->ppc_vr0_regnum
);
180 ret
= ptrace (PTRACE_GETVRREGS
, tid
, 0, ®s
);
185 have_ptrace_getvrregs
= 0;
188 perror_with_name ("Unable to fetch AltiVec register");
191 /* VSCR is fetched as a 16 bytes quantity, but it is really 4 bytes
192 long on the hardware. We deal only with the lower 4 bytes of the
193 vector. VRSAVE is at the end of the array in a 4 bytes slot, so
194 there is no need to define an offset for it. */
195 if (regno
== (tdep
->ppc_vrsave_regnum
- 1))
196 offset
= vrregsize
- DEPRECATED_REGISTER_RAW_SIZE (tdep
->ppc_vrsave_regnum
);
198 supply_register (regno
,
199 regs
+ (regno
- tdep
->ppc_vr0_regnum
) * vrregsize
+ offset
);
203 fetch_register (int tid
, int regno
)
205 /* This isn't really an address. But ptrace thinks of it as one. */
206 char mess
[128]; /* For messages */
208 unsigned int offset
; /* Offset of registers within the u area. */
209 char buf
[MAX_REGISTER_SIZE
];
210 CORE_ADDR regaddr
= ppc_register_u_addr (regno
);
212 if (altivec_register_p (regno
))
214 /* If this is the first time through, or if it is not the first
215 time through, and we have comfirmed that there is kernel
216 support for such a ptrace request, then go and fetch the
218 if (have_ptrace_getvrregs
)
220 fetch_altivec_register (tid
, regno
);
223 /* If we have discovered that there is no ptrace support for
224 AltiVec registers, fall through and return zeroes, because
225 regaddr will be -1 in this case. */
230 memset (buf
, '\0', DEPRECATED_REGISTER_RAW_SIZE (regno
)); /* Supply zeroes */
231 supply_register (regno
, buf
);
235 /* Read the raw register using PTRACE_XFER_TYPE sized chunks. On a
236 32-bit platform, 64-bit floating-point registers will require two
238 for (i
= 0; i
< DEPRECATED_REGISTER_RAW_SIZE (regno
); i
+= sizeof (PTRACE_XFER_TYPE
))
241 *(PTRACE_XFER_TYPE
*) & buf
[i
] = ptrace (PT_READ_U
, tid
,
242 (PTRACE_ARG3_TYPE
) regaddr
, 0);
243 regaddr
+= sizeof (PTRACE_XFER_TYPE
);
246 sprintf (mess
, "reading register %s (#%d)",
247 REGISTER_NAME (regno
), regno
);
248 perror_with_name (mess
);
252 /* Now supply the register. Be careful to map between ptrace's and
253 the current_regcache's idea of the current wordsize. */
254 if ((regno
>= FP0_REGNUM
&& regno
< FP0_REGNUM
+32)
255 || gdbarch_byte_order (current_gdbarch
) == BFD_ENDIAN_LITTLE
)
256 /* FPs are always 64 bits. Little endian values are always found
257 at the left-hand end of the register. */
258 regcache_raw_supply (current_regcache
, regno
, buf
);
260 /* Big endian register, need to fetch the right-hand end. */
261 regcache_raw_supply (current_regcache
, regno
,
262 (buf
+ sizeof (PTRACE_XFER_TYPE
)
263 - register_size (current_gdbarch
, regno
)));
267 supply_vrregset (gdb_vrregset_t
*vrregsetp
)
270 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
271 int num_of_vrregs
= tdep
->ppc_vrsave_regnum
- tdep
->ppc_vr0_regnum
+ 1;
272 int vrregsize
= DEPRECATED_REGISTER_RAW_SIZE (tdep
->ppc_vr0_regnum
);
273 int offset
= vrregsize
- DEPRECATED_REGISTER_RAW_SIZE (tdep
->ppc_vrsave_regnum
);
275 for (i
= 0; i
< num_of_vrregs
; i
++)
277 /* The last 2 registers of this set are only 32 bit long, not
278 128. However an offset is necessary only for VSCR because it
279 occupies a whole vector, while VRSAVE occupies a full 4 bytes
281 if (i
== (num_of_vrregs
- 2))
282 supply_register (tdep
->ppc_vr0_regnum
+ i
,
283 *vrregsetp
+ i
* vrregsize
+ offset
);
285 supply_register (tdep
->ppc_vr0_regnum
+ i
, *vrregsetp
+ i
* vrregsize
);
290 fetch_altivec_registers (int tid
)
295 ret
= ptrace (PTRACE_GETVRREGS
, tid
, 0, ®s
);
300 have_ptrace_getvrregs
= 0;
303 perror_with_name ("Unable to fetch AltiVec registers");
305 supply_vrregset (®s
);
309 fetch_ppc_registers (int tid
)
312 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
314 for (i
= 0; i
<= tdep
->ppc_fpscr_regnum
; i
++)
315 fetch_register (tid
, i
);
316 if (tdep
->ppc_mq_regnum
!= -1)
317 fetch_register (tid
, tdep
->ppc_mq_regnum
);
318 if (have_ptrace_getvrregs
)
319 if (tdep
->ppc_vr0_regnum
!= -1 && tdep
->ppc_vrsave_regnum
!= -1)
320 fetch_altivec_registers (tid
);
323 /* Fetch registers from the child process. Fetch all registers if
324 regno == -1, otherwise fetch all general registers or all floating
325 point registers depending upon the value of regno. */
327 fetch_inferior_registers (int regno
)
329 /* Overload thread id onto process id */
330 int tid
= TIDGET (inferior_ptid
);
332 /* No thread id, just use process id */
334 tid
= PIDGET (inferior_ptid
);
337 fetch_ppc_registers (tid
);
339 fetch_register (tid
, regno
);
342 /* Store one register. */
344 store_altivec_register (int tid
, int regno
)
349 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
350 int vrregsize
= DEPRECATED_REGISTER_RAW_SIZE (tdep
->ppc_vr0_regnum
);
352 ret
= ptrace (PTRACE_GETVRREGS
, tid
, 0, ®s
);
357 have_ptrace_getvrregs
= 0;
360 perror_with_name ("Unable to fetch AltiVec register");
363 /* VSCR is fetched as a 16 bytes quantity, but it is really 4 bytes
364 long on the hardware. */
365 if (regno
== (tdep
->ppc_vrsave_regnum
- 1))
366 offset
= vrregsize
- DEPRECATED_REGISTER_RAW_SIZE (tdep
->ppc_vrsave_regnum
);
368 regcache_collect (regno
,
369 regs
+ (regno
- tdep
->ppc_vr0_regnum
) * vrregsize
+ offset
);
371 ret
= ptrace (PTRACE_SETVRREGS
, tid
, 0, ®s
);
373 perror_with_name ("Unable to store AltiVec register");
377 store_register (int tid
, int regno
)
379 /* This isn't really an address. But ptrace thinks of it as one. */
380 CORE_ADDR regaddr
= ppc_register_u_addr (regno
);
381 char mess
[128]; /* For messages */
383 unsigned int offset
; /* Offset of registers within the u area. */
384 char buf
[MAX_REGISTER_SIZE
];
386 if (altivec_register_p (regno
))
388 store_altivec_register (tid
, regno
);
395 /* First collect the register value from the regcache. Be careful
396 to to convert the regcache's wordsize into ptrace's wordsize. */
397 memset (buf
, 0, sizeof buf
);
398 if ((regno
>= FP0_REGNUM
&& regno
< FP0_REGNUM
+ 32)
399 || TARGET_BYTE_ORDER
== BFD_ENDIAN_LITTLE
)
400 /* Floats are always 64-bit. Little endian registers are always
401 at the left-hand end of the register cache. */
402 regcache_raw_collect (current_regcache
, regno
, buf
);
404 /* Big-endian registers belong at the right-hand end of the
406 regcache_raw_collect (current_regcache
, regno
,
407 (buf
+ sizeof (PTRACE_XFER_TYPE
)
408 - register_size (current_gdbarch
, regno
)));
410 for (i
= 0; i
< DEPRECATED_REGISTER_RAW_SIZE (regno
); i
+= sizeof (PTRACE_XFER_TYPE
))
413 ptrace (PT_WRITE_U
, tid
, (PTRACE_ARG3_TYPE
) regaddr
,
414 *(PTRACE_XFER_TYPE
*) & buf
[i
]);
415 regaddr
+= sizeof (PTRACE_XFER_TYPE
);
418 && regno
== gdbarch_tdep (current_gdbarch
)->ppc_fpscr_regnum
)
420 /* Some older kernel versions don't allow fpscr to be written. */
426 sprintf (mess
, "writing register %s (#%d)",
427 REGISTER_NAME (regno
), regno
);
428 perror_with_name (mess
);
434 fill_vrregset (gdb_vrregset_t
*vrregsetp
)
437 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
438 int num_of_vrregs
= tdep
->ppc_vrsave_regnum
- tdep
->ppc_vr0_regnum
+ 1;
439 int vrregsize
= DEPRECATED_REGISTER_RAW_SIZE (tdep
->ppc_vr0_regnum
);
440 int offset
= vrregsize
- DEPRECATED_REGISTER_RAW_SIZE (tdep
->ppc_vrsave_regnum
);
442 for (i
= 0; i
< num_of_vrregs
; i
++)
444 /* The last 2 registers of this set are only 32 bit long, not
445 128, but only VSCR is fetched as a 16 bytes quantity. */
446 if (i
== (num_of_vrregs
- 2))
447 regcache_collect (tdep
->ppc_vr0_regnum
+ i
,
448 *vrregsetp
+ i
* vrregsize
+ offset
);
450 regcache_collect (tdep
->ppc_vr0_regnum
+ i
, *vrregsetp
+ i
* vrregsize
);
455 store_altivec_registers (int tid
)
460 ret
= ptrace (PTRACE_GETVRREGS
, tid
, 0, ®s
);
465 have_ptrace_getvrregs
= 0;
468 perror_with_name ("Couldn't get AltiVec registers");
471 fill_vrregset (®s
);
473 if (ptrace (PTRACE_SETVRREGS
, tid
, 0, ®s
) < 0)
474 perror_with_name ("Couldn't write AltiVec registers");
478 store_ppc_registers (int tid
)
481 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
483 for (i
= 0; i
<= tdep
->ppc_fpscr_regnum
; i
++)
484 store_register (tid
, i
);
485 if (tdep
->ppc_mq_regnum
!= -1)
486 store_register (tid
, tdep
->ppc_mq_regnum
);
487 if (have_ptrace_getvrregs
)
488 if (tdep
->ppc_vr0_regnum
!= -1 && tdep
->ppc_vrsave_regnum
!= -1)
489 store_altivec_registers (tid
);
493 store_inferior_registers (int regno
)
495 /* Overload thread id onto process id */
496 int tid
= TIDGET (inferior_ptid
);
498 /* No thread id, just use process id */
500 tid
= PIDGET (inferior_ptid
);
503 store_register (tid
, regno
);
505 store_ppc_registers (tid
);
509 supply_gregset (gdb_gregset_t
*gregsetp
)
511 /* NOTE: cagney/2003-11-25: This is the word size used by the ptrace
512 interface, and not the wordsize of the program's ABI. */
513 int wordsize
= sizeof (PTRACE_XFER_TYPE
);
514 ppc_linux_supply_gregset (current_regcache
, -1, gregsetp
,
515 sizeof (gdb_gregset_t
), wordsize
);
519 right_fill_reg (int regnum
, void *reg
)
521 /* NOTE: cagney/2003-11-25: This is the word size used by the ptrace
522 interface, and not the wordsize of the program's ABI. */
523 int wordsize
= sizeof (PTRACE_XFER_TYPE
);
524 /* Right fill the register. */
525 regcache_raw_collect (current_regcache
, regnum
,
528 - register_size (current_gdbarch
, regnum
)));
532 fill_gregset (gdb_gregset_t
*gregsetp
, int regno
)
535 elf_greg_t
*regp
= (elf_greg_t
*) gregsetp
;
536 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
537 const int elf_ngreg
= 48;
540 /* Start with zeros. */
541 memset (regp
, 0, elf_ngreg
* sizeof (*regp
));
543 for (regi
= 0; regi
< 32; regi
++)
545 if ((regno
== -1) || regno
== regi
)
546 right_fill_reg (regi
, (regp
+ PT_R0
+ regi
));
549 if ((regno
== -1) || regno
== PC_REGNUM
)
550 right_fill_reg (PC_REGNUM
, regp
+ PT_NIP
);
551 if ((regno
== -1) || regno
== tdep
->ppc_lr_regnum
)
552 right_fill_reg (tdep
->ppc_lr_regnum
, regp
+ PT_LNK
);
553 if ((regno
== -1) || regno
== tdep
->ppc_cr_regnum
)
554 regcache_collect (tdep
->ppc_cr_regnum
, regp
+ PT_CCR
);
555 if ((regno
== -1) || regno
== tdep
->ppc_xer_regnum
)
556 regcache_collect (tdep
->ppc_xer_regnum
, regp
+ PT_XER
);
557 if ((regno
== -1) || regno
== tdep
->ppc_ctr_regnum
)
558 right_fill_reg (tdep
->ppc_ctr_regnum
, regp
+ PT_CTR
);
560 if (((regno
== -1) || regno
== tdep
->ppc_mq_regnum
)
561 && (tdep
->ppc_mq_regnum
!= -1))
562 right_fill_reg (tdep
->ppc_mq_regnum
, regp
+ PT_MQ
);
564 if ((regno
== -1) || regno
== tdep
->ppc_ps_regnum
)
565 right_fill_reg (tdep
->ppc_ps_regnum
, regp
+ PT_MSR
);
569 supply_fpregset (gdb_fpregset_t
* fpregsetp
)
571 ppc_linux_supply_fpregset (NULL
, current_regcache
, -1, fpregsetp
,
572 sizeof (gdb_fpregset_t
));
575 /* Given a pointer to a floating point register set in /proc format
576 (fpregset_t *), update the register specified by REGNO from gdb's
577 idea of the current floating point register set. If REGNO is -1,
580 fill_fpregset (gdb_fpregset_t
*fpregsetp
, int regno
)
583 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
584 bfd_byte
*fpp
= (void *) fpregsetp
;
586 for (regi
= 0; regi
< 32; regi
++)
588 if ((regno
== -1) || (regno
== FP0_REGNUM
+ regi
))
589 regcache_collect (FP0_REGNUM
+ regi
, fpp
+ 8 * regi
);
591 if ((regno
== -1) || regno
== tdep
->ppc_fpscr_regnum
)
592 right_fill_reg (tdep
->ppc_fpscr_regnum
, (fpp
+ 8 * 32));
This page took 0.05949 seconds and 4 git commands to generate.