bfd/coff64-rs6000.c

   1 /* BFD back-end for IBM RS/6000 "XCOFF64" files.
   2    Copyright 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
   3    2010
   4    Free Software Foundation, Inc.
   5    Written Clinton Popetz.
   6    Contributed by Cygnus Support.
   7
   8    This file is part of BFD, the Binary File Descriptor library.
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 3 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program; if not, write to the Free Software
  22    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  23    MA 02110-1301, USA.  */
  24
  25 #include "sysdep.h"
  26 #include "bfd.h"
  27 #include "bfdlink.h"
  28 #include "libbfd.h"
  29 #include "coff/internal.h"
  30 #include "coff/xcoff.h"
  31 #include "coff/rs6k64.h"
  32 #include "libcoff.h"
  33 #include "libxcoff.h"
  34
  35 #define GET_FILEHDR_SYMPTR H_GET_64
  36 #define PUT_FILEHDR_SYMPTR H_PUT_64
  37 #define GET_AOUTHDR_DATA_START H_GET_64
  38 #define PUT_AOUTHDR_DATA_START H_PUT_64
  39 #define GET_AOUTHDR_TEXT_START H_GET_64
  40 #define PUT_AOUTHDR_TEXT_START H_PUT_64
  41 #define GET_AOUTHDR_TSIZE H_GET_64
  42 #define PUT_AOUTHDR_TSIZE H_PUT_64
  43 #define GET_AOUTHDR_DSIZE H_GET_64
  44 #define PUT_AOUTHDR_DSIZE H_PUT_64
  45 #define GET_AOUTHDR_BSIZE H_GET_64
  46 #define PUT_AOUTHDR_BSIZE H_PUT_64
  47 #define GET_AOUTHDR_ENTRY H_GET_64
  48 #define PUT_AOUTHDR_ENTRY H_PUT_64
  49 #define GET_SCNHDR_PADDR H_GET_64
  50 #define PUT_SCNHDR_PADDR H_PUT_64
  51 #define GET_SCNHDR_VADDR H_GET_64
  52 #define PUT_SCNHDR_VADDR H_PUT_64
  53 #define GET_SCNHDR_SIZE H_GET_64
  54 #define PUT_SCNHDR_SIZE H_PUT_64
  55 #define GET_SCNHDR_SCNPTR H_GET_64
  56 #define PUT_SCNHDR_SCNPTR H_PUT_64
  57 #define GET_SCNHDR_RELPTR H_GET_64
  58 #define PUT_SCNHDR_RELPTR H_PUT_64
  59 #define GET_SCNHDR_LNNOPTR H_GET_64
  60 #define PUT_SCNHDR_LNNOPTR H_PUT_64
  61 #define GET_SCNHDR_NRELOC H_GET_32
  62 #define MAX_SCNHDR_NRELOC 0xffffffff
  63 #define PUT_SCNHDR_NRELOC H_PUT_32
  64 #define GET_SCNHDR_NLNNO H_GET_32
  65 #define MAX_SCNHDR_NLNNO 0xffffffff
  66 #define PUT_SCNHDR_NLNNO H_PUT_32
  67 #define GET_RELOC_VADDR H_GET_64
  68 #define PUT_RELOC_VADDR H_PUT_64
  69
  70 #define COFF_FORCE_SYMBOLS_IN_STRINGS
  71 #define COFF_DEBUG_STRING_WIDE_PREFIX
  72
  73
  74 #define COFF_ADJUST_SCNHDR_OUT_POST(ABFD, INT, EXT)                     \
  75   do                                                                    \
  76     {                                                                   \
  77       memset (((SCNHDR *) EXT)->s_pad, 0,                               \
  78               sizeof (((SCNHDR *) EXT)->s_pad));                        \
  79     }                                                                   \
  80   while (0)
  81
  82 #define NO_COFF_LINENOS
  83
  84 #define coff_SWAP_lineno_in _bfd_xcoff64_swap_lineno_in
  85 #define coff_SWAP_lineno_out _bfd_xcoff64_swap_lineno_out
  86
  87 static void _bfd_xcoff64_swap_lineno_in
  88   (bfd *, void *, void *);
  89 static unsigned int _bfd_xcoff64_swap_lineno_out
  90   (bfd *, void *, void *);
  91 static bfd_boolean _bfd_xcoff64_put_symbol_name
  92   (bfd *, struct bfd_strtab_hash *, struct internal_syment *, const char *);
  93 static bfd_boolean _bfd_xcoff64_put_ldsymbol_name
  94   (bfd *, struct xcoff_loader_info *, struct internal_ldsym *, const char *);
  95 static void _bfd_xcoff64_swap_sym_in
  96   (bfd *, void *, void *);
  97 static unsigned int _bfd_xcoff64_swap_sym_out
  98   (bfd *, void *, void *);
  99 static void _bfd_xcoff64_swap_aux_in
 100   (bfd *, void *, int, int, int, int, void *);
 101 static unsigned int _bfd_xcoff64_swap_aux_out
 102   (bfd *, void *, int, int, int, int, void *);
 103 static void xcoff64_swap_reloc_in
 104   (bfd *, void *, void *);
 105 static unsigned int xcoff64_swap_reloc_out
 106   (bfd *, void *, void *);
 107 extern bfd_boolean _bfd_xcoff_mkobject
 108   (bfd *);
 109 extern bfd_boolean _bfd_xcoff_copy_private_bfd_data
 110   (bfd *, bfd *);
 111 extern bfd_boolean _bfd_xcoff_is_local_label_name
 112   (bfd *, const char *);
 113 extern void xcoff64_rtype2howto
 114   (arelent *, struct internal_reloc *);
 115 extern reloc_howto_type * xcoff64_reloc_type_lookup
 116   (bfd *, bfd_reloc_code_real_type);
 117 extern bfd_boolean _bfd_xcoff_slurp_armap
 118   (bfd *);
 119 extern void *_bfd_xcoff_read_ar_hdr
 120   (bfd *);
 121 extern bfd *_bfd_xcoff_openr_next_archived_file
 122   (bfd *, bfd *);
 123 extern int _bfd_xcoff_stat_arch_elt
 124   (bfd *, struct stat *);
 125 extern bfd_boolean _bfd_xcoff_write_armap
 126   (bfd *, unsigned int, struct orl *, unsigned int, int);
 127 extern bfd_boolean _bfd_xcoff_write_archive_contents
 128   (bfd *);
 129 extern int _bfd_xcoff_sizeof_headers
 130   (bfd *, struct bfd_link_info *);
 131 extern void _bfd_xcoff_swap_sym_in
 132   (bfd *, void *, void *);
 133 extern unsigned int _bfd_xcoff_swap_sym_out
 134   (bfd *, void *, void *);
 135 extern void _bfd_xcoff_swap_aux_in
 136   (bfd *, void *, int, int, int, int, void *);
 137 extern unsigned int _bfd_xcoff_swap_aux_out
 138   (bfd *, void *, int, int, int, int, void *);
 139 static void xcoff64_swap_ldhdr_in
 140   (bfd *, const void *, struct internal_ldhdr *);
 141 static void xcoff64_swap_ldhdr_out
 142   (bfd *, const struct internal_ldhdr *, void *d);
 143 static void xcoff64_swap_ldsym_in
 144   (bfd *, const void *, struct internal_ldsym *);
 145 static void xcoff64_swap_ldsym_out
 146   (bfd *, const struct internal_ldsym *, void *d);
 147 static void xcoff64_swap_ldrel_in
 148   (bfd *, const void *, struct internal_ldrel *);
 149 static void xcoff64_swap_ldrel_out
 150   (bfd *, const struct internal_ldrel *, void *d);
 151 static bfd_boolean xcoff64_write_object_contents
 152   (bfd *);
 153 static bfd_boolean xcoff64_ppc_relocate_section
 154   (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
 155    struct internal_reloc *, struct internal_syment *,
 156    asection **);
 157 static bfd_boolean xcoff64_slurp_armap
 158   (bfd *);
 159 static const bfd_target *xcoff64_archive_p
 160   (bfd *);
 161 static bfd *xcoff64_openr_next_archived_file
 162   (bfd *, bfd *);
 163 static int xcoff64_sizeof_headers
 164   (bfd *, struct bfd_link_info *);
 165 static asection *xcoff64_create_csect_from_smclas
 166   (bfd *, union internal_auxent *, const char *);
 167 static bfd_boolean xcoff64_is_lineno_count_overflow
 168   (bfd *, bfd_vma);
 169 static bfd_boolean xcoff64_is_reloc_count_overflow
 170   (bfd *, bfd_vma);
 171 static bfd_vma xcoff64_loader_symbol_offset
 172   (bfd *, struct internal_ldhdr *);
 173 static bfd_vma xcoff64_loader_reloc_offset
 174   (bfd *, struct internal_ldhdr *);
 175 static bfd_boolean xcoff64_generate_rtinit
 176   (bfd *, const char *, const char *, bfd_boolean);
 177 static bfd_boolean xcoff64_bad_format_hook
 178   (bfd *, void *);
 179
 180 /* Relocation functions */
 181 static bfd_boolean xcoff64_reloc_type_br
 182   (XCOFF_RELOC_FUNCTION_ARGS);
 183
 184 bfd_boolean (*xcoff64_calculate_relocation[XCOFF_MAX_CALCULATE_RELOCATION])
 185   (XCOFF_RELOC_FUNCTION_ARGS) =
 186 {
 187   xcoff_reloc_type_pos,  /* R_POS   (0x00) */
 188   xcoff_reloc_type_neg,  /* R_NEG   (0x01) */
 189   xcoff_reloc_type_rel,  /* R_REL   (0x02) */
 190   xcoff_reloc_type_toc,  /* R_TOC   (0x03) */
 191   xcoff_reloc_type_fail, /* R_RTB   (0x04) */
 192   xcoff_reloc_type_toc,  /* R_GL    (0x05) */
 193   xcoff_reloc_type_toc,  /* R_TCL   (0x06) */
 194   xcoff_reloc_type_fail, /*         (0x07) */
 195   xcoff_reloc_type_ba,   /* R_BA    (0x08) */
 196   xcoff_reloc_type_fail, /*         (0x09) */
 197   xcoff64_reloc_type_br, /* R_BR    (0x0a) */
 198   xcoff_reloc_type_fail, /*         (0x0b) */
 199   xcoff_reloc_type_pos,  /* R_RL    (0x0c) */
 200   xcoff_reloc_type_pos,  /* R_RLA   (0x0d) */
 201   xcoff_reloc_type_fail, /*         (0x0e) */
 202   xcoff_reloc_type_noop, /* R_REF   (0x0f) */
 203   xcoff_reloc_type_fail, /*         (0x10) */
 204   xcoff_reloc_type_fail, /*         (0x11) */
 205   xcoff_reloc_type_toc,  /* R_TRL   (0x12) */
 206   xcoff_reloc_type_toc,  /* R_TRLA  (0x13) */
 207   xcoff_reloc_type_fail, /* R_RRTBI (0x14) */
 208   xcoff_reloc_type_fail, /* R_RRTBA (0x15) */
 209   xcoff_reloc_type_ba,   /* R_CAI   (0x16) */
 210   xcoff_reloc_type_crel, /* R_CREL  (0x17) */
 211   xcoff_reloc_type_ba,   /* R_RBA   (0x18) */
 212   xcoff_reloc_type_ba,   /* R_RBAC  (0x19) */
 213   xcoff64_reloc_type_br, /* R_RBR   (0x1a) */
 214   xcoff_reloc_type_ba,   /* R_RBRC  (0x1b) */
 215 };
 216
 217 /* coffcode.h needs these to be defined.  */
 218 /* Internalcoff.h and coffcode.h modify themselves based on these flags.  */
 219 #define XCOFF64
 220 #define RS6000COFF_C 1
 221
 222 #define SELECT_RELOC(internal, howto)                                   \
 223   {                                                                     \
 224     internal.r_type = howto->type;                                      \
 225     internal.r_size =                                                   \
 226       ((howto->complain_on_overflow == complain_overflow_signed         \
 227         ? 0x80                                                          \
 228         : 0)                                                            \
 229        | (howto->bitsize - 1));                                         \
 230   }
 231
 232 #define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (3)
 233 #define COFF_LONG_FILENAMES
 234 #define NO_COFF_SYMBOLS
 235 #define RTYPE2HOWTO(cache_ptr, dst) xcoff64_rtype2howto (cache_ptr, dst)
 236 #define coff_mkobject _bfd_xcoff_mkobject
 237 #define coff_bfd_copy_private_bfd_data _bfd_xcoff_copy_private_bfd_data
 238 #define coff_bfd_is_local_label_name _bfd_xcoff_is_local_label_name
 239 #define coff_bfd_reloc_type_lookup xcoff64_reloc_type_lookup
 240 #define coff_bfd_reloc_name_lookup xcoff64_reloc_name_lookup
 241 #ifdef AIX_CORE
 242 extern const bfd_target * rs6000coff_core_p
 243   (bfd *abfd);
 244 extern bfd_boolean rs6000coff_core_file_matches_executable_p
 245   (bfd *cbfd, bfd *ebfd);
 246 extern char *rs6000coff_core_file_failing_command
 247   (bfd *abfd);
 248 extern int rs6000coff_core_file_failing_signal
 249   (bfd *abfd);
 250 #define CORE_FILE_P rs6000coff_core_p
 251 #define coff_core_file_failing_command \
 252   rs6000coff_core_file_failing_command
 253 #define coff_core_file_failing_signal \
 254   rs6000coff_core_file_failing_signal
 255 #define coff_core_file_matches_executable_p \
 256   rs6000coff_core_file_matches_executable_p
 257 #define coff_core_file_pid \
 258   _bfd_nocore_core_file_pid
 259 #else
 260 #define CORE_FILE_P _bfd_dummy_target
 261 #define coff_core_file_failing_command \
 262   _bfd_nocore_core_file_failing_command
 263 #define coff_core_file_failing_signal \
 264   _bfd_nocore_core_file_failing_signal
 265 #define coff_core_file_matches_executable_p \
 266   _bfd_nocore_core_file_matches_executable_p
 267 #define coff_core_file_pid \
 268   _bfd_nocore_core_file_pid
 269 #endif
 270 #define coff_SWAP_sym_in _bfd_xcoff64_swap_sym_in
 271 #define coff_SWAP_sym_out _bfd_xcoff64_swap_sym_out
 272 #define coff_SWAP_aux_in _bfd_xcoff64_swap_aux_in
 273 #define coff_SWAP_aux_out _bfd_xcoff64_swap_aux_out
 274 #define coff_swap_reloc_in xcoff64_swap_reloc_in
 275 #define coff_swap_reloc_out xcoff64_swap_reloc_out
 276 #define NO_COFF_RELOCS
 277
 278 #ifndef bfd_pe_print_pdata
 279 #define bfd_pe_print_pdata      NULL
 280 #endif
 281
 282 #include "coffcode.h"
 283
 284 /* For XCOFF64, the effective width of symndx changes depending on
 285    whether we are the first entry.  Sigh.  */
 286 static void
 287 _bfd_xcoff64_swap_lineno_in (bfd *abfd, void *ext1, void *in1)
 288 {
 289   LINENO *ext = (LINENO *) ext1;
 290   struct internal_lineno *in = (struct internal_lineno *) in1;
 291
 292   in->l_lnno = H_GET_32 (abfd, (ext->l_lnno));
 293   if (in->l_lnno == 0)
 294     in->l_addr.l_symndx = H_GET_32 (abfd, ext->l_addr.l_symndx);
 295   else
 296     in->l_addr.l_paddr = H_GET_64 (abfd, ext->l_addr.l_paddr);
 297 }
 298
 299 static unsigned int
 300 _bfd_xcoff64_swap_lineno_out (bfd *abfd, void *inp, void *outp)
 301 {
 302   struct internal_lineno *in = (struct internal_lineno *) inp;
 303   struct external_lineno *ext = (struct external_lineno *) outp;
 304
 305   H_PUT_32 (abfd, in->l_addr.l_symndx, ext->l_addr.l_symndx);
 306   H_PUT_32 (abfd, in->l_lnno, (ext->l_lnno));
 307
 308   if (in->l_lnno == 0)
 309     H_PUT_32 (abfd, in->l_addr.l_symndx, ext->l_addr.l_symndx);
 310   else
 311     H_PUT_64 (abfd, in->l_addr.l_paddr, ext->l_addr.l_paddr);
 312
 313   return bfd_coff_linesz (abfd);
 314 }
 315
 316 static void
 317 _bfd_xcoff64_swap_sym_in (bfd *abfd, void *ext1, void *in1)
 318 {
 319   struct external_syment *ext = (struct external_syment *) ext1;
 320   struct internal_syment *in = (struct internal_syment *) in1;
 321
 322   in->_n._n_n._n_zeroes = 0;
 323   in->_n._n_n._n_offset = H_GET_32 (abfd, ext->e_offset);
 324   in->n_value = H_GET_64 (abfd, ext->e_value);
 325   in->n_scnum = H_GET_16 (abfd, ext->e_scnum);
 326   in->n_type = H_GET_16 (abfd, ext->e_type);
 327   in->n_sclass = H_GET_8 (abfd, ext->e_sclass);
 328   in->n_numaux = H_GET_8 (abfd, ext->e_numaux);
 329 }
 330
 331 static unsigned int
 332 _bfd_xcoff64_swap_sym_out (bfd *abfd, void *inp, void *extp)
 333 {
 334   struct internal_syment *in = (struct internal_syment *) inp;
 335   struct external_syment *ext = (struct external_syment *) extp;
 336
 337   H_PUT_32 (abfd, in->_n._n_n._n_offset, ext->e_offset);
 338   H_PUT_64 (abfd, in->n_value, ext->e_value);
 339   H_PUT_16 (abfd, in->n_scnum, ext->e_scnum);
 340   H_PUT_16 (abfd, in->n_type, ext->e_type);
 341   H_PUT_8 (abfd, in->n_sclass, ext->e_sclass);
 342   H_PUT_8 (abfd, in->n_numaux, ext->e_numaux);
 343   return bfd_coff_symesz (abfd);
 344 }
 345
 346 static void
 347 _bfd_xcoff64_swap_aux_in (bfd *abfd, void *ext1, int type, int in_class,
 348                           int indx, int numaux, void *in1)
 349 {
 350   union external_auxent *ext = (union external_auxent *) ext1;
 351   union internal_auxent *in = (union internal_auxent *) in1;
 352
 353   switch (in_class)
 354     {
 355     case C_FILE:
 356       if (ext->x_file.x_n.x_zeroes[0] == 0)
 357         {
 358           in->x_file.x_n.x_zeroes = 0;
 359           in->x_file.x_n.x_offset = H_GET_32 (abfd, ext->x_file.x_n.x_offset);
 360         }
 361       else
 362         {
 363           memcpy (in->x_file.x_fname, ext->x_file.x_fname, FILNMLEN);
 364         }
 365       goto end;
 366
 367       /* RS/6000 "csect" auxents */
 368     case C_EXT:
 369     case C_AIX_WEAKEXT:
 370     case C_HIDEXT:
 371       if (indx + 1 == numaux)
 372         {
 373           bfd_signed_vma h = 0;
 374           bfd_vma l = 0;
 375
 376           h = H_GET_S32 (abfd, ext->x_csect.x_scnlen_hi);
 377           l = H_GET_32 (abfd, ext->x_csect.x_scnlen_lo);
 378
 379           in->x_csect.x_scnlen.l = h << 32 | (l & 0xffffffff);
 380
 381           in->x_csect.x_parmhash = H_GET_32 (abfd, ext->x_csect.x_parmhash);
 382           in->x_csect.x_snhash = H_GET_16 (abfd, ext->x_csect.x_snhash);
 383           /* We don't have to hack bitfields in x_smtyp because it's
 384              defined by shifts-and-ands, which are equivalent on all
 385              byte orders.  */
 386           in->x_csect.x_smtyp = H_GET_8 (abfd, ext->x_csect.x_smtyp);
 387           in->x_csect.x_smclas = H_GET_8 (abfd, ext->x_csect.x_smclas);
 388           goto end;
 389         }
 390       break;
 391
 392     case C_STAT:
 393     case C_LEAFSTAT:
 394     case C_HIDDEN:
 395       if (type == T_NULL)
 396         {
 397           /* PE defines some extra fields; we zero them out for
 398              safety.  */
 399           in->x_scn.x_checksum = 0;
 400           in->x_scn.x_associated = 0;
 401           in->x_scn.x_comdat = 0;
 402
 403           goto end;
 404         }
 405       break;
 406     }
 407
 408   if (in_class == C_BLOCK || in_class == C_FCN || ISFCN (type)
 409       || ISTAG (in_class))
 410     {
 411       in->x_sym.x_fcnary.x_fcn.x_lnnoptr
 412         = H_GET_64 (abfd, ext->x_sym.x_fcnary.x_fcn.x_lnnoptr);
 413       in->x_sym.x_fcnary.x_fcn.x_endndx.l
 414         = H_GET_32 (abfd, ext->x_sym.x_fcnary.x_fcn.x_endndx);
 415     }
 416   if (ISFCN (type))
 417     {
 418       in->x_sym.x_misc.x_fsize
 419         = H_GET_32 (abfd, ext->x_sym.x_fcnary.x_fcn.x_fsize);
 420     }
 421   else
 422     {
 423       in->x_sym.x_misc.x_lnsz.x_lnno
 424         = H_GET_32 (abfd, ext->x_sym.x_fcnary.x_lnsz.x_lnno);
 425       in->x_sym.x_misc.x_lnsz.x_size
 426         = H_GET_16 (abfd, ext->x_sym.x_fcnary.x_lnsz.x_size);
 427     }
 428
 429  end: ;
 430 }
 431
 432 static unsigned int
 433 _bfd_xcoff64_swap_aux_out (bfd *abfd, void *inp, int type, int in_class,
 434                            int indx ATTRIBUTE_UNUSED,
 435                            int numaux ATTRIBUTE_UNUSED,
 436                            void *extp)
 437 {
 438   union internal_auxent *in = (union internal_auxent *) inp;
 439   union external_auxent *ext = (union external_auxent *) extp;
 440
 441   memset (ext, 0, bfd_coff_auxesz (abfd));
 442   switch (in_class)
 443     {
 444     case C_FILE:
 445       if (in->x_file.x_n.x_zeroes == 0)
 446         {
 447           H_PUT_32 (abfd, 0, ext->x_file.x_n.x_zeroes);
 448           H_PUT_32 (abfd, in->x_file.x_n.x_offset, ext->x_file.x_n.x_offset);
 449         }
 450       else
 451         {
 452           memcpy (ext->x_file.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   /* 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   /* 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   /* 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   /* 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   /* 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   /* 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   /* 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   /* 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   /* 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   /* 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   /* 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   /* 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   /* 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   /* 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   /* 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   /* 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   /* 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   /* 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   /* 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   /* 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   /* 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   /* 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   HOWTO (R_POS,                 /* type */
1716          0,                     /* rightshift */
1717          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1718          32,                    /* bitsize */
1719          FALSE,                 /* pc_relative */
1720          0,                     /* bitpos */
1721          complain_overflow_bitfield, /* complain_on_overflow */
1722          0,                     /* special_function */
1723          "R_POS_32",            /* name */
1724          TRUE,                  /* partial_inplace */
1725          0xffffffff,            /* src_mask */
1726          0xffffffff,            /* dst_mask */
1727          FALSE),                /* pcrel_offset */
1728
1729   /* 16 bit Non modifiable absolute branch.  */
1730   HOWTO (R_BA,                  /* type */
1731          0,                     /* rightshift */
1732          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1733          16,                    /* bitsize */
1734          FALSE,                 /* pc_relative */
1735          0,                     /* bitpos */
1736          complain_overflow_bitfield, /* complain_on_overflow */
1737          0,                     /* special_function */
1738          "R_BA_16",             /* name */
1739          TRUE,                  /* partial_inplace */
1740          0xfffc,                /* src_mask */
1741          0xfffc,                /* dst_mask */
1742          FALSE),                /* pcrel_offset */
1743
1744   /* Modifiable branch relative.  */
1745   HOWTO (R_RBR,                 /* type */
1746          0,                     /* rightshift */
1747          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1748          16,                    /* bitsize */
1749          FALSE,                 /* pc_relative */
1750          0,                     /* bitpos */
1751          complain_overflow_signed, /* complain_on_overflow */
1752          0,                     /* special_function */
1753          "R_RBR_16",            /* name */
1754          TRUE,                  /* partial_inplace */
1755          0xffff,                /* src_mask */
1756          0xffff,                /* dst_mask */
1757          FALSE),                /* pcrel_offset */
1758
1759   /* Modifiable branch absolute.  */
1760   HOWTO (R_RBA,                 /* type */
1761          0,                     /* rightshift */
1762          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1763          16,                    /* bitsize */
1764          FALSE,                 /* pc_relative */
1765          0,                     /* bitpos */
1766          complain_overflow_bitfield, /* complain_on_overflow */
1767          0,                     /* special_function */
1768          "R_RBA_16",            /* name */
1769          TRUE,                  /* partial_inplace */
1770          0xffff,                /* src_mask */
1771          0xffff,                /* dst_mask */
1772          FALSE),                /* pcrel_offset */
1773
1774 };
1775
1776 void
1777 xcoff64_rtype2howto (arelent *relent, struct internal_reloc *internal)
1778 {
1779   if (internal->r_type > R_RBRC)
1780     abort ();
1781
1782   /* Default howto layout works most of the time */
1783   relent->howto = &xcoff64_howto_table[internal->r_type];
1784
1785   /* Special case some 16 bit reloc */
1786   if (15 == (internal->r_size & 0x3f))
1787     {
1788       if (R_BA == internal->r_type)
1789         relent->howto = &xcoff64_howto_table[0x1d];
1790       else if (R_RBR == internal->r_type)
1791         relent->howto = &xcoff64_howto_table[0x1e];
1792       else if (R_RBA == internal->r_type)
1793         relent->howto = &xcoff64_howto_table[0x1f];
1794     }
1795   /* Special case 32 bit */
1796   else if (31 == (internal->r_size & 0x3f))
1797     {
1798       if (R_POS == internal->r_type)
1799         relent->howto = &xcoff64_howto_table[0x1c];
1800     }
1801
1802   /* The r_size field of an XCOFF reloc encodes the bitsize of the
1803      relocation, as well as indicating whether it is signed or not.
1804      Doublecheck that the relocation information gathered from the
1805      type matches this information.  The bitsize is not significant
1806      for R_REF relocs.  */
1807   if (relent->howto->dst_mask != 0
1808       && (relent->howto->bitsize
1809           != ((unsigned int) internal->r_size & 0x3f) + 1))
1810     abort ();
1811 }
1812
1813 reloc_howto_type *
1814 xcoff64_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1815                            bfd_reloc_code_real_type code)
1816 {
1817   switch (code)
1818     {
1819     case BFD_RELOC_PPC_B26:
1820       return &xcoff64_howto_table[0xa];
1821     case BFD_RELOC_PPC_BA16:
1822       return &xcoff64_howto_table[0x1d];
1823     case BFD_RELOC_PPC_BA26:
1824       return &xcoff64_howto_table[8];
1825     case BFD_RELOC_PPC_TOC16:
1826       return &xcoff64_howto_table[3];
1827     case BFD_RELOC_32:
1828     case BFD_RELOC_CTOR:
1829       return &xcoff64_howto_table[0x1c];
1830     case BFD_RELOC_64:
1831       return &xcoff64_howto_table[0];
1832     case BFD_RELOC_NONE:
1833       return &xcoff64_howto_table[0xf];
1834     default:
1835       return NULL;
1836     }
1837 }
1838
1839 static reloc_howto_type *
1840 xcoff64_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1841                            const char *r_name)
1842 {
1843   unsigned int i;
1844
1845   for (i = 0;
1846        i < sizeof (xcoff64_howto_table) / sizeof (xcoff64_howto_table[0]);
1847        i++)
1848     if (xcoff64_howto_table[i].name != NULL
1849         && strcasecmp (xcoff64_howto_table[i].name, r_name) == 0)
1850       return &xcoff64_howto_table[i];
1851
1852   return NULL;
1853 }
1854
1855 /* Read in the armap of an XCOFF archive.  */
1856
1857 static bfd_boolean
1858 xcoff64_slurp_armap (bfd *abfd)
1859 {
1860   file_ptr off;
1861   size_t namlen;
1862   bfd_size_type sz, amt;
1863   bfd_byte *contents, *cend;
1864   bfd_vma c, i;
1865   carsym *arsym;
1866   bfd_byte *p;
1867   file_ptr pos;
1868
1869   /* This is for the new format.  */
1870   struct xcoff_ar_hdr_big hdr;
1871
1872   if (xcoff_ardata (abfd) == NULL)
1873     {
1874       bfd_has_map (abfd) = FALSE;
1875       return TRUE;
1876     }
1877
1878   off = bfd_scan_vma (xcoff_ardata_big (abfd)->symoff64,
1879                       (const char **) NULL, 10);
1880   if (off == 0)
1881     {
1882       bfd_has_map (abfd) = FALSE;
1883       return TRUE;
1884     }
1885
1886   if (bfd_seek (abfd, off, SEEK_SET) != 0)
1887     return FALSE;
1888
1889   /* The symbol table starts with a normal archive header.  */
1890   if (bfd_bread (&hdr, (bfd_size_type) SIZEOF_AR_HDR_BIG, abfd)
1891       != SIZEOF_AR_HDR_BIG)
1892     return FALSE;
1893
1894   /* Skip the name (normally empty).  */
1895   namlen = strtol (hdr.namlen, (char **) NULL, 10);
1896   pos = ((namlen + 1) & ~(size_t) 1) + SXCOFFARFMAG;
1897   if (bfd_seek (abfd, pos, SEEK_CUR) != 0)
1898     return FALSE;
1899
1900   sz = bfd_scan_vma (hdr.size, (const char **) NULL, 10);
1901
1902   /* Read in the entire symbol table.  */
1903   contents = (bfd_byte *) bfd_alloc (abfd, sz);
1904   if (contents == NULL)
1905     return FALSE;
1906   if (bfd_bread (contents, sz, abfd) != sz)
1907     return FALSE;
1908
1909   /* The symbol table starts with an eight byte count.  */
1910   c = H_GET_64 (abfd, contents);
1911
1912   if (c * 8 >= sz)
1913     {
1914       bfd_set_error (bfd_error_bad_value);
1915       return FALSE;
1916     }
1917   amt = c;
1918   amt *= sizeof (carsym);
1919   bfd_ardata (abfd)->symdefs = (carsym *) bfd_alloc (abfd, amt);
1920   if (bfd_ardata (abfd)->symdefs == NULL)
1921     return FALSE;
1922
1923   /* After the count comes a list of eight byte file offsets.  */
1924   for (i = 0, arsym = bfd_ardata (abfd)->symdefs, p = contents + 8;
1925        i < c;
1926        ++i, ++arsym, p += 8)
1927     arsym->file_offset = H_GET_64 (abfd, p);
1928
1929   /* After the file offsets come null terminated symbol names.  */
1930   cend = contents + sz;
1931   for (i = 0, arsym = bfd_ardata (abfd)->symdefs;
1932        i < c;
1933        ++i, ++arsym, p += strlen ((char *) p) + 1)
1934     {
1935       if (p >= cend)
1936         {
1937           bfd_set_error (bfd_error_bad_value);
1938           return FALSE;
1939         }
1940       arsym->name = (char *) p;
1941     }
1942
1943   bfd_ardata (abfd)->symdef_count = c;
1944   bfd_has_map (abfd) = TRUE;
1945
1946   return TRUE;
1947 }
1948
1949
1950 /* See if this is an NEW XCOFF archive.  */
1951
1952 static const bfd_target *
1953 xcoff64_archive_p (bfd *abfd)
1954 {
1955   struct artdata *tdata_hold;
1956   char magic[SXCOFFARMAG];
1957   /* This is the new format.  */
1958   struct xcoff_ar_file_hdr_big hdr;
1959   bfd_size_type amt = SXCOFFARMAG;
1960
1961   if (bfd_bread (magic, amt, abfd) != amt)
1962     {
1963       if (bfd_get_error () != bfd_error_system_call)
1964         bfd_set_error (bfd_error_wrong_format);
1965       return NULL;
1966     }
1967
1968   if (strncmp (magic, XCOFFARMAGBIG, SXCOFFARMAG) != 0)
1969     {
1970       bfd_set_error (bfd_error_wrong_format);
1971       return NULL;
1972     }
1973
1974   /* Copy over the magic string.  */
1975   memcpy (hdr.magic, magic, SXCOFFARMAG);
1976
1977   /* Now read the rest of the file header.  */
1978   amt = SIZEOF_AR_FILE_HDR_BIG - SXCOFFARMAG;
1979   if (bfd_bread (&hdr.memoff, amt, abfd) != amt)
1980     {
1981       if (bfd_get_error () != bfd_error_system_call)
1982         bfd_set_error (bfd_error_wrong_format);
1983       return NULL;
1984     }
1985
1986   tdata_hold = bfd_ardata (abfd);
1987
1988   amt = sizeof (struct artdata);
1989   bfd_ardata (abfd) = (struct artdata *) bfd_zalloc (abfd, amt);
1990   if (bfd_ardata (abfd) == (struct artdata *) NULL)
1991     goto error_ret_restore;
1992
1993   /* Already cleared by bfd_zalloc above.
1994      bfd_ardata (abfd)->cache = NULL;
1995      bfd_ardata (abfd)->archive_head = NULL;
1996      bfd_ardata (abfd)->symdefs = NULL;
1997      bfd_ardata (abfd)->extended_names = NULL;
1998      bfd_ardata (abfd)->extended_names_size = 0;  */
1999   bfd_ardata (abfd)->first_file_filepos = bfd_scan_vma (hdr.firstmemoff,
2000                                                         (const char **) NULL,
2001                                                         10);
2002
2003   amt = SIZEOF_AR_FILE_HDR_BIG;
2004   bfd_ardata (abfd)->tdata = bfd_zalloc (abfd, amt);
2005   if (bfd_ardata (abfd)->tdata == NULL)
2006     goto error_ret;
2007
2008   memcpy (bfd_ardata (abfd)->tdata, &hdr, SIZEOF_AR_FILE_HDR_BIG);
2009
2010   if (! xcoff64_slurp_armap (abfd))
2011     {
2012     error_ret:
2013       bfd_release (abfd, bfd_ardata (abfd));
2014     error_ret_restore:
2015       bfd_ardata (abfd) = tdata_hold;
2016       return NULL;
2017     }
2018
2019   return abfd->xvec;
2020 }
2021
2022
2023 /* Open the next element in an XCOFF archive.  */
2024
2025 static bfd *
2026 xcoff64_openr_next_archived_file (bfd *archive, bfd *last_file)
2027 {
2028   bfd_vma filestart;
2029
2030   if ((xcoff_ardata (archive) == NULL)
2031       || ! xcoff_big_format_p (archive))
2032     {
2033       bfd_set_error (bfd_error_invalid_operation);
2034       return NULL;
2035     }
2036
2037   if (last_file == NULL)
2038     {
2039       filestart = bfd_ardata (archive)->first_file_filepos;
2040     }
2041   else
2042     {
2043       filestart = bfd_scan_vma (arch_xhdr_big (last_file)->nextoff,
2044                                 (const char **) NULL, 10);
2045     }
2046
2047   if (filestart == 0
2048       || filestart == bfd_scan_vma (xcoff_ardata_big (archive)->memoff,
2049                                     (const char **) NULL, 10)
2050       || filestart == bfd_scan_vma (xcoff_ardata_big (archive)->symoff,
2051                                     (const char **) NULL, 10))
2052     {
2053       bfd_set_error (bfd_error_no_more_archived_files);
2054       return NULL;
2055     }
2056
2057   return _bfd_get_elt_at_filepos (archive, (file_ptr) filestart);
2058 }
2059
2060 /* We can't use the usual coff_sizeof_headers routine, because AIX
2061    always uses an a.out header.  */
2062
2063 static int
2064 xcoff64_sizeof_headers (bfd *abfd,
2065                         struct bfd_link_info *info ATTRIBUTE_UNUSED)
2066 {
2067   int size;
2068
2069   size = bfd_coff_filhsz (abfd);
2070
2071   /* Don't think the small aout header can be used since some of the
2072      old elements have been reordered past the end of the old coff
2073      small aout size.  */
2074
2075   if (xcoff_data (abfd)->full_aouthdr)
2076     size += bfd_coff_aoutsz (abfd);
2077
2078   size += abfd->section_count * bfd_coff_scnhsz (abfd);
2079   return size;
2080 }
2081
2082 static asection *
2083 xcoff64_create_csect_from_smclas (bfd *abfd, union internal_auxent *aux,
2084                                   const char *symbol_name)
2085 {
2086   asection *return_value = NULL;
2087
2088   /* Changes from 32 :
2089      .sv == 8, is only for 32 bit programs
2090      .ti == 12 and .tb == 13 are now reserved.  */
2091   static const char *names[19] =
2092   {
2093     ".pr", ".ro", ".db", ".tc", ".ua", ".rw", ".gl", ".xo",
2094     NULL, ".bs", ".ds", ".uc", NULL,  NULL,  NULL,  ".tc0",
2095     ".td", ".sv64", ".sv3264"
2096   };
2097
2098   if ((19 >= aux->x_csect.x_smclas)
2099       && (NULL != names[aux->x_csect.x_smclas]))
2100     {
2101
2102       return_value = bfd_make_section_anyway
2103         (abfd, names[aux->x_csect.x_smclas]);
2104
2105     }
2106   else
2107     {
2108       (*_bfd_error_handler)
2109         (_("%B: symbol `%s' has unrecognized smclas %d"),
2110          abfd, symbol_name, aux->x_csect.x_smclas);
2111       bfd_set_error (bfd_error_bad_value);
2112     }
2113
2114   return return_value;
2115 }
2116
2117 static bfd_boolean
2118 xcoff64_is_lineno_count_overflow (bfd *abfd ATTRIBUTE_UNUSED,
2119                                   bfd_vma value ATTRIBUTE_UNUSED)
2120 {
2121   return FALSE;
2122 }
2123
2124 static bfd_boolean
2125 xcoff64_is_reloc_count_overflow (bfd *abfd ATTRIBUTE_UNUSED,
2126                                  bfd_vma value ATTRIBUTE_UNUSED)
2127 {
2128   return FALSE;
2129 }
2130
2131 static bfd_vma
2132 xcoff64_loader_symbol_offset (bfd *abfd ATTRIBUTE_UNUSED,
2133                               struct internal_ldhdr *ldhdr)
2134 {
2135   return (ldhdr->l_symoff);
2136 }
2137
2138 static bfd_vma
2139 xcoff64_loader_reloc_offset (bfd *abfd ATTRIBUTE_UNUSED,
2140                              struct internal_ldhdr *ldhdr)
2141 {
2142   return (ldhdr->l_rldoff);
2143 }
2144
2145 static bfd_boolean
2146 xcoff64_bad_format_hook (bfd * abfd, void *filehdr)
2147 {
2148   struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
2149
2150   /* Check flavor first.  */
2151   if (bfd_get_flavour (abfd) != bfd_target_xcoff_flavour)
2152     return FALSE;
2153
2154   if (bfd_xcoff_magic_number (abfd) != internal_f->f_magic)
2155     return FALSE;
2156
2157   return TRUE;
2158 }
2159
2160 static bfd_boolean
2161 xcoff64_generate_rtinit (bfd *abfd, const char *init, const char *fini,
2162                          bfd_boolean rtld)
2163 {
2164   bfd_byte filehdr_ext[FILHSZ];
2165   bfd_byte scnhdr_ext[SCNHSZ * 3];
2166   bfd_byte syment_ext[SYMESZ * 10];
2167   bfd_byte reloc_ext[RELSZ * 3];
2168   bfd_byte *data_buffer;
2169   bfd_size_type data_buffer_size;
2170   bfd_byte *string_table, *st_tmp;
2171   bfd_size_type string_table_size;
2172   bfd_vma val;
2173   size_t initsz, finisz;
2174   struct internal_filehdr filehdr;
2175   struct internal_scnhdr text_scnhdr;
2176   struct internal_scnhdr data_scnhdr;
2177   struct internal_scnhdr bss_scnhdr;
2178   struct internal_syment syment;
2179   union internal_auxent auxent;
2180   struct internal_reloc reloc;
2181
2182   char *text_name = ".text";
2183   char *data_name = ".data";
2184   char *bss_name = ".bss";
2185   char *rtinit_name = "__rtinit";
2186   char *rtld_name = "__rtld";
2187
2188   if (! bfd_xcoff_rtinit_size (abfd))
2189     return FALSE;
2190
2191   initsz = (init == NULL ? 0 : 1 + strlen (init));
2192   finisz = (fini == NULL ? 0 : 1 + strlen (fini));
2193
2194   /* File header.  */
2195   memset (filehdr_ext, 0, FILHSZ);
2196   memset (&filehdr, 0, sizeof (struct internal_filehdr));
2197   filehdr.f_magic = bfd_xcoff_magic_number (abfd);
2198   filehdr.f_nscns = 3;
2199   filehdr.f_timdat = 0;
2200   filehdr.f_nsyms = 0;  /* at least 6, no more than 8 */
2201   filehdr.f_symptr = 0; /* set below */
2202   filehdr.f_opthdr = 0;
2203   filehdr.f_flags = 0;
2204
2205   /* Section headers.  */
2206   memset (scnhdr_ext, 0, 3 * SCNHSZ);
2207
2208   /* Text.  */
2209   memset (&text_scnhdr, 0, sizeof (struct internal_scnhdr));
2210   memcpy (text_scnhdr.s_name, text_name, strlen (text_name));
2211   text_scnhdr.s_paddr = 0;
2212   text_scnhdr.s_vaddr = 0;
2213   text_scnhdr.s_size = 0;
2214   text_scnhdr.s_scnptr = 0;
2215   text_scnhdr.s_relptr = 0;
2216   text_scnhdr.s_lnnoptr = 0;
2217   text_scnhdr.s_nreloc = 0;
2218   text_scnhdr.s_nlnno = 0;
2219   text_scnhdr.s_flags = STYP_TEXT;
2220
2221   /* Data.  */
2222   memset (&data_scnhdr, 0, sizeof (struct internal_scnhdr));
2223   memcpy (data_scnhdr.s_name, data_name, strlen (data_name));
2224   data_scnhdr.s_paddr = 0;
2225   data_scnhdr.s_vaddr = 0;
2226   data_scnhdr.s_size = 0;    /* set below */
2227   data_scnhdr.s_scnptr = FILHSZ + 3 * SCNHSZ;
2228   data_scnhdr.s_relptr = 0;  /* set below */
2229   data_scnhdr.s_lnnoptr = 0;
2230   data_scnhdr.s_nreloc = 0;  /* either 1 or 2 */
2231   data_scnhdr.s_nlnno = 0;
2232   data_scnhdr.s_flags = STYP_DATA;
2233
2234   /* Bss.  */
2235   memset (&bss_scnhdr, 0, sizeof (struct internal_scnhdr));
2236   memcpy (bss_scnhdr.s_name, bss_name, strlen (bss_name));
2237   bss_scnhdr.s_paddr = 0; /* set below */
2238   bss_scnhdr.s_vaddr = 0; /* set below */
2239   bss_scnhdr.s_size = 0;  /* set below */
2240   bss_scnhdr.s_scnptr = 0;
2241   bss_scnhdr.s_relptr = 0;
2242   bss_scnhdr.s_lnnoptr = 0;
2243   bss_scnhdr.s_nreloc = 0;
2244   bss_scnhdr.s_nlnno = 0;
2245   bss_scnhdr.s_flags = STYP_BSS;
2246
2247   /* .data
2248      0x0000           0x00000000 : rtl
2249      0x0004           0x00000000 :
2250      0x0008           0x00000018 : offset to init, or 0
2251      0x000C           0x00000038 : offset to fini, or 0
2252      0x0010           0x00000010 : size of descriptor
2253      0x0014           0x00000000 : pad
2254      0x0018           0x00000000 : init, needs a reloc
2255      0x001C           0x00000000 :
2256      0x0020           0x00000058 : offset to init name
2257      0x0024           0x00000000 : flags, padded to a word
2258      0x0028           0x00000000 : empty init
2259      0x002C           0x00000000 :
2260      0x0030           0x00000000 :
2261      0x0034           0x00000000 :
2262      0x0038           0x00000000 : fini, needs a reloc
2263      0x003C           0x00000000 :
2264      0x0040           0x00000??? : offset to fini name
2265      0x0044           0x00000000 : flags, padded to a word
2266      0x0048           0x00000000 : empty fini
2267      0x004C           0x00000000 :
2268      0x0050           0x00000000 :
2269      0x0054           0x00000000 :
2270      0x0058           init name
2271      0x0058 + initsz  fini name */
2272
2273   data_buffer_size = 0x0058 + initsz + finisz;
2274   data_buffer_size = (data_buffer_size + 7) &~ (bfd_size_type) 7;
2275   data_buffer = NULL;
2276   data_buffer = (bfd_byte *) bfd_zmalloc (data_buffer_size);
2277   if (data_buffer == NULL)
2278     return FALSE;
2279
2280   if (initsz)
2281     {
2282       val = 0x18;
2283       bfd_put_32 (abfd, val, &data_buffer[0x08]);
2284       val = 0x58;
2285       bfd_put_32 (abfd, val, &data_buffer[0x20]);
2286       memcpy (&data_buffer[val], init, initsz);
2287     }
2288
2289   if (finisz)
2290     {
2291       val = 0x38;
2292       bfd_put_32 (abfd, val, &data_buffer[0x0C]);
2293       val = 0x58 + initsz;
2294       bfd_put_32 (abfd, val, &data_buffer[0x40]);
2295       memcpy (&data_buffer[val], fini, finisz);
2296     }
2297
2298   val = 0x10;
2299   bfd_put_32 (abfd, val, &data_buffer[0x10]);
2300   data_scnhdr.s_size = data_buffer_size;
2301   bss_scnhdr.s_paddr = bss_scnhdr.s_vaddr = data_scnhdr.s_size;
2302
2303   /* String table.  */
2304   string_table_size = 4;
2305   string_table_size += strlen (data_name) + 1;
2306   string_table_size += strlen (rtinit_name) + 1;
2307   string_table_size += initsz;
2308   string_table_size += finisz;
2309   if (rtld)
2310     string_table_size += strlen (rtld_name) + 1;
2311
2312   string_table = (bfd_byte *) bfd_zmalloc (string_table_size);
2313   if (string_table == NULL)
2314     return FALSE;
2315
2316   val = string_table_size;
2317   bfd_put_32 (abfd, val, &string_table[0]);
2318   st_tmp = string_table + 4;
2319
2320   /* symbols
2321      0. .data csect
2322      2. __rtinit
2323      4. init function
2324      6. fini function
2325      8. __rtld  */
2326   memset (syment_ext, 0, 10 * SYMESZ);
2327   memset (reloc_ext, 0, 3 * RELSZ);
2328
2329   /* .data csect */
2330   memset (&syment, 0, sizeof (struct internal_syment));
2331   memset (&auxent, 0, sizeof (union internal_auxent));
2332
2333   syment._n._n_n._n_offset = st_tmp - string_table;
2334   memcpy (st_tmp, data_name, strlen (data_name));
2335   st_tmp += strlen (data_name) + 1;
2336
2337   syment.n_scnum = 2;
2338   syment.n_sclass = C_HIDEXT;
2339   syment.n_numaux = 1;
2340   auxent.x_csect.x_scnlen.l = data_buffer_size;
2341   auxent.x_csect.x_smtyp = 3 << 3 | XTY_SD;
2342   auxent.x_csect.x_smclas = XMC_RW;
2343   bfd_coff_swap_sym_out (abfd, &syment,
2344                          &syment_ext[filehdr.f_nsyms * SYMESZ]);
2345   bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0,
2346                          syment.n_numaux,
2347                          &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]);
2348   filehdr.f_nsyms += 2;
2349
2350   /* __rtinit */
2351   memset (&syment, 0, sizeof (struct internal_syment));
2352   memset (&auxent, 0, sizeof (union internal_auxent));
2353   syment._n._n_n._n_offset = st_tmp - string_table;
2354   memcpy (st_tmp, rtinit_name, strlen (rtinit_name));
2355   st_tmp += strlen (rtinit_name) + 1;
2356
2357   syment.n_scnum = 2;
2358   syment.n_sclass = C_EXT;
2359   syment.n_numaux = 1;
2360   auxent.x_csect.x_smtyp = XTY_LD;
2361   auxent.x_csect.x_smclas = XMC_RW;
2362   bfd_coff_swap_sym_out (abfd, &syment,
2363                          &syment_ext[filehdr.f_nsyms * SYMESZ]);
2364   bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0,
2365                          syment.n_numaux,
2366                          &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]);
2367   filehdr.f_nsyms += 2;
2368
2369   /* Init.  */
2370   if (initsz)
2371     {
2372       memset (&syment, 0, sizeof (struct internal_syment));
2373       memset (&auxent, 0, sizeof (union internal_auxent));
2374
2375       syment._n._n_n._n_offset = st_tmp - string_table;
2376       memcpy (st_tmp, init, initsz);
2377       st_tmp += initsz;
2378
2379       syment.n_sclass = C_EXT;
2380       syment.n_numaux = 1;
2381       bfd_coff_swap_sym_out (abfd, &syment,
2382                              &syment_ext[filehdr.f_nsyms * SYMESZ]);
2383       bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0,
2384                              syment.n_numaux,
2385                              &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]);
2386       /* Reloc.  */
2387       memset (&reloc, 0, sizeof (struct internal_reloc));
2388       reloc.r_vaddr = 0x0018;
2389       reloc.r_symndx = filehdr.f_nsyms;
2390       reloc.r_type = R_POS;
2391       reloc.r_size = 63;
2392       bfd_coff_swap_reloc_out (abfd, &reloc, &reloc_ext[0]);
2393
2394       filehdr.f_nsyms += 2;
2395       data_scnhdr.s_nreloc += 1;
2396     }
2397
2398   /* Finit.  */
2399   if (finisz)
2400     {
2401       memset (&syment, 0, sizeof (struct internal_syment));
2402       memset (&auxent, 0, sizeof (union internal_auxent));
2403
2404       syment._n._n_n._n_offset = st_tmp - string_table;
2405       memcpy (st_tmp, fini, finisz);
2406       st_tmp += finisz;
2407
2408       syment.n_sclass = C_EXT;
2409       syment.n_numaux = 1;
2410       bfd_coff_swap_sym_out (abfd, &syment,
2411                              &syment_ext[filehdr.f_nsyms * SYMESZ]);
2412       bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0,
2413                              syment.n_numaux,
2414                              &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]);
2415
2416       /* Reloc.  */
2417       memset (&reloc, 0, sizeof (struct internal_reloc));
2418       reloc.r_vaddr = 0x0038;
2419       reloc.r_symndx = filehdr.f_nsyms;
2420       reloc.r_type = R_POS;
2421       reloc.r_size = 63;
2422       bfd_coff_swap_reloc_out (abfd, &reloc,
2423                                &reloc_ext[data_scnhdr.s_nreloc * RELSZ]);
2424
2425       filehdr.f_nsyms += 2;
2426       data_scnhdr.s_nreloc += 1;
2427     }
2428
2429   if (rtld)
2430     {
2431       memset (&syment, 0, sizeof (struct internal_syment));
2432       memset (&auxent, 0, sizeof (union internal_auxent));
2433
2434       syment._n._n_n._n_offset = st_tmp - string_table;
2435       memcpy (st_tmp, rtld_name, strlen (rtld_name));
2436       st_tmp += strlen (rtld_name) + 1;
2437
2438       syment.n_sclass = C_EXT;
2439       syment.n_numaux = 1;
2440       bfd_coff_swap_sym_out (abfd, &syment,
2441                              &syment_ext[filehdr.f_nsyms * SYMESZ]);
2442       bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0,
2443                              syment.n_numaux,
2444                              &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]);
2445
2446       /* Reloc.  */
2447       memset (&reloc, 0, sizeof (struct internal_reloc));
2448       reloc.r_vaddr = 0x0000;
2449       reloc.r_symndx = filehdr.f_nsyms;
2450       reloc.r_type = R_POS;
2451       reloc.r_size = 63;
2452       bfd_coff_swap_reloc_out (abfd, &reloc,
2453                                &reloc_ext[data_scnhdr.s_nreloc * RELSZ]);
2454
2455       filehdr.f_nsyms += 2;
2456       data_scnhdr.s_nreloc += 1;
2457
2458       bss_scnhdr.s_size = 0;
2459     }
2460
2461   data_scnhdr.s_relptr = data_scnhdr.s_scnptr + data_buffer_size;
2462   filehdr.f_symptr = data_scnhdr.s_relptr + data_scnhdr.s_nreloc * RELSZ;
2463
2464   bfd_coff_swap_filehdr_out (abfd, &filehdr, filehdr_ext);
2465   bfd_bwrite (filehdr_ext, FILHSZ, abfd);
2466   bfd_coff_swap_scnhdr_out (abfd, &text_scnhdr, &scnhdr_ext[SCNHSZ * 0]);
2467   bfd_coff_swap_scnhdr_out (abfd, &data_scnhdr, &scnhdr_ext[SCNHSZ * 1]);
2468   bfd_coff_swap_scnhdr_out (abfd, &bss_scnhdr, &scnhdr_ext[SCNHSZ * 2]);
2469   bfd_bwrite (scnhdr_ext, 3 * SCNHSZ, abfd);
2470   bfd_bwrite (data_buffer, data_buffer_size, abfd);
2471   bfd_bwrite (reloc_ext, data_scnhdr.s_nreloc * RELSZ, abfd);
2472   bfd_bwrite (syment_ext, filehdr.f_nsyms * SYMESZ, abfd);
2473   bfd_bwrite (string_table, string_table_size, abfd);
2474
2475   free (data_buffer);
2476   data_buffer = NULL;
2477
2478   return TRUE;
2479 }
2480
2481 /* The typical dynamic reloc.  */
2482
2483 static reloc_howto_type xcoff64_dynamic_reloc =
2484 HOWTO (0,                       /* type */
2485        0,                       /* rightshift */
2486        4,                       /* size (0 = byte, 1 = short, 2 = long) */
2487        64,                      /* bitsize */
2488        FALSE,                   /* pc_relative */
2489        0,                       /* bitpos */
2490        complain_overflow_bitfield, /* complain_on_overflow */
2491        0,                       /* special_function */
2492        "R_POS",                 /* name */
2493        TRUE,                    /* partial_inplace */
2494        MINUS_ONE,               /* src_mask */
2495        MINUS_ONE,               /* dst_mask */
2496        FALSE);                  /* pcrel_offset */
2497
2498 static unsigned long xcoff64_glink_code[10] =
2499 {
2500   0xe9820000,   /* ld r12,0(r2) */
2501   0xf8410028,   /* std r2,40(r1) */
2502   0xe80c0000,   /* ld r0,0(r12) */
2503   0xe84c0008,   /* ld r0,8(r12) */
2504   0x7c0903a6,   /* mtctr r0 */
2505   0x4e800420,   /* bctr */
2506   0x00000000,   /* start of traceback table */
2507   0x000ca000,   /* traceback table */
2508   0x00000000,   /* traceback table */
2509   0x00000018,   /* ??? */
2510 };
2511
2512 static const struct xcoff_backend_data_rec bfd_xcoff_backend_data =
2513   {
2514     { /* COFF backend, defined in libcoff.h.  */
2515       _bfd_xcoff64_swap_aux_in,
2516       _bfd_xcoff64_swap_sym_in,
2517       _bfd_xcoff64_swap_lineno_in,
2518       _bfd_xcoff64_swap_aux_out,
2519       _bfd_xcoff64_swap_sym_out,
2520       _bfd_xcoff64_swap_lineno_out,
2521       xcoff64_swap_reloc_out,
2522       coff_swap_filehdr_out,
2523       coff_swap_aouthdr_out,
2524       coff_swap_scnhdr_out,
2525       FILHSZ,
2526       AOUTSZ,
2527       SCNHSZ,
2528       SYMESZ,
2529       AUXESZ,
2530       RELSZ,
2531       LINESZ,
2532       FILNMLEN,
2533       TRUE,                     /* _bfd_coff_long_filenames */
2534       XCOFF_NO_LONG_SECTION_NAMES,  /* _bfd_coff_long_section_names */
2535       3,                        /* _bfd_coff_default_section_alignment_power */
2536       TRUE,                     /* _bfd_coff_force_symnames_in_strings */
2537       4,                        /* _bfd_coff_debug_string_prefix_length */
2538       coff_swap_filehdr_in,
2539       coff_swap_aouthdr_in,
2540       coff_swap_scnhdr_in,
2541       xcoff64_swap_reloc_in,
2542       xcoff64_bad_format_hook,
2543       coff_set_arch_mach_hook,
2544       coff_mkobject_hook,
2545       styp_to_sec_flags,
2546       coff_set_alignment_hook,
2547       coff_slurp_symbol_table,
2548       symname_in_debug_hook,
2549       coff_pointerize_aux_hook,
2550       coff_print_aux,
2551       dummy_reloc16_extra_cases,
2552       dummy_reloc16_estimate,
2553       NULL,                     /* bfd_coff_symbol_classification */
2554       coff_compute_section_file_positions,
2555       NULL,                     /* _bfd_coff_start_final_link */
2556       xcoff64_ppc_relocate_section,
2557       coff_rtype_to_howto,
2558       NULL,                     /* _bfd_coff_adjust_symndx */
2559       _bfd_generic_link_add_one_symbol,
2560       coff_link_output_has_begun,
2561       coff_final_link_postscript,
2562       NULL                      /* print_pdata.  */
2563     },
2564
2565     0x01EF,                     /* magic number */
2566     bfd_arch_powerpc,
2567     bfd_mach_ppc_620,
2568
2569     /* Function pointers to xcoff specific swap routines.  */
2570     xcoff64_swap_ldhdr_in,
2571     xcoff64_swap_ldhdr_out,
2572     xcoff64_swap_ldsym_in,
2573     xcoff64_swap_ldsym_out,
2574     xcoff64_swap_ldrel_in,
2575     xcoff64_swap_ldrel_out,
2576
2577     /* Sizes.  */
2578     LDHDRSZ,
2579     LDSYMSZ,
2580     LDRELSZ,
2581     24,                         /* _xcoff_function_descriptor_size */
2582     0,                          /* _xcoff_small_aout_header_size */
2583
2584     /* Versions.  */
2585     2,                          /* _xcoff_ldhdr_version */
2586
2587     _bfd_xcoff64_put_symbol_name,
2588     _bfd_xcoff64_put_ldsymbol_name,
2589     &xcoff64_dynamic_reloc,
2590     xcoff64_create_csect_from_smclas,
2591
2592     /* Lineno and reloc count overflow.  */
2593     xcoff64_is_lineno_count_overflow,
2594     xcoff64_is_reloc_count_overflow,
2595
2596     xcoff64_loader_symbol_offset,
2597     xcoff64_loader_reloc_offset,
2598
2599     /* glink.  */
2600     &xcoff64_glink_code[0],
2601     40,                         /* _xcoff_glink_size */
2602
2603     /* rtinit.  */
2604     88,                         /* _xcoff_rtinit_size */
2605     xcoff64_generate_rtinit,
2606   };
2607
2608 /* The transfer vector that leads the outside world to all of the above.  */
2609 const bfd_target rs6000coff64_vec =
2610   {
2611     "aixcoff64-rs6000",
2612     bfd_target_xcoff_flavour,
2613     BFD_ENDIAN_BIG,             /* data byte order is big */
2614     BFD_ENDIAN_BIG,             /* header byte order is big */
2615
2616     (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | DYNAMIC
2617      | HAS_SYMS | HAS_LOCALS | WP_TEXT),
2618
2619     SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA,
2620     0,                          /* leading char */
2621     '/',                        /* ar_pad_char */
2622     15,                         /* ar_max_namelen */
2623
2624     /* data */
2625     bfd_getb64,
2626     bfd_getb_signed_64,
2627     bfd_putb64,
2628     bfd_getb32,
2629     bfd_getb_signed_32,
2630     bfd_putb32,
2631     bfd_getb16,
2632     bfd_getb_signed_16,
2633     bfd_putb16,
2634
2635     /* hdrs */
2636     bfd_getb64,
2637     bfd_getb_signed_64,
2638     bfd_putb64,
2639     bfd_getb32,
2640     bfd_getb_signed_32,
2641     bfd_putb32,
2642     bfd_getb16,
2643     bfd_getb_signed_16,
2644     bfd_putb16,
2645
2646     { /* bfd_check_format */
2647       _bfd_dummy_target,
2648       coff_object_p,
2649       xcoff64_archive_p,
2650       CORE_FILE_P
2651     },
2652
2653     { /* bfd_set_format */
2654       bfd_false,
2655       coff_mkobject,
2656       _bfd_generic_mkarchive,
2657       bfd_false
2658     },
2659
2660     {/* bfd_write_contents */
2661       bfd_false,
2662       xcoff64_write_object_contents,
2663       _bfd_xcoff_write_archive_contents,
2664       bfd_false
2665     },
2666
2667     /* Generic */
2668     bfd_true,
2669     bfd_true,
2670     coff_new_section_hook,
2671     _bfd_generic_get_section_contents,
2672     _bfd_generic_get_section_contents_in_window,
2673
2674     /* Copy */
2675     _bfd_xcoff_copy_private_bfd_data,
2676     _bfd_generic_bfd_merge_private_bfd_data,
2677     _bfd_generic_init_private_section_data,
2678     _bfd_generic_bfd_copy_private_section_data,
2679     _bfd_generic_bfd_copy_private_symbol_data,
2680     _bfd_generic_bfd_copy_private_header_data,
2681     _bfd_generic_bfd_set_private_flags,
2682     _bfd_generic_bfd_print_private_bfd_data,
2683
2684     /* Core */
2685     BFD_JUMP_TABLE_CORE (coff),
2686
2687     /* Archive */
2688     xcoff64_slurp_armap,
2689     _bfd_noarchive_slurp_extended_name_table,
2690     _bfd_noarchive_construct_extended_name_table,
2691     bfd_dont_truncate_arname,
2692     _bfd_xcoff_write_armap,
2693     _bfd_xcoff_read_ar_hdr,
2694     _bfd_generic_write_ar_hdr,
2695     xcoff64_openr_next_archived_file,
2696     _bfd_generic_get_elt_at_index,
2697     _bfd_xcoff_stat_arch_elt,
2698     bfd_true,
2699
2700     /* Symbols */
2701     coff_get_symtab_upper_bound,
2702     coff_canonicalize_symtab,
2703     coff_make_empty_symbol,
2704     coff_print_symbol,
2705     coff_get_symbol_info,
2706     _bfd_xcoff_is_local_label_name,
2707     coff_bfd_is_target_special_symbol,
2708     coff_get_lineno,
2709     coff_find_nearest_line,
2710     _bfd_generic_find_line,
2711     coff_find_inliner_info,
2712     coff_bfd_make_debug_symbol,
2713     _bfd_generic_read_minisymbols,
2714     _bfd_generic_minisymbol_to_symbol,
2715
2716     /* Reloc */
2717     coff_get_reloc_upper_bound,
2718     coff_canonicalize_reloc,
2719     xcoff64_reloc_type_lookup,
2720     xcoff64_reloc_name_lookup,
2721
2722     /* Write */
2723     coff_set_arch_mach,
2724     coff_set_section_contents,
2725
2726     /* Link */
2727     xcoff64_sizeof_headers,
2728     bfd_generic_get_relocated_section_contents,
2729     bfd_generic_relax_section,
2730     _bfd_xcoff_bfd_link_hash_table_create,
2731     _bfd_generic_link_hash_table_free,
2732     _bfd_xcoff_bfd_link_add_symbols,
2733     _bfd_generic_link_just_syms,
2734     _bfd_generic_copy_link_hash_symbol_type,
2735     _bfd_xcoff_bfd_final_link,
2736     _bfd_generic_link_split_section,
2737     bfd_generic_gc_sections,
2738     bfd_generic_merge_sections,
2739     bfd_generic_is_group_section,
2740     bfd_generic_discard_group,
2741     _bfd_generic_section_already_linked,
2742     _bfd_xcoff_define_common_symbol,
2743
2744     /* Dynamic */
2745     _bfd_xcoff_get_dynamic_symtab_upper_bound,
2746     _bfd_xcoff_canonicalize_dynamic_symtab,
2747     _bfd_nodynamic_get_synthetic_symtab,
2748     _bfd_xcoff_get_dynamic_reloc_upper_bound,
2749     _bfd_xcoff_canonicalize_dynamic_reloc,
2750
2751     /* Opposite endian version, none exists */
2752     NULL,
2753
2754     &bfd_xcoff_backend_data,
2755   };
2756
2757 extern const bfd_target *xcoff64_core_p
2758   (bfd *);
2759 extern bfd_boolean xcoff64_core_file_matches_executable_p
2760   (bfd *, bfd *);
2761 extern char *xcoff64_core_file_failing_command
2762   (bfd *);
2763 extern int xcoff64_core_file_failing_signal
2764   (bfd *);
2765 #define xcoff64_core_file_pid _bfd_nocore_core_file_pid
2766
2767 /* AIX 5 */
2768 static const struct xcoff_backend_data_rec bfd_xcoff_aix5_backend_data =
2769   {
2770     { /* COFF backend, defined in libcoff.h.  */
2771       _bfd_xcoff64_swap_aux_in,
2772       _bfd_xcoff64_swap_sym_in,
2773       _bfd_xcoff64_swap_lineno_in,
2774       _bfd_xcoff64_swap_aux_out,
2775       _bfd_xcoff64_swap_sym_out,
2776       _bfd_xcoff64_swap_lineno_out,
2777       xcoff64_swap_reloc_out,
2778       coff_swap_filehdr_out,
2779       coff_swap_aouthdr_out,
2780       coff_swap_scnhdr_out,
2781       FILHSZ,
2782       AOUTSZ,
2783       SCNHSZ,
2784       SYMESZ,
2785       AUXESZ,
2786       RELSZ,
2787       LINESZ,
2788       FILNMLEN,
2789       TRUE,                     /* _bfd_coff_long_filenames */
2790       XCOFF_NO_LONG_SECTION_NAMES,  /* _bfd_coff_long_section_names */
2791       3,                        /* _bfd_coff_default_section_alignment_power */
2792       TRUE,                     /* _bfd_coff_force_symnames_in_strings */
2793       4,                        /* _bfd_coff_debug_string_prefix_length */
2794       coff_swap_filehdr_in,
2795       coff_swap_aouthdr_in,
2796       coff_swap_scnhdr_in,
2797       xcoff64_swap_reloc_in,
2798       xcoff64_bad_format_hook,
2799       coff_set_arch_mach_hook,
2800       coff_mkobject_hook,
2801       styp_to_sec_flags,
2802       coff_set_alignment_hook,
2803       coff_slurp_symbol_table,
2804       symname_in_debug_hook,
2805       coff_pointerize_aux_hook,
2806       coff_print_aux,
2807       dummy_reloc16_extra_cases,
2808       dummy_reloc16_estimate,
2809       NULL,                     /* bfd_coff_sym_is_global */
2810       coff_compute_section_file_positions,
2811       NULL,                     /* _bfd_coff_start_final_link */
2812       xcoff64_ppc_relocate_section,
2813       coff_rtype_to_howto,
2814       NULL,                     /* _bfd_coff_adjust_symndx */
2815       _bfd_generic_link_add_one_symbol,
2816       coff_link_output_has_begun,
2817       coff_final_link_postscript,
2818       NULL                      /* print_pdata.  */
2819     },
2820
2821     U64_TOCMAGIC,               /* magic number */
2822     bfd_arch_powerpc,
2823     bfd_mach_ppc_620,
2824
2825     /* Function pointers to xcoff specific swap routines.  */
2826     xcoff64_swap_ldhdr_in,
2827     xcoff64_swap_ldhdr_out,
2828     xcoff64_swap_ldsym_in,
2829     xcoff64_swap_ldsym_out,
2830     xcoff64_swap_ldrel_in,
2831     xcoff64_swap_ldrel_out,
2832
2833     /* Sizes.  */
2834     LDHDRSZ,
2835     LDSYMSZ,
2836     LDRELSZ,
2837     24,                         /* _xcoff_function_descriptor_size */
2838     0,                          /* _xcoff_small_aout_header_size */
2839     /* Versions.  */
2840     2,                          /* _xcoff_ldhdr_version */
2841
2842     _bfd_xcoff64_put_symbol_name,
2843     _bfd_xcoff64_put_ldsymbol_name,
2844     &xcoff64_dynamic_reloc,
2845     xcoff64_create_csect_from_smclas,
2846
2847     /* Lineno and reloc count overflow.  */
2848     xcoff64_is_lineno_count_overflow,
2849     xcoff64_is_reloc_count_overflow,
2850
2851     xcoff64_loader_symbol_offset,
2852     xcoff64_loader_reloc_offset,
2853
2854     /* glink.  */
2855     &xcoff64_glink_code[0],
2856     40,                         /* _xcoff_glink_size */
2857
2858     /* rtinit.  */
2859     88,                         /* _xcoff_rtinit_size */
2860     xcoff64_generate_rtinit,
2861   };
2862
2863 /* The transfer vector that leads the outside world to all of the above.  */
2864 const bfd_target aix5coff64_vec =
2865   {
2866     "aix5coff64-rs6000",
2867     bfd_target_xcoff_flavour,
2868     BFD_ENDIAN_BIG,             /* data byte order is big */
2869     BFD_ENDIAN_BIG,             /* header byte order is big */
2870
2871     (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | DYNAMIC
2872      | HAS_SYMS | HAS_LOCALS | WP_TEXT),
2873
2874     SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA,
2875     0,                          /* leading char */
2876     '/',                        /* ar_pad_char */
2877     15,                         /* ar_max_namelen */
2878
2879     /* data */
2880     bfd_getb64,
2881     bfd_getb_signed_64,
2882     bfd_putb64,
2883     bfd_getb32,
2884     bfd_getb_signed_32,
2885     bfd_putb32,
2886     bfd_getb16,
2887     bfd_getb_signed_16,
2888     bfd_putb16,
2889
2890     /* hdrs */
2891     bfd_getb64,
2892     bfd_getb_signed_64,
2893     bfd_putb64,
2894     bfd_getb32,
2895     bfd_getb_signed_32,
2896     bfd_putb32,
2897     bfd_getb16,
2898     bfd_getb_signed_16,
2899     bfd_putb16,
2900
2901     { /* bfd_check_format */
2902       _bfd_dummy_target,
2903       coff_object_p,
2904       xcoff64_archive_p,
2905       xcoff64_core_p
2906     },
2907
2908     { /* bfd_set_format */
2909       bfd_false,
2910       coff_mkobject,
2911       _bfd_generic_mkarchive,
2912       bfd_false
2913     },
2914
2915     {/* bfd_write_contents */
2916       bfd_false,
2917       xcoff64_write_object_contents,
2918       _bfd_xcoff_write_archive_contents,
2919       bfd_false
2920     },
2921
2922     /* Generic */
2923     bfd_true,
2924     bfd_true,
2925     coff_new_section_hook,
2926     _bfd_generic_get_section_contents,
2927     _bfd_generic_get_section_contents_in_window,
2928
2929     /* Copy */
2930     _bfd_xcoff_copy_private_bfd_data,
2931     _bfd_generic_bfd_merge_private_bfd_data,
2932     _bfd_generic_init_private_section_data,
2933     _bfd_generic_bfd_copy_private_section_data,
2934     _bfd_generic_bfd_copy_private_symbol_data,
2935     _bfd_generic_bfd_copy_private_header_data,
2936     _bfd_generic_bfd_set_private_flags,
2937     _bfd_generic_bfd_print_private_bfd_data,
2938
2939     /* Core */
2940     BFD_JUMP_TABLE_CORE (xcoff64),
2941
2942     /* Archive */
2943     xcoff64_slurp_armap,
2944     _bfd_noarchive_slurp_extended_name_table,
2945     _bfd_noarchive_construct_extended_name_table,
2946     bfd_dont_truncate_arname,
2947     _bfd_xcoff_write_armap,
2948     _bfd_xcoff_read_ar_hdr,
2949     _bfd_generic_write_ar_hdr,
2950     xcoff64_openr_next_archived_file,
2951     _bfd_generic_get_elt_at_index,
2952     _bfd_xcoff_stat_arch_elt,
2953     bfd_true,
2954
2955     /* Symbols */
2956     coff_get_symtab_upper_bound,
2957     coff_canonicalize_symtab,
2958     coff_make_empty_symbol,
2959     coff_print_symbol,
2960     coff_get_symbol_info,
2961     _bfd_xcoff_is_local_label_name,
2962     coff_bfd_is_target_special_symbol,
2963     coff_get_lineno,
2964     coff_find_nearest_line,
2965     _bfd_generic_find_line,
2966     coff_find_inliner_info,
2967     coff_bfd_make_debug_symbol,
2968     _bfd_generic_read_minisymbols,
2969     _bfd_generic_minisymbol_to_symbol,
2970
2971     /* Reloc */
2972     coff_get_reloc_upper_bound,
2973     coff_canonicalize_reloc,
2974     xcoff64_reloc_type_lookup,
2975     xcoff64_reloc_name_lookup,
2976
2977     /* Write */
2978     coff_set_arch_mach,
2979     coff_set_section_contents,
2980
2981     /* Link */
2982     xcoff64_sizeof_headers,
2983     bfd_generic_get_relocated_section_contents,
2984     bfd_generic_relax_section,
2985     _bfd_xcoff_bfd_link_hash_table_create,
2986     _bfd_generic_link_hash_table_free,
2987     _bfd_xcoff_bfd_link_add_symbols,
2988     _bfd_generic_link_just_syms,
2989     _bfd_generic_copy_link_hash_symbol_type,
2990     _bfd_xcoff_bfd_final_link,
2991     _bfd_generic_link_split_section,
2992     bfd_generic_gc_sections,
2993     bfd_generic_merge_sections,
2994     bfd_generic_is_group_section,
2995     bfd_generic_discard_group,
2996     _bfd_generic_section_already_linked,
2997     _bfd_xcoff_define_common_symbol,
2998
2999     /* Dynamic */
3000     _bfd_xcoff_get_dynamic_symtab_upper_bound,
3001     _bfd_xcoff_canonicalize_dynamic_symtab,
3002     _bfd_nodynamic_get_synthetic_symtab,
3003     _bfd_xcoff_get_dynamic_reloc_upper_bound,
3004     _bfd_xcoff_canonicalize_dynamic_reloc,
3005
3006     /* Opposite endian version, none exists.  */
3007     NULL,
3008
3009     & bfd_xcoff_aix5_backend_data,
3010   };