1 /* Native support code for PPC AIX, for GDB the GNU debugger.
3 Copyright (C) 2006-2016 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"
33 #include "rs6000-tdep.h"
35 #include "rs6000-aix-tdep.h"
36 #include "xcoffread.h"
38 #include "solib-aix.h"
39 #include "xml-utils.h"
41 /* If the kernel has to deliver a signal, it pushes a sigcontext
42 structure on the stack and then calls the signal handler, passing
43 the address of the sigcontext in an argument register. Usually
44 the signal handler doesn't save this register, so we have to
45 access the sigcontext structure via an offset from the signal handler
47 The following constants were determined by experimentation on AIX 3.2. */
48 #define SIG_FRAME_PC_OFFSET 96
49 #define SIG_FRAME_LR_OFFSET 108
50 #define SIG_FRAME_FP_OFFSET 284
53 /* Core file support. */
55 static struct ppc_reg_offsets rs6000_aix32_reg_offsets
=
57 /* General-purpose registers. */
69 /* Floating-point registers. */
71 56, /* fpscr_offset */
74 /* AltiVec registers. */
77 -1 /* vrsave_offset */
80 static struct ppc_reg_offsets rs6000_aix64_reg_offsets
=
82 /* General-purpose registers. */
94 /* Floating-point registers. */
96 296, /* fpscr_offset */
99 /* AltiVec registers. */
101 -1, /* vscr_offset */
102 -1 /* vrsave_offset */
106 /* Supply register REGNUM in the general-purpose register set REGSET
107 from the buffer specified by GREGS and LEN to register cache
108 REGCACHE. If REGNUM is -1, do this for all registers in REGSET. */
111 rs6000_aix_supply_regset (const struct regset
*regset
,
112 struct regcache
*regcache
, int regnum
,
113 const void *gregs
, size_t len
)
115 ppc_supply_gregset (regset
, regcache
, regnum
, gregs
, len
);
116 ppc_supply_fpregset (regset
, regcache
, regnum
, gregs
, len
);
119 /* Collect register REGNUM in the general-purpose register set
120 REGSET, from register cache REGCACHE into the buffer specified by
121 GREGS and LEN. If REGNUM is -1, do this for all registers in
125 rs6000_aix_collect_regset (const struct regset
*regset
,
126 const struct regcache
*regcache
, int regnum
,
127 void *gregs
, size_t len
)
129 ppc_collect_gregset (regset
, regcache
, regnum
, gregs
, len
);
130 ppc_collect_fpregset (regset
, regcache
, regnum
, gregs
, len
);
133 /* AIX register set. */
135 static const struct regset rs6000_aix32_regset
=
137 &rs6000_aix32_reg_offsets
,
138 rs6000_aix_supply_regset
,
139 rs6000_aix_collect_regset
,
142 static const struct regset rs6000_aix64_regset
=
144 &rs6000_aix64_reg_offsets
,
145 rs6000_aix_supply_regset
,
146 rs6000_aix_collect_regset
,
149 /* Iterate over core file register note sections. */
152 rs6000_aix_iterate_over_regset_sections (struct gdbarch
*gdbarch
,
153 iterate_over_regset_sections_cb
*cb
,
155 const struct regcache
*regcache
)
157 if (gdbarch_tdep (gdbarch
)->wordsize
== 4)
158 cb (".reg", 592, &rs6000_aix32_regset
, NULL
, cb_data
);
160 cb (".reg", 576, &rs6000_aix64_regset
, NULL
, cb_data
);
164 /* Pass the arguments in either registers, or in the stack. In RS/6000,
165 the first eight words of the argument list (that might be less than
166 eight parameters if some parameters occupy more than one word) are
167 passed in r3..r10 registers. Float and double parameters are
168 passed in fpr's, in addition to that. Rest of the parameters if any
169 are passed in user stack. There might be cases in which half of the
170 parameter is copied into registers, the other half is pushed into
173 Stack must be aligned on 64-bit boundaries when synthesizing
176 If the function is returning a structure, then the return address is passed
177 in r3, then the first 7 words of the parameters can be passed in registers,
181 rs6000_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
182 struct regcache
*regcache
, CORE_ADDR bp_addr
,
183 int nargs
, struct value
**args
, CORE_ADDR sp
,
184 int struct_return
, CORE_ADDR struct_addr
)
186 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
187 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
190 int argno
; /* current argument number */
191 int argbytes
; /* current argument byte */
192 gdb_byte tmp_buffer
[50];
193 int f_argno
= 0; /* current floating point argno */
194 int wordsize
= gdbarch_tdep (gdbarch
)->wordsize
;
195 CORE_ADDR func_addr
= find_function_addr (function
, NULL
);
197 struct value
*arg
= 0;
202 /* The calling convention this function implements assumes the
203 processor has floating-point registers. We shouldn't be using it
204 on PPC variants that lack them. */
205 gdb_assert (ppc_floating_point_unit_p (gdbarch
));
207 /* The first eight words of ther arguments are passed in registers.
208 Copy them appropriately. */
211 /* If the function is returning a `struct', then the first word
212 (which will be passed in r3) is used for struct return address.
213 In that case we should advance one word and start from r4
214 register to copy parameters. */
217 regcache_raw_write_unsigned (regcache
, tdep
->ppc_gp0_regnum
+ 3,
222 /* effectively indirect call... gcc does...
224 return_val example( float, int);
227 float in fp0, int in r3
228 offset of stack on overflow 8/16
229 for varargs, must go by type.
231 float in r3&r4, int in r5
232 offset of stack on overflow different
234 return in r3 or f0. If no float, must study how gcc emulates floats;
235 pay attention to arg promotion.
236 User may have to cast\args to handle promotion correctly
237 since gdb won't know if prototype supplied or not. */
239 for (argno
= 0, argbytes
= 0; argno
< nargs
&& ii
< 8; ++ii
)
241 int reg_size
= register_size (gdbarch
, ii
+ 3);
244 type
= check_typedef (value_type (arg
));
245 len
= TYPE_LENGTH (type
);
247 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
249 /* Floating point arguments are passed in fpr's, as well as gpr's.
250 There are 13 fpr's reserved for passing parameters. At this point
251 there is no way we would run out of them.
253 Always store the floating point value using the register's
254 floating-point format. */
255 const int fp_regnum
= tdep
->ppc_fp0_regnum
+ 1 + f_argno
;
256 gdb_byte reg_val
[MAX_REGISTER_SIZE
];
257 struct type
*reg_type
= register_type (gdbarch
, fp_regnum
);
259 gdb_assert (len
<= 8);
261 convert_typed_floating (value_contents (arg
), type
,
263 regcache_cooked_write (regcache
, fp_regnum
, reg_val
);
270 /* Argument takes more than one register. */
271 while (argbytes
< len
)
273 gdb_byte word
[MAX_REGISTER_SIZE
];
274 memset (word
, 0, reg_size
);
276 ((char *) value_contents (arg
)) + argbytes
,
277 (len
- argbytes
) > reg_size
278 ? reg_size
: len
- argbytes
);
279 regcache_cooked_write (regcache
,
280 tdep
->ppc_gp0_regnum
+ 3 + ii
,
282 ++ii
, argbytes
+= reg_size
;
285 goto ran_out_of_registers_for_arguments
;
292 /* Argument can fit in one register. No problem. */
293 gdb_byte word
[MAX_REGISTER_SIZE
];
295 memset (word
, 0, reg_size
);
296 memcpy (word
, value_contents (arg
), len
);
297 regcache_cooked_write (regcache
, tdep
->ppc_gp0_regnum
+ 3 +ii
, word
);
302 ran_out_of_registers_for_arguments
:
304 regcache_cooked_read_unsigned (regcache
,
305 gdbarch_sp_regnum (gdbarch
),
308 /* Location for 8 parameters are always reserved. */
311 /* Another six words for back chain, TOC register, link register, etc. */
314 /* Stack pointer must be quadword aligned. */
317 /* If there are more arguments, allocate space for them in
318 the stack, then push them starting from the ninth one. */
320 if ((argno
< nargs
) || argbytes
)
326 space
+= ((len
- argbytes
+ 3) & -4);
332 for (; jj
< nargs
; ++jj
)
334 struct value
*val
= args
[jj
];
335 space
+= ((TYPE_LENGTH (value_type (val
))) + 3) & -4;
338 /* Add location required for the rest of the parameters. */
339 space
= (space
+ 15) & -16;
342 /* This is another instance we need to be concerned about
343 securing our stack space. If we write anything underneath %sp
344 (r1), we might conflict with the kernel who thinks he is free
345 to use this area. So, update %sp first before doing anything
348 regcache_raw_write_signed (regcache
,
349 gdbarch_sp_regnum (gdbarch
), sp
);
351 /* If the last argument copied into the registers didn't fit there
352 completely, push the rest of it into stack. */
356 write_memory (sp
+ 24 + (ii
* 4),
357 value_contents (arg
) + argbytes
,
360 ii
+= ((len
- argbytes
+ 3) & -4) / 4;
363 /* Push the rest of the arguments into stack. */
364 for (; argno
< nargs
; ++argno
)
368 type
= check_typedef (value_type (arg
));
369 len
= TYPE_LENGTH (type
);
372 /* Float types should be passed in fpr's, as well as in the
374 if (TYPE_CODE (type
) == TYPE_CODE_FLT
&& f_argno
< 13)
377 gdb_assert (len
<= 8);
379 regcache_cooked_write (regcache
,
380 tdep
->ppc_fp0_regnum
+ 1 + f_argno
,
381 value_contents (arg
));
385 write_memory (sp
+ 24 + (ii
* 4), value_contents (arg
), len
);
386 ii
+= ((len
+ 3) & -4) / 4;
390 /* Set the stack pointer. According to the ABI, the SP is meant to
391 be set _before_ the corresponding stack space is used. On AIX,
392 this even applies when the target has been completely stopped!
393 Not doing this can lead to conflicts with the kernel which thinks
394 that it still has control over this not-yet-allocated stack
396 regcache_raw_write_signed (regcache
, gdbarch_sp_regnum (gdbarch
), sp
);
398 /* Set back chain properly. */
399 store_unsigned_integer (tmp_buffer
, wordsize
, byte_order
, saved_sp
);
400 write_memory (sp
, tmp_buffer
, wordsize
);
402 /* Point the inferior function call's return address at the dummy's
404 regcache_raw_write_signed (regcache
, tdep
->ppc_lr_regnum
, bp_addr
);
406 /* Set the TOC register value. */
407 regcache_raw_write_signed (regcache
, tdep
->ppc_toc_regnum
,
408 solib_aix_get_toc_value (func_addr
));
410 target_store_registers (regcache
, -1);
414 static enum return_value_convention
415 rs6000_return_value (struct gdbarch
*gdbarch
, struct value
*function
,
416 struct type
*valtype
, struct regcache
*regcache
,
417 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
419 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
420 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
422 /* The calling convention this function implements assumes the
423 processor has floating-point registers. We shouldn't be using it
424 on PowerPC variants that lack them. */
425 gdb_assert (ppc_floating_point_unit_p (gdbarch
));
427 /* AltiVec extension: Functions that declare a vector data type as a
428 return value place that return value in VR2. */
429 if (TYPE_CODE (valtype
) == TYPE_CODE_ARRAY
&& TYPE_VECTOR (valtype
)
430 && TYPE_LENGTH (valtype
) == 16)
433 regcache_cooked_read (regcache
, tdep
->ppc_vr0_regnum
+ 2, readbuf
);
435 regcache_cooked_write (regcache
, tdep
->ppc_vr0_regnum
+ 2, writebuf
);
437 return RETURN_VALUE_REGISTER_CONVENTION
;
440 /* If the called subprogram returns an aggregate, there exists an
441 implicit first argument, whose value is the address of a caller-
442 allocated buffer into which the callee is assumed to store its
443 return value. All explicit parameters are appropriately
445 if (TYPE_CODE (valtype
) == TYPE_CODE_STRUCT
446 || TYPE_CODE (valtype
) == TYPE_CODE_UNION
447 || TYPE_CODE (valtype
) == TYPE_CODE_ARRAY
)
448 return RETURN_VALUE_STRUCT_CONVENTION
;
450 /* Scalar floating-point values are returned in FPR1 for float or
451 double, and in FPR1:FPR2 for quadword precision. Fortran
452 complex*8 and complex*16 are returned in FPR1:FPR2, and
453 complex*32 is returned in FPR1:FPR4. */
454 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
455 && (TYPE_LENGTH (valtype
) == 4 || TYPE_LENGTH (valtype
) == 8))
457 struct type
*regtype
= register_type (gdbarch
, tdep
->ppc_fp0_regnum
);
460 /* FIXME: kettenis/2007-01-01: Add support for quadword
461 precision and complex. */
465 regcache_cooked_read (regcache
, tdep
->ppc_fp0_regnum
+ 1, regval
);
466 convert_typed_floating (regval
, regtype
, readbuf
, valtype
);
470 convert_typed_floating (writebuf
, valtype
, regval
, regtype
);
471 regcache_cooked_write (regcache
, tdep
->ppc_fp0_regnum
+ 1, regval
);
474 return RETURN_VALUE_REGISTER_CONVENTION
;
477 /* Values of the types int, long, short, pointer, and char (length
478 is less than or equal to four bytes), as well as bit values of
479 lengths less than or equal to 32 bits, must be returned right
480 justified in GPR3 with signed values sign extended and unsigned
481 values zero extended, as necessary. */
482 if (TYPE_LENGTH (valtype
) <= tdep
->wordsize
)
488 /* For reading we don't have to worry about sign extension. */
489 regcache_cooked_read_unsigned (regcache
, tdep
->ppc_gp0_regnum
+ 3,
491 store_unsigned_integer (readbuf
, TYPE_LENGTH (valtype
), byte_order
,
496 /* For writing, use unpack_long since that should handle any
497 required sign extension. */
498 regcache_cooked_write_unsigned (regcache
, tdep
->ppc_gp0_regnum
+ 3,
499 unpack_long (valtype
, writebuf
));
502 return RETURN_VALUE_REGISTER_CONVENTION
;
505 /* Eight-byte non-floating-point scalar values must be returned in
508 if (TYPE_LENGTH (valtype
) == 8)
510 gdb_assert (TYPE_CODE (valtype
) != TYPE_CODE_FLT
);
511 gdb_assert (tdep
->wordsize
== 4);
517 regcache_cooked_read (regcache
, tdep
->ppc_gp0_regnum
+ 3, regval
);
518 regcache_cooked_read (regcache
, tdep
->ppc_gp0_regnum
+ 4,
520 memcpy (readbuf
, regval
, 8);
524 regcache_cooked_write (regcache
, tdep
->ppc_gp0_regnum
+ 3, writebuf
);
525 regcache_cooked_write (regcache
, tdep
->ppc_gp0_regnum
+ 4,
529 return RETURN_VALUE_REGISTER_CONVENTION
;
532 return RETURN_VALUE_STRUCT_CONVENTION
;
535 /* Support for CONVERT_FROM_FUNC_PTR_ADDR (ARCH, ADDR, TARG).
537 Usually a function pointer's representation is simply the address
538 of the function. On the RS/6000 however, a function pointer is
539 represented by a pointer to an OPD entry. This OPD entry contains
540 three words, the first word is the address of the function, the
541 second word is the TOC pointer (r2), and the third word is the
542 static chain value. Throughout GDB it is currently assumed that a
543 function pointer contains the address of the function, which is not
544 easy to fix. In addition, the conversion of a function address to
545 a function pointer would require allocation of an OPD entry in the
546 inferior's memory space, with all its drawbacks. To be able to
547 call C++ virtual methods in the inferior (which are called via
548 function pointers), find_function_addr uses this function to get the
549 function address from a function pointer. */
551 /* Return real function address if ADDR (a function pointer) is in the data
552 space and is therefore a special function pointer. */
555 rs6000_convert_from_func_ptr_addr (struct gdbarch
*gdbarch
,
557 struct target_ops
*targ
)
559 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
560 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
561 struct obj_section
*s
;
563 s
= find_pc_section (addr
);
565 /* Normally, functions live inside a section that is executable.
566 So, if ADDR points to a non-executable section, then treat it
567 as a function descriptor and return the target address iff
568 the target address itself points to a section that is executable. */
569 if (s
&& (s
->the_bfd_section
->flags
& SEC_CODE
) == 0)
572 struct obj_section
*pc_section
;
576 pc
= read_memory_unsigned_integer (addr
, tdep
->wordsize
, byte_order
);
578 CATCH (e
, RETURN_MASK_ERROR
)
580 /* An error occured during reading. Probably a memory error
581 due to the section not being loaded yet. This address
582 cannot be a function descriptor. */
587 pc_section
= find_pc_section (pc
);
589 if (pc_section
&& (pc_section
->the_bfd_section
->flags
& SEC_CODE
))
597 /* Calculate the destination of a branch/jump. Return -1 if not a branch. */
600 branch_dest (struct regcache
*regcache
, int opcode
, int instr
,
601 CORE_ADDR pc
, CORE_ADDR safety
)
603 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
604 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
605 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
611 absolute
= (int) ((instr
>> 1) & 1);
616 immediate
= ((instr
& ~3) << 6) >> 6; /* br unconditional */
620 dest
= pc
+ immediate
;
624 immediate
= ((instr
& ~3) << 16) >> 16; /* br conditional */
628 dest
= pc
+ immediate
;
632 ext_op
= (instr
>> 1) & 0x3ff;
634 if (ext_op
== 16) /* br conditional register */
636 dest
= regcache_raw_get_unsigned (regcache
, tdep
->ppc_lr_regnum
) & ~3;
638 /* If we are about to return from a signal handler, dest is
639 something like 0x3c90. The current frame is a signal handler
640 caller frame, upon completion of the sigreturn system call
641 execution will return to the saved PC in the frame. */
642 if (dest
< AIX_TEXT_SEGMENT_BASE
)
644 struct frame_info
*frame
= get_current_frame ();
646 dest
= read_memory_unsigned_integer
647 (get_frame_base (frame
) + SIG_FRAME_PC_OFFSET
,
648 tdep
->wordsize
, byte_order
);
652 else if (ext_op
== 528) /* br cond to count reg */
654 dest
= regcache_raw_get_unsigned (regcache
,
655 tdep
->ppc_ctr_regnum
) & ~3;
657 /* If we are about to execute a system call, dest is something
658 like 0x22fc or 0x3b00. Upon completion the system call
659 will return to the address in the link register. */
660 if (dest
< AIX_TEXT_SEGMENT_BASE
)
661 dest
= regcache_raw_get_unsigned (regcache
,
662 tdep
->ppc_lr_regnum
) & ~3;
671 return (dest
< AIX_TEXT_SEGMENT_BASE
) ? safety
: dest
;
674 /* AIX does not support PT_STEP. Simulate it. */
676 static VEC (CORE_ADDR
) *
677 rs6000_software_single_step (struct frame_info
*frame
)
679 struct regcache
*regcache
= get_current_regcache ();
680 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
681 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
686 VEC (CORE_ADDR
) *next_pcs
;
688 loc
= regcache_read_pc (regcache
);
690 insn
= read_memory_integer (loc
, 4, byte_order
);
692 next_pcs
= ppc_deal_with_atomic_sequence (frame
);
693 if (next_pcs
!= NULL
)
696 breaks
[0] = loc
+ PPC_INSN_SIZE
;
698 breaks
[1] = branch_dest (regcache
, opcode
, insn
, loc
, breaks
[0]);
700 /* Don't put two breakpoints on the same address. */
701 if (breaks
[1] == breaks
[0])
704 for (ii
= 0; ii
< 2; ++ii
)
706 /* ignore invalid breakpoint. */
707 if (breaks
[ii
] == -1)
709 VEC_safe_push (CORE_ADDR
, next_pcs
, breaks
[ii
]);
712 errno
= 0; /* FIXME, don't ignore errors! */
713 /* What errors? {read,write}_memory call error(). */
717 /* Implement the "auto_wide_charset" gdbarch method for this platform. */
720 rs6000_aix_auto_wide_charset (void)
725 /* Implement an osabi sniffer for RS6000/AIX.
727 This function assumes that ABFD's flavour is XCOFF. In other words,
728 it should be registered as a sniffer for bfd_target_xcoff_flavour
729 objfiles only. A failed assertion will be raised if this condition
732 static enum gdb_osabi
733 rs6000_aix_osabi_sniffer (bfd
*abfd
)
735 gdb_assert (bfd_get_flavour (abfd
) == bfd_target_xcoff_flavour
);
737 /* The only noticeable difference between Lynx178 XCOFF files and
738 AIX XCOFF files comes from the fact that there are no shared
739 libraries on Lynx178. On AIX, we are betting that an executable
740 linked with no shared library will never exist. */
741 if (xcoff_get_n_import_files (abfd
) <= 0)
742 return GDB_OSABI_UNKNOWN
;
744 return GDB_OSABI_AIX
;
747 /* A structure encoding the offset and size of a field within
756 /* A structure describing the layout of all the fields of interest
757 in AIX's struct ld_info. Each field in this struct corresponds
758 to the field of the same name in struct ld_info. */
762 struct field_info ldinfo_next
;
763 struct field_info ldinfo_fd
;
764 struct field_info ldinfo_textorg
;
765 struct field_info ldinfo_textsize
;
766 struct field_info ldinfo_dataorg
;
767 struct field_info ldinfo_datasize
;
768 struct field_info ldinfo_filename
;
771 /* The following data has been generated by compiling and running
772 the following program on AIX 5.3. */
777 #define __LDINFO_PTRACE32__
778 #define __LDINFO_PTRACE64__
781 #define pinfo(type,member) \
783 struct type ldi = {0}; \
785 printf (" {%d, %d},\t/* %s */\n", \
786 offsetof (struct type, member), \
787 sizeof (ldi.member), \
795 printf ("static const struct ld_info_desc ld_info32_desc =\n{\n");
796 pinfo (__ld_info32
, ldinfo_next
);
797 pinfo (__ld_info32
, ldinfo_fd
);
798 pinfo (__ld_info32
, ldinfo_textorg
);
799 pinfo (__ld_info32
, ldinfo_textsize
);
800 pinfo (__ld_info32
, ldinfo_dataorg
);
801 pinfo (__ld_info32
, ldinfo_datasize
);
802 pinfo (__ld_info32
, ldinfo_filename
);
807 printf ("static const struct ld_info_desc ld_info64_desc =\n{\n");
808 pinfo (__ld_info64
, ldinfo_next
);
809 pinfo (__ld_info64
, ldinfo_fd
);
810 pinfo (__ld_info64
, ldinfo_textorg
);
811 pinfo (__ld_info64
, ldinfo_textsize
);
812 pinfo (__ld_info64
, ldinfo_dataorg
);
813 pinfo (__ld_info64
, ldinfo_datasize
);
814 pinfo (__ld_info64
, ldinfo_filename
);
821 /* Layout of the 32bit version of struct ld_info. */
823 static const struct ld_info_desc ld_info32_desc
=
825 {0, 4}, /* ldinfo_next */
826 {4, 4}, /* ldinfo_fd */
827 {8, 4}, /* ldinfo_textorg */
828 {12, 4}, /* ldinfo_textsize */
829 {16, 4}, /* ldinfo_dataorg */
830 {20, 4}, /* ldinfo_datasize */
831 {24, 2}, /* ldinfo_filename */
834 /* Layout of the 64bit version of struct ld_info. */
836 static const struct ld_info_desc ld_info64_desc
=
838 {0, 4}, /* ldinfo_next */
839 {8, 4}, /* ldinfo_fd */
840 {16, 8}, /* ldinfo_textorg */
841 {24, 8}, /* ldinfo_textsize */
842 {32, 8}, /* ldinfo_dataorg */
843 {40, 8}, /* ldinfo_datasize */
844 {48, 2}, /* ldinfo_filename */
847 /* A structured representation of one entry read from the ld_info
848 binary data provided by the AIX loader. */
862 /* Return a struct ld_info object corresponding to the entry at
865 Note that the filename and member_name strings still point
866 to the data in LDI_BUF. So LDI_BUF must not be deallocated
867 while the struct ld_info object returned is in use. */
869 static struct ld_info
870 rs6000_aix_extract_ld_info (struct gdbarch
*gdbarch
,
871 const gdb_byte
*ldi_buf
)
873 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
874 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
875 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
876 const struct ld_info_desc desc
877 = tdep
->wordsize
== 8 ? ld_info64_desc
: ld_info32_desc
;
880 info
.next
= extract_unsigned_integer (ldi_buf
+ desc
.ldinfo_next
.offset
,
881 desc
.ldinfo_next
.size
,
883 info
.fd
= extract_signed_integer (ldi_buf
+ desc
.ldinfo_fd
.offset
,
886 info
.textorg
= extract_typed_address (ldi_buf
+ desc
.ldinfo_textorg
.offset
,
889 = extract_unsigned_integer (ldi_buf
+ desc
.ldinfo_textsize
.offset
,
890 desc
.ldinfo_textsize
.size
,
892 info
.dataorg
= extract_typed_address (ldi_buf
+ desc
.ldinfo_dataorg
.offset
,
895 = extract_unsigned_integer (ldi_buf
+ desc
.ldinfo_datasize
.offset
,
896 desc
.ldinfo_datasize
.size
,
898 info
.filename
= (char *) ldi_buf
+ desc
.ldinfo_filename
.offset
;
899 info
.member_name
= info
.filename
+ strlen (info
.filename
) + 1;
904 /* Append to OBJSTACK an XML string description of the shared library
905 corresponding to LDI, following the TARGET_OBJECT_LIBRARIES_AIX
909 rs6000_aix_shared_library_to_xml (struct ld_info
*ldi
,
910 struct obstack
*obstack
)
914 obstack_grow_str (obstack
, "<library name=\"");
915 p
= xml_escape_text (ldi
->filename
);
916 obstack_grow_str (obstack
, p
);
918 obstack_grow_str (obstack
, "\"");
920 if (ldi
->member_name
[0] != '\0')
922 obstack_grow_str (obstack
, " member=\"");
923 p
= xml_escape_text (ldi
->member_name
);
924 obstack_grow_str (obstack
, p
);
926 obstack_grow_str (obstack
, "\"");
929 obstack_grow_str (obstack
, " text_addr=\"");
930 obstack_grow_str (obstack
, core_addr_to_string (ldi
->textorg
));
931 obstack_grow_str (obstack
, "\"");
933 obstack_grow_str (obstack
, " text_size=\"");
934 obstack_grow_str (obstack
, pulongest (ldi
->textsize
));
935 obstack_grow_str (obstack
, "\"");
937 obstack_grow_str (obstack
, " data_addr=\"");
938 obstack_grow_str (obstack
, core_addr_to_string (ldi
->dataorg
));
939 obstack_grow_str (obstack
, "\"");
941 obstack_grow_str (obstack
, " data_size=\"");
942 obstack_grow_str (obstack
, pulongest (ldi
->datasize
));
943 obstack_grow_str (obstack
, "\"");
945 obstack_grow_str (obstack
, "></library>");
948 /* Convert the ld_info binary data provided by the AIX loader into
949 an XML representation following the TARGET_OBJECT_LIBRARIES_AIX
952 LDI_BUF is a buffer containing the ld_info data.
953 READBUF, OFFSET and LEN follow the same semantics as target_ops'
954 to_xfer_partial target_ops method.
956 If CLOSE_LDINFO_FD is nonzero, then this routine also closes
957 the ldinfo_fd file descriptor. This is useful when the ldinfo
958 data is obtained via ptrace, as ptrace opens a file descriptor
959 for each and every entry; but we cannot use this descriptor
960 as the consumer of the XML library list might live in a different
964 rs6000_aix_ld_info_to_xml (struct gdbarch
*gdbarch
, const gdb_byte
*ldi_buf
,
965 gdb_byte
*readbuf
, ULONGEST offset
, ULONGEST len
,
968 struct obstack obstack
;
972 obstack_init (&obstack
);
973 obstack_grow_str (&obstack
, "<library-list-aix version=\"1.0\">\n");
977 struct ld_info ldi
= rs6000_aix_extract_ld_info (gdbarch
, ldi_buf
);
979 rs6000_aix_shared_library_to_xml (&ldi
, &obstack
);
985 ldi_buf
= ldi_buf
+ ldi
.next
;
988 obstack_grow_str0 (&obstack
, "</library-list-aix>\n");
990 buf
= (const char *) obstack_finish (&obstack
);
991 len_avail
= strlen (buf
);
992 if (offset
>= len_avail
)
996 if (len
> len_avail
- offset
)
997 len
= len_avail
- offset
;
998 memcpy (readbuf
, buf
+ offset
, len
);
1001 obstack_free (&obstack
, NULL
);
1005 /* Implement the core_xfer_shared_libraries_aix gdbarch method. */
1008 rs6000_aix_core_xfer_shared_libraries_aix (struct gdbarch
*gdbarch
,
1013 struct bfd_section
*ldinfo_sec
;
1015 gdb_byte
*ldinfo_buf
;
1016 struct cleanup
*cleanup
;
1019 ldinfo_sec
= bfd_get_section_by_name (core_bfd
, ".ldinfo");
1020 if (ldinfo_sec
== NULL
)
1021 error (_("cannot find .ldinfo section from core file: %s"),
1022 bfd_errmsg (bfd_get_error ()));
1023 ldinfo_size
= bfd_get_section_size (ldinfo_sec
);
1025 ldinfo_buf
= (gdb_byte
*) xmalloc (ldinfo_size
);
1026 cleanup
= make_cleanup (xfree
, ldinfo_buf
);
1028 if (! bfd_get_section_contents (core_bfd
, ldinfo_sec
,
1029 ldinfo_buf
, 0, ldinfo_size
))
1030 error (_("unable to read .ldinfo section from core file: %s"),
1031 bfd_errmsg (bfd_get_error ()));
1033 result
= rs6000_aix_ld_info_to_xml (gdbarch
, ldinfo_buf
, readbuf
,
1036 do_cleanups (cleanup
);
1041 rs6000_aix_init_osabi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
1043 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1045 /* RS6000/AIX does not support PT_STEP. Has to be simulated. */
1046 set_gdbarch_software_single_step (gdbarch
, rs6000_software_single_step
);
1048 /* Displaced stepping is currently not supported in combination with
1049 software single-stepping. */
1050 set_gdbarch_displaced_step_copy_insn (gdbarch
, NULL
);
1051 set_gdbarch_displaced_step_fixup (gdbarch
, NULL
);
1052 set_gdbarch_displaced_step_free_closure (gdbarch
, NULL
);
1053 set_gdbarch_displaced_step_location (gdbarch
, NULL
);
1055 set_gdbarch_push_dummy_call (gdbarch
, rs6000_push_dummy_call
);
1056 set_gdbarch_return_value (gdbarch
, rs6000_return_value
);
1057 set_gdbarch_long_double_bit (gdbarch
, 8 * TARGET_CHAR_BIT
);
1059 /* Handle RS/6000 function pointers (which are really function
1061 set_gdbarch_convert_from_func_ptr_addr
1062 (gdbarch
, rs6000_convert_from_func_ptr_addr
);
1064 /* Core file support. */
1065 set_gdbarch_iterate_over_regset_sections
1066 (gdbarch
, rs6000_aix_iterate_over_regset_sections
);
1067 set_gdbarch_core_xfer_shared_libraries_aix
1068 (gdbarch
, rs6000_aix_core_xfer_shared_libraries_aix
);
1070 if (tdep
->wordsize
== 8)
1071 tdep
->lr_frame_offset
= 16;
1073 tdep
->lr_frame_offset
= 8;
1075 if (tdep
->wordsize
== 4)
1076 /* PowerOpen / AIX 32 bit. The saved area or red zone consists of
1077 19 4 byte GPRS + 18 8 byte FPRs giving a total of 220 bytes.
1078 Problem is, 220 isn't frame (16 byte) aligned. Round it up to
1080 set_gdbarch_frame_red_zone_size (gdbarch
, 224);
1082 set_gdbarch_frame_red_zone_size (gdbarch
, 0);
1084 set_gdbarch_auto_wide_charset (gdbarch
, rs6000_aix_auto_wide_charset
);
1086 set_solib_ops (gdbarch
, &solib_aix_so_ops
);
1089 /* Provide a prototype to silence -Wmissing-prototypes. */
1090 extern initialize_file_ftype _initialize_rs6000_aix_tdep
;
1093 _initialize_rs6000_aix_tdep (void)
1095 gdbarch_register_osabi_sniffer (bfd_arch_rs6000
,
1096 bfd_target_xcoff_flavour
,
1097 rs6000_aix_osabi_sniffer
);
1098 gdbarch_register_osabi_sniffer (bfd_arch_powerpc
,
1099 bfd_target_xcoff_flavour
,
1100 rs6000_aix_osabi_sniffer
);
1102 gdbarch_register_osabi (bfd_arch_rs6000
, 0, GDB_OSABI_AIX
,
1103 rs6000_aix_init_osabi
);
1104 gdbarch_register_osabi (bfd_arch_powerpc
, 0, GDB_OSABI_AIX
,
1105 rs6000_aix_init_osabi
);