1 /* Native support code for PPC AIX, for GDB the GNU debugger.
3 Copyright (C) 2006-2014 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 "exceptions.h"
37 #include "xcoffread.h"
39 #include "solib-aix.h"
40 #include "xml-utils.h"
42 /* If the kernel has to deliver a signal, it pushes a sigcontext
43 structure on the stack and then calls the signal handler, passing
44 the address of the sigcontext in an argument register. Usually
45 the signal handler doesn't save this register, so we have to
46 access the sigcontext structure via an offset from the signal handler
48 The following constants were determined by experimentation on AIX 3.2. */
49 #define SIG_FRAME_PC_OFFSET 96
50 #define SIG_FRAME_LR_OFFSET 108
51 #define SIG_FRAME_FP_OFFSET 284
54 /* Core file support. */
56 static struct ppc_reg_offsets rs6000_aix32_reg_offsets
=
58 /* General-purpose registers. */
70 /* Floating-point registers. */
72 56, /* fpscr_offset */
75 /* AltiVec registers. */
78 -1 /* vrsave_offset */
81 static struct ppc_reg_offsets rs6000_aix64_reg_offsets
=
83 /* General-purpose registers. */
95 /* Floating-point registers. */
97 296, /* fpscr_offset */
100 /* AltiVec registers. */
102 -1, /* vscr_offset */
103 -1 /* vrsave_offset */
107 /* Supply register REGNUM in the general-purpose register set REGSET
108 from the buffer specified by GREGS and LEN to register cache
109 REGCACHE. If REGNUM is -1, do this for all registers in REGSET. */
112 rs6000_aix_supply_regset (const struct regset
*regset
,
113 struct regcache
*regcache
, int regnum
,
114 const void *gregs
, size_t len
)
116 ppc_supply_gregset (regset
, regcache
, regnum
, gregs
, len
);
117 ppc_supply_fpregset (regset
, regcache
, regnum
, gregs
, len
);
120 /* Collect register REGNUM in the general-purpose register set
121 REGSET, from register cache REGCACHE into the buffer specified by
122 GREGS and LEN. If REGNUM is -1, do this for all registers in
126 rs6000_aix_collect_regset (const struct regset
*regset
,
127 const struct regcache
*regcache
, int regnum
,
128 void *gregs
, size_t len
)
130 ppc_collect_gregset (regset
, regcache
, regnum
, gregs
, len
);
131 ppc_collect_fpregset (regset
, regcache
, regnum
, gregs
, len
);
134 /* AIX register set. */
136 static const struct regset rs6000_aix32_regset
=
138 &rs6000_aix32_reg_offsets
,
139 rs6000_aix_supply_regset
,
140 rs6000_aix_collect_regset
,
143 static const struct regset rs6000_aix64_regset
=
145 &rs6000_aix64_reg_offsets
,
146 rs6000_aix_supply_regset
,
147 rs6000_aix_collect_regset
,
150 /* Return the appropriate register set for the core section identified
151 by SECT_NAME and SECT_SIZE. */
153 static const struct regset
*
154 rs6000_aix_regset_from_core_section (struct gdbarch
*gdbarch
,
155 const char *sect_name
, size_t sect_size
)
157 if (gdbarch_tdep (gdbarch
)->wordsize
== 4)
159 if (strcmp (sect_name
, ".reg") == 0 && sect_size
>= 592)
160 return &rs6000_aix32_regset
;
164 if (strcmp (sect_name
, ".reg") == 0 && sect_size
>= 576)
165 return &rs6000_aix64_regset
;
172 /* Pass the arguments in either registers, or in the stack. In RS/6000,
173 the first eight words of the argument list (that might be less than
174 eight parameters if some parameters occupy more than one word) are
175 passed in r3..r10 registers. Float and double parameters are
176 passed in fpr's, in addition to that. Rest of the parameters if any
177 are passed in user stack. There might be cases in which half of the
178 parameter is copied into registers, the other half is pushed into
181 Stack must be aligned on 64-bit boundaries when synthesizing
184 If the function is returning a structure, then the return address is passed
185 in r3, then the first 7 words of the parameters can be passed in registers,
189 rs6000_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
190 struct regcache
*regcache
, CORE_ADDR bp_addr
,
191 int nargs
, struct value
**args
, CORE_ADDR sp
,
192 int struct_return
, CORE_ADDR struct_addr
)
194 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
195 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
198 int argno
; /* current argument number */
199 int argbytes
; /* current argument byte */
200 gdb_byte tmp_buffer
[50];
201 int f_argno
= 0; /* current floating point argno */
202 int wordsize
= gdbarch_tdep (gdbarch
)->wordsize
;
203 CORE_ADDR func_addr
= find_function_addr (function
, NULL
);
205 struct value
*arg
= 0;
210 /* The calling convention this function implements assumes the
211 processor has floating-point registers. We shouldn't be using it
212 on PPC variants that lack them. */
213 gdb_assert (ppc_floating_point_unit_p (gdbarch
));
215 /* The first eight words of ther arguments are passed in registers.
216 Copy them appropriately. */
219 /* If the function is returning a `struct', then the first word
220 (which will be passed in r3) is used for struct return address.
221 In that case we should advance one word and start from r4
222 register to copy parameters. */
225 regcache_raw_write_unsigned (regcache
, tdep
->ppc_gp0_regnum
+ 3,
230 /* effectively indirect call... gcc does...
232 return_val example( float, int);
235 float in fp0, int in r3
236 offset of stack on overflow 8/16
237 for varargs, must go by type.
239 float in r3&r4, int in r5
240 offset of stack on overflow different
242 return in r3 or f0. If no float, must study how gcc emulates floats;
243 pay attention to arg promotion.
244 User may have to cast\args to handle promotion correctly
245 since gdb won't know if prototype supplied or not. */
247 for (argno
= 0, argbytes
= 0; argno
< nargs
&& ii
< 8; ++ii
)
249 int reg_size
= register_size (gdbarch
, ii
+ 3);
252 type
= check_typedef (value_type (arg
));
253 len
= TYPE_LENGTH (type
);
255 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
257 /* Floating point arguments are passed in fpr's, as well as gpr's.
258 There are 13 fpr's reserved for passing parameters. At this point
259 there is no way we would run out of them.
261 Always store the floating point value using the register's
262 floating-point format. */
263 const int fp_regnum
= tdep
->ppc_fp0_regnum
+ 1 + f_argno
;
264 gdb_byte reg_val
[MAX_REGISTER_SIZE
];
265 struct type
*reg_type
= register_type (gdbarch
, fp_regnum
);
267 gdb_assert (len
<= 8);
269 convert_typed_floating (value_contents (arg
), type
,
271 regcache_cooked_write (regcache
, fp_regnum
, reg_val
);
278 /* Argument takes more than one register. */
279 while (argbytes
< len
)
281 gdb_byte word
[MAX_REGISTER_SIZE
];
282 memset (word
, 0, reg_size
);
284 ((char *) value_contents (arg
)) + argbytes
,
285 (len
- argbytes
) > reg_size
286 ? reg_size
: len
- argbytes
);
287 regcache_cooked_write (regcache
,
288 tdep
->ppc_gp0_regnum
+ 3 + ii
,
290 ++ii
, argbytes
+= reg_size
;
293 goto ran_out_of_registers_for_arguments
;
300 /* Argument can fit in one register. No problem. */
301 int adj
= gdbarch_byte_order (gdbarch
)
302 == BFD_ENDIAN_BIG
? reg_size
- len
: 0;
303 gdb_byte word
[MAX_REGISTER_SIZE
];
305 memset (word
, 0, reg_size
);
306 memcpy (word
, value_contents (arg
), len
);
307 regcache_cooked_write (regcache
, tdep
->ppc_gp0_regnum
+ 3 +ii
, word
);
312 ran_out_of_registers_for_arguments
:
314 regcache_cooked_read_unsigned (regcache
,
315 gdbarch_sp_regnum (gdbarch
),
318 /* Location for 8 parameters are always reserved. */
321 /* Another six words for back chain, TOC register, link register, etc. */
324 /* Stack pointer must be quadword aligned. */
327 /* If there are more arguments, allocate space for them in
328 the stack, then push them starting from the ninth one. */
330 if ((argno
< nargs
) || argbytes
)
336 space
+= ((len
- argbytes
+ 3) & -4);
342 for (; jj
< nargs
; ++jj
)
344 struct value
*val
= args
[jj
];
345 space
+= ((TYPE_LENGTH (value_type (val
))) + 3) & -4;
348 /* Add location required for the rest of the parameters. */
349 space
= (space
+ 15) & -16;
352 /* This is another instance we need to be concerned about
353 securing our stack space. If we write anything underneath %sp
354 (r1), we might conflict with the kernel who thinks he is free
355 to use this area. So, update %sp first before doing anything
358 regcache_raw_write_signed (regcache
,
359 gdbarch_sp_regnum (gdbarch
), sp
);
361 /* If the last argument copied into the registers didn't fit there
362 completely, push the rest of it into stack. */
366 write_memory (sp
+ 24 + (ii
* 4),
367 value_contents (arg
) + argbytes
,
370 ii
+= ((len
- argbytes
+ 3) & -4) / 4;
373 /* Push the rest of the arguments into stack. */
374 for (; argno
< nargs
; ++argno
)
378 type
= check_typedef (value_type (arg
));
379 len
= TYPE_LENGTH (type
);
382 /* Float types should be passed in fpr's, as well as in the
384 if (TYPE_CODE (type
) == TYPE_CODE_FLT
&& f_argno
< 13)
387 gdb_assert (len
<= 8);
389 regcache_cooked_write (regcache
,
390 tdep
->ppc_fp0_regnum
+ 1 + f_argno
,
391 value_contents (arg
));
395 write_memory (sp
+ 24 + (ii
* 4), value_contents (arg
), len
);
396 ii
+= ((len
+ 3) & -4) / 4;
400 /* Set the stack pointer. According to the ABI, the SP is meant to
401 be set _before_ the corresponding stack space is used. On AIX,
402 this even applies when the target has been completely stopped!
403 Not doing this can lead to conflicts with the kernel which thinks
404 that it still has control over this not-yet-allocated stack
406 regcache_raw_write_signed (regcache
, gdbarch_sp_regnum (gdbarch
), sp
);
408 /* Set back chain properly. */
409 store_unsigned_integer (tmp_buffer
, wordsize
, byte_order
, saved_sp
);
410 write_memory (sp
, tmp_buffer
, wordsize
);
412 /* Point the inferior function call's return address at the dummy's
414 regcache_raw_write_signed (regcache
, tdep
->ppc_lr_regnum
, bp_addr
);
416 /* Set the TOC register value. */
417 regcache_raw_write_signed (regcache
, tdep
->ppc_toc_regnum
,
418 solib_aix_get_toc_value (func_addr
));
420 target_store_registers (regcache
, -1);
424 static enum return_value_convention
425 rs6000_return_value (struct gdbarch
*gdbarch
, struct value
*function
,
426 struct type
*valtype
, struct regcache
*regcache
,
427 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
429 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
430 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
432 /* The calling convention this function implements assumes the
433 processor has floating-point registers. We shouldn't be using it
434 on PowerPC variants that lack them. */
435 gdb_assert (ppc_floating_point_unit_p (gdbarch
));
437 /* AltiVec extension: Functions that declare a vector data type as a
438 return value place that return value in VR2. */
439 if (TYPE_CODE (valtype
) == TYPE_CODE_ARRAY
&& TYPE_VECTOR (valtype
)
440 && TYPE_LENGTH (valtype
) == 16)
443 regcache_cooked_read (regcache
, tdep
->ppc_vr0_regnum
+ 2, readbuf
);
445 regcache_cooked_write (regcache
, tdep
->ppc_vr0_regnum
+ 2, writebuf
);
447 return RETURN_VALUE_REGISTER_CONVENTION
;
450 /* If the called subprogram returns an aggregate, there exists an
451 implicit first argument, whose value is the address of a caller-
452 allocated buffer into which the callee is assumed to store its
453 return value. All explicit parameters are appropriately
455 if (TYPE_CODE (valtype
) == TYPE_CODE_STRUCT
456 || TYPE_CODE (valtype
) == TYPE_CODE_UNION
457 || TYPE_CODE (valtype
) == TYPE_CODE_ARRAY
)
458 return RETURN_VALUE_STRUCT_CONVENTION
;
460 /* Scalar floating-point values are returned in FPR1 for float or
461 double, and in FPR1:FPR2 for quadword precision. Fortran
462 complex*8 and complex*16 are returned in FPR1:FPR2, and
463 complex*32 is returned in FPR1:FPR4. */
464 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
465 && (TYPE_LENGTH (valtype
) == 4 || TYPE_LENGTH (valtype
) == 8))
467 struct type
*regtype
= register_type (gdbarch
, tdep
->ppc_fp0_regnum
);
470 /* FIXME: kettenis/2007-01-01: Add support for quadword
471 precision and complex. */
475 regcache_cooked_read (regcache
, tdep
->ppc_fp0_regnum
+ 1, regval
);
476 convert_typed_floating (regval
, regtype
, readbuf
, valtype
);
480 convert_typed_floating (writebuf
, valtype
, regval
, regtype
);
481 regcache_cooked_write (regcache
, tdep
->ppc_fp0_regnum
+ 1, regval
);
484 return RETURN_VALUE_REGISTER_CONVENTION
;
487 /* Values of the types int, long, short, pointer, and char (length
488 is less than or equal to four bytes), as well as bit values of
489 lengths less than or equal to 32 bits, must be returned right
490 justified in GPR3 with signed values sign extended and unsigned
491 values zero extended, as necessary. */
492 if (TYPE_LENGTH (valtype
) <= tdep
->wordsize
)
498 /* For reading we don't have to worry about sign extension. */
499 regcache_cooked_read_unsigned (regcache
, tdep
->ppc_gp0_regnum
+ 3,
501 store_unsigned_integer (readbuf
, TYPE_LENGTH (valtype
), byte_order
,
506 /* For writing, use unpack_long since that should handle any
507 required sign extension. */
508 regcache_cooked_write_unsigned (regcache
, tdep
->ppc_gp0_regnum
+ 3,
509 unpack_long (valtype
, writebuf
));
512 return RETURN_VALUE_REGISTER_CONVENTION
;
515 /* Eight-byte non-floating-point scalar values must be returned in
518 if (TYPE_LENGTH (valtype
) == 8)
520 gdb_assert (TYPE_CODE (valtype
) != TYPE_CODE_FLT
);
521 gdb_assert (tdep
->wordsize
== 4);
527 regcache_cooked_read (regcache
, tdep
->ppc_gp0_regnum
+ 3, regval
);
528 regcache_cooked_read (regcache
, tdep
->ppc_gp0_regnum
+ 4,
530 memcpy (readbuf
, regval
, 8);
534 regcache_cooked_write (regcache
, tdep
->ppc_gp0_regnum
+ 3, writebuf
);
535 regcache_cooked_write (regcache
, tdep
->ppc_gp0_regnum
+ 4,
539 return RETURN_VALUE_REGISTER_CONVENTION
;
542 return RETURN_VALUE_STRUCT_CONVENTION
;
545 /* Support for CONVERT_FROM_FUNC_PTR_ADDR (ARCH, ADDR, TARG).
547 Usually a function pointer's representation is simply the address
548 of the function. On the RS/6000 however, a function pointer is
549 represented by a pointer to an OPD entry. This OPD entry contains
550 three words, the first word is the address of the function, the
551 second word is the TOC pointer (r2), and the third word is the
552 static chain value. Throughout GDB it is currently assumed that a
553 function pointer contains the address of the function, which is not
554 easy to fix. In addition, the conversion of a function address to
555 a function pointer would require allocation of an OPD entry in the
556 inferior's memory space, with all its drawbacks. To be able to
557 call C++ virtual methods in the inferior (which are called via
558 function pointers), find_function_addr uses this function to get the
559 function address from a function pointer. */
561 /* Return real function address if ADDR (a function pointer) is in the data
562 space and is therefore a special function pointer. */
565 rs6000_convert_from_func_ptr_addr (struct gdbarch
*gdbarch
,
567 struct target_ops
*targ
)
569 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
570 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
571 struct obj_section
*s
;
573 s
= find_pc_section (addr
);
575 /* Normally, functions live inside a section that is executable.
576 So, if ADDR points to a non-executable section, then treat it
577 as a function descriptor and return the target address iff
578 the target address itself points to a section that is executable. */
579 if (s
&& (s
->the_bfd_section
->flags
& SEC_CODE
) == 0)
582 struct obj_section
*pc_section
;
583 volatile struct gdb_exception e
;
585 TRY_CATCH (e
, RETURN_MASK_ERROR
)
587 pc
= read_memory_unsigned_integer (addr
, tdep
->wordsize
, byte_order
);
591 /* An error occured during reading. Probably a memory error
592 due to the section not being loaded yet. This address
593 cannot be a function descriptor. */
596 pc_section
= find_pc_section (pc
);
598 if (pc_section
&& (pc_section
->the_bfd_section
->flags
& SEC_CODE
))
606 /* Calculate the destination of a branch/jump. Return -1 if not a branch. */
609 branch_dest (struct frame_info
*frame
, int opcode
, int instr
,
610 CORE_ADDR pc
, CORE_ADDR safety
)
612 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
613 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
614 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
620 absolute
= (int) ((instr
>> 1) & 1);
625 immediate
= ((instr
& ~3) << 6) >> 6; /* br unconditional */
629 dest
= pc
+ immediate
;
633 immediate
= ((instr
& ~3) << 16) >> 16; /* br conditional */
637 dest
= pc
+ immediate
;
641 ext_op
= (instr
>> 1) & 0x3ff;
643 if (ext_op
== 16) /* br conditional register */
645 dest
= get_frame_register_unsigned (frame
, tdep
->ppc_lr_regnum
) & ~3;
647 /* If we are about to return from a signal handler, dest is
648 something like 0x3c90. The current frame is a signal handler
649 caller frame, upon completion of the sigreturn system call
650 execution will return to the saved PC in the frame. */
651 if (dest
< AIX_TEXT_SEGMENT_BASE
)
652 dest
= read_memory_unsigned_integer
653 (get_frame_base (frame
) + SIG_FRAME_PC_OFFSET
,
654 tdep
->wordsize
, byte_order
);
657 else if (ext_op
== 528) /* br cond to count reg */
659 dest
= get_frame_register_unsigned (frame
,
660 tdep
->ppc_ctr_regnum
) & ~3;
662 /* If we are about to execute a system call, dest is something
663 like 0x22fc or 0x3b00. Upon completion the system call
664 will return to the address in the link register. */
665 if (dest
< AIX_TEXT_SEGMENT_BASE
)
666 dest
= get_frame_register_unsigned (frame
,
667 tdep
->ppc_lr_regnum
) & ~3;
676 return (dest
< AIX_TEXT_SEGMENT_BASE
) ? safety
: dest
;
679 /* AIX does not support PT_STEP. Simulate it. */
682 rs6000_software_single_step (struct frame_info
*frame
)
684 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
685 struct address_space
*aspace
= get_frame_address_space (frame
);
686 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
692 loc
= get_frame_pc (frame
);
694 insn
= read_memory_integer (loc
, 4, byte_order
);
696 if (ppc_deal_with_atomic_sequence (frame
))
699 breaks
[0] = loc
+ PPC_INSN_SIZE
;
701 breaks
[1] = branch_dest (frame
, opcode
, insn
, loc
, breaks
[0]);
703 /* Don't put two breakpoints on the same address. */
704 if (breaks
[1] == breaks
[0])
707 for (ii
= 0; ii
< 2; ++ii
)
709 /* ignore invalid breakpoint. */
710 if (breaks
[ii
] == -1)
712 insert_single_step_breakpoint (gdbarch
, aspace
, breaks
[ii
]);
715 errno
= 0; /* FIXME, don't ignore errors! */
716 /* What errors? {read,write}_memory call error(). */
720 /* Implement the "auto_wide_charset" gdbarch method for this platform. */
723 rs6000_aix_auto_wide_charset (void)
728 /* Implement an osabi sniffer for RS6000/AIX.
730 This function assumes that ABFD's flavour is XCOFF. In other words,
731 it should be registered as a sniffer for bfd_target_xcoff_flavour
732 objfiles only. A failed assertion will be raised if this condition
735 static enum gdb_osabi
736 rs6000_aix_osabi_sniffer (bfd
*abfd
)
738 gdb_assert (bfd_get_flavour (abfd
) == bfd_target_xcoff_flavour
);
740 /* The only noticeable difference between Lynx178 XCOFF files and
741 AIX XCOFF files comes from the fact that there are no shared
742 libraries on Lynx178. On AIX, we are betting that an executable
743 linked with no shared library will never exist. */
744 if (xcoff_get_n_import_files (abfd
) <= 0)
745 return GDB_OSABI_UNKNOWN
;
747 return GDB_OSABI_AIX
;
750 /* A structure encoding the offset and size of a field within
759 /* A structure describing the layout of all the fields of interest
760 in AIX's struct ld_info. Each field in this struct corresponds
761 to the field of the same name in struct ld_info. */
765 struct field_info ldinfo_next
;
766 struct field_info ldinfo_fd
;
767 struct field_info ldinfo_textorg
;
768 struct field_info ldinfo_textsize
;
769 struct field_info ldinfo_dataorg
;
770 struct field_info ldinfo_datasize
;
771 struct field_info ldinfo_filename
;
774 /* The following data has been generated by compiling and running
775 the following program on AIX 5.3. */
780 #define __LDINFO_PTRACE32__
781 #define __LDINFO_PTRACE64__
784 #define pinfo(type,member) \
786 struct type ldi = {0}; \
788 printf (" {%d, %d},\t/* %s */\n", \
789 offsetof (struct type, member), \
790 sizeof (ldi.member), \
798 printf ("static const struct ld_info_desc ld_info32_desc =\n{\n");
799 pinfo (__ld_info32
, ldinfo_next
);
800 pinfo (__ld_info32
, ldinfo_fd
);
801 pinfo (__ld_info32
, ldinfo_textorg
);
802 pinfo (__ld_info32
, ldinfo_textsize
);
803 pinfo (__ld_info32
, ldinfo_dataorg
);
804 pinfo (__ld_info32
, ldinfo_datasize
);
805 pinfo (__ld_info32
, ldinfo_filename
);
810 printf ("static const struct ld_info_desc ld_info64_desc =\n{\n");
811 pinfo (__ld_info64
, ldinfo_next
);
812 pinfo (__ld_info64
, ldinfo_fd
);
813 pinfo (__ld_info64
, ldinfo_textorg
);
814 pinfo (__ld_info64
, ldinfo_textsize
);
815 pinfo (__ld_info64
, ldinfo_dataorg
);
816 pinfo (__ld_info64
, ldinfo_datasize
);
817 pinfo (__ld_info64
, ldinfo_filename
);
824 /* Layout of the 32bit version of struct ld_info. */
826 static const struct ld_info_desc ld_info32_desc
=
828 {0, 4}, /* ldinfo_next */
829 {4, 4}, /* ldinfo_fd */
830 {8, 4}, /* ldinfo_textorg */
831 {12, 4}, /* ldinfo_textsize */
832 {16, 4}, /* ldinfo_dataorg */
833 {20, 4}, /* ldinfo_datasize */
834 {24, 2}, /* ldinfo_filename */
837 /* Layout of the 64bit version of struct ld_info. */
839 static const struct ld_info_desc ld_info64_desc
=
841 {0, 4}, /* ldinfo_next */
842 {8, 4}, /* ldinfo_fd */
843 {16, 8}, /* ldinfo_textorg */
844 {24, 8}, /* ldinfo_textsize */
845 {32, 8}, /* ldinfo_dataorg */
846 {40, 8}, /* ldinfo_datasize */
847 {48, 2}, /* ldinfo_filename */
850 /* A structured representation of one entry read from the ld_info
851 binary data provided by the AIX loader. */
865 /* Return a struct ld_info object corresponding to the entry at
868 Note that the filename and member_name strings still point
869 to the data in LDI_BUF. So LDI_BUF must not be deallocated
870 while the struct ld_info object returned is in use. */
872 static struct ld_info
873 rs6000_aix_extract_ld_info (struct gdbarch
*gdbarch
,
874 const gdb_byte
*ldi_buf
)
876 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
877 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
878 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
879 const struct ld_info_desc desc
880 = tdep
->wordsize
== 8 ? ld_info64_desc
: ld_info32_desc
;
883 info
.next
= extract_unsigned_integer (ldi_buf
+ desc
.ldinfo_next
.offset
,
884 desc
.ldinfo_next
.size
,
886 info
.fd
= extract_signed_integer (ldi_buf
+ desc
.ldinfo_fd
.offset
,
889 info
.textorg
= extract_typed_address (ldi_buf
+ desc
.ldinfo_textorg
.offset
,
892 = extract_unsigned_integer (ldi_buf
+ desc
.ldinfo_textsize
.offset
,
893 desc
.ldinfo_textsize
.size
,
895 info
.dataorg
= extract_typed_address (ldi_buf
+ desc
.ldinfo_dataorg
.offset
,
898 = extract_unsigned_integer (ldi_buf
+ desc
.ldinfo_datasize
.offset
,
899 desc
.ldinfo_datasize
.size
,
901 info
.filename
= (char *) ldi_buf
+ desc
.ldinfo_filename
.offset
;
902 info
.member_name
= info
.filename
+ strlen (info
.filename
) + 1;
907 /* Append to OBJSTACK an XML string description of the shared library
908 corresponding to LDI, following the TARGET_OBJECT_LIBRARIES_AIX
912 rs6000_aix_shared_library_to_xml (struct ld_info
*ldi
,
913 struct obstack
*obstack
)
917 obstack_grow_str (obstack
, "<library name=\"");
918 p
= xml_escape_text (ldi
->filename
);
919 obstack_grow_str (obstack
, p
);
921 obstack_grow_str (obstack
, "\"");
923 if (ldi
->member_name
[0] != '\0')
925 obstack_grow_str (obstack
, " member=\"");
926 p
= xml_escape_text (ldi
->member_name
);
927 obstack_grow_str (obstack
, p
);
929 obstack_grow_str (obstack
, "\"");
932 obstack_grow_str (obstack
, " text_addr=\"");
933 obstack_grow_str (obstack
, core_addr_to_string (ldi
->textorg
));
934 obstack_grow_str (obstack
, "\"");
936 obstack_grow_str (obstack
, " text_size=\"");
937 obstack_grow_str (obstack
, pulongest (ldi
->textsize
));
938 obstack_grow_str (obstack
, "\"");
940 obstack_grow_str (obstack
, " data_addr=\"");
941 obstack_grow_str (obstack
, core_addr_to_string (ldi
->dataorg
));
942 obstack_grow_str (obstack
, "\"");
944 obstack_grow_str (obstack
, " data_size=\"");
945 obstack_grow_str (obstack
, pulongest (ldi
->datasize
));
946 obstack_grow_str (obstack
, "\"");
948 obstack_grow_str (obstack
, "></library>");
951 /* Convert the ld_info binary data provided by the AIX loader into
952 an XML representation following the TARGET_OBJECT_LIBRARIES_AIX
955 LDI_BUF is a buffer containing the ld_info data.
956 READBUF, OFFSET and LEN follow the same semantics as target_ops'
957 to_xfer_partial target_ops method.
959 If CLOSE_LDINFO_FD is nonzero, then this routine also closes
960 the ldinfo_fd file descriptor. This is useful when the ldinfo
961 data is obtained via ptrace, as ptrace opens a file descriptor
962 for each and every entry; but we cannot use this descriptor
963 as the consumer of the XML library list might live in a different
967 rs6000_aix_ld_info_to_xml (struct gdbarch
*gdbarch
, const gdb_byte
*ldi_buf
,
968 gdb_byte
*readbuf
, ULONGEST offset
, ULONGEST len
,
971 struct obstack obstack
;
975 obstack_init (&obstack
);
976 obstack_grow_str (&obstack
, "<library-list-aix version=\"1.0\">\n");
980 struct ld_info ldi
= rs6000_aix_extract_ld_info (gdbarch
, ldi_buf
);
982 rs6000_aix_shared_library_to_xml (&ldi
, &obstack
);
988 ldi_buf
= ldi_buf
+ ldi
.next
;
991 obstack_grow_str0 (&obstack
, "</library-list-aix>\n");
993 buf
= obstack_finish (&obstack
);
994 len_avail
= strlen (buf
);
995 if (offset
>= len_avail
)
999 if (len
> len_avail
- offset
)
1000 len
= len_avail
- offset
;
1001 memcpy (readbuf
, buf
+ offset
, len
);
1004 obstack_free (&obstack
, NULL
);
1008 /* Implement the core_xfer_shared_libraries_aix gdbarch method. */
1011 rs6000_aix_core_xfer_shared_libraries_aix (struct gdbarch
*gdbarch
,
1016 struct bfd_section
*ldinfo_sec
;
1018 gdb_byte
*ldinfo_buf
;
1019 struct cleanup
*cleanup
;
1022 ldinfo_sec
= bfd_get_section_by_name (core_bfd
, ".ldinfo");
1023 if (ldinfo_sec
== NULL
)
1024 error (_("cannot find .ldinfo section from core file: %s"),
1025 bfd_errmsg (bfd_get_error ()));
1026 ldinfo_size
= bfd_get_section_size (ldinfo_sec
);
1028 ldinfo_buf
= xmalloc (ldinfo_size
);
1029 cleanup
= make_cleanup (xfree
, ldinfo_buf
);
1031 if (! bfd_get_section_contents (core_bfd
, ldinfo_sec
,
1032 ldinfo_buf
, 0, ldinfo_size
))
1033 error (_("unable to read .ldinfo section from core file: %s"),
1034 bfd_errmsg (bfd_get_error ()));
1036 result
= rs6000_aix_ld_info_to_xml (gdbarch
, ldinfo_buf
, readbuf
,
1039 do_cleanups (cleanup
);
1044 rs6000_aix_init_osabi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
1046 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1048 /* RS6000/AIX does not support PT_STEP. Has to be simulated. */
1049 set_gdbarch_software_single_step (gdbarch
, rs6000_software_single_step
);
1051 /* Displaced stepping is currently not supported in combination with
1052 software single-stepping. */
1053 set_gdbarch_displaced_step_copy_insn (gdbarch
, NULL
);
1054 set_gdbarch_displaced_step_fixup (gdbarch
, NULL
);
1055 set_gdbarch_displaced_step_free_closure (gdbarch
, NULL
);
1056 set_gdbarch_displaced_step_location (gdbarch
, NULL
);
1058 set_gdbarch_push_dummy_call (gdbarch
, rs6000_push_dummy_call
);
1059 set_gdbarch_return_value (gdbarch
, rs6000_return_value
);
1060 set_gdbarch_long_double_bit (gdbarch
, 8 * TARGET_CHAR_BIT
);
1062 /* Handle RS/6000 function pointers (which are really function
1064 set_gdbarch_convert_from_func_ptr_addr
1065 (gdbarch
, rs6000_convert_from_func_ptr_addr
);
1067 /* Core file support. */
1068 set_gdbarch_regset_from_core_section
1069 (gdbarch
, rs6000_aix_regset_from_core_section
);
1070 set_gdbarch_core_xfer_shared_libraries_aix
1071 (gdbarch
, rs6000_aix_core_xfer_shared_libraries_aix
);
1073 if (tdep
->wordsize
== 8)
1074 tdep
->lr_frame_offset
= 16;
1076 tdep
->lr_frame_offset
= 8;
1078 if (tdep
->wordsize
== 4)
1079 /* PowerOpen / AIX 32 bit. The saved area or red zone consists of
1080 19 4 byte GPRS + 18 8 byte FPRs giving a total of 220 bytes.
1081 Problem is, 220 isn't frame (16 byte) aligned. Round it up to
1083 set_gdbarch_frame_red_zone_size (gdbarch
, 224);
1085 set_gdbarch_frame_red_zone_size (gdbarch
, 0);
1087 set_gdbarch_auto_wide_charset (gdbarch
, rs6000_aix_auto_wide_charset
);
1089 set_solib_ops (gdbarch
, &solib_aix_so_ops
);
1092 /* Provide a prototype to silence -Wmissing-prototypes. */
1093 extern initialize_file_ftype _initialize_rs6000_aix_tdep
;
1096 _initialize_rs6000_aix_tdep (void)
1098 gdbarch_register_osabi_sniffer (bfd_arch_rs6000
,
1099 bfd_target_xcoff_flavour
,
1100 rs6000_aix_osabi_sniffer
);
1101 gdbarch_register_osabi_sniffer (bfd_arch_powerpc
,
1102 bfd_target_xcoff_flavour
,
1103 rs6000_aix_osabi_sniffer
);
1105 gdbarch_register_osabi (bfd_arch_rs6000
, 0, GDB_OSABI_AIX
,
1106 rs6000_aix_init_osabi
);
1107 gdbarch_register_osabi (bfd_arch_powerpc
, 0, GDB_OSABI_AIX
,
1108 rs6000_aix_init_osabi
);