1 /* Native support code for PPC AIX, for GDB the GNU debugger.
3 Copyright (C) 2006, 2007, 2008, 2009, 2010 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"
39 /* Hook for determining the TOC address when calling functions in the
40 inferior under AIX. The initialization code in rs6000-nat.c sets
41 this hook to point to find_toc_address. */
43 CORE_ADDR (*rs6000_find_toc_address_hook
) (CORE_ADDR
) = NULL
;
45 /* If the kernel has to deliver a signal, it pushes a sigcontext
46 structure on the stack and then calls the signal handler, passing
47 the address of the sigcontext in an argument register. Usually
48 the signal handler doesn't save this register, so we have to
49 access the sigcontext structure via an offset from the signal handler
51 The following constants were determined by experimentation on AIX 3.2. */
52 #define SIG_FRAME_PC_OFFSET 96
53 #define SIG_FRAME_LR_OFFSET 108
54 #define SIG_FRAME_FP_OFFSET 284
57 /* Core file support. */
59 static struct ppc_reg_offsets rs6000_aix32_reg_offsets
=
61 /* General-purpose registers. */
73 /* Floating-point registers. */
75 56, /* fpscr_offset */
78 /* AltiVec registers. */
81 -1 /* vrsave_offset */
84 static struct ppc_reg_offsets rs6000_aix64_reg_offsets
=
86 /* General-purpose registers. */
98 /* Floating-point registers. */
100 296, /* fpscr_offset */
103 /* AltiVec registers. */
105 -1, /* vscr_offset */
106 -1 /* vrsave_offset */
110 /* Supply register REGNUM in the general-purpose register set REGSET
111 from the buffer specified by GREGS and LEN to register cache
112 REGCACHE. If REGNUM is -1, do this for all registers in REGSET. */
115 rs6000_aix_supply_regset (const struct regset
*regset
,
116 struct regcache
*regcache
, int regnum
,
117 const void *gregs
, size_t len
)
119 ppc_supply_gregset (regset
, regcache
, regnum
, gregs
, len
);
120 ppc_supply_fpregset (regset
, regcache
, regnum
, gregs
, len
);
123 /* Collect register REGNUM in the general-purpose register set
124 REGSET. from register cache REGCACHE into the buffer specified by
125 GREGS and LEN. If REGNUM is -1, do this for all registers in
129 rs6000_aix_collect_regset (const struct regset
*regset
,
130 const struct regcache
*regcache
, int regnum
,
131 void *gregs
, size_t len
)
133 ppc_collect_gregset (regset
, regcache
, regnum
, gregs
, len
);
134 ppc_collect_fpregset (regset
, regcache
, regnum
, gregs
, len
);
137 /* AIX register set. */
139 static struct regset rs6000_aix32_regset
=
141 &rs6000_aix32_reg_offsets
,
142 rs6000_aix_supply_regset
,
143 rs6000_aix_collect_regset
,
146 static struct regset rs6000_aix64_regset
=
148 &rs6000_aix64_reg_offsets
,
149 rs6000_aix_supply_regset
,
150 rs6000_aix_collect_regset
,
153 /* Return the appropriate register set for the core section identified
154 by SECT_NAME and SECT_SIZE. */
156 static const struct regset
*
157 rs6000_aix_regset_from_core_section (struct gdbarch
*gdbarch
,
158 const char *sect_name
, size_t sect_size
)
160 if (gdbarch_tdep (gdbarch
)->wordsize
== 4)
162 if (strcmp (sect_name
, ".reg") == 0 && sect_size
>= 592)
163 return &rs6000_aix32_regset
;
167 if (strcmp (sect_name
, ".reg") == 0 && sect_size
>= 576)
168 return &rs6000_aix64_regset
;
175 /* Pass the arguments in either registers, or in the stack. In RS/6000,
176 the first eight words of the argument list (that might be less than
177 eight parameters if some parameters occupy more than one word) are
178 passed in r3..r10 registers. float and double parameters are
179 passed in fpr's, in addition to that. Rest of the parameters if any
180 are passed in user stack. There might be cases in which half of the
181 parameter is copied into registers, the other half is pushed into
184 Stack must be aligned on 64-bit boundaries when synthesizing
187 If the function is returning a structure, then the return address is passed
188 in r3, then the first 7 words of the parameters can be passed in registers,
192 rs6000_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
193 struct regcache
*regcache
, CORE_ADDR bp_addr
,
194 int nargs
, struct value
**args
, CORE_ADDR sp
,
195 int struct_return
, CORE_ADDR struct_addr
)
197 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
198 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
201 int argno
; /* current argument number */
202 int argbytes
; /* current argument byte */
203 gdb_byte tmp_buffer
[50];
204 int f_argno
= 0; /* current floating point argno */
205 int wordsize
= gdbarch_tdep (gdbarch
)->wordsize
;
206 CORE_ADDR func_addr
= find_function_addr (function
, NULL
);
208 struct value
*arg
= 0;
213 /* The calling convention this function implements assumes the
214 processor has floating-point registers. We shouldn't be using it
215 on PPC variants that lack them. */
216 gdb_assert (ppc_floating_point_unit_p (gdbarch
));
218 /* The first eight words of ther arguments are passed in registers.
219 Copy them appropriately. */
222 /* If the function is returning a `struct', then the first word
223 (which will be passed in r3) is used for struct return address.
224 In that case we should advance one word and start from r4
225 register to copy parameters. */
228 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.
252 for (argno
= 0, argbytes
= 0; argno
< nargs
&& ii
< 8; ++ii
)
254 int reg_size
= register_size (gdbarch
, ii
+ 3);
257 type
= check_typedef (value_type (arg
));
258 len
= TYPE_LENGTH (type
);
260 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
263 /* Floating point arguments are passed in fpr's, as well as gpr's.
264 There are 13 fpr's reserved for passing parameters. At this point
265 there is no way we would run out of them. */
267 gdb_assert (len
<= 8);
269 regcache_cooked_write (regcache
,
270 tdep
->ppc_fp0_regnum
+ 1 + f_argno
,
271 value_contents (arg
));
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, get the value from the objfile reader
417 which, in turn, gets it from the VMAP table. */
418 if (rs6000_find_toc_address_hook
!= NULL
)
420 CORE_ADDR tocvalue
= (*rs6000_find_toc_address_hook
) (func_addr
);
421 regcache_raw_write_signed (regcache
, tdep
->ppc_toc_regnum
, tocvalue
);
424 target_store_registers (regcache
, -1);
428 static enum return_value_convention
429 rs6000_return_value (struct gdbarch
*gdbarch
, struct type
*func_type
,
430 struct type
*valtype
, struct regcache
*regcache
,
431 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
433 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
434 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
437 /* The calling convention this function implements assumes the
438 processor has floating-point registers. We shouldn't be using it
439 on PowerPC variants that lack them. */
440 gdb_assert (ppc_floating_point_unit_p (gdbarch
));
442 /* AltiVec extension: Functions that declare a vector data type as a
443 return value place that return value in VR2. */
444 if (TYPE_CODE (valtype
) == TYPE_CODE_ARRAY
&& TYPE_VECTOR (valtype
)
445 && TYPE_LENGTH (valtype
) == 16)
448 regcache_cooked_read (regcache
, tdep
->ppc_vr0_regnum
+ 2, readbuf
);
450 regcache_cooked_write (regcache
, tdep
->ppc_vr0_regnum
+ 2, writebuf
);
452 return RETURN_VALUE_REGISTER_CONVENTION
;
455 /* If the called subprogram returns an aggregate, there exists an
456 implicit first argument, whose value is the address of a caller-
457 allocated buffer into which the callee is assumed to store its
458 return value. All explicit parameters are appropriately
460 if (TYPE_CODE (valtype
) == TYPE_CODE_STRUCT
461 || TYPE_CODE (valtype
) == TYPE_CODE_UNION
462 || TYPE_CODE (valtype
) == TYPE_CODE_ARRAY
)
463 return RETURN_VALUE_STRUCT_CONVENTION
;
465 /* Scalar floating-point values are returned in FPR1 for float or
466 double, and in FPR1:FPR2 for quadword precision. Fortran
467 complex*8 and complex*16 are returned in FPR1:FPR2, and
468 complex*32 is returned in FPR1:FPR4. */
469 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
470 && (TYPE_LENGTH (valtype
) == 4 || TYPE_LENGTH (valtype
) == 8))
472 struct type
*regtype
= register_type (gdbarch
, tdep
->ppc_fp0_regnum
);
475 /* FIXME: kettenis/2007-01-01: Add support for quadword
476 precision and complex. */
480 regcache_cooked_read (regcache
, tdep
->ppc_fp0_regnum
+ 1, regval
);
481 convert_typed_floating (regval
, regtype
, readbuf
, valtype
);
485 convert_typed_floating (writebuf
, valtype
, regval
, regtype
);
486 regcache_cooked_write (regcache
, tdep
->ppc_fp0_regnum
+ 1, regval
);
489 return RETURN_VALUE_REGISTER_CONVENTION
;
492 /* Values of the types int, long, short, pointer, and char (length
493 is less than or equal to four bytes), as well as bit values of
494 lengths less than or equal to 32 bits, must be returned right
495 justified in GPR3 with signed values sign extended and unsigned
496 values zero extended, as necessary. */
497 if (TYPE_LENGTH (valtype
) <= tdep
->wordsize
)
503 /* For reading we don't have to worry about sign extension. */
504 regcache_cooked_read_unsigned (regcache
, tdep
->ppc_gp0_regnum
+ 3,
506 store_unsigned_integer (readbuf
, TYPE_LENGTH (valtype
), byte_order
,
511 /* For writing, use unpack_long since that should handle any
512 required sign extension. */
513 regcache_cooked_write_unsigned (regcache
, tdep
->ppc_gp0_regnum
+ 3,
514 unpack_long (valtype
, writebuf
));
517 return RETURN_VALUE_REGISTER_CONVENTION
;
520 /* Eight-byte non-floating-point scalar values must be returned in
523 if (TYPE_LENGTH (valtype
) == 8)
525 gdb_assert (TYPE_CODE (valtype
) != TYPE_CODE_FLT
);
526 gdb_assert (tdep
->wordsize
== 4);
532 regcache_cooked_read (regcache
, tdep
->ppc_gp0_regnum
+ 3, regval
);
533 regcache_cooked_read (regcache
, tdep
->ppc_gp0_regnum
+ 4,
535 memcpy (readbuf
, regval
, 8);
539 regcache_cooked_write (regcache
, tdep
->ppc_gp0_regnum
+ 3, writebuf
);
540 regcache_cooked_write (regcache
, tdep
->ppc_gp0_regnum
+ 4,
544 return RETURN_VALUE_REGISTER_CONVENTION
;
547 return RETURN_VALUE_STRUCT_CONVENTION
;
550 /* Support for CONVERT_FROM_FUNC_PTR_ADDR (ARCH, ADDR, TARG).
552 Usually a function pointer's representation is simply the address
553 of the function. On the RS/6000 however, a function pointer is
554 represented by a pointer to an OPD entry. This OPD entry contains
555 three words, the first word is the address of the function, the
556 second word is the TOC pointer (r2), and the third word is the
557 static chain value. Throughout GDB it is currently assumed that a
558 function pointer contains the address of the function, which is not
559 easy to fix. In addition, the conversion of a function address to
560 a function pointer would require allocation of an OPD entry in the
561 inferior's memory space, with all its drawbacks. To be able to
562 call C++ virtual methods in the inferior (which are called via
563 function pointers), find_function_addr uses this function to get the
564 function address from a function pointer. */
566 /* Return real function address if ADDR (a function pointer) is in the data
567 space and is therefore a special function pointer. */
570 rs6000_convert_from_func_ptr_addr (struct gdbarch
*gdbarch
,
572 struct target_ops
*targ
)
574 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
575 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
576 struct obj_section
*s
;
578 s
= find_pc_section (addr
);
580 /* Normally, functions live inside a section that is executable.
581 So, if ADDR points to a non-executable section, then treat it
582 as a function descriptor and return the target address iff
583 the target address itself points to a section that is executable. */
584 if (s
&& (s
->the_bfd_section
->flags
& SEC_CODE
) == 0)
587 struct obj_section
*pc_section
;
588 struct gdb_exception e
;
590 TRY_CATCH (e
, RETURN_MASK_ERROR
)
592 pc
= read_memory_unsigned_integer (addr
, tdep
->wordsize
, byte_order
);
596 /* An error occured during reading. Probably a memory error
597 due to the section not being loaded yet. This address
598 cannot be a function descriptor. */
601 pc_section
= find_pc_section (pc
);
603 if (pc_section
&& (pc_section
->the_bfd_section
->flags
& SEC_CODE
))
611 /* Calculate the destination of a branch/jump. Return -1 if not a branch. */
614 branch_dest (struct frame_info
*frame
, int opcode
, int instr
,
615 CORE_ADDR pc
, CORE_ADDR safety
)
617 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
618 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
619 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
625 absolute
= (int) ((instr
>> 1) & 1);
630 immediate
= ((instr
& ~3) << 6) >> 6; /* br unconditional */
634 dest
= pc
+ immediate
;
638 immediate
= ((instr
& ~3) << 16) >> 16; /* br conditional */
642 dest
= pc
+ immediate
;
646 ext_op
= (instr
>> 1) & 0x3ff;
648 if (ext_op
== 16) /* br conditional register */
650 dest
= get_frame_register_unsigned (frame
, tdep
->ppc_lr_regnum
) & ~3;
652 /* If we are about to return from a signal handler, dest is
653 something like 0x3c90. The current frame is a signal handler
654 caller frame, upon completion of the sigreturn system call
655 execution will return to the saved PC in the frame. */
656 if (dest
< AIX_TEXT_SEGMENT_BASE
)
657 dest
= read_memory_unsigned_integer
658 (get_frame_base (frame
) + SIG_FRAME_PC_OFFSET
,
659 tdep
->wordsize
, byte_order
);
662 else if (ext_op
== 528) /* br cond to count reg */
664 dest
= get_frame_register_unsigned (frame
, tdep
->ppc_ctr_regnum
) & ~3;
666 /* If we are about to execute a system call, dest is something
667 like 0x22fc or 0x3b00. Upon completion the system call
668 will return to the address in the link register. */
669 if (dest
< AIX_TEXT_SEGMENT_BASE
)
670 dest
= get_frame_register_unsigned (frame
, 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 static enum gdb_osabi
724 rs6000_aix_osabi_sniffer (bfd
*abfd
)
727 if (bfd_get_flavour (abfd
) == bfd_target_xcoff_flavour
);
728 return GDB_OSABI_AIX
;
730 return GDB_OSABI_UNKNOWN
;
734 rs6000_aix_init_osabi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
736 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
738 /* RS6000/AIX does not support PT_STEP. Has to be simulated. */
739 set_gdbarch_software_single_step (gdbarch
, rs6000_software_single_step
);
741 /* Displaced stepping is currently not supported in combination with
742 software single-stepping. */
743 set_gdbarch_displaced_step_copy_insn (gdbarch
, NULL
);
744 set_gdbarch_displaced_step_fixup (gdbarch
, NULL
);
745 set_gdbarch_displaced_step_free_closure (gdbarch
, NULL
);
746 set_gdbarch_displaced_step_location (gdbarch
, NULL
);
748 set_gdbarch_push_dummy_call (gdbarch
, rs6000_push_dummy_call
);
749 set_gdbarch_return_value (gdbarch
, rs6000_return_value
);
750 set_gdbarch_long_double_bit (gdbarch
, 8 * TARGET_CHAR_BIT
);
752 /* Handle RS/6000 function pointers (which are really function
754 set_gdbarch_convert_from_func_ptr_addr
755 (gdbarch
, rs6000_convert_from_func_ptr_addr
);
757 /* Core file support. */
758 set_gdbarch_regset_from_core_section
759 (gdbarch
, rs6000_aix_regset_from_core_section
);
761 if (tdep
->wordsize
== 8)
762 tdep
->lr_frame_offset
= 16;
764 tdep
->lr_frame_offset
= 8;
766 if (tdep
->wordsize
== 4)
767 /* PowerOpen / AIX 32 bit. The saved area or red zone consists of
768 19 4 byte GPRS + 18 8 byte FPRs giving a total of 220 bytes.
769 Problem is, 220 isn't frame (16 byte) aligned. Round it up to
771 set_gdbarch_frame_red_zone_size (gdbarch
, 224);
773 set_gdbarch_frame_red_zone_size (gdbarch
, 0);
776 /* Provide a prototype to silence -Wmissing-prototypes. */
777 extern initialize_file_ftype _initialize_rs6000_aix_tdep
;
780 _initialize_rs6000_aix_tdep (void)
782 gdbarch_register_osabi_sniffer (bfd_arch_rs6000
,
783 bfd_target_xcoff_flavour
,
784 rs6000_aix_osabi_sniffer
);
785 gdbarch_register_osabi_sniffer (bfd_arch_powerpc
,
786 bfd_target_xcoff_flavour
,
787 rs6000_aix_osabi_sniffer
);
789 gdbarch_register_osabi (bfd_arch_rs6000
, 0, GDB_OSABI_AIX
,
790 rs6000_aix_init_osabi
);
791 gdbarch_register_osabi (bfd_arch_powerpc
, 0, GDB_OSABI_AIX
,
792 rs6000_aix_init_osabi
);