bfd/coff64-rs6000.c

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