bfd/coff64-rs6000.c

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