bfd/coff64-rs6000.c

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