bfd/coff64-rs6000.c

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