bfd/coff64-rs6000.c

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