bfd/coff-rs6000.c

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