bfd/coff64-rs6000.c

   1 /* BFD back-end for IBM RS/6000 "XCOFF64" files.
   2    Copyright 2000, 2001, 2002, 2003, 2004
   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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  22
  23 #include "bfd.h"
  24 #include "sysdep.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 *, bfd_boolean));
 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 *, bfd_boolean));
 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 #ifdef AIX_CORE
 241 extern const bfd_target * rs6000coff_core_p
 242   PARAMS ((bfd *abfd));
 243 extern bfd_boolean rs6000coff_core_file_matches_executable_p
 244   PARAMS ((bfd *cbfd, bfd *ebfd));
 245 extern char *rs6000coff_core_file_failing_command
 246   PARAMS ((bfd *abfd));
 247 extern int rs6000coff_core_file_failing_signal
 248   PARAMS ((bfd *abfd));
 249 #define CORE_FILE_P rs6000coff_core_p
 250 #define coff_core_file_failing_command \
 251   rs6000coff_core_file_failing_command
 252 #define coff_core_file_failing_signal \
 253   rs6000coff_core_file_failing_signal
 254 #define coff_core_file_matches_executable_p \
 255   rs6000coff_core_file_matches_executable_p
 256 #else
 257 #define CORE_FILE_P _bfd_dummy_target
 258 #define coff_core_file_failing_command \
 259   _bfd_nocore_core_file_failing_command
 260 #define coff_core_file_failing_signal \
 261   _bfd_nocore_core_file_failing_signal
 262 #define coff_core_file_matches_executable_p \
 263   _bfd_nocore_core_file_matches_executable_p
 264 #endif
 265 #define coff_SWAP_sym_in _bfd_xcoff64_swap_sym_in
 266 #define coff_SWAP_sym_out _bfd_xcoff64_swap_sym_out
 267 #define coff_SWAP_aux_in _bfd_xcoff64_swap_aux_in
 268 #define coff_SWAP_aux_out _bfd_xcoff64_swap_aux_out
 269 #define coff_swap_reloc_in xcoff64_swap_reloc_in
 270 #define coff_swap_reloc_out xcoff64_swap_reloc_out
 271 #define NO_COFF_RELOCS
 272
 273 #include "coffcode.h"
 274
 275 /* For XCOFF64, the effective width of symndx changes depending on
 276    whether we are the first entry.  Sigh.  */
 277 static void
 278 _bfd_xcoff64_swap_lineno_in (abfd, ext1, in1)
 279      bfd *abfd;
 280      PTR ext1;
 281      PTR in1;
 282 {
 283   LINENO *ext = (LINENO *) ext1;
 284   struct internal_lineno *in = (struct internal_lineno *) in1;
 285
 286   in->l_lnno = H_GET_32 (abfd, (ext->l_lnno));
 287   if (in->l_lnno == 0)
 288     in->l_addr.l_symndx = H_GET_32 (abfd, ext->l_addr.l_symndx);
 289   else
 290     in->l_addr.l_paddr = H_GET_64 (abfd, ext->l_addr.l_paddr);
 291 }
 292
 293 static unsigned int
 294 _bfd_xcoff64_swap_lineno_out (abfd, inp, outp)
 295      bfd *abfd;
 296      PTR inp;
 297      PTR outp;
 298 {
 299   struct internal_lineno *in = (struct internal_lineno *) inp;
 300   struct external_lineno *ext = (struct external_lineno *) outp;
 301
 302   H_PUT_32 (abfd, in->l_addr.l_symndx, ext->l_addr.l_symndx);
 303   H_PUT_32 (abfd, in->l_lnno, (ext->l_lnno));
 304
 305   if (in->l_lnno == 0)
 306     H_PUT_32 (abfd, in->l_addr.l_symndx, ext->l_addr.l_symndx);
 307   else
 308     H_PUT_64 (abfd, in->l_addr.l_paddr, ext->l_addr.l_paddr);
 309
 310   return bfd_coff_linesz (abfd);
 311 }
 312
 313 static void
 314 _bfd_xcoff64_swap_sym_in (abfd, ext1, in1)
 315      bfd *abfd;
 316      PTR ext1;
 317      PTR in1;
 318 {
 319   struct external_syment *ext = (struct external_syment *) ext1;
 320   struct internal_syment *in = (struct internal_syment *) in1;
 321
 322   in->_n._n_n._n_zeroes = 0;
 323   in->_n._n_n._n_offset = H_GET_32 (abfd, ext->e_offset);
 324   in->n_value = H_GET_64 (abfd, ext->e_value);
 325   in->n_scnum = H_GET_16 (abfd, ext->e_scnum);
 326   in->n_type = H_GET_16 (abfd, ext->e_type);
 327   in->n_sclass = H_GET_8 (abfd, ext->e_sclass);
 328   in->n_numaux = H_GET_8 (abfd, ext->e_numaux);
 329 }
 330
 331 static unsigned int
 332 _bfd_xcoff64_swap_sym_out (abfd, inp, extp)
 333      bfd *abfd;
 334      PTR inp;
 335      PTR extp;
 336 {
 337   struct internal_syment *in = (struct internal_syment *) inp;
 338   struct external_syment *ext = (struct external_syment *) extp;
 339
 340   H_PUT_32 (abfd, in->_n._n_n._n_offset, ext->e_offset);
 341   H_PUT_64 (abfd, in->n_value, ext->e_value);
 342   H_PUT_16 (abfd, in->n_scnum, ext->e_scnum);
 343   H_PUT_16 (abfd, in->n_type, ext->e_type);
 344   H_PUT_8 (abfd, in->n_sclass, ext->e_sclass);
 345   H_PUT_8 (abfd, in->n_numaux, ext->e_numaux);
 346   return bfd_coff_symesz (abfd);
 347 }
 348
 349 static void
 350 _bfd_xcoff64_swap_aux_in (abfd, ext1, type, class, indx, numaux, in1)
 351      bfd *abfd;
 352      PTR ext1;
 353      int type;
 354      int class;
 355      int indx;
 356      int numaux;
 357      PTR in1;
 358 {
 359   union external_auxent *ext = (union external_auxent *) ext1;
 360   union internal_auxent *in = (union internal_auxent *) in1;
 361
 362   switch (class)
 363     {
 364     case C_FILE:
 365       if (ext->x_file.x_n.x_zeroes[0] == 0)
 366         {
 367           in->x_file.x_n.x_zeroes = 0;
 368           in->x_file.x_n.x_offset = H_GET_32 (abfd, ext->x_file.x_n.x_offset);
 369         }
 370       else
 371         {
 372           memcpy (in->x_file.x_fname, ext->x_file.x_fname, FILNMLEN);
 373         }
 374       goto end;
 375
 376       /* RS/6000 "csect" auxents */
 377     case C_EXT:
 378     case C_HIDEXT:
 379       if (indx + 1 == numaux)
 380         {
 381           bfd_signed_vma h = 0;
 382           bfd_vma l = 0;
 383
 384           h = H_GET_S32 (abfd, ext->x_csect.x_scnlen_hi);
 385           l = H_GET_32 (abfd, ext->x_csect.x_scnlen_lo);
 386
 387           in->x_csect.x_scnlen.l = h << 32 | (l & 0xffffffff);
 388
 389           in->x_csect.x_parmhash = H_GET_32 (abfd, ext->x_csect.x_parmhash);
 390           in->x_csect.x_snhash = H_GET_16 (abfd, ext->x_csect.x_snhash);
 391           /* We don't have to hack bitfields in x_smtyp because it's
 392              defined by shifts-and-ands, which are equivalent on all
 393              byte orders.  */
 394           in->x_csect.x_smtyp = H_GET_8 (abfd, ext->x_csect.x_smtyp);
 395           in->x_csect.x_smclas = H_GET_8 (abfd, ext->x_csect.x_smclas);
 396           goto end;
 397         }
 398       break;
 399
 400     case C_STAT:
 401     case C_LEAFSTAT:
 402     case C_HIDDEN:
 403       if (type == T_NULL)
 404         {
 405           /* PE defines some extra fields; we zero them out for
 406              safety.  */
 407           in->x_scn.x_checksum = 0;
 408           in->x_scn.x_associated = 0;
 409           in->x_scn.x_comdat = 0;
 410
 411           goto end;
 412         }
 413       break;
 414     }
 415
 416   if (class == C_BLOCK || class == C_FCN || ISFCN (type) || ISTAG (class))
 417     {
 418       in->x_sym.x_fcnary.x_fcn.x_lnnoptr
 419         = H_GET_64 (abfd, ext->x_sym.x_fcnary.x_fcn.x_lnnoptr);
 420       in->x_sym.x_fcnary.x_fcn.x_endndx.l
 421         = H_GET_32 (abfd, ext->x_sym.x_fcnary.x_fcn.x_endndx);
 422     }
 423   if (ISFCN (type))
 424     {
 425       in->x_sym.x_misc.x_fsize
 426         = H_GET_32 (abfd, ext->x_sym.x_fcnary.x_fcn.x_fsize);
 427     }
 428   else
 429     {
 430       in->x_sym.x_misc.x_lnsz.x_lnno
 431         = H_GET_32 (abfd, ext->x_sym.x_fcnary.x_lnsz.x_lnno);
 432       in->x_sym.x_misc.x_lnsz.x_size
 433         = H_GET_16 (abfd, ext->x_sym.x_fcnary.x_lnsz.x_size);
 434     }
 435
 436  end: ;
 437 }
 438
 439 static unsigned int
 440 _bfd_xcoff64_swap_aux_out (abfd, inp, type, class, indx, numaux, extp)
 441      bfd *abfd;
 442      PTR inp;
 443      int type;
 444      int class;
 445      int indx ATTRIBUTE_UNUSED;
 446      int numaux ATTRIBUTE_UNUSED;
 447      PTR extp;
 448 {
 449   union internal_auxent *in = (union internal_auxent *) inp;
 450   union external_auxent *ext = (union external_auxent *) extp;
 451
 452   memset ((PTR) ext, 0, bfd_coff_auxesz (abfd));
 453   switch (class)
 454     {
 455     case C_FILE:
 456       if (in->x_file.x_n.x_zeroes == 0)
 457         {
 458           H_PUT_32 (abfd, 0, ext->x_file.x_n.x_zeroes);
 459           H_PUT_32 (abfd, in->x_file.x_n.x_offset, ext->x_file.x_n.x_offset);
 460         }
 461       else
 462         {
 463           memcpy (ext->x_file.x_fname, in->x_file.x_fname, FILNMLEN);
 464         }
 465       H_PUT_8 (abfd, _AUX_FILE, ext->x_auxtype.x_auxtype);
 466       goto end;
 467
 468       /* RS/6000 "csect" auxents */
 469     case C_EXT:
 470     case C_HIDEXT:
 471       if (indx + 1 == numaux)
 472         {
 473           bfd_vma temp;
 474
 475           temp = in->x_csect.x_scnlen.l & 0xffffffff;
 476           H_PUT_32 (abfd, temp, ext->x_csect.x_scnlen_lo);
 477           temp = in->x_csect.x_scnlen.l >> 32;
 478           H_PUT_32 (abfd, temp, ext->x_csect.x_scnlen_hi);
 479           H_PUT_32 (abfd, in->x_csect.x_parmhash, ext->x_csect.x_parmhash);
 480           H_PUT_16 (abfd, in->x_csect.x_snhash, ext->x_csect.x_snhash);
 481           /* We don't have to hack bitfields in x_smtyp because it's
 482              defined by shifts-and-ands, which are equivalent on all
 483              byte orders.  */
 484           H_PUT_8 (abfd, in->x_csect.x_smtyp, ext->x_csect.x_smtyp);
 485           H_PUT_8 (abfd, in->x_csect.x_smclas, ext->x_csect.x_smclas);
 486           H_PUT_8 (abfd, _AUX_CSECT, ext->x_auxtype.x_auxtype);
 487           goto end;
 488         }
 489       break;
 490
 491     case C_STAT:
 492     case C_LEAFSTAT:
 493     case C_HIDDEN:
 494       if (type == T_NULL)
 495         {
 496           goto end;
 497         }
 498       break;
 499     }
 500
 501   if (class == C_BLOCK || class == C_FCN || ISFCN (type) || ISTAG (class))
 502     {
 503       H_PUT_64 (abfd, in->x_sym.x_fcnary.x_fcn.x_lnnoptr,
 504                ext->x_sym.x_fcnary.x_fcn.x_lnnoptr);
 505       H_PUT_8 (abfd, _AUX_FCN,
 506                ext->x_auxtype.x_auxtype);
 507       H_PUT_32 (abfd, in->x_sym.x_fcnary.x_fcn.x_endndx.l,
 508                ext->x_sym.x_fcnary.x_fcn.x_endndx);
 509     }
 510   if (ISFCN (type))
 511     {
 512       H_PUT_32 (abfd, in->x_sym.x_misc.x_fsize,
 513                ext->x_sym.x_fcnary.x_fcn.x_fsize);
 514     }
 515   else
 516     {
 517       H_PUT_32 (abfd, in->x_sym.x_misc.x_lnsz.x_lnno,
 518                ext->x_sym.x_fcnary.x_lnsz.x_lnno);
 519       H_PUT_16 (abfd, in->x_sym.x_misc.x_lnsz.x_size,
 520                ext->x_sym.x_fcnary.x_lnsz.x_size);
 521     }
 522
 523  end:
 524
 525   return bfd_coff_auxesz (abfd);
 526 }
 527
 528 static bfd_boolean
 529 _bfd_xcoff64_put_symbol_name (abfd, strtab, sym, name)
 530      bfd *abfd;
 531      struct bfd_strtab_hash *strtab;
 532      struct internal_syment *sym;
 533      const char *name;
 534 {
 535   bfd_boolean hash;
 536   bfd_size_type indx;
 537
 538   hash = TRUE;
 539
 540   if ((abfd->flags & BFD_TRADITIONAL_FORMAT) != 0)
 541     hash = FALSE;
 542
 543   indx = _bfd_stringtab_add (strtab, name, hash, FALSE);
 544
 545   if (indx == (bfd_size_type) -1)
 546     return FALSE;
 547
 548   sym->_n._n_n._n_zeroes = 0;
 549   sym->_n._n_n._n_offset = STRING_SIZE_SIZE + indx;
 550
 551   return TRUE;
 552 }
 553
 554 static bfd_boolean
 555 _bfd_xcoff64_put_ldsymbol_name (abfd, ldinfo, ldsym, name)
 556      bfd *abfd ATTRIBUTE_UNUSED;
 557      struct xcoff_loader_info *ldinfo;
 558      struct internal_ldsym *ldsym;
 559      const char *name;
 560 {
 561   size_t len;
 562   len = strlen (name);
 563
 564   if (ldinfo->string_size + len + 3 > ldinfo->string_alc)
 565     {
 566       bfd_size_type newalc;
 567       bfd_byte *newstrings;
 568
 569       newalc = ldinfo->string_alc * 2;
 570       if (newalc == 0)
 571         newalc = 32;
 572       while (ldinfo->string_size + len + 3 > newalc)
 573         newalc *= 2;
 574
 575       newstrings = ((bfd_byte *)
 576                     bfd_realloc ((PTR) 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 = h->root.root.string;
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, name, reloc_type_name, (bfd_vma) 0, input_bfd,
1350                   input_section, rel->r_vaddr - input_section->vma)))
1351             return FALSE;
1352         }
1353
1354       /* Add RELOCATION to the right bits of VALUE_TO_RELOCATE.  */
1355       value_to_relocate = ((value_to_relocate & ~howto.dst_mask)
1356                            | (((value_to_relocate & howto.src_mask)
1357                                + relocation) & howto.dst_mask));
1358
1359       /* Put the value back in the object file.  */
1360       if (1 == howto.size)
1361         bfd_put_16 (input_bfd, value_to_relocate, location);
1362       else if (2 == howto.size)
1363         bfd_put_32 (input_bfd, value_to_relocate, location);
1364       else
1365         bfd_put_64 (input_bfd, value_to_relocate, location);
1366
1367     }
1368   return TRUE;
1369 }
1370
1371 \f
1372 /* The XCOFF reloc table.  Actually, XCOFF relocations specify the
1373    bitsize and whether they are signed or not, along with a
1374    conventional type.  This table is for the types, which are used for
1375    different algorithms for putting in the reloc.  Many of these
1376    relocs need special_function entries, which I have not written.  */
1377
1378 reloc_howto_type xcoff64_howto_table[] =
1379 {
1380   /* Standard 64 bit relocation.  */
1381   HOWTO (R_POS,                 /* type */
1382          0,                     /* rightshift */
1383          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1384          64,                    /* bitsize */
1385          FALSE,                 /* pc_relative */
1386          0,                     /* bitpos */
1387          complain_overflow_bitfield, /* complain_on_overflow */
1388          0,                     /* special_function */
1389          "R_POS_64",            /* name */
1390          TRUE,                  /* partial_inplace */
1391          MINUS_ONE,             /* src_mask */
1392          MINUS_ONE,             /* dst_mask */
1393          FALSE),                /* pcrel_offset */
1394
1395   /* 64 bit relocation, but store negative value.  */
1396   HOWTO (R_NEG,                 /* type */
1397          0,                     /* rightshift */
1398          -4,                    /* size (0 = byte, 1 = short, 2 = long) */
1399          64,                    /* bitsize */
1400          FALSE,                 /* pc_relative */
1401          0,                     /* bitpos */
1402          complain_overflow_bitfield, /* complain_on_overflow */
1403          0,                     /* special_function */
1404          "R_NEG",               /* name */
1405          TRUE,                  /* partial_inplace */
1406          MINUS_ONE,             /* src_mask */
1407          MINUS_ONE,             /* dst_mask */
1408          FALSE),                /* pcrel_offset */
1409
1410   /* 32 bit PC relative relocation.  */
1411   HOWTO (R_REL,                 /* type */
1412          0,                     /* rightshift */
1413          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1414          32,                    /* bitsize */
1415          TRUE,                  /* pc_relative */
1416          0,                     /* bitpos */
1417          complain_overflow_signed, /* complain_on_overflow */
1418          0,                     /* special_function */
1419          "R_REL",               /* name */
1420          TRUE,                  /* partial_inplace */
1421          0xffffffff,            /* src_mask */
1422          0xffffffff,            /* dst_mask */
1423          FALSE),                /* pcrel_offset */
1424
1425   /* 16 bit TOC relative relocation.  */
1426   HOWTO (R_TOC,                 /* type */
1427          0,                     /* rightshift */
1428          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1429          16,                    /* bitsize */
1430          FALSE,                 /* pc_relative */
1431          0,                     /* bitpos */
1432          complain_overflow_bitfield, /* complain_on_overflow */
1433          0,                     /* special_function */
1434          "R_TOC",               /* name */
1435          TRUE,                  /* partial_inplace */
1436          0xffff,                /* src_mask */
1437          0xffff,                /* dst_mask */
1438          FALSE),                /* pcrel_offset */
1439
1440   /* I don't really know what this is.  */
1441   HOWTO (R_RTB,                 /* type */
1442          1,                     /* rightshift */
1443          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1444          32,                    /* bitsize */
1445          FALSE,                 /* pc_relative */
1446          0,                     /* bitpos */
1447          complain_overflow_bitfield, /* complain_on_overflow */
1448          0,                     /* special_function */
1449          "R_RTB",               /* name */
1450          TRUE,                  /* partial_inplace */
1451          0xffffffff,            /* src_mask */
1452          0xffffffff,            /* dst_mask */
1453          FALSE),                /* pcrel_offset */
1454
1455   /* External TOC relative symbol.  */
1456   HOWTO (R_GL,                  /* type */
1457          0,                     /* rightshift */
1458          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1459          16,                    /* bitsize */
1460          FALSE,                 /* pc_relative */
1461          0,                     /* bitpos */
1462          complain_overflow_bitfield, /* complain_on_overflow */
1463          0,                     /* special_function */
1464          "R_GL",                /* name */
1465          TRUE,                  /* partial_inplace */
1466          0xffff,                /* src_mask */
1467          0xffff,                /* dst_mask */
1468          FALSE),                /* pcrel_offset */
1469
1470   /* Local TOC relative symbol.  */
1471   HOWTO (R_TCL,                 /* type */
1472          0,                     /* rightshift */
1473          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1474          16,                    /* bitsize */
1475          FALSE,                 /* pc_relative */
1476          0,                     /* bitpos */
1477          complain_overflow_bitfield, /* complain_on_overflow */
1478          0,                     /* special_function */
1479          "R_TCL",               /* name */
1480          TRUE,                  /* partial_inplace */
1481          0xffff,                /* src_mask */
1482          0xffff,                /* dst_mask */
1483          FALSE),                /* pcrel_offset */
1484
1485   EMPTY_HOWTO (7),
1486
1487   /* Non modifiable absolute branch.  */
1488   HOWTO (R_BA,                  /* type */
1489          0,                     /* rightshift */
1490          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1491          26,                    /* bitsize */
1492          FALSE,                 /* pc_relative */
1493          0,                     /* bitpos */
1494          complain_overflow_bitfield, /* complain_on_overflow */
1495          0,                     /* special_function */
1496          "R_BA_26",             /* name */
1497          TRUE,                  /* partial_inplace */
1498          0x03fffffc,            /* src_mask */
1499          0x03fffffc,            /* dst_mask */
1500          FALSE),                /* pcrel_offset */
1501
1502   EMPTY_HOWTO (9),
1503
1504   /* Non modifiable relative branch.  */
1505   HOWTO (R_BR,                  /* type */
1506          0,                     /* rightshift */
1507          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1508          26,                    /* bitsize */
1509          TRUE,                  /* pc_relative */
1510          0,                     /* bitpos */
1511          complain_overflow_signed, /* complain_on_overflow */
1512          0,                     /* special_function */
1513          "R_BR",                /* name */
1514          TRUE,                  /* partial_inplace */
1515          0x03fffffc,            /* src_mask */
1516          0x03fffffc,            /* dst_mask */
1517          FALSE),                /* pcrel_offset */
1518
1519   EMPTY_HOWTO (0xb),
1520
1521   /* Indirect load.  */
1522   HOWTO (R_RL,                  /* type */
1523          0,                     /* rightshift */
1524          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1525          16,                    /* bitsize */
1526          FALSE,                 /* pc_relative */
1527          0,                     /* bitpos */
1528          complain_overflow_bitfield, /* complain_on_overflow */
1529          0,                     /* special_function */
1530          "R_RL",                /* name */
1531          TRUE,                  /* partial_inplace */
1532          0xffff,                /* src_mask */
1533          0xffff,                /* dst_mask */
1534          FALSE),                /* pcrel_offset */
1535
1536   /* Load address.  */
1537   HOWTO (R_RLA,                 /* type */
1538          0,                     /* rightshift */
1539          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1540          16,                    /* bitsize */
1541          FALSE,                 /* pc_relative */
1542          0,                     /* bitpos */
1543          complain_overflow_bitfield, /* complain_on_overflow */
1544          0,                     /* special_function */
1545          "R_RLA",               /* name */
1546          TRUE,                  /* partial_inplace */
1547          0xffff,                /* src_mask */
1548          0xffff,                /* dst_mask */
1549          FALSE),                /* pcrel_offset */
1550
1551   EMPTY_HOWTO (0xe),
1552
1553   /* Non-relocating reference.  */
1554   HOWTO (R_REF,                 /* type */
1555          0,                     /* rightshift */
1556          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1557          32,                    /* bitsize */
1558          FALSE,                 /* pc_relative */
1559          0,                     /* bitpos */
1560          complain_overflow_dont, /* complain_on_overflow */
1561          0,                     /* special_function */
1562          "R_REF",               /* name */
1563          FALSE,                 /* partial_inplace */
1564          0,                     /* src_mask */
1565          0,                     /* dst_mask */
1566          FALSE),                /* pcrel_offset */
1567
1568   EMPTY_HOWTO (0x10),
1569   EMPTY_HOWTO (0x11),
1570
1571   /* TOC relative indirect load.  */
1572   HOWTO (R_TRL,                 /* type */
1573          0,                     /* rightshift */
1574          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1575          16,                    /* bitsize */
1576          FALSE,                 /* pc_relative */
1577          0,                     /* bitpos */
1578          complain_overflow_bitfield, /* complain_on_overflow */
1579          0,                     /* special_function */
1580          "R_TRL",               /* name */
1581          TRUE,                  /* partial_inplace */
1582          0xffff,                /* src_mask */
1583          0xffff,                /* dst_mask */
1584          FALSE),                /* pcrel_offset */
1585
1586   /* TOC relative load address.  */
1587   HOWTO (R_TRLA,                /* type */
1588          0,                     /* rightshift */
1589          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1590          16,                    /* bitsize */
1591          FALSE,                 /* pc_relative */
1592          0,                     /* bitpos */
1593          complain_overflow_bitfield, /* complain_on_overflow */
1594          0,                     /* special_function */
1595          "R_TRLA",              /* name */
1596          TRUE,                  /* partial_inplace */
1597          0xffff,                /* src_mask */
1598          0xffff,                /* dst_mask */
1599          FALSE),                /* pcrel_offset */
1600
1601   /* Modifiable relative branch.  */
1602   HOWTO (R_RRTBI,               /* type */
1603          1,                     /* rightshift */
1604          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1605          32,                    /* bitsize */
1606          FALSE,                 /* pc_relative */
1607          0,                     /* bitpos */
1608          complain_overflow_bitfield, /* complain_on_overflow */
1609          0,                     /* special_function */
1610          "R_RRTBI",             /* name */
1611          TRUE,                  /* partial_inplace */
1612          0xffffffff,            /* src_mask */
1613          0xffffffff,            /* dst_mask */
1614          FALSE),                /* pcrel_offset */
1615
1616   /* Modifiable absolute branch.  */
1617   HOWTO (R_RRTBA,               /* type */
1618          1,                     /* rightshift */
1619          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1620          32,                    /* bitsize */
1621          FALSE,                 /* pc_relative */
1622          0,                     /* bitpos */
1623          complain_overflow_bitfield, /* complain_on_overflow */
1624          0,                     /* special_function */
1625          "R_RRTBA",             /* name */
1626          TRUE,                  /* partial_inplace */
1627          0xffffffff,            /* src_mask */
1628          0xffffffff,            /* dst_mask */
1629          FALSE),                /* pcrel_offset */
1630
1631   /* Modifiable call absolute indirect.  */
1632   HOWTO (R_CAI,                 /* type */
1633          0,                     /* rightshift */
1634          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1635          16,                    /* bitsize */
1636          FALSE,                 /* pc_relative */
1637          0,                     /* bitpos */
1638          complain_overflow_bitfield, /* complain_on_overflow */
1639          0,                     /* special_function */
1640          "R_CAI",               /* name */
1641          TRUE,                  /* partial_inplace */
1642          0xffff,                /* src_mask */
1643          0xffff,                /* dst_mask */
1644          FALSE),                /* pcrel_offset */
1645
1646   /* Modifiable call relative.  */
1647   HOWTO (R_CREL,                /* type */
1648          0,                     /* rightshift */
1649          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1650          16,                    /* bitsize */
1651          FALSE,                 /* pc_relative */
1652          0,                     /* bitpos */
1653          complain_overflow_bitfield, /* complain_on_overflow */
1654          0,                     /* special_function */
1655          "R_CREL",              /* name */
1656          TRUE,                  /* partial_inplace */
1657          0xffff,                /* src_mask */
1658          0xffff,                /* dst_mask */
1659          FALSE),                /* pcrel_offset */
1660
1661   /* Modifiable branch absolute.  */
1662   HOWTO (R_RBA,                 /* type */
1663          0,                     /* rightshift */
1664          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1665          26,                    /* bitsize */
1666          FALSE,                 /* pc_relative */
1667          0,                     /* bitpos */
1668          complain_overflow_bitfield, /* complain_on_overflow */
1669          0,                     /* special_function */
1670          "R_RBA",               /* name */
1671          TRUE,                  /* partial_inplace */
1672          0x03fffffc,            /* src_mask */
1673          0x03fffffc,            /* dst_mask */
1674          FALSE),                /* pcrel_offset */
1675
1676   /* Modifiable branch absolute.  */
1677   HOWTO (R_RBAC,                /* type */
1678          0,                     /* rightshift */
1679          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1680          32,                    /* bitsize */
1681          FALSE,                 /* pc_relative */
1682          0,                     /* bitpos */
1683          complain_overflow_bitfield, /* complain_on_overflow */
1684          0,                     /* special_function */
1685          "R_RBAC",              /* name */
1686          TRUE,                  /* partial_inplace */
1687          0xffffffff,            /* src_mask */
1688          0xffffffff,            /* dst_mask */
1689          FALSE),                /* pcrel_offset */
1690
1691   /* Modifiable branch relative.  */
1692   HOWTO (R_RBR,                 /* type */
1693          0,                     /* rightshift */
1694          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1695          26,                    /* bitsize */
1696          FALSE,                 /* pc_relative */
1697          0,                     /* bitpos */
1698          complain_overflow_signed, /* complain_on_overflow */
1699          0,                     /* special_function */
1700          "R_RBR_26",            /* name */
1701          TRUE,                  /* partial_inplace */
1702          0x03fffffc,            /* src_mask */
1703          0x03fffffc,            /* dst_mask */
1704          FALSE),                /* pcrel_offset */
1705
1706   /* Modifiable branch absolute.  */
1707   HOWTO (R_RBRC,                /* type */
1708          0,                     /* rightshift */
1709          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1710          16,                    /* bitsize */
1711          FALSE,                 /* pc_relative */
1712          0,                     /* bitpos */
1713          complain_overflow_bitfield, /* complain_on_overflow */
1714          0,                     /* special_function */
1715          "R_RBRC",              /* name */
1716          TRUE,                  /* partial_inplace */
1717          0xffff,                /* src_mask */
1718          0xffff,                /* dst_mask */
1719          FALSE),                /* pcrel_offset */
1720
1721   HOWTO (R_POS,                 /* type */
1722          0,                     /* rightshift */
1723          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1724          32,                    /* bitsize */
1725          FALSE,                 /* pc_relative */
1726          0,                     /* bitpos */
1727          complain_overflow_bitfield, /* complain_on_overflow */
1728          0,                     /* special_function */
1729          "R_POS_32",            /* name */
1730          TRUE,                  /* partial_inplace */
1731          0xffffffff,            /* src_mask */
1732          0xffffffff,            /* dst_mask */
1733          FALSE),                /* pcrel_offset */
1734
1735   /* 16 bit Non modifiable absolute branch.  */
1736   HOWTO (R_BA,                  /* type */
1737          0,                     /* rightshift */
1738          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1739          16,                    /* bitsize */
1740          FALSE,                 /* pc_relative */
1741          0,                     /* bitpos */
1742          complain_overflow_bitfield, /* complain_on_overflow */
1743          0,                     /* special_function */
1744          "R_BA_16",             /* name */
1745          TRUE,                  /* partial_inplace */
1746          0xfffc,                /* src_mask */
1747          0xfffc,                /* dst_mask */
1748          FALSE),                /* pcrel_offset */
1749
1750   /* Modifiable branch relative.  */
1751   HOWTO (R_RBR,                 /* type */
1752          0,                     /* rightshift */
1753          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1754          16,                    /* bitsize */
1755          FALSE,                 /* pc_relative */
1756          0,                     /* bitpos */
1757          complain_overflow_signed, /* complain_on_overflow */
1758          0,                     /* special_function */
1759          "R_RBR_16",            /* name */
1760          TRUE,                  /* partial_inplace */
1761          0xffff,                /* src_mask */
1762          0xffff,                /* dst_mask */
1763          FALSE),                /* pcrel_offset */
1764
1765   /* Modifiable branch absolute.  */
1766   HOWTO (R_RBA,                 /* type */
1767          0,                     /* rightshift */
1768          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1769          16,                    /* bitsize */
1770          FALSE,                 /* pc_relative */
1771          0,                     /* bitpos */
1772          complain_overflow_bitfield, /* complain_on_overflow */
1773          0,                     /* special_function */
1774          "R_RBA_16",            /* name */
1775          TRUE,                  /* partial_inplace */
1776          0xffff,                /* src_mask */
1777          0xffff,                /* dst_mask */
1778          FALSE),                /* pcrel_offset */
1779
1780 };
1781
1782 void
1783 xcoff64_rtype2howto (relent, internal)
1784      arelent *relent;
1785      struct internal_reloc *internal;
1786 {
1787   if (internal->r_type > R_RBRC)
1788     abort ();
1789
1790   /* Default howto layout works most of the time */
1791   relent->howto = &xcoff64_howto_table[internal->r_type];
1792
1793   /* Special case some 16 bit reloc */
1794   if (15 == (internal->r_size & 0x3f))
1795     {
1796       if (R_BA == internal->r_type)
1797         relent->howto = &xcoff64_howto_table[0x1d];
1798       else if (R_RBR == internal->r_type)
1799         relent->howto = &xcoff64_howto_table[0x1e];
1800       else if (R_RBA == internal->r_type)
1801         relent->howto = &xcoff64_howto_table[0x1f];
1802     }
1803   /* Special case 32 bit */
1804   else if (31 == (internal->r_size & 0x3f))
1805     {
1806       if (R_POS == internal->r_type)
1807         relent->howto = &xcoff64_howto_table[0x1c];
1808     }
1809
1810   /* The r_size field of an XCOFF reloc encodes the bitsize of the
1811      relocation, as well as indicating whether it is signed or not.
1812      Doublecheck that the relocation information gathered from the
1813      type matches this information.  The bitsize is not significant
1814      for R_REF relocs.  */
1815   if (relent->howto->dst_mask != 0
1816       && (relent->howto->bitsize
1817           != ((unsigned int) internal->r_size & 0x3f) + 1))
1818     abort ();
1819 }
1820
1821 reloc_howto_type *
1822 xcoff64_reloc_type_lookup (abfd, code)
1823      bfd *abfd ATTRIBUTE_UNUSED;
1824      bfd_reloc_code_real_type code;
1825 {
1826   switch (code)
1827     {
1828     case BFD_RELOC_PPC_B26:
1829       return &xcoff64_howto_table[0xa];
1830     case BFD_RELOC_PPC_BA16:
1831       return &xcoff64_howto_table[0x1d];
1832     case BFD_RELOC_PPC_BA26:
1833       return &xcoff64_howto_table[8];
1834     case BFD_RELOC_PPC_TOC16:
1835       return &xcoff64_howto_table[3];
1836     case BFD_RELOC_32:
1837     case BFD_RELOC_CTOR:
1838       return &xcoff64_howto_table[0x1c];
1839     case BFD_RELOC_64:
1840       return &xcoff64_howto_table[0];
1841     default:
1842       return NULL;
1843     }
1844 }
1845
1846 /* Read in the armap of an XCOFF archive.  */
1847
1848 static bfd_boolean
1849 xcoff64_slurp_armap (abfd)
1850      bfd *abfd;
1851 {
1852   file_ptr off;
1853   size_t namlen;
1854   bfd_size_type sz, amt;
1855   bfd_byte *contents, *cend;
1856   bfd_vma c, i;
1857   carsym *arsym;
1858   bfd_byte *p;
1859   file_ptr pos;
1860
1861   /* This is for the new format.  */
1862   struct xcoff_ar_hdr_big hdr;
1863
1864   if (xcoff_ardata (abfd) == NULL)
1865     {
1866       bfd_has_map (abfd) = FALSE;
1867       return TRUE;
1868     }
1869
1870   off = bfd_scan_vma (xcoff_ardata_big (abfd)->symoff64,
1871                       (const char **) NULL, 10);
1872   if (off == 0)
1873     {
1874       bfd_has_map (abfd) = FALSE;
1875       return TRUE;
1876     }
1877
1878   if (bfd_seek (abfd, off, SEEK_SET) != 0)
1879     return FALSE;
1880
1881   /* The symbol table starts with a normal archive header.  */
1882   if (bfd_bread ((PTR) &hdr, (bfd_size_type) SIZEOF_AR_HDR_BIG, abfd)
1883       != SIZEOF_AR_HDR_BIG)
1884     return FALSE;
1885
1886   /* Skip the name (normally empty).  */
1887   namlen = strtol (hdr.namlen, (char **) NULL, 10);
1888   pos = ((namlen + 1) & ~(size_t) 1) + SXCOFFARFMAG;
1889   if (bfd_seek (abfd, pos, SEEK_CUR) != 0)
1890     return FALSE;
1891
1892   sz = bfd_scan_vma (hdr.size, (const char **) NULL, 10);
1893
1894   /* Read in the entire symbol table.  */
1895   contents = (bfd_byte *) bfd_alloc (abfd, sz);
1896   if (contents == NULL)
1897     return FALSE;
1898   if (bfd_bread ((PTR) contents, sz, abfd) != sz)
1899     return FALSE;
1900
1901   /* The symbol table starts with an eight byte count.  */
1902   c = H_GET_64 (abfd, contents);
1903
1904   if (c * 8 >= sz)
1905     {
1906       bfd_set_error (bfd_error_bad_value);
1907       return FALSE;
1908     }
1909   amt = c;
1910   amt *= sizeof (carsym);
1911   bfd_ardata (abfd)->symdefs = (carsym *) bfd_alloc (abfd, amt);
1912   if (bfd_ardata (abfd)->symdefs == NULL)
1913     return FALSE;
1914
1915   /* After the count comes a list of eight byte file offsets.  */
1916   for (i = 0, arsym = bfd_ardata (abfd)->symdefs, p = contents + 8;
1917        i < c;
1918        ++i, ++arsym, p += 8)
1919     arsym->file_offset = H_GET_64 (abfd, p);
1920
1921   /* After the file offsets come null terminated symbol names.  */
1922   cend = contents + sz;
1923   for (i = 0, arsym = bfd_ardata (abfd)->symdefs;
1924        i < c;
1925        ++i, ++arsym, p += strlen ((char *) p) + 1)
1926     {
1927       if (p >= cend)
1928         {
1929           bfd_set_error (bfd_error_bad_value);
1930           return FALSE;
1931         }
1932       arsym->name = (char *) p;
1933     }
1934
1935   bfd_ardata (abfd)->symdef_count = c;
1936   bfd_has_map (abfd) = TRUE;
1937
1938   return TRUE;
1939 }
1940
1941
1942 /* See if this is an NEW XCOFF archive.  */
1943
1944 static const bfd_target *
1945 xcoff64_archive_p (abfd)
1946      bfd *abfd;
1947 {
1948   struct artdata *tdata_hold;
1949   char magic[SXCOFFARMAG];
1950   /* This is the new format.  */
1951   struct xcoff_ar_file_hdr_big hdr;
1952   bfd_size_type amt = SXCOFFARMAG;
1953
1954   if (bfd_bread ((PTR) magic, amt, abfd) != amt)
1955     {
1956       if (bfd_get_error () != bfd_error_system_call)
1957         bfd_set_error (bfd_error_wrong_format);
1958       return NULL;
1959     }
1960
1961   if (strncmp (magic, XCOFFARMAGBIG, SXCOFFARMAG) != 0)
1962     {
1963       bfd_set_error (bfd_error_wrong_format);
1964       return NULL;
1965     }
1966
1967   /* Copy over the magic string.  */
1968   memcpy (hdr.magic, magic, SXCOFFARMAG);
1969
1970   /* Now read the rest of the file header.  */
1971   amt = SIZEOF_AR_FILE_HDR_BIG - SXCOFFARMAG;
1972   if (bfd_bread ((PTR) &hdr.memoff, amt, abfd) != amt)
1973     {
1974       if (bfd_get_error () != bfd_error_system_call)
1975         bfd_set_error (bfd_error_wrong_format);
1976       return NULL;
1977     }
1978
1979   tdata_hold = bfd_ardata (abfd);
1980
1981   amt = sizeof (struct artdata);
1982   bfd_ardata (abfd) = (struct artdata *) bfd_zalloc (abfd, amt);
1983   if (bfd_ardata (abfd) == (struct artdata *) NULL)
1984     goto error_ret_restore;
1985
1986   bfd_ardata (abfd)->cache = NULL;
1987   bfd_ardata (abfd)->archive_head = NULL;
1988   bfd_ardata (abfd)->symdefs = NULL;
1989   bfd_ardata (abfd)->extended_names = NULL;
1990   bfd_ardata (abfd)->first_file_filepos = bfd_scan_vma (hdr.firstmemoff,
1991                                                         (const char **) NULL,
1992                                                         10);
1993
1994   amt = SIZEOF_AR_FILE_HDR_BIG;
1995   bfd_ardata (abfd)->tdata = bfd_zalloc (abfd, amt);
1996   if (bfd_ardata (abfd)->tdata == NULL)
1997     goto error_ret;
1998
1999   memcpy (bfd_ardata (abfd)->tdata, &hdr, SIZEOF_AR_FILE_HDR_BIG);
2000
2001   if (! xcoff64_slurp_armap (abfd))
2002     {
2003     error_ret:
2004       bfd_release (abfd, bfd_ardata (abfd));
2005     error_ret_restore:
2006       bfd_ardata (abfd) = tdata_hold;
2007       return NULL;
2008     }
2009
2010   return abfd->xvec;
2011 }
2012
2013
2014 /* Open the next element in an XCOFF archive.  */
2015
2016 static bfd *
2017 xcoff64_openr_next_archived_file (archive, last_file)
2018      bfd *archive;
2019      bfd *last_file;
2020 {
2021   bfd_vma filestart;
2022
2023   if ((xcoff_ardata (archive) == NULL)
2024       || ! xcoff_big_format_p (archive))
2025     {
2026       bfd_set_error (bfd_error_invalid_operation);
2027       return NULL;
2028     }
2029
2030   if (last_file == NULL)
2031     {
2032       filestart = bfd_ardata (archive)->first_file_filepos;
2033     }
2034   else
2035     {
2036       filestart = bfd_scan_vma (arch_xhdr_big (last_file)->nextoff,
2037                                 (const char **) NULL, 10);
2038     }
2039
2040   if (filestart == 0
2041       || filestart == bfd_scan_vma (xcoff_ardata_big (archive)->memoff,
2042                                     (const char **) NULL, 10)
2043       || filestart == bfd_scan_vma (xcoff_ardata_big (archive)->symoff,
2044                                     (const char **) NULL, 10))
2045     {
2046       bfd_set_error (bfd_error_no_more_archived_files);
2047       return NULL;
2048     }
2049
2050   return _bfd_get_elt_at_filepos (archive, (file_ptr) filestart);
2051 }
2052
2053 /* We can't use the usual coff_sizeof_headers routine, because AIX
2054    always uses an a.out header.  */
2055
2056 static int
2057 xcoff64_sizeof_headers (abfd, reloc)
2058      bfd *abfd;
2059      bfd_boolean reloc ATTRIBUTE_UNUSED;
2060 {
2061   int size;
2062
2063   size = bfd_coff_filhsz (abfd);
2064
2065   /* Don't think the small aout header can be used since some of the
2066      old elements have been reordered past the end of the old coff
2067      small aout size.  */
2068
2069   if (xcoff_data (abfd)->full_aouthdr)
2070     size += bfd_coff_aoutsz (abfd);
2071
2072   size += abfd->section_count * bfd_coff_scnhsz (abfd);
2073   return size;
2074 }
2075
2076
2077
2078 static asection *
2079 xcoff64_create_csect_from_smclas (abfd, aux, symbol_name)
2080      bfd *abfd;
2081      union internal_auxent *aux;
2082      const char *symbol_name;
2083 {
2084   asection *return_value = NULL;
2085
2086   /* Changes from 32 :
2087      .sv == 8, is only for 32 bit programs
2088      .ti == 12 and .tb == 13 are now reserved.  */
2089   static const char *names[19] =
2090   {
2091     ".pr", ".ro", ".db", ".tc", ".ua", ".rw", ".gl", ".xo",
2092     NULL, ".bs", ".ds", ".uc", NULL,  NULL,  NULL,  ".tc0",
2093     ".td", ".sv64", ".sv3264"
2094   };
2095
2096   if ((19 >= aux->x_csect.x_smclas)
2097       && (NULL != names[aux->x_csect.x_smclas]))
2098     {
2099
2100       return_value = bfd_make_section_anyway
2101         (abfd, names[aux->x_csect.x_smclas]);
2102
2103     }
2104   else
2105     {
2106       (*_bfd_error_handler)
2107         (_("%s: symbol `%s' has unrecognized smclas %d"),
2108          bfd_archive_filename (abfd), symbol_name, aux->x_csect.x_smclas);
2109       bfd_set_error (bfd_error_bad_value);
2110     }
2111
2112   return return_value;
2113 }
2114
2115 static bfd_boolean
2116 xcoff64_is_lineno_count_overflow (abfd, value)
2117      bfd *abfd ATTRIBUTE_UNUSED;
2118      bfd_vma value ATTRIBUTE_UNUSED;
2119 {
2120   return FALSE;
2121 }
2122
2123 static bfd_boolean
2124 xcoff64_is_reloc_count_overflow (abfd, value)
2125      bfd *abfd ATTRIBUTE_UNUSED;
2126      bfd_vma value ATTRIBUTE_UNUSED;
2127 {
2128   return FALSE;
2129 }
2130
2131 static bfd_vma
2132 xcoff64_loader_symbol_offset (abfd, ldhdr)
2133      bfd *abfd ATTRIBUTE_UNUSED;
2134      struct internal_ldhdr *ldhdr;
2135 {
2136   return (ldhdr->l_symoff);
2137 }
2138
2139 static bfd_vma
2140 xcoff64_loader_reloc_offset (abfd, ldhdr)
2141      bfd *abfd ATTRIBUTE_UNUSED;
2142      struct internal_ldhdr *ldhdr;
2143 {
2144   return (ldhdr->l_rldoff);
2145 }
2146
2147 static bfd_boolean
2148 xcoff64_bad_format_hook (abfd, filehdr)
2149      bfd * abfd;
2150      PTR filehdr;
2151 {
2152   struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
2153
2154   /* Check flavor first.  */
2155   if (bfd_get_flavour (abfd) != bfd_target_xcoff_flavour)
2156     return FALSE;
2157
2158   if (bfd_xcoff_magic_number (abfd) != internal_f->f_magic)
2159     return FALSE;
2160
2161   return TRUE;
2162 }
2163
2164 static bfd_boolean
2165 xcoff64_generate_rtinit (abfd, init, fini, rtld)
2166      bfd *abfd;
2167      const char *init;
2168      const char *fini;
2169      bfd_boolean rtld;
2170 {
2171   bfd_byte filehdr_ext[FILHSZ];
2172   bfd_byte scnhdr_ext[SCNHSZ * 3];
2173   bfd_byte syment_ext[SYMESZ * 10];
2174   bfd_byte reloc_ext[RELSZ * 3];
2175   bfd_byte *data_buffer;
2176   bfd_size_type data_buffer_size;
2177   bfd_byte *string_table, *st_tmp;
2178   bfd_size_type string_table_size;
2179   bfd_vma val;
2180   size_t initsz, finisz;
2181   struct internal_filehdr filehdr;
2182   struct internal_scnhdr text_scnhdr;
2183   struct internal_scnhdr data_scnhdr;
2184   struct internal_scnhdr bss_scnhdr;
2185   struct internal_syment syment;
2186   union internal_auxent auxent;
2187   struct internal_reloc reloc;
2188
2189   char *text_name = ".text";
2190   char *data_name = ".data";
2191   char *bss_name = ".bss";
2192   char *rtinit_name = "__rtinit";
2193   char *rtld_name = "__rtld";
2194
2195   if (! bfd_xcoff_rtinit_size (abfd))
2196     return FALSE;
2197
2198   initsz = (init == NULL ? 0 : 1 + strlen (init));
2199   finisz = (fini == NULL ? 0 : 1 + strlen (fini));
2200
2201   /* File header.  */
2202   memset (filehdr_ext, 0, FILHSZ);
2203   memset (&filehdr, 0, sizeof (struct internal_filehdr));
2204   filehdr.f_magic = bfd_xcoff_magic_number (abfd);
2205   filehdr.f_nscns = 3;
2206   filehdr.f_timdat = 0;
2207   filehdr.f_nsyms = 0;  /* at least 6, no more than 8 */
2208   filehdr.f_symptr = 0; /* set below */
2209   filehdr.f_opthdr = 0;
2210   filehdr.f_flags = 0;
2211
2212   /* Section headers.  */
2213   memset (scnhdr_ext, 0, 3 * SCNHSZ);
2214
2215   /* Text.  */
2216   memset (&text_scnhdr, 0, sizeof (struct internal_scnhdr));
2217   memcpy (text_scnhdr.s_name, text_name, strlen (text_name));
2218   text_scnhdr.s_paddr = 0;
2219   text_scnhdr.s_vaddr = 0;
2220   text_scnhdr.s_size = 0;
2221   text_scnhdr.s_scnptr = 0;
2222   text_scnhdr.s_relptr = 0;
2223   text_scnhdr.s_lnnoptr = 0;
2224   text_scnhdr.s_nreloc = 0;
2225   text_scnhdr.s_nlnno = 0;
2226   text_scnhdr.s_flags = STYP_TEXT;
2227
2228   /* Data.  */
2229   memset (&data_scnhdr, 0, sizeof (struct internal_scnhdr));
2230   memcpy (data_scnhdr.s_name, data_name, strlen (data_name));
2231   data_scnhdr.s_paddr = 0;
2232   data_scnhdr.s_vaddr = 0;
2233   data_scnhdr.s_size = 0;    /* set below */
2234   data_scnhdr.s_scnptr = FILHSZ + 3 * SCNHSZ;
2235   data_scnhdr.s_relptr = 0;  /* set below */
2236   data_scnhdr.s_lnnoptr = 0;
2237   data_scnhdr.s_nreloc = 0;  /* either 1 or 2 */
2238   data_scnhdr.s_nlnno = 0;
2239   data_scnhdr.s_flags = STYP_DATA;
2240
2241   /* Bss.  */
2242   memset (&bss_scnhdr, 0, sizeof (struct internal_scnhdr));
2243   memcpy (bss_scnhdr.s_name, bss_name, strlen (bss_name));
2244   bss_scnhdr.s_paddr = 0; /* set below */
2245   bss_scnhdr.s_vaddr = 0; /* set below */
2246   bss_scnhdr.s_size = 0;  /* set below */
2247   bss_scnhdr.s_scnptr = 0;
2248   bss_scnhdr.s_relptr = 0;
2249   bss_scnhdr.s_lnnoptr = 0;
2250   bss_scnhdr.s_nreloc = 0;
2251   bss_scnhdr.s_nlnno = 0;
2252   bss_scnhdr.s_flags = STYP_BSS;
2253
2254   /* .data
2255      0x0000           0x00000000 : rtl
2256      0x0004           0x00000000 :
2257      0x0008           0x00000018 : offset to init, or 0
2258      0x000C           0x00000038 : offset to fini, or 0
2259      0x0010           0x00000010 : size of descriptor
2260      0x0014           0x00000000 : pad
2261      0x0018           0x00000000 : init, needs a reloc
2262      0x001C           0x00000000 :
2263      0x0020           0x00000058 : offset to init name
2264      0x0024           0x00000000 : flags, padded to a word
2265      0x0028           0x00000000 : empty init
2266      0x002C           0x00000000 :
2267      0x0030           0x00000000 :
2268      0x0034           0x00000000 :
2269      0x0038           0x00000000 : fini, needs a reloc
2270      0x003C           0x00000000 :
2271      0x0040           0x00000??? : offset to fini name
2272      0x0044           0x00000000 : flags, padded to a word
2273      0x0048           0x00000000 : empty fini
2274      0x004C           0x00000000 :
2275      0x0050           0x00000000 :
2276      0x0054           0x00000000 :
2277      0x0058           init name
2278      0x0058 + initsz  fini name */
2279
2280   data_buffer_size = 0x0058 + initsz + finisz;
2281   data_buffer_size = (data_buffer_size + 7) &~ (bfd_size_type) 7;
2282   data_buffer = NULL;
2283   data_buffer = (bfd_byte *) bfd_zmalloc (data_buffer_size);
2284   if (data_buffer == NULL)
2285     return FALSE;
2286
2287   if (initsz)
2288     {
2289       val = 0x18;
2290       bfd_put_32 (abfd, val, &data_buffer[0x08]);
2291       val = 0x58;
2292       bfd_put_32 (abfd, val, &data_buffer[0x20]);
2293       memcpy (&data_buffer[val], init, initsz);
2294     }
2295
2296   if (finisz)
2297     {
2298       val = 0x38;
2299       bfd_put_32 (abfd, val, &data_buffer[0x0C]);
2300       val = 0x58 + initsz;
2301       bfd_put_32 (abfd, val, &data_buffer[0x40]);
2302       memcpy (&data_buffer[val], fini, finisz);
2303     }
2304
2305   val = 0x10;
2306   bfd_put_32 (abfd, val, &data_buffer[0x10]);
2307   data_scnhdr.s_size = data_buffer_size;
2308   bss_scnhdr.s_paddr = bss_scnhdr.s_vaddr = data_scnhdr.s_size;
2309
2310   /* String table.  */
2311   string_table_size = 4;
2312   string_table_size += strlen (data_name) + 1;
2313   string_table_size += strlen (rtinit_name) + 1;
2314   string_table_size += initsz;
2315   string_table_size += finisz;
2316   if (rtld)
2317     string_table_size += strlen (rtld_name) + 1;
2318
2319   string_table = (bfd_byte *) bfd_zmalloc (string_table_size);
2320   if (string_table == NULL)
2321     return FALSE;
2322
2323   val = string_table_size;
2324   bfd_put_32 (abfd, val, &string_table[0]);
2325   st_tmp = string_table + 4;
2326
2327   /* symbols
2328      0. .data csect
2329      2. __rtinit
2330      4. init function
2331      6. fini function
2332      8. __rtld  */
2333   memset (syment_ext, 0, 10 * SYMESZ);
2334   memset (reloc_ext, 0, 3 * RELSZ);
2335
2336   /* .data csect */
2337   memset (&syment, 0, sizeof (struct internal_syment));
2338   memset (&auxent, 0, sizeof (union internal_auxent));
2339
2340   syment._n._n_n._n_offset = st_tmp - string_table;
2341   memcpy (st_tmp, data_name, strlen (data_name));
2342   st_tmp += strlen (data_name) + 1;
2343
2344   syment.n_scnum = 2;
2345   syment.n_sclass = C_HIDEXT;
2346   syment.n_numaux = 1;
2347   auxent.x_csect.x_scnlen.l = data_buffer_size;
2348   auxent.x_csect.x_smtyp = 3 << 3 | XTY_SD;
2349   auxent.x_csect.x_smclas = XMC_RW;
2350   bfd_coff_swap_sym_out (abfd, &syment,
2351                          &syment_ext[filehdr.f_nsyms * SYMESZ]);
2352   bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0,
2353                          syment.n_numaux,
2354                          &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]);
2355   filehdr.f_nsyms += 2;
2356
2357   /* __rtinit */
2358   memset (&syment, 0, sizeof (struct internal_syment));
2359   memset (&auxent, 0, sizeof (union internal_auxent));
2360   syment._n._n_n._n_offset = st_tmp - string_table;
2361   memcpy (st_tmp, rtinit_name, strlen (rtinit_name));
2362   st_tmp += strlen (rtinit_name) + 1;
2363
2364   syment.n_scnum = 2;
2365   syment.n_sclass = C_EXT;
2366   syment.n_numaux = 1;
2367   auxent.x_csect.x_smtyp = XTY_LD;
2368   auxent.x_csect.x_smclas = XMC_RW;
2369   bfd_coff_swap_sym_out (abfd, &syment,
2370                          &syment_ext[filehdr.f_nsyms * SYMESZ]);
2371   bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0,
2372                          syment.n_numaux,
2373                          &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]);
2374   filehdr.f_nsyms += 2;
2375
2376   /* Init.  */
2377   if (initsz)
2378     {
2379       memset (&syment, 0, sizeof (struct internal_syment));
2380       memset (&auxent, 0, sizeof (union internal_auxent));
2381
2382       syment._n._n_n._n_offset = st_tmp - string_table;
2383       memcpy (st_tmp, init, initsz);
2384       st_tmp += initsz;
2385
2386       syment.n_sclass = C_EXT;
2387       syment.n_numaux = 1;
2388       bfd_coff_swap_sym_out (abfd, &syment,
2389                              &syment_ext[filehdr.f_nsyms * SYMESZ]);
2390       bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0,
2391                              syment.n_numaux,
2392                              &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]);
2393       /* Reloc.  */
2394       memset (&reloc, 0, sizeof (struct internal_reloc));
2395       reloc.r_vaddr = 0x0018;
2396       reloc.r_symndx = filehdr.f_nsyms;
2397       reloc.r_type = R_POS;
2398       reloc.r_size = 63;
2399       bfd_coff_swap_reloc_out (abfd, &reloc, &reloc_ext[0]);
2400
2401       filehdr.f_nsyms += 2;
2402       data_scnhdr.s_nreloc += 1;
2403     }
2404
2405   /* Finit.  */
2406   if (finisz)
2407     {
2408       memset (&syment, 0, sizeof (struct internal_syment));
2409       memset (&auxent, 0, sizeof (union internal_auxent));
2410
2411       syment._n._n_n._n_offset = st_tmp - string_table;
2412       memcpy (st_tmp, fini, finisz);
2413       st_tmp += finisz;
2414
2415       syment.n_sclass = C_EXT;
2416       syment.n_numaux = 1;
2417       bfd_coff_swap_sym_out (abfd, &syment,
2418                              &syment_ext[filehdr.f_nsyms * SYMESZ]);
2419       bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0,
2420                              syment.n_numaux,
2421                              &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]);
2422
2423       /* Reloc.  */
2424       memset (&reloc, 0, sizeof (struct internal_reloc));
2425       reloc.r_vaddr = 0x0038;
2426       reloc.r_symndx = filehdr.f_nsyms;
2427       reloc.r_type = R_POS;
2428       reloc.r_size = 63;
2429       bfd_coff_swap_reloc_out (abfd, &reloc,
2430                                &reloc_ext[data_scnhdr.s_nreloc * RELSZ]);
2431
2432       filehdr.f_nsyms += 2;
2433       data_scnhdr.s_nreloc += 1;
2434     }
2435
2436   if (rtld)
2437     {
2438       memset (&syment, 0, sizeof (struct internal_syment));
2439       memset (&auxent, 0, sizeof (union internal_auxent));
2440
2441       syment._n._n_n._n_offset = st_tmp - string_table;
2442       memcpy (st_tmp, rtld_name, strlen (rtld_name));
2443       st_tmp += strlen (rtld_name) + 1;
2444
2445       syment.n_sclass = C_EXT;
2446       syment.n_numaux = 1;
2447       bfd_coff_swap_sym_out (abfd, &syment,
2448                              &syment_ext[filehdr.f_nsyms * SYMESZ]);
2449       bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0,
2450                              syment.n_numaux,
2451                              &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]);
2452
2453       /* Reloc.  */
2454       memset (&reloc, 0, sizeof (struct internal_reloc));
2455       reloc.r_vaddr = 0x0000;
2456       reloc.r_symndx = filehdr.f_nsyms;
2457       reloc.r_type = R_POS;
2458       reloc.r_size = 63;
2459       bfd_coff_swap_reloc_out (abfd, &reloc,
2460                                &reloc_ext[data_scnhdr.s_nreloc * RELSZ]);
2461
2462       filehdr.f_nsyms += 2;
2463       data_scnhdr.s_nreloc += 1;
2464
2465       bss_scnhdr.s_size = 0;
2466     }
2467
2468   data_scnhdr.s_relptr = data_scnhdr.s_scnptr + data_buffer_size;
2469   filehdr.f_symptr = data_scnhdr.s_relptr + data_scnhdr.s_nreloc * RELSZ;
2470
2471   bfd_coff_swap_filehdr_out (abfd, &filehdr, filehdr_ext);
2472   bfd_bwrite (filehdr_ext, FILHSZ, abfd);
2473   bfd_coff_swap_scnhdr_out (abfd, &text_scnhdr, &scnhdr_ext[SCNHSZ * 0]);
2474   bfd_coff_swap_scnhdr_out (abfd, &data_scnhdr, &scnhdr_ext[SCNHSZ * 1]);
2475   bfd_coff_swap_scnhdr_out (abfd, &bss_scnhdr, &scnhdr_ext[SCNHSZ * 2]);
2476   bfd_bwrite (scnhdr_ext, 3 * SCNHSZ, abfd);
2477   bfd_bwrite (data_buffer, data_buffer_size, abfd);
2478   bfd_bwrite (reloc_ext, data_scnhdr.s_nreloc * RELSZ, abfd);
2479   bfd_bwrite (syment_ext, filehdr.f_nsyms * SYMESZ, abfd);
2480   bfd_bwrite (string_table, string_table_size, abfd);
2481
2482   free (data_buffer);
2483   data_buffer = NULL;
2484
2485   return TRUE;
2486 }
2487
2488 /* The typical dynamic reloc.  */
2489
2490 static reloc_howto_type xcoff64_dynamic_reloc =
2491 HOWTO (0,                       /* type */
2492        0,                       /* rightshift */
2493        4,                       /* size (0 = byte, 1 = short, 2 = long) */
2494        64,                      /* bitsize */
2495        FALSE,                   /* pc_relative */
2496        0,                       /* bitpos */
2497        complain_overflow_bitfield, /* complain_on_overflow */
2498        0,                       /* special_function */
2499        "R_POS",                 /* name */
2500        TRUE,                    /* partial_inplace */
2501        MINUS_ONE,               /* src_mask */
2502        MINUS_ONE,               /* dst_mask */
2503        FALSE);                  /* pcrel_offset */
2504
2505 static unsigned long xcoff64_glink_code[10] =
2506 {
2507   0xe9820000,   /* ld r12,0(r2) */
2508   0xf8410028,   /* std r2,40(r1) */
2509   0xe80c0000,   /* ld r0,0(r12) */
2510   0xe84c0008,   /* ld r0,8(r12) */
2511   0x7c0903a6,   /* mtctr r0 */
2512   0x4e800420,   /* bctr */
2513   0x00000000,   /* start of traceback table */
2514   0x000ca000,   /* traceback table */
2515   0x00000000,   /* traceback table */
2516   0x00000018,   /* ??? */
2517 };
2518
2519 static const struct xcoff_backend_data_rec bfd_xcoff_backend_data =
2520   {
2521     { /* COFF backend, defined in libcoff.h.  */
2522       _bfd_xcoff64_swap_aux_in,
2523       _bfd_xcoff64_swap_sym_in,
2524       _bfd_xcoff64_swap_lineno_in,
2525       _bfd_xcoff64_swap_aux_out,
2526       _bfd_xcoff64_swap_sym_out,
2527       _bfd_xcoff64_swap_lineno_out,
2528       xcoff64_swap_reloc_out,
2529       coff_swap_filehdr_out,
2530       coff_swap_aouthdr_out,
2531       coff_swap_scnhdr_out,
2532       FILHSZ,
2533       AOUTSZ,
2534       SCNHSZ,
2535       SYMESZ,
2536       AUXESZ,
2537       RELSZ,
2538       LINESZ,
2539       FILNMLEN,
2540       TRUE,                     /* _bfd_coff_long_filenames */
2541       FALSE,                    /* _bfd_coff_long_section_names */
2542       3,                        /* _bfd_coff_default_section_alignment_power */
2543       TRUE,                     /* _bfd_coff_force_symnames_in_strings */
2544       4,                        /* _bfd_coff_debug_string_prefix_length */
2545       coff_swap_filehdr_in,
2546       coff_swap_aouthdr_in,
2547       coff_swap_scnhdr_in,
2548       xcoff64_swap_reloc_in,
2549       xcoff64_bad_format_hook,
2550       coff_set_arch_mach_hook,
2551       coff_mkobject_hook,
2552       styp_to_sec_flags,
2553       coff_set_alignment_hook,
2554       coff_slurp_symbol_table,
2555       symname_in_debug_hook,
2556       coff_pointerize_aux_hook,
2557       coff_print_aux,
2558       dummy_reloc16_extra_cases,
2559       dummy_reloc16_estimate,
2560       NULL,                     /* bfd_coff_sym_is_global */
2561       coff_compute_section_file_positions,
2562       NULL,                     /* _bfd_coff_start_final_link */
2563       xcoff64_ppc_relocate_section,
2564       coff_rtype_to_howto,
2565       NULL,                     /* _bfd_coff_adjust_symndx */
2566       _bfd_generic_link_add_one_symbol,
2567       coff_link_output_has_begun,
2568       coff_final_link_postscript
2569     },
2570
2571     0x01EF,                     /* magic number */
2572     bfd_arch_powerpc,
2573     bfd_mach_ppc_620,
2574
2575     /* Function pointers to xcoff specific swap routines.  */
2576     xcoff64_swap_ldhdr_in,
2577     xcoff64_swap_ldhdr_out,
2578     xcoff64_swap_ldsym_in,
2579     xcoff64_swap_ldsym_out,
2580     xcoff64_swap_ldrel_in,
2581     xcoff64_swap_ldrel_out,
2582
2583     /* Sizes.  */
2584     LDHDRSZ,
2585     LDSYMSZ,
2586     LDRELSZ,
2587     24,                         /* _xcoff_function_descriptor_size */
2588     0,                          /* _xcoff_small_aout_header_size */
2589
2590     /* Versions.  */
2591     2,                          /* _xcoff_ldhdr_version */
2592
2593     _bfd_xcoff64_put_symbol_name,
2594     _bfd_xcoff64_put_ldsymbol_name,
2595     &xcoff64_dynamic_reloc,
2596     xcoff64_create_csect_from_smclas,
2597
2598     /* Lineno and reloc count overflow.  */
2599     xcoff64_is_lineno_count_overflow,
2600     xcoff64_is_reloc_count_overflow,
2601
2602     xcoff64_loader_symbol_offset,
2603     xcoff64_loader_reloc_offset,
2604
2605     /* glink.  */
2606     &xcoff64_glink_code[0],
2607     40,                         /* _xcoff_glink_size */
2608
2609     /* rtinit.  */
2610     88,                         /* _xcoff_rtinit_size */
2611     xcoff64_generate_rtinit,
2612   };
2613
2614 /* The transfer vector that leads the outside world to all of the above.  */
2615 const bfd_target rs6000coff64_vec =
2616   {
2617     "aixcoff64-rs6000",
2618     bfd_target_xcoff_flavour,
2619     BFD_ENDIAN_BIG,             /* data byte order is big */
2620     BFD_ENDIAN_BIG,             /* header byte order is big */
2621
2622     (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | DYNAMIC
2623      | HAS_SYMS | HAS_LOCALS | WP_TEXT),
2624
2625     SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA,
2626     0,                          /* leading char */
2627     '/',                        /* ar_pad_char */
2628     15,                         /* ar_max_namelen */
2629
2630     /* data */
2631     bfd_getb64,
2632     bfd_getb_signed_64,
2633     bfd_putb64,
2634     bfd_getb32,
2635     bfd_getb_signed_32,
2636     bfd_putb32,
2637     bfd_getb16,
2638     bfd_getb_signed_16,
2639     bfd_putb16,
2640
2641     /* hdrs */
2642     bfd_getb64,
2643     bfd_getb_signed_64,
2644     bfd_putb64,
2645     bfd_getb32,
2646     bfd_getb_signed_32,
2647     bfd_putb32,
2648     bfd_getb16,
2649     bfd_getb_signed_16,
2650     bfd_putb16,
2651
2652     { /* bfd_check_format */
2653       _bfd_dummy_target,
2654       coff_object_p,
2655       xcoff64_archive_p,
2656       CORE_FILE_P
2657     },
2658
2659     { /* bfd_set_format */
2660       bfd_false,
2661       coff_mkobject,
2662       _bfd_generic_mkarchive,
2663       bfd_false
2664     },
2665
2666     {/* bfd_write_contents */
2667       bfd_false,
2668       xcoff64_write_object_contents,
2669       _bfd_xcoff_write_archive_contents,
2670       bfd_false
2671     },
2672
2673     /* Generic */
2674     bfd_true,
2675     bfd_true,
2676     coff_new_section_hook,
2677     _bfd_generic_get_section_contents,
2678     _bfd_generic_get_section_contents_in_window,
2679
2680     /* Copy */
2681     _bfd_xcoff_copy_private_bfd_data,
2682     ((bfd_boolean (*) (bfd *, bfd *)) bfd_true),
2683     ((bfd_boolean (*) (bfd *, asection *, bfd *, asection *)) bfd_true),
2684     ((bfd_boolean (*) (bfd *, asymbol *, bfd *, asymbol *)) bfd_true),
2685     ((bfd_boolean (*) (bfd *, bfd *)) bfd_true),
2686     ((bfd_boolean (*) (bfd *, flagword)) bfd_true),
2687     ((bfd_boolean (*) (bfd *, void * )) bfd_true),
2688
2689     /* Core */
2690     coff_core_file_failing_command,
2691     coff_core_file_failing_signal,
2692     coff_core_file_matches_executable_p,
2693
2694     /* Archive */
2695     xcoff64_slurp_armap,
2696     bfd_false,
2697     ((bfd_boolean (*) (bfd *, char **, bfd_size_type *, const char **)) bfd_false),
2698     bfd_dont_truncate_arname,
2699     _bfd_xcoff_write_armap,
2700     _bfd_xcoff_read_ar_hdr,
2701     xcoff64_openr_next_archived_file,
2702     _bfd_generic_get_elt_at_index,
2703     _bfd_xcoff_stat_arch_elt,
2704     bfd_true,
2705
2706     /* Symbols */
2707     coff_get_symtab_upper_bound,
2708     coff_canonicalize_symtab,
2709     coff_make_empty_symbol,
2710     coff_print_symbol,
2711     coff_get_symbol_info,
2712     _bfd_xcoff_is_local_label_name,
2713     coff_get_lineno,
2714     coff_find_nearest_line,
2715     coff_bfd_make_debug_symbol,
2716     _bfd_generic_read_minisymbols,
2717     _bfd_generic_minisymbol_to_symbol,
2718
2719     /* Reloc */
2720     coff_get_reloc_upper_bound,
2721     coff_canonicalize_reloc,
2722     xcoff64_reloc_type_lookup,
2723
2724     /* Write */
2725     coff_set_arch_mach,
2726     coff_set_section_contents,
2727
2728     /* Link */
2729     xcoff64_sizeof_headers,
2730     bfd_generic_get_relocated_section_contents,
2731     bfd_generic_relax_section,
2732     _bfd_xcoff_bfd_link_hash_table_create,
2733     _bfd_generic_link_hash_table_free,
2734     _bfd_xcoff_bfd_link_add_symbols,
2735     _bfd_generic_link_just_syms,
2736     _bfd_xcoff_bfd_final_link,
2737     _bfd_generic_link_split_section,
2738     bfd_generic_gc_sections,
2739     bfd_generic_merge_sections,
2740     bfd_generic_is_group_section,
2741     bfd_generic_discard_group,
2742
2743     /* Dynamic */
2744     _bfd_xcoff_get_dynamic_symtab_upper_bound,
2745     _bfd_xcoff_canonicalize_dynamic_symtab,
2746     _bfd_nodynamic_get_synthetic_symtab,
2747     _bfd_xcoff_get_dynamic_reloc_upper_bound,
2748     _bfd_xcoff_canonicalize_dynamic_reloc,
2749
2750     /* Opposite endian version, none exists */
2751     NULL,
2752
2753     (void *) &bfd_xcoff_backend_data,
2754   };
2755
2756 extern const bfd_target *xcoff64_core_p
2757   PARAMS ((bfd *));
2758 extern bfd_boolean xcoff64_core_file_matches_executable_p
2759   PARAMS ((bfd *, bfd *));
2760 extern char *xcoff64_core_file_failing_command
2761   PARAMS ((bfd *));
2762 extern int xcoff64_core_file_failing_signal
2763   PARAMS ((bfd *));
2764
2765 /* AIX 5 */
2766 static const struct xcoff_backend_data_rec bfd_xcoff_aix5_backend_data =
2767   {
2768     { /* COFF backend, defined in libcoff.h.  */
2769       _bfd_xcoff64_swap_aux_in,
2770       _bfd_xcoff64_swap_sym_in,
2771       _bfd_xcoff64_swap_lineno_in,
2772       _bfd_xcoff64_swap_aux_out,
2773       _bfd_xcoff64_swap_sym_out,
2774       _bfd_xcoff64_swap_lineno_out,
2775       xcoff64_swap_reloc_out,
2776       coff_swap_filehdr_out,
2777       coff_swap_aouthdr_out,
2778       coff_swap_scnhdr_out,
2779       FILHSZ,
2780       AOUTSZ,
2781       SCNHSZ,
2782       SYMESZ,
2783       AUXESZ,
2784       RELSZ,
2785       LINESZ,
2786       FILNMLEN,
2787       TRUE,                     /* _bfd_coff_long_filenames */
2788       FALSE,                    /* _bfd_coff_long_section_names */
2789       3,                        /* _bfd_coff_default_section_alignment_power */
2790       TRUE,                     /* _bfd_coff_force_symnames_in_strings */
2791       4,                        /* _bfd_coff_debug_string_prefix_length */
2792       coff_swap_filehdr_in,
2793       coff_swap_aouthdr_in,
2794       coff_swap_scnhdr_in,
2795       xcoff64_swap_reloc_in,
2796       xcoff64_bad_format_hook,
2797       coff_set_arch_mach_hook,
2798       coff_mkobject_hook,
2799       styp_to_sec_flags,
2800       coff_set_alignment_hook,
2801       coff_slurp_symbol_table,
2802       symname_in_debug_hook,
2803       coff_pointerize_aux_hook,
2804       coff_print_aux,
2805       dummy_reloc16_extra_cases,
2806       dummy_reloc16_estimate,
2807       NULL,                     /* bfd_coff_sym_is_global */
2808       coff_compute_section_file_positions,
2809       NULL,                     /* _bfd_coff_start_final_link */
2810       xcoff64_ppc_relocate_section,
2811       coff_rtype_to_howto,
2812       NULL,                     /* _bfd_coff_adjust_symndx */
2813       _bfd_generic_link_add_one_symbol,
2814       coff_link_output_has_begun,
2815       coff_final_link_postscript
2816     },
2817
2818     U64_TOCMAGIC,               /* magic number */
2819     bfd_arch_powerpc,
2820     bfd_mach_ppc_620,
2821
2822     /* Function pointers to xcoff specific swap routines.  */
2823     xcoff64_swap_ldhdr_in,
2824     xcoff64_swap_ldhdr_out,
2825     xcoff64_swap_ldsym_in,
2826     xcoff64_swap_ldsym_out,
2827     xcoff64_swap_ldrel_in,
2828     xcoff64_swap_ldrel_out,
2829
2830     /* Sizes.  */
2831     LDHDRSZ,
2832     LDSYMSZ,
2833     LDRELSZ,
2834     24,                         /* _xcoff_function_descriptor_size */
2835     0,                          /* _xcoff_small_aout_header_size */
2836     /* Versions.  */
2837     2,                          /* _xcoff_ldhdr_version */
2838
2839     _bfd_xcoff64_put_symbol_name,
2840     _bfd_xcoff64_put_ldsymbol_name,
2841     &xcoff64_dynamic_reloc,
2842     xcoff64_create_csect_from_smclas,
2843
2844     /* Lineno and reloc count overflow.  */
2845     xcoff64_is_lineno_count_overflow,
2846     xcoff64_is_reloc_count_overflow,
2847
2848     xcoff64_loader_symbol_offset,
2849     xcoff64_loader_reloc_offset,
2850
2851     /* glink.  */
2852     &xcoff64_glink_code[0],
2853     40,                         /* _xcoff_glink_size */
2854
2855     /* rtinit.  */
2856     88,                         /* _xcoff_rtinit_size */
2857     xcoff64_generate_rtinit,
2858   };
2859
2860 /* The transfer vector that leads the outside world to all of the above.  */
2861 const bfd_target aix5coff64_vec =
2862   {
2863     "aix5coff64-rs6000",
2864     bfd_target_xcoff_flavour,
2865     BFD_ENDIAN_BIG,             /* data byte order is big */
2866     BFD_ENDIAN_BIG,             /* header byte order is big */
2867
2868     (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | DYNAMIC
2869      | HAS_SYMS | HAS_LOCALS | WP_TEXT),
2870
2871     SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA,
2872     0,                          /* leading char */
2873     '/',                        /* ar_pad_char */
2874     15,                         /* ar_max_namelen */
2875
2876     /* data */
2877     bfd_getb64,
2878     bfd_getb_signed_64,
2879     bfd_putb64,
2880     bfd_getb32,
2881     bfd_getb_signed_32,
2882     bfd_putb32,
2883     bfd_getb16,
2884     bfd_getb_signed_16,
2885     bfd_putb16,
2886
2887     /* hdrs */
2888     bfd_getb64,
2889     bfd_getb_signed_64,
2890     bfd_putb64,
2891     bfd_getb32,
2892     bfd_getb_signed_32,
2893     bfd_putb32,
2894     bfd_getb16,
2895     bfd_getb_signed_16,
2896     bfd_putb16,
2897
2898     { /* bfd_check_format */
2899       _bfd_dummy_target,
2900       coff_object_p,
2901       xcoff64_archive_p,
2902       xcoff64_core_p
2903     },
2904
2905     { /* bfd_set_format */
2906       bfd_false,
2907       coff_mkobject,
2908       _bfd_generic_mkarchive,
2909       bfd_false
2910     },
2911
2912     {/* bfd_write_contents */
2913       bfd_false,
2914       xcoff64_write_object_contents,
2915       _bfd_xcoff_write_archive_contents,
2916       bfd_false
2917     },
2918
2919     /* Generic */
2920     bfd_true,
2921     bfd_true,
2922     coff_new_section_hook,
2923     _bfd_generic_get_section_contents,
2924     _bfd_generic_get_section_contents_in_window,
2925
2926     /* Copy */
2927     _bfd_xcoff_copy_private_bfd_data,
2928     ((bfd_boolean (*) (bfd *, bfd *)) bfd_true),
2929     ((bfd_boolean (*) (bfd *, asection *, bfd *, asection *)) bfd_true),
2930     ((bfd_boolean (*) (bfd *, asymbol *, bfd *, asymbol *)) bfd_true),
2931     ((bfd_boolean (*) (bfd *, bfd *)) bfd_true),
2932     ((bfd_boolean (*) (bfd *, flagword)) bfd_true),
2933     ((bfd_boolean (*) (bfd *, void * )) bfd_true),
2934
2935     /* Core */
2936     xcoff64_core_file_failing_command,
2937     xcoff64_core_file_failing_signal,
2938     xcoff64_core_file_matches_executable_p,
2939
2940     /* Archive */
2941     xcoff64_slurp_armap,
2942     bfd_false,
2943     ((bfd_boolean (*) (bfd *, char **, bfd_size_type *, const char **)) bfd_false),
2944     bfd_dont_truncate_arname,
2945     _bfd_xcoff_write_armap,
2946     _bfd_xcoff_read_ar_hdr,
2947     xcoff64_openr_next_archived_file,
2948     _bfd_generic_get_elt_at_index,
2949     _bfd_xcoff_stat_arch_elt,
2950     bfd_true,
2951
2952     /* Symbols */
2953     coff_get_symtab_upper_bound,
2954     coff_canonicalize_symtab,
2955     coff_make_empty_symbol,
2956     coff_print_symbol,
2957     coff_get_symbol_info,
2958     _bfd_xcoff_is_local_label_name,
2959     coff_get_lineno,
2960     coff_find_nearest_line,
2961     coff_bfd_make_debug_symbol,
2962     _bfd_generic_read_minisymbols,
2963     _bfd_generic_minisymbol_to_symbol,
2964
2965     /* Reloc */
2966     coff_get_reloc_upper_bound,
2967     coff_canonicalize_reloc,
2968     xcoff64_reloc_type_lookup,
2969
2970     /* Write */
2971     coff_set_arch_mach,
2972     coff_set_section_contents,
2973
2974     /* Link */
2975     xcoff64_sizeof_headers,
2976     bfd_generic_get_relocated_section_contents,
2977     bfd_generic_relax_section,
2978     _bfd_xcoff_bfd_link_hash_table_create,
2979     _bfd_generic_link_hash_table_free,
2980     _bfd_xcoff_bfd_link_add_symbols,
2981     _bfd_generic_link_just_syms,
2982     _bfd_xcoff_bfd_final_link,
2983     _bfd_generic_link_split_section,
2984     bfd_generic_gc_sections,
2985     bfd_generic_merge_sections,
2986     bfd_generic_is_group_section,
2987     bfd_generic_discard_group,
2988
2989     /* Dynamic */
2990     _bfd_xcoff_get_dynamic_symtab_upper_bound,
2991     _bfd_xcoff_canonicalize_dynamic_symtab,
2992     _bfd_nodynamic_get_synthetic_symtab,
2993     _bfd_xcoff_get_dynamic_reloc_upper_bound,
2994     _bfd_xcoff_canonicalize_dynamic_reloc,
2995
2996     /* Opposite endian version, none exists.  */
2997     NULL,
2998
2999     (void *) & bfd_xcoff_aix5_backend_data,
3000   };