bfd/coff64-rs6000.c

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