1 /* Native support code for PPC AIX, for GDB the GNU debugger.
3 Copyright (C) 2006-2013 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/>. */
23 #include "gdb_string.h"
24 #include "gdb_assert.h"
34 #include "breakpoint.h"
35 #include "rs6000-tdep.h"
37 #include "exceptions.h"
38 #include "xcoffread.h"
40 /* Hook for determining the TOC address when calling functions in the
41 inferior under AIX. The initialization code in rs6000-nat.c sets
42 this hook to point to find_toc_address. */
44 CORE_ADDR (*rs6000_find_toc_address_hook
) (CORE_ADDR
) = NULL
;
46 /* If the kernel has to deliver a signal, it pushes a sigcontext
47 structure on the stack and then calls the signal handler, passing
48 the address of the sigcontext in an argument register. Usually
49 the signal handler doesn't save this register, so we have to
50 access the sigcontext structure via an offset from the signal handler
52 The following constants were determined by experimentation on AIX 3.2. */
53 #define SIG_FRAME_PC_OFFSET 96
54 #define SIG_FRAME_LR_OFFSET 108
55 #define SIG_FRAME_FP_OFFSET 284
58 /* Core file support. */
60 static struct ppc_reg_offsets rs6000_aix32_reg_offsets
=
62 /* General-purpose registers. */
74 /* Floating-point registers. */
76 56, /* fpscr_offset */
79 /* AltiVec registers. */
82 -1 /* vrsave_offset */
85 static struct ppc_reg_offsets rs6000_aix64_reg_offsets
=
87 /* General-purpose registers. */
99 /* Floating-point registers. */
101 296, /* fpscr_offset */
104 /* AltiVec registers. */
106 -1, /* vscr_offset */
107 -1 /* vrsave_offset */
111 /* Supply register REGNUM in the general-purpose register set REGSET
112 from the buffer specified by GREGS and LEN to register cache
113 REGCACHE. If REGNUM is -1, do this for all registers in REGSET. */
116 rs6000_aix_supply_regset (const struct regset
*regset
,
117 struct regcache
*regcache
, int regnum
,
118 const void *gregs
, size_t len
)
120 ppc_supply_gregset (regset
, regcache
, regnum
, gregs
, len
);
121 ppc_supply_fpregset (regset
, regcache
, regnum
, gregs
, len
);
124 /* Collect register REGNUM in the general-purpose register set
125 REGSET, from register cache REGCACHE into the buffer specified by
126 GREGS and LEN. If REGNUM is -1, do this for all registers in
130 rs6000_aix_collect_regset (const struct regset
*regset
,
131 const struct regcache
*regcache
, int regnum
,
132 void *gregs
, size_t len
)
134 ppc_collect_gregset (regset
, regcache
, regnum
, gregs
, len
);
135 ppc_collect_fpregset (regset
, regcache
, regnum
, gregs
, len
);
138 /* AIX register set. */
140 static struct regset rs6000_aix32_regset
=
142 &rs6000_aix32_reg_offsets
,
143 rs6000_aix_supply_regset
,
144 rs6000_aix_collect_regset
,
147 static struct regset rs6000_aix64_regset
=
149 &rs6000_aix64_reg_offsets
,
150 rs6000_aix_supply_regset
,
151 rs6000_aix_collect_regset
,
154 /* Return the appropriate register set for the core section identified
155 by SECT_NAME and SECT_SIZE. */
157 static const struct regset
*
158 rs6000_aix_regset_from_core_section (struct gdbarch
*gdbarch
,
159 const char *sect_name
, size_t sect_size
)
161 if (gdbarch_tdep (gdbarch
)->wordsize
== 4)
163 if (strcmp (sect_name
, ".reg") == 0 && sect_size
>= 592)
164 return &rs6000_aix32_regset
;
168 if (strcmp (sect_name
, ".reg") == 0 && sect_size
>= 576)
169 return &rs6000_aix64_regset
;
176 /* Pass the arguments in either registers, or in the stack. In RS/6000,
177 the first eight words of the argument list (that might be less than
178 eight parameters if some parameters occupy more than one word) are
179 passed in r3..r10 registers. Float and double parameters are
180 passed in fpr's, in addition to that. Rest of the parameters if any
181 are passed in user stack. There might be cases in which half of the
182 parameter is copied into registers, the other half is pushed into
185 Stack must be aligned on 64-bit boundaries when synthesizing
188 If the function is returning a structure, then the return address is passed
189 in r3, then the first 7 words of the parameters can be passed in registers,
193 rs6000_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
194 struct regcache
*regcache
, CORE_ADDR bp_addr
,
195 int nargs
, struct value
**args
, CORE_ADDR sp
,
196 int struct_return
, CORE_ADDR struct_addr
)
198 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
199 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
202 int argno
; /* current argument number */
203 int argbytes
; /* current argument byte */
204 gdb_byte tmp_buffer
[50];
205 int f_argno
= 0; /* current floating point argno */
206 int wordsize
= gdbarch_tdep (gdbarch
)->wordsize
;
207 CORE_ADDR func_addr
= find_function_addr (function
, NULL
);
209 struct value
*arg
= 0;
214 /* The calling convention this function implements assumes the
215 processor has floating-point registers. We shouldn't be using it
216 on PPC variants that lack them. */
217 gdb_assert (ppc_floating_point_unit_p (gdbarch
));
219 /* The first eight words of ther arguments are passed in registers.
220 Copy them appropriately. */
223 /* If the function is returning a `struct', then the first word
224 (which will be passed in r3) is used for struct return address.
225 In that case we should advance one word and start from r4
226 register to copy parameters. */
229 regcache_raw_write_unsigned (regcache
, tdep
->ppc_gp0_regnum
+ 3,
234 /* effectively indirect call... gcc does...
236 return_val example( float, int);
239 float in fp0, int in r3
240 offset of stack on overflow 8/16
241 for varargs, must go by type.
243 float in r3&r4, int in r5
244 offset of stack on overflow different
246 return in r3 or f0. If no float, must study how gcc emulates floats;
247 pay attention to arg promotion.
248 User may have to cast\args to handle promotion correctly
249 since gdb won't know if prototype supplied or not. */
251 for (argno
= 0, argbytes
= 0; argno
< nargs
&& ii
< 8; ++ii
)
253 int reg_size
= register_size (gdbarch
, ii
+ 3);
256 type
= check_typedef (value_type (arg
));
257 len
= TYPE_LENGTH (type
);
259 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
262 /* Floating point arguments are passed in fpr's, as well as gpr's.
263 There are 13 fpr's reserved for passing parameters. At this point
264 there is no way we would run out of them. */
266 gdb_assert (len
<= 8);
268 regcache_cooked_write (regcache
,
269 tdep
->ppc_fp0_regnum
+ 1 + f_argno
,
270 value_contents (arg
));
277 /* Argument takes more than one register. */
278 while (argbytes
< len
)
280 gdb_byte word
[MAX_REGISTER_SIZE
];
281 memset (word
, 0, reg_size
);
283 ((char *) value_contents (arg
)) + argbytes
,
284 (len
- argbytes
) > reg_size
285 ? reg_size
: len
- argbytes
);
286 regcache_cooked_write (regcache
,
287 tdep
->ppc_gp0_regnum
+ 3 + ii
,
289 ++ii
, argbytes
+= reg_size
;
292 goto ran_out_of_registers_for_arguments
;
299 /* Argument can fit in one register. No problem. */
300 int adj
= gdbarch_byte_order (gdbarch
)
301 == BFD_ENDIAN_BIG
? reg_size
- len
: 0;
302 gdb_byte word
[MAX_REGISTER_SIZE
];
304 memset (word
, 0, reg_size
);
305 memcpy (word
, value_contents (arg
), len
);
306 regcache_cooked_write (regcache
, tdep
->ppc_gp0_regnum
+ 3 +ii
, word
);
311 ran_out_of_registers_for_arguments
:
313 regcache_cooked_read_unsigned (regcache
,
314 gdbarch_sp_regnum (gdbarch
),
317 /* Location for 8 parameters are always reserved. */
320 /* Another six words for back chain, TOC register, link register, etc. */
323 /* Stack pointer must be quadword aligned. */
326 /* If there are more arguments, allocate space for them in
327 the stack, then push them starting from the ninth one. */
329 if ((argno
< nargs
) || argbytes
)
335 space
+= ((len
- argbytes
+ 3) & -4);
341 for (; jj
< nargs
; ++jj
)
343 struct value
*val
= args
[jj
];
344 space
+= ((TYPE_LENGTH (value_type (val
))) + 3) & -4;
347 /* Add location required for the rest of the parameters. */
348 space
= (space
+ 15) & -16;
351 /* This is another instance we need to be concerned about
352 securing our stack space. If we write anything underneath %sp
353 (r1), we might conflict with the kernel who thinks he is free
354 to use this area. So, update %sp first before doing anything
357 regcache_raw_write_signed (regcache
,
358 gdbarch_sp_regnum (gdbarch
), sp
);
360 /* If the last argument copied into the registers didn't fit there
361 completely, push the rest of it into stack. */
365 write_memory (sp
+ 24 + (ii
* 4),
366 value_contents (arg
) + argbytes
,
369 ii
+= ((len
- argbytes
+ 3) & -4) / 4;
372 /* Push the rest of the arguments into stack. */
373 for (; argno
< nargs
; ++argno
)
377 type
= check_typedef (value_type (arg
));
378 len
= TYPE_LENGTH (type
);
381 /* Float types should be passed in fpr's, as well as in the
383 if (TYPE_CODE (type
) == TYPE_CODE_FLT
&& f_argno
< 13)
386 gdb_assert (len
<= 8);
388 regcache_cooked_write (regcache
,
389 tdep
->ppc_fp0_regnum
+ 1 + f_argno
,
390 value_contents (arg
));
394 write_memory (sp
+ 24 + (ii
* 4), value_contents (arg
), len
);
395 ii
+= ((len
+ 3) & -4) / 4;
399 /* Set the stack pointer. According to the ABI, the SP is meant to
400 be set _before_ the corresponding stack space is used. On AIX,
401 this even applies when the target has been completely stopped!
402 Not doing this can lead to conflicts with the kernel which thinks
403 that it still has control over this not-yet-allocated stack
405 regcache_raw_write_signed (regcache
, gdbarch_sp_regnum (gdbarch
), sp
);
407 /* Set back chain properly. */
408 store_unsigned_integer (tmp_buffer
, wordsize
, byte_order
, saved_sp
);
409 write_memory (sp
, tmp_buffer
, wordsize
);
411 /* Point the inferior function call's return address at the dummy's
413 regcache_raw_write_signed (regcache
, tdep
->ppc_lr_regnum
, bp_addr
);
415 /* Set the TOC register, get the value from the objfile reader
416 which, in turn, gets it from the VMAP table. */
417 if (rs6000_find_toc_address_hook
!= NULL
)
419 CORE_ADDR tocvalue
= (*rs6000_find_toc_address_hook
) (func_addr
);
420 regcache_raw_write_signed (regcache
, tdep
->ppc_toc_regnum
, tocvalue
);
423 target_store_registers (regcache
, -1);
427 static enum return_value_convention
428 rs6000_return_value (struct gdbarch
*gdbarch
, struct value
*function
,
429 struct type
*valtype
, struct regcache
*regcache
,
430 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
432 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
433 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
435 /* The calling convention this function implements assumes the
436 processor has floating-point registers. We shouldn't be using it
437 on PowerPC variants that lack them. */
438 gdb_assert (ppc_floating_point_unit_p (gdbarch
));
440 /* AltiVec extension: Functions that declare a vector data type as a
441 return value place that return value in VR2. */
442 if (TYPE_CODE (valtype
) == TYPE_CODE_ARRAY
&& TYPE_VECTOR (valtype
)
443 && TYPE_LENGTH (valtype
) == 16)
446 regcache_cooked_read (regcache
, tdep
->ppc_vr0_regnum
+ 2, readbuf
);
448 regcache_cooked_write (regcache
, tdep
->ppc_vr0_regnum
+ 2, writebuf
);
450 return RETURN_VALUE_REGISTER_CONVENTION
;
453 /* If the called subprogram returns an aggregate, there exists an
454 implicit first argument, whose value is the address of a caller-
455 allocated buffer into which the callee is assumed to store its
456 return value. All explicit parameters are appropriately
458 if (TYPE_CODE (valtype
) == TYPE_CODE_STRUCT
459 || TYPE_CODE (valtype
) == TYPE_CODE_UNION
460 || TYPE_CODE (valtype
) == TYPE_CODE_ARRAY
)
461 return RETURN_VALUE_STRUCT_CONVENTION
;
463 /* Scalar floating-point values are returned in FPR1 for float or
464 double, and in FPR1:FPR2 for quadword precision. Fortran
465 complex*8 and complex*16 are returned in FPR1:FPR2, and
466 complex*32 is returned in FPR1:FPR4. */
467 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
468 && (TYPE_LENGTH (valtype
) == 4 || TYPE_LENGTH (valtype
) == 8))
470 struct type
*regtype
= register_type (gdbarch
, tdep
->ppc_fp0_regnum
);
473 /* FIXME: kettenis/2007-01-01: Add support for quadword
474 precision and complex. */
478 regcache_cooked_read (regcache
, tdep
->ppc_fp0_regnum
+ 1, regval
);
479 convert_typed_floating (regval
, regtype
, readbuf
, valtype
);
483 convert_typed_floating (writebuf
, valtype
, regval
, regtype
);
484 regcache_cooked_write (regcache
, tdep
->ppc_fp0_regnum
+ 1, regval
);
487 return RETURN_VALUE_REGISTER_CONVENTION
;
490 /* Values of the types int, long, short, pointer, and char (length
491 is less than or equal to four bytes), as well as bit values of
492 lengths less than or equal to 32 bits, must be returned right
493 justified in GPR3 with signed values sign extended and unsigned
494 values zero extended, as necessary. */
495 if (TYPE_LENGTH (valtype
) <= tdep
->wordsize
)
501 /* For reading we don't have to worry about sign extension. */
502 regcache_cooked_read_unsigned (regcache
, tdep
->ppc_gp0_regnum
+ 3,
504 store_unsigned_integer (readbuf
, TYPE_LENGTH (valtype
), byte_order
,
509 /* For writing, use unpack_long since that should handle any
510 required sign extension. */
511 regcache_cooked_write_unsigned (regcache
, tdep
->ppc_gp0_regnum
+ 3,
512 unpack_long (valtype
, writebuf
));
515 return RETURN_VALUE_REGISTER_CONVENTION
;
518 /* Eight-byte non-floating-point scalar values must be returned in
521 if (TYPE_LENGTH (valtype
) == 8)
523 gdb_assert (TYPE_CODE (valtype
) != TYPE_CODE_FLT
);
524 gdb_assert (tdep
->wordsize
== 4);
530 regcache_cooked_read (regcache
, tdep
->ppc_gp0_regnum
+ 3, regval
);
531 regcache_cooked_read (regcache
, tdep
->ppc_gp0_regnum
+ 4,
533 memcpy (readbuf
, regval
, 8);
537 regcache_cooked_write (regcache
, tdep
->ppc_gp0_regnum
+ 3, writebuf
);
538 regcache_cooked_write (regcache
, tdep
->ppc_gp0_regnum
+ 4,
542 return RETURN_VALUE_REGISTER_CONVENTION
;
545 return RETURN_VALUE_STRUCT_CONVENTION
;
548 /* Support for CONVERT_FROM_FUNC_PTR_ADDR (ARCH, ADDR, TARG).
550 Usually a function pointer's representation is simply the address
551 of the function. On the RS/6000 however, a function pointer is
552 represented by a pointer to an OPD entry. This OPD entry contains
553 three words, the first word is the address of the function, the
554 second word is the TOC pointer (r2), and the third word is the
555 static chain value. Throughout GDB it is currently assumed that a
556 function pointer contains the address of the function, which is not
557 easy to fix. In addition, the conversion of a function address to
558 a function pointer would require allocation of an OPD entry in the
559 inferior's memory space, with all its drawbacks. To be able to
560 call C++ virtual methods in the inferior (which are called via
561 function pointers), find_function_addr uses this function to get the
562 function address from a function pointer. */
564 /* Return real function address if ADDR (a function pointer) is in the data
565 space and is therefore a special function pointer. */
568 rs6000_convert_from_func_ptr_addr (struct gdbarch
*gdbarch
,
570 struct target_ops
*targ
)
572 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
573 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
574 struct obj_section
*s
;
576 s
= find_pc_section (addr
);
578 /* Normally, functions live inside a section that is executable.
579 So, if ADDR points to a non-executable section, then treat it
580 as a function descriptor and return the target address iff
581 the target address itself points to a section that is executable. */
582 if (s
&& (s
->the_bfd_section
->flags
& SEC_CODE
) == 0)
585 struct obj_section
*pc_section
;
586 volatile struct gdb_exception e
;
588 TRY_CATCH (e
, RETURN_MASK_ERROR
)
590 pc
= read_memory_unsigned_integer (addr
, tdep
->wordsize
, byte_order
);
594 /* An error occured during reading. Probably a memory error
595 due to the section not being loaded yet. This address
596 cannot be a function descriptor. */
599 pc_section
= find_pc_section (pc
);
601 if (pc_section
&& (pc_section
->the_bfd_section
->flags
& SEC_CODE
))
609 /* Calculate the destination of a branch/jump. Return -1 if not a branch. */
612 branch_dest (struct frame_info
*frame
, int opcode
, int instr
,
613 CORE_ADDR pc
, CORE_ADDR safety
)
615 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
616 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
617 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
623 absolute
= (int) ((instr
>> 1) & 1);
628 immediate
= ((instr
& ~3) << 6) >> 6; /* br unconditional */
632 dest
= pc
+ immediate
;
636 immediate
= ((instr
& ~3) << 16) >> 16; /* br conditional */
640 dest
= pc
+ immediate
;
644 ext_op
= (instr
>> 1) & 0x3ff;
646 if (ext_op
== 16) /* br conditional register */
648 dest
= get_frame_register_unsigned (frame
, tdep
->ppc_lr_regnum
) & ~3;
650 /* If we are about to return from a signal handler, dest is
651 something like 0x3c90. The current frame is a signal handler
652 caller frame, upon completion of the sigreturn system call
653 execution will return to the saved PC in the frame. */
654 if (dest
< AIX_TEXT_SEGMENT_BASE
)
655 dest
= read_memory_unsigned_integer
656 (get_frame_base (frame
) + SIG_FRAME_PC_OFFSET
,
657 tdep
->wordsize
, byte_order
);
660 else if (ext_op
== 528) /* br cond to count reg */
662 dest
= get_frame_register_unsigned (frame
,
663 tdep
->ppc_ctr_regnum
) & ~3;
665 /* If we are about to execute a system call, dest is something
666 like 0x22fc or 0x3b00. Upon completion the system call
667 will return to the address in the link register. */
668 if (dest
< AIX_TEXT_SEGMENT_BASE
)
669 dest
= get_frame_register_unsigned (frame
,
670 tdep
->ppc_lr_regnum
) & ~3;
679 return (dest
< AIX_TEXT_SEGMENT_BASE
) ? safety
: dest
;
682 /* AIX does not support PT_STEP. Simulate it. */
685 rs6000_software_single_step (struct frame_info
*frame
)
687 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
688 struct address_space
*aspace
= get_frame_address_space (frame
);
689 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
695 loc
= get_frame_pc (frame
);
697 insn
= read_memory_integer (loc
, 4, byte_order
);
699 if (ppc_deal_with_atomic_sequence (frame
))
702 breaks
[0] = loc
+ PPC_INSN_SIZE
;
704 breaks
[1] = branch_dest (frame
, opcode
, insn
, loc
, breaks
[0]);
706 /* Don't put two breakpoints on the same address. */
707 if (breaks
[1] == breaks
[0])
710 for (ii
= 0; ii
< 2; ++ii
)
712 /* ignore invalid breakpoint. */
713 if (breaks
[ii
] == -1)
715 insert_single_step_breakpoint (gdbarch
, aspace
, breaks
[ii
]);
718 errno
= 0; /* FIXME, don't ignore errors! */
719 /* What errors? {read,write}_memory call error(). */
723 /* Implement the "auto_wide_charset" gdbarch method for this platform. */
726 rs6000_aix_auto_wide_charset (void)
731 /* Implement an osabi sniffer for RS6000/AIX.
733 This function assumes that ABFD's flavour is XCOFF. In other words,
734 it should be registered as a sniffer for bfd_target_xcoff_flavour
735 objfiles only. A failed assertion will be raised if this condition
738 static enum gdb_osabi
739 rs6000_aix_osabi_sniffer (bfd
*abfd
)
741 gdb_assert (bfd_get_flavour (abfd
) == bfd_target_xcoff_flavour
);
743 /* The only noticeable difference between Lynx178 XCOFF files and
744 AIX XCOFF files comes from the fact that there are no shared
745 libraries on Lynx178. On AIX, we are betting that an executable
746 linked with no shared library will never exist. */
747 if (xcoff_get_n_import_files (abfd
) <= 0)
748 return GDB_OSABI_UNKNOWN
;
750 return GDB_OSABI_AIX
;
754 rs6000_aix_init_osabi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
756 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
758 /* RS6000/AIX does not support PT_STEP. Has to be simulated. */
759 set_gdbarch_software_single_step (gdbarch
, rs6000_software_single_step
);
761 /* Displaced stepping is currently not supported in combination with
762 software single-stepping. */
763 set_gdbarch_displaced_step_copy_insn (gdbarch
, NULL
);
764 set_gdbarch_displaced_step_fixup (gdbarch
, NULL
);
765 set_gdbarch_displaced_step_free_closure (gdbarch
, NULL
);
766 set_gdbarch_displaced_step_location (gdbarch
, NULL
);
768 set_gdbarch_push_dummy_call (gdbarch
, rs6000_push_dummy_call
);
769 set_gdbarch_return_value (gdbarch
, rs6000_return_value
);
770 set_gdbarch_long_double_bit (gdbarch
, 8 * TARGET_CHAR_BIT
);
772 /* Handle RS/6000 function pointers (which are really function
774 set_gdbarch_convert_from_func_ptr_addr
775 (gdbarch
, rs6000_convert_from_func_ptr_addr
);
777 /* Core file support. */
778 set_gdbarch_regset_from_core_section
779 (gdbarch
, rs6000_aix_regset_from_core_section
);
781 if (tdep
->wordsize
== 8)
782 tdep
->lr_frame_offset
= 16;
784 tdep
->lr_frame_offset
= 8;
786 if (tdep
->wordsize
== 4)
787 /* PowerOpen / AIX 32 bit. The saved area or red zone consists of
788 19 4 byte GPRS + 18 8 byte FPRs giving a total of 220 bytes.
789 Problem is, 220 isn't frame (16 byte) aligned. Round it up to
791 set_gdbarch_frame_red_zone_size (gdbarch
, 224);
793 set_gdbarch_frame_red_zone_size (gdbarch
, 0);
795 set_gdbarch_auto_wide_charset (gdbarch
, rs6000_aix_auto_wide_charset
);
798 /* Provide a prototype to silence -Wmissing-prototypes. */
799 extern initialize_file_ftype _initialize_rs6000_aix_tdep
;
802 _initialize_rs6000_aix_tdep (void)
804 gdbarch_register_osabi_sniffer (bfd_arch_rs6000
,
805 bfd_target_xcoff_flavour
,
806 rs6000_aix_osabi_sniffer
);
807 gdbarch_register_osabi_sniffer (bfd_arch_powerpc
,
808 bfd_target_xcoff_flavour
,
809 rs6000_aix_osabi_sniffer
);
811 gdbarch_register_osabi (bfd_arch_rs6000
, 0, GDB_OSABI_AIX
,
812 rs6000_aix_init_osabi
);
813 gdbarch_register_osabi (bfd_arch_powerpc
, 0, GDB_OSABI_AIX
,
814 rs6000_aix_init_osabi
);