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