bfd/coff-rs6000.c

   1 /* BFD back-end for IBM RS/6000 "XCOFF" files.
   2    Copyright (C) 1990-2016 Free Software Foundation, Inc.
   3    Written by Metin G. Ozisik, Mimi Phuong-Thao Vo, and John Gilmore.
   4    Archive support from Damon A. Permezel.
   5    Contributed by IBM Corporation and 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 3 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., 51 Franklin Street - Fifth Floor, Boston,
  22    MA 02110-1301, USA.  */
  23
  24 #include "sysdep.h"
  25 #include "libiberty.h"
  26 #include "bfd.h"
  27 #include "bfdlink.h"
  28 #include "libbfd.h"
  29 #include "coff/internal.h"
  30 #include "coff/xcoff.h"
  31 #include "coff/rs6000.h"
  32 #include "libcoff.h"
  33 #include "libxcoff.h"
  34
  35 extern bfd_boolean _bfd_xcoff_mkobject (bfd *);
  36 extern bfd_boolean _bfd_xcoff_copy_private_bfd_data (bfd *, bfd *);
  37 extern bfd_boolean _bfd_xcoff_is_local_label_name (bfd *, const char *);
  38 extern reloc_howto_type *_bfd_xcoff_reloc_type_lookup
  39   (bfd *, bfd_reloc_code_real_type);
  40 extern bfd_boolean _bfd_xcoff_slurp_armap (bfd *);
  41 extern const bfd_target *_bfd_xcoff_archive_p (bfd *);
  42 extern void * _bfd_xcoff_read_ar_hdr (bfd *);
  43 extern bfd *_bfd_xcoff_openr_next_archived_file (bfd *, bfd *);
  44 extern int _bfd_xcoff_stat_arch_elt (bfd *, struct stat *);
  45 extern bfd_boolean _bfd_xcoff_write_armap
  46   (bfd *, unsigned int, struct orl *, unsigned int, int);
  47 extern bfd_boolean _bfd_xcoff_write_archive_contents (bfd *);
  48 extern int _bfd_xcoff_sizeof_headers (bfd *, struct bfd_link_info *);
  49 extern void _bfd_xcoff_swap_sym_in (bfd *, void *, void *);
  50 extern unsigned int _bfd_xcoff_swap_sym_out (bfd *, void *, void *);
  51 extern void _bfd_xcoff_swap_aux_in (bfd *, void *, int, int, int, int, void *);
  52 extern unsigned int _bfd_xcoff_swap_aux_out
  53   (bfd *, void *, int, int, int, int, void *);
  54 static void xcoff_swap_reloc_in (bfd *, void *, void *);
  55 static unsigned int xcoff_swap_reloc_out (bfd *, void *, void *);
  56
  57 /* Forward declare xcoff_rtype2howto for coffcode.h macro.  */
  58 void xcoff_rtype2howto (arelent *, struct internal_reloc *);
  59
  60 /* coffcode.h needs these to be defined.  */
  61 #define RS6000COFF_C 1
  62
  63 #define SELECT_RELOC(internal, howto)                                   \
  64   {                                                                     \
  65     internal.r_type = howto->type;                                      \
  66     internal.r_size =                                                   \
  67       ((howto->complain_on_overflow == complain_overflow_signed         \
  68         ? 0x80                                                          \
  69         : 0)                                                            \
  70        | (howto->bitsize - 1));                                         \
  71   }
  72
  73 #define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (3)
  74 #define COFF_LONG_FILENAMES
  75 #define NO_COFF_SYMBOLS
  76 #define RTYPE2HOWTO(cache_ptr, dst) xcoff_rtype2howto (cache_ptr, dst)
  77 #define coff_mkobject _bfd_xcoff_mkobject
  78 #define coff_bfd_is_local_label_name _bfd_xcoff_is_local_label_name
  79 #ifdef AIX_CORE
  80 extern const bfd_target * rs6000coff_core_p (bfd *abfd);
  81 extern bfd_boolean rs6000coff_core_file_matches_executable_p
  82   (bfd *cbfd, bfd *ebfd);
  83 extern char *rs6000coff_core_file_failing_command (bfd *abfd);
  84 extern int rs6000coff_core_file_failing_signal (bfd *abfd);
  85 #define CORE_FILE_P rs6000coff_core_p
  86 #define coff_core_file_failing_command \
  87   rs6000coff_core_file_failing_command
  88 #define coff_core_file_failing_signal \
  89   rs6000coff_core_file_failing_signal
  90 #define coff_core_file_matches_executable_p \
  91   rs6000coff_core_file_matches_executable_p
  92 #define coff_core_file_pid \
  93   _bfd_nocore_core_file_pid
  94 #else
  95 #define CORE_FILE_P _bfd_dummy_target
  96 #define coff_core_file_failing_command \
  97   _bfd_nocore_core_file_failing_command
  98 #define coff_core_file_failing_signal \
  99   _bfd_nocore_core_file_failing_signal
 100 #define coff_core_file_matches_executable_p \
 101   _bfd_nocore_core_file_matches_executable_p
 102 #define coff_core_file_pid \
 103   _bfd_nocore_core_file_pid
 104 #endif
 105 #define coff_SWAP_sym_in _bfd_xcoff_swap_sym_in
 106 #define coff_SWAP_sym_out _bfd_xcoff_swap_sym_out
 107 #define coff_SWAP_aux_in _bfd_xcoff_swap_aux_in
 108 #define coff_SWAP_aux_out _bfd_xcoff_swap_aux_out
 109 #define coff_swap_reloc_in xcoff_swap_reloc_in
 110 #define coff_swap_reloc_out xcoff_swap_reloc_out
 111 #define NO_COFF_RELOCS
 112
 113 #ifndef bfd_pe_print_pdata
 114 #define bfd_pe_print_pdata      NULL
 115 #endif
 116
 117 #include <stdint.h>
 118 #include "coffcode.h"
 119
 120 /* The main body of code is in coffcode.h.  */
 121
 122 static const char *normalize_filename (bfd *);
 123 static bfd_boolean xcoff_write_armap_old
 124   (bfd *, unsigned int, struct orl *, unsigned int, int);
 125 static bfd_boolean xcoff_write_armap_big
 126   (bfd *, unsigned int, struct orl *, unsigned int, int);
 127 static bfd_boolean xcoff_write_archive_contents_old (bfd *);
 128 static bfd_boolean xcoff_write_archive_contents_big (bfd *);
 129 static void xcoff_swap_ldhdr_in (bfd *, const void *, struct internal_ldhdr *);
 130 static void xcoff_swap_ldhdr_out (bfd *, const struct internal_ldhdr *, void *);
 131 static void xcoff_swap_ldsym_in (bfd *, const void *, struct internal_ldsym *);
 132 static void xcoff_swap_ldsym_out (bfd *, const struct internal_ldsym *, void *);
 133 static void xcoff_swap_ldrel_in (bfd *, const void *, struct internal_ldrel *);
 134 static void xcoff_swap_ldrel_out (bfd *, const struct internal_ldrel *, void *);
 135 static bfd_boolean xcoff_ppc_relocate_section
 136   (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
 137    struct internal_reloc *, struct internal_syment *, asection **);
 138 static bfd_boolean _bfd_xcoff_put_ldsymbol_name
 139   (bfd *, struct xcoff_loader_info *, struct internal_ldsym *, const char *);
 140 static asection *xcoff_create_csect_from_smclas
 141   (bfd *, union internal_auxent *, const char *);
 142 static bfd_boolean xcoff_is_lineno_count_overflow (bfd *, bfd_vma);
 143 static bfd_boolean xcoff_is_reloc_count_overflow (bfd *, bfd_vma);
 144 static bfd_vma xcoff_loader_symbol_offset (bfd *, struct internal_ldhdr *);
 145 static bfd_vma xcoff_loader_reloc_offset (bfd *, struct internal_ldhdr *);
 146 static bfd_boolean xcoff_generate_rtinit
 147   (bfd *, const char *, const char *, bfd_boolean);
 148 static bfd_boolean do_pad (bfd *, unsigned int);
 149 static bfd_boolean do_copy (bfd *, bfd *);
 150
 151 /* Relocation functions */
 152 static bfd_boolean xcoff_reloc_type_br (XCOFF_RELOC_FUNCTION_ARGS);
 153
 154 static bfd_boolean xcoff_complain_overflow_dont_func
 155   (XCOFF_COMPLAIN_FUNCTION_ARGS);
 156 static bfd_boolean xcoff_complain_overflow_bitfield_func
 157   (XCOFF_COMPLAIN_FUNCTION_ARGS);
 158 static bfd_boolean xcoff_complain_overflow_signed_func
 159   (XCOFF_COMPLAIN_FUNCTION_ARGS);
 160 static bfd_boolean xcoff_complain_overflow_unsigned_func
 161   (XCOFF_COMPLAIN_FUNCTION_ARGS);
 162
 163 bfd_boolean (*xcoff_calculate_relocation[XCOFF_MAX_CALCULATE_RELOCATION])
 164   (XCOFF_RELOC_FUNCTION_ARGS) =
 165 {
 166   xcoff_reloc_type_pos,  /* R_POS   (0x00) */
 167   xcoff_reloc_type_neg,  /* R_NEG   (0x01) */
 168   xcoff_reloc_type_rel,  /* R_REL   (0x02) */
 169   xcoff_reloc_type_toc,  /* R_TOC   (0x03) */
 170   xcoff_reloc_type_fail, /* R_RTB   (0x04) */
 171   xcoff_reloc_type_toc,  /* R_GL    (0x05) */
 172   xcoff_reloc_type_toc,  /* R_TCL   (0x06) */
 173   xcoff_reloc_type_fail, /*         (0x07) */
 174   xcoff_reloc_type_ba,   /* R_BA    (0x08) */
 175   xcoff_reloc_type_fail, /*         (0x09) */
 176   xcoff_reloc_type_br,   /* R_BR    (0x0a) */
 177   xcoff_reloc_type_fail, /*         (0x0b) */
 178   xcoff_reloc_type_pos,  /* R_RL    (0x0c) */
 179   xcoff_reloc_type_pos,  /* R_RLA   (0x0d) */
 180   xcoff_reloc_type_fail, /*         (0x0e) */
 181   xcoff_reloc_type_noop, /* R_REF   (0x0f) */
 182   xcoff_reloc_type_fail, /*         (0x10) */
 183   xcoff_reloc_type_fail, /*         (0x11) */
 184   xcoff_reloc_type_toc,  /* R_TRL   (0x12) */
 185   xcoff_reloc_type_toc,  /* R_TRLA  (0x13) */
 186   xcoff_reloc_type_fail, /* R_RRTBI (0x14) */
 187   xcoff_reloc_type_fail, /* R_RRTBA (0x15) */
 188   xcoff_reloc_type_ba,   /* R_CAI   (0x16) */
 189   xcoff_reloc_type_crel, /* R_CREL  (0x17) */
 190   xcoff_reloc_type_ba,   /* R_RBA   (0x18) */
 191   xcoff_reloc_type_ba,   /* R_RBAC  (0x19) */
 192   xcoff_reloc_type_br,   /* R_RBR   (0x1a) */
 193   xcoff_reloc_type_ba,   /* R_RBRC  (0x1b) */
 194 };
 195
 196 bfd_boolean (*xcoff_complain_overflow[XCOFF_MAX_COMPLAIN_OVERFLOW])
 197   (XCOFF_COMPLAIN_FUNCTION_ARGS) =
 198 {
 199   xcoff_complain_overflow_dont_func,
 200   xcoff_complain_overflow_bitfield_func,
 201   xcoff_complain_overflow_signed_func,
 202   xcoff_complain_overflow_unsigned_func,
 203 };
 204
 205 /* Information about one member of an archive.  */
 206 struct member_layout {
 207   /* The archive member that this structure describes.  */
 208   bfd *member;
 209
 210   /* The number of bytes of padding that must be inserted before the
 211      start of the member in order to ensure that the section contents
 212      are correctly aligned.  */
 213   unsigned int leading_padding;
 214
 215   /* The offset of MEMBER from the start of the archive (i.e. the end
 216      of the leading padding).  */
 217   file_ptr offset;
 218
 219   /* The normalized name of MEMBER.  */
 220   const char *name;
 221
 222   /* The length of NAME, without padding.  */
 223   bfd_size_type namlen;
 224
 225   /* The length of NAME, with padding.  */
 226   bfd_size_type padded_namlen;
 227
 228   /* The size of MEMBER's header, including the name and magic sequence.  */
 229   bfd_size_type header_size;
 230
 231   /* The size of the MEMBER's contents.  */
 232   bfd_size_type contents_size;
 233
 234   /* The number of bytes of padding that must be inserted after MEMBER
 235      in order to preserve even alignment.  */
 236   bfd_size_type trailing_padding;
 237 };
 238
 239 /* A structure used for iterating over the members of an archive.  */
 240 struct archive_iterator {
 241   /* The archive itself.  */
 242   bfd *archive;
 243
 244   /* Information about the current archive member.  */
 245   struct member_layout current;
 246
 247   /* Information about the next archive member.  MEMBER is null if there
 248      are no more archive members, in which case OFFSET is the offset of
 249      the first unused byte.  */
 250   struct member_layout next;
 251 };
 252
 253 /* Initialize INFO so that it describes member MEMBER of archive ARCHIVE.
 254    OFFSET is the even-padded offset of MEMBER, not including any leading
 255    padding needed for section alignment.  */
 256
 257 static void
 258 member_layout_init (struct member_layout *info, bfd *archive,
 259                     bfd *member, file_ptr offset)
 260 {
 261   info->member = member;
 262   info->leading_padding = 0;
 263   if (member)
 264     {
 265       info->name = normalize_filename (member);
 266       info->namlen = strlen (info->name);
 267       info->padded_namlen = info->namlen + (info->namlen & 1);
 268       if (xcoff_big_format_p (archive))
 269         info->header_size = SIZEOF_AR_HDR_BIG;
 270       else
 271         info->header_size = SIZEOF_AR_HDR;
 272       info->header_size += info->padded_namlen + SXCOFFARFMAG;
 273       info->contents_size = arelt_size (member);
 274       info->trailing_padding = info->contents_size & 1;
 275
 276       if (bfd_check_format (member, bfd_object)
 277           && bfd_get_flavour (member) == bfd_target_xcoff_flavour
 278           && (member->flags & DYNAMIC) != 0)
 279         info->leading_padding
 280           = (-(offset + info->header_size)
 281              & ((1 << bfd_xcoff_text_align_power (member)) - 1));
 282     }
 283   info->offset = offset + info->leading_padding;
 284 }
 285
 286 /* Set up ITERATOR to iterate through archive ARCHIVE.  */
 287
 288 static void
 289 archive_iterator_begin (struct archive_iterator *iterator,
 290                         bfd *archive)
 291 {
 292   iterator->archive = archive;
 293   member_layout_init (&iterator->next, archive, archive->archive_head,
 294                       xcoff_big_format_p (archive)
 295                       ? SIZEOF_AR_FILE_HDR_BIG
 296                       : SIZEOF_AR_FILE_HDR);
 297 }
 298
 299 /* Make ITERATOR visit the first unvisited archive member.  Return true
 300    on success; return false if all members have been visited.  */
 301
 302 static bfd_boolean
 303 archive_iterator_next (struct archive_iterator *iterator)
 304 {
 305   if (!iterator->next.member)
 306     return FALSE;
 307
 308   iterator->current = iterator->next;
 309   member_layout_init (&iterator->next, iterator->archive,
 310                       iterator->current.member->archive_next,
 311                       iterator->current.offset
 312                       + iterator->current.header_size
 313                       + iterator->current.contents_size
 314                       + iterator->current.trailing_padding);
 315   return TRUE;
 316 }
 317
 318 /* We use our own tdata type.  Its first field is the COFF tdata type,
 319    so the COFF routines are compatible.  */
 320
 321 bfd_boolean
 322 _bfd_xcoff_mkobject (bfd *abfd)
 323 {
 324   coff_data_type *coff;
 325   bfd_size_type amt = sizeof (struct xcoff_tdata);
 326
 327   abfd->tdata.xcoff_obj_data = (struct xcoff_tdata *) bfd_zalloc (abfd, amt);
 328   if (abfd->tdata.xcoff_obj_data == NULL)
 329     return FALSE;
 330   coff = coff_data (abfd);
 331   coff->symbols = (coff_symbol_type *) NULL;
 332   coff->conversion_table = (unsigned int *) NULL;
 333   coff->raw_syments = (struct coff_ptr_struct *) NULL;
 334   coff->relocbase = 0;
 335
 336   xcoff_data (abfd)->modtype = ('1' << 8) | 'L';
 337
 338   /* We set cputype to -1 to indicate that it has not been
 339      initialized.  */
 340   xcoff_data (abfd)->cputype = -1;
 341
 342   xcoff_data (abfd)->csects = NULL;
 343   xcoff_data (abfd)->debug_indices = NULL;
 344
 345   /* text section alignment is different than the default */
 346   bfd_xcoff_text_align_power (abfd) = 2;
 347
 348   return TRUE;
 349 }
 350
 351 /* Copy XCOFF data from one BFD to another.  */
 352
 353 bfd_boolean
 354 _bfd_xcoff_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
 355 {
 356   struct xcoff_tdata *ix, *ox;
 357   asection *sec;
 358
 359   if (ibfd->xvec != obfd->xvec)
 360     return TRUE;
 361   ix = xcoff_data (ibfd);
 362   ox = xcoff_data (obfd);
 363   ox->full_aouthdr = ix->full_aouthdr;
 364   ox->toc = ix->toc;
 365   if (ix->sntoc == 0)
 366     ox->sntoc = 0;
 367   else
 368     {
 369       sec = coff_section_from_bfd_index (ibfd, ix->sntoc);
 370       if (sec == NULL)
 371         ox->sntoc = 0;
 372       else
 373         ox->sntoc = sec->output_section->target_index;
 374     }
 375   if (ix->snentry == 0)
 376     ox->snentry = 0;
 377   else
 378     {
 379       sec = coff_section_from_bfd_index (ibfd, ix->snentry);
 380       if (sec == NULL)
 381         ox->snentry = 0;
 382       else
 383         ox->snentry = sec->output_section->target_index;
 384     }
 385   bfd_xcoff_text_align_power (obfd) = bfd_xcoff_text_align_power (ibfd);
 386   bfd_xcoff_data_align_power (obfd) = bfd_xcoff_data_align_power (ibfd);
 387   ox->modtype = ix->modtype;
 388   ox->cputype = ix->cputype;
 389   ox->maxdata = ix->maxdata;
 390   ox->maxstack = ix->maxstack;
 391   return TRUE;
 392 }
 393
 394 /* I don't think XCOFF really has a notion of local labels based on
 395    name.  This will mean that ld -X doesn't actually strip anything.
 396    The AIX native linker does not have a -X option, and it ignores the
 397    -x option.  */
 398
 399 bfd_boolean
 400 _bfd_xcoff_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED,
 401                                 const char *name ATTRIBUTE_UNUSED)
 402 {
 403   return FALSE;
 404 }
 405 \f
 406 void
 407 _bfd_xcoff_swap_sym_in (bfd *abfd, void * ext1, void * in1)
 408 {
 409   SYMENT *ext = (SYMENT *)ext1;
 410   struct internal_syment * in = (struct internal_syment *)in1;
 411
 412   if (ext->e.e_name[0] != 0)
 413     {
 414       memcpy (in->_n._n_name, ext->e.e_name, SYMNMLEN);
 415     }
 416   else
 417     {
 418       in->_n._n_n._n_zeroes = 0;
 419       in->_n._n_n._n_offset = H_GET_32 (abfd, ext->e.e.e_offset);
 420     }
 421
 422   in->n_value = H_GET_32 (abfd, ext->e_value);
 423   in->n_scnum = (short) H_GET_16 (abfd, ext->e_scnum);
 424   in->n_type = H_GET_16 (abfd, ext->e_type);
 425   in->n_sclass = H_GET_8 (abfd, ext->e_sclass);
 426   in->n_numaux = H_GET_8 (abfd, ext->e_numaux);
 427 }
 428
 429 unsigned int
 430 _bfd_xcoff_swap_sym_out (bfd *abfd, void * inp, void * extp)
 431 {
 432   struct internal_syment *in = (struct internal_syment *)inp;
 433   SYMENT *ext =(SYMENT *)extp;
 434
 435   if (in->_n._n_name[0] != 0)
 436     {
 437       memcpy (ext->e.e_name, in->_n._n_name, SYMNMLEN);
 438     }
 439   else
 440     {
 441       H_PUT_32 (abfd, 0, ext->e.e.e_zeroes);
 442       H_PUT_32 (abfd, in->_n._n_n._n_offset, ext->e.e.e_offset);
 443     }
 444
 445   H_PUT_32 (abfd, in->n_value, ext->e_value);
 446   H_PUT_16 (abfd, in->n_scnum, ext->e_scnum);
 447   H_PUT_16 (abfd, in->n_type, ext->e_type);
 448   H_PUT_8 (abfd, in->n_sclass, ext->e_sclass);
 449   H_PUT_8 (abfd, in->n_numaux, ext->e_numaux);
 450   return bfd_coff_symesz (abfd);
 451 }
 452
 453 void
 454 _bfd_xcoff_swap_aux_in (bfd *abfd, void * ext1, int type, int in_class,
 455                         int indx, int numaux, void * in1)
 456 {
 457   AUXENT * ext = (AUXENT *)ext1;
 458   union internal_auxent *in = (union internal_auxent *)in1;
 459
 460   switch (in_class)
 461     {
 462     case C_FILE:
 463       if (ext->x_file.x_n.x_fname[0] == 0)
 464         {
 465           in->x_file.x_n.x_zeroes = 0;
 466           in->x_file.x_n.x_offset =
 467             H_GET_32 (abfd, ext->x_file.x_n.x_n.x_offset);
 468         }
 469       else
 470         {
 471           if (numaux > 1)
 472             {
 473               if (indx == 0)
 474                 memcpy (in->x_file.x_fname, ext->x_file.x_n.x_fname,
 475                         numaux * sizeof (AUXENT));
 476             }
 477           else
 478             {
 479               memcpy (in->x_file.x_fname, ext->x_file.x_n.x_fname, FILNMLEN);
 480             }
 481         }
 482       goto end;
 483
 484       /* RS/6000 "csect" auxents */
 485     case C_EXT:
 486     case C_AIX_WEAKEXT:
 487     case C_HIDEXT:
 488       if (indx + 1 == numaux)
 489         {
 490           in->x_csect.x_scnlen.l = H_GET_32 (abfd, ext->x_csect.x_scnlen);
 491           in->x_csect.x_parmhash = H_GET_32 (abfd, ext->x_csect.x_parmhash);
 492           in->x_csect.x_snhash   = H_GET_16 (abfd, ext->x_csect.x_snhash);
 493           /* We don't have to hack bitfields in x_smtyp because it's
 494              defined by shifts-and-ands, which are equivalent on all
 495              byte orders.  */
 496           in->x_csect.x_smtyp    = H_GET_8 (abfd, ext->x_csect.x_smtyp);
 497           in->x_csect.x_smclas   = H_GET_8 (abfd, ext->x_csect.x_smclas);
 498           in->x_csect.x_stab     = H_GET_32 (abfd, ext->x_csect.x_stab);
 499           in->x_csect.x_snstab   = H_GET_16 (abfd, ext->x_csect.x_snstab);
 500           goto end;
 501         }
 502       break;
 503
 504     case C_STAT:
 505     case C_LEAFSTAT:
 506     case C_HIDDEN:
 507       if (type == T_NULL)
 508         {
 509           in->x_scn.x_scnlen = H_GET_32 (abfd, ext->x_scn.x_scnlen);
 510           in->x_scn.x_nreloc = H_GET_16 (abfd, ext->x_scn.x_nreloc);
 511           in->x_scn.x_nlinno = H_GET_16 (abfd, ext->x_scn.x_nlinno);
 512           /* PE defines some extra fields; we zero them out for
 513              safety.  */
 514           in->x_scn.x_checksum = 0;
 515           in->x_scn.x_associated = 0;
 516           in->x_scn.x_comdat = 0;
 517
 518           goto end;
 519         }
 520       break;
 521     }
 522
 523   in->x_sym.x_tagndx.l = H_GET_32 (abfd, ext->x_sym.x_tagndx);
 524   in->x_sym.x_tvndx = H_GET_16 (abfd, ext->x_sym.x_tvndx);
 525
 526   if (in_class == C_BLOCK || in_class == C_FCN || ISFCN (type)
 527       || ISTAG (in_class))
 528     {
 529       in->x_sym.x_fcnary.x_fcn.x_lnnoptr =
 530         H_GET_32 (abfd, ext->x_sym.x_fcnary.x_fcn.x_lnnoptr);
 531       in->x_sym.x_fcnary.x_fcn.x_endndx.l =
 532         H_GET_32 (abfd, ext->x_sym.x_fcnary.x_fcn.x_endndx);
 533     }
 534   else
 535     {
 536       in->x_sym.x_fcnary.x_ary.x_dimen[0] =
 537         H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
 538       in->x_sym.x_fcnary.x_ary.x_dimen[1] =
 539         H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
 540       in->x_sym.x_fcnary.x_ary.x_dimen[2] =
 541         H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
 542       in->x_sym.x_fcnary.x_ary.x_dimen[3] =
 543         H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
 544     }
 545
 546   if (ISFCN (type))
 547     {
 548       in->x_sym.x_misc.x_fsize = H_GET_32 (abfd, ext->x_sym.x_misc.x_fsize);
 549     }
 550   else
 551     {
 552       in->x_sym.x_misc.x_lnsz.x_lnno =
 553         H_GET_16 (abfd, ext->x_sym.x_misc.x_lnsz.x_lnno);
 554       in->x_sym.x_misc.x_lnsz.x_size =
 555         H_GET_16 (abfd, ext->x_sym.x_misc.x_lnsz.x_size);
 556     }
 557
 558  end: ;
 559   /* The semicolon is because MSVC doesn't like labels at
 560      end of block.  */
 561 }
 562
 563 unsigned int
 564 _bfd_xcoff_swap_aux_out (bfd *abfd, void * inp, int type, int in_class,
 565                          int indx ATTRIBUTE_UNUSED,
 566                          int numaux ATTRIBUTE_UNUSED,
 567                          void * extp)
 568 {
 569   union internal_auxent *in = (union internal_auxent *)inp;
 570   AUXENT *ext = (AUXENT *)extp;
 571
 572   memset (ext, 0, bfd_coff_auxesz (abfd));
 573   switch (in_class)
 574     {
 575     case C_FILE:
 576       if (in->x_file.x_fname[0] == 0)
 577         {
 578           H_PUT_32 (abfd, 0, ext->x_file.x_n.x_n.x_zeroes);
 579           H_PUT_32 (abfd, in->x_file.x_n.x_offset,
 580                     ext->x_file.x_n.x_n.x_offset);
 581         }
 582       else
 583         {
 584           memcpy (ext->x_file.x_n.x_fname, in->x_file.x_fname, FILNMLEN);
 585         }
 586       goto end;
 587
 588       /* RS/6000 "csect" auxents */
 589     case C_EXT:
 590     case C_AIX_WEAKEXT:
 591     case C_HIDEXT:
 592       if (indx + 1 == numaux)
 593         {
 594           H_PUT_32 (abfd, in->x_csect.x_scnlen.l, ext->x_csect.x_scnlen);
 595           H_PUT_32 (abfd, in->x_csect.x_parmhash, ext->x_csect.x_parmhash);
 596           H_PUT_16 (abfd, in->x_csect.x_snhash, ext->x_csect.x_snhash);
 597           /* We don't have to hack bitfields in x_smtyp because it's
 598              defined by shifts-and-ands, which are equivalent on all
 599              byte orders.  */
 600           H_PUT_8 (abfd, in->x_csect.x_smtyp, ext->x_csect.x_smtyp);
 601           H_PUT_8 (abfd, in->x_csect.x_smclas, ext->x_csect.x_smclas);
 602           H_PUT_32 (abfd, in->x_csect.x_stab, ext->x_csect.x_stab);
 603           H_PUT_16 (abfd, in->x_csect.x_snstab, ext->x_csect.x_snstab);
 604           goto end;
 605         }
 606       break;
 607
 608     case C_STAT:
 609     case C_LEAFSTAT:
 610     case C_HIDDEN:
 611       if (type == T_NULL)
 612         {
 613           H_PUT_32 (abfd, in->x_scn.x_scnlen, ext->x_scn.x_scnlen);
 614           H_PUT_16 (abfd, in->x_scn.x_nreloc, ext->x_scn.x_nreloc);
 615           H_PUT_16 (abfd, in->x_scn.x_nlinno, ext->x_scn.x_nlinno);
 616           goto end;
 617         }
 618       break;
 619     }
 620
 621   H_PUT_32 (abfd, in->x_sym.x_tagndx.l, ext->x_sym.x_tagndx);
 622   H_PUT_16 (abfd, in->x_sym.x_tvndx, ext->x_sym.x_tvndx);
 623
 624   if (in_class == C_BLOCK || in_class == C_FCN || ISFCN (type)
 625       || ISTAG (in_class))
 626     {
 627       H_PUT_32 (abfd, in->x_sym.x_fcnary.x_fcn.x_lnnoptr,
 628                 ext->x_sym.x_fcnary.x_fcn.x_lnnoptr);
 629       H_PUT_32 (abfd, in->x_sym.x_fcnary.x_fcn.x_endndx.l,
 630                 ext->x_sym.x_fcnary.x_fcn.x_endndx);
 631     }
 632   else
 633     {
 634       H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[0],
 635                 ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
 636       H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[1],
 637                 ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
 638       H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[2],
 639                 ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
 640       H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[3],
 641                 ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
 642     }
 643
 644   if (ISFCN (type))
 645     H_PUT_32 (abfd, in->x_sym.x_misc.x_fsize, ext->x_sym.x_misc.x_fsize);
 646   else
 647     {
 648       H_PUT_16 (abfd, in->x_sym.x_misc.x_lnsz.x_lnno,
 649                 ext->x_sym.x_misc.x_lnsz.x_lnno);
 650       H_PUT_16 (abfd, in->x_sym.x_misc.x_lnsz.x_size,
 651                 ext->x_sym.x_misc.x_lnsz.x_size);
 652     }
 653
 654 end:
 655   return bfd_coff_auxesz (abfd);
 656 }
 657
 658
 659 \f
 660 /* The XCOFF reloc table.  Actually, XCOFF relocations specify the
 661    bitsize and whether they are signed or not, along with a
 662    conventional type.  This table is for the types, which are used for
 663    different algorithms for putting in the reloc.  Many of these
 664    relocs need special_function entries, which I have not written.  */
 665
 666
 667 reloc_howto_type xcoff_howto_table[] =
 668 {
 669   /* 0x00: Standard 32 bit relocation.  */
 670   HOWTO (R_POS,                 /* type */
 671          0,                     /* rightshift */
 672          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 673          32,                    /* bitsize */
 674          FALSE,                 /* pc_relative */
 675          0,                     /* bitpos */
 676          complain_overflow_bitfield, /* complain_on_overflow */
 677          0,                     /* special_function */
 678          "R_POS",               /* name */
 679          TRUE,                  /* partial_inplace */
 680          0xffffffff,            /* src_mask */
 681          0xffffffff,            /* dst_mask */
 682          FALSE),                /* pcrel_offset */
 683
 684   /* 0x01: 32 bit relocation, but store negative value.  */
 685   HOWTO (R_NEG,                 /* type */
 686          0,                     /* rightshift */
 687          -2,                    /* size (0 = byte, 1 = short, 2 = long) */
 688          32,                    /* bitsize */
 689          FALSE,                 /* pc_relative */
 690          0,                     /* bitpos */
 691          complain_overflow_bitfield, /* complain_on_overflow */
 692          0,                     /* special_function */
 693          "R_NEG",               /* name */
 694          TRUE,                  /* partial_inplace */
 695          0xffffffff,            /* src_mask */
 696          0xffffffff,            /* dst_mask */
 697          FALSE),                /* pcrel_offset */
 698
 699   /* 0x02: 32 bit PC relative relocation.  */
 700   HOWTO (R_REL,                 /* type */
 701          0,                     /* rightshift */
 702          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 703          32,                    /* bitsize */
 704          TRUE,                  /* pc_relative */
 705          0,                     /* bitpos */
 706          complain_overflow_signed, /* complain_on_overflow */
 707          0,                     /* special_function */
 708          "R_REL",               /* name */
 709          TRUE,                  /* partial_inplace */
 710          0xffffffff,            /* src_mask */
 711          0xffffffff,            /* dst_mask */
 712          FALSE),                /* pcrel_offset */
 713
 714   /* 0x03: 16 bit TOC relative relocation.  */
 715   HOWTO (R_TOC,                 /* type */
 716          0,                     /* rightshift */
 717          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 718          16,                    /* bitsize */
 719          FALSE,                 /* pc_relative */
 720          0,                     /* bitpos */
 721          complain_overflow_bitfield, /* complain_on_overflow */
 722          0,                     /* special_function */
 723          "R_TOC",               /* name */
 724          TRUE,                  /* partial_inplace */
 725          0xffff,                /* src_mask */
 726          0xffff,                /* dst_mask */
 727          FALSE),                /* pcrel_offset */
 728
 729   /* 0x04: I don't really know what this is.  */
 730   HOWTO (R_RTB,                 /* type */
 731          1,                     /* rightshift */
 732          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 733          32,                    /* bitsize */
 734          FALSE,                 /* pc_relative */
 735          0,                     /* bitpos */
 736          complain_overflow_bitfield, /* complain_on_overflow */
 737          0,                     /* special_function */
 738          "R_RTB",               /* name */
 739          TRUE,                  /* partial_inplace */
 740          0xffffffff,            /* src_mask */
 741          0xffffffff,            /* dst_mask */
 742          FALSE),                /* pcrel_offset */
 743
 744   /* 0x05: External TOC relative symbol.  */
 745   HOWTO (R_GL,                  /* type */
 746          0,                     /* rightshift */
 747          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 748          16,                    /* bitsize */
 749          FALSE,                 /* pc_relative */
 750          0,                     /* bitpos */
 751          complain_overflow_bitfield, /* complain_on_overflow */
 752          0,                     /* special_function */
 753          "R_GL",                /* name */
 754          TRUE,                  /* partial_inplace */
 755          0xffff,                /* src_mask */
 756          0xffff,                /* dst_mask */
 757          FALSE),                /* pcrel_offset */
 758
 759   /* 0x06: Local TOC relative symbol.    */
 760   HOWTO (R_TCL,                 /* type */
 761          0,                     /* rightshift */
 762          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 763          16,                    /* bitsize */
 764          FALSE,                 /* pc_relative */
 765          0,                     /* bitpos */
 766          complain_overflow_bitfield, /* complain_on_overflow */
 767          0,                     /* special_function */
 768          "R_TCL",               /* name */
 769          TRUE,                  /* partial_inplace */
 770          0xffff,                /* src_mask */
 771          0xffff,                /* dst_mask */
 772          FALSE),                /* pcrel_offset */
 773
 774   EMPTY_HOWTO (7),
 775
 776   /* 0x08: Non modifiable absolute branch.  */
 777   HOWTO (R_BA,                  /* type */
 778          0,                     /* rightshift */
 779          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 780          26,                    /* bitsize */
 781          FALSE,                 /* pc_relative */
 782          0,                     /* bitpos */
 783          complain_overflow_bitfield, /* complain_on_overflow */
 784          0,                     /* special_function */
 785          "R_BA_26",             /* name */
 786          TRUE,                  /* partial_inplace */
 787          0x03fffffc,            /* src_mask */
 788          0x03fffffc,            /* dst_mask */
 789          FALSE),                /* pcrel_offset */
 790
 791   EMPTY_HOWTO (9),
 792
 793   /* 0x0a: Non modifiable relative branch.  */
 794   HOWTO (R_BR,                  /* type */
 795          0,                     /* rightshift */
 796          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 797          26,                    /* bitsize */
 798          TRUE,                  /* pc_relative */
 799          0,                     /* bitpos */
 800          complain_overflow_signed, /* complain_on_overflow */
 801          0,                     /* special_function */
 802          "R_BR",                /* name */
 803          TRUE,                  /* partial_inplace */
 804          0x03fffffc,            /* src_mask */
 805          0x03fffffc,            /* dst_mask */
 806          FALSE),                /* pcrel_offset */
 807
 808   EMPTY_HOWTO (0xb),
 809
 810   /* 0x0c: Indirect load.  */
 811   HOWTO (R_RL,                  /* type */
 812          0,                     /* rightshift */
 813          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 814          16,                    /* bitsize */
 815          FALSE,                 /* pc_relative */
 816          0,                     /* bitpos */
 817          complain_overflow_bitfield, /* complain_on_overflow */
 818          0,                     /* special_function */
 819          "R_RL",                /* name */
 820          TRUE,                  /* partial_inplace */
 821          0xffff,                /* src_mask */
 822          0xffff,                /* dst_mask */
 823          FALSE),                /* pcrel_offset */
 824
 825   /* 0x0d: Load address.  */
 826   HOWTO (R_RLA,                 /* type */
 827          0,                     /* rightshift */
 828          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 829          16,                    /* bitsize */
 830          FALSE,                 /* pc_relative */
 831          0,                     /* bitpos */
 832          complain_overflow_bitfield, /* complain_on_overflow */
 833          0,                     /* special_function */
 834          "R_RLA",               /* name */
 835          TRUE,                  /* partial_inplace */
 836          0xffff,                /* src_mask */
 837          0xffff,                /* dst_mask */
 838          FALSE),                /* pcrel_offset */
 839
 840   EMPTY_HOWTO (0xe),
 841
 842   /* 0x0f: Non-relocating reference.  Bitsize is 1 so that r_rsize is 0.  */
 843   HOWTO (R_REF,                 /* type */
 844          0,                     /* rightshift */
 845          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 846          1,                     /* bitsize */
 847          FALSE,                 /* pc_relative */
 848          0,                     /* bitpos */
 849          complain_overflow_dont, /* complain_on_overflow */
 850          0,                     /* special_function */
 851          "R_REF",               /* name */
 852          FALSE,                 /* partial_inplace */
 853          0,                     /* src_mask */
 854          0,                     /* dst_mask */
 855          FALSE),                /* pcrel_offset */
 856
 857   EMPTY_HOWTO (0x10),
 858   EMPTY_HOWTO (0x11),
 859
 860   /* 0x12: TOC relative indirect load.  */
 861   HOWTO (R_TRL,                 /* type */
 862          0,                     /* rightshift */
 863          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 864          16,                    /* bitsize */
 865          FALSE,                 /* pc_relative */
 866          0,                     /* bitpos */
 867          complain_overflow_bitfield, /* complain_on_overflow */
 868          0,                     /* special_function */
 869          "R_TRL",               /* name */
 870          TRUE,                  /* partial_inplace */
 871          0xffff,                /* src_mask */
 872          0xffff,                /* dst_mask */
 873          FALSE),                /* pcrel_offset */
 874
 875   /* 0x13: TOC relative load address.  */
 876   HOWTO (R_TRLA,                /* type */
 877          0,                     /* rightshift */
 878          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 879          16,                    /* bitsize */
 880          FALSE,                 /* pc_relative */
 881          0,                     /* bitpos */
 882          complain_overflow_bitfield, /* complain_on_overflow */
 883          0,                     /* special_function */
 884          "R_TRLA",              /* name */
 885          TRUE,                  /* partial_inplace */
 886          0xffff,                /* src_mask */
 887          0xffff,                /* dst_mask */
 888          FALSE),                /* pcrel_offset */
 889
 890   /* 0x14: Modifiable relative branch.  */
 891   HOWTO (R_RRTBI,                /* type */
 892          1,                     /* rightshift */
 893          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 894          32,                    /* bitsize */
 895          FALSE,                 /* pc_relative */
 896          0,                     /* bitpos */
 897          complain_overflow_bitfield, /* complain_on_overflow */
 898          0,                     /* special_function */
 899          "R_RRTBI",             /* name */
 900          TRUE,                  /* partial_inplace */
 901          0xffffffff,            /* src_mask */
 902          0xffffffff,            /* dst_mask */
 903          FALSE),                /* pcrel_offset */
 904
 905   /* 0x15: Modifiable absolute branch.  */
 906   HOWTO (R_RRTBA,                /* type */
 907          1,                     /* rightshift */
 908          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 909          32,                    /* bitsize */
 910          FALSE,                 /* pc_relative */
 911          0,                     /* bitpos */
 912          complain_overflow_bitfield, /* complain_on_overflow */
 913          0,                     /* special_function */
 914          "R_RRTBA",             /* name */
 915          TRUE,                  /* partial_inplace */
 916          0xffffffff,            /* src_mask */
 917          0xffffffff,            /* dst_mask */
 918          FALSE),                /* pcrel_offset */
 919
 920   /* 0x16: Modifiable call absolute indirect.  */
 921   HOWTO (R_CAI,                 /* type */
 922          0,                     /* rightshift */
 923          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 924          16,                    /* bitsize */
 925          FALSE,                 /* pc_relative */
 926          0,                     /* bitpos */
 927          complain_overflow_bitfield, /* complain_on_overflow */
 928          0,                     /* special_function */
 929          "R_CAI",               /* name */
 930          TRUE,                  /* partial_inplace */
 931          0xffff,                /* src_mask */
 932          0xffff,                /* dst_mask */
 933          FALSE),                /* pcrel_offset */
 934
 935   /* 0x17: Modifiable call relative.  */
 936   HOWTO (R_CREL,                /* type */
 937          0,                     /* rightshift */
 938          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 939          16,                    /* bitsize */
 940          FALSE,                 /* pc_relative */
 941          0,                     /* bitpos */
 942          complain_overflow_bitfield, /* complain_on_overflow */
 943          0,                     /* special_function */
 944          "R_CREL",              /* name */
 945          TRUE,                  /* partial_inplace */
 946          0xffff,                /* src_mask */
 947          0xffff,                /* dst_mask */
 948          FALSE),                /* pcrel_offset */
 949
 950   /* 0x18: Modifiable branch absolute.  */
 951   HOWTO (R_RBA,                 /* type */
 952          0,                     /* rightshift */
 953          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 954          26,                    /* bitsize */
 955          FALSE,                 /* pc_relative */
 956          0,                     /* bitpos */
 957          complain_overflow_bitfield, /* complain_on_overflow */
 958          0,                     /* special_function */
 959          "R_RBA",               /* name */
 960          TRUE,                  /* partial_inplace */
 961          0x03fffffc,            /* src_mask */
 962          0x03fffffc,            /* dst_mask */
 963          FALSE),                /* pcrel_offset */
 964
 965   /* 0x19: Modifiable branch absolute.  */
 966   HOWTO (R_RBAC,                /* type */
 967          0,                     /* rightshift */
 968          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 969          32,                    /* bitsize */
 970          FALSE,                 /* pc_relative */
 971          0,                     /* bitpos */
 972          complain_overflow_bitfield, /* complain_on_overflow */
 973          0,                     /* special_function */
 974          "R_RBAC",              /* name */
 975          TRUE,                  /* partial_inplace */
 976          0xffffffff,            /* src_mask */
 977          0xffffffff,            /* dst_mask */
 978          FALSE),                /* pcrel_offset */
 979
 980   /* 0x1a: Modifiable branch relative.  */
 981   HOWTO (R_RBR,                 /* type */
 982          0,                     /* rightshift */
 983          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 984          26,                    /* bitsize */
 985          FALSE,                 /* pc_relative */
 986          0,                     /* bitpos */
 987          complain_overflow_signed, /* complain_on_overflow */
 988          0,                     /* special_function */
 989          "R_RBR_26",            /* name */
 990          TRUE,                  /* partial_inplace */
 991          0x03fffffc,            /* src_mask */
 992          0x03fffffc,            /* dst_mask */
 993          FALSE),                /* pcrel_offset */
 994
 995   /* 0x1b: Modifiable branch absolute.  */
 996   HOWTO (R_RBRC,                /* type */
 997          0,                     /* rightshift */
 998          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 999          16,                    /* bitsize */
1000          FALSE,                 /* pc_relative */
1001          0,                     /* bitpos */
1002          complain_overflow_bitfield, /* complain_on_overflow */
1003          0,                     /* special_function */
1004          "R_RBRC",              /* name */
1005          TRUE,                  /* partial_inplace */
1006          0xffff,                /* src_mask */
1007          0xffff,                /* dst_mask */
1008          FALSE),                /* pcrel_offset */
1009
1010   /* 0x1c: 16 bit Non modifiable absolute branch.  */
1011   HOWTO (R_BA,                  /* type */
1012          0,                     /* rightshift */
1013          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1014          16,                    /* bitsize */
1015          FALSE,                 /* pc_relative */
1016          0,                     /* bitpos */
1017          complain_overflow_bitfield, /* complain_on_overflow */
1018          0,                     /* special_function */
1019          "R_BA_16",             /* name */
1020          TRUE,                  /* partial_inplace */
1021          0xfffc,                /* src_mask */
1022          0xfffc,                /* dst_mask */
1023          FALSE),                /* pcrel_offset */
1024
1025   /* 0x1d: Modifiable branch relative.  */
1026   HOWTO (R_RBR,                 /* type */
1027          0,                     /* rightshift */
1028          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1029          16,                    /* bitsize */
1030          TRUE,                  /* pc_relative */
1031          0,                     /* bitpos */
1032          complain_overflow_signed, /* complain_on_overflow */
1033          0,                     /* special_function */
1034          "R_RBR_16",            /* name */
1035          TRUE,                  /* partial_inplace */
1036          0xfffc,                /* src_mask */
1037          0xfffc,                /* dst_mask */
1038          FALSE),                /* pcrel_offset */
1039
1040   /* 0x1e: Modifiable branch relative.  */
1041   HOWTO (R_RBA,                 /* type */
1042          0,                     /* rightshift */
1043          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1044          16,                    /* bitsize */
1045          FALSE,                 /* pc_relative */
1046          0,                     /* bitpos */
1047          complain_overflow_signed, /* complain_on_overflow */
1048          0,                     /* special_function */
1049          "R_RBA_16",            /* name */
1050          TRUE,                  /* partial_inplace */
1051          0xffff,                /* src_mask */
1052          0xffff,                /* dst_mask */
1053          FALSE),                /* pcrel_offset */
1054 };
1055
1056 void
1057 xcoff_rtype2howto (arelent *relent, struct internal_reloc *internal)
1058 {
1059   if (internal->r_type > R_RBRC)
1060     abort ();
1061
1062   /* Default howto layout works most of the time */
1063   relent->howto = &xcoff_howto_table[internal->r_type];
1064
1065   /* Special case some 16 bit reloc */
1066   if (15 == (internal->r_size & 0x1f))
1067     {
1068       if (R_BA == internal->r_type)
1069         relent->howto = &xcoff_howto_table[0x1c];
1070       else if (R_RBR == internal->r_type)
1071         relent->howto = &xcoff_howto_table[0x1d];
1072       else if (R_RBA == internal->r_type)
1073         relent->howto = &xcoff_howto_table[0x1e];
1074     }
1075
1076   /* The r_size field of an XCOFF reloc encodes the bitsize of the
1077      relocation, as well as indicating whether it is signed or not.
1078      Doublecheck that the relocation information gathered from the
1079      type matches this information.  The bitsize is not significant
1080      for R_REF relocs.  */
1081   if (relent->howto->dst_mask != 0
1082       && (relent->howto->bitsize
1083           != ((unsigned int) internal->r_size & 0x1f) + 1))
1084     abort ();
1085 }
1086
1087 reloc_howto_type *
1088 _bfd_xcoff_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1089                               bfd_reloc_code_real_type code)
1090 {
1091   switch (code)
1092     {
1093     case BFD_RELOC_PPC_B26:
1094       return &xcoff_howto_table[0xa];
1095     case BFD_RELOC_PPC_BA16:
1096       return &xcoff_howto_table[0x1c];
1097     case BFD_RELOC_PPC_BA26:
1098       return &xcoff_howto_table[8];
1099     case BFD_RELOC_PPC_TOC16:
1100       return &xcoff_howto_table[3];
1101     case BFD_RELOC_16:
1102       /* Note that this relocation is only internally used by gas.  */
1103       return &xcoff_howto_table[0xc];
1104     case BFD_RELOC_PPC_B16:
1105       return &xcoff_howto_table[0x1d];
1106     case BFD_RELOC_32:
1107     case BFD_RELOC_CTOR:
1108       return &xcoff_howto_table[0];
1109     case BFD_RELOC_NONE:
1110       return &xcoff_howto_table[0xf];
1111     default:
1112       return NULL;
1113     }
1114 }
1115
1116 static reloc_howto_type *
1117 _bfd_xcoff_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1118                               const char *r_name)
1119 {
1120   unsigned int i;
1121
1122   for (i = 0;
1123        i < sizeof (xcoff_howto_table) / sizeof (xcoff_howto_table[0]);
1124        i++)
1125     if (xcoff_howto_table[i].name != NULL
1126         && strcasecmp (xcoff_howto_table[i].name, r_name) == 0)
1127       return &xcoff_howto_table[i];
1128
1129   return NULL;
1130 }
1131 \f
1132 /* XCOFF archive support.  The original version of this code was by
1133    Damon A. Permezel.  It was enhanced to permit cross support, and
1134    writing archive files, by Ian Lance Taylor, Cygnus Support.
1135
1136    XCOFF uses its own archive format.  Everything is hooked together
1137    with file offset links, so it is possible to rapidly update an
1138    archive in place.  Of course, we don't do that.  An XCOFF archive
1139    has a real file header, not just an ARMAG string.  The structure of
1140    the file header and of each archive header appear below.
1141
1142    An XCOFF archive also has a member table, which is a list of
1143    elements in the archive (you can get that by looking through the
1144    linked list, but you have to read a lot more of the file).  The
1145    member table has a normal archive header with an empty name.  It is
1146    normally (and perhaps must be) the second to last entry in the
1147    archive.  The member table data is almost printable ASCII.  It
1148    starts with a 12 character decimal string which is the number of
1149    entries in the table.  For each entry it has a 12 character decimal
1150    string which is the offset in the archive of that member.  These
1151    entries are followed by a series of null terminated strings which
1152    are the member names for each entry.
1153
1154    Finally, an XCOFF archive has a global symbol table, which is what
1155    we call the armap.  The global symbol table has a normal archive
1156    header with an empty name.  It is normally (and perhaps must be)
1157    the last entry in the archive.  The contents start with a four byte
1158    binary number which is the number of entries.  This is followed by
1159    a that many four byte binary numbers; each is the file offset of an
1160    entry in the archive.  These numbers are followed by a series of
1161    null terminated strings, which are symbol names.
1162
1163    AIX 4.3 introduced a new archive format which can handle larger
1164    files and also 32- and 64-bit objects in the same archive.  The
1165    things said above remain true except that there is now more than
1166    one global symbol table.  The one is used to index 32-bit objects,
1167    the other for 64-bit objects.
1168
1169    The new archives (recognizable by the new ARMAG string) has larger
1170    field lengths so that we cannot really share any code.  Also we have
1171    to take care that we are not generating the new form of archives
1172    on AIX 4.2 or earlier systems.  */
1173
1174 /* XCOFF archives use this as a magic string.  Note that both strings
1175    have the same length.  */
1176
1177 /* Set the magic for archive.  */
1178
1179 bfd_boolean
1180 bfd_xcoff_ar_archive_set_magic (bfd *abfd ATTRIBUTE_UNUSED,
1181                                 char *magic ATTRIBUTE_UNUSED)
1182 {
1183   /* Not supported yet.  */
1184   return FALSE;
1185  /* bfd_xcoff_archive_set_magic (abfd, magic); */
1186 }
1187
1188 /* Read in the armap of an XCOFF archive.  */
1189
1190 bfd_boolean
1191 _bfd_xcoff_slurp_armap (bfd *abfd)
1192 {
1193   file_ptr off;
1194   size_t namlen;
1195   bfd_size_type sz;
1196   bfd_byte *contents, *cend;
1197   bfd_vma c, i;
1198   carsym *arsym;
1199   bfd_byte *p;
1200
1201   if (xcoff_ardata (abfd) == NULL)
1202     {
1203       bfd_has_map (abfd) = FALSE;
1204       return TRUE;
1205     }
1206
1207   if (! xcoff_big_format_p (abfd))
1208     {
1209       /* This is for the old format.  */
1210       struct xcoff_ar_hdr hdr;
1211
1212       off = strtol (xcoff_ardata (abfd)->symoff, (char **) NULL, 10);
1213       if (off == 0)
1214         {
1215           bfd_has_map (abfd) = FALSE;
1216           return TRUE;
1217         }
1218
1219       if (bfd_seek (abfd, off, SEEK_SET) != 0)
1220         return FALSE;
1221
1222       /* The symbol table starts with a normal archive header.  */
1223       if (bfd_bread (&hdr, (bfd_size_type) SIZEOF_AR_HDR, abfd)
1224           != SIZEOF_AR_HDR)
1225         return FALSE;
1226
1227       /* Skip the name (normally empty).  */
1228       namlen = strtol (hdr.namlen, (char **) NULL, 10);
1229       off = ((namlen + 1) & ~ (size_t) 1) + SXCOFFARFMAG;
1230       if (bfd_seek (abfd, off, SEEK_CUR) != 0)
1231         return FALSE;
1232
1233       sz = strtol (hdr.size, (char **) NULL, 10);
1234
1235       /* Read in the entire symbol table.  */
1236       contents = (bfd_byte *) bfd_alloc (abfd, sz);
1237       if (contents == NULL)
1238         return FALSE;
1239       if (bfd_bread (contents, sz, abfd) != sz)
1240         return FALSE;
1241
1242       /* The symbol table starts with a four byte count.  */
1243       c = H_GET_32 (abfd, contents);
1244
1245       if (c * 4 >= sz)
1246         {
1247           bfd_set_error (bfd_error_bad_value);
1248           return FALSE;
1249         }
1250
1251       bfd_ardata (abfd)->symdefs =
1252         ((carsym *) bfd_alloc (abfd, c * sizeof (carsym)));
1253       if (bfd_ardata (abfd)->symdefs == NULL)
1254         return FALSE;
1255
1256       /* After the count comes a list of four byte file offsets.  */
1257       for (i = 0, arsym = bfd_ardata (abfd)->symdefs, p = contents + 4;
1258            i < c;
1259            ++i, ++arsym, p += 4)
1260         arsym->file_offset = H_GET_32 (abfd, p);
1261     }
1262   else
1263     {
1264       /* This is for the new format.  */
1265       struct xcoff_ar_hdr_big hdr;
1266
1267       off = strtol (xcoff_ardata_big (abfd)->symoff, (char **) NULL, 10);
1268       if (off == 0)
1269         {
1270           bfd_has_map (abfd) = FALSE;
1271           return TRUE;
1272         }
1273
1274       if (bfd_seek (abfd, off, SEEK_SET) != 0)
1275         return FALSE;
1276
1277       /* The symbol table starts with a normal archive header.  */
1278       if (bfd_bread (&hdr, (bfd_size_type) SIZEOF_AR_HDR_BIG, abfd)
1279           != SIZEOF_AR_HDR_BIG)
1280         return FALSE;
1281
1282       /* Skip the name (normally empty).  */
1283       namlen = strtol (hdr.namlen, (char **) NULL, 10);
1284       off = ((namlen + 1) & ~ (size_t) 1) + SXCOFFARFMAG;
1285       if (bfd_seek (abfd, off, SEEK_CUR) != 0)
1286         return FALSE;
1287
1288       /* XXX This actually has to be a call to strtoll (at least on 32-bit
1289          machines) since the field width is 20 and there numbers with more
1290          than 32 bits can be represented.  */
1291       sz = strtol (hdr.size, (char **) NULL, 10);
1292
1293       /* Read in the entire symbol table.  */
1294       contents = (bfd_byte *) bfd_alloc (abfd, sz);
1295       if (contents == NULL)
1296         return FALSE;
1297       if (bfd_bread (contents, sz, abfd) != sz)
1298         return FALSE;
1299
1300       /* The symbol table starts with an eight byte count.  */
1301       c = H_GET_64 (abfd, contents);
1302
1303       if (c * 8 >= sz)
1304         {
1305           bfd_set_error (bfd_error_bad_value);
1306           return FALSE;
1307         }
1308
1309       bfd_ardata (abfd)->symdefs =
1310         ((carsym *) bfd_alloc (abfd, c * sizeof (carsym)));
1311       if (bfd_ardata (abfd)->symdefs == NULL)
1312         return FALSE;
1313
1314       /* After the count comes a list of eight byte file offsets.  */
1315       for (i = 0, arsym = bfd_ardata (abfd)->symdefs, p = contents + 8;
1316            i < c;
1317            ++i, ++arsym, p += 8)
1318         arsym->file_offset = H_GET_64 (abfd, p);
1319     }
1320
1321   /* After the file offsets come null terminated symbol names.  */
1322   cend = contents + sz;
1323   for (i = 0, arsym = bfd_ardata (abfd)->symdefs;
1324        i < c;
1325        ++i, ++arsym, p += strlen ((char *) p) + 1)
1326     {
1327       if (p >= cend)
1328         {
1329           bfd_set_error (bfd_error_bad_value);
1330           return FALSE;
1331         }
1332       arsym->name = (char *) p;
1333     }
1334
1335   bfd_ardata (abfd)->symdef_count = c;
1336   bfd_has_map (abfd) = TRUE;
1337
1338   return TRUE;
1339 }
1340
1341 /* See if this is an XCOFF archive.  */
1342
1343 const bfd_target *
1344 _bfd_xcoff_archive_p (bfd *abfd)
1345 {
1346   struct artdata *tdata_hold;
1347   char magic[SXCOFFARMAG];
1348   bfd_size_type amt = SXCOFFARMAG;
1349
1350   if (bfd_bread (magic, amt, abfd) != amt)
1351     {
1352       if (bfd_get_error () != bfd_error_system_call)
1353         bfd_set_error (bfd_error_wrong_format);
1354       return NULL;
1355     }
1356
1357   if (strncmp (magic, XCOFFARMAG, SXCOFFARMAG) != 0
1358       && strncmp (magic, XCOFFARMAGBIG, SXCOFFARMAG) != 0)
1359     {
1360       bfd_set_error (bfd_error_wrong_format);
1361       return NULL;
1362     }
1363
1364   tdata_hold = bfd_ardata (abfd);
1365
1366   amt = sizeof (struct artdata);
1367   bfd_ardata (abfd) = (struct artdata *) bfd_zalloc (abfd, amt);
1368   if (bfd_ardata (abfd) == (struct artdata *) NULL)
1369     goto error_ret_restore;
1370
1371   /* Cleared by bfd_zalloc above.
1372      bfd_ardata (abfd)->cache = NULL;
1373      bfd_ardata (abfd)->archive_head = NULL;
1374      bfd_ardata (abfd)->symdefs = NULL;
1375      bfd_ardata (abfd)->extended_names = NULL;
1376      bfd_ardata (abfd)->extended_names_size = 0;  */
1377
1378   /* Now handle the two formats.  */
1379   if (magic[1] != 'b')
1380     {
1381       /* This is the old format.  */
1382       struct xcoff_ar_file_hdr hdr;
1383
1384       /* Copy over the magic string.  */
1385       memcpy (hdr.magic, magic, SXCOFFARMAG);
1386
1387       /* Now read the rest of the file header.  */
1388       amt = SIZEOF_AR_FILE_HDR - SXCOFFARMAG;
1389       if (bfd_bread (&hdr.memoff, amt, abfd) != amt)
1390         {
1391           if (bfd_get_error () != bfd_error_system_call)
1392             bfd_set_error (bfd_error_wrong_format);
1393           goto error_ret;
1394         }
1395
1396       bfd_ardata (abfd)->first_file_filepos = strtol (hdr.firstmemoff,
1397                                                       (char **) NULL, 10);
1398
1399       amt = SIZEOF_AR_FILE_HDR;
1400       bfd_ardata (abfd)->tdata = bfd_zalloc (abfd, amt);
1401       if (bfd_ardata (abfd)->tdata == NULL)
1402         goto error_ret;
1403
1404       memcpy (bfd_ardata (abfd)->tdata, &hdr, SIZEOF_AR_FILE_HDR);
1405     }
1406   else
1407     {
1408       /* This is the new format.  */
1409       struct xcoff_ar_file_hdr_big hdr;
1410
1411       /* Copy over the magic string.  */
1412       memcpy (hdr.magic, magic, SXCOFFARMAG);
1413
1414       /* Now read the rest of the file header.  */
1415       amt = SIZEOF_AR_FILE_HDR_BIG - SXCOFFARMAG;
1416       if (bfd_bread (&hdr.memoff, amt, abfd) != amt)
1417         {
1418           if (bfd_get_error () != bfd_error_system_call)
1419             bfd_set_error (bfd_error_wrong_format);
1420           goto error_ret;
1421         }
1422
1423       bfd_ardata (abfd)->first_file_filepos = bfd_scan_vma (hdr.firstmemoff,
1424                                                             (const char **) 0,
1425                                                             10);
1426
1427       amt = SIZEOF_AR_FILE_HDR_BIG;
1428       bfd_ardata (abfd)->tdata = bfd_zalloc (abfd, amt);
1429       if (bfd_ardata (abfd)->tdata == NULL)
1430         goto error_ret;
1431
1432       memcpy (bfd_ardata (abfd)->tdata, &hdr, SIZEOF_AR_FILE_HDR_BIG);
1433     }
1434
1435   if (! _bfd_xcoff_slurp_armap (abfd))
1436     {
1437     error_ret:
1438       bfd_release (abfd, bfd_ardata (abfd));
1439     error_ret_restore:
1440       bfd_ardata (abfd) = tdata_hold;
1441       return NULL;
1442     }
1443
1444   return abfd->xvec;
1445 }
1446
1447 /* Read the archive header in an XCOFF archive.  */
1448
1449 void *
1450 _bfd_xcoff_read_ar_hdr (bfd *abfd)
1451 {
1452   bfd_size_type namlen;
1453   struct areltdata *ret;
1454   bfd_size_type amt = sizeof (struct areltdata);
1455
1456   ret = (struct areltdata *) bfd_zmalloc (amt);
1457   if (ret == NULL)
1458     return NULL;
1459
1460   if (! xcoff_big_format_p (abfd))
1461     {
1462       struct xcoff_ar_hdr hdr;
1463       struct xcoff_ar_hdr *hdrp;
1464
1465       if (bfd_bread (&hdr, (bfd_size_type) SIZEOF_AR_HDR, abfd)
1466           != SIZEOF_AR_HDR)
1467         {
1468           free (ret);
1469           return NULL;
1470         }
1471
1472       namlen = strtol (hdr.namlen, (char **) NULL, 10);
1473       amt = SIZEOF_AR_HDR + namlen + 1;
1474       hdrp = (struct xcoff_ar_hdr *) bfd_alloc (abfd, amt);
1475       if (hdrp == NULL)
1476         {
1477           free (ret);
1478           return NULL;
1479         }
1480       memcpy (hdrp, &hdr, SIZEOF_AR_HDR);
1481       if (bfd_bread ((char *) hdrp + SIZEOF_AR_HDR, namlen, abfd) != namlen)
1482         {
1483           free (ret);
1484           return NULL;
1485         }
1486       ((char *) hdrp)[SIZEOF_AR_HDR + namlen] = '\0';
1487
1488       ret->arch_header = (char *) hdrp;
1489       ret->parsed_size = strtol (hdr.size, (char **) NULL, 10);
1490       ret->filename = (char *) hdrp + SIZEOF_AR_HDR;
1491     }
1492   else
1493     {
1494       struct xcoff_ar_hdr_big hdr;
1495       struct xcoff_ar_hdr_big *hdrp;
1496
1497       if (bfd_bread (&hdr, (bfd_size_type) SIZEOF_AR_HDR_BIG, abfd)
1498           != SIZEOF_AR_HDR_BIG)
1499         {
1500           free (ret);
1501           return NULL;
1502         }
1503
1504       namlen = strtol (hdr.namlen, (char **) NULL, 10);
1505       amt = SIZEOF_AR_HDR_BIG + namlen + 1;
1506       hdrp = (struct xcoff_ar_hdr_big *) bfd_alloc (abfd, amt);
1507       if (hdrp == NULL)
1508         {
1509           free (ret);
1510           return NULL;
1511         }
1512       memcpy (hdrp, &hdr, SIZEOF_AR_HDR_BIG);
1513       if (bfd_bread ((char *) hdrp + SIZEOF_AR_HDR_BIG, namlen, abfd) != namlen)
1514         {
1515           free (ret);
1516           return NULL;
1517         }
1518       ((char *) hdrp)[SIZEOF_AR_HDR_BIG + namlen] = '\0';
1519
1520       ret->arch_header = (char *) hdrp;
1521       /* XXX This actually has to be a call to strtoll (at least on 32-bit
1522          machines) since the field width is 20 and there numbers with more
1523          than 32 bits can be represented.  */
1524       ret->parsed_size = strtol (hdr.size, (char **) NULL, 10);
1525       ret->filename = (char *) hdrp + SIZEOF_AR_HDR_BIG;
1526     }
1527
1528   /* Skip over the XCOFFARFMAG at the end of the file name.  */
1529   if (bfd_seek (abfd, (file_ptr) ((namlen & 1) + SXCOFFARFMAG), SEEK_CUR) != 0)
1530     return NULL;
1531
1532   return ret;
1533 }
1534
1535 /* Open the next element in an XCOFF archive.  */
1536
1537 bfd *
1538 _bfd_xcoff_openr_next_archived_file (bfd *archive, bfd *last_file)
1539 {
1540   file_ptr filestart;
1541
1542   if (xcoff_ardata (archive) == NULL)
1543     {
1544       bfd_set_error (bfd_error_invalid_operation);
1545       return NULL;
1546     }
1547
1548   if (! xcoff_big_format_p (archive))
1549     {
1550       if (last_file == NULL)
1551         filestart = bfd_ardata (archive)->first_file_filepos;
1552       else
1553         filestart = strtol (arch_xhdr (last_file)->nextoff, (char **) NULL,
1554                             10);
1555
1556       if (filestart == 0
1557           || filestart == strtol (xcoff_ardata (archive)->memoff,
1558                                   (char **) NULL, 10)
1559           || filestart == strtol (xcoff_ardata (archive)->symoff,
1560                                   (char **) NULL, 10))
1561         {
1562           bfd_set_error (bfd_error_no_more_archived_files);
1563           return NULL;
1564         }
1565     }
1566   else
1567     {
1568       if (last_file == NULL)
1569         filestart = bfd_ardata (archive)->first_file_filepos;
1570       else
1571         /* XXX These actually have to be a calls to strtoll (at least
1572            on 32-bit machines) since the fields's width is 20 and
1573            there numbers with more than 32 bits can be represented.  */
1574         filestart = strtol (arch_xhdr_big (last_file)->nextoff, (char **) NULL,
1575                             10);
1576
1577       /* XXX These actually have to be calls to strtoll (at least on 32-bit
1578          machines) since the fields's width is 20 and there numbers with more
1579          than 32 bits can be represented.  */
1580       if (filestart == 0
1581           || filestart == strtol (xcoff_ardata_big (archive)->memoff,
1582                                   (char **) NULL, 10)
1583           || filestart == strtol (xcoff_ardata_big (archive)->symoff,
1584                                   (char **) NULL, 10))
1585         {
1586           bfd_set_error (bfd_error_no_more_archived_files);
1587           return NULL;
1588         }
1589     }
1590
1591   return _bfd_get_elt_at_filepos (archive, filestart);
1592 }
1593
1594 /* Stat an element in an XCOFF archive.  */
1595
1596 int
1597 _bfd_xcoff_stat_arch_elt (bfd *abfd, struct stat *s)
1598 {
1599   if (abfd->arelt_data == NULL)
1600     {
1601       bfd_set_error (bfd_error_invalid_operation);
1602       return -1;
1603     }
1604
1605   if (! xcoff_big_format_p (abfd->my_archive))
1606     {
1607       struct xcoff_ar_hdr *hdrp = arch_xhdr (abfd);
1608
1609       s->st_mtime = strtol (hdrp->date, (char **) NULL, 10);
1610       s->st_uid = strtol (hdrp->uid, (char **) NULL, 10);
1611       s->st_gid = strtol (hdrp->gid, (char **) NULL, 10);
1612       s->st_mode = strtol (hdrp->mode, (char **) NULL, 8);
1613       s->st_size = arch_eltdata (abfd)->parsed_size;
1614     }
1615   else
1616     {
1617       struct xcoff_ar_hdr_big *hdrp = arch_xhdr_big (abfd);
1618
1619       s->st_mtime = strtol (hdrp->date, (char **) NULL, 10);
1620       s->st_uid = strtol (hdrp->uid, (char **) NULL, 10);
1621       s->st_gid = strtol (hdrp->gid, (char **) NULL, 10);
1622       s->st_mode = strtol (hdrp->mode, (char **) NULL, 8);
1623       s->st_size = arch_eltdata (abfd)->parsed_size;
1624     }
1625
1626   return 0;
1627 }
1628
1629 /* Normalize a file name for inclusion in an archive.  */
1630
1631 static const char *
1632 normalize_filename (bfd *abfd)
1633 {
1634   const char *file;
1635   const char *filename;
1636
1637   file = bfd_get_filename (abfd);
1638   filename = strrchr (file, '/');
1639   if (filename != NULL)
1640     filename++;
1641   else
1642     filename = file;
1643   return filename;
1644 }
1645
1646 /* Write out an XCOFF armap.  */
1647
1648 static bfd_boolean
1649 xcoff_write_armap_old (bfd *abfd, unsigned int elength ATTRIBUTE_UNUSED,
1650                        struct orl *map, unsigned int orl_count, int stridx)
1651 {
1652   struct archive_iterator iterator;
1653   struct xcoff_ar_hdr hdr;
1654   char *p;
1655   unsigned char buf[4];
1656   unsigned int i;
1657
1658   memset (&hdr, 0, sizeof hdr);
1659   sprintf (hdr.size, "%ld", (long) (4 + orl_count * 4 + stridx));
1660   sprintf (hdr.nextoff, "%d", 0);
1661   memcpy (hdr.prevoff, xcoff_ardata (abfd)->memoff, XCOFFARMAG_ELEMENT_SIZE);
1662   sprintf (hdr.date, "%d", 0);
1663   sprintf (hdr.uid, "%d", 0);
1664   sprintf (hdr.gid, "%d", 0);
1665   sprintf (hdr.mode, "%d", 0);
1666   sprintf (hdr.namlen, "%d", 0);
1667
1668   /* We need spaces, not null bytes, in the header.  */
1669   for (p = (char *) &hdr; p < (char *) &hdr + SIZEOF_AR_HDR; p++)
1670     if (*p == '\0')
1671       *p = ' ';
1672
1673   if (bfd_bwrite (&hdr, (bfd_size_type) SIZEOF_AR_HDR, abfd)
1674       != SIZEOF_AR_HDR
1675       || (bfd_bwrite (XCOFFARFMAG, (bfd_size_type) SXCOFFARFMAG, abfd)
1676           != SXCOFFARFMAG))
1677     return FALSE;
1678
1679   H_PUT_32 (abfd, orl_count, buf);
1680   if (bfd_bwrite (buf, (bfd_size_type) 4, abfd) != 4)
1681     return FALSE;
1682
1683   i = 0;
1684   archive_iterator_begin (&iterator, abfd);
1685   while (i < orl_count && archive_iterator_next (&iterator))
1686     while (map[i].u.abfd == iterator.current.member)
1687       {
1688         H_PUT_32 (abfd, iterator.current.offset, buf);
1689         if (bfd_bwrite (buf, (bfd_size_type) 4, abfd) != 4)
1690           return FALSE;
1691         ++i;
1692       }
1693
1694   for (i = 0; i < orl_count; i++)
1695     {
1696       const char *name;
1697       size_t namlen;
1698
1699       name = *map[i].name;
1700       namlen = strlen (name);
1701       if (bfd_bwrite (name, (bfd_size_type) (namlen + 1), abfd) != namlen + 1)
1702         return FALSE;
1703     }
1704
1705   if ((stridx & 1) != 0)
1706     {
1707       char b;
1708
1709       b = '\0';
1710       if (bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1)
1711         return FALSE;
1712     }
1713
1714   return TRUE;
1715 }
1716
1717 static char buff20[XCOFFARMAGBIG_ELEMENT_SIZE + 1];
1718 #define FMT20  "%-20lld"
1719 #define FMT12  "%-12d"
1720 #define FMT12_OCTAL  "%-12o"
1721 #define FMT4  "%-4d"
1722 #define PRINT20(d, v) \
1723   sprintf (buff20, FMT20, (long long)(v)), \
1724   memcpy ((void *) (d), buff20, 20)
1725
1726 #define PRINT12(d, v) \
1727   sprintf (buff20, FMT12, (int)(v)), \
1728   memcpy ((void *) (d), buff20, 12)
1729
1730 #define PRINT12_OCTAL(d, v) \
1731   sprintf (buff20, FMT12_OCTAL, (unsigned int)(v)), \
1732   memcpy ((void *) (d), buff20, 12)
1733
1734 #define PRINT4(d, v) \
1735   sprintf (buff20, FMT4, (int)(v)), \
1736   memcpy ((void *) (d), buff20, 4)
1737
1738 #define READ20(d, v) \
1739   buff20[20] = 0, \
1740   memcpy (buff20, (d), 20), \
1741   (v) = bfd_scan_vma (buff20, (const char **) NULL, 10)
1742
1743 static bfd_boolean
1744 do_pad (bfd *abfd, unsigned int number)
1745 {
1746   bfd_byte b = 0;
1747
1748   /* Limit pad to <= 4096.  */
1749   if (number > 4096)
1750     return FALSE;
1751
1752   while (number--)
1753     if (bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1)
1754       return FALSE;
1755
1756   return TRUE;
1757 }
1758
1759 static bfd_boolean
1760 do_copy (bfd *out_bfd, bfd *in_bfd)
1761 {
1762   bfd_size_type remaining;
1763   bfd_byte buffer[DEFAULT_BUFFERSIZE];
1764
1765   if (bfd_seek (in_bfd, (file_ptr) 0, SEEK_SET) != 0)
1766     return FALSE;
1767
1768   remaining = arelt_size (in_bfd);
1769
1770   while (remaining >= DEFAULT_BUFFERSIZE)
1771     {
1772       if (bfd_bread (buffer, DEFAULT_BUFFERSIZE, in_bfd) != DEFAULT_BUFFERSIZE
1773           || bfd_bwrite (buffer, DEFAULT_BUFFERSIZE, out_bfd) != DEFAULT_BUFFERSIZE)
1774         return FALSE;
1775
1776       remaining -= DEFAULT_BUFFERSIZE;
1777     }
1778
1779   if (remaining)
1780     {
1781       if (bfd_bread (buffer, remaining, in_bfd) != remaining
1782           || bfd_bwrite (buffer, remaining, out_bfd) != remaining)
1783         return FALSE;
1784     }
1785
1786   return TRUE;
1787 }
1788
1789 static bfd_boolean
1790 xcoff_write_armap_big (bfd *abfd, unsigned int elength ATTRIBUTE_UNUSED,
1791                        struct orl *map, unsigned int orl_count, int stridx)
1792 {
1793   struct archive_iterator iterator;
1794   struct xcoff_ar_file_hdr_big *fhdr;
1795   bfd_vma i, sym_32, sym_64, str_32, str_64;
1796   const bfd_arch_info_type *arch_info;
1797   bfd *current_bfd;
1798   size_t string_length;
1799   file_ptr nextoff, prevoff;
1800
1801   /* First, we look through the symbols and work out which are
1802      from 32-bit objects and which from 64-bit ones.  */
1803   sym_32 = sym_64 = str_32 = str_64 = 0;
1804
1805   i = 0;
1806   for (current_bfd = abfd->archive_head;
1807        current_bfd != NULL && i < orl_count;
1808        current_bfd = current_bfd->archive_next)
1809     {
1810       arch_info = bfd_get_arch_info (current_bfd);
1811       while (map[i].u.abfd == current_bfd)
1812         {
1813           string_length = strlen (*map[i].name) + 1;
1814           if (arch_info->bits_per_address == 64)
1815             {
1816               sym_64++;
1817               str_64 += string_length;
1818             }
1819           else
1820             {
1821               sym_32++;
1822               str_32 += string_length;
1823             }
1824           i++;
1825         }
1826     }
1827
1828   /* A quick sanity check... */
1829   BFD_ASSERT (sym_64 + sym_32 == orl_count);
1830   /* Explicit cast to int for compiler.  */
1831   BFD_ASSERT ((int)(str_64 + str_32) == stridx);
1832
1833   fhdr = xcoff_ardata_big (abfd);
1834
1835   /* xcoff_write_archive_contents_big passes nextoff in symoff. */
1836   READ20 (fhdr->memoff, prevoff);
1837   READ20 (fhdr->symoff, nextoff);
1838
1839   BFD_ASSERT (nextoff == bfd_tell (abfd));
1840
1841   /* Write out the symbol table.
1842      Layout :
1843
1844      standard big archive header
1845      0x0000                   ar_size   [0x14]
1846      0x0014                   ar_nxtmem [0x14]
1847      0x0028                   ar_prvmem [0x14]
1848      0x003C                   ar_date   [0x0C]
1849      0x0048                   ar_uid    [0x0C]
1850      0x0054                   ar_gid    [0x0C]
1851      0x0060                   ar_mod    [0x0C]
1852      0x006C                   ar_namelen[0x04]
1853      0x0070                   ar_fmag   [SXCOFFARFMAG]
1854
1855      Symbol table
1856      0x0072                   num_syms  [0x08], binary
1857      0x0078                   offsets   [0x08 * num_syms], binary
1858      0x0086 + 0x08 * num_syms names     [??]
1859      ??                       pad to even bytes.
1860   */
1861
1862   if (sym_32)
1863     {
1864       struct xcoff_ar_hdr_big *hdr;
1865       char *symbol_table;
1866       char *st;
1867
1868       bfd_vma symbol_table_size =
1869         SIZEOF_AR_HDR_BIG
1870         + SXCOFFARFMAG
1871         + 8
1872         + 8 * sym_32
1873         + str_32 + (str_32 & 1);
1874
1875       symbol_table = bfd_zmalloc (symbol_table_size);
1876       if (symbol_table == NULL)
1877         return FALSE;
1878
1879       hdr = (struct xcoff_ar_hdr_big *) symbol_table;
1880
1881       PRINT20 (hdr->size, 8 + 8 * sym_32 + str_32 + (str_32 & 1));
1882
1883       if (sym_64)
1884         PRINT20 (hdr->nextoff, nextoff + symbol_table_size);
1885       else
1886         PRINT20 (hdr->nextoff, 0);
1887
1888       PRINT20 (hdr->prevoff, prevoff);
1889       PRINT12 (hdr->date, 0);
1890       PRINT12 (hdr->uid, 0);
1891       PRINT12 (hdr->gid, 0);
1892       PRINT12 (hdr->mode, 0);
1893       PRINT4 (hdr->namlen, 0) ;
1894
1895       st = symbol_table + SIZEOF_AR_HDR_BIG;
1896       memcpy (st, XCOFFARFMAG, SXCOFFARFMAG);
1897       st += SXCOFFARFMAG;
1898
1899       bfd_h_put_64 (abfd, sym_32, st);
1900       st += 8;
1901
1902       /* loop over the 32 bit offsets */
1903       i = 0;
1904       archive_iterator_begin (&iterator, abfd);
1905       while (i < orl_count && archive_iterator_next (&iterator))
1906         {
1907           arch_info = bfd_get_arch_info (iterator.current.member);
1908           while (map[i].u.abfd == iterator.current.member)
1909             {
1910               if (arch_info->bits_per_address == 32)
1911                 {
1912                   bfd_h_put_64 (abfd, iterator.current.offset, st);
1913                   st += 8;
1914                 }
1915               i++;
1916             }
1917         }
1918
1919       /* loop over the 32 bit symbol names */
1920       i = 0;
1921       for (current_bfd = abfd->archive_head;
1922            current_bfd != NULL && i < orl_count;
1923            current_bfd = current_bfd->archive_next)
1924         {
1925           arch_info = bfd_get_arch_info (current_bfd);
1926           while (map[i].u.abfd == current_bfd)
1927             {
1928               if (arch_info->bits_per_address == 32)
1929                 {
1930                   string_length = sprintf (st, "%s", *map[i].name);
1931                   st += string_length + 1;
1932                 }
1933               i++;
1934             }
1935         }
1936
1937       bfd_bwrite (symbol_table, symbol_table_size, abfd);
1938
1939       free (symbol_table);
1940
1941       prevoff = nextoff;
1942       nextoff = nextoff + symbol_table_size;
1943     }
1944   else
1945     PRINT20 (fhdr->symoff, 0);
1946
1947   if (sym_64)
1948     {
1949       struct xcoff_ar_hdr_big *hdr;
1950       char *symbol_table;
1951       char *st;
1952
1953       bfd_vma symbol_table_size =
1954         SIZEOF_AR_HDR_BIG
1955         + SXCOFFARFMAG
1956         + 8
1957         + 8 * sym_64
1958         + str_64 + (str_64 & 1);
1959
1960       symbol_table = bfd_zmalloc (symbol_table_size);
1961       if (symbol_table == NULL)
1962         return FALSE;
1963
1964       hdr = (struct xcoff_ar_hdr_big *) symbol_table;
1965
1966       PRINT20 (hdr->size, 8 + 8 * sym_64 + str_64 + (str_64 & 1));
1967       PRINT20 (hdr->nextoff, 0);
1968       PRINT20 (hdr->prevoff, prevoff);
1969       PRINT12 (hdr->date, 0);
1970       PRINT12 (hdr->uid, 0);
1971       PRINT12 (hdr->gid, 0);
1972       PRINT12 (hdr->mode, 0);
1973       PRINT4 (hdr->namlen, 0);
1974
1975       st = symbol_table + SIZEOF_AR_HDR_BIG;
1976       memcpy (st, XCOFFARFMAG, SXCOFFARFMAG);
1977       st += SXCOFFARFMAG;
1978
1979       bfd_h_put_64 (abfd, sym_64, st);
1980       st += 8;
1981
1982       /* loop over the 64 bit offsets */
1983       i = 0;
1984       archive_iterator_begin (&iterator, abfd);
1985       while (i < orl_count && archive_iterator_next (&iterator))
1986         {
1987           arch_info = bfd_get_arch_info (iterator.current.member);
1988           while (map[i].u.abfd == iterator.current.member)
1989             {
1990               if (arch_info->bits_per_address == 64)
1991                 {
1992                   bfd_h_put_64 (abfd, iterator.current.offset, st);
1993                   st += 8;
1994                 }
1995               i++;
1996             }
1997         }
1998
1999       /* loop over the 64 bit symbol names */
2000       i = 0;
2001       for (current_bfd = abfd->archive_head;
2002            current_bfd != NULL && i < orl_count;
2003            current_bfd = current_bfd->archive_next)
2004         {
2005           arch_info = bfd_get_arch_info (current_bfd);
2006           while (map[i].u.abfd == current_bfd)
2007             {
2008               if (arch_info->bits_per_address == 64)
2009                 {
2010                   string_length = sprintf (st, "%s", *map[i].name);
2011                   st += string_length + 1;
2012                 }
2013               i++;
2014             }
2015         }
2016
2017       bfd_bwrite (symbol_table, symbol_table_size, abfd);
2018
2019       free (symbol_table);
2020
2021       PRINT20 (fhdr->symoff64, nextoff);
2022     }
2023   else
2024     PRINT20 (fhdr->symoff64, 0);
2025
2026   return TRUE;
2027 }
2028
2029 bfd_boolean
2030 _bfd_xcoff_write_armap (bfd *abfd, unsigned int elength ATTRIBUTE_UNUSED,
2031                         struct orl *map, unsigned int orl_count, int stridx)
2032 {
2033   if (! xcoff_big_format_p (abfd))
2034     return xcoff_write_armap_old (abfd, elength, map, orl_count, stridx);
2035   else
2036     return xcoff_write_armap_big (abfd, elength, map, orl_count, stridx);
2037 }
2038
2039 /* Write out an XCOFF archive.  We always write an entire archive,
2040    rather than fussing with the freelist and so forth.  */
2041
2042 static bfd_boolean
2043 xcoff_write_archive_contents_old (bfd *abfd)
2044 {
2045   struct archive_iterator iterator;
2046   struct xcoff_ar_file_hdr fhdr;
2047   bfd_size_type count;
2048   bfd_size_type total_namlen;
2049   file_ptr *offsets;
2050   bfd_boolean makemap;
2051   bfd_boolean hasobjects;
2052   file_ptr prevoff, nextoff;
2053   bfd *sub;
2054   size_t i;
2055   struct xcoff_ar_hdr ahdr;
2056   bfd_size_type size;
2057   char *p;
2058   char decbuf[XCOFFARMAG_ELEMENT_SIZE + 1];
2059
2060   memset (&fhdr, 0, sizeof fhdr);
2061   (void) strncpy (fhdr.magic, XCOFFARMAG, SXCOFFARMAG);
2062   sprintf (fhdr.firstmemoff, "%d", SIZEOF_AR_FILE_HDR);
2063   sprintf (fhdr.freeoff, "%d", 0);
2064
2065   count = 0;
2066   total_namlen = 0;
2067   for (sub = abfd->archive_head; sub != NULL; sub = sub->archive_next)
2068     {
2069       ++count;
2070       total_namlen += strlen (normalize_filename (sub)) + 1;
2071       if (sub->arelt_data == NULL)
2072         {
2073           sub->arelt_data = bfd_zmalloc (sizeof (struct areltdata));
2074           if (sub->arelt_data == NULL)
2075             return FALSE;
2076         }
2077       if (arch_xhdr (sub) == NULL)
2078         {
2079           struct xcoff_ar_hdr *ahdrp;
2080           struct stat s;
2081
2082           if (stat (bfd_get_filename (sub), &s) != 0)
2083             {
2084               bfd_set_error (bfd_error_system_call);
2085               return FALSE;
2086             }
2087
2088           ahdrp = bfd_zalloc (sub, sizeof (*ahdrp));
2089           if (ahdrp == NULL)
2090             return FALSE;
2091
2092           sprintf (ahdrp->size, "%ld", (long) s.st_size);
2093           sprintf (ahdrp->date, "%ld", (long) s.st_mtime);
2094           sprintf (ahdrp->uid, "%ld", (long) s.st_uid);
2095           sprintf (ahdrp->gid, "%ld", (long) s.st_gid);
2096           sprintf (ahdrp->mode, "%o", (unsigned int) s.st_mode);
2097
2098           arch_eltdata (sub)->arch_header = (char *) ahdrp;
2099           arch_eltdata (sub)->parsed_size = s.st_size;
2100         }
2101     }
2102   offsets = (file_ptr *) bfd_alloc (abfd, count * sizeof (file_ptr));
2103   if (offsets == NULL)
2104     return FALSE;
2105
2106   if (bfd_seek (abfd, (file_ptr) SIZEOF_AR_FILE_HDR, SEEK_SET) != 0)
2107     return FALSE;
2108
2109   makemap = bfd_has_map (abfd);
2110   hasobjects = FALSE;
2111   prevoff = 0;
2112   for (archive_iterator_begin (&iterator, abfd), i = 0;
2113        archive_iterator_next (&iterator);
2114        i++)
2115     {
2116       bfd_size_type namlen;
2117       struct xcoff_ar_hdr *ahdrp;
2118
2119       if (makemap && ! hasobjects)
2120         {
2121           if (bfd_check_format (iterator.current.member, bfd_object))
2122             hasobjects = TRUE;
2123         }
2124
2125       ahdrp = arch_xhdr (iterator.current.member);
2126       sprintf (ahdrp->prevoff, "%ld", (long) prevoff);
2127       sprintf (ahdrp->namlen, "%ld", (long) iterator.current.namlen);
2128       sprintf (ahdrp->nextoff, "%ld", (long) iterator.next.offset);
2129
2130       /* We need spaces, not null bytes, in the header.  */
2131       for (p = (char *) ahdrp; p < (char *) ahdrp + SIZEOF_AR_HDR; p++)
2132         if (*p == '\0')
2133           *p = ' ';
2134
2135       if (!do_pad (abfd, iterator.current.leading_padding))
2136         return FALSE;
2137
2138       BFD_ASSERT (iterator.current.offset == bfd_tell (abfd));
2139       namlen = iterator.current.padded_namlen;
2140       if (bfd_bwrite (ahdrp, SIZEOF_AR_HDR, abfd) != SIZEOF_AR_HDR
2141           || bfd_bwrite (iterator.current.name, namlen, abfd) != namlen
2142           || bfd_bwrite (XCOFFARFMAG, SXCOFFARFMAG, abfd) != SXCOFFARFMAG
2143           || bfd_seek (iterator.current.member, 0, SEEK_SET) != 0
2144           || !do_copy (abfd, iterator.current.member)
2145           || !do_pad (abfd, iterator.current.trailing_padding))
2146         return FALSE;
2147
2148       offsets[i] = iterator.current.offset;
2149       prevoff = iterator.current.offset;
2150     }
2151
2152   sprintf (fhdr.lastmemoff, "%ld", (long) prevoff);
2153
2154   /* Write out the member table.  */
2155
2156   nextoff = iterator.next.offset;
2157   BFD_ASSERT (nextoff == bfd_tell (abfd));
2158   sprintf (fhdr.memoff, "%ld", (long) nextoff);
2159
2160   memset (&ahdr, 0, sizeof ahdr);
2161   sprintf (ahdr.size, "%ld", (long) (XCOFFARMAG_ELEMENT_SIZE
2162                                      + count * XCOFFARMAG_ELEMENT_SIZE
2163                                      + total_namlen));
2164   sprintf (ahdr.prevoff, "%ld", (long) prevoff);
2165   sprintf (ahdr.date, "%d", 0);
2166   sprintf (ahdr.uid, "%d", 0);
2167   sprintf (ahdr.gid, "%d", 0);
2168   sprintf (ahdr.mode, "%d", 0);
2169   sprintf (ahdr.namlen, "%d", 0);
2170
2171   size = (SIZEOF_AR_HDR
2172           + XCOFFARMAG_ELEMENT_SIZE
2173           + count * XCOFFARMAG_ELEMENT_SIZE
2174           + total_namlen
2175           + SXCOFFARFMAG);
2176
2177   prevoff = nextoff;
2178   nextoff += size + (size & 1);
2179
2180   if (makemap && hasobjects)
2181     sprintf (ahdr.nextoff, "%ld", (long) nextoff);
2182   else
2183     sprintf (ahdr.nextoff, "%d", 0);
2184
2185   /* We need spaces, not null bytes, in the header.  */
2186   for (p = (char *) &ahdr; p < (char *) &ahdr + SIZEOF_AR_HDR; p++)
2187     if (*p == '\0')
2188       *p = ' ';
2189
2190   if ((bfd_bwrite (&ahdr, (bfd_size_type) SIZEOF_AR_HDR, abfd)
2191        != SIZEOF_AR_HDR)
2192       || (bfd_bwrite (XCOFFARFMAG, (bfd_size_type) SXCOFFARFMAG, abfd)
2193           != SXCOFFARFMAG))
2194     return FALSE;
2195
2196   sprintf (decbuf, "%-12ld", (long) count);
2197   if (bfd_bwrite (decbuf, (bfd_size_type) XCOFFARMAG_ELEMENT_SIZE, abfd)
2198       != XCOFFARMAG_ELEMENT_SIZE)
2199     return FALSE;
2200   for (i = 0; i < (size_t) count; i++)
2201     {
2202       sprintf (decbuf, "%-12ld", (long) offsets[i]);
2203       if (bfd_bwrite (decbuf, (bfd_size_type) XCOFFARMAG_ELEMENT_SIZE,
2204                       abfd) != XCOFFARMAG_ELEMENT_SIZE)
2205         return FALSE;
2206     }
2207   for (sub = abfd->archive_head; sub != NULL; sub = sub->archive_next)
2208     {
2209       const char *name;
2210       bfd_size_type namlen;
2211
2212       name = normalize_filename (sub);
2213       namlen = strlen (name);
2214       if (bfd_bwrite (name, namlen + 1, abfd) != namlen + 1)
2215         return FALSE;
2216     }
2217
2218   if (! do_pad (abfd, size & 1))
2219     return FALSE;
2220
2221   /* Write out the armap, if appropriate.  */
2222   if (! makemap || ! hasobjects)
2223     sprintf (fhdr.symoff, "%d", 0);
2224   else
2225     {
2226       BFD_ASSERT (nextoff == bfd_tell (abfd));
2227       sprintf (fhdr.symoff, "%ld", (long) nextoff);
2228       bfd_ardata (abfd)->tdata = &fhdr;
2229       if (! _bfd_compute_and_write_armap (abfd, 0))
2230         return FALSE;
2231     }
2232
2233   /* Write out the archive file header.  */
2234
2235   /* We need spaces, not null bytes, in the header.  */
2236   for (p = (char *) &fhdr; p < (char *) &fhdr + SIZEOF_AR_FILE_HDR; p++)
2237     if (*p == '\0')
2238       *p = ' ';
2239
2240   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
2241       || (bfd_bwrite (&fhdr, (bfd_size_type) SIZEOF_AR_FILE_HDR, abfd)
2242           != SIZEOF_AR_FILE_HDR))
2243     return FALSE;
2244
2245   return TRUE;
2246 }
2247
2248 static bfd_boolean
2249 xcoff_write_archive_contents_big (bfd *abfd)
2250 {
2251   struct xcoff_ar_file_hdr_big fhdr;
2252   bfd_size_type count;
2253   bfd_size_type total_namlen;
2254   file_ptr *offsets;
2255   bfd_boolean makemap;
2256   bfd_boolean hasobjects;
2257   file_ptr prevoff, nextoff;
2258   bfd *current_bfd;
2259   size_t i;
2260   struct xcoff_ar_hdr_big *hdr;
2261   bfd_size_type size;
2262   char *member_table, *mt;
2263   bfd_vma member_table_size;
2264   struct archive_iterator iterator;
2265
2266   memset (&fhdr, 0, SIZEOF_AR_FILE_HDR_BIG);
2267   memcpy (fhdr.magic, XCOFFARMAGBIG, SXCOFFARMAG);
2268
2269   if (bfd_seek (abfd, (file_ptr) SIZEOF_AR_FILE_HDR_BIG, SEEK_SET) != 0)
2270     return FALSE;
2271
2272   /* Calculate count and total_namlen.  */
2273   makemap = bfd_has_map (abfd);
2274   hasobjects = FALSE;
2275   for (current_bfd = abfd->archive_head, count = 0, total_namlen = 0;
2276        current_bfd != NULL;
2277        current_bfd = current_bfd->archive_next, count++)
2278     {
2279       total_namlen += strlen (normalize_filename (current_bfd)) + 1;
2280
2281       if (makemap
2282           && ! hasobjects
2283           && bfd_check_format (current_bfd, bfd_object))
2284         hasobjects = TRUE;
2285
2286       if (current_bfd->arelt_data == NULL)
2287         {
2288           size = sizeof (struct areltdata);
2289           current_bfd->arelt_data = bfd_zmalloc (size);
2290           if (current_bfd->arelt_data == NULL)
2291             return FALSE;
2292         }
2293
2294       if (arch_xhdr_big (current_bfd) == NULL)
2295         {
2296           struct xcoff_ar_hdr_big *ahdrp;
2297           struct stat s;
2298
2299           /* XXX This should actually be a call to stat64 (at least on
2300              32-bit machines).
2301              XXX This call will fail if the original object is not found.  */
2302           if (stat (bfd_get_filename (current_bfd), &s) != 0)
2303             {
2304               bfd_set_error (bfd_error_system_call);
2305               return FALSE;
2306             }
2307
2308           ahdrp = bfd_zalloc (current_bfd, sizeof (*ahdrp));
2309           if (ahdrp == NULL)
2310             return FALSE;
2311
2312           PRINT20 (ahdrp->size, s.st_size);
2313           PRINT12 (ahdrp->date, s.st_mtime);
2314           PRINT12 (ahdrp->uid,  s.st_uid);
2315           PRINT12 (ahdrp->gid,  s.st_gid);
2316           PRINT12_OCTAL (ahdrp->mode, s.st_mode);
2317
2318           arch_eltdata (current_bfd)->arch_header = (char *) ahdrp;
2319           arch_eltdata (current_bfd)->parsed_size = s.st_size;
2320         }
2321     }
2322
2323   offsets = NULL;
2324   if (count)
2325     {
2326       offsets = (file_ptr *) bfd_malloc (count * sizeof (file_ptr));
2327       if (offsets == NULL)
2328         return FALSE;
2329     }
2330
2331   prevoff = 0;
2332   for (archive_iterator_begin (&iterator, abfd), i = 0;
2333        archive_iterator_next (&iterator);
2334        i++)
2335     {
2336       bfd_size_type namlen;
2337       struct xcoff_ar_hdr_big *ahdrp;
2338
2339       ahdrp = arch_xhdr_big (iterator.current.member);
2340       PRINT20 (ahdrp->prevoff, prevoff);
2341       PRINT4 (ahdrp->namlen, iterator.current.namlen);
2342       PRINT20 (ahdrp->nextoff, iterator.next.offset);
2343
2344       if (!do_pad (abfd, iterator.current.leading_padding))
2345         {
2346           free (offsets);
2347           return FALSE;
2348         }
2349
2350       BFD_ASSERT (iterator.current.offset == bfd_tell (abfd));
2351       namlen = iterator.current.padded_namlen;
2352       if (bfd_bwrite (ahdrp, SIZEOF_AR_HDR_BIG, abfd) != SIZEOF_AR_HDR_BIG
2353           || bfd_bwrite (iterator.current.name, namlen, abfd) != namlen
2354           || bfd_bwrite (XCOFFARFMAG, SXCOFFARFMAG, abfd) != SXCOFFARFMAG
2355           || bfd_seek (iterator.current.member, 0, SEEK_SET) != 0
2356           || !do_copy (abfd, iterator.current.member)
2357           || !do_pad (abfd, iterator.current.trailing_padding))
2358         {
2359           free (offsets);
2360           return FALSE;
2361         }
2362
2363       offsets[i] = iterator.current.offset;
2364       prevoff = iterator.current.offset;
2365     }
2366
2367   if (count)
2368     {
2369       PRINT20 (fhdr.firstmemoff, offsets[0]);
2370       PRINT20 (fhdr.lastmemoff, prevoff);
2371     }
2372
2373   /* Write out the member table.
2374      Layout :
2375
2376      standard big archive header
2377      0x0000                   ar_size   [0x14]
2378      0x0014                   ar_nxtmem [0x14]
2379      0x0028                   ar_prvmem [0x14]
2380      0x003C                   ar_date   [0x0C]
2381      0x0048                   ar_uid    [0x0C]
2382      0x0054                   ar_gid    [0x0C]
2383      0x0060                   ar_mod    [0x0C]
2384      0x006C                   ar_namelen[0x04]
2385      0x0070                   ar_fmag   [0x02]
2386
2387      Member table
2388      0x0072                   count     [0x14]
2389      0x0086                   offsets   [0x14 * counts]
2390      0x0086 + 0x14 * counts   names     [??]
2391      ??                       pad to even bytes.
2392    */
2393
2394   nextoff = iterator.next.offset;
2395   BFD_ASSERT (nextoff == bfd_tell (abfd));
2396
2397   member_table_size = (SIZEOF_AR_HDR_BIG
2398                        + SXCOFFARFMAG
2399                        + XCOFFARMAGBIG_ELEMENT_SIZE
2400                        + count * XCOFFARMAGBIG_ELEMENT_SIZE
2401                        + total_namlen);
2402
2403   member_table_size += member_table_size & 1;
2404   member_table = bfd_zmalloc (member_table_size);
2405   if (member_table == NULL)
2406     {
2407       free (offsets);
2408       return FALSE;
2409     }
2410
2411   hdr = (struct xcoff_ar_hdr_big *) member_table;
2412
2413   PRINT20 (hdr->size, (XCOFFARMAGBIG_ELEMENT_SIZE
2414                        + count * XCOFFARMAGBIG_ELEMENT_SIZE
2415                        + total_namlen + (total_namlen & 1)));
2416   if (makemap && hasobjects)
2417     PRINT20 (hdr->nextoff, nextoff + member_table_size);
2418   else
2419     PRINT20 (hdr->nextoff, 0);
2420   PRINT20 (hdr->prevoff, prevoff);
2421   PRINT12 (hdr->date, 0);
2422   PRINT12 (hdr->uid, 0);
2423   PRINT12 (hdr->gid, 0);
2424   PRINT12 (hdr->mode, 0);
2425   PRINT4 (hdr->namlen, 0);
2426
2427   mt = member_table + SIZEOF_AR_HDR_BIG;
2428   memcpy (mt, XCOFFARFMAG, SXCOFFARFMAG);
2429   mt += SXCOFFARFMAG;
2430
2431   PRINT20 (mt, count);
2432   mt += XCOFFARMAGBIG_ELEMENT_SIZE;
2433   for (i = 0; i < (size_t) count; i++)
2434     {
2435       PRINT20 (mt, offsets[i]);
2436       mt += XCOFFARMAGBIG_ELEMENT_SIZE;
2437     }
2438
2439   if (count)
2440     {
2441       free (offsets);
2442       offsets = NULL;
2443     }
2444
2445   for (current_bfd = abfd->archive_head;
2446        current_bfd != NULL;
2447        current_bfd = current_bfd->archive_next)
2448     {
2449       const char *name;
2450       size_t namlen;
2451
2452       name = normalize_filename (current_bfd);
2453       namlen = sprintf (mt, "%s", name);
2454       mt += namlen + 1;
2455     }
2456
2457   if (bfd_bwrite (member_table, member_table_size, abfd) != member_table_size)
2458     return FALSE;
2459
2460   free (member_table);
2461
2462   PRINT20 (fhdr.memoff, nextoff);
2463
2464   prevoff = nextoff;
2465   nextoff += member_table_size;
2466
2467   /* Write out the armap, if appropriate.  */
2468
2469   if (! makemap || ! hasobjects)
2470     PRINT20 (fhdr.symoff, 0);
2471   else
2472     {
2473       BFD_ASSERT (nextoff == bfd_tell (abfd));
2474
2475       /* Save nextoff in fhdr.symoff so the armap routine can use it.  */
2476       PRINT20 (fhdr.symoff, nextoff);
2477
2478       bfd_ardata (abfd)->tdata = &fhdr;
2479       if (! _bfd_compute_and_write_armap (abfd, 0))
2480         return FALSE;
2481     }
2482
2483   /* Write out the archive file header.  */
2484
2485   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
2486       || (bfd_bwrite (&fhdr, (bfd_size_type) SIZEOF_AR_FILE_HDR_BIG,
2487                       abfd) != SIZEOF_AR_FILE_HDR_BIG))
2488     return FALSE;
2489
2490   return TRUE;
2491 }
2492
2493 bfd_boolean
2494 _bfd_xcoff_write_archive_contents (bfd *abfd)
2495 {
2496   if (! xcoff_big_format_p (abfd))
2497     return xcoff_write_archive_contents_old (abfd);
2498   else
2499     return xcoff_write_archive_contents_big (abfd);
2500 }
2501 \f
2502 /* We can't use the usual coff_sizeof_headers routine, because AIX
2503    always uses an a.out header.  */
2504
2505 int
2506 _bfd_xcoff_sizeof_headers (bfd *abfd,
2507                            struct bfd_link_info *info ATTRIBUTE_UNUSED)
2508 {
2509   int size;
2510
2511   size = FILHSZ;
2512   if (xcoff_data (abfd)->full_aouthdr)
2513     size += AOUTSZ;
2514   else
2515     size += SMALL_AOUTSZ;
2516   size += abfd->section_count * SCNHSZ;
2517
2518   if (info->strip != strip_all)
2519     {
2520       /* There can be additional sections just for dealing with overflow in
2521          reloc and lineno counts. But the numbers of relocs and lineno aren't
2522          known when bfd_sizeof_headers is called, so we compute them by
2523          summing the numbers from input sections.  */
2524       struct nbr_reloc_lineno
2525       {
2526         unsigned int reloc_count;
2527         unsigned int lineno_count;
2528       };
2529       struct nbr_reloc_lineno *n_rl;
2530       bfd *sub;
2531       unsigned int max_index;
2532       asection *s;
2533
2534       /* Although the number of sections is known, the maximum value of
2535          section->index isn't (because some sections may have been removed).
2536          Don't try to renumber sections, just compute the upper bound.  */
2537       max_index = 0;
2538       for (s = abfd->sections; s != NULL; s = s->next)
2539         if (s->index > max_index)
2540           max_index = s->index;
2541
2542       /* Allocate the per section counters. It could be possible to use a
2543          preallocated array as the number of sections is limited on XCOFF,
2544          but this creates a maintainance issue.  */
2545       n_rl = bfd_zmalloc ((max_index + 1) * sizeof (*n_rl));
2546       if (n_rl == NULL)
2547         return -1;
2548
2549       /* Sum.  */
2550       for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
2551         for (s = sub->sections; s != NULL; s = s->next)
2552           {
2553             struct nbr_reloc_lineno *e = &n_rl[s->output_section->index];
2554             e->reloc_count += s->reloc_count;
2555             e->lineno_count += s->lineno_count;
2556           }
2557
2558       /* Add the size of a section for each section with an overflow.  */
2559       for (s = abfd->sections; s != NULL; s = s->next)
2560         {
2561           struct nbr_reloc_lineno *e = &n_rl[s->index];
2562
2563           if (e->reloc_count >= 0xffff
2564               || (e->lineno_count >= 0xffff && info->strip != strip_debugger))
2565             size += SCNHSZ;
2566         }
2567
2568       free (n_rl);
2569     }
2570
2571   return size;
2572 }
2573 \f
2574 /* Routines to swap information in the XCOFF .loader section.  If we
2575    ever need to write an XCOFF loader, this stuff will need to be
2576    moved to another file shared by the linker (which XCOFF calls the
2577    ``binder'') and the loader.  */
2578
2579 /* Swap in the ldhdr structure.  */
2580
2581 static void
2582 xcoff_swap_ldhdr_in (bfd *abfd, const void * s, struct internal_ldhdr *dst)
2583 {
2584   const struct external_ldhdr *src = (const struct external_ldhdr *) s;
2585
2586   dst->l_version = bfd_get_32 (abfd, src->l_version);
2587   dst->l_nsyms = bfd_get_32 (abfd, src->l_nsyms);
2588   dst->l_nreloc = bfd_get_32 (abfd, src->l_nreloc);
2589   dst->l_istlen = bfd_get_32 (abfd, src->l_istlen);
2590   dst->l_nimpid = bfd_get_32 (abfd, src->l_nimpid);
2591   dst->l_impoff = bfd_get_32 (abfd, src->l_impoff);
2592   dst->l_stlen = bfd_get_32 (abfd, src->l_stlen);
2593   dst->l_stoff = bfd_get_32 (abfd, src->l_stoff);
2594 }
2595
2596 /* Swap out the ldhdr structure.  */
2597
2598 static void
2599 xcoff_swap_ldhdr_out (bfd *abfd, const struct internal_ldhdr *src, void * d)
2600 {
2601   struct external_ldhdr *dst = (struct external_ldhdr *) d;
2602
2603   bfd_put_32 (abfd, (bfd_vma) src->l_version, dst->l_version);
2604   bfd_put_32 (abfd, src->l_nsyms, dst->l_nsyms);
2605   bfd_put_32 (abfd, src->l_nreloc, dst->l_nreloc);
2606   bfd_put_32 (abfd, src->l_istlen, dst->l_istlen);
2607   bfd_put_32 (abfd, src->l_nimpid, dst->l_nimpid);
2608   bfd_put_32 (abfd, src->l_impoff, dst->l_impoff);
2609   bfd_put_32 (abfd, src->l_stlen, dst->l_stlen);
2610   bfd_put_32 (abfd, src->l_stoff, dst->l_stoff);
2611 }
2612
2613 /* Swap in the ldsym structure.  */
2614
2615 static void
2616 xcoff_swap_ldsym_in (bfd *abfd, const void * s, struct internal_ldsym *dst)
2617 {
2618   const struct external_ldsym *src = (const struct external_ldsym *) s;
2619
2620   if (bfd_get_32 (abfd, src->_l._l_l._l_zeroes) != 0) {
2621     memcpy (dst->_l._l_name, src->_l._l_name, SYMNMLEN);
2622   } else {
2623     dst->_l._l_l._l_zeroes = 0;
2624     dst->_l._l_l._l_offset = bfd_get_32 (abfd, src->_l._l_l._l_offset);
2625   }
2626   dst->l_value = bfd_get_32 (abfd, src->l_value);
2627   dst->l_scnum = bfd_get_16 (abfd, src->l_scnum);
2628   dst->l_smtype = bfd_get_8 (abfd, src->l_smtype);
2629   dst->l_smclas = bfd_get_8 (abfd, src->l_smclas);
2630   dst->l_ifile = bfd_get_32 (abfd, src->l_ifile);
2631   dst->l_parm = bfd_get_32 (abfd, src->l_parm);
2632 }
2633
2634 /* Swap out the ldsym structure.  */
2635
2636 static void
2637 xcoff_swap_ldsym_out (bfd *abfd, const struct internal_ldsym *src, void * d)
2638 {
2639   struct external_ldsym *dst = (struct external_ldsym *) d;
2640
2641   if (src->_l._l_l._l_zeroes != 0)
2642     memcpy (dst->_l._l_name, src->_l._l_name, SYMNMLEN);
2643   else
2644     {
2645       bfd_put_32 (abfd, (bfd_vma) 0, dst->_l._l_l._l_zeroes);
2646       bfd_put_32 (abfd, (bfd_vma) src->_l._l_l._l_offset,
2647                   dst->_l._l_l._l_offset);
2648     }
2649   bfd_put_32 (abfd, src->l_value, dst->l_value);
2650   bfd_put_16 (abfd, (bfd_vma) src->l_scnum, dst->l_scnum);
2651   bfd_put_8 (abfd, src->l_smtype, dst->l_smtype);
2652   bfd_put_8 (abfd, src->l_smclas, dst->l_smclas);
2653   bfd_put_32 (abfd, src->l_ifile, dst->l_ifile);
2654   bfd_put_32 (abfd, src->l_parm, dst->l_parm);
2655 }
2656
2657 static void
2658 xcoff_swap_reloc_in (bfd *abfd, void * s, void * d)
2659 {
2660   struct external_reloc *src = (struct external_reloc *) s;
2661   struct internal_reloc *dst = (struct internal_reloc *) d;
2662
2663   memset (dst, 0, sizeof (struct internal_reloc));
2664
2665   dst->r_vaddr = bfd_get_32 (abfd, src->r_vaddr);
2666   dst->r_symndx = bfd_get_32 (abfd, src->r_symndx);
2667   dst->r_size = bfd_get_8 (abfd, src->r_size);
2668   dst->r_type = bfd_get_8 (abfd, src->r_type);
2669 }
2670
2671 static unsigned int
2672 xcoff_swap_reloc_out (bfd *abfd, void * s, void * d)
2673 {
2674   struct internal_reloc *src = (struct internal_reloc *) s;
2675   struct external_reloc *dst = (struct external_reloc *) d;
2676
2677   bfd_put_32 (abfd, src->r_vaddr, dst->r_vaddr);
2678   bfd_put_32 (abfd, src->r_symndx, dst->r_symndx);
2679   bfd_put_8 (abfd, src->r_type, dst->r_type);
2680   bfd_put_8 (abfd, src->r_size, dst->r_size);
2681
2682   return bfd_coff_relsz (abfd);
2683 }
2684
2685 /* Swap in the ldrel structure.  */
2686
2687 static void
2688 xcoff_swap_ldrel_in (bfd *abfd, const void * s, struct internal_ldrel *dst)
2689 {
2690   const struct external_ldrel *src = (const struct external_ldrel *) s;
2691
2692   dst->l_vaddr = bfd_get_32 (abfd, src->l_vaddr);
2693   dst->l_symndx = bfd_get_32 (abfd, src->l_symndx);
2694   dst->l_rtype = bfd_get_16 (abfd, src->l_rtype);
2695   dst->l_rsecnm = bfd_get_16 (abfd, src->l_rsecnm);
2696 }
2697
2698 /* Swap out the ldrel structure.  */
2699
2700 static void
2701 xcoff_swap_ldrel_out (bfd *abfd, const struct internal_ldrel *src, void * d)
2702 {
2703   struct external_ldrel *dst = (struct external_ldrel *) d;
2704
2705   bfd_put_32 (abfd, src->l_vaddr, dst->l_vaddr);
2706   bfd_put_32 (abfd, src->l_symndx, dst->l_symndx);
2707   bfd_put_16 (abfd, (bfd_vma) src->l_rtype, dst->l_rtype);
2708   bfd_put_16 (abfd, (bfd_vma) src->l_rsecnm, dst->l_rsecnm);
2709 }
2710 \f
2711
2712 bfd_boolean
2713 xcoff_reloc_type_noop (bfd *input_bfd ATTRIBUTE_UNUSED,
2714                        asection *input_section ATTRIBUTE_UNUSED,
2715                        bfd *output_bfd ATTRIBUTE_UNUSED,
2716                        struct internal_reloc *rel ATTRIBUTE_UNUSED,
2717                        struct internal_syment *sym ATTRIBUTE_UNUSED,
2718                        struct reloc_howto_struct *howto ATTRIBUTE_UNUSED,
2719                        bfd_vma val ATTRIBUTE_UNUSED,
2720                        bfd_vma addend ATTRIBUTE_UNUSED,
2721                        bfd_vma *relocation ATTRIBUTE_UNUSED,
2722                        bfd_byte *contents ATTRIBUTE_UNUSED)
2723 {
2724   return TRUE;
2725 }
2726
2727 bfd_boolean
2728 xcoff_reloc_type_fail (bfd *input_bfd,
2729                        asection *input_section ATTRIBUTE_UNUSED,
2730                        bfd *output_bfd ATTRIBUTE_UNUSED,
2731                        struct internal_reloc *rel,
2732                        struct internal_syment *sym ATTRIBUTE_UNUSED,
2733                        struct reloc_howto_struct *howto ATTRIBUTE_UNUSED,
2734                        bfd_vma val ATTRIBUTE_UNUSED,
2735                        bfd_vma addend ATTRIBUTE_UNUSED,
2736                        bfd_vma *relocation ATTRIBUTE_UNUSED,
2737                        bfd_byte *contents ATTRIBUTE_UNUSED)
2738 {
2739   (*_bfd_error_handler)
2740     (_("%s: unsupported relocation type 0x%02x"),
2741      bfd_get_filename (input_bfd), (unsigned int) rel->r_type);
2742   bfd_set_error (bfd_error_bad_value);
2743   return FALSE;
2744 }
2745
2746 bfd_boolean
2747 xcoff_reloc_type_pos (bfd *input_bfd ATTRIBUTE_UNUSED,
2748                       asection *input_section ATTRIBUTE_UNUSED,
2749                       bfd *output_bfd ATTRIBUTE_UNUSED,
2750                       struct internal_reloc *rel ATTRIBUTE_UNUSED,
2751                       struct internal_syment *sym ATTRIBUTE_UNUSED,
2752                       struct reloc_howto_struct *howto ATTRIBUTE_UNUSED,
2753                       bfd_vma val,
2754                       bfd_vma addend,
2755                       bfd_vma *relocation,
2756                       bfd_byte *contents ATTRIBUTE_UNUSED)
2757 {
2758   *relocation = val + addend;
2759   return TRUE;
2760 }
2761
2762 bfd_boolean
2763 xcoff_reloc_type_neg (bfd *input_bfd ATTRIBUTE_UNUSED,
2764                       asection *input_section ATTRIBUTE_UNUSED,
2765                       bfd *output_bfd ATTRIBUTE_UNUSED,
2766                       struct internal_reloc *rel ATTRIBUTE_UNUSED,
2767                       struct internal_syment *sym ATTRIBUTE_UNUSED,
2768                       struct reloc_howto_struct *howto ATTRIBUTE_UNUSED,
2769                       bfd_vma val,
2770                       bfd_vma addend,
2771                       bfd_vma *relocation,
2772                       bfd_byte *contents ATTRIBUTE_UNUSED)
2773 {
2774   *relocation = addend - val;
2775   return TRUE;
2776 }
2777
2778 bfd_boolean
2779 xcoff_reloc_type_rel (bfd *input_bfd ATTRIBUTE_UNUSED,
2780                       asection *input_section,
2781                       bfd *output_bfd ATTRIBUTE_UNUSED,
2782                       struct internal_reloc *rel ATTRIBUTE_UNUSED,
2783                       struct internal_syment *sym ATTRIBUTE_UNUSED,
2784                       struct reloc_howto_struct *howto,
2785                       bfd_vma val,
2786                       bfd_vma addend,
2787                       bfd_vma *relocation,
2788                       bfd_byte *contents ATTRIBUTE_UNUSED)
2789 {
2790   howto->pc_relative = TRUE;
2791
2792   /* A PC relative reloc includes the section address.  */
2793   addend += input_section->vma;
2794
2795   *relocation = val + addend;
2796   *relocation -= (input_section->output_section->vma
2797                   + input_section->output_offset);
2798   return TRUE;
2799 }
2800
2801 bfd_boolean
2802 xcoff_reloc_type_toc (bfd *input_bfd,
2803                       asection *input_section ATTRIBUTE_UNUSED,
2804                       bfd *output_bfd,
2805                       struct internal_reloc *rel,
2806                       struct internal_syment *sym,
2807                       struct reloc_howto_struct *howto ATTRIBUTE_UNUSED,
2808                       bfd_vma val,
2809                       bfd_vma addend ATTRIBUTE_UNUSED,
2810                       bfd_vma *relocation,
2811                       bfd_byte *contents ATTRIBUTE_UNUSED)
2812 {
2813   struct xcoff_link_hash_entry *h;
2814
2815   if (0 > rel->r_symndx)
2816     return FALSE;
2817
2818   h = obj_xcoff_sym_hashes (input_bfd)[rel->r_symndx];
2819
2820   if (h != NULL && h->smclas != XMC_TD)
2821     {
2822       if (h->toc_section == NULL)
2823         {
2824           (*_bfd_error_handler)
2825             (_("%s: TOC reloc at 0x%x to symbol `%s' with no TOC entry"),
2826              bfd_get_filename (input_bfd), rel->r_vaddr,
2827              h->root.root.string);
2828           bfd_set_error (bfd_error_bad_value);
2829           return FALSE;
2830         }
2831
2832       BFD_ASSERT ((h->flags & XCOFF_SET_TOC) == 0);
2833       val = (h->toc_section->output_section->vma
2834               + h->toc_section->output_offset);
2835     }
2836
2837   *relocation = ((val - xcoff_data (output_bfd)->toc)
2838                  - (sym->n_value - xcoff_data (input_bfd)->toc));
2839   return TRUE;
2840 }
2841
2842 bfd_boolean
2843 xcoff_reloc_type_ba (bfd *input_bfd ATTRIBUTE_UNUSED,
2844                      asection *input_section ATTRIBUTE_UNUSED,
2845                      bfd *output_bfd ATTRIBUTE_UNUSED,
2846                      struct internal_reloc *rel ATTRIBUTE_UNUSED,
2847                      struct internal_syment *sym ATTRIBUTE_UNUSED,
2848                      struct reloc_howto_struct *howto,
2849                      bfd_vma val,
2850                      bfd_vma addend,
2851                      bfd_vma *relocation,
2852                      bfd_byte *contents ATTRIBUTE_UNUSED)
2853 {
2854   howto->src_mask &= ~3;
2855   howto->dst_mask = howto->src_mask;
2856
2857   *relocation = val + addend;
2858
2859   return TRUE;
2860 }
2861
2862 static bfd_boolean
2863 xcoff_reloc_type_br (bfd *input_bfd,
2864                      asection *input_section,
2865                      bfd *output_bfd ATTRIBUTE_UNUSED,
2866                      struct internal_reloc *rel,
2867                      struct internal_syment *sym ATTRIBUTE_UNUSED,
2868                      struct reloc_howto_struct *howto,
2869                      bfd_vma val,
2870                      bfd_vma addend,
2871                      bfd_vma *relocation,
2872                      bfd_byte *contents)
2873 {
2874   struct xcoff_link_hash_entry *h;
2875   bfd_vma section_offset;
2876
2877   if (0 > rel->r_symndx)
2878     return FALSE;
2879
2880   h = obj_xcoff_sym_hashes (input_bfd)[rel->r_symndx];
2881   section_offset = rel->r_vaddr - input_section->vma;
2882
2883   /* If we see an R_BR or R_RBR reloc which is jumping to global
2884      linkage code, and it is followed by an appropriate cror nop
2885      instruction, we replace the cror with lwz r2,20(r1).  This
2886      restores the TOC after the glink code.  Contrariwise, if the
2887      call is followed by a lwz r2,20(r1), but the call is not
2888      going to global linkage code, we can replace the load with a
2889      cror.  */
2890   if (NULL != h
2891       && (bfd_link_hash_defined == h->root.type
2892           || bfd_link_hash_defweak == h->root.type)
2893       && section_offset + 8 <= input_section->size)
2894     {
2895       bfd_byte *pnext;
2896       unsigned long next;
2897
2898       pnext = contents + section_offset + 4;
2899       next = bfd_get_32 (input_bfd, pnext);
2900
2901       /* The _ptrgl function is magic.  It is used by the AIX
2902          compiler to call a function through a pointer.  */
2903       if (h->smclas == XMC_GL || strcmp (h->root.root.string, "._ptrgl") == 0)
2904         {
2905           if (next == 0x4def7b82                        /* cror 15,15,15 */
2906               || next == 0x4ffffb82                     /* cror 31,31,31 */
2907               || next == 0x60000000)                    /* ori r0,r0,0 */
2908             bfd_put_32 (input_bfd, 0x80410014, pnext);  /* lwz r2,20(r1) */
2909
2910         }
2911       else
2912         {
2913           if (next == 0x80410014)                       /* lwz r2,20(r1) */
2914             bfd_put_32 (input_bfd, 0x60000000, pnext);  /* ori r0,r0,0 */
2915         }
2916     }
2917   else if (NULL != h && bfd_link_hash_undefined == h->root.type)
2918     {
2919       /* Normally, this relocation is against a defined symbol.  In the
2920          case where this is a partial link and the output section offset
2921          is greater than 2^25, the linker will return an invalid error
2922          message that the relocation has been truncated.  Yes it has been
2923          truncated but no it not important.  For this case, disable the
2924          overflow checking. */
2925
2926       howto->complain_on_overflow = complain_overflow_dont;
2927     }
2928
2929   /* The original PC-relative relocation is biased by -r_vaddr, so adding
2930      the value below will give the absolute target address.  */
2931   *relocation = val + addend + rel->r_vaddr;
2932
2933   howto->src_mask &= ~3;
2934   howto->dst_mask = howto->src_mask;
2935
2936   if (h != NULL
2937       && (h->root.type == bfd_link_hash_defined
2938           || h->root.type == bfd_link_hash_defweak)
2939       && bfd_is_abs_section (h->root.u.def.section)
2940       && section_offset + 4 <= input_section->size)
2941     {
2942       bfd_byte *ptr;
2943       bfd_vma insn;
2944
2945       /* Turn the relative branch into an absolute one by setting the
2946          AA bit.  */
2947       ptr = contents + section_offset;
2948       insn = bfd_get_32 (input_bfd, ptr);
2949       insn |= 2;
2950       bfd_put_32 (input_bfd, insn, ptr);
2951
2952       /* Make the howto absolute too.  */
2953       howto->pc_relative = FALSE;
2954       howto->complain_on_overflow = complain_overflow_bitfield;
2955     }
2956   else
2957     {
2958       /* Use a PC-relative howto and subtract the instruction's address
2959          from the target address we calculated above.  */
2960       howto->pc_relative = TRUE;
2961       *relocation -= (input_section->output_section->vma
2962                       + input_section->output_offset
2963                       + section_offset);
2964     }
2965   return TRUE;
2966 }
2967
2968 bfd_boolean
2969 xcoff_reloc_type_crel (bfd *input_bfd ATTRIBUTE_UNUSED,
2970                        asection *input_section,
2971                        bfd *output_bfd ATTRIBUTE_UNUSED,
2972                        struct internal_reloc *rel ATTRIBUTE_UNUSED,
2973                        struct internal_syment *sym ATTRIBUTE_UNUSED,
2974                        struct reloc_howto_struct *howto,
2975                        bfd_vma val ATTRIBUTE_UNUSED,
2976                        bfd_vma addend,
2977                        bfd_vma *relocation,
2978                        bfd_byte *contents ATTRIBUTE_UNUSED)
2979 {
2980   howto->pc_relative = TRUE;
2981   howto->src_mask &= ~3;
2982   howto->dst_mask = howto->src_mask;
2983
2984   /* A PC relative reloc includes the section address.  */
2985   addend += input_section->vma;
2986
2987   *relocation = val + addend;
2988   *relocation -= (input_section->output_section->vma
2989                   + input_section->output_offset);
2990   return TRUE;
2991 }
2992
2993 static bfd_boolean
2994 xcoff_complain_overflow_dont_func (bfd *input_bfd ATTRIBUTE_UNUSED,
2995                                    bfd_vma val ATTRIBUTE_UNUSED,
2996                                    bfd_vma relocation ATTRIBUTE_UNUSED,
2997                                    struct reloc_howto_struct *
2998                                       howto ATTRIBUTE_UNUSED)
2999 {
3000   return FALSE;
3001 }
3002
3003 static bfd_boolean
3004 xcoff_complain_overflow_bitfield_func (bfd *input_bfd,
3005                                        bfd_vma val,
3006                                        bfd_vma relocation,
3007                                        struct reloc_howto_struct *howto)
3008 {
3009   bfd_vma fieldmask, signmask, ss;
3010   bfd_vma a, b, sum;
3011
3012   /* Get the values to be added together.  For signed and unsigned
3013      relocations, we assume that all values should be truncated to
3014      the size of an address.  For bitfields, all the bits matter.
3015      See also bfd_check_overflow.  */
3016   fieldmask = N_ONES (howto->bitsize);
3017   a = relocation;
3018   b = val & howto->src_mask;
3019
3020   /* Much like unsigned, except no trimming with addrmask.  In
3021      addition, the sum overflows if there is a carry out of
3022      the bfd_vma, i.e., the sum is less than either input
3023      operand.  */
3024   a >>= howto->rightshift;
3025   b >>= howto->bitpos;
3026
3027   /* Bitfields are sometimes used for signed numbers; for
3028      example, a 13-bit field sometimes represents values in
3029      0..8191 and sometimes represents values in -4096..4095.
3030      If the field is signed and a is -4095 (0x1001) and b is
3031      -1 (0x1fff), the sum is -4096 (0x1000), but (0x1001 +
3032      0x1fff is 0x3000).  It's not clear how to handle this
3033      everywhere, since there is not way to know how many bits
3034      are significant in the relocation, but the original code
3035      assumed that it was fully sign extended, and we will keep
3036      that assumption.  */
3037   signmask = (fieldmask >> 1) + 1;
3038
3039   if ((a & ~ fieldmask) != 0)
3040     {
3041       /* Some bits out of the field are set.  This might not
3042          be a problem: if this is a signed bitfield, it is OK
3043          iff all the high bits are set, including the sign
3044          bit.  We'll try setting all but the most significant
3045          bit in the original relocation value: if this is all
3046          ones, we are OK, assuming a signed bitfield.  */
3047       ss = (signmask << howto->rightshift) - 1;
3048       if ((ss | relocation) != ~ (bfd_vma) 0)
3049         return TRUE;
3050       a &= fieldmask;
3051     }
3052
3053   /* We just assume (b & ~ fieldmask) == 0.  */
3054
3055   /* We explicitly permit wrap around if this relocation
3056      covers the high bit of an address.  The Linux kernel
3057      relies on it, and it is the only way to write assembler
3058      code which can run when loaded at a location 0x80000000
3059      away from the location at which it is linked.  */
3060   if (howto->bitsize + howto->rightshift
3061       == bfd_arch_bits_per_address (input_bfd))
3062     return FALSE;
3063
3064   sum = a + b;
3065   if (sum < a || (sum & ~ fieldmask) != 0)
3066     {
3067       /* There was a carry out, or the field overflow.  Test
3068          for signed operands again.  Here is the overflow test
3069          is as for complain_overflow_signed.  */
3070       if (((~ (a ^ b)) & (a ^ sum)) & signmask)
3071         return TRUE;
3072     }
3073
3074   return FALSE;
3075 }
3076
3077 static bfd_boolean
3078 xcoff_complain_overflow_signed_func (bfd *input_bfd,
3079                                      bfd_vma val,
3080                                      bfd_vma relocation,
3081                                      struct reloc_howto_struct *howto)
3082 {
3083   bfd_vma addrmask, fieldmask, signmask, ss;
3084   bfd_vma a, b, sum;
3085
3086   /* Get the values to be added together.  For signed and unsigned
3087      relocations, we assume that all values should be truncated to
3088      the size of an address.  For bitfields, all the bits matter.
3089      See also bfd_check_overflow.  */
3090   fieldmask = N_ONES (howto->bitsize);
3091   addrmask = N_ONES (bfd_arch_bits_per_address (input_bfd)) | fieldmask;
3092   a = relocation;
3093   b = val & howto->src_mask;
3094
3095   a = (a & addrmask) >> howto->rightshift;
3096
3097   /* If any sign bits are set, all sign bits must be set.
3098      That is, A must be a valid negative address after
3099      shifting.  */
3100   signmask = ~ (fieldmask >> 1);
3101   ss = a & signmask;
3102   if (ss != 0 && ss != ((addrmask >> howto->rightshift) & signmask))
3103     return TRUE;
3104
3105   /* We only need this next bit of code if the sign bit of B
3106      is below the sign bit of A.  This would only happen if
3107      SRC_MASK had fewer bits than BITSIZE.  Note that if
3108      SRC_MASK has more bits than BITSIZE, we can get into
3109      trouble; we would need to verify that B is in range, as
3110      we do for A above.  */
3111   signmask = ((~ howto->src_mask) >> 1) & howto->src_mask;
3112   if ((b & signmask) != 0)
3113     {
3114       /* Set all the bits above the sign bit.  */
3115       b -= signmask <<= 1;
3116     }
3117
3118   b = (b & addrmask) >> howto->bitpos;
3119
3120   /* Now we can do the addition.  */
3121   sum = a + b;
3122
3123   /* See if the result has the correct sign.  Bits above the
3124      sign bit are junk now; ignore them.  If the sum is
3125      positive, make sure we did not have all negative inputs;
3126      if the sum is negative, make sure we did not have all
3127      positive inputs.  The test below looks only at the sign
3128      bits, and it really just
3129      SIGN (A) == SIGN (B) && SIGN (A) != SIGN (SUM)
3130   */
3131   signmask = (fieldmask >> 1) + 1;
3132   if (((~ (a ^ b)) & (a ^ sum)) & signmask)
3133     return TRUE;
3134
3135   return FALSE;
3136 }
3137
3138 static bfd_boolean
3139 xcoff_complain_overflow_unsigned_func (bfd *input_bfd,
3140                                        bfd_vma val,
3141                                        bfd_vma relocation,
3142                                        struct reloc_howto_struct *howto)
3143 {
3144   bfd_vma addrmask, fieldmask;
3145   bfd_vma a, b, sum;
3146
3147   /* Get the values to be added together.  For signed and unsigned
3148      relocations, we assume that all values should be truncated to
3149      the size of an address.  For bitfields, all the bits matter.
3150      See also bfd_check_overflow.  */
3151   fieldmask = N_ONES (howto->bitsize);
3152   addrmask = N_ONES (bfd_arch_bits_per_address (input_bfd)) | fieldmask;
3153   a = relocation;
3154   b = val & howto->src_mask;
3155
3156   /* Checking for an unsigned overflow is relatively easy:
3157      trim the addresses and add, and trim the result as well.
3158      Overflow is normally indicated when the result does not
3159      fit in the field.  However, we also need to consider the
3160      case when, e.g., fieldmask is 0x7fffffff or smaller, an
3161      input is 0x80000000, and bfd_vma is only 32 bits; then we
3162      will get sum == 0, but there is an overflow, since the
3163      inputs did not fit in the field.  Instead of doing a
3164      separate test, we can check for this by or-ing in the
3165      operands when testing for the sum overflowing its final
3166      field.  */
3167   a = (a & addrmask) >> howto->rightshift;
3168   b = (b & addrmask) >> howto->bitpos;
3169   sum = (a + b) & addrmask;
3170   if ((a | b | sum) & ~ fieldmask)
3171     return TRUE;
3172
3173   return FALSE;
3174 }
3175
3176 /* This is the relocation function for the RS/6000/POWER/PowerPC.
3177    This is currently the only processor which uses XCOFF; I hope that
3178    will never change.
3179
3180    I took the relocation type definitions from two documents:
3181    the PowerPC AIX Version 4 Application Binary Interface, First
3182    Edition (April 1992), and the PowerOpen ABI, Big-Endian
3183    32-Bit Hardware Implementation (June 30, 1994).  Differences
3184    between the documents are noted below.
3185
3186    Unsupported r_type's
3187
3188    R_RTB:
3189    R_RRTBI:
3190    R_RRTBA:
3191
3192    These relocs are defined by the PowerPC ABI to be
3193    relative branches which use half of the difference
3194    between the symbol and the program counter.  I can't
3195    quite figure out when this is useful.  These relocs are
3196    not defined by the PowerOpen ABI.
3197
3198    Supported r_type's
3199
3200    R_POS:
3201    Simple positive relocation.
3202
3203    R_NEG:
3204    Simple negative relocation.
3205
3206    R_REL:
3207    Simple PC relative relocation.
3208
3209    R_TOC:
3210    TOC relative relocation.  The value in the instruction in
3211    the input file is the offset from the input file TOC to
3212    the desired location.  We want the offset from the final
3213    TOC to the desired location.  We have:
3214    isym = iTOC + in
3215    iinsn = in + o
3216    osym = oTOC + on
3217    oinsn = on + o
3218    so we must change insn by on - in.
3219
3220    R_GL:
3221    GL linkage relocation.  The value of this relocation
3222    is the address of the entry in the TOC section.
3223
3224    R_TCL:
3225    Local object TOC address.  I can't figure out the
3226    difference between this and case R_GL.
3227
3228    R_TRL:
3229    TOC relative relocation.  A TOC relative load instruction
3230    which may be changed to a load address instruction.
3231    FIXME: We don't currently implement this optimization.
3232
3233    R_TRLA:
3234    TOC relative relocation.  This is a TOC relative load
3235    address instruction which may be changed to a load
3236    instruction.  FIXME: I don't know if this is the correct
3237    implementation.
3238
3239    R_BA:
3240    Absolute branch.  We don't want to mess with the lower
3241    two bits of the instruction.
3242
3243    R_CAI:
3244    The PowerPC ABI defines this as an absolute call which
3245    may be modified to become a relative call.  The PowerOpen
3246    ABI does not define this relocation type.
3247
3248    R_RBA:
3249    Absolute branch which may be modified to become a
3250    relative branch.
3251
3252    R_RBAC:
3253    The PowerPC ABI defines this as an absolute branch to a
3254    fixed address which may be modified to an absolute branch
3255    to a symbol.  The PowerOpen ABI does not define this
3256    relocation type.
3257
3258    R_RBRC:
3259    The PowerPC ABI defines this as an absolute branch to a
3260    fixed address which may be modified to a relative branch.
3261    The PowerOpen ABI does not define this relocation type.
3262
3263    R_BR:
3264    Relative branch.  We don't want to mess with the lower
3265    two bits of the instruction.
3266
3267    R_CREL:
3268    The PowerPC ABI defines this as a relative call which may
3269    be modified to become an absolute call.  The PowerOpen
3270    ABI does not define this relocation type.
3271
3272    R_RBR:
3273    A relative branch which may be modified to become an
3274    absolute branch.
3275
3276    R_RL:
3277    The PowerPC AIX ABI describes this as a load which may be
3278    changed to a load address.  The PowerOpen ABI says this
3279    is the same as case R_POS.
3280
3281    R_RLA:
3282    The PowerPC AIX ABI describes this as a load address
3283    which may be changed to a load.  The PowerOpen ABI says
3284    this is the same as R_POS.
3285 */
3286
3287 bfd_boolean
3288 xcoff_ppc_relocate_section (bfd *output_bfd,
3289                             struct bfd_link_info *info,
3290                             bfd *input_bfd,
3291                             asection *input_section,
3292                             bfd_byte *contents,
3293                             struct internal_reloc *relocs,
3294                             struct internal_syment *syms,
3295                             asection **sections)
3296 {
3297   struct internal_reloc *rel;
3298   struct internal_reloc *relend;
3299
3300   rel = relocs;
3301   relend = rel + input_section->reloc_count;
3302   for (; rel < relend; rel++)
3303     {
3304       long symndx;
3305       struct xcoff_link_hash_entry *h;
3306       struct internal_syment *sym;
3307       bfd_vma addend;
3308       bfd_vma val;
3309       struct reloc_howto_struct howto;
3310       bfd_vma relocation;
3311       bfd_vma value_to_relocate;
3312       bfd_vma address;
3313       bfd_byte *location;
3314
3315       /* Relocation type R_REF is a special relocation type which is
3316          merely used to prevent garbage collection from occurring for
3317          the csect including the symbol which it references.  */
3318       if (rel->r_type == R_REF)
3319         continue;
3320
3321       /* howto */
3322       howto.type = rel->r_type;
3323       howto.rightshift = 0;
3324       howto.bitsize = (rel->r_size & 0x1f) + 1;
3325       howto.size = howto.bitsize > 16 ? 2 : 1;
3326       howto.pc_relative = FALSE;
3327       howto.bitpos = 0;
3328       howto.complain_on_overflow = (rel->r_size & 0x80
3329                                     ? complain_overflow_signed
3330                                     : complain_overflow_bitfield);
3331       howto.special_function = NULL;
3332       howto.name = "internal";
3333       howto.partial_inplace = TRUE;
3334       howto.src_mask = howto.dst_mask = N_ONES (howto.bitsize);
3335       howto.pcrel_offset = FALSE;
3336
3337       /* symbol */
3338       val = 0;
3339       addend = 0;
3340       h = NULL;
3341       sym = NULL;
3342       symndx = rel->r_symndx;
3343
3344       if (-1 != symndx)
3345         {
3346           asection *sec;
3347
3348           h = obj_xcoff_sym_hashes (input_bfd)[symndx];
3349           sym = syms + symndx;
3350           addend = - sym->n_value;
3351
3352           if (NULL == h)
3353             {
3354               sec = sections[symndx];
3355               /* Hack to make sure we use the right TOC anchor value
3356                  if this reloc is against the TOC anchor.  */
3357               if (sec->name[3] == '0'
3358                   && strcmp (sec->name, ".tc0") == 0)
3359                 val = xcoff_data (output_bfd)->toc;
3360               else
3361                 val = (sec->output_section->vma
3362                        + sec->output_offset
3363                        + sym->n_value
3364                        - sec->vma);
3365             }
3366           else
3367             {
3368               if (info->unresolved_syms_in_objects != RM_IGNORE
3369                   && (h->flags & XCOFF_WAS_UNDEFINED) != 0)
3370                 {
3371                   if (! ((*info->callbacks->undefined_symbol)
3372                          (info, h->root.root.string,
3373                           input_bfd, input_section,
3374                           rel->r_vaddr - input_section->vma,
3375                           (info->unresolved_syms_in_objects
3376                            == RM_GENERATE_ERROR))))
3377                     return FALSE;
3378                 }
3379               if (h->root.type == bfd_link_hash_defined
3380                   || h->root.type == bfd_link_hash_defweak)
3381                 {
3382                   sec = h->root.u.def.section;
3383                   val = (h->root.u.def.value
3384                          + sec->output_section->vma
3385                          + sec->output_offset);
3386                 }
3387               else if (h->root.type == bfd_link_hash_common)
3388                 {
3389                   sec = h->root.u.c.p->section;
3390                   val = (sec->output_section->vma
3391                          + sec->output_offset);
3392
3393                 }
3394               else
3395                 {
3396                   BFD_ASSERT (bfd_link_relocatable (info)
3397                               || (info->static_link
3398                                   && (h->flags & XCOFF_WAS_UNDEFINED) != 0)
3399                               || (h->flags & XCOFF_DEF_DYNAMIC) != 0
3400                               || (h->flags & XCOFF_IMPORT) != 0);
3401                 }
3402             }
3403         }
3404
3405       if (rel->r_type >= XCOFF_MAX_CALCULATE_RELOCATION
3406           || !((*xcoff_calculate_relocation[rel->r_type])
3407                (input_bfd, input_section, output_bfd, rel, sym, &howto, val,
3408                 addend, &relocation, contents)))
3409         return FALSE;
3410
3411       /* address */
3412       address = rel->r_vaddr - input_section->vma;
3413       location = contents + address;
3414
3415       if (address > input_section->size)
3416         abort ();
3417
3418       /* Get the value we are going to relocate.  */
3419       if (1 == howto.size)
3420         value_to_relocate = bfd_get_16 (input_bfd, location);
3421       else
3422         value_to_relocate = bfd_get_32 (input_bfd, location);
3423
3424       /* overflow.
3425
3426          FIXME: We may drop bits during the addition
3427          which we don't check for.  We must either check at every single
3428          operation, which would be tedious, or we must do the computations
3429          in a type larger than bfd_vma, which would be inefficient.  */
3430
3431       if ((unsigned int) howto.complain_on_overflow
3432           >= XCOFF_MAX_COMPLAIN_OVERFLOW)
3433         abort ();
3434
3435       if (((*xcoff_complain_overflow[howto.complain_on_overflow])
3436            (input_bfd, value_to_relocate, relocation, &howto)))
3437         {
3438           const char *name;
3439           char buf[SYMNMLEN + 1];
3440           char reloc_type_name[10];
3441
3442           if (symndx == -1)
3443             {
3444               name = "*ABS*";
3445             }
3446           else if (h != NULL)
3447             {
3448               name = NULL;
3449             }
3450           else
3451             {
3452               name = _bfd_coff_internal_syment_name (input_bfd, sym, buf);
3453               if (name == NULL)
3454                 name = "UNKNOWN";
3455             }
3456           sprintf (reloc_type_name, "0x%02x", rel->r_type);
3457
3458           if (! ((*info->callbacks->reloc_overflow)
3459                  (info, (h ? &h->root : NULL), name, reloc_type_name,
3460                   (bfd_vma) 0, input_bfd, input_section,
3461                   rel->r_vaddr - input_section->vma)))
3462             return FALSE;
3463         }
3464
3465       /* Add RELOCATION to the right bits of VALUE_TO_RELOCATE.  */
3466       value_to_relocate = ((value_to_relocate & ~howto.dst_mask)
3467                            | (((value_to_relocate & howto.src_mask)
3468                                + relocation) & howto.dst_mask));
3469
3470       /* Put the value back in the object file.  */
3471       if (1 == howto.size)
3472         bfd_put_16 (input_bfd, value_to_relocate, location);
3473       else
3474         bfd_put_32 (input_bfd, value_to_relocate, location);
3475     }
3476
3477   return TRUE;
3478 }
3479
3480 static bfd_boolean
3481 _bfd_xcoff_put_ldsymbol_name (bfd *abfd ATTRIBUTE_UNUSED,
3482                               struct xcoff_loader_info *ldinfo,
3483                               struct internal_ldsym *ldsym,
3484                               const char *name)
3485 {
3486   size_t len;
3487   len = strlen (name);
3488
3489   if (len <= SYMNMLEN)
3490     strncpy (ldsym->_l._l_name, name, SYMNMLEN);
3491   else
3492     {
3493       if (ldinfo->string_size + len + 3 > ldinfo->string_alc)
3494         {
3495           bfd_size_type newalc;
3496           char *newstrings;
3497
3498           newalc = ldinfo->string_alc * 2;
3499           if (newalc == 0)
3500             newalc = 32;
3501           while (ldinfo->string_size + len + 3 > newalc)
3502             newalc *= 2;
3503
3504           newstrings = bfd_realloc (ldinfo->strings, newalc);
3505           if (newstrings == NULL)
3506             {
3507               ldinfo->failed = TRUE;
3508               return FALSE;
3509             }
3510           ldinfo->string_alc = newalc;
3511           ldinfo->strings = newstrings;
3512         }
3513
3514       bfd_put_16 (ldinfo->output_bfd, (bfd_vma) (len + 1),
3515                   ldinfo->strings + ldinfo->string_size);
3516       strcpy (ldinfo->strings + ldinfo->string_size + 2, name);
3517       ldsym->_l._l_l._l_zeroes = 0;
3518       ldsym->_l._l_l._l_offset = ldinfo->string_size + 2;
3519       ldinfo->string_size += len + 3;
3520     }
3521
3522   return TRUE;
3523 }
3524
3525 static bfd_boolean
3526 _bfd_xcoff_put_symbol_name (struct bfd_link_info *info,
3527                             struct bfd_strtab_hash *strtab,
3528                             struct internal_syment *sym,
3529                             const char *name)
3530 {
3531   if (strlen (name) <= SYMNMLEN)
3532     {
3533       strncpy (sym->_n._n_name, name, SYMNMLEN);
3534     }
3535   else
3536     {
3537       bfd_boolean hash;
3538       bfd_size_type indx;
3539
3540       hash = !info->traditional_format;
3541       indx = _bfd_stringtab_add (strtab, name, hash, FALSE);
3542       if (indx == (bfd_size_type) -1)
3543         return FALSE;
3544       sym->_n._n_n._n_zeroes = 0;
3545       sym->_n._n_n._n_offset = STRING_SIZE_SIZE + indx;
3546     }
3547   return TRUE;
3548 }
3549
3550 static asection *
3551 xcoff_create_csect_from_smclas (bfd *abfd,
3552                                 union internal_auxent *aux,
3553                                 const char *symbol_name)
3554 {
3555   asection *return_value = NULL;
3556
3557   /* .sv64 = x_smclas == 17
3558      This is an invalid csect for 32 bit apps.  */
3559   static const char * const names[] =
3560     {
3561       ".pr", ".ro", ".db", ".tc", ".ua", ".rw", ".gl", ".xo", /* 0 - 7 */
3562       ".sv", ".bs", ".ds", ".uc", ".ti", ".tb", NULL, ".tc0", /* 8 - 15 */
3563       ".td", NULL, ".sv3264", NULL, ".tl", ".ul", ".te"
3564     };
3565
3566   if ((aux->x_csect.x_smclas < ARRAY_SIZE (names))
3567       && (NULL != names[aux->x_csect.x_smclas]))
3568     {
3569       return_value = bfd_make_section_anyway
3570         (abfd, names[aux->x_csect.x_smclas]);
3571     }
3572   else
3573     {
3574       (*_bfd_error_handler)
3575         (_("%B: symbol `%s' has unrecognized smclas %d"),
3576          abfd, symbol_name, aux->x_csect.x_smclas);
3577       bfd_set_error (bfd_error_bad_value);
3578     }
3579
3580   return return_value;
3581 }
3582
3583 static bfd_boolean
3584 xcoff_is_lineno_count_overflow (bfd *abfd ATTRIBUTE_UNUSED, bfd_vma value)
3585 {
3586   if (0xffff <= value)
3587     return TRUE;
3588
3589   return FALSE;
3590 }
3591
3592 static bfd_boolean
3593 xcoff_is_reloc_count_overflow (bfd *abfd ATTRIBUTE_UNUSED, bfd_vma value)
3594 {
3595   if (0xffff <= value)
3596     return TRUE;
3597
3598   return FALSE;
3599 }
3600
3601 static bfd_vma
3602 xcoff_loader_symbol_offset (bfd *abfd,
3603                             struct internal_ldhdr *ldhdr ATTRIBUTE_UNUSED)
3604 {
3605   return bfd_xcoff_ldhdrsz (abfd);
3606 }
3607
3608 static bfd_vma
3609 xcoff_loader_reloc_offset (bfd *abfd, struct internal_ldhdr *ldhdr)
3610 {
3611   return bfd_xcoff_ldhdrsz (abfd) + ldhdr->l_nsyms * bfd_xcoff_ldsymsz (abfd);
3612 }
3613
3614 static bfd_boolean
3615 xcoff_generate_rtinit  (bfd *abfd, const char *init, const char *fini,
3616                         bfd_boolean rtld)
3617 {
3618   bfd_byte filehdr_ext[FILHSZ];
3619   bfd_byte scnhdr_ext[SCNHSZ];
3620   bfd_byte syment_ext[SYMESZ * 10];
3621   bfd_byte reloc_ext[RELSZ * 3];
3622   bfd_byte *data_buffer;
3623   bfd_size_type data_buffer_size;
3624   bfd_byte *string_table = NULL, *st_tmp = NULL;
3625   bfd_size_type string_table_size;
3626   bfd_vma val;
3627   size_t initsz, finisz;
3628   struct internal_filehdr filehdr;
3629   struct internal_scnhdr scnhdr;
3630   struct internal_syment syment;
3631   union internal_auxent auxent;
3632   struct internal_reloc reloc;
3633
3634   char *data_name = ".data";
3635   char *rtinit_name = "__rtinit";
3636   char *rtld_name = "__rtld";
3637
3638   if (! bfd_xcoff_rtinit_size (abfd))
3639     return FALSE;
3640
3641   initsz = (init == NULL ? 0 : 1 + strlen (init));
3642   finisz = (fini == NULL ? 0 : 1 + strlen (fini));
3643
3644   /* file header */
3645   memset (filehdr_ext, 0, FILHSZ);
3646   memset (&filehdr, 0, sizeof (struct internal_filehdr));
3647   filehdr.f_magic = bfd_xcoff_magic_number (abfd);
3648   filehdr.f_nscns = 1;
3649   filehdr.f_timdat = 0;
3650   filehdr.f_nsyms = 0;  /* at least 6, no more than 10 */
3651   filehdr.f_symptr = 0; /* set below */
3652   filehdr.f_opthdr = 0;
3653   filehdr.f_flags = 0;
3654
3655   /* section header */
3656   memset (scnhdr_ext, 0, SCNHSZ);
3657   memset (&scnhdr, 0, sizeof (struct internal_scnhdr));
3658   memcpy (scnhdr.s_name, data_name, strlen (data_name));
3659   scnhdr.s_paddr = 0;
3660   scnhdr.s_vaddr = 0;
3661   scnhdr.s_size = 0;    /* set below */
3662   scnhdr.s_scnptr = FILHSZ + SCNHSZ;
3663   scnhdr.s_relptr = 0;  /* set below */
3664   scnhdr.s_lnnoptr = 0;
3665   scnhdr.s_nreloc = 0;  /* either 1 or 2 */
3666   scnhdr.s_nlnno = 0;
3667   scnhdr.s_flags = STYP_DATA;
3668
3669   /* .data
3670      0x0000           0x00000000 : rtl
3671      0x0004           0x00000010 : offset to init, or 0
3672      0x0008           0x00000028 : offset to fini, or 0
3673      0x000C           0x0000000C : size of descriptor
3674      0x0010           0x00000000 : init, needs a reloc
3675      0x0014           0x00000040 : offset to init name
3676      0x0018           0x00000000 : flags, padded to a word
3677      0x001C           0x00000000 : empty init
3678      0x0020           0x00000000 :
3679      0x0024           0x00000000 :
3680      0x0028           0x00000000 : fini, needs a reloc
3681      0x002C           0x00000??? : offset to fini name
3682      0x0030           0x00000000 : flags, padded to a word
3683      0x0034           0x00000000 : empty fini
3684      0x0038           0x00000000 :
3685      0x003C           0x00000000 :
3686      0x0040           init name
3687      0x0040 + initsz  fini name */
3688
3689   data_buffer_size = 0x0040 + initsz + finisz;
3690   data_buffer_size = (data_buffer_size + 7) &~ (bfd_size_type) 7;
3691   data_buffer = NULL;
3692   data_buffer = (bfd_byte *) bfd_zmalloc (data_buffer_size);
3693   if (data_buffer == NULL)
3694     return FALSE;
3695
3696   if (initsz)
3697     {
3698       val = 0x10;
3699       bfd_h_put_32 (abfd, val, &data_buffer[0x04]);
3700       val = 0x40;
3701       bfd_h_put_32 (abfd, val, &data_buffer[0x14]);
3702       memcpy (&data_buffer[val], init, initsz);
3703     }
3704
3705   if (finisz)
3706     {
3707       val = 0x28;
3708       bfd_h_put_32 (abfd, val, &data_buffer[0x08]);
3709       val = 0x40 + initsz;
3710       bfd_h_put_32 (abfd, val, &data_buffer[0x2C]);
3711       memcpy (&data_buffer[val], fini, finisz);
3712     }
3713
3714   val = 0x0C;
3715   bfd_h_put_32 (abfd, val, &data_buffer[0x0C]);
3716
3717   scnhdr.s_size = data_buffer_size;
3718
3719   /* string table */
3720   string_table_size = 0;
3721   if (initsz > 9)
3722     string_table_size += initsz;
3723   if (finisz > 9)
3724     string_table_size += finisz;
3725   if (string_table_size)
3726     {
3727       string_table_size += 4;
3728       string_table = (bfd_byte *) bfd_zmalloc (string_table_size);
3729       if (string_table == NULL)
3730         return FALSE;
3731
3732       val = string_table_size;
3733       bfd_h_put_32 (abfd, val, &string_table[0]);
3734       st_tmp = string_table + 4;
3735     }
3736
3737   /* symbols
3738      0. .data csect
3739      2. __rtinit
3740      4. init function
3741      6. fini function
3742      8. __rtld  */
3743   memset (syment_ext, 0, 10 * SYMESZ);
3744   memset (reloc_ext, 0, 3 * RELSZ);
3745
3746   /* .data csect */
3747   memset (&syment, 0, sizeof (struct internal_syment));
3748   memset (&auxent, 0, sizeof (union internal_auxent));
3749   memcpy (syment._n._n_name, data_name, strlen (data_name));
3750   syment.n_scnum = 1;
3751   syment.n_sclass = C_HIDEXT;
3752   syment.n_numaux = 1;
3753   auxent.x_csect.x_scnlen.l = data_buffer_size;
3754   auxent.x_csect.x_smtyp = 3 << 3 | XTY_SD;
3755   auxent.x_csect.x_smclas = XMC_RW;
3756   bfd_coff_swap_sym_out (abfd, &syment,
3757                          &syment_ext[filehdr.f_nsyms * SYMESZ]);
3758   bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0,
3759                          syment.n_numaux,
3760                          &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]);
3761   filehdr.f_nsyms += 2;
3762
3763   /* __rtinit */
3764   memset (&syment, 0, sizeof (struct internal_syment));
3765   memset (&auxent, 0, sizeof (union internal_auxent));
3766   memcpy (syment._n._n_name, rtinit_name, strlen (rtinit_name));
3767   syment.n_scnum = 1;
3768   syment.n_sclass = C_EXT;
3769   syment.n_numaux = 1;
3770   auxent.x_csect.x_smtyp = XTY_LD;
3771   auxent.x_csect.x_smclas = XMC_RW;
3772   bfd_coff_swap_sym_out (abfd, &syment,
3773                          &syment_ext[filehdr.f_nsyms * SYMESZ]);
3774   bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0,
3775                          syment.n_numaux,
3776                          &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]);
3777   filehdr.f_nsyms += 2;
3778
3779   /* init */
3780   if (initsz)
3781     {
3782       memset (&syment, 0, sizeof (struct internal_syment));
3783       memset (&auxent, 0, sizeof (union internal_auxent));
3784
3785       if (initsz > 9)
3786         {
3787           syment._n._n_n._n_offset = st_tmp - string_table;
3788           memcpy (st_tmp, init, initsz);
3789           st_tmp += initsz;
3790         }
3791       else
3792         memcpy (syment._n._n_name, init, initsz - 1);
3793
3794       syment.n_sclass = C_EXT;
3795       syment.n_numaux = 1;
3796       bfd_coff_swap_sym_out (abfd, &syment,
3797                              &syment_ext[filehdr.f_nsyms * SYMESZ]);
3798       bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0,
3799                              syment.n_numaux,
3800                              &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]);
3801
3802       /* reloc */
3803       memset (&reloc, 0, sizeof (struct internal_reloc));
3804       reloc.r_vaddr = 0x0010;
3805       reloc.r_symndx = filehdr.f_nsyms;
3806       reloc.r_type = R_POS;
3807       reloc.r_size = 31;
3808       bfd_coff_swap_reloc_out (abfd, &reloc, &reloc_ext[0]);
3809
3810       filehdr.f_nsyms += 2;
3811       scnhdr.s_nreloc += 1;
3812     }
3813
3814   /* fini */
3815   if (finisz)
3816     {
3817       memset (&syment, 0, sizeof (struct internal_syment));
3818       memset (&auxent, 0, sizeof (union internal_auxent));
3819
3820       if (finisz > 9)
3821         {
3822           syment._n._n_n._n_offset = st_tmp - string_table;
3823           memcpy (st_tmp, fini, finisz);
3824           st_tmp += finisz;
3825         }
3826       else
3827         memcpy (syment._n._n_name, fini, finisz - 1);
3828
3829       syment.n_sclass = C_EXT;
3830       syment.n_numaux = 1;
3831       bfd_coff_swap_sym_out (abfd, &syment,
3832                              &syment_ext[filehdr.f_nsyms * SYMESZ]);
3833       bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0,
3834                              syment.n_numaux,
3835                              &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]);
3836
3837       /* reloc */
3838       memset (&reloc, 0, sizeof (struct internal_reloc));
3839       reloc.r_vaddr = 0x0028;
3840       reloc.r_symndx = filehdr.f_nsyms;
3841       reloc.r_type = R_POS;
3842       reloc.r_size = 31;
3843       bfd_coff_swap_reloc_out (abfd, &reloc,
3844                                &reloc_ext[scnhdr.s_nreloc * RELSZ]);
3845
3846       filehdr.f_nsyms += 2;
3847       scnhdr.s_nreloc += 1;
3848     }
3849
3850   if (rtld)
3851     {
3852       memset (&syment, 0, sizeof (struct internal_syment));
3853       memset (&auxent, 0, sizeof (union internal_auxent));
3854       memcpy (syment._n._n_name, rtld_name, strlen (rtld_name));
3855       syment.n_sclass = C_EXT;
3856       syment.n_numaux = 1;
3857       bfd_coff_swap_sym_out (abfd, &syment,
3858                              &syment_ext[filehdr.f_nsyms * SYMESZ]);
3859       bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0,
3860                              syment.n_numaux,
3861                              &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]);
3862
3863       /* reloc */
3864       memset (&reloc, 0, sizeof (struct internal_reloc));
3865       reloc.r_vaddr = 0x0000;
3866       reloc.r_symndx = filehdr.f_nsyms;
3867       reloc.r_type = R_POS;
3868       reloc.r_size = 31;
3869       bfd_coff_swap_reloc_out (abfd, &reloc,
3870                                &reloc_ext[scnhdr.s_nreloc * RELSZ]);
3871
3872       filehdr.f_nsyms += 2;
3873       scnhdr.s_nreloc += 1;
3874     }
3875
3876   scnhdr.s_relptr = scnhdr.s_scnptr + data_buffer_size;
3877   filehdr.f_symptr = scnhdr.s_relptr + scnhdr.s_nreloc * RELSZ;
3878
3879   bfd_coff_swap_filehdr_out (abfd, &filehdr, filehdr_ext);
3880   bfd_bwrite (filehdr_ext, FILHSZ, abfd);
3881   bfd_coff_swap_scnhdr_out (abfd, &scnhdr, scnhdr_ext);
3882   bfd_bwrite (scnhdr_ext, SCNHSZ, abfd);
3883   bfd_bwrite (data_buffer, data_buffer_size, abfd);
3884   bfd_bwrite (reloc_ext, scnhdr.s_nreloc * RELSZ, abfd);
3885   bfd_bwrite (syment_ext, filehdr.f_nsyms * SYMESZ, abfd);
3886   bfd_bwrite (string_table, string_table_size, abfd);
3887
3888   free (data_buffer);
3889   data_buffer = NULL;
3890
3891   return TRUE;
3892 }
3893
3894
3895 static reloc_howto_type xcoff_dynamic_reloc =
3896 HOWTO (0,                       /* type */
3897        0,                       /* rightshift */
3898        2,                       /* size (0 = byte, 1 = short, 2 = long) */
3899        32,                      /* bitsize */
3900        FALSE,                   /* pc_relative */
3901        0,                       /* bitpos */
3902        complain_overflow_bitfield, /* complain_on_overflow */
3903        0,                       /* special_function */
3904        "R_POS",                 /* name */
3905        TRUE,                    /* partial_inplace */
3906        0xffffffff,              /* src_mask */
3907        0xffffffff,              /* dst_mask */
3908        FALSE);                  /* pcrel_offset */
3909
3910 /*  glink
3911
3912    The first word of global linkage code must be modified by filling in
3913    the correct TOC offset.  */
3914
3915 static unsigned long xcoff_glink_code[9] =
3916   {
3917     0x81820000, /* lwz r12,0(r2) */
3918     0x90410014, /* stw r2,20(r1) */
3919     0x800c0000, /* lwz r0,0(r12) */
3920     0x804c0004, /* lwz r2,4(r12) */
3921     0x7c0903a6, /* mtctr r0 */
3922     0x4e800420, /* bctr */
3923     0x00000000, /* start of traceback table */
3924     0x000c8000, /* traceback table */
3925     0x00000000, /* traceback table */
3926   };
3927
3928 /* Table to convert DWARF flags to section names.  */
3929
3930 const struct xcoff_dwsect_name xcoff_dwsect_names[] = {
3931   { SSUBTYP_DWINFO,  ".dwinfo",   TRUE },
3932   { SSUBTYP_DWLINE,  ".dwline",   TRUE },
3933   { SSUBTYP_DWPBNMS, ".dwpbnms",  TRUE },
3934   { SSUBTYP_DWPBTYP, ".dwpbtyp",  TRUE },
3935   { SSUBTYP_DWARNGE, ".dwarnge",  TRUE },
3936   { SSUBTYP_DWABREV, ".dwabrev",  FALSE },
3937   { SSUBTYP_DWSTR,   ".dwstr",    TRUE },
3938   { SSUBTYP_DWRNGES, ".dwrnges",  TRUE }
3939 };
3940
3941 /* For generic entry points.  */
3942 #define _bfd_xcoff_close_and_cleanup _bfd_archive_close_and_cleanup
3943 #define _bfd_xcoff_bfd_free_cached_info bfd_true
3944 #define _bfd_xcoff_new_section_hook coff_new_section_hook
3945 #define _bfd_xcoff_get_section_contents _bfd_generic_get_section_contents
3946 #define _bfd_xcoff_get_section_contents_in_window \
3947   _bfd_generic_get_section_contents_in_window
3948
3949 /* For copy private data entry points.  */
3950 #define _bfd_xcoff_bfd_copy_private_bfd_data \
3951   _bfd_xcoff_copy_private_bfd_data
3952 #define _bfd_xcoff_bfd_merge_private_bfd_data \
3953   _bfd_generic_bfd_merge_private_bfd_data
3954 #define _bfd_xcoff_bfd_copy_private_section_data \
3955   _bfd_generic_bfd_copy_private_section_data
3956 #define _bfd_xcoff_bfd_copy_private_symbol_data \
3957    _bfd_generic_bfd_copy_private_symbol_data
3958 #define _bfd_xcoff_bfd_copy_private_header_data \
3959    _bfd_generic_bfd_copy_private_header_data
3960 #define _bfd_xcoff_bfd_set_private_flags \
3961    _bfd_generic_bfd_set_private_flags
3962 #define _bfd_xcoff_bfd_print_private_bfd_data \
3963    _bfd_generic_bfd_print_private_bfd_data
3964
3965 /* For archive entry points.  */
3966 #define _bfd_xcoff_slurp_extended_name_table \
3967    _bfd_noarchive_slurp_extended_name_table
3968 #define _bfd_xcoff_construct_extended_name_table \
3969    _bfd_noarchive_construct_extended_name_table
3970 #define _bfd_xcoff_truncate_arname bfd_dont_truncate_arname
3971 #define _bfd_xcoff_write_ar_hdr _bfd_generic_write_ar_hdr
3972 #define _bfd_xcoff_get_elt_at_index _bfd_generic_get_elt_at_index
3973 #define _bfd_xcoff_generic_stat_arch_elt _bfd_xcoff_stat_arch_elt
3974 #define _bfd_xcoff_update_armap_timestamp bfd_true
3975
3976 /* For symbols entry points.  */
3977 #define _bfd_xcoff_get_symtab_upper_bound coff_get_symtab_upper_bound
3978 #define _bfd_xcoff_canonicalize_symtab coff_canonicalize_symtab
3979 #define _bfd_xcoff_make_empty_symbol coff_make_empty_symbol
3980 #define _bfd_xcoff_print_symbol coff_print_symbol
3981 #define _bfd_xcoff_get_symbol_info coff_get_symbol_info
3982 #define _bfd_xcoff_get_symbol_version_string \
3983   _bfd_nosymbols_get_symbol_version_string
3984 #define _bfd_xcoff_bfd_is_local_label_name _bfd_xcoff_is_local_label_name
3985 #define _bfd_xcoff_bfd_is_target_special_symbol \
3986   coff_bfd_is_target_special_symbol
3987 #define _bfd_xcoff_get_lineno coff_get_lineno
3988 #define _bfd_xcoff_find_nearest_line coff_find_nearest_line
3989 #define _bfd_xcoff_find_line coff_find_line
3990 #define _bfd_xcoff_find_inliner_info coff_find_inliner_info
3991 #define _bfd_xcoff_bfd_make_debug_symbol coff_bfd_make_debug_symbol
3992 #define _bfd_xcoff_read_minisymbols _bfd_generic_read_minisymbols
3993 #define _bfd_xcoff_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
3994
3995 /* For reloc entry points.  */
3996 #define _bfd_xcoff_get_reloc_upper_bound coff_get_reloc_upper_bound
3997 #define _bfd_xcoff_canonicalize_reloc coff_canonicalize_reloc
3998 #define _bfd_xcoff_bfd_reloc_type_lookup _bfd_xcoff_reloc_type_lookup
3999 #define _bfd_xcoff_bfd_reloc_name_lookup _bfd_xcoff_reloc_name_lookup
4000
4001 /* For link entry points.  */
4002 #define _bfd_xcoff_bfd_get_relocated_section_contents \
4003   bfd_generic_get_relocated_section_contents
4004 #define _bfd_xcoff_bfd_relax_section bfd_generic_relax_section
4005 #define _bfd_xcoff_bfd_link_hash_table_free _bfd_generic_link_hash_table_free
4006 #define _bfd_xcoff_bfd_link_just_syms _bfd_generic_link_just_syms
4007 #define _bfd_xcoff_bfd_copy_link_hash_symbol_type \
4008   _bfd_generic_copy_link_hash_symbol_type
4009 #define _bfd_xcoff_bfd_link_split_section _bfd_generic_link_split_section
4010 #define _bfd_xcoff_bfd_gc_sections bfd_generic_gc_sections
4011 #define _bfd_xcoff_bfd_lookup_section_flags bfd_generic_lookup_section_flags
4012 #define _bfd_xcoff_bfd_merge_sections bfd_generic_merge_sections
4013 #define _bfd_xcoff_bfd_is_group_section bfd_generic_is_group_section
4014 #define _bfd_xcoff_bfd_discard_group bfd_generic_discard_group
4015 #define _bfd_xcoff_section_already_linked _bfd_generic_section_already_linked
4016 #define _bfd_xcoff_bfd_define_common_symbol _bfd_xcoff_define_common_symbol
4017
4018 /* For dynamic symbols and relocs entry points.  */
4019 #define _bfd_xcoff_get_synthetic_symtab _bfd_nodynamic_get_synthetic_symtab
4020
4021 static const struct xcoff_backend_data_rec bfd_xcoff_backend_data =
4022   {
4023     { /* COFF backend, defined in libcoff.h.  */
4024       _bfd_xcoff_swap_aux_in,
4025       _bfd_xcoff_swap_sym_in,
4026       coff_swap_lineno_in,
4027       _bfd_xcoff_swap_aux_out,
4028       _bfd_xcoff_swap_sym_out,
4029       coff_swap_lineno_out,
4030       xcoff_swap_reloc_out,
4031       coff_swap_filehdr_out,
4032       coff_swap_aouthdr_out,
4033       coff_swap_scnhdr_out,
4034       FILHSZ,
4035       AOUTSZ,
4036       SCNHSZ,
4037       SYMESZ,
4038       AUXESZ,
4039       RELSZ,
4040       LINESZ,
4041       FILNMLEN,
4042       TRUE,                     /* _bfd_coff_long_filenames */
4043       XCOFF_NO_LONG_SECTION_NAMES,  /* _bfd_coff_long_section_names */
4044       3,                        /* _bfd_coff_default_section_alignment_power */
4045       FALSE,                    /* _bfd_coff_force_symnames_in_strings */
4046       2,                        /* _bfd_coff_debug_string_prefix_length */
4047       32768,                    /* _bfd_coff_max_nscns */
4048       coff_swap_filehdr_in,
4049       coff_swap_aouthdr_in,
4050       coff_swap_scnhdr_in,
4051       xcoff_swap_reloc_in,
4052       coff_bad_format_hook,
4053       coff_set_arch_mach_hook,
4054       coff_mkobject_hook,
4055       styp_to_sec_flags,
4056       coff_set_alignment_hook,
4057       coff_slurp_symbol_table,
4058       symname_in_debug_hook,
4059       coff_pointerize_aux_hook,
4060       coff_print_aux,
4061       dummy_reloc16_extra_cases,
4062       dummy_reloc16_estimate,
4063       NULL,                     /* bfd_coff_sym_is_global */
4064       coff_compute_section_file_positions,
4065       NULL,                     /* _bfd_coff_start_final_link */
4066       xcoff_ppc_relocate_section,
4067       coff_rtype_to_howto,
4068       NULL,                     /* _bfd_coff_adjust_symndx */
4069       _bfd_generic_link_add_one_symbol,
4070       coff_link_output_has_begun,
4071       coff_final_link_postscript,
4072       NULL                      /* print_pdata.  */
4073     },
4074
4075     0x01DF,                     /* magic number */
4076     bfd_arch_rs6000,
4077     bfd_mach_rs6k,
4078
4079     /* Function pointers to xcoff specific swap routines.  */
4080     xcoff_swap_ldhdr_in,
4081     xcoff_swap_ldhdr_out,
4082     xcoff_swap_ldsym_in,
4083     xcoff_swap_ldsym_out,
4084     xcoff_swap_ldrel_in,
4085     xcoff_swap_ldrel_out,
4086
4087     /* Sizes.  */
4088     LDHDRSZ,
4089     LDSYMSZ,
4090     LDRELSZ,
4091     12,                         /* _xcoff_function_descriptor_size */
4092     SMALL_AOUTSZ,
4093
4094     /* Versions.  */
4095     1,                          /* _xcoff_ldhdr_version */
4096
4097     _bfd_xcoff_put_symbol_name,
4098     _bfd_xcoff_put_ldsymbol_name,
4099     &xcoff_dynamic_reloc,
4100     xcoff_create_csect_from_smclas,
4101
4102     /* Lineno and reloc count overflow.  */
4103     xcoff_is_lineno_count_overflow,
4104     xcoff_is_reloc_count_overflow,
4105
4106     xcoff_loader_symbol_offset,
4107     xcoff_loader_reloc_offset,
4108
4109     /* glink.  */
4110     &xcoff_glink_code[0],
4111     36,                         /* _xcoff_glink_size */
4112
4113     /* rtinit */
4114     64,                         /* _xcoff_rtinit_size */
4115     xcoff_generate_rtinit,
4116   };
4117
4118 /* The transfer vector that leads the outside world to all of the above.  */
4119 const bfd_target rs6000_xcoff_vec =
4120   {
4121     "aixcoff-rs6000",
4122     bfd_target_xcoff_flavour,
4123     BFD_ENDIAN_BIG,             /* data byte order is big */
4124     BFD_ENDIAN_BIG,             /* header byte order is big */
4125
4126     (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | DYNAMIC
4127      | HAS_SYMS | HAS_LOCALS | WP_TEXT),
4128
4129     SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA,
4130     0,                          /* leading char */
4131     '/',                        /* ar_pad_char */
4132     15,                         /* ar_max_namelen */
4133     0,                          /* match priority.  */
4134
4135     /* data */
4136     bfd_getb64,
4137     bfd_getb_signed_64,
4138     bfd_putb64,
4139     bfd_getb32,
4140     bfd_getb_signed_32,
4141     bfd_putb32,
4142     bfd_getb16,
4143     bfd_getb_signed_16,
4144     bfd_putb16,
4145
4146     /* hdrs */
4147     bfd_getb64,
4148     bfd_getb_signed_64,
4149     bfd_putb64,
4150     bfd_getb32,
4151     bfd_getb_signed_32,
4152     bfd_putb32,
4153     bfd_getb16,
4154     bfd_getb_signed_16,
4155     bfd_putb16,
4156
4157     { /* bfd_check_format */
4158       _bfd_dummy_target,
4159       coff_object_p,
4160       _bfd_xcoff_archive_p,
4161       CORE_FILE_P
4162     },
4163
4164     { /* bfd_set_format */
4165       bfd_false,
4166       coff_mkobject,
4167       _bfd_generic_mkarchive,
4168       bfd_false
4169     },
4170
4171     {/* bfd_write_contents */
4172       bfd_false,
4173       coff_write_object_contents,
4174       _bfd_xcoff_write_archive_contents,
4175       bfd_false
4176     },
4177
4178     BFD_JUMP_TABLE_GENERIC (_bfd_xcoff),
4179     BFD_JUMP_TABLE_COPY (_bfd_xcoff),
4180     BFD_JUMP_TABLE_CORE (coff),
4181     BFD_JUMP_TABLE_ARCHIVE (_bfd_xcoff),
4182     BFD_JUMP_TABLE_SYMBOLS (_bfd_xcoff),
4183     BFD_JUMP_TABLE_RELOCS (_bfd_xcoff),
4184     BFD_JUMP_TABLE_WRITE (coff),
4185     BFD_JUMP_TABLE_LINK (_bfd_xcoff),
4186     BFD_JUMP_TABLE_DYNAMIC (_bfd_xcoff),
4187
4188     /* Opposite endian version, none exists */
4189     NULL,
4190
4191     & bfd_xcoff_backend_data,
4192   };
4193
4194 /* xcoff-powermac target
4195    Old target.
4196    Only difference between this target and the rs6000 target is the
4197    the default architecture and machine type used in coffcode.h
4198
4199    PowerPC Macs use the same magic numbers as RS/6000
4200    (because that's how they were bootstrapped originally),
4201    but they are always PowerPC architecture.  */
4202 static const struct xcoff_backend_data_rec bfd_pmac_xcoff_backend_data =
4203   {
4204     { /* COFF backend, defined in libcoff.h.  */
4205       _bfd_xcoff_swap_aux_in,
4206       _bfd_xcoff_swap_sym_in,
4207       coff_swap_lineno_in,
4208       _bfd_xcoff_swap_aux_out,
4209       _bfd_xcoff_swap_sym_out,
4210       coff_swap_lineno_out,
4211       xcoff_swap_reloc_out,
4212       coff_swap_filehdr_out,
4213       coff_swap_aouthdr_out,
4214       coff_swap_scnhdr_out,
4215       FILHSZ,
4216       AOUTSZ,
4217       SCNHSZ,
4218       SYMESZ,
4219       AUXESZ,
4220       RELSZ,
4221       LINESZ,
4222       FILNMLEN,
4223       TRUE,                     /* _bfd_coff_long_filenames */
4224       XCOFF_NO_LONG_SECTION_NAMES,  /* _bfd_coff_long_section_names */
4225       3,                        /* _bfd_coff_default_section_alignment_power */
4226       FALSE,                    /* _bfd_coff_force_symnames_in_strings */
4227       2,                        /* _bfd_coff_debug_string_prefix_length */
4228       32768,                    /* _bfd_coff_max_nscns */
4229       coff_swap_filehdr_in,
4230       coff_swap_aouthdr_in,
4231       coff_swap_scnhdr_in,
4232       xcoff_swap_reloc_in,
4233       coff_bad_format_hook,
4234       coff_set_arch_mach_hook,
4235       coff_mkobject_hook,
4236       styp_to_sec_flags,
4237       coff_set_alignment_hook,
4238       coff_slurp_symbol_table,
4239       symname_in_debug_hook,
4240       coff_pointerize_aux_hook,
4241       coff_print_aux,
4242       dummy_reloc16_extra_cases,
4243       dummy_reloc16_estimate,
4244       NULL,                     /* bfd_coff_sym_is_global */
4245       coff_compute_section_file_positions,
4246       NULL,                     /* _bfd_coff_start_final_link */
4247       xcoff_ppc_relocate_section,
4248       coff_rtype_to_howto,
4249       NULL,                     /* _bfd_coff_adjust_symndx */
4250       _bfd_generic_link_add_one_symbol,
4251       coff_link_output_has_begun,
4252       coff_final_link_postscript,
4253       NULL                      /* print_pdata.  */
4254     },
4255
4256     0x01DF,                     /* magic number */
4257     bfd_arch_powerpc,
4258     bfd_mach_ppc,
4259
4260     /* Function pointers to xcoff specific swap routines.  */
4261     xcoff_swap_ldhdr_in,
4262     xcoff_swap_ldhdr_out,
4263     xcoff_swap_ldsym_in,
4264     xcoff_swap_ldsym_out,
4265     xcoff_swap_ldrel_in,
4266     xcoff_swap_ldrel_out,
4267
4268     /* Sizes.  */
4269     LDHDRSZ,
4270     LDSYMSZ,
4271     LDRELSZ,
4272     12,                         /* _xcoff_function_descriptor_size */
4273     SMALL_AOUTSZ,
4274
4275     /* Versions.  */
4276     1,                          /* _xcoff_ldhdr_version */
4277
4278     _bfd_xcoff_put_symbol_name,
4279     _bfd_xcoff_put_ldsymbol_name,
4280     &xcoff_dynamic_reloc,
4281     xcoff_create_csect_from_smclas,
4282
4283     /* Lineno and reloc count overflow.  */
4284     xcoff_is_lineno_count_overflow,
4285     xcoff_is_reloc_count_overflow,
4286
4287     xcoff_loader_symbol_offset,
4288     xcoff_loader_reloc_offset,
4289
4290     /* glink.  */
4291     &xcoff_glink_code[0],
4292     36,                         /* _xcoff_glink_size */
4293
4294     /* rtinit */
4295     0,                          /* _xcoff_rtinit_size */
4296     xcoff_generate_rtinit,
4297   };
4298
4299 /* The transfer vector that leads the outside world to all of the above.  */
4300 const bfd_target powerpc_xcoff_vec =
4301   {
4302     "xcoff-powermac",
4303     bfd_target_xcoff_flavour,
4304     BFD_ENDIAN_BIG,             /* data byte order is big */
4305     BFD_ENDIAN_BIG,             /* header byte order is big */
4306
4307     (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | DYNAMIC
4308      | HAS_SYMS | HAS_LOCALS | WP_TEXT),
4309
4310     SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA,
4311     0,                          /* leading char */
4312     '/',                        /* ar_pad_char */
4313     15,                         /* ar_max_namelen */
4314     0,                          /* match priority.  */
4315
4316     /* data */
4317     bfd_getb64,
4318     bfd_getb_signed_64,
4319     bfd_putb64,
4320     bfd_getb32,
4321     bfd_getb_signed_32,
4322     bfd_putb32,
4323     bfd_getb16,
4324     bfd_getb_signed_16,
4325     bfd_putb16,
4326
4327     /* hdrs */
4328     bfd_getb64,
4329     bfd_getb_signed_64,
4330     bfd_putb64,
4331     bfd_getb32,
4332     bfd_getb_signed_32,
4333     bfd_putb32,
4334     bfd_getb16,
4335     bfd_getb_signed_16,
4336     bfd_putb16,
4337
4338     { /* bfd_check_format */
4339       _bfd_dummy_target,
4340       coff_object_p,
4341       _bfd_xcoff_archive_p,
4342       CORE_FILE_P
4343     },
4344
4345     { /* bfd_set_format */
4346       bfd_false,
4347       coff_mkobject,
4348       _bfd_generic_mkarchive,
4349       bfd_false
4350     },
4351
4352     {/* bfd_write_contents */
4353       bfd_false,
4354       coff_write_object_contents,
4355       _bfd_xcoff_write_archive_contents,
4356       bfd_false
4357     },
4358
4359     BFD_JUMP_TABLE_GENERIC (_bfd_xcoff),
4360     BFD_JUMP_TABLE_COPY (_bfd_xcoff),
4361     BFD_JUMP_TABLE_CORE (coff),
4362     BFD_JUMP_TABLE_ARCHIVE (_bfd_xcoff),
4363     BFD_JUMP_TABLE_SYMBOLS (_bfd_xcoff),
4364     BFD_JUMP_TABLE_RELOCS (_bfd_xcoff),
4365     BFD_JUMP_TABLE_WRITE (coff),
4366     BFD_JUMP_TABLE_LINK (_bfd_xcoff),
4367     BFD_JUMP_TABLE_DYNAMIC (_bfd_xcoff),
4368
4369     /* Opposite endian version, none exists */
4370     NULL,
4371
4372     & bfd_pmac_xcoff_backend_data,
4373   };