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