contrib/binutils/bfd/coff64-rs6000.c

   1 /* BFD back-end for IBM RS/6000 "XCOFF64" files.
   2    Copyright 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
   3    Free Software Foundation, Inc.
   4    Written Clinton Popetz.
   5    Contributed by Cygnus Support.
   6
   7    This file is part of BFD, the Binary File Descriptor library.
   8
   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 2 of the License, or
  12    (at your option) any later version.
  13
  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.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
  22
  23 #include "sysdep.h"
  24 #include "bfd.h"
  25 #include "bfdlink.h"
  26 #include "libbfd.h"
  27 #include "coff/internal.h"
  28 #include "coff/xcoff.h"
  29 #include "coff/rs6k64.h"
  30 #include "libcoff.h"
  31 #include "libxcoff.h"
  32
  33 #define GET_FILEHDR_SYMPTR H_GET_64
  34 #define PUT_FILEHDR_SYMPTR H_PUT_64
  35 #define GET_AOUTHDR_DATA_START H_GET_64
  36 #define PUT_AOUTHDR_DATA_START H_PUT_64
  37 #define GET_AOUTHDR_TEXT_START H_GET_64
  38 #define PUT_AOUTHDR_TEXT_START H_PUT_64
  39 #define GET_AOUTHDR_TSIZE H_GET_64
  40 #define PUT_AOUTHDR_TSIZE H_PUT_64
  41 #define GET_AOUTHDR_DSIZE H_GET_64
  42 #define PUT_AOUTHDR_DSIZE H_PUT_64
  43 #define GET_AOUTHDR_BSIZE H_GET_64
  44 #define PUT_AOUTHDR_BSIZE H_PUT_64
  45 #define GET_AOUTHDR_ENTRY H_GET_64
  46 #define PUT_AOUTHDR_ENTRY H_PUT_64
  47 #define GET_SCNHDR_PADDR H_GET_64
  48 #define PUT_SCNHDR_PADDR H_PUT_64
  49 #define GET_SCNHDR_VADDR H_GET_64
  50 #define PUT_SCNHDR_VADDR H_PUT_64
  51 #define GET_SCNHDR_SIZE H_GET_64
  52 #define PUT_SCNHDR_SIZE H_PUT_64
  53 #define GET_SCNHDR_SCNPTR H_GET_64
  54 #define PUT_SCNHDR_SCNPTR H_PUT_64
  55 #define GET_SCNHDR_RELPTR H_GET_64
  56 #define PUT_SCNHDR_RELPTR H_PUT_64
  57 #define GET_SCNHDR_LNNOPTR H_GET_64
  58 #define PUT_SCNHDR_LNNOPTR H_PUT_64
  59 #define GET_SCNHDR_NRELOC H_GET_32
  60 #define MAX_SCNHDR_NRELOC 0xffffffff
  61 #define PUT_SCNHDR_NRELOC H_PUT_32
  62 #define GET_SCNHDR_NLNNO H_GET_32
  63 #define MAX_SCNHDR_NLNNO 0xffffffff
  64 #define PUT_SCNHDR_NLNNO H_PUT_32
  65 #define GET_RELOC_VADDR H_GET_64
  66 #define PUT_RELOC_VADDR H_PUT_64
  67
  68 #define COFF_FORCE_SYMBOLS_IN_STRINGS
  69 #define COFF_DEBUG_STRING_WIDE_PREFIX
  70
  71
  72 #define COFF_ADJUST_SCNHDR_OUT_POST(ABFD, INT, EXT)                     \
  73   do                                                                    \
  74     {                                                                   \
  75       memset (((SCNHDR *) EXT)->s_pad, 0,                               \
  76               sizeof (((SCNHDR *) EXT)->s_pad));                        \
  77     }                                                                   \
  78   while (0)
  79
  80 #define NO_COFF_LINENOS
  81
  82 #define coff_SWAP_lineno_in _bfd_xcoff64_swap_lineno_in
  83 #define coff_SWAP_lineno_out _bfd_xcoff64_swap_lineno_out
  84
  85 static void _bfd_xcoff64_swap_lineno_in
  86   PARAMS ((bfd *, PTR, PTR));
  87 static unsigned int _bfd_xcoff64_swap_lineno_out
  88   PARAMS ((bfd *, PTR, PTR));
  89 static bfd_boolean _bfd_xcoff64_put_symbol_name
  90   PARAMS ((bfd *, struct bfd_strtab_hash *, struct internal_syment *,
  91            const char *));
  92 static bfd_boolean _bfd_xcoff64_put_ldsymbol_name
  93   PARAMS ((bfd *, struct xcoff_loader_info *, struct internal_ldsym *,
  94            const char *));
  95 static void _bfd_xcoff64_swap_sym_in
  96   PARAMS ((bfd *, PTR, PTR));
  97 static unsigned int _bfd_xcoff64_swap_sym_out
  98   PARAMS ((bfd *, PTR, PTR));
  99 static void _bfd_xcoff64_swap_aux_in
 100   PARAMS ((bfd *, PTR, int, int, int, int, PTR));
 101 static unsigned int _bfd_xcoff64_swap_aux_out
 102   PARAMS ((bfd *, PTR, int, int, int, int, PTR));
 103 static void xcoff64_swap_reloc_in
 104   PARAMS ((bfd *, PTR, PTR));
 105 static unsigned int xcoff64_swap_reloc_out
 106   PARAMS ((bfd *, PTR, PTR));
 107 extern bfd_boolean _bfd_xcoff_mkobject
 108   PARAMS ((bfd *));
 109 extern bfd_boolean _bfd_xcoff_copy_private_bfd_data
 110   PARAMS ((bfd *, bfd *));
 111 extern bfd_boolean _bfd_xcoff_is_local_label_name
 112   PARAMS ((bfd *, const char *));
 113 extern void xcoff64_rtype2howto
 114   PARAMS ((arelent *, struct internal_reloc *));
 115 extern reloc_howto_type * xcoff64_reloc_type_lookup
 116   PARAMS ((bfd *, bfd_reloc_code_real_type));
 117 extern bfd_boolean _bfd_xcoff_slurp_armap
 118   PARAMS ((bfd *));
 119 extern PTR _bfd_xcoff_read_ar_hdr
 120   PARAMS ((bfd *));
 121 extern bfd *_bfd_xcoff_openr_next_archived_file
 122   PARAMS ((bfd *, bfd *));
 123 extern int _bfd_xcoff_stat_arch_elt
 124   PARAMS ((bfd *, struct stat *));
 125 extern bfd_boolean _bfd_xcoff_write_armap
 126   PARAMS ((bfd *, unsigned int, struct orl *, unsigned int, int));
 127 extern bfd_boolean _bfd_xcoff_write_archive_contents
 128   PARAMS ((bfd *));
 129 extern int _bfd_xcoff_sizeof_headers
 130   PARAMS ((bfd *, struct bfd_link_info *));
 131 extern void _bfd_xcoff_swap_sym_in
 132   PARAMS ((bfd *, PTR, PTR));
 133 extern unsigned int _bfd_xcoff_swap_sym_out
 134   PARAMS ((bfd *, PTR, PTR));
 135 extern void _bfd_xcoff_swap_aux_in
 136   PARAMS ((bfd *, PTR, int, int, int, int, PTR));
 137 extern unsigned int _bfd_xcoff_swap_aux_out
 138   PARAMS ((bfd *, PTR, int, int, int, int, PTR));
 139 static void xcoff64_swap_ldhdr_in
 140   PARAMS ((bfd *, const PTR, struct internal_ldhdr *));
 141 static void xcoff64_swap_ldhdr_out
 142   PARAMS ((bfd *, const struct internal_ldhdr *, PTR d));
 143 static void xcoff64_swap_ldsym_in
 144   PARAMS ((bfd *, const PTR, struct internal_ldsym *));
 145 static void xcoff64_swap_ldsym_out
 146   PARAMS ((bfd *, const struct internal_ldsym *, PTR d));
 147 static void xcoff64_swap_ldrel_in
 148   PARAMS ((bfd *, const PTR, struct internal_ldrel *));
 149 static void xcoff64_swap_ldrel_out
 150   PARAMS ((bfd *, const struct internal_ldrel *, PTR d));
 151 static bfd_boolean xcoff64_write_object_contents
 152   PARAMS ((bfd *));
 153 static bfd_boolean xcoff64_ppc_relocate_section
 154   PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
 155            struct internal_reloc *, struct internal_syment *,
 156            asection **));
 157 static bfd_boolean xcoff64_slurp_armap
 158   PARAMS ((bfd *));
 159 static const bfd_target *xcoff64_archive_p
 160   PARAMS ((bfd *));
 161 static bfd *xcoff64_openr_next_archived_file
 162   PARAMS ((bfd *, bfd *));
 163 static int xcoff64_sizeof_headers
 164   PARAMS ((bfd *, struct bfd_link_info *));
 165 static asection *xcoff64_create_csect_from_smclas
 166   PARAMS ((bfd *, union internal_auxent *, const char *));
 167 static bfd_boolean xcoff64_is_lineno_count_overflow
 168   PARAMS ((bfd *, bfd_vma));
 169 static bfd_boolean xcoff64_is_reloc_count_overflow
 170   PARAMS ((bfd *, bfd_vma));
 171 static bfd_vma xcoff64_loader_symbol_offset
 172   PARAMS ((bfd *, struct internal_ldhdr *));
 173 static bfd_vma xcoff64_loader_reloc_offset
 174   PARAMS ((bfd *, struct internal_ldhdr *));
 175 static bfd_boolean xcoff64_generate_rtinit
 176   PARAMS ((bfd *, const char *, const char *, bfd_boolean));
 177 static bfd_boolean xcoff64_bad_format_hook
 178   PARAMS ((bfd *, PTR ));
 179
 180 /* Relocation functions */
 181 static bfd_boolean xcoff64_reloc_type_br
 182   PARAMS ((XCOFF_RELOC_FUNCTION_ARGS));
 183
 184 bfd_boolean (*xcoff64_calculate_relocation[XCOFF_MAX_CALCULATE_RELOCATION])
 185   PARAMS ((XCOFF_RELOC_FUNCTION_ARGS)) =
 186 {
 187   xcoff_reloc_type_pos,  /* R_POS   (0x00) */
 188   xcoff_reloc_type_neg,  /* R_NEG   (0x01) */
 189   xcoff_reloc_type_rel,  /* R_REL   (0x02) */
 190   xcoff_reloc_type_toc,  /* R_TOC   (0x03) */
 191   xcoff_reloc_type_fail, /* R_RTB   (0x04) */
 192   xcoff_reloc_type_toc,  /* R_GL    (0x05) */
 193   xcoff_reloc_type_toc,  /* R_TCL   (0x06) */
 194   xcoff_reloc_type_fail, /*         (0x07) */
 195   xcoff_reloc_type_ba,   /* R_BA    (0x08) */
 196   xcoff_reloc_type_fail, /*         (0x09) */
 197   xcoff64_reloc_type_br, /* R_BR    (0x0a) */
 198   xcoff_reloc_type_fail, /*         (0x0b) */
 199   xcoff_reloc_type_pos,  /* R_RL    (0x0c) */
 200   xcoff_reloc_type_pos,  /* R_RLA   (0x0d) */
 201   xcoff_reloc_type_fail, /*         (0x0e) */
 202   xcoff_reloc_type_noop, /* R_REF   (0x0f) */
 203   xcoff_reloc_type_fail, /*         (0x10) */
 204   xcoff_reloc_type_fail, /*         (0x11) */
 205   xcoff_reloc_type_toc,  /* R_TRL   (0x12) */
 206   xcoff_reloc_type_toc,  /* R_TRLA  (0x13) */
 207   xcoff_reloc_type_fail, /* R_RRTBI (0x14) */
 208   xcoff_reloc_type_fail, /* R_RRTBA (0x15) */
 209   xcoff_reloc_type_ba,   /* R_CAI   (0x16) */
 210   xcoff_reloc_type_crel, /* R_CREL  (0x17) */
 211   xcoff_reloc_type_ba,   /* R_RBA   (0x18) */
 212   xcoff_reloc_type_ba,   /* R_RBAC  (0x19) */
 213   xcoff64_reloc_type_br, /* R_RBR   (0x1a) */
 214   xcoff_reloc_type_ba,   /* R_RBRC  (0x1b) */
 215 };
 216
 217 /* coffcode.h needs these to be defined.  */
 218 /* Internalcoff.h and coffcode.h modify themselves based on these flags.  */
 219 #define XCOFF64
 220 #define RS6000COFF_C 1
 221
 222 #define SELECT_RELOC(internal, howto)                                   \
 223   {                                                                     \
 224     internal.r_type = howto->type;                                      \
 225     internal.r_size =                                                   \
 226       ((howto->complain_on_overflow == complain_overflow_signed         \
 227         ? 0x80                                                          \
 228         : 0)                                                            \
 229        | (howto->bitsize - 1));                                         \
 230   }
 231
 232 #define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (3)
 233 #define COFF_LONG_FILENAMES
 234 #define NO_COFF_SYMBOLS
 235 #define RTYPE2HOWTO(cache_ptr, dst) xcoff64_rtype2howto (cache_ptr, dst)
 236 #define coff_mkobject _bfd_xcoff_mkobject
 237 #define coff_bfd_copy_private_bfd_data _bfd_xcoff_copy_private_bfd_data
 238 #define coff_bfd_is_local_label_name _bfd_xcoff_is_local_label_name
 239 #define coff_bfd_reloc_type_lookup xcoff64_reloc_type_lookup
 240 #define coff_bfd_reloc_name_lookup xcoff64_reloc_name_lookup
 241 #ifdef AIX_CORE
 242 extern const bfd_target * rs6000coff_core_p
 243   PARAMS ((bfd *abfd));
 244 extern bfd_boolean rs6000coff_core_file_matches_executable_p
 245   PARAMS ((bfd *cbfd, bfd *ebfd));
 246 extern char *rs6000coff_core_file_failing_command
 247   PARAMS ((bfd *abfd));
 248 extern int rs6000coff_core_file_failing_signal
 249   PARAMS ((bfd *abfd));
 250 #define CORE_FILE_P rs6000coff_core_p
 251 #define coff_core_file_failing_command \
 252   rs6000coff_core_file_failing_command
 253 #define coff_core_file_failing_signal \
 254   rs6000coff_core_file_failing_signal
 255 #define coff_core_file_matches_executable_p \
 256   rs6000coff_core_file_matches_executable_p
 257 #else
 258 #define CORE_FILE_P _bfd_dummy_target
 259 #define coff_core_file_failing_command \
 260   _bfd_nocore_core_file_failing_command
 261 #define coff_core_file_failing_signal \
 262   _bfd_nocore_core_file_failing_signal
 263 #define coff_core_file_matches_executable_p \
 264   _bfd_nocore_core_file_matches_executable_p
 265 #endif
 266 #define coff_SWAP_sym_in _bfd_xcoff64_swap_sym_in
 267 #define coff_SWAP_sym_out _bfd_xcoff64_swap_sym_out
 268 #define coff_SWAP_aux_in _bfd_xcoff64_swap_aux_in
 269 #define coff_SWAP_aux_out _bfd_xcoff64_swap_aux_out
 270 #define coff_swap_reloc_in xcoff64_swap_reloc_in
 271 #define coff_swap_reloc_out xcoff64_swap_reloc_out
 272 #define NO_COFF_RELOCS
 273
 274 #include "coffcode.h"
 275
 276 /* For XCOFF64, the effective width of symndx changes depending on
 277    whether we are the first entry.  Sigh.  */
 278 static void
 279 _bfd_xcoff64_swap_lineno_in (abfd, ext1, in1)
 280      bfd *abfd;
 281      PTR ext1;
 282      PTR in1;
 283 {
 284   LINENO *ext = (LINENO *) ext1;
 285   struct internal_lineno *in = (struct internal_lineno *) in1;
 286
 287   in->l_lnno = H_GET_32 (abfd, (ext->l_lnno));
 288   if (in->l_lnno == 0)
 289     in->l_addr.l_symndx = H_GET_32 (abfd, ext->l_addr.l_symndx);
 290   else
 291     in->l_addr.l_paddr = H_GET_64 (abfd, ext->l_addr.l_paddr);
 292 }
 293
 294 static unsigned int
 295 _bfd_xcoff64_swap_lineno_out (abfd, inp, outp)
 296      bfd *abfd;
 297      PTR inp;
 298      PTR outp;
 299 {
 300   struct internal_lineno *in = (struct internal_lineno *) inp;
 301   struct external_lineno *ext = (struct external_lineno *) outp;
 302
 303   H_PUT_32 (abfd, in->l_addr.l_symndx, ext->l_addr.l_symndx);
 304   H_PUT_32 (abfd, in->l_lnno, (ext->l_lnno));
 305
 306   if (in->l_lnno == 0)
 307     H_PUT_32 (abfd, in->l_addr.l_symndx, ext->l_addr.l_symndx);
 308   else
 309     H_PUT_64 (abfd, in->l_addr.l_paddr, ext->l_addr.l_paddr);
 310
 311   return bfd_coff_linesz (abfd);
 312 }
 313
 314 static void
 315 _bfd_xcoff64_swap_sym_in (abfd, ext1, in1)
 316      bfd *abfd;
 317      PTR ext1;
 318      PTR in1;
 319 {
 320   struct external_syment *ext = (struct external_syment *) ext1;
 321   struct internal_syment *in = (struct internal_syment *) in1;
 322
 323   in->_n._n_n._n_zeroes = 0;
 324   in->_n._n_n._n_offset = H_GET_32 (abfd, ext->e_offset);
 325   in->n_value = H_GET_64 (abfd, ext->e_value);
 326   in->n_scnum = H_GET_16 (abfd, ext->e_scnum);
 327   in->n_type = H_GET_16 (abfd, ext->e_type);
 328   in->n_sclass = H_GET_8 (abfd, ext->e_sclass);
 329   in->n_numaux = H_GET_8 (abfd, ext->e_numaux);
 330 }
 331
 332 static unsigned int
 333 _bfd_xcoff64_swap_sym_out (abfd, inp, extp)
 334      bfd *abfd;
 335      PTR inp;
 336      PTR extp;
 337 {
 338   struct internal_syment *in = (struct internal_syment *) inp;
 339   struct external_syment *ext = (struct external_syment *) extp;
 340
 341   H_PUT_32 (abfd, in->_n._n_n._n_offset, ext->e_offset);
 342   H_PUT_64 (abfd, in->n_value, ext->e_value);
 343   H_PUT_16 (abfd, in->n_scnum, ext->e_scnum);
 344   H_PUT_16 (abfd, in->n_type, ext->e_type);
 345   H_PUT_8 (abfd, in->n_sclass, ext->e_sclass);
 346   H_PUT_8 (abfd, in->n_numaux, ext->e_numaux);
 347   return bfd_coff_symesz (abfd);
 348 }
 349
 350 static void
 351 _bfd_xcoff64_swap_aux_in (abfd, ext1, type, class, indx, numaux, in1)
 352      bfd *abfd;
 353      PTR ext1;
 354      int type;
 355      int class;
 356      int indx;
 357      int numaux;
 358      PTR in1;
 359 {
 360   union external_auxent *ext = (union external_auxent *) ext1;
 361   union internal_auxent *in = (union internal_auxent *) in1;
 362
 363   switch (class)
 364     {
 365     case C_FILE:
 366       if (ext->x_file.x_n.x_zeroes[0] == 0)
 367         {
 368           in->x_file.x_n.x_zeroes = 0;
 369           in->x_file.x_n.x_offset = H_GET_32 (abfd, ext->x_file.x_n.x_offset);
 370         }
 371       else
 372         {
 373           memcpy (in->x_file.x_fname, ext->x_file.x_fname, FILNMLEN);
 374         }
 375       goto end;
 376
 377       /* RS/6000 "csect" auxents */
 378     case C_EXT:
 379     case C_HIDEXT:
 380       if (indx + 1 == numaux)
 381         {
 382           bfd_signed_vma h = 0;
 383           bfd_vma l = 0;
 384
 385           h = H_GET_S32 (abfd, ext->x_csect.x_scnlen_hi);
 386           l = H_GET_32 (abfd, ext->x_csect.x_scnlen_lo);
 387
 388           in->x_csect.x_scnlen.l = h << 32 | (l & 0xffffffff);
 389
 390           in->x_csect.x_parmhash = H_GET_32 (abfd, ext->x_csect.x_parmhash);
 391           in->x_csect.x_snhash = H_GET_16 (abfd, ext->x_csect.x_snhash);
 392           /* We don't have to hack bitfields in x_smtyp because it's
 393              defined by shifts-and-ands, which are equivalent on all
 394              byte orders.  */
 395           in->x_csect.x_smtyp = H_GET_8 (abfd, ext->x_csect.x_smtyp);
 396           in->x_csect.x_smclas = H_GET_8 (abfd, ext->x_csect.x_smclas);
 397           goto end;
 398         }
 399       break;
 400
 401     case C_STAT:
 402     case C_LEAFSTAT:
 403     case C_HIDDEN:
 404       if (type == T_NULL)
 405         {
 406           /* PE defines some extra fields; we zero them out for
 407              safety.  */
 408           in->x_scn.x_checksum = 0;
 409           in->x_scn.x_associated = 0;
 410           in->x_scn.x_comdat = 0;
 411
 412           goto end;
 413         }
 414       break;
 415     }
 416
 417   if (class == C_BLOCK || class == C_FCN || ISFCN (type) || ISTAG (class))
 418     {
 419       in->x_sym.x_fcnary.x_fcn.x_lnnoptr
 420         = H_GET_64 (abfd, ext->x_sym.x_fcnary.x_fcn.x_lnnoptr);
 421       in->x_sym.x_fcnary.x_fcn.x_endndx.l
 422         = H_GET_32 (abfd, ext->x_sym.x_fcnary.x_fcn.x_endndx);
 423     }
 424   if (ISFCN (type))
 425     {
 426       in->x_sym.x_misc.x_fsize
 427         = H_GET_32 (abfd, ext->x_sym.x_fcnary.x_fcn.x_fsize);
 428     }
 429   else
 430     {
 431       in->x_sym.x_misc.x_lnsz.x_lnno
 432         = H_GET_32 (abfd, ext->x_sym.x_fcnary.x_lnsz.x_lnno);
 433       in->x_sym.x_misc.x_lnsz.x_size
 434         = H_GET_16 (abfd, ext->x_sym.x_fcnary.x_lnsz.x_size);
 435     }
 436
 437  end: ;
 438 }
 439
 440 static unsigned int
 441 _bfd_xcoff64_swap_aux_out (abfd, inp, type, class, indx, numaux, extp)
 442      bfd *abfd;
 443      PTR inp;
 444      int type;
 445      int class;
 446      int indx ATTRIBUTE_UNUSED;
 447      int numaux ATTRIBUTE_UNUSED;
 448      PTR extp;
 449 {
 450   union internal_auxent *in = (union internal_auxent *) inp;
 451   union external_auxent *ext = (union external_auxent *) extp;
 452
 453   memset ((PTR) ext, 0, bfd_coff_auxesz (abfd));
 454   switch (class)
 455     {
 456     case C_FILE:
 457       if (in->x_file.x_n.x_zeroes == 0)
 458         {
 459           H_PUT_32 (abfd, 0, ext->x_file.x_n.x_zeroes);
 460           H_PUT_32 (abfd, in->x_file.x_n.x_offset, ext->x_file.x_n.x_offset);
 461         }
 462       else
 463         {
 464           memcpy (ext->x_file.x_fname, in->x_file.x_fname, FILNMLEN);
 465         }
 466       H_PUT_8 (abfd, _AUX_FILE, ext->x_auxtype.x_auxtype);
 467       goto end;
 468
 469       /* RS/6000 "csect" auxents */
 470     case C_EXT:
 471     case C_HIDEXT:
 472       if (indx + 1 == numaux)
 473         {
 474           bfd_vma temp;
 475
 476           temp = in->x_csect.x_scnlen.l & 0xffffffff;
 477           H_PUT_32 (abfd, temp, ext->x_csect.x_scnlen_lo);
 478           temp = in->x_csect.x_scnlen.l >> 32;
 479           H_PUT_32 (abfd, temp, ext->x_csect.x_scnlen_hi);
 480           H_PUT_32 (abfd, in->x_csect.x_parmhash, ext->x_csect.x_parmhash);
 481           H_PUT_16 (abfd, in->x_csect.x_snhash, ext->x_csect.x_snhash);
 482           /* We don't have to hack bitfields in x_smtyp because it's
 483              defined by shifts-and-ands, which are equivalent on all
 484              byte orders.  */
 485           H_PUT_8 (abfd, in->x_csect.x_smtyp, ext->x_csect.x_smtyp);
 486           H_PUT_8 (abfd, in->x_csect.x_smclas, ext->x_csect.x_smclas);
 487           H_PUT_8 (abfd, _AUX_CSECT, ext->x_auxtype.x_auxtype);
 488           goto end;
 489         }
 490       break;
 491
 492     case C_STAT:
 493     case C_LEAFSTAT:
 494     case C_HIDDEN:
 495       if (type == T_NULL)
 496         {
 497           goto end;
 498         }
 499       break;
 500     }
 501
 502   if (class == C_BLOCK || class == C_FCN || ISFCN (type) || ISTAG (class))
 503     {
 504       H_PUT_64 (abfd, in->x_sym.x_fcnary.x_fcn.x_lnnoptr,
 505                ext->x_sym.x_fcnary.x_fcn.x_lnnoptr);
 506       H_PUT_8 (abfd, _AUX_FCN,
 507                ext->x_auxtype.x_auxtype);
 508       H_PUT_32 (abfd, in->x_sym.x_fcnary.x_fcn.x_endndx.l,
 509                ext->x_sym.x_fcnary.x_fcn.x_endndx);
 510     }
 511   if (ISFCN (type))
 512     {
 513       H_PUT_32 (abfd, in->x_sym.x_misc.x_fsize,
 514                ext->x_sym.x_fcnary.x_fcn.x_fsize);
 515     }
 516   else
 517     {
 518       H_PUT_32 (abfd, in->x_sym.x_misc.x_lnsz.x_lnno,
 519                ext->x_sym.x_fcnary.x_lnsz.x_lnno);
 520       H_PUT_16 (abfd, in->x_sym.x_misc.x_lnsz.x_size,
 521                ext->x_sym.x_fcnary.x_lnsz.x_size);
 522     }
 523
 524  end:
 525
 526   return bfd_coff_auxesz (abfd);
 527 }
 528
 529 static bfd_boolean
 530 _bfd_xcoff64_put_symbol_name (abfd, strtab, sym, name)
 531      bfd *abfd;
 532      struct bfd_strtab_hash *strtab;
 533      struct internal_syment *sym;
 534      const char *name;
 535 {
 536   bfd_boolean hash;
 537   bfd_size_type indx;
 538
 539   hash = TRUE;
 540
 541   if ((abfd->flags & BFD_TRADITIONAL_FORMAT) != 0)
 542     hash = FALSE;
 543
 544   indx = _bfd_stringtab_add (strtab, name, hash, FALSE);
 545
 546   if (indx == (bfd_size_type) -1)
 547     return FALSE;
 548
 549   sym->_n._n_n._n_zeroes = 0;
 550   sym->_n._n_n._n_offset = STRING_SIZE_SIZE + indx;
 551
 552   return TRUE;
 553 }
 554
 555 static bfd_boolean
 556 _bfd_xcoff64_put_ldsymbol_name (abfd, ldinfo, ldsym, name)
 557      bfd *abfd ATTRIBUTE_UNUSED;
 558      struct xcoff_loader_info *ldinfo;
 559      struct internal_ldsym *ldsym;
 560      const char *name;
 561 {
 562   size_t len;
 563   len = strlen (name);
 564
 565   if (ldinfo->string_size + len + 3 > ldinfo->string_alc)
 566     {
 567       bfd_size_type newalc;
 568       char *newstrings;
 569
 570       newalc = ldinfo->string_alc * 2;
 571       if (newalc == 0)
 572         newalc = 32;
 573       while (ldinfo->string_size + len + 3 > newalc)
 574         newalc *= 2;
 575
 576       newstrings = bfd_realloc (ldinfo->strings, newalc);
 577       if (newstrings == NULL)
 578         {
 579           ldinfo->failed = TRUE;
 580           return FALSE;
 581         }
 582       ldinfo->string_alc = newalc;
 583       ldinfo->strings = newstrings;
 584     }
 585
 586   bfd_put_16 (ldinfo->output_bfd, (bfd_vma) (len + 1),
 587               ldinfo->strings + ldinfo->string_size);
 588   strcpy (ldinfo->strings + ldinfo->string_size + 2, name);
 589   ldsym->_l._l_l._l_zeroes = 0;
 590   ldsym->_l._l_l._l_offset = ldinfo->string_size + 2;
 591   ldinfo->string_size += len + 3;
 592
 593   return TRUE;
 594 }
 595
 596 /* Routines to swap information in the XCOFF .loader section.  If we
 597    ever need to write an XCOFF loader, this stuff will need to be
 598    moved to another file shared by the linker (which XCOFF calls the
 599    ``binder'') and the loader.  */
 600
 601 /* Swap in the ldhdr structure.  */
 602
 603 static void
 604 xcoff64_swap_ldhdr_in (abfd, s, dst)
 605      bfd *abfd;
 606      const PTR s;
 607      struct internal_ldhdr *dst;
 608 {
 609   const struct external_ldhdr *src = (const struct external_ldhdr *) s;
 610
 611   dst->l_version = bfd_get_32 (abfd, src->l_version);
 612   dst->l_nsyms = bfd_get_32 (abfd, src->l_nsyms);
 613   dst->l_nreloc = bfd_get_32 (abfd, src->l_nreloc);
 614   dst->l_istlen = bfd_get_32 (abfd, src->l_istlen);
 615   dst->l_nimpid = bfd_get_32 (abfd, src->l_nimpid);
 616   dst->l_stlen = bfd_get_32 (abfd, src->l_stlen);
 617   dst->l_impoff = bfd_get_64 (abfd, src->l_impoff);
 618   dst->l_stoff = bfd_get_64 (abfd, src->l_stoff);
 619   dst->l_symoff = bfd_get_64 (abfd, src->l_symoff);
 620   dst->l_rldoff = bfd_get_64 (abfd, src->l_rldoff);
 621 }
 622
 623 /* Swap out the ldhdr structure.  */
 624
 625 static void
 626 xcoff64_swap_ldhdr_out (abfd, src, d)
 627      bfd *abfd;
 628      const struct internal_ldhdr *src;
 629      PTR d;
 630 {
 631   struct external_ldhdr *dst = (struct external_ldhdr *) d;
 632
 633   bfd_put_32 (abfd, (bfd_vma) src->l_version, dst->l_version);
 634   bfd_put_32 (abfd, src->l_nsyms, dst->l_nsyms);
 635   bfd_put_32 (abfd, src->l_nreloc, dst->l_nreloc);
 636   bfd_put_32 (abfd, src->l_istlen, dst->l_istlen);
 637   bfd_put_32 (abfd, src->l_nimpid, dst->l_nimpid);
 638   bfd_put_32 (abfd, src->l_stlen, dst->l_stlen);
 639   bfd_put_64 (abfd, src->l_impoff, dst->l_impoff);
 640   bfd_put_64 (abfd, src->l_stoff, dst->l_stoff);
 641   bfd_put_64 (abfd, src->l_symoff, dst->l_symoff);
 642   bfd_put_64 (abfd, src->l_rldoff, dst->l_rldoff);
 643 }
 644
 645 /* Swap in the ldsym structure.  */
 646
 647 static void
 648 xcoff64_swap_ldsym_in (abfd, s, dst)
 649      bfd *abfd;
 650      const PTR s;
 651      struct internal_ldsym *dst;
 652 {
 653   const struct external_ldsym *src = (const struct external_ldsym *) s;
 654   /* XCOFF64 does not use l_zeroes like XCOFF32
 655      Set the internal l_zeroes to 0 so the common 32/64 code uses l_value
 656      as an offset into the loader symbol table.  */
 657   dst->_l._l_l._l_zeroes = 0;
 658   dst->_l._l_l._l_offset = bfd_get_32 (abfd, src->l_offset);
 659   dst->l_value = bfd_get_64 (abfd, src->l_value);
 660   dst->l_scnum = bfd_get_16 (abfd, src->l_scnum);
 661   dst->l_smtype = bfd_get_8 (abfd, src->l_smtype);
 662   dst->l_smclas = bfd_get_8 (abfd, src->l_smclas);
 663   dst->l_ifile = bfd_get_32 (abfd, src->l_ifile);
 664   dst->l_parm = bfd_get_32 (abfd, src->l_parm);
 665 }
 666
 667 /* Swap out the ldsym structure.  */
 668
 669 static void
 670 xcoff64_swap_ldsym_out (abfd, src, d)
 671      bfd *abfd;
 672      const struct internal_ldsym *src;
 673      PTR d;
 674 {
 675   struct external_ldsym *dst = (struct external_ldsym *) d;
 676
 677   bfd_put_64 (abfd, src->l_value, dst->l_value);
 678   bfd_put_32 (abfd, (bfd_vma) src->_l._l_l._l_offset, dst->l_offset);
 679   bfd_put_16 (abfd, (bfd_vma) src->l_scnum, dst->l_scnum);
 680   bfd_put_8 (abfd, src->l_smtype, dst->l_smtype);
 681   bfd_put_8 (abfd, src->l_smclas, dst->l_smclas);
 682   bfd_put_32 (abfd, src->l_ifile, dst->l_ifile);
 683   bfd_put_32 (abfd, src->l_parm, dst->l_parm);
 684 }
 685
 686 static void
 687 xcoff64_swap_reloc_in (abfd, s, d)
 688      bfd *abfd;
 689      PTR s;
 690      PTR d;
 691 {
 692   struct external_reloc *src = (struct external_reloc *) s;
 693   struct internal_reloc *dst = (struct internal_reloc *) d;
 694
 695   memset (dst, 0, sizeof (struct internal_reloc));
 696
 697   dst->r_vaddr = bfd_get_64 (abfd, src->r_vaddr);
 698   dst->r_symndx = bfd_get_32 (abfd, src->r_symndx);
 699   dst->r_size = bfd_get_8 (abfd, src->r_size);
 700   dst->r_type = bfd_get_8 (abfd, src->r_type);
 701 }
 702
 703 static unsigned int
 704 xcoff64_swap_reloc_out (abfd, s, d)
 705      bfd *abfd;
 706      PTR s;
 707      PTR d;
 708 {
 709   struct internal_reloc *src = (struct internal_reloc *) s;
 710   struct external_reloc *dst = (struct external_reloc *) d;
 711
 712   bfd_put_64 (abfd, src->r_vaddr, dst->r_vaddr);
 713   bfd_put_32 (abfd, src->r_symndx, dst->r_symndx);
 714   bfd_put_8 (abfd, src->r_type, dst->r_type);
 715   bfd_put_8 (abfd, src->r_size, dst->r_size);
 716
 717   return bfd_coff_relsz (abfd);
 718 }
 719
 720 /* Swap in the ldrel structure.  */
 721
 722 static void
 723 xcoff64_swap_ldrel_in (abfd, s, dst)
 724      bfd *abfd;
 725      const PTR s;
 726      struct internal_ldrel *dst;
 727 {
 728   const struct external_ldrel *src = (const struct external_ldrel *) s;
 729
 730   dst->l_vaddr = bfd_get_64 (abfd, src->l_vaddr);
 731   dst->l_symndx = bfd_get_32 (abfd, src->l_symndx);
 732   dst->l_rtype = bfd_get_16 (abfd, src->l_rtype);
 733   dst->l_rsecnm = bfd_get_16 (abfd, src->l_rsecnm);
 734 }
 735
 736 /* Swap out the ldrel structure.  */
 737
 738 static void
 739 xcoff64_swap_ldrel_out (abfd, src, d)
 740      bfd *abfd;
 741      const struct internal_ldrel *src;
 742      PTR d;
 743 {
 744   struct external_ldrel *dst = (struct external_ldrel *) d;
 745
 746   bfd_put_64 (abfd, src->l_vaddr, dst->l_vaddr);
 747   bfd_put_16 (abfd, (bfd_vma) src->l_rtype, dst->l_rtype);
 748   bfd_put_16 (abfd, (bfd_vma) src->l_rsecnm, dst->l_rsecnm);
 749   bfd_put_32 (abfd, src->l_symndx, dst->l_symndx);
 750 }
 751
 752 static bfd_boolean
 753 xcoff64_write_object_contents (abfd)
 754      bfd *abfd;
 755 {
 756   asection *current;
 757   bfd_boolean hasrelocs = FALSE;
 758   bfd_boolean haslinno = FALSE;
 759   file_ptr scn_base;
 760   file_ptr reloc_base;
 761   file_ptr lineno_base;
 762   file_ptr sym_base;
 763   unsigned long reloc_size = 0;
 764   unsigned long lnno_size = 0;
 765   bfd_boolean long_section_names;
 766   asection *text_sec = ((void *) 0);
 767   asection *data_sec = ((void *) 0);
 768   asection *bss_sec = ((void *) 0);
 769   struct internal_filehdr internal_f;
 770   struct internal_aouthdr internal_a;
 771
 772   bfd_set_error (bfd_error_system_call);
 773
 774   if (! abfd->output_has_begun)
 775     {
 776       if (! bfd_coff_compute_section_file_positions (abfd))
 777         return FALSE;
 778     }
 779
 780   /* Work out the size of the reloc and linno areas.  */
 781   reloc_base = obj_relocbase (abfd);
 782
 783   for (current = abfd->sections; current != NULL; current = current->next)
 784     reloc_size += current->reloc_count * bfd_coff_relsz (abfd);
 785
 786   lineno_base = reloc_base + reloc_size;
 787
 788   /* Make a pass through the symbol table to count line number entries and
 789      put them into the correct asections.  */
 790   lnno_size = coff_count_linenumbers (abfd) * bfd_coff_linesz (abfd);
 791
 792   sym_base = lineno_base + lnno_size;
 793
 794   /* Indicate in each section->line_filepos its actual file address.  */
 795   for (current = abfd->sections; current != NULL; current =  current->next)
 796     {
 797       if (current->lineno_count)
 798         {
 799           current->line_filepos = lineno_base;
 800           current->moving_line_filepos = lineno_base;
 801           lineno_base += current->lineno_count * bfd_coff_linesz (abfd);
 802         }
 803       else
 804         {
 805           current->line_filepos = 0;
 806         }
 807
 808       if (current->reloc_count)
 809         {
 810           current->rel_filepos = reloc_base;
 811           reloc_base += current->reloc_count * bfd_coff_relsz (abfd);
 812         }
 813       else
 814         {
 815           current->rel_filepos = 0;
 816         }
 817     }
 818
 819   if ((abfd->flags & EXEC_P) != 0)
 820     {
 821       scn_base = bfd_coff_filhsz (abfd) + bfd_coff_aoutsz (abfd);
 822       internal_f.f_opthdr = bfd_coff_aoutsz (abfd);
 823     }
 824   else
 825     {
 826       scn_base = bfd_coff_filhsz (abfd);
 827       internal_f.f_opthdr = 0;
 828     }
 829
 830   internal_f.f_nscns = 0;
 831
 832   if (bfd_seek (abfd, scn_base, SEEK_SET) != 0)
 833     return FALSE;
 834
 835   long_section_names = FALSE;
 836   for (current = abfd->sections; current != NULL; current = current->next)
 837     {
 838       struct internal_scnhdr section;
 839       struct external_scnhdr buff;
 840       bfd_size_type amount;
 841
 842       internal_f.f_nscns++;
 843
 844       strncpy (section.s_name, current->name, SCNNMLEN);
 845
 846       section.s_vaddr = current->vma;
 847       section.s_paddr = current->lma;
 848       section.s_size =  current->size;
 849
 850       /* If this section has no size or is unloadable then the scnptr
 851          will be 0 too.  */
 852       if (current->size == 0
 853           || (current->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
 854         {
 855           section.s_scnptr = 0;
 856         }
 857       else
 858         {
 859           section.s_scnptr = current->filepos;
 860         }
 861
 862       section.s_relptr = current->rel_filepos;
 863       section.s_lnnoptr = current->line_filepos;
 864       section.s_nreloc = current->reloc_count;
 865
 866       section.s_nlnno = current->lineno_count;
 867       if (current->reloc_count != 0)
 868         hasrelocs = TRUE;
 869       if (current->lineno_count != 0)
 870         haslinno = TRUE;
 871
 872       section.s_flags = sec_to_styp_flags (current->name, current->flags);
 873
 874       if (!strcmp (current->name, _TEXT))
 875         {
 876           text_sec = current;
 877         }
 878       else if (!strcmp (current->name, _DATA))
 879         {
 880           data_sec = current;
 881         }
 882       else if (!strcmp (current->name, _BSS))
 883         {
 884           bss_sec = current;
 885         }
 886
 887       amount = bfd_coff_scnhsz (abfd);
 888       if (bfd_coff_swap_scnhdr_out (abfd, &section, &buff) == 0
 889           || bfd_bwrite ((PTR) (&buff), amount, abfd) != amount)
 890         return FALSE;
 891     }
 892
 893   internal_f.f_timdat = 0;
 894
 895   internal_f.f_flags = 0;
 896
 897   if (!hasrelocs)
 898     internal_f.f_flags |= F_RELFLG;
 899   if (!haslinno)
 900     internal_f.f_flags |= F_LNNO;
 901   if (abfd->flags & EXEC_P)
 902     internal_f.f_flags |= F_EXEC;
 903
 904   /* FIXME: this is wrong for PPC_PE!  */
 905   if (bfd_little_endian (abfd))
 906     internal_f.f_flags |= F_AR32WR;
 907   else
 908     internal_f.f_flags |= F_AR32W;
 909
 910   if ((abfd->flags & DYNAMIC) != 0)
 911     internal_f.f_flags |= F_SHROBJ;
 912   if (bfd_get_section_by_name (abfd, _LOADER) != NULL)
 913     internal_f.f_flags |= F_DYNLOAD;
 914
 915   memset (&internal_a, 0, sizeof internal_a);
 916
 917   internal_f.f_magic = bfd_xcoff_magic_number (abfd);
 918   internal_a.magic = (abfd->flags & D_PAGED
 919                       ? RS6K_AOUTHDR_ZMAGIC
 920                       : (abfd->flags & WP_TEXT
 921                          ? RS6K_AOUTHDR_NMAGIC
 922                          : RS6K_AOUTHDR_OMAGIC));
 923
 924   /* FIXME: Does anybody ever set this to another value?  */
 925   internal_a.vstamp = 0;
 926
 927   /* Now should write relocs, strings, syms.  */
 928   obj_sym_filepos (abfd) = sym_base;
 929
 930   internal_f.f_symptr = 0;
 931   internal_f.f_nsyms = 0;
 932
 933   /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
 934      backend linker, and obj_raw_syment_count is not valid until after
 935      coff_write_symbols is called.  */
 936   if (bfd_get_symcount (abfd) != 0)
 937     {
 938       int firstundef;
 939
 940       if (!coff_renumber_symbols (abfd, &firstundef))
 941         return FALSE;
 942       coff_mangle_symbols (abfd);
 943       if (! coff_write_symbols (abfd))
 944         return FALSE;
 945       if (! coff_write_linenumbers (abfd))
 946         return FALSE;
 947       if (! coff_write_relocs (abfd, firstundef))
 948         return FALSE;
 949
 950       internal_f.f_symptr = sym_base;
 951       internal_f.f_nsyms = bfd_get_symcount (abfd);
 952     }
 953   else if (obj_raw_syment_count (abfd) != 0)
 954     {
 955       internal_f.f_symptr = sym_base;
 956
 957       /* AIX appears to require that F_RELFLG not be set if there are
 958          local symbols but no relocations.  */
 959       internal_f.f_flags &=~ F_RELFLG;
 960     }
 961   else
 962     {
 963       internal_f.f_flags |= F_LSYMS;
 964     }
 965
 966   if (text_sec)
 967     {
 968       internal_a.tsize = text_sec->size;
 969       internal_a.text_start = internal_a.tsize ? text_sec->vma : 0;
 970     }
 971
 972   if (data_sec)
 973     {
 974       internal_a.dsize = data_sec->size;
 975       internal_a.data_start = internal_a.dsize ? data_sec->vma : 0;
 976     }
 977
 978   if (bss_sec)
 979     {
 980       internal_a.bsize = bss_sec->size;
 981       if (internal_a.bsize && bss_sec->vma < internal_a.data_start)
 982         internal_a.data_start = bss_sec->vma;
 983     }
 984
 985   internal_a.entry = bfd_get_start_address (abfd);
 986   internal_f.f_nsyms = obj_raw_syment_count (abfd);
 987
 988   if (xcoff_data (abfd)->full_aouthdr)
 989     {
 990       bfd_vma toc;
 991       asection *loader_sec;
 992
 993       internal_a.vstamp = 1;
 994
 995       internal_a.o_snentry = xcoff_data (abfd)->snentry;
 996       if (internal_a.o_snentry == 0)
 997         internal_a.entry = (bfd_vma) -1;
 998
 999       if (text_sec != NULL)
1000         {
1001           internal_a.o_sntext = text_sec->target_index;
1002           internal_a.o_algntext = bfd_get_section_alignment (abfd, text_sec);
1003         }
1004       else
1005         {
1006           internal_a.o_sntext = 0;
1007           internal_a.o_algntext = 0;
1008         }
1009
1010       if (data_sec != NULL)
1011         {
1012           internal_a.o_sndata = data_sec->target_index;
1013           internal_a.o_algndata = bfd_get_section_alignment (abfd, data_sec);
1014         }
1015       else
1016         {
1017           internal_a.o_sndata = 0;
1018           internal_a.o_algndata = 0;
1019         }
1020
1021       loader_sec = bfd_get_section_by_name (abfd, ".loader");
1022       if (loader_sec != NULL)
1023         internal_a.o_snloader = loader_sec->target_index;
1024       else
1025         internal_a.o_snloader = 0;
1026       if (bss_sec != NULL)
1027         internal_a.o_snbss = bss_sec->target_index;
1028       else
1029         internal_a.o_snbss = 0;
1030
1031       toc = xcoff_data (abfd)->toc;
1032       internal_a.o_toc = toc;
1033       internal_a.o_sntoc = xcoff_data (abfd)->sntoc;
1034
1035       internal_a.o_modtype = xcoff_data (abfd)->modtype;
1036       if (xcoff_data (abfd)->cputype != -1)
1037         internal_a.o_cputype = xcoff_data (abfd)->cputype;
1038       else
1039         {
1040           switch (bfd_get_arch (abfd))
1041             {
1042             case bfd_arch_rs6000:
1043               internal_a.o_cputype = 4;
1044               break;
1045             case bfd_arch_powerpc:
1046               if (bfd_get_mach (abfd) == bfd_mach_ppc)
1047                 internal_a.o_cputype = 3;
1048               else
1049                 internal_a.o_cputype = 1;
1050               break;
1051             default:
1052               abort ();
1053             }
1054         }
1055       internal_a.o_maxstack = xcoff_data (abfd)->maxstack;
1056       internal_a.o_maxdata = xcoff_data (abfd)->maxdata;
1057     }
1058
1059   if (bfd_seek (abfd, (file_ptr) 0, 0) != 0)
1060     return FALSE;
1061
1062   {
1063     char * buff;
1064     bfd_size_type amount = bfd_coff_filhsz (abfd);
1065
1066     buff = bfd_malloc (amount);
1067     if (buff == NULL)
1068       return FALSE;
1069
1070     bfd_coff_swap_filehdr_out (abfd, (PTR) &internal_f, (PTR) buff);
1071     amount = bfd_bwrite ((PTR) buff, amount, abfd);
1072
1073     free (buff);
1074
1075     if (amount != bfd_coff_filhsz (abfd))
1076       return FALSE;
1077   }
1078
1079   if (abfd->flags & EXEC_P)
1080     {
1081       char * buff;
1082       bfd_size_type amount = bfd_coff_aoutsz (abfd);
1083
1084       buff = bfd_malloc (amount);
1085       if (buff == NULL)
1086         return FALSE;
1087
1088       bfd_coff_swap_aouthdr_out (abfd, (PTR) &internal_a, (PTR) buff);
1089       amount = bfd_bwrite ((PTR) buff, amount, abfd);
1090
1091       free (buff);
1092
1093       if (amount != bfd_coff_aoutsz (abfd))
1094         return FALSE;
1095     }
1096
1097   return TRUE;
1098 }
1099
1100 static bfd_boolean
1101 xcoff64_reloc_type_br (input_bfd, input_section, output_bfd, rel, sym, howto,
1102                        val, addend, relocation, contents)
1103      bfd *input_bfd;
1104      asection *input_section;
1105      bfd *output_bfd ATTRIBUTE_UNUSED;
1106      struct internal_reloc *rel;
1107      struct internal_syment *sym ATTRIBUTE_UNUSED;
1108      struct reloc_howto_struct *howto;
1109      bfd_vma val;
1110      bfd_vma addend;
1111      bfd_vma *relocation;
1112      bfd_byte *contents;
1113 {
1114   struct xcoff_link_hash_entry *h;
1115
1116   if (0 > rel->r_symndx)
1117     return FALSE;
1118
1119   h = obj_xcoff_sym_hashes (input_bfd)[rel->r_symndx];
1120
1121   /* If we see an R_BR or R_RBR reloc which is jumping to global
1122      linkage code, and it is followed by an appropriate cror nop
1123      instruction, we replace the cror with ld r2,40(r1).  This
1124      restores the TOC after the glink code.  Contrariwise, if the
1125      call is followed by a ld r2,40(r1), but the call is not
1126      going to global linkage code, we can replace the load with a
1127      cror.  */
1128   if (NULL != h
1129       && bfd_link_hash_defined == h->root.type
1130       && rel->r_vaddr - input_section->vma + 8 <= input_section->size)
1131     {
1132       bfd_byte *pnext;
1133       unsigned long next;
1134
1135       pnext = contents + (rel->r_vaddr - input_section->vma) + 4;
1136       next = bfd_get_32 (input_bfd, pnext);
1137
1138       /* The _ptrgl function is magic.  It is used by the AIX compiler to call
1139          a function through a pointer.  */
1140       if (h->smclas == XMC_GL || strcmp (h->root.root.string, "._ptrgl") == 0)
1141         {
1142           if (next == 0x4def7b82                        /* cror 15,15,15  */
1143               || next == 0x4ffffb82                     /* cror 31,31,31  */
1144               || next == 0x60000000)                    /* ori  r0,r0,0   */
1145             bfd_put_32 (input_bfd, 0xe8410028, pnext);  /* ld   r2,40(r1) */
1146         }
1147       else
1148         {
1149           if (next == 0xe8410028)                       /* ld r2,40(r1)   */
1150             bfd_put_32 (input_bfd, 0x60000000, pnext);  /* ori r0,r0,0    */
1151         }
1152     }
1153   else if (NULL != h && bfd_link_hash_undefined == h->root.type)
1154     {
1155       /* Normally, this relocation is against a defined symbol.  In the
1156          case where this is a partial link and the output section offset
1157          is greater than 2^25, the linker will return an invalid error
1158          message that the relocation has been truncated.  Yes it has been
1159          truncated but no it not important.  For this case, disable the
1160          overflow checking. */
1161       howto->complain_on_overflow = complain_overflow_dont;
1162     }
1163
1164   howto->pc_relative = TRUE;
1165   howto->src_mask &= ~3;
1166   howto->dst_mask = howto->src_mask;
1167
1168   /* A PC relative reloc includes the section address.  */
1169   addend += input_section->vma;
1170
1171   *relocation = val + addend;
1172   *relocation -= (input_section->output_section->vma
1173                   + input_section->output_offset);
1174   return TRUE;
1175 }
1176
1177 /* This is the relocation function for the PowerPC64.
1178    See xcoff_ppc_relocation_section for more information. */
1179
1180 bfd_boolean
1181 xcoff64_ppc_relocate_section (output_bfd, info, input_bfd,
1182                               input_section, contents, relocs, syms,
1183                               sections)
1184      bfd *output_bfd;
1185      struct bfd_link_info *info;
1186      bfd *input_bfd;
1187      asection *input_section;
1188      bfd_byte *contents;
1189      struct internal_reloc *relocs;
1190      struct internal_syment *syms;
1191      asection **sections;
1192 {
1193   struct internal_reloc *rel;
1194   struct internal_reloc *relend;
1195
1196   rel = relocs;
1197   relend = rel + input_section->reloc_count;
1198   for (; rel < relend; rel++)
1199     {
1200       long symndx;
1201       struct xcoff_link_hash_entry *h;
1202       struct internal_syment *sym;
1203       bfd_vma addend;
1204       bfd_vma val;
1205       struct reloc_howto_struct howto;
1206       bfd_vma relocation;
1207       bfd_vma value_to_relocate;
1208       bfd_vma address;
1209       bfd_byte *location;
1210
1211       /* Relocation type R_REF is a special relocation type which is
1212          merely used to prevent garbage collection from occurring for
1213          the csect including the symbol which it references.  */
1214       if (rel->r_type == R_REF)
1215         continue;
1216
1217       /* howto */
1218       howto.type = rel->r_type;
1219       howto.rightshift = 0;
1220       howto.bitsize = (rel->r_size & 0x3f) + 1;
1221       howto.size = howto.bitsize > 16 ? (howto.bitsize > 32 ? 4 : 2) : 1;
1222       howto.pc_relative = FALSE;
1223       howto.bitpos = 0;
1224       howto.complain_on_overflow = (rel->r_size & 0x80
1225                                     ? complain_overflow_signed
1226                                     : complain_overflow_bitfield);
1227       howto.special_function = NULL;
1228       howto.name = "internal";
1229       howto.partial_inplace = TRUE;
1230       howto.src_mask = howto.dst_mask = N_ONES (howto.bitsize);
1231       howto.pcrel_offset = FALSE;
1232
1233       /* symbol */
1234       val = 0;
1235       addend = 0;
1236       h = NULL;
1237       sym = NULL;
1238       symndx = rel->r_symndx;
1239
1240       if (-1 != symndx)
1241         {
1242           asection *sec;
1243
1244           h = obj_xcoff_sym_hashes (input_bfd)[symndx];
1245           sym = syms + symndx;
1246           addend = - sym->n_value;
1247
1248           if (NULL == h)
1249             {
1250               sec = sections[symndx];
1251               /* Hack to make sure we use the right TOC anchor value
1252                  if this reloc is against the TOC anchor.  */
1253               if (sec->name[3] == '0'
1254                   && strcmp (sec->name, ".tc0") == 0)
1255                 val = xcoff_data (output_bfd)->toc;
1256               else
1257                 val = (sec->output_section->vma
1258                        + sec->output_offset
1259                        + sym->n_value
1260                        - sec->vma);
1261             }
1262           else
1263             {
1264               if (h->root.type == bfd_link_hash_defined
1265                   || h->root.type == bfd_link_hash_defweak)
1266                 {
1267                   sec = h->root.u.def.section;
1268                   val = (h->root.u.def.value
1269                          + sec->output_section->vma
1270                          + sec->output_offset);
1271                 }
1272               else if (h->root.type == bfd_link_hash_common)
1273                 {
1274                   sec = h->root.u.c.p->section;
1275                   val = (sec->output_section->vma
1276                          + sec->output_offset);
1277                 }
1278               else if ((0 == (h->flags & (XCOFF_DEF_DYNAMIC | XCOFF_IMPORT)))
1279                        && ! info->relocatable)
1280                 {
1281                   if (! ((*info->callbacks->undefined_symbol)
1282                          (info, h->root.root.string, input_bfd, input_section,
1283                           rel->r_vaddr - input_section->vma, TRUE)))
1284                     return FALSE;
1285
1286                   /* Don't try to process the reloc.  It can't help, and
1287                      it may generate another error.  */
1288                   continue;
1289                 }
1290             }
1291         }
1292
1293       if (rel->r_type >= XCOFF_MAX_CALCULATE_RELOCATION
1294           || !((*xcoff64_calculate_relocation[rel->r_type])
1295               (input_bfd, input_section, output_bfd, rel, sym, &howto, val,
1296                addend, &relocation, contents)))
1297         return FALSE;
1298
1299       /* address */
1300       address = rel->r_vaddr - input_section->vma;
1301       location = contents + address;
1302
1303       if (address > input_section->size)
1304         abort ();
1305
1306       /* Get the value we are going to relocate.  */
1307       if (1 == howto.size)
1308         value_to_relocate = bfd_get_16 (input_bfd, location);
1309       else if (2 == howto.size)
1310         value_to_relocate = bfd_get_32 (input_bfd, location);
1311       else
1312         value_to_relocate = bfd_get_64 (input_bfd, location);
1313
1314       /* overflow.
1315
1316          FIXME: We may drop bits during the addition
1317          which we don't check for.  We must either check at every single
1318          operation, which would be tedious, or we must do the computations
1319          in a type larger than bfd_vma, which would be inefficient.  */
1320
1321       if ((unsigned int) howto.complain_on_overflow
1322           >= XCOFF_MAX_COMPLAIN_OVERFLOW)
1323         abort ();
1324
1325       if (((*xcoff_complain_overflow[howto.complain_on_overflow])
1326            (input_bfd, value_to_relocate, relocation, &howto)))
1327         {
1328           const char *name;
1329           char buf[SYMNMLEN + 1];
1330           char reloc_type_name[10];
1331
1332           if (symndx == -1)
1333             {
1334               name = "*ABS*";
1335             }
1336           else if (h != NULL)
1337             {
1338               name = NULL;
1339             }
1340           else
1341             {
1342               name = _bfd_coff_internal_syment_name (input_bfd, sym, buf);
1343               if (name == NULL)
1344                 name = "UNKNOWN";
1345             }
1346           sprintf (reloc_type_name, "0x%02x", rel->r_type);
1347
1348           if (! ((*info->callbacks->reloc_overflow)
1349                  (info, (h ? &h->root : NULL), name, reloc_type_name,
1350                   (bfd_vma) 0, input_bfd, input_section,
1351                   rel->r_vaddr - input_section->vma)))
1352             return FALSE;
1353         }
1354
1355       /* Add RELOCATION to the right bits of VALUE_TO_RELOCATE.  */
1356       value_to_relocate = ((value_to_relocate & ~howto.dst_mask)
1357                            | (((value_to_relocate & howto.src_mask)
1358                                + relocation) & howto.dst_mask));
1359
1360       /* Put the value back in the object file.  */
1361       if (1 == howto.size)
1362         bfd_put_16 (input_bfd, value_to_relocate, location);
1363       else if (2 == howto.size)
1364         bfd_put_32 (input_bfd, value_to_relocate, location);
1365       else
1366         bfd_put_64 (input_bfd, value_to_relocate, location);
1367
1368     }
1369   return TRUE;
1370 }
1371
1372 \f
1373 /* The XCOFF reloc table.  Actually, XCOFF relocations specify the
1374    bitsize and whether they are signed or not, along with a
1375    conventional type.  This table is for the types, which are used for
1376    different algorithms for putting in the reloc.  Many of these
1377    relocs need special_function entries, which I have not written.  */
1378
1379 reloc_howto_type xcoff64_howto_table[] =
1380 {
1381   /* Standard 64 bit relocation.  */
1382   HOWTO (R_POS,                 /* type */
1383          0,                     /* rightshift */
1384          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1385          64,                    /* bitsize */
1386          FALSE,                 /* pc_relative */
1387          0,                     /* bitpos */
1388          complain_overflow_bitfield, /* complain_on_overflow */
1389          0,                     /* special_function */
1390          "R_POS_64",            /* name */
1391          TRUE,                  /* partial_inplace */
1392          MINUS_ONE,             /* src_mask */
1393          MINUS_ONE,             /* dst_mask */
1394          FALSE),                /* pcrel_offset */
1395
1396   /* 64 bit relocation, but store negative value.  */
1397   HOWTO (R_NEG,                 /* type */
1398          0,                     /* rightshift */
1399          -4,                    /* size (0 = byte, 1 = short, 2 = long) */
1400          64,                    /* bitsize */
1401          FALSE,                 /* pc_relative */
1402          0,                     /* bitpos */
1403          complain_overflow_bitfield, /* complain_on_overflow */
1404          0,                     /* special_function */
1405          "R_NEG",               /* name */
1406          TRUE,                  /* partial_inplace */
1407          MINUS_ONE,             /* src_mask */
1408          MINUS_ONE,             /* dst_mask */
1409          FALSE),                /* pcrel_offset */
1410
1411   /* 32 bit PC relative relocation.  */
1412   HOWTO (R_REL,                 /* type */
1413          0,                     /* rightshift */
1414          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1415          32,                    /* bitsize */
1416          TRUE,                  /* pc_relative */
1417          0,                     /* bitpos */
1418          complain_overflow_signed, /* complain_on_overflow */
1419          0,                     /* special_function */
1420          "R_REL",               /* name */
1421          TRUE,                  /* partial_inplace */
1422          0xffffffff,            /* src_mask */
1423          0xffffffff,            /* dst_mask */
1424          FALSE),                /* pcrel_offset */
1425
1426   /* 16 bit TOC relative relocation.  */
1427   HOWTO (R_TOC,                 /* type */
1428          0,                     /* rightshift */
1429          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1430          16,                    /* bitsize */
1431          FALSE,                 /* pc_relative */
1432          0,                     /* bitpos */
1433          complain_overflow_bitfield, /* complain_on_overflow */
1434          0,                     /* special_function */
1435          "R_TOC",               /* name */
1436          TRUE,                  /* partial_inplace */
1437          0xffff,                /* src_mask */
1438          0xffff,                /* dst_mask */
1439          FALSE),                /* pcrel_offset */
1440
1441   /* I don't really know what this is.  */
1442   HOWTO (R_RTB,                 /* type */
1443          1,                     /* rightshift */
1444          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1445          32,                    /* bitsize */
1446          FALSE,                 /* pc_relative */
1447          0,                     /* bitpos */
1448          complain_overflow_bitfield, /* complain_on_overflow */
1449          0,                     /* special_function */
1450          "R_RTB",               /* name */
1451          TRUE,                  /* partial_inplace */
1452          0xffffffff,            /* src_mask */
1453          0xffffffff,            /* dst_mask */
1454          FALSE),                /* pcrel_offset */
1455
1456   /* External TOC relative symbol.  */
1457   HOWTO (R_GL,                  /* type */
1458          0,                     /* rightshift */
1459          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1460          16,                    /* bitsize */
1461          FALSE,                 /* pc_relative */
1462          0,                     /* bitpos */
1463          complain_overflow_bitfield, /* complain_on_overflow */
1464          0,                     /* special_function */
1465          "R_GL",                /* name */
1466          TRUE,                  /* partial_inplace */
1467          0xffff,                /* src_mask */
1468          0xffff,                /* dst_mask */
1469          FALSE),                /* pcrel_offset */
1470
1471   /* Local TOC relative symbol.  */
1472   HOWTO (R_TCL,                 /* type */
1473          0,                     /* rightshift */
1474          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1475          16,                    /* bitsize */
1476          FALSE,                 /* pc_relative */
1477          0,                     /* bitpos */
1478          complain_overflow_bitfield, /* complain_on_overflow */
1479          0,                     /* special_function */
1480          "R_TCL",               /* name */
1481          TRUE,                  /* partial_inplace */
1482          0xffff,                /* src_mask */
1483          0xffff,                /* dst_mask */
1484          FALSE),                /* pcrel_offset */
1485
1486   EMPTY_HOWTO (7),
1487
1488   /* Non modifiable absolute branch.  */
1489   HOWTO (R_BA,                  /* type */
1490          0,                     /* rightshift */
1491          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1492          26,                    /* bitsize */
1493          FALSE,                 /* pc_relative */
1494          0,                     /* bitpos */
1495          complain_overflow_bitfield, /* complain_on_overflow */
1496          0,                     /* special_function */
1497          "R_BA_26",             /* name */
1498          TRUE,                  /* partial_inplace */
1499          0x03fffffc,            /* src_mask */
1500          0x03fffffc,            /* dst_mask */
1501          FALSE),                /* pcrel_offset */
1502
1503   EMPTY_HOWTO (9),
1504
1505   /* Non modifiable relative branch.  */
1506   HOWTO (R_BR,                  /* type */
1507          0,                     /* rightshift */
1508          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1509          26,                    /* bitsize */
1510          TRUE,                  /* pc_relative */
1511          0,                     /* bitpos */
1512          complain_overflow_signed, /* complain_on_overflow */
1513          0,                     /* special_function */
1514          "R_BR",                /* name */
1515          TRUE,                  /* partial_inplace */
1516          0x03fffffc,            /* src_mask */
1517          0x03fffffc,            /* dst_mask */
1518          FALSE),                /* pcrel_offset */
1519
1520   EMPTY_HOWTO (0xb),
1521
1522   /* Indirect load.  */
1523   HOWTO (R_RL,                  /* type */
1524          0,                     /* rightshift */
1525          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1526          16,                    /* bitsize */
1527          FALSE,                 /* pc_relative */
1528          0,                     /* bitpos */
1529          complain_overflow_bitfield, /* complain_on_overflow */
1530          0,                     /* special_function */
1531          "R_RL",                /* name */
1532          TRUE,                  /* partial_inplace */
1533          0xffff,                /* src_mask */
1534          0xffff,                /* dst_mask */
1535          FALSE),                /* pcrel_offset */
1536
1537   /* Load address.  */
1538   HOWTO (R_RLA,                 /* type */
1539          0,                     /* rightshift */
1540          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1541          16,                    /* bitsize */
1542          FALSE,                 /* pc_relative */
1543          0,                     /* bitpos */
1544          complain_overflow_bitfield, /* complain_on_overflow */
1545          0,                     /* special_function */
1546          "R_RLA",               /* name */
1547          TRUE,                  /* partial_inplace */
1548          0xffff,                /* src_mask */
1549          0xffff,                /* dst_mask */
1550          FALSE),                /* pcrel_offset */
1551
1552   EMPTY_HOWTO (0xe),
1553
1554   /* Non-relocating reference.  */
1555   HOWTO (R_REF,                 /* type */
1556          0,                     /* rightshift */
1557          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1558          32,                    /* bitsize */
1559          FALSE,                 /* pc_relative */
1560          0,                     /* bitpos */
1561          complain_overflow_dont, /* complain_on_overflow */
1562          0,                     /* special_function */
1563          "R_REF",               /* name */
1564          FALSE,                 /* partial_inplace */
1565          0,                     /* src_mask */
1566          0,                     /* dst_mask */
1567          FALSE),                /* pcrel_offset */
1568
1569   EMPTY_HOWTO (0x10),
1570   EMPTY_HOWTO (0x11),
1571
1572   /* TOC relative indirect load.  */
1573   HOWTO (R_TRL,                 /* type */
1574          0,                     /* rightshift */
1575          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1576          16,                    /* bitsize */
1577          FALSE,                 /* pc_relative */
1578          0,                     /* bitpos */
1579          complain_overflow_bitfield, /* complain_on_overflow */
1580          0,                     /* special_function */
1581          "R_TRL",               /* name */
1582          TRUE,                  /* partial_inplace */
1583          0xffff,                /* src_mask */
1584          0xffff,                /* dst_mask */
1585          FALSE),                /* pcrel_offset */
1586
1587   /* TOC relative load address.  */
1588   HOWTO (R_TRLA,                /* type */
1589          0,                     /* rightshift */
1590          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1591          16,                    /* bitsize */
1592          FALSE,                 /* pc_relative */
1593          0,                     /* bitpos */
1594          complain_overflow_bitfield, /* complain_on_overflow */
1595          0,                     /* special_function */
1596          "R_TRLA",              /* name */
1597          TRUE,                  /* partial_inplace */
1598          0xffff,                /* src_mask */
1599          0xffff,                /* dst_mask */
1600          FALSE),                /* pcrel_offset */
1601
1602   /* Modifiable relative branch.  */
1603   HOWTO (R_RRTBI,               /* type */
1604          1,                     /* rightshift */
1605          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1606          32,                    /* bitsize */
1607          FALSE,                 /* pc_relative */
1608          0,                     /* bitpos */
1609          complain_overflow_bitfield, /* complain_on_overflow */
1610          0,                     /* special_function */
1611          "R_RRTBI",             /* name */
1612          TRUE,                  /* partial_inplace */
1613          0xffffffff,            /* src_mask */
1614          0xffffffff,            /* dst_mask */
1615          FALSE),                /* pcrel_offset */
1616
1617   /* Modifiable absolute branch.  */
1618   HOWTO (R_RRTBA,               /* type */
1619          1,                     /* rightshift */
1620          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1621          32,                    /* bitsize */
1622          FALSE,                 /* pc_relative */
1623          0,                     /* bitpos */
1624          complain_overflow_bitfield, /* complain_on_overflow */
1625          0,                     /* special_function */
1626          "R_RRTBA",             /* name */
1627          TRUE,                  /* partial_inplace */
1628          0xffffffff,            /* src_mask */
1629          0xffffffff,            /* dst_mask */
1630          FALSE),                /* pcrel_offset */
1631
1632   /* Modifiable call absolute indirect.  */
1633   HOWTO (R_CAI,                 /* type */
1634          0,                     /* rightshift */
1635          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1636          16,                    /* bitsize */
1637          FALSE,                 /* pc_relative */
1638          0,                     /* bitpos */
1639          complain_overflow_bitfield, /* complain_on_overflow */
1640          0,                     /* special_function */
1641          "R_CAI",               /* name */
1642          TRUE,                  /* partial_inplace */
1643          0xffff,                /* src_mask */
1644          0xffff,                /* dst_mask */
1645          FALSE),                /* pcrel_offset */
1646
1647   /* Modifiable call relative.  */
1648   HOWTO (R_CREL,                /* type */
1649          0,                     /* rightshift */
1650          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1651          16,                    /* bitsize */
1652          FALSE,                 /* pc_relative */
1653          0,                     /* bitpos */
1654          complain_overflow_bitfield, /* complain_on_overflow */
1655          0,                     /* special_function */
1656          "R_CREL",              /* name */
1657          TRUE,                  /* partial_inplace */
1658          0xffff,                /* src_mask */
1659          0xffff,                /* dst_mask */
1660          FALSE),                /* pcrel_offset */
1661
1662   /* Modifiable branch absolute.  */
1663   HOWTO (R_RBA,                 /* type */
1664          0,                     /* rightshift */
1665          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1666          26,                    /* bitsize */
1667          FALSE,                 /* pc_relative */
1668          0,                     /* bitpos */
1669          complain_overflow_bitfield, /* complain_on_overflow */
1670          0,                     /* special_function */
1671          "R_RBA",               /* name */
1672          TRUE,                  /* partial_inplace */
1673          0x03fffffc,            /* src_mask */
1674          0x03fffffc,            /* dst_mask */
1675          FALSE),                /* pcrel_offset */
1676
1677   /* Modifiable branch absolute.  */
1678   HOWTO (R_RBAC,                /* type */
1679          0,                     /* rightshift */
1680          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1681          32,                    /* bitsize */
1682          FALSE,                 /* pc_relative */
1683          0,                     /* bitpos */
1684          complain_overflow_bitfield, /* complain_on_overflow */
1685          0,                     /* special_function */
1686          "R_RBAC",              /* name */
1687          TRUE,                  /* partial_inplace */
1688          0xffffffff,            /* src_mask */
1689          0xffffffff,            /* dst_mask */
1690          FALSE),                /* pcrel_offset */
1691
1692   /* Modifiable branch relative.  */
1693   HOWTO (R_RBR,                 /* type */
1694          0,                     /* rightshift */
1695          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1696          26,                    /* bitsize */
1697          FALSE,                 /* pc_relative */
1698          0,                     /* bitpos */
1699          complain_overflow_signed, /* complain_on_overflow */
1700          0,                     /* special_function */
1701          "R_RBR_26",            /* name */
1702          TRUE,                  /* partial_inplace */
1703          0x03fffffc,            /* src_mask */
1704          0x03fffffc,            /* dst_mask */
1705          FALSE),                /* pcrel_offset */
1706
1707   /* Modifiable branch absolute.  */
1708   HOWTO (R_RBRC,                /* type */
1709          0,                     /* rightshift */
1710          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1711          16,                    /* bitsize */
1712          FALSE,                 /* pc_relative */
1713          0,                     /* bitpos */
1714          complain_overflow_bitfield, /* complain_on_overflow */
1715          0,                     /* special_function */
1716          "R_RBRC",              /* name */
1717          TRUE,                  /* partial_inplace */
1718          0xffff,                /* src_mask */
1719          0xffff,                /* dst_mask */
1720          FALSE),                /* pcrel_offset */
1721
1722   HOWTO (R_POS,                 /* type */
1723          0,                     /* rightshift */
1724          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1725          32,                    /* bitsize */
1726          FALSE,                 /* pc_relative */
1727          0,                     /* bitpos */
1728          complain_overflow_bitfield, /* complain_on_overflow */
1729          0,                     /* special_function */
1730          "R_POS_32",            /* name */
1731          TRUE,                  /* partial_inplace */
1732          0xffffffff,            /* src_mask */
1733          0xffffffff,            /* dst_mask */
1734          FALSE),                /* pcrel_offset */
1735
1736   /* 16 bit Non modifiable absolute branch.  */
1737   HOWTO (R_BA,                  /* type */
1738          0,                     /* rightshift */
1739          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1740          16,                    /* bitsize */
1741          FALSE,                 /* pc_relative */
1742          0,                     /* bitpos */
1743          complain_overflow_bitfield, /* complain_on_overflow */
1744          0,                     /* special_function */
1745          "R_BA_16",             /* name */
1746          TRUE,                  /* partial_inplace */
1747          0xfffc,                /* src_mask */
1748          0xfffc,                /* dst_mask */
1749          FALSE),                /* pcrel_offset */
1750
1751   /* Modifiable branch relative.  */
1752   HOWTO (R_RBR,                 /* type */
1753          0,                     /* rightshift */
1754          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1755          16,                    /* bitsize */
1756          FALSE,                 /* pc_relative */
1757          0,                     /* bitpos */
1758          complain_overflow_signed, /* complain_on_overflow */
1759          0,                     /* special_function */
1760          "R_RBR_16",            /* name */
1761          TRUE,                  /* partial_inplace */
1762          0xffff,                /* src_mask */
1763          0xffff,                /* dst_mask */
1764          FALSE),                /* pcrel_offset */
1765
1766   /* Modifiable branch absolute.  */
1767   HOWTO (R_RBA,                 /* type */
1768          0,                     /* rightshift */
1769          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1770          16,                    /* bitsize */
1771          FALSE,                 /* pc_relative */
1772          0,                     /* bitpos */
1773          complain_overflow_bitfield, /* complain_on_overflow */
1774          0,                     /* special_function */
1775          "R_RBA_16",            /* name */
1776          TRUE,                  /* partial_inplace */
1777          0xffff,                /* src_mask */
1778          0xffff,                /* dst_mask */
1779          FALSE),                /* pcrel_offset */
1780
1781 };
1782
1783 void
1784 xcoff64_rtype2howto (relent, internal)
1785      arelent *relent;
1786      struct internal_reloc *internal;
1787 {
1788   if (internal->r_type > R_RBRC)
1789     abort ();
1790
1791   /* Default howto layout works most of the time */
1792   relent->howto = &xcoff64_howto_table[internal->r_type];
1793
1794   /* Special case some 16 bit reloc */
1795   if (15 == (internal->r_size & 0x3f))
1796     {
1797       if (R_BA == internal->r_type)
1798         relent->howto = &xcoff64_howto_table[0x1d];
1799       else if (R_RBR == internal->r_type)
1800         relent->howto = &xcoff64_howto_table[0x1e];
1801       else if (R_RBA == internal->r_type)
1802         relent->howto = &xcoff64_howto_table[0x1f];
1803     }
1804   /* Special case 32 bit */
1805   else if (31 == (internal->r_size & 0x3f))
1806     {
1807       if (R_POS == internal->r_type)
1808         relent->howto = &xcoff64_howto_table[0x1c];
1809     }
1810
1811   /* The r_size field of an XCOFF reloc encodes the bitsize of the
1812      relocation, as well as indicating whether it is signed or not.
1813      Doublecheck that the relocation information gathered from the
1814      type matches this information.  The bitsize is not significant
1815      for R_REF relocs.  */
1816   if (relent->howto->dst_mask != 0
1817       && (relent->howto->bitsize
1818           != ((unsigned int) internal->r_size & 0x3f) + 1))
1819     abort ();
1820 }
1821
1822 reloc_howto_type *
1823 xcoff64_reloc_type_lookup (abfd, code)
1824      bfd *abfd ATTRIBUTE_UNUSED;
1825      bfd_reloc_code_real_type code;
1826 {
1827   switch (code)
1828     {
1829     case BFD_RELOC_PPC_B26:
1830       return &xcoff64_howto_table[0xa];
1831     case BFD_RELOC_PPC_BA16:
1832       return &xcoff64_howto_table[0x1d];
1833     case BFD_RELOC_PPC_BA26:
1834       return &xcoff64_howto_table[8];
1835     case BFD_RELOC_PPC_TOC16:
1836       return &xcoff64_howto_table[3];
1837     case BFD_RELOC_32:
1838     case BFD_RELOC_CTOR:
1839       return &xcoff64_howto_table[0x1c];
1840     case BFD_RELOC_64:
1841       return &xcoff64_howto_table[0];
1842     default:
1843       return NULL;
1844     }
1845 }
1846
1847 static reloc_howto_type *
1848 xcoff64_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1849                            const char *r_name)
1850 {
1851   unsigned int i;
1852
1853   for (i = 0;
1854        i < sizeof (xcoff64_howto_table) / sizeof (xcoff64_howto_table[0]);
1855        i++)
1856     if (xcoff64_howto_table[i].name != NULL
1857         && strcasecmp (xcoff64_howto_table[i].name, r_name) == 0)
1858       return &xcoff64_howto_table[i];
1859
1860   return NULL;
1861 }
1862
1863 /* Read in the armap of an XCOFF archive.  */
1864
1865 static bfd_boolean
1866 xcoff64_slurp_armap (abfd)
1867      bfd *abfd;
1868 {
1869   file_ptr off;
1870   size_t namlen;
1871   bfd_size_type sz, amt;
1872   bfd_byte *contents, *cend;
1873   bfd_vma c, i;
1874   carsym *arsym;
1875   bfd_byte *p;
1876   file_ptr pos;
1877
1878   /* This is for the new format.  */
1879   struct xcoff_ar_hdr_big hdr;
1880
1881   if (xcoff_ardata (abfd) == NULL)
1882     {
1883       bfd_has_map (abfd) = FALSE;
1884       return TRUE;
1885     }
1886
1887   off = bfd_scan_vma (xcoff_ardata_big (abfd)->symoff64,
1888                       (const char **) NULL, 10);
1889   if (off == 0)
1890     {
1891       bfd_has_map (abfd) = FALSE;
1892       return TRUE;
1893     }
1894
1895   if (bfd_seek (abfd, off, SEEK_SET) != 0)
1896     return FALSE;
1897
1898   /* The symbol table starts with a normal archive header.  */
1899   if (bfd_bread ((PTR) &hdr, (bfd_size_type) SIZEOF_AR_HDR_BIG, abfd)
1900       != SIZEOF_AR_HDR_BIG)
1901     return FALSE;
1902
1903   /* Skip the name (normally empty).  */
1904   namlen = strtol (hdr.namlen, (char **) NULL, 10);
1905   pos = ((namlen + 1) & ~(size_t) 1) + SXCOFFARFMAG;
1906   if (bfd_seek (abfd, pos, SEEK_CUR) != 0)
1907     return FALSE;
1908
1909   sz = bfd_scan_vma (hdr.size, (const char **) NULL, 10);
1910
1911   /* Read in the entire symbol table.  */
1912   contents = (bfd_byte *) bfd_alloc (abfd, sz);
1913   if (contents == NULL)
1914     return FALSE;
1915   if (bfd_bread ((PTR) contents, sz, abfd) != sz)
1916     return FALSE;
1917
1918   /* The symbol table starts with an eight byte count.  */
1919   c = H_GET_64 (abfd, contents);
1920
1921   if (c * 8 >= sz)
1922     {
1923       bfd_set_error (bfd_error_bad_value);
1924       return FALSE;
1925     }
1926   amt = c;
1927   amt *= sizeof (carsym);
1928   bfd_ardata (abfd)->symdefs = (carsym *) bfd_alloc (abfd, amt);
1929   if (bfd_ardata (abfd)->symdefs == NULL)
1930     return FALSE;
1931
1932   /* After the count comes a list of eight byte file offsets.  */
1933   for (i = 0, arsym = bfd_ardata (abfd)->symdefs, p = contents + 8;
1934        i < c;
1935        ++i, ++arsym, p += 8)
1936     arsym->file_offset = H_GET_64 (abfd, p);
1937
1938   /* After the file offsets come null terminated symbol names.  */
1939   cend = contents + sz;
1940   for (i = 0, arsym = bfd_ardata (abfd)->symdefs;
1941        i < c;
1942        ++i, ++arsym, p += strlen ((char *) p) + 1)
1943     {
1944       if (p >= cend)
1945         {
1946           bfd_set_error (bfd_error_bad_value);
1947           return FALSE;
1948         }
1949       arsym->name = (char *) p;
1950     }
1951
1952   bfd_ardata (abfd)->symdef_count = c;
1953   bfd_has_map (abfd) = TRUE;
1954
1955   return TRUE;
1956 }
1957
1958
1959 /* See if this is an NEW XCOFF archive.  */
1960
1961 static const bfd_target *
1962 xcoff64_archive_p (abfd)
1963      bfd *abfd;
1964 {
1965   struct artdata *tdata_hold;
1966   char magic[SXCOFFARMAG];
1967   /* This is the new format.  */
1968   struct xcoff_ar_file_hdr_big hdr;
1969   bfd_size_type amt = SXCOFFARMAG;
1970
1971   if (bfd_bread ((PTR) magic, amt, abfd) != amt)
1972     {
1973       if (bfd_get_error () != bfd_error_system_call)
1974         bfd_set_error (bfd_error_wrong_format);
1975       return NULL;
1976     }
1977
1978   if (strncmp (magic, XCOFFARMAGBIG, SXCOFFARMAG) != 0)
1979     {
1980       bfd_set_error (bfd_error_wrong_format);
1981       return NULL;
1982     }
1983
1984   /* Copy over the magic string.  */
1985   memcpy (hdr.magic, magic, SXCOFFARMAG);
1986
1987   /* Now read the rest of the file header.  */
1988   amt = SIZEOF_AR_FILE_HDR_BIG - SXCOFFARMAG;
1989   if (bfd_bread ((PTR) &hdr.memoff, amt, abfd) != amt)
1990     {
1991       if (bfd_get_error () != bfd_error_system_call)
1992         bfd_set_error (bfd_error_wrong_format);
1993       return NULL;
1994     }
1995
1996   tdata_hold = bfd_ardata (abfd);
1997
1998   amt = sizeof (struct artdata);
1999   bfd_ardata (abfd) = (struct artdata *) bfd_zalloc (abfd, amt);
2000   if (bfd_ardata (abfd) == (struct artdata *) NULL)
2001     goto error_ret_restore;
2002
2003   /* Already cleared by bfd_zalloc above.
2004      bfd_ardata (abfd)->cache = NULL;
2005      bfd_ardata (abfd)->archive_head = NULL;
2006      bfd_ardata (abfd)->symdefs = NULL;
2007      bfd_ardata (abfd)->extended_names = NULL;
2008      bfd_ardata (abfd)->extended_names_size = 0;  */
2009   bfd_ardata (abfd)->first_file_filepos = bfd_scan_vma (hdr.firstmemoff,
2010                                                         (const char **) NULL,
2011                                                         10);
2012
2013   amt = SIZEOF_AR_FILE_HDR_BIG;
2014   bfd_ardata (abfd)->tdata = bfd_zalloc (abfd, amt);
2015   if (bfd_ardata (abfd)->tdata == NULL)
2016     goto error_ret;
2017
2018   memcpy (bfd_ardata (abfd)->tdata, &hdr, SIZEOF_AR_FILE_HDR_BIG);
2019
2020   if (! xcoff64_slurp_armap (abfd))
2021     {
2022     error_ret:
2023       bfd_release (abfd, bfd_ardata (abfd));
2024     error_ret_restore:
2025       bfd_ardata (abfd) = tdata_hold;
2026       return NULL;
2027     }
2028
2029   return abfd->xvec;
2030 }
2031
2032
2033 /* Open the next element in an XCOFF archive.  */
2034
2035 static bfd *
2036 xcoff64_openr_next_archived_file (archive, last_file)
2037      bfd *archive;
2038      bfd *last_file;
2039 {
2040   bfd_vma filestart;
2041
2042   if ((xcoff_ardata (archive) == NULL)
2043       || ! xcoff_big_format_p (archive))
2044     {
2045       bfd_set_error (bfd_error_invalid_operation);
2046       return NULL;
2047     }
2048
2049   if (last_file == NULL)
2050     {
2051       filestart = bfd_ardata (archive)->first_file_filepos;
2052     }
2053   else
2054     {
2055       filestart = bfd_scan_vma (arch_xhdr_big (last_file)->nextoff,
2056                                 (const char **) NULL, 10);
2057     }
2058
2059   if (filestart == 0
2060       || filestart == bfd_scan_vma (xcoff_ardata_big (archive)->memoff,
2061                                     (const char **) NULL, 10)
2062       || filestart == bfd_scan_vma (xcoff_ardata_big (archive)->symoff,
2063                                     (const char **) NULL, 10))
2064     {
2065       bfd_set_error (bfd_error_no_more_archived_files);
2066       return NULL;
2067     }
2068
2069   return _bfd_get_elt_at_filepos (archive, (file_ptr) filestart);
2070 }
2071
2072 /* We can't use the usual coff_sizeof_headers routine, because AIX
2073    always uses an a.out header.  */
2074
2075 static int
2076 xcoff64_sizeof_headers (bfd *abfd,
2077                         struct bfd_link_info *info ATTRIBUTE_UNUSED)
2078 {
2079   int size;
2080
2081   size = bfd_coff_filhsz (abfd);
2082
2083   /* Don't think the small aout header can be used since some of the
2084      old elements have been reordered past the end of the old coff
2085      small aout size.  */
2086
2087   if (xcoff_data (abfd)->full_aouthdr)
2088     size += bfd_coff_aoutsz (abfd);
2089
2090   size += abfd->section_count * bfd_coff_scnhsz (abfd);
2091   return size;
2092 }
2093
2094
2095
2096 static asection *
2097 xcoff64_create_csect_from_smclas (abfd, aux, symbol_name)
2098      bfd *abfd;
2099      union internal_auxent *aux;
2100      const char *symbol_name;
2101 {
2102   asection *return_value = NULL;
2103
2104   /* Changes from 32 :
2105      .sv == 8, is only for 32 bit programs
2106      .ti == 12 and .tb == 13 are now reserved.  */
2107   static const char *names[19] =
2108   {
2109     ".pr", ".ro", ".db", ".tc", ".ua", ".rw", ".gl", ".xo",
2110     NULL, ".bs", ".ds", ".uc", NULL,  NULL,  NULL,  ".tc0",
2111     ".td", ".sv64", ".sv3264"
2112   };
2113
2114   if ((19 >= aux->x_csect.x_smclas)
2115       && (NULL != names[aux->x_csect.x_smclas]))
2116     {
2117
2118       return_value = bfd_make_section_anyway
2119         (abfd, names[aux->x_csect.x_smclas]);
2120
2121     }
2122   else
2123     {
2124       (*_bfd_error_handler)
2125         (_("%B: symbol `%s' has unrecognized smclas %d"),
2126          abfd, symbol_name, aux->x_csect.x_smclas);
2127       bfd_set_error (bfd_error_bad_value);
2128     }
2129
2130   return return_value;
2131 }
2132
2133 static bfd_boolean
2134 xcoff64_is_lineno_count_overflow (abfd, value)
2135      bfd *abfd ATTRIBUTE_UNUSED;
2136      bfd_vma value ATTRIBUTE_UNUSED;
2137 {
2138   return FALSE;
2139 }
2140
2141 static bfd_boolean
2142 xcoff64_is_reloc_count_overflow (abfd, value)
2143      bfd *abfd ATTRIBUTE_UNUSED;
2144      bfd_vma value ATTRIBUTE_UNUSED;
2145 {
2146   return FALSE;
2147 }
2148
2149 static bfd_vma
2150 xcoff64_loader_symbol_offset (abfd, ldhdr)
2151      bfd *abfd ATTRIBUTE_UNUSED;
2152      struct internal_ldhdr *ldhdr;
2153 {
2154   return (ldhdr->l_symoff);
2155 }
2156
2157 static bfd_vma
2158 xcoff64_loader_reloc_offset (abfd, ldhdr)
2159      bfd *abfd ATTRIBUTE_UNUSED;
2160      struct internal_ldhdr *ldhdr;
2161 {
2162   return (ldhdr->l_rldoff);
2163 }
2164
2165 static bfd_boolean
2166 xcoff64_bad_format_hook (abfd, filehdr)
2167      bfd * abfd;
2168      PTR filehdr;
2169 {
2170   struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
2171
2172   /* Check flavor first.  */
2173   if (bfd_get_flavour (abfd) != bfd_target_xcoff_flavour)
2174     return FALSE;
2175
2176   if (bfd_xcoff_magic_number (abfd) != internal_f->f_magic)
2177     return FALSE;
2178
2179   return TRUE;
2180 }
2181
2182 static bfd_boolean
2183 xcoff64_generate_rtinit (abfd, init, fini, rtld)
2184      bfd *abfd;
2185      const char *init;
2186      const char *fini;
2187      bfd_boolean rtld;
2188 {
2189   bfd_byte filehdr_ext[FILHSZ];
2190   bfd_byte scnhdr_ext[SCNHSZ * 3];
2191   bfd_byte syment_ext[SYMESZ * 10];
2192   bfd_byte reloc_ext[RELSZ * 3];
2193   bfd_byte *data_buffer;
2194   bfd_size_type data_buffer_size;
2195   bfd_byte *string_table, *st_tmp;
2196   bfd_size_type string_table_size;
2197   bfd_vma val;
2198   size_t initsz, finisz;
2199   struct internal_filehdr filehdr;
2200   struct internal_scnhdr text_scnhdr;
2201   struct internal_scnhdr data_scnhdr;
2202   struct internal_scnhdr bss_scnhdr;
2203   struct internal_syment syment;
2204   union internal_auxent auxent;
2205   struct internal_reloc reloc;
2206
2207   char *text_name = ".text";
2208   char *data_name = ".data";
2209   char *bss_name = ".bss";
2210   char *rtinit_name = "__rtinit";
2211   char *rtld_name = "__rtld";
2212
2213   if (! bfd_xcoff_rtinit_size (abfd))
2214     return FALSE;
2215
2216   initsz = (init == NULL ? 0 : 1 + strlen (init));
2217   finisz = (fini == NULL ? 0 : 1 + strlen (fini));
2218
2219   /* File header.  */
2220   memset (filehdr_ext, 0, FILHSZ);
2221   memset (&filehdr, 0, sizeof (struct internal_filehdr));
2222   filehdr.f_magic = bfd_xcoff_magic_number (abfd);
2223   filehdr.f_nscns = 3;
2224   filehdr.f_timdat = 0;
2225   filehdr.f_nsyms = 0;  /* at least 6, no more than 8 */
2226   filehdr.f_symptr = 0; /* set below */
2227   filehdr.f_opthdr = 0;
2228   filehdr.f_flags = 0;
2229
2230   /* Section headers.  */
2231   memset (scnhdr_ext, 0, 3 * SCNHSZ);
2232
2233   /* Text.  */
2234   memset (&text_scnhdr, 0, sizeof (struct internal_scnhdr));
2235   memcpy (text_scnhdr.s_name, text_name, strlen (text_name));
2236   text_scnhdr.s_paddr = 0;
2237   text_scnhdr.s_vaddr = 0;
2238   text_scnhdr.s_size = 0;
2239   text_scnhdr.s_scnptr = 0;
2240   text_scnhdr.s_relptr = 0;
2241   text_scnhdr.s_lnnoptr = 0;
2242   text_scnhdr.s_nreloc = 0;
2243   text_scnhdr.s_nlnno = 0;
2244   text_scnhdr.s_flags = STYP_TEXT;
2245
2246   /* Data.  */
2247   memset (&data_scnhdr, 0, sizeof (struct internal_scnhdr));
2248   memcpy (data_scnhdr.s_name, data_name, strlen (data_name));
2249   data_scnhdr.s_paddr = 0;
2250   data_scnhdr.s_vaddr = 0;
2251   data_scnhdr.s_size = 0;    /* set below */
2252   data_scnhdr.s_scnptr = FILHSZ + 3 * SCNHSZ;
2253   data_scnhdr.s_relptr = 0;  /* set below */
2254   data_scnhdr.s_lnnoptr = 0;
2255   data_scnhdr.s_nreloc = 0;  /* either 1 or 2 */
2256   data_scnhdr.s_nlnno = 0;
2257   data_scnhdr.s_flags = STYP_DATA;
2258
2259   /* Bss.  */
2260   memset (&bss_scnhdr, 0, sizeof (struct internal_scnhdr));
2261   memcpy (bss_scnhdr.s_name, bss_name, strlen (bss_name));
2262   bss_scnhdr.s_paddr = 0; /* set below */
2263   bss_scnhdr.s_vaddr = 0; /* set below */
2264   bss_scnhdr.s_size = 0;  /* set below */
2265   bss_scnhdr.s_scnptr = 0;
2266   bss_scnhdr.s_relptr = 0;
2267   bss_scnhdr.s_lnnoptr = 0;
2268   bss_scnhdr.s_nreloc = 0;
2269   bss_scnhdr.s_nlnno = 0;
2270   bss_scnhdr.s_flags = STYP_BSS;
2271
2272   /* .data
2273      0x0000           0x00000000 : rtl
2274      0x0004           0x00000000 :
2275      0x0008           0x00000018 : offset to init, or 0
2276      0x000C           0x00000038 : offset to fini, or 0
2277      0x0010           0x00000010 : size of descriptor
2278      0x0014           0x00000000 : pad
2279      0x0018           0x00000000 : init, needs a reloc
2280      0x001C           0x00000000 :
2281      0x0020           0x00000058 : offset to init name
2282      0x0024           0x00000000 : flags, padded to a word
2283      0x0028           0x00000000 : empty init
2284      0x002C           0x00000000 :
2285      0x0030           0x00000000 :
2286      0x0034           0x00000000 :
2287      0x0038           0x00000000 : fini, needs a reloc
2288      0x003C           0x00000000 :
2289      0x0040           0x00000??? : offset to fini name
2290      0x0044           0x00000000 : flags, padded to a word
2291      0x0048           0x00000000 : empty fini
2292      0x004C           0x00000000 :
2293      0x0050           0x00000000 :
2294      0x0054           0x00000000 :
2295      0x0058           init name
2296      0x0058 + initsz  fini name */
2297
2298   data_buffer_size = 0x0058 + initsz + finisz;
2299   data_buffer_size = (data_buffer_size + 7) &~ (bfd_size_type) 7;
2300   data_buffer = NULL;
2301   data_buffer = (bfd_byte *) bfd_zmalloc (data_buffer_size);
2302   if (data_buffer == NULL)
2303     return FALSE;
2304
2305   if (initsz)
2306     {
2307       val = 0x18;
2308       bfd_put_32 (abfd, val, &data_buffer[0x08]);
2309       val = 0x58;
2310       bfd_put_32 (abfd, val, &data_buffer[0x20]);
2311       memcpy (&data_buffer[val], init, initsz);
2312     }
2313
2314   if (finisz)
2315     {
2316       val = 0x38;
2317       bfd_put_32 (abfd, val, &data_buffer[0x0C]);
2318       val = 0x58 + initsz;
2319       bfd_put_32 (abfd, val, &data_buffer[0x40]);
2320       memcpy (&data_buffer[val], fini, finisz);
2321     }
2322
2323   val = 0x10;
2324   bfd_put_32 (abfd, val, &data_buffer[0x10]);
2325   data_scnhdr.s_size = data_buffer_size;
2326   bss_scnhdr.s_paddr = bss_scnhdr.s_vaddr = data_scnhdr.s_size;
2327
2328   /* String table.  */
2329   string_table_size = 4;
2330   string_table_size += strlen (data_name) + 1;
2331   string_table_size += strlen (rtinit_name) + 1;
2332   string_table_size += initsz;
2333   string_table_size += finisz;
2334   if (rtld)
2335     string_table_size += strlen (rtld_name) + 1;
2336
2337   string_table = (bfd_byte *) bfd_zmalloc (string_table_size);
2338   if (string_table == NULL)
2339     return FALSE;
2340
2341   val = string_table_size;
2342   bfd_put_32 (abfd, val, &string_table[0]);
2343   st_tmp = string_table + 4;
2344
2345   /* symbols
2346      0. .data csect
2347      2. __rtinit
2348      4. init function
2349      6. fini function
2350      8. __rtld  */
2351   memset (syment_ext, 0, 10 * SYMESZ);
2352   memset (reloc_ext, 0, 3 * RELSZ);
2353
2354   /* .data csect */
2355   memset (&syment, 0, sizeof (struct internal_syment));
2356   memset (&auxent, 0, sizeof (union internal_auxent));
2357
2358   syment._n._n_n._n_offset = st_tmp - string_table;
2359   memcpy (st_tmp, data_name, strlen (data_name));
2360   st_tmp += strlen (data_name) + 1;
2361
2362   syment.n_scnum = 2;
2363   syment.n_sclass = C_HIDEXT;
2364   syment.n_numaux = 1;
2365   auxent.x_csect.x_scnlen.l = data_buffer_size;
2366   auxent.x_csect.x_smtyp = 3 << 3 | XTY_SD;
2367   auxent.x_csect.x_smclas = XMC_RW;
2368   bfd_coff_swap_sym_out (abfd, &syment,
2369                          &syment_ext[filehdr.f_nsyms * SYMESZ]);
2370   bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0,
2371                          syment.n_numaux,
2372                          &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]);
2373   filehdr.f_nsyms += 2;
2374
2375   /* __rtinit */
2376   memset (&syment, 0, sizeof (struct internal_syment));
2377   memset (&auxent, 0, sizeof (union internal_auxent));
2378   syment._n._n_n._n_offset = st_tmp - string_table;
2379   memcpy (st_tmp, rtinit_name, strlen (rtinit_name));
2380   st_tmp += strlen (rtinit_name) + 1;
2381
2382   syment.n_scnum = 2;
2383   syment.n_sclass = C_EXT;
2384   syment.n_numaux = 1;
2385   auxent.x_csect.x_smtyp = XTY_LD;
2386   auxent.x_csect.x_smclas = XMC_RW;
2387   bfd_coff_swap_sym_out (abfd, &syment,
2388                          &syment_ext[filehdr.f_nsyms * SYMESZ]);
2389   bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0,
2390                          syment.n_numaux,
2391                          &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]);
2392   filehdr.f_nsyms += 2;
2393
2394   /* Init.  */
2395   if (initsz)
2396     {
2397       memset (&syment, 0, sizeof (struct internal_syment));
2398       memset (&auxent, 0, sizeof (union internal_auxent));
2399
2400       syment._n._n_n._n_offset = st_tmp - string_table;
2401       memcpy (st_tmp, init, initsz);
2402       st_tmp += initsz;
2403
2404       syment.n_sclass = C_EXT;
2405       syment.n_numaux = 1;
2406       bfd_coff_swap_sym_out (abfd, &syment,
2407                              &syment_ext[filehdr.f_nsyms * SYMESZ]);
2408       bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0,
2409                              syment.n_numaux,
2410                              &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]);
2411       /* Reloc.  */
2412       memset (&reloc, 0, sizeof (struct internal_reloc));
2413       reloc.r_vaddr = 0x0018;
2414       reloc.r_symndx = filehdr.f_nsyms;
2415       reloc.r_type = R_POS;
2416       reloc.r_size = 63;
2417       bfd_coff_swap_reloc_out (abfd, &reloc, &reloc_ext[0]);
2418
2419       filehdr.f_nsyms += 2;
2420       data_scnhdr.s_nreloc += 1;
2421     }
2422
2423   /* Finit.  */
2424   if (finisz)
2425     {
2426       memset (&syment, 0, sizeof (struct internal_syment));
2427       memset (&auxent, 0, sizeof (union internal_auxent));
2428
2429       syment._n._n_n._n_offset = st_tmp - string_table;
2430       memcpy (st_tmp, fini, finisz);
2431       st_tmp += finisz;
2432
2433       syment.n_sclass = C_EXT;
2434       syment.n_numaux = 1;
2435       bfd_coff_swap_sym_out (abfd, &syment,
2436                              &syment_ext[filehdr.f_nsyms * SYMESZ]);
2437       bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0,
2438                              syment.n_numaux,
2439                              &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]);
2440
2441       /* Reloc.  */
2442       memset (&reloc, 0, sizeof (struct internal_reloc));
2443       reloc.r_vaddr = 0x0038;
2444       reloc.r_symndx = filehdr.f_nsyms;
2445       reloc.r_type = R_POS;
2446       reloc.r_size = 63;
2447       bfd_coff_swap_reloc_out (abfd, &reloc,
2448                                &reloc_ext[data_scnhdr.s_nreloc * RELSZ]);
2449
2450       filehdr.f_nsyms += 2;
2451       data_scnhdr.s_nreloc += 1;
2452     }
2453
2454   if (rtld)
2455     {
2456       memset (&syment, 0, sizeof (struct internal_syment));
2457       memset (&auxent, 0, sizeof (union internal_auxent));
2458
2459       syment._n._n_n._n_offset = st_tmp - string_table;
2460       memcpy (st_tmp, rtld_name, strlen (rtld_name));
2461       st_tmp += strlen (rtld_name) + 1;
2462
2463       syment.n_sclass = C_EXT;
2464       syment.n_numaux = 1;
2465       bfd_coff_swap_sym_out (abfd, &syment,
2466                              &syment_ext[filehdr.f_nsyms * SYMESZ]);
2467       bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0,
2468                              syment.n_numaux,
2469                              &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]);
2470
2471       /* Reloc.  */
2472       memset (&reloc, 0, sizeof (struct internal_reloc));
2473       reloc.r_vaddr = 0x0000;
2474       reloc.r_symndx = filehdr.f_nsyms;
2475       reloc.r_type = R_POS;
2476       reloc.r_size = 63;
2477       bfd_coff_swap_reloc_out (abfd, &reloc,
2478                                &reloc_ext[data_scnhdr.s_nreloc * RELSZ]);
2479
2480       filehdr.f_nsyms += 2;
2481       data_scnhdr.s_nreloc += 1;
2482
2483       bss_scnhdr.s_size = 0;
2484     }
2485
2486   data_scnhdr.s_relptr = data_scnhdr.s_scnptr + data_buffer_size;
2487   filehdr.f_symptr = data_scnhdr.s_relptr + data_scnhdr.s_nreloc * RELSZ;
2488
2489   bfd_coff_swap_filehdr_out (abfd, &filehdr, filehdr_ext);
2490   bfd_bwrite (filehdr_ext, FILHSZ, abfd);
2491   bfd_coff_swap_scnhdr_out (abfd, &text_scnhdr, &scnhdr_ext[SCNHSZ * 0]);
2492   bfd_coff_swap_scnhdr_out (abfd, &data_scnhdr, &scnhdr_ext[SCNHSZ * 1]);
2493   bfd_coff_swap_scnhdr_out (abfd, &bss_scnhdr, &scnhdr_ext[SCNHSZ * 2]);
2494   bfd_bwrite (scnhdr_ext, 3 * SCNHSZ, abfd);
2495   bfd_bwrite (data_buffer, data_buffer_size, abfd);
2496   bfd_bwrite (reloc_ext, data_scnhdr.s_nreloc * RELSZ, abfd);
2497   bfd_bwrite (syment_ext, filehdr.f_nsyms * SYMESZ, abfd);
2498   bfd_bwrite (string_table, string_table_size, abfd);
2499
2500   free (data_buffer);
2501   data_buffer = NULL;
2502
2503   return TRUE;
2504 }
2505
2506 /* The typical dynamic reloc.  */
2507
2508 static reloc_howto_type xcoff64_dynamic_reloc =
2509 HOWTO (0,                       /* type */
2510        0,                       /* rightshift */
2511        4,                       /* size (0 = byte, 1 = short, 2 = long) */
2512        64,                      /* bitsize */
2513        FALSE,                   /* pc_relative */
2514        0,                       /* bitpos */
2515        complain_overflow_bitfield, /* complain_on_overflow */
2516        0,                       /* special_function */
2517        "R_POS",                 /* name */
2518        TRUE,                    /* partial_inplace */
2519        MINUS_ONE,               /* src_mask */
2520        MINUS_ONE,               /* dst_mask */
2521        FALSE);                  /* pcrel_offset */
2522
2523 static unsigned long xcoff64_glink_code[10] =
2524 {
2525   0xe9820000,   /* ld r12,0(r2) */
2526   0xf8410028,   /* std r2,40(r1) */
2527   0xe80c0000,   /* ld r0,0(r12) */
2528   0xe84c0008,   /* ld r0,8(r12) */
2529   0x7c0903a6,   /* mtctr r0 */
2530   0x4e800420,   /* bctr */
2531   0x00000000,   /* start of traceback table */
2532   0x000ca000,   /* traceback table */
2533   0x00000000,   /* traceback table */
2534   0x00000018,   /* ??? */
2535 };
2536
2537 static const struct xcoff_backend_data_rec bfd_xcoff_backend_data =
2538   {
2539     { /* COFF backend, defined in libcoff.h.  */
2540       _bfd_xcoff64_swap_aux_in,
2541       _bfd_xcoff64_swap_sym_in,
2542       _bfd_xcoff64_swap_lineno_in,
2543       _bfd_xcoff64_swap_aux_out,
2544       _bfd_xcoff64_swap_sym_out,
2545       _bfd_xcoff64_swap_lineno_out,
2546       xcoff64_swap_reloc_out,
2547       coff_swap_filehdr_out,
2548       coff_swap_aouthdr_out,
2549       coff_swap_scnhdr_out,
2550       FILHSZ,
2551       AOUTSZ,
2552       SCNHSZ,
2553       SYMESZ,
2554       AUXESZ,
2555       RELSZ,
2556       LINESZ,
2557       FILNMLEN,
2558       TRUE,                     /* _bfd_coff_long_filenames */
2559       FALSE,                    /* _bfd_coff_long_section_names */
2560       3,                        /* _bfd_coff_default_section_alignment_power */
2561       TRUE,                     /* _bfd_coff_force_symnames_in_strings */
2562       4,                        /* _bfd_coff_debug_string_prefix_length */
2563       coff_swap_filehdr_in,
2564       coff_swap_aouthdr_in,
2565       coff_swap_scnhdr_in,
2566       xcoff64_swap_reloc_in,
2567       xcoff64_bad_format_hook,
2568       coff_set_arch_mach_hook,
2569       coff_mkobject_hook,
2570       styp_to_sec_flags,
2571       coff_set_alignment_hook,
2572       coff_slurp_symbol_table,
2573       symname_in_debug_hook,
2574       coff_pointerize_aux_hook,
2575       coff_print_aux,
2576       dummy_reloc16_extra_cases,
2577       dummy_reloc16_estimate,
2578       NULL,                     /* bfd_coff_sym_is_global */
2579       coff_compute_section_file_positions,
2580       NULL,                     /* _bfd_coff_start_final_link */
2581       xcoff64_ppc_relocate_section,
2582       coff_rtype_to_howto,
2583       NULL,                     /* _bfd_coff_adjust_symndx */
2584       _bfd_generic_link_add_one_symbol,
2585       coff_link_output_has_begun,
2586       coff_final_link_postscript
2587     },
2588
2589     0x01EF,                     /* magic number */
2590     bfd_arch_powerpc,
2591     bfd_mach_ppc_620,
2592
2593     /* Function pointers to xcoff specific swap routines.  */
2594     xcoff64_swap_ldhdr_in,
2595     xcoff64_swap_ldhdr_out,
2596     xcoff64_swap_ldsym_in,
2597     xcoff64_swap_ldsym_out,
2598     xcoff64_swap_ldrel_in,
2599     xcoff64_swap_ldrel_out,
2600
2601     /* Sizes.  */
2602     LDHDRSZ,
2603     LDSYMSZ,
2604     LDRELSZ,
2605     24,                         /* _xcoff_function_descriptor_size */
2606     0,                          /* _xcoff_small_aout_header_size */
2607
2608     /* Versions.  */
2609     2,                          /* _xcoff_ldhdr_version */
2610
2611     _bfd_xcoff64_put_symbol_name,
2612     _bfd_xcoff64_put_ldsymbol_name,
2613     &xcoff64_dynamic_reloc,
2614     xcoff64_create_csect_from_smclas,
2615
2616     /* Lineno and reloc count overflow.  */
2617     xcoff64_is_lineno_count_overflow,
2618     xcoff64_is_reloc_count_overflow,
2619
2620     xcoff64_loader_symbol_offset,
2621     xcoff64_loader_reloc_offset,
2622
2623     /* glink.  */
2624     &xcoff64_glink_code[0],
2625     40,                         /* _xcoff_glink_size */
2626
2627     /* rtinit.  */
2628     88,                         /* _xcoff_rtinit_size */
2629     xcoff64_generate_rtinit,
2630   };
2631
2632 /* The transfer vector that leads the outside world to all of the above.  */
2633 const bfd_target rs6000coff64_vec =
2634   {
2635     "aixcoff64-rs6000",
2636     bfd_target_xcoff_flavour,
2637     BFD_ENDIAN_BIG,             /* data byte order is big */
2638     BFD_ENDIAN_BIG,             /* header byte order is big */
2639
2640     (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | DYNAMIC
2641      | HAS_SYMS | HAS_LOCALS | WP_TEXT),
2642
2643     SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA,
2644     0,                          /* leading char */
2645     '/',                        /* ar_pad_char */
2646     15,                         /* ar_max_namelen */
2647
2648     /* data */
2649     bfd_getb64,
2650     bfd_getb_signed_64,
2651     bfd_putb64,
2652     bfd_getb32,
2653     bfd_getb_signed_32,
2654     bfd_putb32,
2655     bfd_getb16,
2656     bfd_getb_signed_16,
2657     bfd_putb16,
2658
2659     /* hdrs */
2660     bfd_getb64,
2661     bfd_getb_signed_64,
2662     bfd_putb64,
2663     bfd_getb32,
2664     bfd_getb_signed_32,
2665     bfd_putb32,
2666     bfd_getb16,
2667     bfd_getb_signed_16,
2668     bfd_putb16,
2669
2670     { /* bfd_check_format */
2671       _bfd_dummy_target,
2672       coff_object_p,
2673       xcoff64_archive_p,
2674       CORE_FILE_P
2675     },
2676
2677     { /* bfd_set_format */
2678       bfd_false,
2679       coff_mkobject,
2680       _bfd_generic_mkarchive,
2681       bfd_false
2682     },
2683
2684     {/* bfd_write_contents */
2685       bfd_false,
2686       xcoff64_write_object_contents,
2687       _bfd_xcoff_write_archive_contents,
2688       bfd_false
2689     },
2690
2691     /* Generic */
2692     bfd_true,
2693     bfd_true,
2694     coff_new_section_hook,
2695     _bfd_generic_get_section_contents,
2696     _bfd_generic_get_section_contents_in_window,
2697
2698     /* Copy */
2699     _bfd_xcoff_copy_private_bfd_data,
2700     ((bfd_boolean (*) (bfd *, bfd *)) bfd_true),
2701     _bfd_generic_init_private_section_data,
2702     ((bfd_boolean (*) (bfd *, asection *, bfd *, asection *)) bfd_true),
2703     ((bfd_boolean (*) (bfd *, asymbol *, bfd *, asymbol *)) bfd_true),
2704     ((bfd_boolean (*) (bfd *, bfd *)) bfd_true),
2705     ((bfd_boolean (*) (bfd *, flagword)) bfd_true),
2706     ((bfd_boolean (*) (bfd *, void * )) bfd_true),
2707
2708     /* Core */
2709     coff_core_file_failing_command,
2710     coff_core_file_failing_signal,
2711     coff_core_file_matches_executable_p,
2712
2713     /* Archive */
2714     xcoff64_slurp_armap,
2715     bfd_false,
2716     ((bfd_boolean (*) (bfd *, char **, bfd_size_type *, const char **)) bfd_false),
2717     bfd_dont_truncate_arname,
2718     _bfd_xcoff_write_armap,
2719     _bfd_xcoff_read_ar_hdr,
2720     xcoff64_openr_next_archived_file,
2721     _bfd_generic_get_elt_at_index,
2722     _bfd_xcoff_stat_arch_elt,
2723     bfd_true,
2724
2725     /* Symbols */
2726     coff_get_symtab_upper_bound,
2727     coff_canonicalize_symtab,
2728     coff_make_empty_symbol,
2729     coff_print_symbol,
2730     coff_get_symbol_info,
2731     _bfd_xcoff_is_local_label_name,
2732     coff_bfd_is_target_special_symbol,
2733     coff_get_lineno,
2734     coff_find_nearest_line,
2735     _bfd_generic_find_line,
2736     coff_find_inliner_info,
2737     coff_bfd_make_debug_symbol,
2738     _bfd_generic_read_minisymbols,
2739     _bfd_generic_minisymbol_to_symbol,
2740
2741     /* Reloc */
2742     coff_get_reloc_upper_bound,
2743     coff_canonicalize_reloc,
2744     xcoff64_reloc_type_lookup,
2745     xcoff64_reloc_name_lookup,
2746
2747     /* Write */
2748     coff_set_arch_mach,
2749     coff_set_section_contents,
2750
2751     /* Link */
2752     xcoff64_sizeof_headers,
2753     bfd_generic_get_relocated_section_contents,
2754     bfd_generic_relax_section,
2755     _bfd_xcoff_bfd_link_hash_table_create,
2756     _bfd_generic_link_hash_table_free,
2757     _bfd_xcoff_bfd_link_add_symbols,
2758     _bfd_generic_link_just_syms,
2759     _bfd_xcoff_bfd_final_link,
2760     _bfd_generic_link_split_section,
2761     bfd_generic_gc_sections,
2762     bfd_generic_merge_sections,
2763     bfd_generic_is_group_section,
2764     bfd_generic_discard_group,
2765     _bfd_generic_section_already_linked,
2766
2767     /* Dynamic */
2768     _bfd_xcoff_get_dynamic_symtab_upper_bound,
2769     _bfd_xcoff_canonicalize_dynamic_symtab,
2770     _bfd_nodynamic_get_synthetic_symtab,
2771     _bfd_xcoff_get_dynamic_reloc_upper_bound,
2772     _bfd_xcoff_canonicalize_dynamic_reloc,
2773
2774     /* Opposite endian version, none exists */
2775     NULL,
2776
2777     (void *) &bfd_xcoff_backend_data,
2778   };
2779
2780 extern const bfd_target *xcoff64_core_p
2781   PARAMS ((bfd *));
2782 extern bfd_boolean xcoff64_core_file_matches_executable_p
2783   PARAMS ((bfd *, bfd *));
2784 extern char *xcoff64_core_file_failing_command
2785   PARAMS ((bfd *));
2786 extern int xcoff64_core_file_failing_signal
2787   PARAMS ((bfd *));
2788
2789 /* AIX 5 */
2790 static const struct xcoff_backend_data_rec bfd_xcoff_aix5_backend_data =
2791   {
2792     { /* COFF backend, defined in libcoff.h.  */
2793       _bfd_xcoff64_swap_aux_in,
2794       _bfd_xcoff64_swap_sym_in,
2795       _bfd_xcoff64_swap_lineno_in,
2796       _bfd_xcoff64_swap_aux_out,
2797       _bfd_xcoff64_swap_sym_out,
2798       _bfd_xcoff64_swap_lineno_out,
2799       xcoff64_swap_reloc_out,
2800       coff_swap_filehdr_out,
2801       coff_swap_aouthdr_out,
2802       coff_swap_scnhdr_out,
2803       FILHSZ,
2804       AOUTSZ,
2805       SCNHSZ,
2806       SYMESZ,
2807       AUXESZ,
2808       RELSZ,
2809       LINESZ,
2810       FILNMLEN,
2811       TRUE,                     /* _bfd_coff_long_filenames */
2812       FALSE,                    /* _bfd_coff_long_section_names */
2813       3,                        /* _bfd_coff_default_section_alignment_power */
2814       TRUE,                     /* _bfd_coff_force_symnames_in_strings */
2815       4,                        /* _bfd_coff_debug_string_prefix_length */
2816       coff_swap_filehdr_in,
2817       coff_swap_aouthdr_in,
2818       coff_swap_scnhdr_in,
2819       xcoff64_swap_reloc_in,
2820       xcoff64_bad_format_hook,
2821       coff_set_arch_mach_hook,
2822       coff_mkobject_hook,
2823       styp_to_sec_flags,
2824       coff_set_alignment_hook,
2825       coff_slurp_symbol_table,
2826       symname_in_debug_hook,
2827       coff_pointerize_aux_hook,
2828       coff_print_aux,
2829       dummy_reloc16_extra_cases,
2830       dummy_reloc16_estimate,
2831       NULL,                     /* bfd_coff_sym_is_global */
2832       coff_compute_section_file_positions,
2833       NULL,                     /* _bfd_coff_start_final_link */
2834       xcoff64_ppc_relocate_section,
2835       coff_rtype_to_howto,
2836       NULL,                     /* _bfd_coff_adjust_symndx */
2837       _bfd_generic_link_add_one_symbol,
2838       coff_link_output_has_begun,
2839       coff_final_link_postscript
2840     },
2841
2842     U64_TOCMAGIC,               /* magic number */
2843     bfd_arch_powerpc,
2844     bfd_mach_ppc_620,
2845
2846     /* Function pointers to xcoff specific swap routines.  */
2847     xcoff64_swap_ldhdr_in,
2848     xcoff64_swap_ldhdr_out,
2849     xcoff64_swap_ldsym_in,
2850     xcoff64_swap_ldsym_out,
2851     xcoff64_swap_ldrel_in,
2852     xcoff64_swap_ldrel_out,
2853
2854     /* Sizes.  */
2855     LDHDRSZ,
2856     LDSYMSZ,
2857     LDRELSZ,
2858     24,                         /* _xcoff_function_descriptor_size */
2859     0,                          /* _xcoff_small_aout_header_size */
2860     /* Versions.  */
2861     2,                          /* _xcoff_ldhdr_version */
2862
2863     _bfd_xcoff64_put_symbol_name,
2864     _bfd_xcoff64_put_ldsymbol_name,
2865     &xcoff64_dynamic_reloc,
2866     xcoff64_create_csect_from_smclas,
2867
2868     /* Lineno and reloc count overflow.  */
2869     xcoff64_is_lineno_count_overflow,
2870     xcoff64_is_reloc_count_overflow,
2871
2872     xcoff64_loader_symbol_offset,
2873     xcoff64_loader_reloc_offset,
2874
2875     /* glink.  */
2876     &xcoff64_glink_code[0],
2877     40,                         /* _xcoff_glink_size */
2878
2879     /* rtinit.  */
2880     88,                         /* _xcoff_rtinit_size */
2881     xcoff64_generate_rtinit,
2882   };
2883
2884 /* The transfer vector that leads the outside world to all of the above.  */
2885 const bfd_target aix5coff64_vec =
2886   {
2887     "aix5coff64-rs6000",
2888     bfd_target_xcoff_flavour,
2889     BFD_ENDIAN_BIG,             /* data byte order is big */
2890     BFD_ENDIAN_BIG,             /* header byte order is big */
2891
2892     (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | DYNAMIC
2893      | HAS_SYMS | HAS_LOCALS | WP_TEXT),
2894
2895     SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA,
2896     0,                          /* leading char */
2897     '/',                        /* ar_pad_char */
2898     15,                         /* ar_max_namelen */
2899
2900     /* data */
2901     bfd_getb64,
2902     bfd_getb_signed_64,
2903     bfd_putb64,
2904     bfd_getb32,
2905     bfd_getb_signed_32,
2906     bfd_putb32,
2907     bfd_getb16,
2908     bfd_getb_signed_16,
2909     bfd_putb16,
2910
2911     /* hdrs */
2912     bfd_getb64,
2913     bfd_getb_signed_64,
2914     bfd_putb64,
2915     bfd_getb32,
2916     bfd_getb_signed_32,
2917     bfd_putb32,
2918     bfd_getb16,
2919     bfd_getb_signed_16,
2920     bfd_putb16,
2921
2922     { /* bfd_check_format */
2923       _bfd_dummy_target,
2924       coff_object_p,
2925       xcoff64_archive_p,
2926       xcoff64_core_p
2927     },
2928
2929     { /* bfd_set_format */
2930       bfd_false,
2931       coff_mkobject,
2932       _bfd_generic_mkarchive,
2933       bfd_false
2934     },
2935
2936     {/* bfd_write_contents */
2937       bfd_false,
2938       xcoff64_write_object_contents,
2939       _bfd_xcoff_write_archive_contents,
2940       bfd_false
2941     },
2942
2943     /* Generic */
2944     bfd_true,
2945     bfd_true,
2946     coff_new_section_hook,
2947     _bfd_generic_get_section_contents,
2948     _bfd_generic_get_section_contents_in_window,
2949
2950     /* Copy */
2951     _bfd_xcoff_copy_private_bfd_data,
2952     ((bfd_boolean (*) (bfd *, bfd *)) bfd_true),
2953     _bfd_generic_init_private_section_data,
2954     ((bfd_boolean (*) (bfd *, asection *, bfd *, asection *)) bfd_true),
2955     ((bfd_boolean (*) (bfd *, asymbol *, bfd *, asymbol *)) bfd_true),
2956     ((bfd_boolean (*) (bfd *, bfd *)) bfd_true),
2957     ((bfd_boolean (*) (bfd *, flagword)) bfd_true),
2958     ((bfd_boolean (*) (bfd *, void * )) bfd_true),
2959
2960     /* Core */
2961     xcoff64_core_file_failing_command,
2962     xcoff64_core_file_failing_signal,
2963     xcoff64_core_file_matches_executable_p,
2964
2965     /* Archive */
2966     xcoff64_slurp_armap,
2967     bfd_false,
2968     ((bfd_boolean (*) (bfd *, char **, bfd_size_type *, const char **)) bfd_false),
2969     bfd_dont_truncate_arname,
2970     _bfd_xcoff_write_armap,
2971     _bfd_xcoff_read_ar_hdr,
2972     xcoff64_openr_next_archived_file,
2973     _bfd_generic_get_elt_at_index,
2974     _bfd_xcoff_stat_arch_elt,
2975     bfd_true,
2976
2977     /* Symbols */
2978     coff_get_symtab_upper_bound,
2979     coff_canonicalize_symtab,
2980     coff_make_empty_symbol,
2981     coff_print_symbol,
2982     coff_get_symbol_info,
2983     _bfd_xcoff_is_local_label_name,
2984     coff_bfd_is_target_special_symbol,
2985     coff_get_lineno,
2986     coff_find_nearest_line,
2987     _bfd_generic_find_line,
2988     coff_find_inliner_info,
2989     coff_bfd_make_debug_symbol,
2990     _bfd_generic_read_minisymbols,
2991     _bfd_generic_minisymbol_to_symbol,
2992
2993     /* Reloc */
2994     coff_get_reloc_upper_bound,
2995     coff_canonicalize_reloc,
2996     xcoff64_reloc_type_lookup,
2997     xcoff64_reloc_name_lookup,
2998
2999     /* Write */
3000     coff_set_arch_mach,
3001     coff_set_section_contents,
3002
3003     /* Link */
3004     xcoff64_sizeof_headers,
3005     bfd_generic_get_relocated_section_contents,
3006     bfd_generic_relax_section,
3007     _bfd_xcoff_bfd_link_hash_table_create,
3008     _bfd_generic_link_hash_table_free,
3009     _bfd_xcoff_bfd_link_add_symbols,
3010     _bfd_generic_link_just_syms,
3011     _bfd_xcoff_bfd_final_link,
3012     _bfd_generic_link_split_section,
3013     bfd_generic_gc_sections,
3014     bfd_generic_merge_sections,
3015     bfd_generic_is_group_section,
3016     bfd_generic_discard_group,
3017     _bfd_generic_section_already_linked,
3018
3019     /* Dynamic */
3020     _bfd_xcoff_get_dynamic_symtab_upper_bound,
3021     _bfd_xcoff_canonicalize_dynamic_symtab,
3022     _bfd_nodynamic_get_synthetic_symtab,
3023     _bfd_xcoff_get_dynamic_reloc_upper_bound,
3024     _bfd_xcoff_canonicalize_dynamic_reloc,
3025
3026     /* Opposite endian version, none exists.  */
3027     NULL,
3028
3029     (void *) & bfd_xcoff_aix5_backend_data,
3030   };