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