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
&& regno
<= tdep
->ppc_gplast_regnum
)
136 u_addr
= ((PT_R0
+ regno
) * wordsize
);
138 /* Floating point regs: eight bytes each in both 32- and 64-bit
139 ptrace interfaces. Thus, two slots each in 32-bit interface, one
140 slot each in 64-bit interface. */
141 if (regno
>= FP0_REGNUM
&& regno
<= FPLAST_REGNUM
)
142 u_addr
= (PT_FPR0
* wordsize
) + ((regno
- FP0_REGNUM
) * 8);
144 /* UISA special purpose registers: 1 slot each */
145 if (regno
== PC_REGNUM
)
146 u_addr
= PT_NIP
* wordsize
;
147 if (regno
== tdep
->ppc_lr_regnum
)
148 u_addr
= PT_LNK
* wordsize
;
149 if (regno
== tdep
->ppc_cr_regnum
)
150 u_addr
= PT_CCR
* wordsize
;
151 if (regno
== tdep
->ppc_xer_regnum
)
152 u_addr
= PT_XER
* wordsize
;
153 if (regno
== tdep
->ppc_ctr_regnum
)
154 u_addr
= PT_CTR
* wordsize
;
156 if (regno
== tdep
->ppc_mq_regnum
)
157 u_addr
= PT_MQ
* wordsize
;
159 if (regno
== tdep
->ppc_ps_regnum
)
160 u_addr
= PT_MSR
* wordsize
;
161 if (regno
== tdep
->ppc_fpscr_regnum
)
162 u_addr
= PT_FPSCR
* wordsize
;
167 /* The Linux kernel ptrace interface for AltiVec registers uses the
168 registers set mechanism, as opposed to the interface for all the
169 other registers, that stores/fetches each register individually. */
171 fetch_altivec_register (int tid
, int regno
)
176 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
177 int vrregsize
= DEPRECATED_REGISTER_RAW_SIZE (tdep
->ppc_vr0_regnum
);
179 ret
= ptrace (PTRACE_GETVRREGS
, tid
, 0, ®s
);
184 have_ptrace_getvrregs
= 0;
187 perror_with_name ("Unable to fetch AltiVec register");
190 /* VSCR is fetched as a 16 bytes quantity, but it is really 4 bytes
191 long on the hardware. We deal only with the lower 4 bytes of the
192 vector. VRSAVE is at the end of the array in a 4 bytes slot, so
193 there is no need to define an offset for it. */
194 if (regno
== (tdep
->ppc_vrsave_regnum
- 1))
195 offset
= vrregsize
- DEPRECATED_REGISTER_RAW_SIZE (tdep
->ppc_vrsave_regnum
);
197 supply_register (regno
,
198 regs
+ (regno
- tdep
->ppc_vr0_regnum
) * vrregsize
+ offset
);
202 fetch_register (int tid
, int regno
)
204 /* This isn't really an address. But ptrace thinks of it as one. */
205 char mess
[128]; /* For messages */
207 unsigned int offset
; /* Offset of registers within the u area. */
208 char buf
[MAX_REGISTER_SIZE
];
209 CORE_ADDR regaddr
= ppc_register_u_addr (regno
);
211 if (altivec_register_p (regno
))
213 /* If this is the first time through, or if it is not the first
214 time through, and we have comfirmed that there is kernel
215 support for such a ptrace request, then go and fetch the
217 if (have_ptrace_getvrregs
)
219 fetch_altivec_register (tid
, regno
);
222 /* If we have discovered that there is no ptrace support for
223 AltiVec registers, fall through and return zeroes, because
224 regaddr will be -1 in this case. */
229 memset (buf
, '\0', DEPRECATED_REGISTER_RAW_SIZE (regno
)); /* Supply zeroes */
230 supply_register (regno
, buf
);
234 /* Read the raw register using PTRACE_XFER_TYPE sized chunks. On a
235 32-bit platform, 64-bit floating-point registers will require two
237 for (i
= 0; i
< DEPRECATED_REGISTER_RAW_SIZE (regno
); i
+= sizeof (PTRACE_XFER_TYPE
))
240 *(PTRACE_XFER_TYPE
*) & buf
[i
] = ptrace (PT_READ_U
, tid
,
241 (PTRACE_ARG3_TYPE
) regaddr
, 0);
242 regaddr
+= sizeof (PTRACE_XFER_TYPE
);
245 sprintf (mess
, "reading register %s (#%d)",
246 REGISTER_NAME (regno
), regno
);
247 perror_with_name (mess
);
251 /* Now supply the register. Be careful to map between ptrace's and
252 the current_regcache's idea of the current wordsize. */
253 if ((regno
>= FP0_REGNUM
&& regno
< FP0_REGNUM
+32)
254 || gdbarch_byte_order (current_gdbarch
) == BFD_ENDIAN_LITTLE
)
255 /* FPs are always 64 bits. Little endian values are always found
256 at the left-hand end of the register. */
257 regcache_raw_supply (current_regcache
, regno
, buf
);
259 /* Big endian register, need to fetch the right-hand end. */
260 regcache_raw_supply (current_regcache
, regno
,
261 (buf
+ sizeof (PTRACE_XFER_TYPE
)
262 - register_size (current_gdbarch
, regno
)));
266 supply_vrregset (gdb_vrregset_t
*vrregsetp
)
269 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
270 int num_of_vrregs
= tdep
->ppc_vrsave_regnum
- tdep
->ppc_vr0_regnum
+ 1;
271 int vrregsize
= DEPRECATED_REGISTER_RAW_SIZE (tdep
->ppc_vr0_regnum
);
272 int offset
= vrregsize
- DEPRECATED_REGISTER_RAW_SIZE (tdep
->ppc_vrsave_regnum
);
274 for (i
= 0; i
< num_of_vrregs
; i
++)
276 /* The last 2 registers of this set are only 32 bit long, not
277 128. However an offset is necessary only for VSCR because it
278 occupies a whole vector, while VRSAVE occupies a full 4 bytes
280 if (i
== (num_of_vrregs
- 2))
281 supply_register (tdep
->ppc_vr0_regnum
+ i
,
282 *vrregsetp
+ i
* vrregsize
+ offset
);
284 supply_register (tdep
->ppc_vr0_regnum
+ i
, *vrregsetp
+ i
* vrregsize
);
289 fetch_altivec_registers (int tid
)
294 ret
= ptrace (PTRACE_GETVRREGS
, tid
, 0, ®s
);
299 have_ptrace_getvrregs
= 0;
302 perror_with_name ("Unable to fetch AltiVec registers");
304 supply_vrregset (®s
);
308 fetch_ppc_registers (int tid
)
311 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
313 for (i
= 0; i
<= tdep
->ppc_fpscr_regnum
; i
++)
314 fetch_register (tid
, i
);
315 if (tdep
->ppc_mq_regnum
!= -1)
316 fetch_register (tid
, tdep
->ppc_mq_regnum
);
317 if (have_ptrace_getvrregs
)
318 if (tdep
->ppc_vr0_regnum
!= -1 && tdep
->ppc_vrsave_regnum
!= -1)
319 fetch_altivec_registers (tid
);
322 /* Fetch registers from the child process. Fetch all registers if
323 regno == -1, otherwise fetch all general registers or all floating
324 point registers depending upon the value of regno. */
326 fetch_inferior_registers (int regno
)
328 /* Overload thread id onto process id */
329 int tid
= TIDGET (inferior_ptid
);
331 /* No thread id, just use process id */
333 tid
= PIDGET (inferior_ptid
);
336 fetch_ppc_registers (tid
);
338 fetch_register (tid
, regno
);
341 /* Store one register. */
343 store_altivec_register (int tid
, int regno
)
348 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
349 int vrregsize
= DEPRECATED_REGISTER_RAW_SIZE (tdep
->ppc_vr0_regnum
);
351 ret
= ptrace (PTRACE_GETVRREGS
, tid
, 0, ®s
);
356 have_ptrace_getvrregs
= 0;
359 perror_with_name ("Unable to fetch AltiVec register");
362 /* VSCR is fetched as a 16 bytes quantity, but it is really 4 bytes
363 long on the hardware. */
364 if (regno
== (tdep
->ppc_vrsave_regnum
- 1))
365 offset
= vrregsize
- DEPRECATED_REGISTER_RAW_SIZE (tdep
->ppc_vrsave_regnum
);
367 regcache_collect (regno
,
368 regs
+ (regno
- tdep
->ppc_vr0_regnum
) * vrregsize
+ offset
);
370 ret
= ptrace (PTRACE_SETVRREGS
, tid
, 0, ®s
);
372 perror_with_name ("Unable to store AltiVec register");
376 store_register (int tid
, int regno
)
378 /* This isn't really an address. But ptrace thinks of it as one. */
379 CORE_ADDR regaddr
= ppc_register_u_addr (regno
);
380 char mess
[128]; /* For messages */
382 unsigned int offset
; /* Offset of registers within the u area. */
383 char buf
[MAX_REGISTER_SIZE
];
385 if (altivec_register_p (regno
))
387 store_altivec_register (tid
, regno
);
394 /* First collect the register value from the regcache. Be careful
395 to to convert the regcache's wordsize into ptrace's wordsize. */
396 memset (buf
, 0, sizeof buf
);
397 if ((regno
>= FP0_REGNUM
&& regno
< FP0_REGNUM
+ 32)
398 || TARGET_BYTE_ORDER
== BFD_ENDIAN_LITTLE
)
399 /* Floats are always 64-bit. Little endian registers are always
400 at the left-hand end of the register cache. */
401 regcache_raw_collect (current_regcache
, regno
, buf
);
403 /* Big-endian registers belong at the right-hand end of the
405 regcache_raw_collect (current_regcache
, regno
,
406 (buf
+ sizeof (PTRACE_XFER_TYPE
)
407 - register_size (current_gdbarch
, regno
)));
409 for (i
= 0; i
< DEPRECATED_REGISTER_RAW_SIZE (regno
); i
+= sizeof (PTRACE_XFER_TYPE
))
412 ptrace (PT_WRITE_U
, tid
, (PTRACE_ARG3_TYPE
) regaddr
,
413 *(PTRACE_XFER_TYPE
*) & buf
[i
]);
414 regaddr
+= sizeof (PTRACE_XFER_TYPE
);
417 && regno
== gdbarch_tdep (current_gdbarch
)->ppc_fpscr_regnum
)
419 /* Some older kernel versions don't allow fpscr to be written. */
425 sprintf (mess
, "writing register %s (#%d)",
426 REGISTER_NAME (regno
), regno
);
427 perror_with_name (mess
);
433 fill_vrregset (gdb_vrregset_t
*vrregsetp
)
436 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
437 int num_of_vrregs
= tdep
->ppc_vrsave_regnum
- tdep
->ppc_vr0_regnum
+ 1;
438 int vrregsize
= DEPRECATED_REGISTER_RAW_SIZE (tdep
->ppc_vr0_regnum
);
439 int offset
= vrregsize
- DEPRECATED_REGISTER_RAW_SIZE (tdep
->ppc_vrsave_regnum
);
441 for (i
= 0; i
< num_of_vrregs
; i
++)
443 /* The last 2 registers of this set are only 32 bit long, not
444 128, but only VSCR is fetched as a 16 bytes quantity. */
445 if (i
== (num_of_vrregs
- 2))
446 regcache_collect (tdep
->ppc_vr0_regnum
+ i
,
447 *vrregsetp
+ i
* vrregsize
+ offset
);
449 regcache_collect (tdep
->ppc_vr0_regnum
+ i
, *vrregsetp
+ i
* vrregsize
);
454 store_altivec_registers (int tid
)
459 ret
= ptrace (PTRACE_GETVRREGS
, tid
, 0, ®s
);
464 have_ptrace_getvrregs
= 0;
467 perror_with_name ("Couldn't get AltiVec registers");
470 fill_vrregset (®s
);
472 if (ptrace (PTRACE_SETVRREGS
, tid
, 0, ®s
) < 0)
473 perror_with_name ("Couldn't write AltiVec registers");
477 store_ppc_registers (int tid
)
480 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
482 for (i
= 0; i
<= tdep
->ppc_fpscr_regnum
; i
++)
483 store_register (tid
, i
);
484 if (tdep
->ppc_mq_regnum
!= -1)
485 store_register (tid
, tdep
->ppc_mq_regnum
);
486 if (have_ptrace_getvrregs
)
487 if (tdep
->ppc_vr0_regnum
!= -1 && tdep
->ppc_vrsave_regnum
!= -1)
488 store_altivec_registers (tid
);
492 store_inferior_registers (int regno
)
494 /* Overload thread id onto process id */
495 int tid
= TIDGET (inferior_ptid
);
497 /* No thread id, just use process id */
499 tid
= PIDGET (inferior_ptid
);
502 store_register (tid
, regno
);
504 store_ppc_registers (tid
);
508 supply_gregset (gdb_gregset_t
*gregsetp
)
510 /* NOTE: cagney/2003-11-25: This is the word size used by the ptrace
511 interface, and not the wordsize of the program's ABI. */
512 int wordsize
= sizeof (PTRACE_XFER_TYPE
);
513 ppc_linux_supply_gregset (current_regcache
, -1, gregsetp
,
514 sizeof (gdb_gregset_t
), wordsize
);
518 right_fill_reg (int regnum
, void *reg
)
520 /* NOTE: cagney/2003-11-25: This is the word size used by the ptrace
521 interface, and not the wordsize of the program's ABI. */
522 int wordsize
= sizeof (PTRACE_XFER_TYPE
);
523 /* Right fill the register. */
524 regcache_raw_collect (current_regcache
, regnum
,
527 - register_size (current_gdbarch
, regnum
)));
531 fill_gregset (gdb_gregset_t
*gregsetp
, int regno
)
534 elf_greg_t
*regp
= (elf_greg_t
*) gregsetp
;
535 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
536 const int elf_ngreg
= 48;
539 /* Start with zeros. */
540 memset (regp
, 0, elf_ngreg
* sizeof (*regp
));
542 for (regi
= 0; regi
< 32; regi
++)
544 if ((regno
== -1) || regno
== regi
)
545 right_fill_reg (regi
, (regp
+ PT_R0
+ regi
));
548 if ((regno
== -1) || regno
== PC_REGNUM
)
549 right_fill_reg (PC_REGNUM
, regp
+ PT_NIP
);
550 if ((regno
== -1) || regno
== tdep
->ppc_lr_regnum
)
551 right_fill_reg (tdep
->ppc_lr_regnum
, regp
+ PT_LNK
);
552 if ((regno
== -1) || regno
== tdep
->ppc_cr_regnum
)
553 regcache_collect (tdep
->ppc_cr_regnum
, regp
+ PT_CCR
);
554 if ((regno
== -1) || regno
== tdep
->ppc_xer_regnum
)
555 regcache_collect (tdep
->ppc_xer_regnum
, regp
+ PT_XER
);
556 if ((regno
== -1) || regno
== tdep
->ppc_ctr_regnum
)
557 right_fill_reg (tdep
->ppc_ctr_regnum
, regp
+ PT_CTR
);
559 if (((regno
== -1) || regno
== tdep
->ppc_mq_regnum
)
560 && (tdep
->ppc_mq_regnum
!= -1))
561 right_fill_reg (tdep
->ppc_mq_regnum
, regp
+ PT_MQ
);
563 if ((regno
== -1) || regno
== tdep
->ppc_ps_regnum
)
564 right_fill_reg (tdep
->ppc_ps_regnum
, regp
+ PT_MSR
);
568 supply_fpregset (gdb_fpregset_t
* fpregsetp
)
570 ppc_linux_supply_fpregset (NULL
, current_regcache
, -1, fpregsetp
,
571 sizeof (gdb_fpregset_t
));
574 /* Given a pointer to a floating point register set in /proc format
575 (fpregset_t *), update the register specified by REGNO from gdb's
576 idea of the current floating point register set. If REGNO is -1,
579 fill_fpregset (gdb_fpregset_t
*fpregsetp
, int regno
)
582 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
583 bfd_byte
*fpp
= (void *) fpregsetp
;
585 for (regi
= 0; regi
< 32; regi
++)
587 if ((regno
== -1) || (regno
== FP0_REGNUM
+ regi
))
588 regcache_collect (FP0_REGNUM
+ regi
, fpp
+ 8 * regi
);
590 if ((regno
== -1) || regno
== tdep
->ppc_fpscr_regnum
)
591 right_fill_reg (tdep
->ppc_fpscr_regnum
, (fpp
+ 8 * 32));
This page took 0.052419 seconds and 4 git commands to generate.