1 /* Native support code for PPC AIX, for GDB the GNU debugger.
3 Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011
4 Free Software Foundation, Inc.
6 Free Software Foundation, Inc.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "gdb_string.h"
25 #include "gdb_assert.h"
35 #include "breakpoint.h"
36 #include "rs6000-tdep.h"
38 #include "exceptions.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,
235 effectively indirect call... gcc does...
237 return_val example( float, int);
240 float in fp0, int in r3
241 offset of stack on overflow 8/16
242 for varargs, must go by type.
244 float in r3&r4, int in r5
245 offset of stack on overflow different
247 return in r3 or f0. If no float, must study how gcc emulates floats;
248 pay attention to arg promotion.
249 User may have to cast\args to handle promotion correctly
250 since gdb won't know if prototype supplied or not.
253 for (argno
= 0, argbytes
= 0; argno
< nargs
&& ii
< 8; ++ii
)
255 int reg_size
= register_size (gdbarch
, ii
+ 3);
258 type
= check_typedef (value_type (arg
));
259 len
= TYPE_LENGTH (type
);
261 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
264 /* Floating point arguments are passed in fpr's, as well as gpr's.
265 There are 13 fpr's reserved for passing parameters. At this point
266 there is no way we would run out of them. */
268 gdb_assert (len
<= 8);
270 regcache_cooked_write (regcache
,
271 tdep
->ppc_fp0_regnum
+ 1 + f_argno
,
272 value_contents (arg
));
279 /* Argument takes more than one register. */
280 while (argbytes
< len
)
282 gdb_byte word
[MAX_REGISTER_SIZE
];
283 memset (word
, 0, reg_size
);
285 ((char *) value_contents (arg
)) + argbytes
,
286 (len
- argbytes
) > reg_size
287 ? reg_size
: len
- argbytes
);
288 regcache_cooked_write (regcache
,
289 tdep
->ppc_gp0_regnum
+ 3 + ii
,
291 ++ii
, argbytes
+= reg_size
;
294 goto ran_out_of_registers_for_arguments
;
301 /* Argument can fit in one register. No problem. */
302 int adj
= gdbarch_byte_order (gdbarch
)
303 == BFD_ENDIAN_BIG
? reg_size
- len
: 0;
304 gdb_byte word
[MAX_REGISTER_SIZE
];
306 memset (word
, 0, reg_size
);
307 memcpy (word
, value_contents (arg
), len
);
308 regcache_cooked_write (regcache
, tdep
->ppc_gp0_regnum
+ 3 +ii
, word
);
313 ran_out_of_registers_for_arguments
:
315 regcache_cooked_read_unsigned (regcache
,
316 gdbarch_sp_regnum (gdbarch
),
319 /* Location for 8 parameters are always reserved. */
322 /* Another six words for back chain, TOC register, link register, etc. */
325 /* Stack pointer must be quadword aligned. */
328 /* If there are more arguments, allocate space for them in
329 the stack, then push them starting from the ninth one. */
331 if ((argno
< nargs
) || argbytes
)
337 space
+= ((len
- argbytes
+ 3) & -4);
343 for (; jj
< nargs
; ++jj
)
345 struct value
*val
= args
[jj
];
346 space
+= ((TYPE_LENGTH (value_type (val
))) + 3) & -4;
349 /* Add location required for the rest of the parameters. */
350 space
= (space
+ 15) & -16;
353 /* This is another instance we need to be concerned about
354 securing our stack space. If we write anything underneath %sp
355 (r1), we might conflict with the kernel who thinks he is free
356 to use this area. So, update %sp first before doing anything
359 regcache_raw_write_signed (regcache
,
360 gdbarch_sp_regnum (gdbarch
), sp
);
362 /* If the last argument copied into the registers didn't fit there
363 completely, push the rest of it into stack. */
367 write_memory (sp
+ 24 + (ii
* 4),
368 value_contents (arg
) + argbytes
,
371 ii
+= ((len
- argbytes
+ 3) & -4) / 4;
374 /* Push the rest of the arguments into stack. */
375 for (; argno
< nargs
; ++argno
)
379 type
= check_typedef (value_type (arg
));
380 len
= TYPE_LENGTH (type
);
383 /* Float types should be passed in fpr's, as well as in the
385 if (TYPE_CODE (type
) == TYPE_CODE_FLT
&& f_argno
< 13)
388 gdb_assert (len
<= 8);
390 regcache_cooked_write (regcache
,
391 tdep
->ppc_fp0_regnum
+ 1 + f_argno
,
392 value_contents (arg
));
396 write_memory (sp
+ 24 + (ii
* 4), value_contents (arg
), len
);
397 ii
+= ((len
+ 3) & -4) / 4;
401 /* Set the stack pointer. According to the ABI, the SP is meant to
402 be set _before_ the corresponding stack space is used. On AIX,
403 this even applies when the target has been completely stopped!
404 Not doing this can lead to conflicts with the kernel which thinks
405 that it still has control over this not-yet-allocated stack
407 regcache_raw_write_signed (regcache
, gdbarch_sp_regnum (gdbarch
), sp
);
409 /* Set back chain properly. */
410 store_unsigned_integer (tmp_buffer
, wordsize
, byte_order
, saved_sp
);
411 write_memory (sp
, tmp_buffer
, wordsize
);
413 /* Point the inferior function call's return address at the dummy's
415 regcache_raw_write_signed (regcache
, tdep
->ppc_lr_regnum
, bp_addr
);
417 /* Set the TOC register, get the value from the objfile reader
418 which, in turn, gets it from the VMAP table. */
419 if (rs6000_find_toc_address_hook
!= NULL
)
421 CORE_ADDR tocvalue
= (*rs6000_find_toc_address_hook
) (func_addr
);
422 regcache_raw_write_signed (regcache
, tdep
->ppc_toc_regnum
, tocvalue
);
425 target_store_registers (regcache
, -1);
429 static enum return_value_convention
430 rs6000_return_value (struct gdbarch
*gdbarch
, struct type
*func_type
,
431 struct type
*valtype
, struct regcache
*regcache
,
432 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
434 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
435 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
438 /* The calling convention this function implements assumes the
439 processor has floating-point registers. We shouldn't be using it
440 on PowerPC variants that lack them. */
441 gdb_assert (ppc_floating_point_unit_p (gdbarch
));
443 /* AltiVec extension: Functions that declare a vector data type as a
444 return value place that return value in VR2. */
445 if (TYPE_CODE (valtype
) == TYPE_CODE_ARRAY
&& TYPE_VECTOR (valtype
)
446 && TYPE_LENGTH (valtype
) == 16)
449 regcache_cooked_read (regcache
, tdep
->ppc_vr0_regnum
+ 2, readbuf
);
451 regcache_cooked_write (regcache
, tdep
->ppc_vr0_regnum
+ 2, writebuf
);
453 return RETURN_VALUE_REGISTER_CONVENTION
;
456 /* If the called subprogram returns an aggregate, there exists an
457 implicit first argument, whose value is the address of a caller-
458 allocated buffer into which the callee is assumed to store its
459 return value. All explicit parameters are appropriately
461 if (TYPE_CODE (valtype
) == TYPE_CODE_STRUCT
462 || TYPE_CODE (valtype
) == TYPE_CODE_UNION
463 || TYPE_CODE (valtype
) == TYPE_CODE_ARRAY
)
464 return RETURN_VALUE_STRUCT_CONVENTION
;
466 /* Scalar floating-point values are returned in FPR1 for float or
467 double, and in FPR1:FPR2 for quadword precision. Fortran
468 complex*8 and complex*16 are returned in FPR1:FPR2, and
469 complex*32 is returned in FPR1:FPR4. */
470 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
471 && (TYPE_LENGTH (valtype
) == 4 || TYPE_LENGTH (valtype
) == 8))
473 struct type
*regtype
= register_type (gdbarch
, tdep
->ppc_fp0_regnum
);
476 /* FIXME: kettenis/2007-01-01: Add support for quadword
477 precision and complex. */
481 regcache_cooked_read (regcache
, tdep
->ppc_fp0_regnum
+ 1, regval
);
482 convert_typed_floating (regval
, regtype
, readbuf
, valtype
);
486 convert_typed_floating (writebuf
, valtype
, regval
, regtype
);
487 regcache_cooked_write (regcache
, tdep
->ppc_fp0_regnum
+ 1, regval
);
490 return RETURN_VALUE_REGISTER_CONVENTION
;
493 /* Values of the types int, long, short, pointer, and char (length
494 is less than or equal to four bytes), as well as bit values of
495 lengths less than or equal to 32 bits, must be returned right
496 justified in GPR3 with signed values sign extended and unsigned
497 values zero extended, as necessary. */
498 if (TYPE_LENGTH (valtype
) <= tdep
->wordsize
)
504 /* For reading we don't have to worry about sign extension. */
505 regcache_cooked_read_unsigned (regcache
, tdep
->ppc_gp0_regnum
+ 3,
507 store_unsigned_integer (readbuf
, TYPE_LENGTH (valtype
), byte_order
,
512 /* For writing, use unpack_long since that should handle any
513 required sign extension. */
514 regcache_cooked_write_unsigned (regcache
, tdep
->ppc_gp0_regnum
+ 3,
515 unpack_long (valtype
, writebuf
));
518 return RETURN_VALUE_REGISTER_CONVENTION
;
521 /* Eight-byte non-floating-point scalar values must be returned in
524 if (TYPE_LENGTH (valtype
) == 8)
526 gdb_assert (TYPE_CODE (valtype
) != TYPE_CODE_FLT
);
527 gdb_assert (tdep
->wordsize
== 4);
533 regcache_cooked_read (regcache
, tdep
->ppc_gp0_regnum
+ 3, regval
);
534 regcache_cooked_read (regcache
, tdep
->ppc_gp0_regnum
+ 4,
536 memcpy (readbuf
, regval
, 8);
540 regcache_cooked_write (regcache
, tdep
->ppc_gp0_regnum
+ 3, writebuf
);
541 regcache_cooked_write (regcache
, tdep
->ppc_gp0_regnum
+ 4,
545 return RETURN_VALUE_REGISTER_CONVENTION
;
548 return RETURN_VALUE_STRUCT_CONVENTION
;
551 /* Support for CONVERT_FROM_FUNC_PTR_ADDR (ARCH, ADDR, TARG).
553 Usually a function pointer's representation is simply the address
554 of the function. On the RS/6000 however, a function pointer is
555 represented by a pointer to an OPD entry. This OPD entry contains
556 three words, the first word is the address of the function, the
557 second word is the TOC pointer (r2), and the third word is the
558 static chain value. Throughout GDB it is currently assumed that a
559 function pointer contains the address of the function, which is not
560 easy to fix. In addition, the conversion of a function address to
561 a function pointer would require allocation of an OPD entry in the
562 inferior's memory space, with all its drawbacks. To be able to
563 call C++ virtual methods in the inferior (which are called via
564 function pointers), find_function_addr uses this function to get the
565 function address from a function pointer. */
567 /* Return real function address if ADDR (a function pointer) is in the data
568 space and is therefore a special function pointer. */
571 rs6000_convert_from_func_ptr_addr (struct gdbarch
*gdbarch
,
573 struct target_ops
*targ
)
575 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
576 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
577 struct obj_section
*s
;
579 s
= find_pc_section (addr
);
581 /* Normally, functions live inside a section that is executable.
582 So, if ADDR points to a non-executable section, then treat it
583 as a function descriptor and return the target address iff
584 the target address itself points to a section that is executable. */
585 if (s
&& (s
->the_bfd_section
->flags
& SEC_CODE
) == 0)
588 struct obj_section
*pc_section
;
589 struct gdb_exception e
;
591 TRY_CATCH (e
, RETURN_MASK_ERROR
)
593 pc
= read_memory_unsigned_integer (addr
, tdep
->wordsize
, byte_order
);
597 /* An error occured during reading. Probably a memory error
598 due to the section not being loaded yet. This address
599 cannot be a function descriptor. */
602 pc_section
= find_pc_section (pc
);
604 if (pc_section
&& (pc_section
->the_bfd_section
->flags
& SEC_CODE
))
612 /* Calculate the destination of a branch/jump. Return -1 if not a branch. */
615 branch_dest (struct frame_info
*frame
, int opcode
, int instr
,
616 CORE_ADDR pc
, CORE_ADDR safety
)
618 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
619 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
620 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
626 absolute
= (int) ((instr
>> 1) & 1);
631 immediate
= ((instr
& ~3) << 6) >> 6; /* br unconditional */
635 dest
= pc
+ immediate
;
639 immediate
= ((instr
& ~3) << 16) >> 16; /* br conditional */
643 dest
= pc
+ immediate
;
647 ext_op
= (instr
>> 1) & 0x3ff;
649 if (ext_op
== 16) /* br conditional register */
651 dest
= get_frame_register_unsigned (frame
, tdep
->ppc_lr_regnum
) & ~3;
653 /* If we are about to return from a signal handler, dest is
654 something like 0x3c90. The current frame is a signal handler
655 caller frame, upon completion of the sigreturn system call
656 execution will return to the saved PC in the frame. */
657 if (dest
< AIX_TEXT_SEGMENT_BASE
)
658 dest
= read_memory_unsigned_integer
659 (get_frame_base (frame
) + SIG_FRAME_PC_OFFSET
,
660 tdep
->wordsize
, byte_order
);
663 else if (ext_op
== 528) /* br cond to count reg */
665 dest
= get_frame_register_unsigned (frame
, tdep
->ppc_ctr_regnum
) & ~3;
667 /* If we are about to execute a system call, dest is something
668 like 0x22fc or 0x3b00. Upon completion the system call
669 will return to the address in the link register. */
670 if (dest
< AIX_TEXT_SEGMENT_BASE
)
671 dest
= get_frame_register_unsigned (frame
, tdep
->ppc_lr_regnum
) & ~3;
680 return (dest
< AIX_TEXT_SEGMENT_BASE
) ? safety
: dest
;
683 /* AIX does not support PT_STEP. Simulate it. */
686 rs6000_software_single_step (struct frame_info
*frame
)
688 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
689 struct address_space
*aspace
= get_frame_address_space (frame
);
690 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
696 loc
= get_frame_pc (frame
);
698 insn
= read_memory_integer (loc
, 4, byte_order
);
700 if (ppc_deal_with_atomic_sequence (frame
))
703 breaks
[0] = loc
+ PPC_INSN_SIZE
;
705 breaks
[1] = branch_dest (frame
, opcode
, insn
, loc
, breaks
[0]);
707 /* Don't put two breakpoints on the same address. */
708 if (breaks
[1] == breaks
[0])
711 for (ii
= 0; ii
< 2; ++ii
)
713 /* ignore invalid breakpoint. */
714 if (breaks
[ii
] == -1)
716 insert_single_step_breakpoint (gdbarch
, aspace
, breaks
[ii
]);
719 errno
= 0; /* FIXME, don't ignore errors! */
720 /* What errors? {read,write}_memory call error(). */
724 static enum gdb_osabi
725 rs6000_aix_osabi_sniffer (bfd
*abfd
)
728 if (bfd_get_flavour (abfd
) == bfd_target_xcoff_flavour
);
729 return GDB_OSABI_AIX
;
731 return GDB_OSABI_UNKNOWN
;
735 rs6000_aix_init_osabi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
737 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
739 /* RS6000/AIX does not support PT_STEP. Has to be simulated. */
740 set_gdbarch_software_single_step (gdbarch
, rs6000_software_single_step
);
742 /* Displaced stepping is currently not supported in combination with
743 software single-stepping. */
744 set_gdbarch_displaced_step_copy_insn (gdbarch
, NULL
);
745 set_gdbarch_displaced_step_fixup (gdbarch
, NULL
);
746 set_gdbarch_displaced_step_free_closure (gdbarch
, NULL
);
747 set_gdbarch_displaced_step_location (gdbarch
, NULL
);
749 set_gdbarch_push_dummy_call (gdbarch
, rs6000_push_dummy_call
);
750 set_gdbarch_return_value (gdbarch
, rs6000_return_value
);
751 set_gdbarch_long_double_bit (gdbarch
, 8 * TARGET_CHAR_BIT
);
753 /* Handle RS/6000 function pointers (which are really function
755 set_gdbarch_convert_from_func_ptr_addr
756 (gdbarch
, rs6000_convert_from_func_ptr_addr
);
758 /* Core file support. */
759 set_gdbarch_regset_from_core_section
760 (gdbarch
, rs6000_aix_regset_from_core_section
);
762 if (tdep
->wordsize
== 8)
763 tdep
->lr_frame_offset
= 16;
765 tdep
->lr_frame_offset
= 8;
767 if (tdep
->wordsize
== 4)
768 /* PowerOpen / AIX 32 bit. The saved area or red zone consists of
769 19 4 byte GPRS + 18 8 byte FPRs giving a total of 220 bytes.
770 Problem is, 220 isn't frame (16 byte) aligned. Round it up to
772 set_gdbarch_frame_red_zone_size (gdbarch
, 224);
774 set_gdbarch_frame_red_zone_size (gdbarch
, 0);
777 /* Provide a prototype to silence -Wmissing-prototypes. */
778 extern initialize_file_ftype _initialize_rs6000_aix_tdep
;
781 _initialize_rs6000_aix_tdep (void)
783 gdbarch_register_osabi_sniffer (bfd_arch_rs6000
,
784 bfd_target_xcoff_flavour
,
785 rs6000_aix_osabi_sniffer
);
786 gdbarch_register_osabi_sniffer (bfd_arch_powerpc
,
787 bfd_target_xcoff_flavour
,
788 rs6000_aix_osabi_sniffer
);
790 gdbarch_register_osabi (bfd_arch_rs6000
, 0, GDB_OSABI_AIX
,
791 rs6000_aix_init_osabi
);
792 gdbarch_register_osabi (bfd_arch_powerpc
, 0, GDB_OSABI_AIX
,
793 rs6000_aix_init_osabi
);