bfd/coff-rs6000.c

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