bfd/coff-rs6000.c

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