1 /* Native support code for PPC AIX, for GDB the GNU debugger.
3 Copyright (C) 2006-2015 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 int adj
= gdbarch_byte_order (gdbarch
)
294 == BFD_ENDIAN_BIG
? reg_size
- len
: 0;
295 gdb_byte word
[MAX_REGISTER_SIZE
];
297 memset (word
, 0, reg_size
);
298 memcpy (word
, value_contents (arg
), len
);
299 regcache_cooked_write (regcache
, tdep
->ppc_gp0_regnum
+ 3 +ii
, word
);
304 ran_out_of_registers_for_arguments
:
306 regcache_cooked_read_unsigned (regcache
,
307 gdbarch_sp_regnum (gdbarch
),
310 /* Location for 8 parameters are always reserved. */
313 /* Another six words for back chain, TOC register, link register, etc. */
316 /* Stack pointer must be quadword aligned. */
319 /* If there are more arguments, allocate space for them in
320 the stack, then push them starting from the ninth one. */
322 if ((argno
< nargs
) || argbytes
)
328 space
+= ((len
- argbytes
+ 3) & -4);
334 for (; jj
< nargs
; ++jj
)
336 struct value
*val
= args
[jj
];
337 space
+= ((TYPE_LENGTH (value_type (val
))) + 3) & -4;
340 /* Add location required for the rest of the parameters. */
341 space
= (space
+ 15) & -16;
344 /* This is another instance we need to be concerned about
345 securing our stack space. If we write anything underneath %sp
346 (r1), we might conflict with the kernel who thinks he is free
347 to use this area. So, update %sp first before doing anything
350 regcache_raw_write_signed (regcache
,
351 gdbarch_sp_regnum (gdbarch
), sp
);
353 /* If the last argument copied into the registers didn't fit there
354 completely, push the rest of it into stack. */
358 write_memory (sp
+ 24 + (ii
* 4),
359 value_contents (arg
) + argbytes
,
362 ii
+= ((len
- argbytes
+ 3) & -4) / 4;
365 /* Push the rest of the arguments into stack. */
366 for (; argno
< nargs
; ++argno
)
370 type
= check_typedef (value_type (arg
));
371 len
= TYPE_LENGTH (type
);
374 /* Float types should be passed in fpr's, as well as in the
376 if (TYPE_CODE (type
) == TYPE_CODE_FLT
&& f_argno
< 13)
379 gdb_assert (len
<= 8);
381 regcache_cooked_write (regcache
,
382 tdep
->ppc_fp0_regnum
+ 1 + f_argno
,
383 value_contents (arg
));
387 write_memory (sp
+ 24 + (ii
* 4), value_contents (arg
), len
);
388 ii
+= ((len
+ 3) & -4) / 4;
392 /* Set the stack pointer. According to the ABI, the SP is meant to
393 be set _before_ the corresponding stack space is used. On AIX,
394 this even applies when the target has been completely stopped!
395 Not doing this can lead to conflicts with the kernel which thinks
396 that it still has control over this not-yet-allocated stack
398 regcache_raw_write_signed (regcache
, gdbarch_sp_regnum (gdbarch
), sp
);
400 /* Set back chain properly. */
401 store_unsigned_integer (tmp_buffer
, wordsize
, byte_order
, saved_sp
);
402 write_memory (sp
, tmp_buffer
, wordsize
);
404 /* Point the inferior function call's return address at the dummy's
406 regcache_raw_write_signed (regcache
, tdep
->ppc_lr_regnum
, bp_addr
);
408 /* Set the TOC register value. */
409 regcache_raw_write_signed (regcache
, tdep
->ppc_toc_regnum
,
410 solib_aix_get_toc_value (func_addr
));
412 target_store_registers (regcache
, -1);
416 static enum return_value_convention
417 rs6000_return_value (struct gdbarch
*gdbarch
, struct value
*function
,
418 struct type
*valtype
, struct regcache
*regcache
,
419 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
421 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
422 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
424 /* The calling convention this function implements assumes the
425 processor has floating-point registers. We shouldn't be using it
426 on PowerPC variants that lack them. */
427 gdb_assert (ppc_floating_point_unit_p (gdbarch
));
429 /* AltiVec extension: Functions that declare a vector data type as a
430 return value place that return value in VR2. */
431 if (TYPE_CODE (valtype
) == TYPE_CODE_ARRAY
&& TYPE_VECTOR (valtype
)
432 && TYPE_LENGTH (valtype
) == 16)
435 regcache_cooked_read (regcache
, tdep
->ppc_vr0_regnum
+ 2, readbuf
);
437 regcache_cooked_write (regcache
, tdep
->ppc_vr0_regnum
+ 2, writebuf
);
439 return RETURN_VALUE_REGISTER_CONVENTION
;
442 /* If the called subprogram returns an aggregate, there exists an
443 implicit first argument, whose value is the address of a caller-
444 allocated buffer into which the callee is assumed to store its
445 return value. All explicit parameters are appropriately
447 if (TYPE_CODE (valtype
) == TYPE_CODE_STRUCT
448 || TYPE_CODE (valtype
) == TYPE_CODE_UNION
449 || TYPE_CODE (valtype
) == TYPE_CODE_ARRAY
)
450 return RETURN_VALUE_STRUCT_CONVENTION
;
452 /* Scalar floating-point values are returned in FPR1 for float or
453 double, and in FPR1:FPR2 for quadword precision. Fortran
454 complex*8 and complex*16 are returned in FPR1:FPR2, and
455 complex*32 is returned in FPR1:FPR4. */
456 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
457 && (TYPE_LENGTH (valtype
) == 4 || TYPE_LENGTH (valtype
) == 8))
459 struct type
*regtype
= register_type (gdbarch
, tdep
->ppc_fp0_regnum
);
462 /* FIXME: kettenis/2007-01-01: Add support for quadword
463 precision and complex. */
467 regcache_cooked_read (regcache
, tdep
->ppc_fp0_regnum
+ 1, regval
);
468 convert_typed_floating (regval
, regtype
, readbuf
, valtype
);
472 convert_typed_floating (writebuf
, valtype
, regval
, regtype
);
473 regcache_cooked_write (regcache
, tdep
->ppc_fp0_regnum
+ 1, regval
);
476 return RETURN_VALUE_REGISTER_CONVENTION
;
479 /* Values of the types int, long, short, pointer, and char (length
480 is less than or equal to four bytes), as well as bit values of
481 lengths less than or equal to 32 bits, must be returned right
482 justified in GPR3 with signed values sign extended and unsigned
483 values zero extended, as necessary. */
484 if (TYPE_LENGTH (valtype
) <= tdep
->wordsize
)
490 /* For reading we don't have to worry about sign extension. */
491 regcache_cooked_read_unsigned (regcache
, tdep
->ppc_gp0_regnum
+ 3,
493 store_unsigned_integer (readbuf
, TYPE_LENGTH (valtype
), byte_order
,
498 /* For writing, use unpack_long since that should handle any
499 required sign extension. */
500 regcache_cooked_write_unsigned (regcache
, tdep
->ppc_gp0_regnum
+ 3,
501 unpack_long (valtype
, writebuf
));
504 return RETURN_VALUE_REGISTER_CONVENTION
;
507 /* Eight-byte non-floating-point scalar values must be returned in
510 if (TYPE_LENGTH (valtype
) == 8)
512 gdb_assert (TYPE_CODE (valtype
) != TYPE_CODE_FLT
);
513 gdb_assert (tdep
->wordsize
== 4);
519 regcache_cooked_read (regcache
, tdep
->ppc_gp0_regnum
+ 3, regval
);
520 regcache_cooked_read (regcache
, tdep
->ppc_gp0_regnum
+ 4,
522 memcpy (readbuf
, regval
, 8);
526 regcache_cooked_write (regcache
, tdep
->ppc_gp0_regnum
+ 3, writebuf
);
527 regcache_cooked_write (regcache
, tdep
->ppc_gp0_regnum
+ 4,
531 return RETURN_VALUE_REGISTER_CONVENTION
;
534 return RETURN_VALUE_STRUCT_CONVENTION
;
537 /* Support for CONVERT_FROM_FUNC_PTR_ADDR (ARCH, ADDR, TARG).
539 Usually a function pointer's representation is simply the address
540 of the function. On the RS/6000 however, a function pointer is
541 represented by a pointer to an OPD entry. This OPD entry contains
542 three words, the first word is the address of the function, the
543 second word is the TOC pointer (r2), and the third word is the
544 static chain value. Throughout GDB it is currently assumed that a
545 function pointer contains the address of the function, which is not
546 easy to fix. In addition, the conversion of a function address to
547 a function pointer would require allocation of an OPD entry in the
548 inferior's memory space, with all its drawbacks. To be able to
549 call C++ virtual methods in the inferior (which are called via
550 function pointers), find_function_addr uses this function to get the
551 function address from a function pointer. */
553 /* Return real function address if ADDR (a function pointer) is in the data
554 space and is therefore a special function pointer. */
557 rs6000_convert_from_func_ptr_addr (struct gdbarch
*gdbarch
,
559 struct target_ops
*targ
)
561 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
562 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
563 struct obj_section
*s
;
565 s
= find_pc_section (addr
);
567 /* Normally, functions live inside a section that is executable.
568 So, if ADDR points to a non-executable section, then treat it
569 as a function descriptor and return the target address iff
570 the target address itself points to a section that is executable. */
571 if (s
&& (s
->the_bfd_section
->flags
& SEC_CODE
) == 0)
574 struct obj_section
*pc_section
;
578 pc
= read_memory_unsigned_integer (addr
, tdep
->wordsize
, byte_order
);
580 CATCH (e
, RETURN_MASK_ERROR
)
582 /* An error occured during reading. Probably a memory error
583 due to the section not being loaded yet. This address
584 cannot be a function descriptor. */
589 pc_section
= find_pc_section (pc
);
591 if (pc_section
&& (pc_section
->the_bfd_section
->flags
& SEC_CODE
))
599 /* Calculate the destination of a branch/jump. Return -1 if not a branch. */
602 branch_dest (struct frame_info
*frame
, int opcode
, int instr
,
603 CORE_ADDR pc
, CORE_ADDR safety
)
605 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
606 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
607 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
613 absolute
= (int) ((instr
>> 1) & 1);
618 immediate
= ((instr
& ~3) << 6) >> 6; /* br unconditional */
622 dest
= pc
+ immediate
;
626 immediate
= ((instr
& ~3) << 16) >> 16; /* br conditional */
630 dest
= pc
+ immediate
;
634 ext_op
= (instr
>> 1) & 0x3ff;
636 if (ext_op
== 16) /* br conditional register */
638 dest
= get_frame_register_unsigned (frame
, tdep
->ppc_lr_regnum
) & ~3;
640 /* If we are about to return from a signal handler, dest is
641 something like 0x3c90. The current frame is a signal handler
642 caller frame, upon completion of the sigreturn system call
643 execution will return to the saved PC in the frame. */
644 if (dest
< AIX_TEXT_SEGMENT_BASE
)
645 dest
= read_memory_unsigned_integer
646 (get_frame_base (frame
) + SIG_FRAME_PC_OFFSET
,
647 tdep
->wordsize
, byte_order
);
650 else if (ext_op
== 528) /* br cond to count reg */
652 dest
= get_frame_register_unsigned (frame
,
653 tdep
->ppc_ctr_regnum
) & ~3;
655 /* If we are about to execute a system call, dest is something
656 like 0x22fc or 0x3b00. Upon completion the system call
657 will return to the address in the link register. */
658 if (dest
< AIX_TEXT_SEGMENT_BASE
)
659 dest
= get_frame_register_unsigned (frame
,
660 tdep
->ppc_lr_regnum
) & ~3;
669 return (dest
< AIX_TEXT_SEGMENT_BASE
) ? safety
: dest
;
672 /* AIX does not support PT_STEP. Simulate it. */
675 rs6000_software_single_step (struct frame_info
*frame
)
677 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
678 struct address_space
*aspace
= get_frame_address_space (frame
);
679 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
685 loc
= get_frame_pc (frame
);
687 insn
= read_memory_integer (loc
, 4, byte_order
);
689 if (ppc_deal_with_atomic_sequence (frame
))
692 breaks
[0] = loc
+ PPC_INSN_SIZE
;
694 breaks
[1] = branch_dest (frame
, opcode
, insn
, loc
, breaks
[0]);
696 /* Don't put two breakpoints on the same address. */
697 if (breaks
[1] == breaks
[0])
700 for (ii
= 0; ii
< 2; ++ii
)
702 /* ignore invalid breakpoint. */
703 if (breaks
[ii
] == -1)
705 insert_single_step_breakpoint (gdbarch
, aspace
, breaks
[ii
]);
708 errno
= 0; /* FIXME, don't ignore errors! */
709 /* What errors? {read,write}_memory call error(). */
713 /* Implement the "auto_wide_charset" gdbarch method for this platform. */
716 rs6000_aix_auto_wide_charset (void)
721 /* Implement an osabi sniffer for RS6000/AIX.
723 This function assumes that ABFD's flavour is XCOFF. In other words,
724 it should be registered as a sniffer for bfd_target_xcoff_flavour
725 objfiles only. A failed assertion will be raised if this condition
728 static enum gdb_osabi
729 rs6000_aix_osabi_sniffer (bfd
*abfd
)
731 gdb_assert (bfd_get_flavour (abfd
) == bfd_target_xcoff_flavour
);
733 /* The only noticeable difference between Lynx178 XCOFF files and
734 AIX XCOFF files comes from the fact that there are no shared
735 libraries on Lynx178. On AIX, we are betting that an executable
736 linked with no shared library will never exist. */
737 if (xcoff_get_n_import_files (abfd
) <= 0)
738 return GDB_OSABI_UNKNOWN
;
740 return GDB_OSABI_AIX
;
743 /* A structure encoding the offset and size of a field within
752 /* A structure describing the layout of all the fields of interest
753 in AIX's struct ld_info. Each field in this struct corresponds
754 to the field of the same name in struct ld_info. */
758 struct field_info ldinfo_next
;
759 struct field_info ldinfo_fd
;
760 struct field_info ldinfo_textorg
;
761 struct field_info ldinfo_textsize
;
762 struct field_info ldinfo_dataorg
;
763 struct field_info ldinfo_datasize
;
764 struct field_info ldinfo_filename
;
767 /* The following data has been generated by compiling and running
768 the following program on AIX 5.3. */
773 #define __LDINFO_PTRACE32__
774 #define __LDINFO_PTRACE64__
777 #define pinfo(type,member) \
779 struct type ldi = {0}; \
781 printf (" {%d, %d},\t/* %s */\n", \
782 offsetof (struct type, member), \
783 sizeof (ldi.member), \
791 printf ("static const struct ld_info_desc ld_info32_desc =\n{\n");
792 pinfo (__ld_info32
, ldinfo_next
);
793 pinfo (__ld_info32
, ldinfo_fd
);
794 pinfo (__ld_info32
, ldinfo_textorg
);
795 pinfo (__ld_info32
, ldinfo_textsize
);
796 pinfo (__ld_info32
, ldinfo_dataorg
);
797 pinfo (__ld_info32
, ldinfo_datasize
);
798 pinfo (__ld_info32
, ldinfo_filename
);
803 printf ("static const struct ld_info_desc ld_info64_desc =\n{\n");
804 pinfo (__ld_info64
, ldinfo_next
);
805 pinfo (__ld_info64
, ldinfo_fd
);
806 pinfo (__ld_info64
, ldinfo_textorg
);
807 pinfo (__ld_info64
, ldinfo_textsize
);
808 pinfo (__ld_info64
, ldinfo_dataorg
);
809 pinfo (__ld_info64
, ldinfo_datasize
);
810 pinfo (__ld_info64
, ldinfo_filename
);
817 /* Layout of the 32bit version of struct ld_info. */
819 static const struct ld_info_desc ld_info32_desc
=
821 {0, 4}, /* ldinfo_next */
822 {4, 4}, /* ldinfo_fd */
823 {8, 4}, /* ldinfo_textorg */
824 {12, 4}, /* ldinfo_textsize */
825 {16, 4}, /* ldinfo_dataorg */
826 {20, 4}, /* ldinfo_datasize */
827 {24, 2}, /* ldinfo_filename */
830 /* Layout of the 64bit version of struct ld_info. */
832 static const struct ld_info_desc ld_info64_desc
=
834 {0, 4}, /* ldinfo_next */
835 {8, 4}, /* ldinfo_fd */
836 {16, 8}, /* ldinfo_textorg */
837 {24, 8}, /* ldinfo_textsize */
838 {32, 8}, /* ldinfo_dataorg */
839 {40, 8}, /* ldinfo_datasize */
840 {48, 2}, /* ldinfo_filename */
843 /* A structured representation of one entry read from the ld_info
844 binary data provided by the AIX loader. */
858 /* Return a struct ld_info object corresponding to the entry at
861 Note that the filename and member_name strings still point
862 to the data in LDI_BUF. So LDI_BUF must not be deallocated
863 while the struct ld_info object returned is in use. */
865 static struct ld_info
866 rs6000_aix_extract_ld_info (struct gdbarch
*gdbarch
,
867 const gdb_byte
*ldi_buf
)
869 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
870 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
871 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
872 const struct ld_info_desc desc
873 = tdep
->wordsize
== 8 ? ld_info64_desc
: ld_info32_desc
;
876 info
.next
= extract_unsigned_integer (ldi_buf
+ desc
.ldinfo_next
.offset
,
877 desc
.ldinfo_next
.size
,
879 info
.fd
= extract_signed_integer (ldi_buf
+ desc
.ldinfo_fd
.offset
,
882 info
.textorg
= extract_typed_address (ldi_buf
+ desc
.ldinfo_textorg
.offset
,
885 = extract_unsigned_integer (ldi_buf
+ desc
.ldinfo_textsize
.offset
,
886 desc
.ldinfo_textsize
.size
,
888 info
.dataorg
= extract_typed_address (ldi_buf
+ desc
.ldinfo_dataorg
.offset
,
891 = extract_unsigned_integer (ldi_buf
+ desc
.ldinfo_datasize
.offset
,
892 desc
.ldinfo_datasize
.size
,
894 info
.filename
= (char *) ldi_buf
+ desc
.ldinfo_filename
.offset
;
895 info
.member_name
= info
.filename
+ strlen (info
.filename
) + 1;
900 /* Append to OBJSTACK an XML string description of the shared library
901 corresponding to LDI, following the TARGET_OBJECT_LIBRARIES_AIX
905 rs6000_aix_shared_library_to_xml (struct ld_info
*ldi
,
906 struct obstack
*obstack
)
910 obstack_grow_str (obstack
, "<library name=\"");
911 p
= xml_escape_text (ldi
->filename
);
912 obstack_grow_str (obstack
, p
);
914 obstack_grow_str (obstack
, "\"");
916 if (ldi
->member_name
[0] != '\0')
918 obstack_grow_str (obstack
, " member=\"");
919 p
= xml_escape_text (ldi
->member_name
);
920 obstack_grow_str (obstack
, p
);
922 obstack_grow_str (obstack
, "\"");
925 obstack_grow_str (obstack
, " text_addr=\"");
926 obstack_grow_str (obstack
, core_addr_to_string (ldi
->textorg
));
927 obstack_grow_str (obstack
, "\"");
929 obstack_grow_str (obstack
, " text_size=\"");
930 obstack_grow_str (obstack
, pulongest (ldi
->textsize
));
931 obstack_grow_str (obstack
, "\"");
933 obstack_grow_str (obstack
, " data_addr=\"");
934 obstack_grow_str (obstack
, core_addr_to_string (ldi
->dataorg
));
935 obstack_grow_str (obstack
, "\"");
937 obstack_grow_str (obstack
, " data_size=\"");
938 obstack_grow_str (obstack
, pulongest (ldi
->datasize
));
939 obstack_grow_str (obstack
, "\"");
941 obstack_grow_str (obstack
, "></library>");
944 /* Convert the ld_info binary data provided by the AIX loader into
945 an XML representation following the TARGET_OBJECT_LIBRARIES_AIX
948 LDI_BUF is a buffer containing the ld_info data.
949 READBUF, OFFSET and LEN follow the same semantics as target_ops'
950 to_xfer_partial target_ops method.
952 If CLOSE_LDINFO_FD is nonzero, then this routine also closes
953 the ldinfo_fd file descriptor. This is useful when the ldinfo
954 data is obtained via ptrace, as ptrace opens a file descriptor
955 for each and every entry; but we cannot use this descriptor
956 as the consumer of the XML library list might live in a different
960 rs6000_aix_ld_info_to_xml (struct gdbarch
*gdbarch
, const gdb_byte
*ldi_buf
,
961 gdb_byte
*readbuf
, ULONGEST offset
, ULONGEST len
,
964 struct obstack obstack
;
968 obstack_init (&obstack
);
969 obstack_grow_str (&obstack
, "<library-list-aix version=\"1.0\">\n");
973 struct ld_info ldi
= rs6000_aix_extract_ld_info (gdbarch
, ldi_buf
);
975 rs6000_aix_shared_library_to_xml (&ldi
, &obstack
);
981 ldi_buf
= ldi_buf
+ ldi
.next
;
984 obstack_grow_str0 (&obstack
, "</library-list-aix>\n");
986 buf
= obstack_finish (&obstack
);
987 len_avail
= strlen (buf
);
988 if (offset
>= len_avail
)
992 if (len
> len_avail
- offset
)
993 len
= len_avail
- offset
;
994 memcpy (readbuf
, buf
+ offset
, len
);
997 obstack_free (&obstack
, NULL
);
1001 /* Implement the core_xfer_shared_libraries_aix gdbarch method. */
1004 rs6000_aix_core_xfer_shared_libraries_aix (struct gdbarch
*gdbarch
,
1009 struct bfd_section
*ldinfo_sec
;
1011 gdb_byte
*ldinfo_buf
;
1012 struct cleanup
*cleanup
;
1015 ldinfo_sec
= bfd_get_section_by_name (core_bfd
, ".ldinfo");
1016 if (ldinfo_sec
== NULL
)
1017 error (_("cannot find .ldinfo section from core file: %s"),
1018 bfd_errmsg (bfd_get_error ()));
1019 ldinfo_size
= bfd_get_section_size (ldinfo_sec
);
1021 ldinfo_buf
= xmalloc (ldinfo_size
);
1022 cleanup
= make_cleanup (xfree
, ldinfo_buf
);
1024 if (! bfd_get_section_contents (core_bfd
, ldinfo_sec
,
1025 ldinfo_buf
, 0, ldinfo_size
))
1026 error (_("unable to read .ldinfo section from core file: %s"),
1027 bfd_errmsg (bfd_get_error ()));
1029 result
= rs6000_aix_ld_info_to_xml (gdbarch
, ldinfo_buf
, readbuf
,
1032 do_cleanups (cleanup
);
1037 rs6000_aix_init_osabi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
1039 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1041 /* RS6000/AIX does not support PT_STEP. Has to be simulated. */
1042 set_gdbarch_software_single_step (gdbarch
, rs6000_software_single_step
);
1044 /* Displaced stepping is currently not supported in combination with
1045 software single-stepping. */
1046 set_gdbarch_displaced_step_copy_insn (gdbarch
, NULL
);
1047 set_gdbarch_displaced_step_fixup (gdbarch
, NULL
);
1048 set_gdbarch_displaced_step_free_closure (gdbarch
, NULL
);
1049 set_gdbarch_displaced_step_location (gdbarch
, NULL
);
1051 set_gdbarch_push_dummy_call (gdbarch
, rs6000_push_dummy_call
);
1052 set_gdbarch_return_value (gdbarch
, rs6000_return_value
);
1053 set_gdbarch_long_double_bit (gdbarch
, 8 * TARGET_CHAR_BIT
);
1055 /* Handle RS/6000 function pointers (which are really function
1057 set_gdbarch_convert_from_func_ptr_addr
1058 (gdbarch
, rs6000_convert_from_func_ptr_addr
);
1060 /* Core file support. */
1061 set_gdbarch_iterate_over_regset_sections
1062 (gdbarch
, rs6000_aix_iterate_over_regset_sections
);
1063 set_gdbarch_core_xfer_shared_libraries_aix
1064 (gdbarch
, rs6000_aix_core_xfer_shared_libraries_aix
);
1066 if (tdep
->wordsize
== 8)
1067 tdep
->lr_frame_offset
= 16;
1069 tdep
->lr_frame_offset
= 8;
1071 if (tdep
->wordsize
== 4)
1072 /* PowerOpen / AIX 32 bit. The saved area or red zone consists of
1073 19 4 byte GPRS + 18 8 byte FPRs giving a total of 220 bytes.
1074 Problem is, 220 isn't frame (16 byte) aligned. Round it up to
1076 set_gdbarch_frame_red_zone_size (gdbarch
, 224);
1078 set_gdbarch_frame_red_zone_size (gdbarch
, 0);
1080 set_gdbarch_auto_wide_charset (gdbarch
, rs6000_aix_auto_wide_charset
);
1082 set_solib_ops (gdbarch
, &solib_aix_so_ops
);
1085 /* Provide a prototype to silence -Wmissing-prototypes. */
1086 extern initialize_file_ftype _initialize_rs6000_aix_tdep
;
1089 _initialize_rs6000_aix_tdep (void)
1091 gdbarch_register_osabi_sniffer (bfd_arch_rs6000
,
1092 bfd_target_xcoff_flavour
,
1093 rs6000_aix_osabi_sniffer
);
1094 gdbarch_register_osabi_sniffer (bfd_arch_powerpc
,
1095 bfd_target_xcoff_flavour
,
1096 rs6000_aix_osabi_sniffer
);
1098 gdbarch_register_osabi (bfd_arch_rs6000
, 0, GDB_OSABI_AIX
,
1099 rs6000_aix_init_osabi
);
1100 gdbarch_register_osabi (bfd_arch_powerpc
, 0, GDB_OSABI_AIX
,
1101 rs6000_aix_init_osabi
);