bfd/coff-rs6000.c

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