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
>= tdep
->ppc_fp0_regnum
143 && regno
< tdep
->ppc_fp0_regnum
+ ppc_num_fprs
)
144 u_addr
= (PT_FPR0
* wordsize
) + ((regno
- tdep
->ppc_fp0_regnum
) * 8);
146 /* UISA special purpose registers: 1 slot each */
147 if (regno
== PC_REGNUM
)
148 u_addr
= PT_NIP
* wordsize
;
149 if (regno
== tdep
->ppc_lr_regnum
)
150 u_addr
= PT_LNK
* wordsize
;
151 if (regno
== tdep
->ppc_cr_regnum
)
152 u_addr
= PT_CCR
* wordsize
;
153 if (regno
== tdep
->ppc_xer_regnum
)
154 u_addr
= PT_XER
* wordsize
;
155 if (regno
== tdep
->ppc_ctr_regnum
)
156 u_addr
= PT_CTR
* wordsize
;
158 if (regno
== tdep
->ppc_mq_regnum
)
159 u_addr
= PT_MQ
* wordsize
;
161 if (regno
== tdep
->ppc_ps_regnum
)
162 u_addr
= PT_MSR
* wordsize
;
163 if (regno
== tdep
->ppc_fpscr_regnum
)
164 u_addr
= PT_FPSCR
* wordsize
;
169 /* The Linux kernel ptrace interface for AltiVec registers uses the
170 registers set mechanism, as opposed to the interface for all the
171 other registers, that stores/fetches each register individually. */
173 fetch_altivec_register (int tid
, int regno
)
178 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
179 int vrregsize
= DEPRECATED_REGISTER_RAW_SIZE (tdep
->ppc_vr0_regnum
);
181 ret
= ptrace (PTRACE_GETVRREGS
, tid
, 0, ®s
);
186 have_ptrace_getvrregs
= 0;
189 perror_with_name ("Unable to fetch AltiVec register");
192 /* VSCR is fetched as a 16 bytes quantity, but it is really 4 bytes
193 long on the hardware. We deal only with the lower 4 bytes of the
194 vector. VRSAVE is at the end of the array in a 4 bytes slot, so
195 there is no need to define an offset for it. */
196 if (regno
== (tdep
->ppc_vrsave_regnum
- 1))
197 offset
= vrregsize
- DEPRECATED_REGISTER_RAW_SIZE (tdep
->ppc_vrsave_regnum
);
199 supply_register (regno
,
200 regs
+ (regno
- tdep
->ppc_vr0_regnum
) * vrregsize
+ offset
);
204 fetch_register (int tid
, int regno
)
206 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
207 /* This isn't really an address. But ptrace thinks of it as one. */
208 char mess
[128]; /* For messages */
210 unsigned int offset
; /* Offset of registers within the u area. */
211 char buf
[MAX_REGISTER_SIZE
];
212 CORE_ADDR regaddr
= ppc_register_u_addr (regno
);
214 if (altivec_register_p (regno
))
216 /* If this is the first time through, or if it is not the first
217 time through, and we have comfirmed that there is kernel
218 support for such a ptrace request, then go and fetch the
220 if (have_ptrace_getvrregs
)
222 fetch_altivec_register (tid
, regno
);
225 /* If we have discovered that there is no ptrace support for
226 AltiVec registers, fall through and return zeroes, because
227 regaddr will be -1 in this case. */
232 memset (buf
, '\0', DEPRECATED_REGISTER_RAW_SIZE (regno
)); /* Supply zeroes */
233 supply_register (regno
, buf
);
237 /* Read the raw register using PTRACE_XFER_TYPE sized chunks. On a
238 32-bit platform, 64-bit floating-point registers will require two
240 for (i
= 0; i
< DEPRECATED_REGISTER_RAW_SIZE (regno
); i
+= sizeof (PTRACE_XFER_TYPE
))
243 *(PTRACE_XFER_TYPE
*) & buf
[i
] = ptrace (PT_READ_U
, tid
,
244 (PTRACE_ARG3_TYPE
) regaddr
, 0);
245 regaddr
+= sizeof (PTRACE_XFER_TYPE
);
248 sprintf (mess
, "reading register %s (#%d)",
249 REGISTER_NAME (regno
), regno
);
250 perror_with_name (mess
);
254 /* Now supply the register. Be careful to map between ptrace's and
255 the current_regcache's idea of the current wordsize. */
256 if ((regno
>= tdep
->ppc_fp0_regnum
257 && regno
< tdep
->ppc_fp0_regnum
+ ppc_num_fprs
)
258 || gdbarch_byte_order (current_gdbarch
) == BFD_ENDIAN_LITTLE
)
259 /* FPs are always 64 bits. Little endian values are always found
260 at the left-hand end of the register. */
261 regcache_raw_supply (current_regcache
, regno
, buf
);
263 /* Big endian register, need to fetch the right-hand end. */
264 regcache_raw_supply (current_regcache
, regno
,
265 (buf
+ sizeof (PTRACE_XFER_TYPE
)
266 - register_size (current_gdbarch
, regno
)));
270 supply_vrregset (gdb_vrregset_t
*vrregsetp
)
273 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
274 int num_of_vrregs
= tdep
->ppc_vrsave_regnum
- tdep
->ppc_vr0_regnum
+ 1;
275 int vrregsize
= DEPRECATED_REGISTER_RAW_SIZE (tdep
->ppc_vr0_regnum
);
276 int offset
= vrregsize
- DEPRECATED_REGISTER_RAW_SIZE (tdep
->ppc_vrsave_regnum
);
278 for (i
= 0; i
< num_of_vrregs
; i
++)
280 /* The last 2 registers of this set are only 32 bit long, not
281 128. However an offset is necessary only for VSCR because it
282 occupies a whole vector, while VRSAVE occupies a full 4 bytes
284 if (i
== (num_of_vrregs
- 2))
285 supply_register (tdep
->ppc_vr0_regnum
+ i
,
286 *vrregsetp
+ i
* vrregsize
+ offset
);
288 supply_register (tdep
->ppc_vr0_regnum
+ i
, *vrregsetp
+ i
* vrregsize
);
293 fetch_altivec_registers (int tid
)
298 ret
= ptrace (PTRACE_GETVRREGS
, tid
, 0, ®s
);
303 have_ptrace_getvrregs
= 0;
306 perror_with_name ("Unable to fetch AltiVec registers");
308 supply_vrregset (®s
);
312 fetch_ppc_registers (int tid
)
315 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
317 for (i
= 0; i
< ppc_num_gprs
; i
++)
318 fetch_register (tid
, tdep
->ppc_gp0_regnum
+ i
);
319 if (tdep
->ppc_fp0_regnum
>= 0)
320 for (i
= 0; i
< ppc_num_fprs
; i
++)
321 fetch_register (tid
, tdep
->ppc_fp0_regnum
+ i
);
322 fetch_register (tid
, PC_REGNUM
);
323 if (tdep
->ppc_ps_regnum
!= -1)
324 fetch_register (tid
, tdep
->ppc_ps_regnum
);
325 if (tdep
->ppc_cr_regnum
!= -1)
326 fetch_register (tid
, tdep
->ppc_cr_regnum
);
327 if (tdep
->ppc_lr_regnum
!= -1)
328 fetch_register (tid
, tdep
->ppc_lr_regnum
);
329 if (tdep
->ppc_ctr_regnum
!= -1)
330 fetch_register (tid
, tdep
->ppc_ctr_regnum
);
331 if (tdep
->ppc_xer_regnum
!= -1)
332 fetch_register (tid
, tdep
->ppc_xer_regnum
);
333 if (tdep
->ppc_mq_regnum
!= -1)
334 fetch_register (tid
, tdep
->ppc_mq_regnum
);
335 if (tdep
->ppc_fpscr_regnum
!= -1)
336 fetch_register (tid
, tdep
->ppc_fpscr_regnum
);
337 if (have_ptrace_getvrregs
)
338 if (tdep
->ppc_vr0_regnum
!= -1 && tdep
->ppc_vrsave_regnum
!= -1)
339 fetch_altivec_registers (tid
);
342 /* Fetch registers from the child process. Fetch all registers if
343 regno == -1, otherwise fetch all general registers or all floating
344 point registers depending upon the value of regno. */
346 fetch_inferior_registers (int regno
)
348 /* Overload thread id onto process id */
349 int tid
= TIDGET (inferior_ptid
);
351 /* No thread id, just use process id */
353 tid
= PIDGET (inferior_ptid
);
356 fetch_ppc_registers (tid
);
358 fetch_register (tid
, regno
);
361 /* Store one register. */
363 store_altivec_register (int tid
, int regno
)
368 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
369 int vrregsize
= DEPRECATED_REGISTER_RAW_SIZE (tdep
->ppc_vr0_regnum
);
371 ret
= ptrace (PTRACE_GETVRREGS
, tid
, 0, ®s
);
376 have_ptrace_getvrregs
= 0;
379 perror_with_name ("Unable to fetch AltiVec register");
382 /* VSCR is fetched as a 16 bytes quantity, but it is really 4 bytes
383 long on the hardware. */
384 if (regno
== (tdep
->ppc_vrsave_regnum
- 1))
385 offset
= vrregsize
- DEPRECATED_REGISTER_RAW_SIZE (tdep
->ppc_vrsave_regnum
);
387 regcache_collect (regno
,
388 regs
+ (regno
- tdep
->ppc_vr0_regnum
) * vrregsize
+ offset
);
390 ret
= ptrace (PTRACE_SETVRREGS
, tid
, 0, ®s
);
392 perror_with_name ("Unable to store AltiVec register");
396 store_register (int tid
, int regno
)
398 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
399 /* This isn't really an address. But ptrace thinks of it as one. */
400 CORE_ADDR regaddr
= ppc_register_u_addr (regno
);
401 char mess
[128]; /* For messages */
403 unsigned int offset
; /* Offset of registers within the u area. */
404 char buf
[MAX_REGISTER_SIZE
];
406 if (altivec_register_p (regno
))
408 store_altivec_register (tid
, regno
);
415 /* First collect the register value from the regcache. Be careful
416 to to convert the regcache's wordsize into ptrace's wordsize. */
417 memset (buf
, 0, sizeof buf
);
418 if ((regno
>= tdep
->ppc_fp0_regnum
419 && regno
< tdep
->ppc_fp0_regnum
+ ppc_num_fprs
)
420 || TARGET_BYTE_ORDER
== BFD_ENDIAN_LITTLE
)
421 /* Floats are always 64-bit. Little endian registers are always
422 at the left-hand end of the register cache. */
423 regcache_raw_collect (current_regcache
, regno
, buf
);
425 /* Big-endian registers belong at the right-hand end of the
427 regcache_raw_collect (current_regcache
, regno
,
428 (buf
+ sizeof (PTRACE_XFER_TYPE
)
429 - register_size (current_gdbarch
, regno
)));
431 for (i
= 0; i
< DEPRECATED_REGISTER_RAW_SIZE (regno
); i
+= sizeof (PTRACE_XFER_TYPE
))
434 ptrace (PT_WRITE_U
, tid
, (PTRACE_ARG3_TYPE
) regaddr
,
435 *(PTRACE_XFER_TYPE
*) & buf
[i
]);
436 regaddr
+= sizeof (PTRACE_XFER_TYPE
);
439 && regno
== gdbarch_tdep (current_gdbarch
)->ppc_fpscr_regnum
)
441 /* Some older kernel versions don't allow fpscr to be written. */
447 sprintf (mess
, "writing register %s (#%d)",
448 REGISTER_NAME (regno
), regno
);
449 perror_with_name (mess
);
455 fill_vrregset (gdb_vrregset_t
*vrregsetp
)
458 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
459 int num_of_vrregs
= tdep
->ppc_vrsave_regnum
- tdep
->ppc_vr0_regnum
+ 1;
460 int vrregsize
= DEPRECATED_REGISTER_RAW_SIZE (tdep
->ppc_vr0_regnum
);
461 int offset
= vrregsize
- DEPRECATED_REGISTER_RAW_SIZE (tdep
->ppc_vrsave_regnum
);
463 for (i
= 0; i
< num_of_vrregs
; i
++)
465 /* The last 2 registers of this set are only 32 bit long, not
466 128, but only VSCR is fetched as a 16 bytes quantity. */
467 if (i
== (num_of_vrregs
- 2))
468 regcache_collect (tdep
->ppc_vr0_regnum
+ i
,
469 *vrregsetp
+ i
* vrregsize
+ offset
);
471 regcache_collect (tdep
->ppc_vr0_regnum
+ i
, *vrregsetp
+ i
* vrregsize
);
476 store_altivec_registers (int tid
)
481 ret
= ptrace (PTRACE_GETVRREGS
, tid
, 0, ®s
);
486 have_ptrace_getvrregs
= 0;
489 perror_with_name ("Couldn't get AltiVec registers");
492 fill_vrregset (®s
);
494 if (ptrace (PTRACE_SETVRREGS
, tid
, 0, ®s
) < 0)
495 perror_with_name ("Couldn't write AltiVec registers");
499 store_ppc_registers (int tid
)
502 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
504 for (i
= 0; i
< ppc_num_gprs
; i
++)
505 store_register (tid
, tdep
->ppc_gp0_regnum
+ i
);
506 if (tdep
->ppc_fp0_regnum
>= 0)
507 for (i
= 0; i
< ppc_num_fprs
; i
++)
508 store_register (tid
, tdep
->ppc_fp0_regnum
+ i
);
509 store_register (tid
, PC_REGNUM
);
510 if (tdep
->ppc_ps_regnum
!= -1)
511 store_register (tid
, tdep
->ppc_ps_regnum
);
512 if (tdep
->ppc_cr_regnum
!= -1)
513 store_register (tid
, tdep
->ppc_cr_regnum
);
514 if (tdep
->ppc_lr_regnum
!= -1)
515 store_register (tid
, tdep
->ppc_lr_regnum
);
516 if (tdep
->ppc_ctr_regnum
!= -1)
517 store_register (tid
, tdep
->ppc_ctr_regnum
);
518 if (tdep
->ppc_xer_regnum
!= -1)
519 store_register (tid
, tdep
->ppc_xer_regnum
);
520 if (tdep
->ppc_mq_regnum
!= -1)
521 store_register (tid
, tdep
->ppc_mq_regnum
);
522 if (tdep
->ppc_fpscr_regnum
!= -1)
523 store_register (tid
, tdep
->ppc_fpscr_regnum
);
524 if (have_ptrace_getvrregs
)
525 if (tdep
->ppc_vr0_regnum
!= -1 && tdep
->ppc_vrsave_regnum
!= -1)
526 store_altivec_registers (tid
);
530 store_inferior_registers (int regno
)
532 /* Overload thread id onto process id */
533 int tid
= TIDGET (inferior_ptid
);
535 /* No thread id, just use process id */
537 tid
= PIDGET (inferior_ptid
);
540 store_register (tid
, regno
);
542 store_ppc_registers (tid
);
546 supply_gregset (gdb_gregset_t
*gregsetp
)
548 /* NOTE: cagney/2003-11-25: This is the word size used by the ptrace
549 interface, and not the wordsize of the program's ABI. */
550 int wordsize
= sizeof (PTRACE_XFER_TYPE
);
551 ppc_linux_supply_gregset (current_regcache
, -1, gregsetp
,
552 sizeof (gdb_gregset_t
), wordsize
);
556 right_fill_reg (int regnum
, void *reg
)
558 /* NOTE: cagney/2003-11-25: This is the word size used by the ptrace
559 interface, and not the wordsize of the program's ABI. */
560 int wordsize
= sizeof (PTRACE_XFER_TYPE
);
561 /* Right fill the register. */
562 regcache_raw_collect (current_regcache
, regnum
,
565 - register_size (current_gdbarch
, regnum
)));
569 fill_gregset (gdb_gregset_t
*gregsetp
, int regno
)
572 elf_greg_t
*regp
= (elf_greg_t
*) gregsetp
;
573 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
574 const int elf_ngreg
= 48;
577 /* Start with zeros. */
578 memset (regp
, 0, elf_ngreg
* sizeof (*regp
));
580 for (regi
= 0; regi
< 32; regi
++)
582 if ((regno
== -1) || regno
== regi
)
583 right_fill_reg (regi
, (regp
+ PT_R0
+ regi
));
586 if ((regno
== -1) || regno
== PC_REGNUM
)
587 right_fill_reg (PC_REGNUM
, regp
+ PT_NIP
);
588 if ((regno
== -1) || regno
== tdep
->ppc_lr_regnum
)
589 right_fill_reg (tdep
->ppc_lr_regnum
, regp
+ PT_LNK
);
590 if ((regno
== -1) || regno
== tdep
->ppc_cr_regnum
)
591 regcache_collect (tdep
->ppc_cr_regnum
, regp
+ PT_CCR
);
592 if ((regno
== -1) || regno
== tdep
->ppc_xer_regnum
)
593 regcache_collect (tdep
->ppc_xer_regnum
, regp
+ PT_XER
);
594 if ((regno
== -1) || regno
== tdep
->ppc_ctr_regnum
)
595 right_fill_reg (tdep
->ppc_ctr_regnum
, regp
+ PT_CTR
);
597 if (((regno
== -1) || regno
== tdep
->ppc_mq_regnum
)
598 && (tdep
->ppc_mq_regnum
!= -1))
599 right_fill_reg (tdep
->ppc_mq_regnum
, regp
+ PT_MQ
);
601 if ((regno
== -1) || regno
== tdep
->ppc_ps_regnum
)
602 right_fill_reg (tdep
->ppc_ps_regnum
, regp
+ PT_MSR
);
606 supply_fpregset (gdb_fpregset_t
* fpregsetp
)
608 ppc_linux_supply_fpregset (NULL
, current_regcache
, -1, fpregsetp
,
609 sizeof (gdb_fpregset_t
));
612 /* Given a pointer to a floating point register set in /proc format
613 (fpregset_t *), update the register specified by REGNO from gdb's
614 idea of the current floating point register set. If REGNO is -1,
617 fill_fpregset (gdb_fpregset_t
*fpregsetp
, int regno
)
620 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
621 bfd_byte
*fpp
= (void *) fpregsetp
;
623 for (regi
= 0; regi
< 32; regi
++)
625 if ((regno
== -1) || (regno
== tdep
->ppc_fp0_regnum
+ regi
))
626 regcache_collect (tdep
->ppc_fp0_regnum
+ regi
, fpp
+ 8 * regi
);
628 if ((regno
== -1) || regno
== tdep
->ppc_fpscr_regnum
)
629 right_fill_reg (tdep
->ppc_fpscr_regnum
, (fpp
+ 8 * 32));
This page took 0.04283 seconds and 5 git commands to generate.