1 /* Native support code for PPC AIX, for GDB the GNU debugger.
3 Copyright (C) 2006-2023 Free Software Foundation, Inc.
5 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
32 #include "breakpoint.h"
34 #include "rs6000-aix-tdep.h"
35 #include "xcoffread.h"
37 #include "solib-aix.h"
38 #include "target-float.h"
39 #include "gdbsupport/xml-utils.h"
40 #include "trad-frame.h"
41 #include "frame-unwind.h"
43 /* If the kernel has to deliver a signal, it pushes a sigcontext
44 structure on the stack and then calls the signal handler, passing
45 the address of the sigcontext in an argument register. Usually
46 the signal handler doesn't save this register, so we have to
47 access the sigcontext structure via an offset from the signal handler
49 The following constants were determined by experimentation on AIX 3.2.
51 sigcontext structure have the mstsave saved under the
52 sc_jmpbuf.jmp_context. STKMIN(minimum stack size) is 56 for 32-bit
53 processes, and iar offset under sc_jmpbuf.jmp_context is 40.
54 ie offsetof(struct sigcontext, sc_jmpbuf.jmp_context.iar).
55 so PC offset in this case is STKMIN+iar offset, which is 96. */
57 #define SIG_FRAME_PC_OFFSET 96
58 #define SIG_FRAME_LR_OFFSET 108
59 /* STKMIN+grp1 offset, which is 56+228=284 */
60 #define SIG_FRAME_FP_OFFSET 284
63 STKMIN64 is 112 and iar offset is 312. So 112+312=424 */
64 #define SIG_FRAME_LR_OFFSET64 424
65 /* STKMIN64+grp1 offset. 112+56=168 */
66 #define SIG_FRAME_FP_OFFSET64 168
68 /* Minimum possible text address in AIX. */
69 #define AIX_TEXT_SEGMENT_BASE 0x10000000
71 struct rs6000_aix_reg_vrreg_offset
78 static struct rs6000_aix_reg_vrreg_offset rs6000_aix_vrreg_offset
=
80 /* AltiVec registers. */
82 544, /* vscr_offset. */
83 560 /* vrsave_offset */
87 rs6000_aix_get_vrreg_offset (ppc_gdbarch_tdep
*tdep
,
88 const struct rs6000_aix_reg_vrreg_offset
*offsets
,
91 if (regnum
>= tdep
->ppc_vr0_regnum
&&
92 regnum
< tdep
->ppc_vr0_regnum
+ ppc_num_vrs
)
93 return offsets
->vr0_offset
+ (regnum
- tdep
->ppc_vr0_regnum
) * 16;
95 if (regnum
== tdep
->ppc_vrsave_regnum
- 1)
96 return offsets
->vscr_offset
;
98 if (regnum
== tdep
->ppc_vrsave_regnum
)
99 return offsets
->vrsave_offset
;
105 rs6000_aix_supply_vrregset (const struct regset
*regset
, struct regcache
*regcache
,
106 int regnum
, const void *vrregs
, size_t len
)
108 struct gdbarch
*gdbarch
= regcache
->arch ();
109 const struct rs6000_aix_reg_vrreg_offset
*offsets
;
111 ppc_gdbarch_tdep
*tdep
= gdbarch_tdep
<ppc_gdbarch_tdep
> (gdbarch
);
112 if (!(tdep
->ppc_vr0_regnum
>= 0 && tdep
->ppc_vrsave_regnum
>= 0))
115 offsets
= (const struct rs6000_aix_reg_vrreg_offset
*) regset
->regmap
;
120 for (i
= tdep
->ppc_vr0_regnum
, offset
= offsets
->vr0_offset
;
121 i
< tdep
->ppc_vr0_regnum
+ ppc_num_vrs
;
123 ppc_supply_reg (regcache
, i
, (const gdb_byte
*) vrregs
, offset
, 16);
125 ppc_supply_reg (regcache
, (tdep
->ppc_vrsave_regnum
- 1),
126 (const gdb_byte
*) vrregs
, offsets
->vscr_offset
, 4);
128 ppc_supply_reg (regcache
, tdep
->ppc_vrsave_regnum
,
129 (const gdb_byte
*) vrregs
, offsets
->vrsave_offset
, 4);
133 offset
= rs6000_aix_get_vrreg_offset (tdep
, offsets
, regnum
);
134 if (regnum
!= tdep
->ppc_vrsave_regnum
&&
135 regnum
!= tdep
->ppc_vrsave_regnum
- 1)
136 ppc_supply_reg (regcache
, regnum
, (const gdb_byte
*) vrregs
, offset
, 16);
138 ppc_supply_reg (regcache
, regnum
,
139 (const gdb_byte
*) vrregs
, offset
, 4);
144 rs6000_aix_supply_vsxregset (const struct regset
*regset
, struct regcache
*regcache
,
145 int regnum
, const void *vsxregs
, size_t len
)
147 struct gdbarch
*gdbarch
= regcache
->arch ();
148 ppc_gdbarch_tdep
*tdep
= gdbarch_tdep
<ppc_gdbarch_tdep
> (gdbarch
);
149 if (!(tdep
->ppc_vsr0_regnum
>= 0))
156 for (i
= tdep
->ppc_vsr0_upper_regnum
; i
< tdep
->ppc_vsr0_upper_regnum
157 + 32; i
++, offset
+= 8)
158 ppc_supply_reg (regcache
, i
, (const gdb_byte
*) vsxregs
, offset
, 8);
163 ppc_supply_reg (regcache
, regnum
, (const gdb_byte
*) vsxregs
, 0, 8);
167 rs6000_aix_collect_vsxregset (const struct regset
*regset
,
168 const struct regcache
*regcache
,
169 int regnum
, void *vsxregs
, size_t len
)
171 struct gdbarch
*gdbarch
= regcache
->arch ();
172 ppc_gdbarch_tdep
*tdep
= gdbarch_tdep
<ppc_gdbarch_tdep
> (gdbarch
);
173 if (!(tdep
->ppc_vsr0_regnum
>= 0))
180 for (i
= tdep
->ppc_vsr0_upper_regnum
; i
< tdep
->ppc_vsr0_upper_regnum
181 + 32; i
++, offset
+= 8)
182 ppc_collect_reg (regcache
, i
, (gdb_byte
*) vsxregs
, offset
, 8);
187 ppc_collect_reg (regcache
, regnum
, (gdb_byte
*) vsxregs
, 0, 8);
191 rs6000_aix_collect_vrregset (const struct regset
*regset
,
192 const struct regcache
*regcache
,
193 int regnum
, void *vrregs
, size_t len
)
195 struct gdbarch
*gdbarch
= regcache
->arch ();
196 const struct rs6000_aix_reg_vrreg_offset
*offsets
;
199 ppc_gdbarch_tdep
*tdep
= gdbarch_tdep
<ppc_gdbarch_tdep
> (gdbarch
);
200 if (!(tdep
->ppc_vr0_regnum
>= 0 && tdep
->ppc_vrsave_regnum
>= 0))
203 offsets
= (const struct rs6000_aix_reg_vrreg_offset
*) regset
->regmap
;
208 for (i
= tdep
->ppc_vr0_regnum
, offset
= offsets
->vr0_offset
; i
<
209 tdep
->ppc_vr0_regnum
+ ppc_num_vrs
; i
++, offset
+= 16)
210 ppc_collect_reg (regcache
, i
, (gdb_byte
*) vrregs
, offset
, 16);
212 ppc_collect_reg (regcache
, (tdep
->ppc_vrsave_regnum
- 1),
213 (gdb_byte
*) vrregs
, offsets
->vscr_offset
, 4);
215 ppc_collect_reg (regcache
, tdep
->ppc_vrsave_regnum
,
216 (gdb_byte
*) vrregs
, offsets
->vrsave_offset
, 4);
221 offset
= rs6000_aix_get_vrreg_offset (tdep
, offsets
, regnum
);
222 if (regnum
!= tdep
->ppc_vrsave_regnum
223 && regnum
!= tdep
->ppc_vrsave_regnum
- 1)
224 ppc_collect_reg (regcache
, regnum
, (gdb_byte
*) vrregs
, offset
, 16);
226 ppc_collect_reg (regcache
, regnum
,
227 (gdb_byte
*) vrregs
, offset
, 4);
230 static const struct regset rs6000_aix_vrregset
= {
231 &rs6000_aix_vrreg_offset
,
232 rs6000_aix_supply_vrregset
,
233 rs6000_aix_collect_vrregset
236 static const struct regset rs6000_aix_vsxregset
= {
237 &rs6000_aix_vrreg_offset
,
238 rs6000_aix_supply_vsxregset
,
239 rs6000_aix_collect_vsxregset
242 static struct trad_frame_cache
*
243 aix_sighandle_frame_cache (frame_info_ptr this_frame
,
247 CORE_ADDR base
, base_orig
, func
;
248 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
249 ppc_gdbarch_tdep
*tdep
= gdbarch_tdep
<ppc_gdbarch_tdep
> (gdbarch
);
250 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
251 struct trad_frame_cache
*this_trad_cache
;
253 if ((*this_cache
) != NULL
)
254 return (struct trad_frame_cache
*) (*this_cache
);
256 this_trad_cache
= trad_frame_cache_zalloc (this_frame
);
257 (*this_cache
) = this_trad_cache
;
259 base
= get_frame_register_unsigned (this_frame
,
260 gdbarch_sp_regnum (gdbarch
));
263 if (tdep
->wordsize
== 4)
265 func
= read_memory_unsigned_integer (base_orig
+
266 SIG_FRAME_PC_OFFSET
+ 8,
267 tdep
->wordsize
, byte_order
);
268 safe_read_memory_integer (base_orig
+ SIG_FRAME_FP_OFFSET
+ 8,
269 tdep
->wordsize
, byte_order
, &backchain
);
270 base
= (CORE_ADDR
)backchain
;
274 func
= read_memory_unsigned_integer (base_orig
+
275 SIG_FRAME_LR_OFFSET64
,
276 tdep
->wordsize
, byte_order
);
277 safe_read_memory_integer (base_orig
+ SIG_FRAME_FP_OFFSET64
,
278 tdep
->wordsize
, byte_order
, &backchain
);
279 base
= (CORE_ADDR
)backchain
;
282 trad_frame_set_reg_value (this_trad_cache
, gdbarch_pc_regnum (gdbarch
), func
);
283 trad_frame_set_reg_value (this_trad_cache
, gdbarch_sp_regnum (gdbarch
), base
);
285 if (tdep
->wordsize
== 4)
286 trad_frame_set_reg_addr (this_trad_cache
, tdep
->ppc_lr_regnum
,
287 base_orig
+ 0x38 + 52 + 8);
289 trad_frame_set_reg_addr (this_trad_cache
, tdep
->ppc_lr_regnum
,
290 base_orig
+ 0x70 + 320);
292 trad_frame_set_id (this_trad_cache
, frame_id_build (base
, func
));
293 trad_frame_set_this_base (this_trad_cache
, base
);
295 return this_trad_cache
;
299 aix_sighandle_frame_this_id (frame_info_ptr this_frame
,
300 void **this_prologue_cache
,
301 struct frame_id
*this_id
)
303 struct trad_frame_cache
*this_trad_cache
304 = aix_sighandle_frame_cache (this_frame
, this_prologue_cache
);
305 trad_frame_get_id (this_trad_cache
, this_id
);
308 static struct value
*
309 aix_sighandle_frame_prev_register (frame_info_ptr this_frame
,
310 void **this_prologue_cache
, int regnum
)
312 struct trad_frame_cache
*this_trad_cache
313 = aix_sighandle_frame_cache (this_frame
, this_prologue_cache
);
314 return trad_frame_get_register (this_trad_cache
, this_frame
, regnum
);
318 aix_sighandle_frame_sniffer (const struct frame_unwind
*self
,
319 frame_info_ptr this_frame
,
320 void **this_prologue_cache
)
322 CORE_ADDR pc
= get_frame_pc (this_frame
);
323 if (pc
&& pc
< AIX_TEXT_SEGMENT_BASE
)
329 /* AIX signal handler frame unwinder */
331 static const struct frame_unwind aix_sighandle_frame_unwind
= {
332 "rs6000 aix sighandle",
334 default_frame_unwind_stop_reason
,
335 aix_sighandle_frame_this_id
,
336 aix_sighandle_frame_prev_register
,
338 aix_sighandle_frame_sniffer
341 /* Core file support. */
343 static struct ppc_reg_offsets rs6000_aix32_reg_offsets
=
345 /* General-purpose registers. */
357 /* Floating-point registers. */
359 56, /* fpscr_offset */
363 static struct ppc_reg_offsets rs6000_aix64_reg_offsets
=
365 /* General-purpose registers. */
373 280, /* ctr_offset */
374 292, /* xer_offset */
377 /* Floating-point registers. */
379 296, /* fpscr_offset */
384 /* Supply register REGNUM in the general-purpose register set REGSET
385 from the buffer specified by GREGS and LEN to register cache
386 REGCACHE. If REGNUM is -1, do this for all registers in REGSET. */
389 rs6000_aix_supply_regset (const struct regset
*regset
,
390 struct regcache
*regcache
, int regnum
,
391 const void *gregs
, size_t len
)
393 ppc_supply_gregset (regset
, regcache
, regnum
, gregs
, len
);
394 ppc_supply_fpregset (regset
, regcache
, regnum
, gregs
, len
);
397 /* Collect register REGNUM in the general-purpose register set
398 REGSET, from register cache REGCACHE into the buffer specified by
399 GREGS and LEN. If REGNUM is -1, do this for all registers in
403 rs6000_aix_collect_regset (const struct regset
*regset
,
404 const struct regcache
*regcache
, int regnum
,
405 void *gregs
, size_t len
)
407 ppc_collect_gregset (regset
, regcache
, regnum
, gregs
, len
);
408 ppc_collect_fpregset (regset
, regcache
, regnum
, gregs
, len
);
411 /* AIX register set. */
413 static const struct regset rs6000_aix32_regset
=
415 &rs6000_aix32_reg_offsets
,
416 rs6000_aix_supply_regset
,
417 rs6000_aix_collect_regset
,
420 static const struct regset rs6000_aix64_regset
=
422 &rs6000_aix64_reg_offsets
,
423 rs6000_aix_supply_regset
,
424 rs6000_aix_collect_regset
,
427 /* Iterate over core file register note sections. */
430 rs6000_aix_iterate_over_regset_sections (struct gdbarch
*gdbarch
,
431 iterate_over_regset_sections_cb
*cb
,
433 const struct regcache
*regcache
)
435 ppc_gdbarch_tdep
*tdep
= gdbarch_tdep
<ppc_gdbarch_tdep
> (gdbarch
);
436 int have_altivec
= tdep
->ppc_vr0_regnum
!= -1;
437 int have_vsx
= tdep
->ppc_vsr0_upper_regnum
!= -1;
439 if (tdep
->wordsize
== 4)
440 cb (".reg", 592, 592, &rs6000_aix32_regset
, NULL
, cb_data
);
442 cb (".reg", 576, 576, &rs6000_aix64_regset
, NULL
, cb_data
);
445 cb (".aix-vmx", 560, 560, &rs6000_aix_vrregset
, "AIX altivec", cb_data
);
448 cb (".aix-vsx", 256, 256, &rs6000_aix_vsxregset
, "AIX vsx", cb_data
);
452 /* Read core file description for AIX. */
454 static const struct target_desc
*
455 ppc_aix_core_read_description (struct gdbarch
*gdbarch
,
456 struct target_ops
*target
,
459 asection
*altivec
= bfd_get_section_by_name (abfd
, ".aix-vmx");
460 asection
*vsx
= bfd_get_section_by_name (abfd
, ".aix-vsx");
461 asection
*section
= bfd_get_section_by_name (abfd
, ".reg");
462 ppc_gdbarch_tdep
*tdep
= gdbarch_tdep
<ppc_gdbarch_tdep
> (gdbarch
);
468 if (tdep
->wordsize
== 8)
472 return tdesc_powerpc_vsx64
;
473 else if (vsx
&& !arch64
)
474 return tdesc_powerpc_vsx32
;
475 else if (altivec
&& arch64
)
476 return tdesc_powerpc_altivec64
;
477 else if (altivec
&& !arch64
)
478 return tdesc_powerpc_altivec32
;
483 /* Pass the arguments in either registers, or in the stack. In RS/6000,
484 the first eight words of the argument list (that might be less than
485 eight parameters if some parameters occupy more than one word) are
486 passed in r3..r10 registers. Float and double parameters are
487 passed in fpr's, in addition to that. Rest of the parameters if any
488 are passed in user stack. There might be cases in which half of the
489 parameter is copied into registers, the other half is pushed into
492 Stack must be aligned on 64-bit boundaries when synthesizing
495 If the function is returning a structure, then the return address is passed
496 in r3, then the first 7 words of the parameters can be passed in registers,
500 rs6000_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
501 struct regcache
*regcache
, CORE_ADDR bp_addr
,
502 int nargs
, struct value
**args
, CORE_ADDR sp
,
503 function_call_return_method return_method
,
504 CORE_ADDR struct_addr
)
506 ppc_gdbarch_tdep
*tdep
= gdbarch_tdep
<ppc_gdbarch_tdep
> (gdbarch
);
507 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
510 int argno
; /* current argument number */
511 int argbytes
; /* current argument byte */
512 gdb_byte tmp_buffer
[50];
513 int f_argno
= 0; /* current floating point argno */
514 int wordsize
= tdep
->wordsize
;
515 CORE_ADDR func_addr
= find_function_addr (function
, NULL
);
517 struct value
*arg
= 0;
522 /* The calling convention this function implements assumes the
523 processor has floating-point registers. We shouldn't be using it
524 on PPC variants that lack them. */
525 gdb_assert (ppc_floating_point_unit_p (gdbarch
));
527 /* The first eight words of ther arguments are passed in registers.
528 Copy them appropriately. */
531 /* If the function is returning a `struct', then the first word
532 (which will be passed in r3) is used for struct return address.
533 In that case we should advance one word and start from r4
534 register to copy parameters. */
535 if (return_method
== return_method_struct
)
537 regcache_raw_write_unsigned (regcache
, tdep
->ppc_gp0_regnum
+ 3,
542 /* effectively indirect call... gcc does...
544 return_val example( float, int);
547 float in fp0, int in r3
548 offset of stack on overflow 8/16
549 for varargs, must go by type.
551 float in r3&r4, int in r5
552 offset of stack on overflow different
554 return in r3 or f0. If no float, must study how gcc emulates floats;
555 pay attention to arg promotion.
556 User may have to cast\args to handle promotion correctly
557 since gdb won't know if prototype supplied or not. */
559 for (argno
= 0, argbytes
= 0; argno
< nargs
&& ii
< 8; ++ii
)
561 int reg_size
= register_size (gdbarch
, ii
+ 3);
564 type
= check_typedef (arg
->type ());
565 len
= type
->length ();
567 if (type
->code () == TYPE_CODE_FLT
)
569 /* Floating point arguments are passed in fpr's, as well as gpr's.
570 There are 13 fpr's reserved for passing parameters. At this point
571 there is no way we would run out of them.
573 Always store the floating point value using the register's
574 floating-point format. */
575 const int fp_regnum
= tdep
->ppc_fp0_regnum
+ 1 + f_argno
;
576 gdb_byte reg_val
[PPC_MAX_REGISTER_SIZE
];
577 struct type
*reg_type
= register_type (gdbarch
, fp_regnum
);
579 gdb_assert (len
<= 8);
581 target_float_convert (arg
->contents ().data (), type
, reg_val
,
583 regcache
->cooked_write (fp_regnum
, reg_val
);
590 /* Argument takes more than one register. */
591 while (argbytes
< len
)
593 gdb_byte word
[PPC_MAX_REGISTER_SIZE
];
594 memset (word
, 0, reg_size
);
596 ((char *) arg
->contents ().data ()) + argbytes
,
597 (len
- argbytes
) > reg_size
598 ? reg_size
: len
- argbytes
);
599 regcache
->cooked_write (tdep
->ppc_gp0_regnum
+ 3 + ii
, word
);
600 ++ii
, argbytes
+= reg_size
;
603 goto ran_out_of_registers_for_arguments
;
610 /* Argument can fit in one register. No problem. */
611 gdb_byte word
[PPC_MAX_REGISTER_SIZE
];
613 memset (word
, 0, reg_size
);
614 if (type
->code () == TYPE_CODE_INT
615 || type
->code () == TYPE_CODE_ENUM
616 || type
->code () == TYPE_CODE_BOOL
617 || type
->code () == TYPE_CODE_CHAR
)
618 /* Sign or zero extend the "int" into a "word". */
619 store_unsigned_integer (word
, reg_size
, byte_order
,
620 unpack_long (type
, arg
->contents ().data ()));
622 memcpy (word
, arg
->contents ().data (), len
);
623 regcache
->cooked_write (tdep
->ppc_gp0_regnum
+ 3 +ii
, word
);
628 ran_out_of_registers_for_arguments
:
630 regcache_cooked_read_unsigned (regcache
,
631 gdbarch_sp_regnum (gdbarch
),
634 /* Location for 8 parameters are always reserved. */
637 /* Another six words for back chain, TOC register, link register, etc. */
640 /* Stack pointer must be quadword aligned. */
643 /* If there are more arguments, allocate space for them in
644 the stack, then push them starting from the ninth one. */
646 if ((argno
< nargs
) || argbytes
)
652 space
+= ((len
- argbytes
+ 3) & -4);
658 for (; jj
< nargs
; ++jj
)
660 struct value
*val
= args
[jj
];
661 space
+= ((val
->type ()->length ()) + 3) & -4;
664 /* Add location required for the rest of the parameters. */
665 space
= (space
+ 15) & -16;
668 /* This is another instance we need to be concerned about
669 securing our stack space. If we write anything underneath %sp
670 (r1), we might conflict with the kernel who thinks he is free
671 to use this area. So, update %sp first before doing anything
674 regcache_raw_write_signed (regcache
,
675 gdbarch_sp_regnum (gdbarch
), sp
);
677 /* If the last argument copied into the registers didn't fit there
678 completely, push the rest of it into stack. */
682 write_memory (sp
+ 24 + (ii
* 4),
683 arg
->contents ().data () + argbytes
,
686 ii
+= ((len
- argbytes
+ 3) & -4) / 4;
689 /* Push the rest of the arguments into stack. */
690 for (; argno
< nargs
; ++argno
)
694 type
= check_typedef (arg
->type ());
695 len
= type
->length ();
698 /* Float types should be passed in fpr's, as well as in the
700 if (type
->code () == TYPE_CODE_FLT
&& f_argno
< 13)
703 gdb_assert (len
<= 8);
705 regcache
->cooked_write (tdep
->ppc_fp0_regnum
+ 1 + f_argno
,
706 arg
->contents ().data ());
710 write_memory (sp
+ 24 + (ii
* 4), arg
->contents ().data (), len
);
711 ii
+= ((len
+ 3) & -4) / 4;
715 /* Set the stack pointer. According to the ABI, the SP is meant to
716 be set _before_ the corresponding stack space is used. On AIX,
717 this even applies when the target has been completely stopped!
718 Not doing this can lead to conflicts with the kernel which thinks
719 that it still has control over this not-yet-allocated stack
721 regcache_raw_write_signed (regcache
, gdbarch_sp_regnum (gdbarch
), sp
);
723 /* Set back chain properly. */
724 store_unsigned_integer (tmp_buffer
, wordsize
, byte_order
, saved_sp
);
725 write_memory (sp
, tmp_buffer
, wordsize
);
727 /* Point the inferior function call's return address at the dummy's
729 regcache_raw_write_signed (regcache
, tdep
->ppc_lr_regnum
, bp_addr
);
731 /* Set the TOC register value. */
732 regcache_raw_write_signed (regcache
, tdep
->ppc_toc_regnum
,
733 solib_aix_get_toc_value (func_addr
));
735 target_store_registers (regcache
, -1);
739 static enum return_value_convention
740 rs6000_return_value (struct gdbarch
*gdbarch
, struct value
*function
,
741 struct type
*valtype
, struct regcache
*regcache
,
742 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
744 ppc_gdbarch_tdep
*tdep
= gdbarch_tdep
<ppc_gdbarch_tdep
> (gdbarch
);
745 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
747 /* The calling convention this function implements assumes the
748 processor has floating-point registers. We shouldn't be using it
749 on PowerPC variants that lack them. */
750 gdb_assert (ppc_floating_point_unit_p (gdbarch
));
752 /* AltiVec extension: Functions that declare a vector data type as a
753 return value place that return value in VR2. */
754 if (valtype
->code () == TYPE_CODE_ARRAY
&& valtype
->is_vector ()
755 && valtype
->length () == 16)
758 regcache
->cooked_read (tdep
->ppc_vr0_regnum
+ 2, readbuf
);
760 regcache
->cooked_write (tdep
->ppc_vr0_regnum
+ 2, writebuf
);
762 return RETURN_VALUE_REGISTER_CONVENTION
;
765 /* If the called subprogram returns an aggregate, there exists an
766 implicit first argument, whose value is the address of a caller-
767 allocated buffer into which the callee is assumed to store its
768 return value. All explicit parameters are appropriately
770 if (valtype
->code () == TYPE_CODE_STRUCT
771 || valtype
->code () == TYPE_CODE_UNION
772 || valtype
->code () == TYPE_CODE_ARRAY
)
773 return RETURN_VALUE_STRUCT_CONVENTION
;
775 /* Scalar floating-point values are returned in FPR1 for float or
776 double, and in FPR1:FPR2 for quadword precision. Fortran
777 complex*8 and complex*16 are returned in FPR1:FPR2, and
778 complex*32 is returned in FPR1:FPR4. */
779 if (valtype
->code () == TYPE_CODE_FLT
780 && (valtype
->length () == 4 || valtype
->length () == 8))
782 struct type
*regtype
= register_type (gdbarch
, tdep
->ppc_fp0_regnum
);
785 /* FIXME: kettenis/2007-01-01: Add support for quadword
786 precision and complex. */
790 regcache
->cooked_read (tdep
->ppc_fp0_regnum
+ 1, regval
);
791 target_float_convert (regval
, regtype
, readbuf
, valtype
);
795 target_float_convert (writebuf
, valtype
, regval
, regtype
);
796 regcache
->cooked_write (tdep
->ppc_fp0_regnum
+ 1, regval
);
799 return RETURN_VALUE_REGISTER_CONVENTION
;
802 /* Values of the types int, long, short, pointer, and char (length
803 is less than or equal to four bytes), as well as bit values of
804 lengths less than or equal to 32 bits, must be returned right
805 justified in GPR3 with signed values sign extended and unsigned
806 values zero extended, as necessary. */
807 if (valtype
->length () <= tdep
->wordsize
)
813 /* For reading we don't have to worry about sign extension. */
814 regcache_cooked_read_unsigned (regcache
, tdep
->ppc_gp0_regnum
+ 3,
816 store_unsigned_integer (readbuf
, valtype
->length (), byte_order
,
821 /* For writing, use unpack_long since that should handle any
822 required sign extension. */
823 regcache_cooked_write_unsigned (regcache
, tdep
->ppc_gp0_regnum
+ 3,
824 unpack_long (valtype
, writebuf
));
827 return RETURN_VALUE_REGISTER_CONVENTION
;
830 /* Eight-byte non-floating-point scalar values must be returned in
833 if (valtype
->length () == 8)
835 gdb_assert (valtype
->code () != TYPE_CODE_FLT
);
836 gdb_assert (tdep
->wordsize
== 4);
842 regcache
->cooked_read (tdep
->ppc_gp0_regnum
+ 3, regval
);
843 regcache
->cooked_read (tdep
->ppc_gp0_regnum
+ 4, regval
+ 4);
844 memcpy (readbuf
, regval
, 8);
848 regcache
->cooked_write (tdep
->ppc_gp0_regnum
+ 3, writebuf
);
849 regcache
->cooked_write (tdep
->ppc_gp0_regnum
+ 4, writebuf
+ 4);
852 return RETURN_VALUE_REGISTER_CONVENTION
;
855 return RETURN_VALUE_STRUCT_CONVENTION
;
858 /* Support for CONVERT_FROM_FUNC_PTR_ADDR (ARCH, ADDR, TARG).
860 Usually a function pointer's representation is simply the address
861 of the function. On the RS/6000 however, a function pointer is
862 represented by a pointer to an OPD entry. This OPD entry contains
863 three words, the first word is the address of the function, the
864 second word is the TOC pointer (r2), and the third word is the
865 static chain value. Throughout GDB it is currently assumed that a
866 function pointer contains the address of the function, which is not
867 easy to fix. In addition, the conversion of a function address to
868 a function pointer would require allocation of an OPD entry in the
869 inferior's memory space, with all its drawbacks. To be able to
870 call C++ virtual methods in the inferior (which are called via
871 function pointers), find_function_addr uses this function to get the
872 function address from a function pointer. */
874 /* Return real function address if ADDR (a function pointer) is in the data
875 space and is therefore a special function pointer. */
878 rs6000_convert_from_func_ptr_addr (struct gdbarch
*gdbarch
,
880 struct target_ops
*targ
)
882 ppc_gdbarch_tdep
*tdep
= gdbarch_tdep
<ppc_gdbarch_tdep
> (gdbarch
);
883 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
884 struct obj_section
*s
;
886 s
= find_pc_section (addr
);
888 /* Normally, functions live inside a section that is executable.
889 So, if ADDR points to a non-executable section, then treat it
890 as a function descriptor and return the target address iff
891 the target address itself points to a section that is executable. */
892 if (s
&& (s
->the_bfd_section
->flags
& SEC_CODE
) == 0)
895 struct obj_section
*pc_section
;
899 pc
= read_memory_unsigned_integer (addr
, tdep
->wordsize
, byte_order
);
901 catch (const gdb_exception_error
&e
)
903 /* An error occurred during reading. Probably a memory error
904 due to the section not being loaded yet. This address
905 cannot be a function descriptor. */
909 pc_section
= find_pc_section (pc
);
911 if (pc_section
&& (pc_section
->the_bfd_section
->flags
& SEC_CODE
))
919 /* Calculate the destination of a branch/jump. Return -1 if not a branch. */
922 branch_dest (struct regcache
*regcache
, int opcode
, int instr
,
923 CORE_ADDR pc
, CORE_ADDR safety
)
925 struct gdbarch
*gdbarch
= regcache
->arch ();
926 ppc_gdbarch_tdep
*tdep
= gdbarch_tdep
<ppc_gdbarch_tdep
> (gdbarch
);
927 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
933 absolute
= (int) ((instr
>> 1) & 1);
938 immediate
= ((instr
& ~3) << 6) >> 6; /* br unconditional */
942 dest
= pc
+ immediate
;
946 immediate
= ((instr
& ~3) << 16) >> 16; /* br conditional */
950 dest
= pc
+ immediate
;
954 ext_op
= (instr
>> 1) & 0x3ff;
956 if (ext_op
== 16) /* br conditional register */
958 dest
= regcache_raw_get_unsigned (regcache
, tdep
->ppc_lr_regnum
) & ~3;
960 /* If we are about to return from a signal handler, dest is
961 something like 0x3c90. The current frame is a signal handler
962 caller frame, upon completion of the sigreturn system call
963 execution will return to the saved PC in the frame. */
964 if (dest
< AIX_TEXT_SEGMENT_BASE
)
966 frame_info_ptr frame
= get_current_frame ();
968 dest
= read_memory_unsigned_integer
969 (get_frame_base (frame
) + SIG_FRAME_PC_OFFSET
,
970 tdep
->wordsize
, byte_order
);
974 else if (ext_op
== 528) /* br cond to count reg */
976 dest
= regcache_raw_get_unsigned (regcache
,
977 tdep
->ppc_ctr_regnum
) & ~3;
979 /* If we are about to execute a system call, dest is something
980 like 0x22fc or 0x3b00. Upon completion the system call
981 will return to the address in the link register. */
982 if (dest
< AIX_TEXT_SEGMENT_BASE
)
983 dest
= regcache_raw_get_unsigned (regcache
,
984 tdep
->ppc_lr_regnum
) & ~3;
993 return (dest
< AIX_TEXT_SEGMENT_BASE
) ? safety
: dest
;
996 /* AIX does not support PT_STEP. Simulate it. */
998 static std::vector
<CORE_ADDR
>
999 rs6000_software_single_step (struct regcache
*regcache
)
1001 struct gdbarch
*gdbarch
= regcache
->arch ();
1002 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1005 CORE_ADDR breaks
[2];
1008 loc
= regcache_read_pc (regcache
);
1010 insn
= read_memory_integer (loc
, 4, byte_order
);
1012 std::vector
<CORE_ADDR
> next_pcs
= ppc_deal_with_atomic_sequence (regcache
);
1013 if (!next_pcs
.empty ())
1016 breaks
[0] = loc
+ PPC_INSN_SIZE
;
1017 opcode
= insn
>> 26;
1018 breaks
[1] = branch_dest (regcache
, opcode
, insn
, loc
, breaks
[0]);
1020 /* Don't put two breakpoints on the same address. */
1021 if (breaks
[1] == breaks
[0])
1024 for (ii
= 0; ii
< 2; ++ii
)
1026 /* ignore invalid breakpoint. */
1027 if (breaks
[ii
] == -1)
1030 next_pcs
.push_back (breaks
[ii
]);
1033 errno
= 0; /* FIXME, don't ignore errors! */
1034 /* What errors? {read,write}_memory call error(). */
1038 /* Implement the "auto_wide_charset" gdbarch method for this platform. */
1041 rs6000_aix_auto_wide_charset (void)
1046 /* Implement an osabi sniffer for RS6000/AIX.
1048 This function assumes that ABFD's flavour is XCOFF. In other words,
1049 it should be registered as a sniffer for bfd_target_xcoff_flavour
1050 objfiles only. A failed assertion will be raised if this condition
1053 static enum gdb_osabi
1054 rs6000_aix_osabi_sniffer (bfd
*abfd
)
1056 gdb_assert (bfd_get_flavour (abfd
) == bfd_target_xcoff_flavour
);
1058 /* The only noticeable difference between Lynx178 XCOFF files and
1059 AIX XCOFF files comes from the fact that there are no shared
1060 libraries on Lynx178. On AIX, we are betting that an executable
1061 linked with no shared library will never exist. */
1062 if (xcoff_get_n_import_files (abfd
) <= 0)
1063 return GDB_OSABI_UNKNOWN
;
1065 return GDB_OSABI_AIX
;
1068 /* A structure encoding the offset and size of a field within
1077 /* A structure describing the layout of all the fields of interest
1078 in AIX's struct ld_info. Each field in this struct corresponds
1079 to the field of the same name in struct ld_info. */
1083 struct ldinfo_field ldinfo_next
;
1084 struct ldinfo_field ldinfo_fd
;
1085 struct ldinfo_field ldinfo_textorg
;
1086 struct ldinfo_field ldinfo_textsize
;
1087 struct ldinfo_field ldinfo_dataorg
;
1088 struct ldinfo_field ldinfo_datasize
;
1089 struct ldinfo_field ldinfo_filename
;
1092 /* The following data has been generated by compiling and running
1093 the following program on AIX 5.3. */
1098 #define __LDINFO_PTRACE32__
1099 #define __LDINFO_PTRACE64__
1100 #include <sys/ldr.h>
1102 #define pinfo(type,member) \
1104 struct type ldi = {0}; \
1106 printf (" {%d, %d},\t/* %s */\n", \
1107 offsetof (struct type, member), \
1108 sizeof (ldi.member), \
1116 printf ("static const struct ld_info_desc ld_info32_desc =\n{\n");
1117 pinfo (__ld_info32
, ldinfo_next
);
1118 pinfo (__ld_info32
, ldinfo_fd
);
1119 pinfo (__ld_info32
, ldinfo_textorg
);
1120 pinfo (__ld_info32
, ldinfo_textsize
);
1121 pinfo (__ld_info32
, ldinfo_dataorg
);
1122 pinfo (__ld_info32
, ldinfo_datasize
);
1123 pinfo (__ld_info32
, ldinfo_filename
);
1128 printf ("static const struct ld_info_desc ld_info64_desc =\n{\n");
1129 pinfo (__ld_info64
, ldinfo_next
);
1130 pinfo (__ld_info64
, ldinfo_fd
);
1131 pinfo (__ld_info64
, ldinfo_textorg
);
1132 pinfo (__ld_info64
, ldinfo_textsize
);
1133 pinfo (__ld_info64
, ldinfo_dataorg
);
1134 pinfo (__ld_info64
, ldinfo_datasize
);
1135 pinfo (__ld_info64
, ldinfo_filename
);
1142 /* Layout of the 32bit version of struct ld_info. */
1144 static const struct ld_info_desc ld_info32_desc
=
1146 {0, 4}, /* ldinfo_next */
1147 {4, 4}, /* ldinfo_fd */
1148 {8, 4}, /* ldinfo_textorg */
1149 {12, 4}, /* ldinfo_textsize */
1150 {16, 4}, /* ldinfo_dataorg */
1151 {20, 4}, /* ldinfo_datasize */
1152 {24, 2}, /* ldinfo_filename */
1155 /* Layout of the 64bit version of struct ld_info. */
1157 static const struct ld_info_desc ld_info64_desc
=
1159 {0, 4}, /* ldinfo_next */
1160 {8, 4}, /* ldinfo_fd */
1161 {16, 8}, /* ldinfo_textorg */
1162 {24, 8}, /* ldinfo_textsize */
1163 {32, 8}, /* ldinfo_dataorg */
1164 {40, 8}, /* ldinfo_datasize */
1165 {48, 2}, /* ldinfo_filename */
1168 /* A structured representation of one entry read from the ld_info
1169 binary data provided by the AIX loader. */
1183 /* Return a struct ld_info object corresponding to the entry at
1186 Note that the filename and member_name strings still point
1187 to the data in LDI_BUF. So LDI_BUF must not be deallocated
1188 while the struct ld_info object returned is in use. */
1190 static struct ld_info
1191 rs6000_aix_extract_ld_info (struct gdbarch
*gdbarch
,
1192 const gdb_byte
*ldi_buf
)
1194 ppc_gdbarch_tdep
*tdep
= gdbarch_tdep
<ppc_gdbarch_tdep
> (gdbarch
);
1195 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1196 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
1197 const struct ld_info_desc desc
1198 = tdep
->wordsize
== 8 ? ld_info64_desc
: ld_info32_desc
;
1199 struct ld_info info
;
1201 info
.next
= extract_unsigned_integer (ldi_buf
+ desc
.ldinfo_next
.offset
,
1202 desc
.ldinfo_next
.size
,
1204 info
.fd
= extract_signed_integer (ldi_buf
+ desc
.ldinfo_fd
.offset
,
1205 desc
.ldinfo_fd
.size
,
1207 info
.textorg
= extract_typed_address (ldi_buf
+ desc
.ldinfo_textorg
.offset
,
1210 = extract_unsigned_integer (ldi_buf
+ desc
.ldinfo_textsize
.offset
,
1211 desc
.ldinfo_textsize
.size
,
1213 info
.dataorg
= extract_typed_address (ldi_buf
+ desc
.ldinfo_dataorg
.offset
,
1216 = extract_unsigned_integer (ldi_buf
+ desc
.ldinfo_datasize
.offset
,
1217 desc
.ldinfo_datasize
.size
,
1219 info
.filename
= (char *) ldi_buf
+ desc
.ldinfo_filename
.offset
;
1220 info
.member_name
= info
.filename
+ strlen (info
.filename
) + 1;
1225 /* Append to OBJSTACK an XML string description of the shared library
1226 corresponding to LDI, following the TARGET_OBJECT_LIBRARIES_AIX
1230 rs6000_aix_shared_library_to_xml (struct ld_info
*ldi
,
1231 struct obstack
*obstack
)
1233 obstack_grow_str (obstack
, "<library name=\"");
1234 std::string p
= xml_escape_text (ldi
->filename
);
1235 obstack_grow_str (obstack
, p
.c_str ());
1236 obstack_grow_str (obstack
, "\"");
1238 if (ldi
->member_name
[0] != '\0')
1240 obstack_grow_str (obstack
, " member=\"");
1241 p
= xml_escape_text (ldi
->member_name
);
1242 obstack_grow_str (obstack
, p
.c_str ());
1243 obstack_grow_str (obstack
, "\"");
1246 obstack_grow_str (obstack
, " text_addr=\"");
1247 obstack_grow_str (obstack
, core_addr_to_string (ldi
->textorg
));
1248 obstack_grow_str (obstack
, "\"");
1250 obstack_grow_str (obstack
, " text_size=\"");
1251 obstack_grow_str (obstack
, pulongest (ldi
->textsize
));
1252 obstack_grow_str (obstack
, "\"");
1254 obstack_grow_str (obstack
, " data_addr=\"");
1255 obstack_grow_str (obstack
, core_addr_to_string (ldi
->dataorg
));
1256 obstack_grow_str (obstack
, "\"");
1258 obstack_grow_str (obstack
, " data_size=\"");
1259 obstack_grow_str (obstack
, pulongest (ldi
->datasize
));
1260 obstack_grow_str (obstack
, "\"");
1262 obstack_grow_str (obstack
, "></library>");
1265 /* Convert the ld_info binary data provided by the AIX loader into
1266 an XML representation following the TARGET_OBJECT_LIBRARIES_AIX
1269 LDI_BUF is a buffer containing the ld_info data.
1270 READBUF, OFFSET and LEN follow the same semantics as target_ops'
1271 to_xfer_partial target_ops method.
1273 If CLOSE_LDINFO_FD is nonzero, then this routine also closes
1274 the ldinfo_fd file descriptor. This is useful when the ldinfo
1275 data is obtained via ptrace, as ptrace opens a file descriptor
1276 for each and every entry; but we cannot use this descriptor
1277 as the consumer of the XML library list might live in a different
1281 rs6000_aix_ld_info_to_xml (struct gdbarch
*gdbarch
, const gdb_byte
*ldi_buf
,
1282 gdb_byte
*readbuf
, ULONGEST offset
, ULONGEST len
,
1283 int close_ldinfo_fd
)
1285 struct obstack obstack
;
1289 obstack_init (&obstack
);
1290 obstack_grow_str (&obstack
, "<library-list-aix version=\"1.0\">\n");
1294 struct ld_info ldi
= rs6000_aix_extract_ld_info (gdbarch
, ldi_buf
);
1296 rs6000_aix_shared_library_to_xml (&ldi
, &obstack
);
1297 if (close_ldinfo_fd
)
1302 ldi_buf
= ldi_buf
+ ldi
.next
;
1305 obstack_grow_str0 (&obstack
, "</library-list-aix>\n");
1307 buf
= (const char *) obstack_finish (&obstack
);
1308 len_avail
= strlen (buf
);
1309 if (offset
>= len_avail
)
1313 if (len
> len_avail
- offset
)
1314 len
= len_avail
- offset
;
1315 memcpy (readbuf
, buf
+ offset
, len
);
1318 obstack_free (&obstack
, NULL
);
1322 /* Implement the core_xfer_shared_libraries_aix gdbarch method. */
1325 rs6000_aix_core_xfer_shared_libraries_aix (struct gdbarch
*gdbarch
,
1330 struct bfd_section
*ldinfo_sec
;
1333 ldinfo_sec
= bfd_get_section_by_name (core_bfd
, ".ldinfo");
1334 if (ldinfo_sec
== NULL
)
1335 error (_("cannot find .ldinfo section from core file: %s"),
1336 bfd_errmsg (bfd_get_error ()));
1337 ldinfo_size
= bfd_section_size (ldinfo_sec
);
1339 gdb::byte_vector
ldinfo_buf (ldinfo_size
);
1341 if (! bfd_get_section_contents (core_bfd
, ldinfo_sec
,
1342 ldinfo_buf
.data (), 0, ldinfo_size
))
1343 error (_("unable to read .ldinfo section from core file: %s"),
1344 bfd_errmsg (bfd_get_error ()));
1346 return rs6000_aix_ld_info_to_xml (gdbarch
, ldinfo_buf
.data (), readbuf
,
1351 rs6000_aix_init_osabi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
1353 ppc_gdbarch_tdep
*tdep
= gdbarch_tdep
<ppc_gdbarch_tdep
> (gdbarch
);
1355 /* RS6000/AIX does not support PT_STEP. Has to be simulated. */
1356 set_gdbarch_software_single_step (gdbarch
, rs6000_software_single_step
);
1358 /* Displaced stepping is currently not supported in combination with
1359 software single-stepping. These override the values set by
1360 rs6000_gdbarch_init. */
1361 set_gdbarch_displaced_step_copy_insn (gdbarch
, NULL
);
1362 set_gdbarch_displaced_step_fixup (gdbarch
, NULL
);
1363 set_gdbarch_displaced_step_prepare (gdbarch
, NULL
);
1364 set_gdbarch_displaced_step_finish (gdbarch
, NULL
);
1366 set_gdbarch_push_dummy_call (gdbarch
, rs6000_push_dummy_call
);
1367 set_gdbarch_return_value (gdbarch
, rs6000_return_value
);
1368 set_gdbarch_long_double_bit (gdbarch
, 8 * TARGET_CHAR_BIT
);
1370 /* Handle RS/6000 function pointers (which are really function
1372 set_gdbarch_convert_from_func_ptr_addr
1373 (gdbarch
, rs6000_convert_from_func_ptr_addr
);
1375 /* Core file support. */
1376 set_gdbarch_iterate_over_regset_sections
1377 (gdbarch
, rs6000_aix_iterate_over_regset_sections
);
1378 set_gdbarch_core_xfer_shared_libraries_aix
1379 (gdbarch
, rs6000_aix_core_xfer_shared_libraries_aix
);
1380 set_gdbarch_core_read_description (gdbarch
, ppc_aix_core_read_description
);
1382 if (tdep
->wordsize
== 8)
1383 tdep
->lr_frame_offset
= 16;
1385 tdep
->lr_frame_offset
= 8;
1387 if (tdep
->wordsize
== 4)
1388 /* PowerOpen / AIX 32 bit. The saved area or red zone consists of
1389 19 4 byte GPRS + 18 8 byte FPRs giving a total of 220 bytes.
1390 Problem is, 220 isn't frame (16 byte) aligned. Round it up to
1392 set_gdbarch_frame_red_zone_size (gdbarch
, 224);
1394 set_gdbarch_frame_red_zone_size (gdbarch
, 0);
1396 if (tdep
->wordsize
== 8)
1397 set_gdbarch_wchar_bit (gdbarch
, 32);
1399 set_gdbarch_wchar_bit (gdbarch
, 16);
1400 set_gdbarch_wchar_signed (gdbarch
, 0);
1401 set_gdbarch_auto_wide_charset (gdbarch
, rs6000_aix_auto_wide_charset
);
1403 set_gdbarch_so_ops (gdbarch
, &solib_aix_so_ops
);
1404 frame_unwind_append_unwinder (gdbarch
, &aix_sighandle_frame_unwind
);
1407 void _initialize_rs6000_aix_tdep ();
1409 _initialize_rs6000_aix_tdep ()
1411 gdbarch_register_osabi_sniffer (bfd_arch_rs6000
,
1412 bfd_target_xcoff_flavour
,
1413 rs6000_aix_osabi_sniffer
);
1414 gdbarch_register_osabi_sniffer (bfd_arch_powerpc
,
1415 bfd_target_xcoff_flavour
,
1416 rs6000_aix_osabi_sniffer
);
1418 gdbarch_register_osabi (bfd_arch_rs6000
, 0, GDB_OSABI_AIX
,
1419 rs6000_aix_init_osabi
);
1420 gdbarch_register_osabi (bfd_arch_powerpc
, 0, GDB_OSABI_AIX
,
1421 rs6000_aix_init_osabi
);