bfd/coff-rs6000.c

   1 /* BFD back-end for IBM RS/6000 "XCOFF" files.
   2    Copyright 1990-1999, 2000, 2001, 2002, 2003
   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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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 *, bfd_boolean));
  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 *, ufile_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   bfd_ardata (abfd)->cache = NULL;
1298   bfd_ardata (abfd)->archive_head = NULL;
1299   bfd_ardata (abfd)->symdefs = NULL;
1300   bfd_ardata (abfd)->extended_names = NULL;
1301
1302   /* Now handle the two formats.  */
1303   if (magic[1] != 'b')
1304     {
1305       /* This is the old format.  */
1306       struct xcoff_ar_file_hdr hdr;
1307
1308       /* Copy over the magic string.  */
1309       memcpy (hdr.magic, magic, SXCOFFARMAG);
1310
1311       /* Now read the rest of the file header.  */
1312       amt = SIZEOF_AR_FILE_HDR - SXCOFFARMAG;
1313       if (bfd_bread ((PTR) &hdr.memoff, amt, abfd) != amt)
1314         {
1315           if (bfd_get_error () != bfd_error_system_call)
1316             bfd_set_error (bfd_error_wrong_format);
1317           goto error_ret;
1318         }
1319
1320       bfd_ardata (abfd)->first_file_filepos = strtol (hdr.firstmemoff,
1321                                                       (char **) NULL, 10);
1322
1323       amt = SIZEOF_AR_FILE_HDR;
1324       bfd_ardata (abfd)->tdata = bfd_zalloc (abfd, amt);
1325       if (bfd_ardata (abfd)->tdata == NULL)
1326         goto error_ret;
1327
1328       memcpy (bfd_ardata (abfd)->tdata, &hdr, SIZEOF_AR_FILE_HDR);
1329     }
1330   else
1331     {
1332       /* This is the new format.  */
1333       struct xcoff_ar_file_hdr_big hdr;
1334
1335       /* Copy over the magic string.  */
1336       memcpy (hdr.magic, magic, SXCOFFARMAG);
1337
1338       /* Now read the rest of the file header.  */
1339       amt = SIZEOF_AR_FILE_HDR_BIG - SXCOFFARMAG;
1340       if (bfd_bread ((PTR) &hdr.memoff, amt, abfd) != amt)
1341         {
1342           if (bfd_get_error () != bfd_error_system_call)
1343             bfd_set_error (bfd_error_wrong_format);
1344           goto error_ret;
1345         }
1346
1347       bfd_ardata (abfd)->first_file_filepos = bfd_scan_vma (hdr.firstmemoff,
1348                                                             (const char **) 0,
1349                                                             10);
1350
1351       amt = SIZEOF_AR_FILE_HDR_BIG;
1352       bfd_ardata (abfd)->tdata = bfd_zalloc (abfd, amt);
1353       if (bfd_ardata (abfd)->tdata == NULL)
1354         goto error_ret;
1355
1356       memcpy (bfd_ardata (abfd)->tdata, &hdr, SIZEOF_AR_FILE_HDR_BIG);
1357     }
1358
1359   if (! _bfd_xcoff_slurp_armap (abfd))
1360     {
1361     error_ret:
1362       bfd_release (abfd, bfd_ardata (abfd));
1363     error_ret_restore:
1364       bfd_ardata (abfd) = tdata_hold;
1365       return NULL;
1366     }
1367
1368   return abfd->xvec;
1369 }
1370
1371 /* Read the archive header in an XCOFF archive.  */
1372
1373 PTR
1374 _bfd_xcoff_read_ar_hdr (abfd)
1375      bfd *abfd;
1376 {
1377   bfd_size_type namlen;
1378   struct areltdata *ret;
1379   bfd_size_type amt = sizeof (struct areltdata);
1380
1381   ret = (struct areltdata *) bfd_alloc (abfd, amt);
1382   if (ret == NULL)
1383     return NULL;
1384
1385   if (! xcoff_big_format_p (abfd))
1386     {
1387       struct xcoff_ar_hdr hdr;
1388       struct xcoff_ar_hdr *hdrp;
1389
1390       if (bfd_bread ((PTR) &hdr, (bfd_size_type) SIZEOF_AR_HDR, abfd)
1391           != SIZEOF_AR_HDR)
1392         {
1393           free (ret);
1394           return NULL;
1395         }
1396
1397       namlen = strtol (hdr.namlen, (char **) NULL, 10);
1398       amt = SIZEOF_AR_HDR + namlen + 1;
1399       hdrp = (struct xcoff_ar_hdr *) bfd_alloc (abfd, amt);
1400       if (hdrp == NULL)
1401         {
1402           free (ret);
1403           return NULL;
1404         }
1405       memcpy (hdrp, &hdr, SIZEOF_AR_HDR);
1406       if (bfd_bread ((char *) hdrp + SIZEOF_AR_HDR, namlen, abfd) != namlen)
1407         {
1408           free (ret);
1409           return NULL;
1410         }
1411       ((char *) hdrp)[SIZEOF_AR_HDR + namlen] = '\0';
1412
1413       ret->arch_header = (char *) hdrp;
1414       ret->parsed_size = strtol (hdr.size, (char **) NULL, 10);
1415       ret->filename = (char *) hdrp + SIZEOF_AR_HDR;
1416     }
1417   else
1418     {
1419       struct xcoff_ar_hdr_big hdr;
1420       struct xcoff_ar_hdr_big *hdrp;
1421
1422       if (bfd_bread ((PTR) &hdr, (bfd_size_type) SIZEOF_AR_HDR_BIG, abfd)
1423           != SIZEOF_AR_HDR_BIG)
1424         {
1425           free (ret);
1426           return NULL;
1427         }
1428
1429       namlen = strtol (hdr.namlen, (char **) NULL, 10);
1430       amt = SIZEOF_AR_HDR_BIG + namlen + 1;
1431       hdrp = (struct xcoff_ar_hdr_big *) bfd_alloc (abfd, amt);
1432       if (hdrp == NULL)
1433         {
1434           free (ret);
1435           return NULL;
1436         }
1437       memcpy (hdrp, &hdr, SIZEOF_AR_HDR_BIG);
1438       if (bfd_bread ((char *) hdrp + SIZEOF_AR_HDR_BIG, namlen, abfd) != namlen)
1439         {
1440           free (ret);
1441           return NULL;
1442         }
1443       ((char *) hdrp)[SIZEOF_AR_HDR_BIG + namlen] = '\0';
1444
1445       ret->arch_header = (char *) hdrp;
1446       /* XXX This actually has to be a call to strtoll (at least on 32-bit
1447          machines) since the field width is 20 and there numbers with more
1448          than 32 bits can be represented.  */
1449       ret->parsed_size = strtol (hdr.size, (char **) NULL, 10);
1450       ret->filename = (char *) hdrp + SIZEOF_AR_HDR_BIG;
1451     }
1452
1453   /* Skip over the XCOFFARFMAG at the end of the file name.  */
1454   if (bfd_seek (abfd, (file_ptr) ((namlen & 1) + SXCOFFARFMAG), SEEK_CUR) != 0)
1455     return NULL;
1456
1457   return (PTR) ret;
1458 }
1459
1460 /* Open the next element in an XCOFF archive.  */
1461
1462 bfd *
1463 _bfd_xcoff_openr_next_archived_file (archive, last_file)
1464      bfd *archive;
1465      bfd *last_file;
1466 {
1467   file_ptr filestart;
1468
1469   if (xcoff_ardata (archive) == NULL)
1470     {
1471       bfd_set_error (bfd_error_invalid_operation);
1472       return NULL;
1473     }
1474
1475   if (! xcoff_big_format_p (archive))
1476     {
1477       if (last_file == NULL)
1478         filestart = bfd_ardata (archive)->first_file_filepos;
1479       else
1480         filestart = strtol (arch_xhdr (last_file)->nextoff, (char **) NULL,
1481                             10);
1482
1483       if (filestart == 0
1484           || filestart == strtol (xcoff_ardata (archive)->memoff,
1485                                   (char **) NULL, 10)
1486           || filestart == strtol (xcoff_ardata (archive)->symoff,
1487                                   (char **) NULL, 10))
1488         {
1489           bfd_set_error (bfd_error_no_more_archived_files);
1490           return NULL;
1491         }
1492     }
1493   else
1494     {
1495       if (last_file == NULL)
1496         filestart = bfd_ardata (archive)->first_file_filepos;
1497       else
1498         /* XXX These actually have to be a calls to strtoll (at least
1499            on 32-bit machines) since the fields's width is 20 and
1500            there numbers with more than 32 bits can be represented.  */
1501         filestart = strtol (arch_xhdr_big (last_file)->nextoff, (char **) NULL,
1502                             10);
1503
1504       /* XXX These actually have to be calls to strtoll (at least on 32-bit
1505          machines) since the fields's width is 20 and there numbers with more
1506          than 32 bits can be represented.  */
1507       if (filestart == 0
1508           || filestart == strtol (xcoff_ardata_big (archive)->memoff,
1509                                   (char **) NULL, 10)
1510           || filestart == strtol (xcoff_ardata_big (archive)->symoff,
1511                                   (char **) NULL, 10))
1512         {
1513           bfd_set_error (bfd_error_no_more_archived_files);
1514           return NULL;
1515         }
1516     }
1517
1518   return _bfd_get_elt_at_filepos (archive, filestart);
1519 }
1520
1521 /* Stat an element in an XCOFF archive.  */
1522
1523 int
1524 _bfd_xcoff_stat_arch_elt (abfd, s)
1525      bfd *abfd;
1526      struct stat *s;
1527 {
1528   if (abfd->arelt_data == NULL)
1529     {
1530       bfd_set_error (bfd_error_invalid_operation);
1531       return -1;
1532     }
1533
1534   if (! xcoff_big_format_p (abfd->my_archive))
1535     {
1536       struct xcoff_ar_hdr *hdrp = arch_xhdr (abfd);
1537
1538       s->st_mtime = strtol (hdrp->date, (char **) NULL, 10);
1539       s->st_uid = strtol (hdrp->uid, (char **) NULL, 10);
1540       s->st_gid = strtol (hdrp->gid, (char **) NULL, 10);
1541       s->st_mode = strtol (hdrp->mode, (char **) NULL, 8);
1542       s->st_size = arch_eltdata (abfd)->parsed_size;
1543     }
1544   else
1545     {
1546       struct xcoff_ar_hdr_big *hdrp = arch_xhdr_big (abfd);
1547
1548       s->st_mtime = strtol (hdrp->date, (char **) NULL, 10);
1549       s->st_uid = strtol (hdrp->uid, (char **) NULL, 10);
1550       s->st_gid = strtol (hdrp->gid, (char **) NULL, 10);
1551       s->st_mode = strtol (hdrp->mode, (char **) NULL, 8);
1552       s->st_size = arch_eltdata (abfd)->parsed_size;
1553     }
1554
1555   return 0;
1556 }
1557
1558 /* Normalize a file name for inclusion in an archive.  */
1559
1560 static const char *
1561 normalize_filename (abfd)
1562      bfd *abfd;
1563 {
1564   const char *file;
1565   const char *filename;
1566
1567   file = bfd_get_filename (abfd);
1568   filename = strrchr (file, '/');
1569   if (filename != NULL)
1570     filename++;
1571   else
1572     filename = file;
1573   return filename;
1574 }
1575
1576 /* Write out an XCOFF armap.  */
1577
1578 /*ARGSUSED*/
1579 static bfd_boolean
1580 xcoff_write_armap_old (abfd, elength, map, orl_count, stridx)
1581      bfd *abfd;
1582      unsigned int elength ATTRIBUTE_UNUSED;
1583      struct orl *map;
1584      unsigned int orl_count;
1585      int stridx;
1586 {
1587   struct xcoff_ar_hdr hdr;
1588   char *p;
1589   unsigned char buf[4];
1590   bfd *sub;
1591   file_ptr fileoff;
1592   unsigned int i;
1593
1594   memset (&hdr, 0, sizeof hdr);
1595   sprintf (hdr.size, "%ld", (long) (4 + orl_count * 4 + stridx));
1596   sprintf (hdr.nextoff, "%d", 0);
1597   memcpy (hdr.prevoff, xcoff_ardata (abfd)->memoff, XCOFFARMAG_ELEMENT_SIZE);
1598   sprintf (hdr.date, "%d", 0);
1599   sprintf (hdr.uid, "%d", 0);
1600   sprintf (hdr.gid, "%d", 0);
1601   sprintf (hdr.mode, "%d", 0);
1602   sprintf (hdr.namlen, "%d", 0);
1603
1604   /* We need spaces, not null bytes, in the header.  */
1605   for (p = (char *) &hdr; p < (char *) &hdr + SIZEOF_AR_HDR; p++)
1606     if (*p == '\0')
1607       *p = ' ';
1608
1609   if (bfd_bwrite ((PTR) &hdr, (bfd_size_type) SIZEOF_AR_HDR, abfd)
1610       != SIZEOF_AR_HDR
1611       || (bfd_bwrite (XCOFFARFMAG, (bfd_size_type) SXCOFFARFMAG, abfd)
1612           != SXCOFFARFMAG))
1613     return FALSE;
1614
1615   H_PUT_32 (abfd, orl_count, buf);
1616   if (bfd_bwrite (buf, (bfd_size_type) 4, abfd) != 4)
1617     return FALSE;
1618
1619   sub = abfd->archive_head;
1620   fileoff = SIZEOF_AR_FILE_HDR;
1621   i = 0;
1622   while (sub != NULL && i < orl_count)
1623     {
1624       size_t namlen;
1625
1626       while (map[i].u.abfd == sub)
1627         {
1628           H_PUT_32 (abfd, fileoff, buf);
1629           if (bfd_bwrite (buf, (bfd_size_type) 4, abfd) != 4)
1630             return FALSE;
1631           ++i;
1632         }
1633       namlen = strlen (normalize_filename (sub));
1634       namlen = (namlen + 1) &~ (size_t) 1;
1635       fileoff += (SIZEOF_AR_HDR
1636                   + namlen
1637                   + SXCOFFARFMAG
1638                   + arelt_size (sub));
1639       fileoff = (fileoff + 1) &~ 1;
1640       sub = sub->next;
1641     }
1642
1643   for (i = 0; i < orl_count; i++)
1644     {
1645       const char *name;
1646       size_t namlen;
1647
1648       name = *map[i].name;
1649       namlen = strlen (name);
1650       if (bfd_bwrite (name, (bfd_size_type) (namlen + 1), abfd) != namlen + 1)
1651         return FALSE;
1652     }
1653
1654   if ((stridx & 1) != 0)
1655     {
1656       char b;
1657
1658       b = '\0';
1659       if (bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1)
1660         return FALSE;
1661     }
1662
1663   return TRUE;
1664 }
1665
1666 static char buff20[XCOFFARMAGBIG_ELEMENT_SIZE + 1];
1667 #define FMT20  "%-20lld"
1668 #define FMT12  "%-12d"
1669 #define FMT12_OCTAL  "%-12o"
1670 #define FMT4  "%-4d"
1671 #define PRINT20(d, v) \
1672   sprintf (buff20, FMT20, (long long)(v)), \
1673   memcpy ((void *) (d), buff20, 20)
1674
1675 #define PRINT12(d, v) \
1676   sprintf (buff20, FMT12, (int)(v)), \
1677   memcpy ((void *) (d), buff20, 12)
1678
1679 #define PRINT12_OCTAL(d, v) \
1680   sprintf (buff20, FMT12_OCTAL, (unsigned int)(v)), \
1681   memcpy ((void *) (d), buff20, 12)
1682
1683 #define PRINT4(d, v) \
1684   sprintf (buff20, FMT4, (int)(v)), \
1685   memcpy ((void *) (d), buff20, 4)
1686
1687 #define READ20(d, v) \
1688   buff20[20] = 0, \
1689   memcpy (buff20, (d), 20), \
1690   (v) = bfd_scan_vma (buff20, (const char **) NULL, 10)
1691
1692 static bfd_boolean
1693 do_pad (abfd, number)
1694      bfd *abfd;
1695      unsigned int number;
1696 {
1697   bfd_byte b = 0;
1698
1699   /* Limit pad to <= 4096.  */
1700   if (number > 4096)
1701     return FALSE;
1702
1703   while (number--)
1704     if (bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1)
1705       return FALSE;
1706
1707   return TRUE;
1708 }
1709
1710 static bfd_boolean
1711 do_copy (out_bfd, in_bfd)
1712      bfd *out_bfd;
1713      bfd *in_bfd;
1714 {
1715   bfd_size_type remaining;
1716   bfd_byte buffer[DEFAULT_BUFFERSIZE];
1717
1718   if (bfd_seek (in_bfd, (file_ptr) 0, SEEK_SET) != 0)
1719     return FALSE;
1720
1721   remaining = arelt_size (in_bfd);
1722
1723   while (remaining >= DEFAULT_BUFFERSIZE)
1724     {
1725       if (bfd_bread (buffer, DEFAULT_BUFFERSIZE, in_bfd) != DEFAULT_BUFFERSIZE
1726           || bfd_bwrite (buffer, DEFAULT_BUFFERSIZE, out_bfd) != DEFAULT_BUFFERSIZE)
1727         return FALSE;
1728
1729       remaining -= DEFAULT_BUFFERSIZE;
1730     }
1731
1732   if (remaining)
1733     {
1734       if (bfd_bread (buffer, remaining, in_bfd) != remaining
1735           || bfd_bwrite (buffer, remaining, out_bfd) != remaining)
1736         return FALSE;
1737     }
1738
1739   return TRUE;
1740 }
1741
1742 static bfd_boolean
1743 do_shared_object_padding (out_bfd, in_bfd, offset, ar_header_size)
1744      bfd *out_bfd;
1745      bfd *in_bfd;
1746      ufile_ptr *offset;
1747      int ar_header_size;
1748 {
1749   if (bfd_check_format (in_bfd, bfd_object)
1750       && bfd_get_flavour (in_bfd) == bfd_target_xcoff_flavour
1751       && (in_bfd->flags & DYNAMIC) != 0)
1752     {
1753       bfd_size_type pad = 0;
1754       int text_align_power;
1755
1756       text_align_power = bfd_xcoff_text_align_power (in_bfd);
1757
1758       pad = 1 << text_align_power;
1759       pad -= (*offset + ar_header_size) & (pad - 1);
1760
1761       if (! do_pad (out_bfd, pad))
1762         return FALSE;
1763
1764       *offset += pad;
1765     }
1766
1767   return TRUE;
1768 }
1769
1770 static bfd_boolean
1771 xcoff_write_armap_big (abfd, elength, map, orl_count, stridx)
1772      bfd *abfd;
1773      unsigned int elength ATTRIBUTE_UNUSED;
1774      struct orl *map;
1775      unsigned int orl_count;
1776      int stridx;
1777 {
1778   struct xcoff_ar_file_hdr_big *fhdr;
1779   bfd_vma i, sym_32, sym_64, str_32, str_64;
1780   const bfd_arch_info_type *arch_info = NULL;
1781   bfd *current_bfd;
1782   size_t string_length;
1783   ufile_ptr nextoff, prevoff;
1784
1785   /* First, we look through the symbols and work out which are
1786      from 32-bit objects and which from 64-bit ones.  */
1787   sym_32 = sym_64 = str_32 = str_64 = 0;
1788
1789   current_bfd = abfd->archive_head;
1790   if (current_bfd != NULL)
1791     arch_info = bfd_get_arch_info (current_bfd);
1792     i = 0;
1793     while (current_bfd != NULL && i < orl_count)
1794     {
1795       while (map[i].u.abfd == current_bfd)
1796         {
1797           string_length = strlen (*map[i].name) + 1;
1798
1799           if (arch_info->bits_per_address == 64)
1800             {
1801               sym_64++;
1802               str_64 += string_length;
1803             }
1804           else
1805             {
1806               sym_32++;
1807               str_32 += string_length;
1808             }
1809           i++;
1810         }
1811       current_bfd = current_bfd->next;
1812       if (current_bfd != NULL)
1813         arch_info = bfd_get_arch_info (current_bfd);
1814     }
1815
1816   /* A quick sanity check... */
1817   BFD_ASSERT (sym_64 + sym_32 == orl_count);
1818   /* Explicit cast to int for compiler.  */
1819   BFD_ASSERT ((int)(str_64 + str_32) == stridx);
1820
1821   fhdr = xcoff_ardata_big (abfd);
1822
1823   /* xcoff_write_archive_contents_big passes nextoff in symoff. */
1824   READ20 (fhdr->memoff, prevoff);
1825   READ20 (fhdr->symoff, nextoff);
1826
1827   BFD_ASSERT (nextoff == bfd_tell (abfd));
1828
1829   /* Write out the symbol table.
1830      Layout :
1831
1832      standard big archive header
1833      0x0000                   ar_size   [0x14]
1834      0x0014                   ar_nxtmem [0x14]
1835      0x0028                   ar_prvmem [0x14]
1836      0x003C                   ar_date   [0x0C]
1837      0x0048                   ar_uid    [0x0C]
1838      0x0054                   ar_gid    [0x0C]
1839      0x0060                   ar_mod    [0x0C]
1840      0x006C                   ar_namelen[0x04]
1841      0x0070                   ar_fmag   [SXCOFFARFMAG]
1842
1843      Symbol table
1844      0x0072                   num_syms  [0x08], binary
1845      0x0078                   offsets   [0x08 * num_syms], binary
1846      0x0086 + 0x08 * num_syms names     [??]
1847      ??                       pad to even bytes.
1848   */
1849
1850   if (sym_32)
1851     {
1852       struct xcoff_ar_hdr_big *hdr;
1853       bfd_byte *symbol_table;
1854       bfd_byte *st;
1855       file_ptr fileoff;
1856
1857       bfd_vma symbol_table_size =
1858         SIZEOF_AR_HDR_BIG
1859         + SXCOFFARFMAG
1860         + 8
1861         + 8 * sym_32
1862         + str_32 + (str_32 & 1);
1863
1864       symbol_table = NULL;
1865       symbol_table = (bfd_byte *) 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       symbol_table = NULL;
1946
1947       prevoff = nextoff;
1948       nextoff = nextoff + symbol_table_size;
1949     }
1950   else
1951     PRINT20 (fhdr->symoff, 0);
1952
1953   if (sym_64)
1954     {
1955       struct xcoff_ar_hdr_big *hdr;
1956       bfd_byte *symbol_table;
1957       bfd_byte *st;
1958       file_ptr fileoff;
1959
1960       bfd_vma symbol_table_size =
1961         SIZEOF_AR_HDR_BIG
1962         + SXCOFFARFMAG
1963         + 8
1964         + 8 * sym_64
1965         + str_64 + (str_64 & 1);
1966
1967       symbol_table = NULL;
1968       symbol_table = (bfd_byte *) bfd_zmalloc (symbol_table_size);
1969       if (symbol_table == NULL)
1970         return FALSE;
1971
1972       hdr = (struct xcoff_ar_hdr_big *) symbol_table;
1973
1974       PRINT20 (hdr->size, 8 + 8 * sym_64 + str_64 + (str_64 & 1));
1975       PRINT20 (hdr->nextoff, 0);
1976       PRINT20 (hdr->prevoff, prevoff);
1977       PRINT12 (hdr->date, 0);
1978       PRINT12 (hdr->uid, 0);
1979       PRINT12 (hdr->gid, 0);
1980       PRINT12 (hdr->mode, 0);
1981       PRINT4 (hdr->namlen, 0);
1982
1983       st = symbol_table + SIZEOF_AR_HDR_BIG;
1984       memcpy (st, XCOFFARFMAG, SXCOFFARFMAG);
1985       st += SXCOFFARFMAG;
1986
1987       bfd_h_put_64 (abfd, sym_64, st);
1988       st += 8;
1989
1990       /* loop over the 64 bit offsets */
1991       current_bfd = abfd->archive_head;
1992       if (current_bfd != NULL)
1993         arch_info = bfd_get_arch_info (current_bfd);
1994       fileoff = SIZEOF_AR_FILE_HDR_BIG;
1995       i = 0;
1996       while (current_bfd != NULL && i < orl_count)
1997         {
1998           while (map[i].u.abfd == current_bfd)
1999             {
2000               if (arch_info->bits_per_address == 64)
2001                 {
2002                   bfd_h_put_64 (abfd, fileoff, st);
2003                   st += 8;
2004                 }
2005               i++;
2006             }
2007           string_length = strlen (normalize_filename (current_bfd));
2008           string_length += string_length & 1;
2009           fileoff += (SIZEOF_AR_HDR_BIG
2010                       + string_length
2011                       + SXCOFFARFMAG
2012                       + arelt_size (current_bfd));
2013           fileoff += fileoff & 1;
2014           current_bfd = current_bfd->next;
2015           if (current_bfd != NULL)
2016             arch_info = bfd_get_arch_info (current_bfd);
2017         }
2018
2019       /* loop over the 64 bit symbol names */
2020       current_bfd = abfd->archive_head;
2021       if (current_bfd != NULL)
2022         arch_info = bfd_get_arch_info (current_bfd);
2023       i = 0;
2024       while (current_bfd != NULL && i < orl_count)
2025         {
2026           while (map[i].u.abfd == current_bfd)
2027             {
2028               if (arch_info->bits_per_address == 64)
2029                 {
2030                   string_length = sprintf (st, "%s", *map[i].name);
2031                   st += string_length + 1;
2032                 }
2033               i++;
2034             }
2035           current_bfd = current_bfd->next;
2036           if (current_bfd != NULL)
2037             arch_info = bfd_get_arch_info (current_bfd);
2038         }
2039
2040       bfd_bwrite (symbol_table, symbol_table_size, abfd);
2041
2042       free (symbol_table);
2043       symbol_table = NULL;
2044
2045       PRINT20 (fhdr->symoff64, nextoff);
2046     }
2047   else
2048     PRINT20 (fhdr->symoff64, 0);
2049
2050   return TRUE;
2051 }
2052
2053 bfd_boolean
2054 _bfd_xcoff_write_armap (abfd, elength, map, orl_count, stridx)
2055      bfd *abfd;
2056      unsigned int elength ATTRIBUTE_UNUSED;
2057      struct orl *map;
2058      unsigned int orl_count;
2059      int stridx;
2060 {
2061   if (! xcoff_big_format_p (abfd))
2062     return xcoff_write_armap_old (abfd, elength, map, orl_count, stridx);
2063   else
2064     return xcoff_write_armap_big (abfd, elength, map, orl_count, stridx);
2065 }
2066
2067 /* Write out an XCOFF archive.  We always write an entire archive,
2068    rather than fussing with the freelist and so forth.  */
2069
2070 static bfd_boolean
2071 xcoff_write_archive_contents_old (abfd)
2072      bfd *abfd;
2073 {
2074   struct xcoff_ar_file_hdr fhdr;
2075   bfd_size_type count;
2076   bfd_size_type total_namlen;
2077   file_ptr *offsets;
2078   bfd_boolean makemap;
2079   bfd_boolean hasobjects;
2080   ufile_ptr prevoff, nextoff;
2081   bfd *sub;
2082   size_t i;
2083   struct xcoff_ar_hdr ahdr;
2084   bfd_size_type size;
2085   char *p;
2086   char decbuf[XCOFFARMAG_ELEMENT_SIZE + 1];
2087
2088   memset (&fhdr, 0, sizeof fhdr);
2089   strncpy (fhdr.magic, XCOFFARMAG, SXCOFFARMAG);
2090   sprintf (fhdr.firstmemoff, "%d", SIZEOF_AR_FILE_HDR);
2091   sprintf (fhdr.freeoff, "%d", 0);
2092
2093   count = 0;
2094   total_namlen = 0;
2095   for (sub = abfd->archive_head; sub != NULL; sub = sub->next)
2096     {
2097       ++count;
2098       total_namlen += strlen (normalize_filename (sub)) + 1;
2099     }
2100   offsets = (file_ptr *) bfd_alloc (abfd, count * sizeof (file_ptr));
2101   if (offsets == NULL)
2102     return FALSE;
2103
2104   if (bfd_seek (abfd, (file_ptr) SIZEOF_AR_FILE_HDR, SEEK_SET) != 0)
2105     return FALSE;
2106
2107   makemap = bfd_has_map (abfd);
2108   hasobjects = FALSE;
2109   prevoff = 0;
2110   nextoff = SIZEOF_AR_FILE_HDR;
2111   for (sub = abfd->archive_head, i = 0; sub != NULL; sub = sub->next, i++)
2112     {
2113       const char *name;
2114       bfd_size_type namlen;
2115       struct xcoff_ar_hdr *ahdrp;
2116       bfd_size_type remaining;
2117
2118       if (makemap && ! hasobjects)
2119         {
2120           if (bfd_check_format (sub, bfd_object))
2121             hasobjects = TRUE;
2122         }
2123
2124       name = normalize_filename (sub);
2125       namlen = strlen (name);
2126
2127       if (sub->arelt_data != NULL)
2128         ahdrp = arch_xhdr (sub);
2129       else
2130         ahdrp = NULL;
2131
2132       if (ahdrp == NULL)
2133         {
2134           struct stat s;
2135
2136           memset (&ahdr, 0, sizeof ahdr);
2137           ahdrp = &ahdr;
2138           if (stat (bfd_get_filename (sub), &s) != 0)
2139             {
2140               bfd_set_error (bfd_error_system_call);
2141               return FALSE;
2142             }
2143
2144           sprintf (ahdrp->size, "%ld", (long) s.st_size);
2145           sprintf (ahdrp->date, "%ld", (long) s.st_mtime);
2146           sprintf (ahdrp->uid, "%ld", (long) s.st_uid);
2147           sprintf (ahdrp->gid, "%ld", (long) s.st_gid);
2148           sprintf (ahdrp->mode, "%o", (unsigned int) s.st_mode);
2149
2150           if (sub->arelt_data == NULL)
2151             {
2152               size = sizeof (struct areltdata);
2153               sub->arelt_data = bfd_alloc (sub, size);
2154               if (sub->arelt_data == NULL)
2155                 return FALSE;
2156             }
2157
2158           arch_eltdata (sub)->parsed_size = s.st_size;
2159         }
2160
2161       sprintf (ahdrp->prevoff, "%ld", (long) prevoff);
2162       sprintf (ahdrp->namlen, "%ld", (long) namlen);
2163
2164       /* If the length of the name is odd, we write out the null byte
2165          after the name as well.  */
2166       namlen = (namlen + 1) &~ (bfd_size_type) 1;
2167
2168       remaining = arelt_size (sub);
2169       size = (SIZEOF_AR_HDR
2170               + namlen
2171               + SXCOFFARFMAG
2172               + remaining);
2173
2174       BFD_ASSERT (nextoff == bfd_tell (abfd));
2175
2176       offsets[i] = nextoff;
2177
2178       prevoff = nextoff;
2179       nextoff += size + (size & 1);
2180
2181       sprintf (ahdrp->nextoff, "%ld", (long) nextoff);
2182
2183       /* We need spaces, not null bytes, in the header.  */
2184       for (p = (char *) ahdrp; p < (char *) ahdrp + SIZEOF_AR_HDR; p++)
2185         if (*p == '\0')
2186           *p = ' ';
2187
2188       if ((bfd_bwrite ((PTR) ahdrp, (bfd_size_type) SIZEOF_AR_HDR, abfd)
2189            != SIZEOF_AR_HDR)
2190           || bfd_bwrite ((PTR) name, namlen, abfd) != namlen
2191           || bfd_bwrite ((PTR) XCOFFARFMAG, (bfd_size_type) SXCOFFARFMAG,
2192                          abfd) != SXCOFFARFMAG)
2193         return FALSE;
2194
2195       if (bfd_seek (sub, (file_ptr) 0, SEEK_SET) != 0)
2196         return FALSE;
2197
2198       if (! do_copy (abfd, sub))
2199         return FALSE;
2200
2201       if (! do_pad (abfd, size & 1))
2202         return FALSE;
2203     }
2204
2205   sprintf (fhdr.lastmemoff, "%ld", (long) prevoff);
2206
2207   /* Write out the member table.  */
2208
2209   BFD_ASSERT (nextoff == bfd_tell (abfd));
2210   sprintf (fhdr.memoff, "%ld", (long) nextoff);
2211
2212   memset (&ahdr, 0, sizeof ahdr);
2213   sprintf (ahdr.size, "%ld", (long) (XCOFFARMAG_ELEMENT_SIZE
2214                                      + count * XCOFFARMAG_ELEMENT_SIZE
2215                                      + total_namlen));
2216   sprintf (ahdr.prevoff, "%ld", (long) prevoff);
2217   sprintf (ahdr.date, "%d", 0);
2218   sprintf (ahdr.uid, "%d", 0);
2219   sprintf (ahdr.gid, "%d", 0);
2220   sprintf (ahdr.mode, "%d", 0);
2221   sprintf (ahdr.namlen, "%d", 0);
2222
2223   size = (SIZEOF_AR_HDR
2224           + XCOFFARMAG_ELEMENT_SIZE
2225           + count * XCOFFARMAG_ELEMENT_SIZE
2226           + total_namlen
2227           + SXCOFFARFMAG);
2228
2229   prevoff = nextoff;
2230   nextoff += size + (size & 1);
2231
2232   if (makemap && hasobjects)
2233     sprintf (ahdr.nextoff, "%ld", (long) nextoff);
2234   else
2235     sprintf (ahdr.nextoff, "%d", 0);
2236
2237   /* We need spaces, not null bytes, in the header.  */
2238   for (p = (char *) &ahdr; p < (char *) &ahdr + SIZEOF_AR_HDR; p++)
2239     if (*p == '\0')
2240       *p = ' ';
2241
2242   if ((bfd_bwrite ((PTR) &ahdr, (bfd_size_type) SIZEOF_AR_HDR, abfd)
2243        != SIZEOF_AR_HDR)
2244       || (bfd_bwrite ((PTR) XCOFFARFMAG, (bfd_size_type) SXCOFFARFMAG, abfd)
2245           != SXCOFFARFMAG))
2246     return FALSE;
2247
2248   sprintf (decbuf, "%-12ld", (long) count);
2249   if (bfd_bwrite ((PTR) decbuf, (bfd_size_type) XCOFFARMAG_ELEMENT_SIZE, abfd)
2250       != XCOFFARMAG_ELEMENT_SIZE)
2251     return FALSE;
2252   for (i = 0; i < (size_t) count; i++)
2253     {
2254       sprintf (decbuf, "%-12ld", (long) offsets[i]);
2255       if (bfd_bwrite ((PTR) decbuf, (bfd_size_type) XCOFFARMAG_ELEMENT_SIZE,
2256                       abfd) != XCOFFARMAG_ELEMENT_SIZE)
2257         return FALSE;
2258     }
2259   for (sub = abfd->archive_head; sub != NULL; sub = sub->next)
2260     {
2261       const char *name;
2262       bfd_size_type namlen;
2263
2264       name = normalize_filename (sub);
2265       namlen = strlen (name);
2266       if (bfd_bwrite ((PTR) name, namlen + 1, abfd) != namlen + 1)
2267         return FALSE;
2268     }
2269
2270   if (! do_pad (abfd, size & 1))
2271     return FALSE;
2272
2273   /* Write out the armap, if appropriate.  */
2274   if (! makemap || ! hasobjects)
2275     sprintf (fhdr.symoff, "%d", 0);
2276   else
2277     {
2278       BFD_ASSERT (nextoff == bfd_tell (abfd));
2279       sprintf (fhdr.symoff, "%ld", (long) nextoff);
2280       bfd_ardata (abfd)->tdata = (PTR) &fhdr;
2281       if (! _bfd_compute_and_write_armap (abfd, 0))
2282         return FALSE;
2283     }
2284
2285   /* Write out the archive file header.  */
2286
2287   /* We need spaces, not null bytes, in the header.  */
2288   for (p = (char *) &fhdr; p < (char *) &fhdr + SIZEOF_AR_FILE_HDR; p++)
2289     if (*p == '\0')
2290       *p = ' ';
2291
2292   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
2293       || (bfd_bwrite ((PTR) &fhdr, (bfd_size_type) SIZEOF_AR_FILE_HDR, abfd)
2294           != SIZEOF_AR_FILE_HDR))
2295     return FALSE;
2296
2297   return TRUE;
2298 }
2299
2300 static bfd_boolean
2301 xcoff_write_archive_contents_big (abfd)
2302      bfd *abfd;
2303 {
2304   struct xcoff_ar_file_hdr_big fhdr;
2305   bfd_size_type count;
2306   bfd_size_type total_namlen;
2307   file_ptr *offsets;
2308   bfd_boolean makemap;
2309   bfd_boolean hasobjects;
2310   ufile_ptr prevoff, nextoff;
2311   bfd *current_bfd;
2312   size_t i;
2313   struct xcoff_ar_hdr_big *hdr, ahdr;
2314   bfd_size_type size;
2315   bfd_byte *member_table, *mt;
2316   bfd_vma member_table_size;
2317
2318   memset (&fhdr, 0, SIZEOF_AR_FILE_HDR_BIG);
2319   memcpy (fhdr.magic, XCOFFARMAGBIG, SXCOFFARMAG);
2320
2321   if (bfd_seek (abfd, (file_ptr) SIZEOF_AR_FILE_HDR_BIG, SEEK_SET) != 0)
2322     return FALSE;
2323
2324   /* Calculate count and total_namlen.  */
2325   makemap = bfd_has_map (abfd);
2326   hasobjects = FALSE;
2327   for (current_bfd = abfd->archive_head, count = 0, total_namlen = 0;
2328        current_bfd != NULL;
2329        current_bfd = current_bfd->next, count++)
2330     {
2331       total_namlen += strlen (normalize_filename (current_bfd)) + 1;
2332
2333       if (makemap
2334           && ! hasobjects
2335           && bfd_check_format (current_bfd, bfd_object))
2336         hasobjects = TRUE;
2337     }
2338
2339   offsets = NULL;
2340   if (count)
2341     {
2342       offsets = (file_ptr *) bfd_malloc (count * sizeof (file_ptr));
2343       if (offsets == NULL)
2344         return FALSE;
2345     }
2346
2347   prevoff = 0;
2348   nextoff = SIZEOF_AR_FILE_HDR_BIG;
2349   for (current_bfd = abfd->archive_head, i = 0;
2350        current_bfd != NULL;
2351        current_bfd = current_bfd->next, i++)
2352     {
2353       const char *name;
2354       bfd_size_type namlen;
2355       struct xcoff_ar_hdr_big *ahdrp;
2356       bfd_size_type remaining;
2357
2358       name = normalize_filename (current_bfd);
2359       namlen = strlen (name);
2360
2361       if (current_bfd->arelt_data != NULL)
2362         ahdrp = arch_xhdr_big (current_bfd);
2363       else
2364         ahdrp = NULL;
2365
2366       if (ahdrp == NULL)
2367         {
2368           struct stat s;
2369
2370           ahdrp = &ahdr;
2371           /* XXX This should actually be a call to stat64 (at least on
2372              32-bit machines).
2373              XXX This call will fail if the original object is not found.  */
2374           if (stat (bfd_get_filename (current_bfd), &s) != 0)
2375             {
2376               bfd_set_error (bfd_error_system_call);
2377               return FALSE;
2378             }
2379
2380           PRINT20 (ahdrp->size, s.st_size);
2381           PRINT12 (ahdrp->date, s.st_mtime);
2382           PRINT12 (ahdrp->uid,  s.st_uid);
2383           PRINT12 (ahdrp->gid,  s.st_gid);
2384           PRINT12_OCTAL (ahdrp->mode, s.st_mode);
2385
2386           if (current_bfd->arelt_data == NULL)
2387             {
2388               size = sizeof (struct areltdata);
2389               current_bfd->arelt_data = bfd_alloc (current_bfd, size);
2390               if (current_bfd->arelt_data == NULL)
2391                 return FALSE;
2392             }
2393
2394           arch_eltdata (current_bfd)->parsed_size = s.st_size;
2395         }
2396
2397       PRINT20 (ahdrp->prevoff, prevoff);
2398       PRINT4 (ahdrp->namlen, namlen);
2399
2400       /* If the length of the name is odd, we write out the null byte
2401          after the name as well.  */
2402       namlen = (namlen + 1) &~ (bfd_size_type) 1;
2403
2404       remaining = arelt_size (current_bfd);
2405       size = (SIZEOF_AR_HDR_BIG
2406               + namlen
2407               + SXCOFFARFMAG
2408               + remaining);
2409
2410       BFD_ASSERT (nextoff == bfd_tell (abfd));
2411
2412       /* Check for xcoff shared objects.
2413          Their text section needs to be aligned wrt the archive file position.
2414          This requires extra padding before the archive header.  */
2415       if (! do_shared_object_padding (abfd, current_bfd, & nextoff,
2416                                       SIZEOF_AR_HDR_BIG + namlen
2417                                       + SXCOFFARFMAG))
2418         return FALSE;
2419
2420       offsets[i] = nextoff;
2421
2422       prevoff = nextoff;
2423       nextoff += size + (size & 1);
2424
2425       PRINT20 (ahdrp->nextoff, nextoff);
2426
2427       if ((bfd_bwrite ((PTR) ahdrp, (bfd_size_type) SIZEOF_AR_HDR_BIG, abfd)
2428            != SIZEOF_AR_HDR_BIG)
2429           || bfd_bwrite ((PTR) name, (bfd_size_type) namlen, abfd) != namlen
2430           || (bfd_bwrite ((PTR) XCOFFARFMAG, (bfd_size_type) SXCOFFARFMAG,
2431                           abfd) != SXCOFFARFMAG))
2432         return FALSE;
2433
2434       if (bfd_seek (current_bfd, (file_ptr) 0, SEEK_SET) != 0)
2435         return FALSE;
2436
2437       if (! do_copy (abfd, current_bfd))
2438         return FALSE;
2439
2440       if (! do_pad (abfd, size & 1))
2441         return FALSE;
2442     }
2443
2444   if (count)
2445     {
2446       PRINT20 (fhdr.firstmemoff, offsets[0]);
2447       PRINT20 (fhdr.lastmemoff, prevoff);
2448     }
2449
2450   /* Write out the member table.
2451      Layout :
2452
2453      standard big archive header
2454      0x0000                   ar_size   [0x14]
2455      0x0014                   ar_nxtmem [0x14]
2456      0x0028                   ar_prvmem [0x14]
2457      0x003C                   ar_date   [0x0C]
2458      0x0048                   ar_uid    [0x0C]
2459      0x0054                   ar_gid    [0x0C]
2460      0x0060                   ar_mod    [0x0C]
2461      0x006C                   ar_namelen[0x04]
2462      0x0070                   ar_fmag   [0x02]
2463
2464      Member table
2465      0x0072                   count     [0x14]
2466      0x0086                   offsets   [0x14 * counts]
2467      0x0086 + 0x14 * counts   names     [??]
2468      ??                       pad to even bytes.
2469    */
2470
2471   BFD_ASSERT (nextoff == bfd_tell (abfd));
2472
2473   member_table_size = (SIZEOF_AR_HDR_BIG
2474                        + SXCOFFARFMAG
2475                        + XCOFFARMAGBIG_ELEMENT_SIZE
2476                        + count * XCOFFARMAGBIG_ELEMENT_SIZE
2477                        + total_namlen);
2478
2479   member_table_size += member_table_size & 1;
2480   member_table = NULL;
2481   member_table = (bfd_byte *) bfd_zmalloc (member_table_size);
2482   if (member_table == NULL)
2483     return FALSE;
2484
2485   hdr = (struct xcoff_ar_hdr_big *) member_table;
2486
2487   PRINT20 (hdr->size, (XCOFFARMAGBIG_ELEMENT_SIZE
2488                        + count * XCOFFARMAGBIG_ELEMENT_SIZE
2489                        + total_namlen + (total_namlen & 1)));
2490   if (makemap && hasobjects)
2491     PRINT20 (hdr->nextoff, nextoff + member_table_size);
2492   else
2493     PRINT20 (hdr->nextoff, 0);
2494   PRINT20 (hdr->prevoff, prevoff);
2495   PRINT12 (hdr->date, 0);
2496   PRINT12 (hdr->uid, 0);
2497   PRINT12 (hdr->gid, 0);
2498   PRINT12 (hdr->mode, 0);
2499   PRINT4 (hdr->namlen, 0);
2500
2501   mt = member_table + SIZEOF_AR_HDR_BIG;
2502   memcpy (mt, XCOFFARFMAG, SXCOFFARFMAG);
2503   mt += SXCOFFARFMAG;
2504
2505   PRINT20 (mt, count);
2506   mt += XCOFFARMAGBIG_ELEMENT_SIZE;
2507   for (i = 0; i < (size_t) count; i++)
2508     {
2509       PRINT20 (mt, offsets[i]);
2510       mt += XCOFFARMAGBIG_ELEMENT_SIZE;
2511     }
2512
2513   if (count)
2514     {
2515       free (offsets);
2516       offsets = NULL;
2517     }
2518
2519   for (current_bfd = abfd->archive_head; current_bfd != NULL;
2520        current_bfd = current_bfd->next)
2521     {
2522       const char *name;
2523       size_t namlen;
2524
2525       name = normalize_filename (current_bfd);
2526       namlen = sprintf (mt, "%s", name);
2527       mt += namlen + 1;
2528     }
2529
2530   if (bfd_bwrite (member_table, member_table_size, abfd) != member_table_size)
2531     return FALSE;
2532
2533   free (member_table);
2534   member_table = NULL;
2535
2536   PRINT20 (fhdr.memoff, nextoff);
2537
2538   prevoff = nextoff;
2539   nextoff += member_table_size;
2540
2541   /* Write out the armap, if appropriate.  */
2542
2543   if (! makemap || ! hasobjects)
2544     PRINT20 (fhdr.symoff, 0);
2545   else
2546     {
2547       BFD_ASSERT (nextoff == bfd_tell (abfd));
2548
2549       /* Save nextoff in fhdr.symoff so the armap routine can use it.  */
2550       PRINT20 (fhdr.symoff, nextoff);
2551
2552       bfd_ardata (abfd)->tdata = (PTR) &fhdr;
2553       if (! _bfd_compute_and_write_armap (abfd, 0))
2554         return FALSE;
2555     }
2556
2557   /* Write out the archive file header.  */
2558
2559   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
2560       || (bfd_bwrite ((PTR) &fhdr, (bfd_size_type) SIZEOF_AR_FILE_HDR_BIG,
2561                       abfd) != SIZEOF_AR_FILE_HDR_BIG))
2562     return FALSE;
2563
2564   return TRUE;
2565 }
2566
2567 bfd_boolean
2568 _bfd_xcoff_write_archive_contents (abfd)
2569      bfd *abfd;
2570 {
2571   if (! xcoff_big_format_p (abfd))
2572     return xcoff_write_archive_contents_old (abfd);
2573   else
2574     return xcoff_write_archive_contents_big (abfd);
2575 }
2576 \f
2577 /* We can't use the usual coff_sizeof_headers routine, because AIX
2578    always uses an a.out header.  */
2579
2580 int
2581 _bfd_xcoff_sizeof_headers (abfd, reloc)
2582      bfd *abfd;
2583      bfd_boolean reloc ATTRIBUTE_UNUSED;
2584 {
2585   int size;
2586
2587   size = FILHSZ;
2588   if (xcoff_data (abfd)->full_aouthdr)
2589     size += AOUTSZ;
2590   else
2591     size += SMALL_AOUTSZ;
2592   size += abfd->section_count * SCNHSZ;
2593   return size;
2594 }
2595 \f
2596 /* Routines to swap information in the XCOFF .loader section.  If we
2597    ever need to write an XCOFF loader, this stuff will need to be
2598    moved to another file shared by the linker (which XCOFF calls the
2599    ``binder'') and the loader.  */
2600
2601 /* Swap in the ldhdr structure.  */
2602
2603 static void
2604 xcoff_swap_ldhdr_in (abfd, s, dst)
2605      bfd *abfd;
2606      const PTR s;
2607      struct internal_ldhdr *dst;
2608 {
2609   const struct external_ldhdr *src = (const struct external_ldhdr *) s;
2610
2611   dst->l_version = bfd_get_32 (abfd, src->l_version);
2612   dst->l_nsyms = bfd_get_32 (abfd, src->l_nsyms);
2613   dst->l_nreloc = bfd_get_32 (abfd, src->l_nreloc);
2614   dst->l_istlen = bfd_get_32 (abfd, src->l_istlen);
2615   dst->l_nimpid = bfd_get_32 (abfd, src->l_nimpid);
2616   dst->l_impoff = bfd_get_32 (abfd, src->l_impoff);
2617   dst->l_stlen = bfd_get_32 (abfd, src->l_stlen);
2618   dst->l_stoff = bfd_get_32 (abfd, src->l_stoff);
2619 }
2620
2621 /* Swap out the ldhdr structure.  */
2622
2623 static void
2624 xcoff_swap_ldhdr_out (abfd, src, d)
2625      bfd *abfd;
2626      const struct internal_ldhdr *src;
2627      PTR d;
2628 {
2629   struct external_ldhdr *dst = (struct external_ldhdr *) d;
2630
2631   bfd_put_32 (abfd, (bfd_vma) src->l_version, dst->l_version);
2632   bfd_put_32 (abfd, src->l_nsyms, dst->l_nsyms);
2633   bfd_put_32 (abfd, src->l_nreloc, dst->l_nreloc);
2634   bfd_put_32 (abfd, src->l_istlen, dst->l_istlen);
2635   bfd_put_32 (abfd, src->l_nimpid, dst->l_nimpid);
2636   bfd_put_32 (abfd, src->l_impoff, dst->l_impoff);
2637   bfd_put_32 (abfd, src->l_stlen, dst->l_stlen);
2638   bfd_put_32 (abfd, src->l_stoff, dst->l_stoff);
2639 }
2640
2641 /* Swap in the ldsym structure.  */
2642
2643 static void
2644 xcoff_swap_ldsym_in (abfd, s, dst)
2645      bfd *abfd;
2646      const PTR s;
2647      struct internal_ldsym *dst;
2648 {
2649   const struct external_ldsym *src = (const struct external_ldsym *) s;
2650
2651   if (bfd_get_32 (abfd, src->_l._l_l._l_zeroes) != 0) {
2652     memcpy (dst->_l._l_name, src->_l._l_name, SYMNMLEN);
2653   } else {
2654     dst->_l._l_l._l_zeroes = 0;
2655     dst->_l._l_l._l_offset = bfd_get_32 (abfd, src->_l._l_l._l_offset);
2656   }
2657   dst->l_value = bfd_get_32 (abfd, src->l_value);
2658   dst->l_scnum = bfd_get_16 (abfd, src->l_scnum);
2659   dst->l_smtype = bfd_get_8 (abfd, src->l_smtype);
2660   dst->l_smclas = bfd_get_8 (abfd, src->l_smclas);
2661   dst->l_ifile = bfd_get_32 (abfd, src->l_ifile);
2662   dst->l_parm = bfd_get_32 (abfd, src->l_parm);
2663 }
2664
2665 /* Swap out the ldsym structure.  */
2666
2667 static void
2668 xcoff_swap_ldsym_out (abfd, src, d)
2669      bfd *abfd;
2670      const struct internal_ldsym *src;
2671      PTR d;
2672 {
2673   struct external_ldsym *dst = (struct external_ldsym *) d;
2674
2675   if (src->_l._l_l._l_zeroes != 0)
2676     memcpy (dst->_l._l_name, src->_l._l_name, SYMNMLEN);
2677   else
2678     {
2679       bfd_put_32 (abfd, (bfd_vma) 0, dst->_l._l_l._l_zeroes);
2680       bfd_put_32 (abfd, (bfd_vma) src->_l._l_l._l_offset,
2681                   dst->_l._l_l._l_offset);
2682     }
2683   bfd_put_32 (abfd, src->l_value, dst->l_value);
2684   bfd_put_16 (abfd, (bfd_vma) src->l_scnum, dst->l_scnum);
2685   bfd_put_8 (abfd, src->l_smtype, dst->l_smtype);
2686   bfd_put_8 (abfd, src->l_smclas, dst->l_smclas);
2687   bfd_put_32 (abfd, src->l_ifile, dst->l_ifile);
2688   bfd_put_32 (abfd, src->l_parm, dst->l_parm);
2689 }
2690
2691 static void
2692 xcoff_swap_reloc_in (abfd, s, d)
2693      bfd *abfd;
2694      PTR s;
2695      PTR d;
2696 {
2697   struct external_reloc *src = (struct external_reloc *) s;
2698   struct internal_reloc *dst = (struct internal_reloc *) d;
2699
2700   memset (dst, 0, sizeof (struct internal_reloc));
2701
2702   dst->r_vaddr = bfd_get_32 (abfd, src->r_vaddr);
2703   dst->r_symndx = bfd_get_32 (abfd, src->r_symndx);
2704   dst->r_size = bfd_get_8 (abfd, src->r_size);
2705   dst->r_type = bfd_get_8 (abfd, src->r_type);
2706 }
2707
2708 static unsigned int
2709 xcoff_swap_reloc_out (abfd, s, d)
2710      bfd *abfd;
2711      PTR s;
2712      PTR d;
2713 {
2714   struct internal_reloc *src = (struct internal_reloc *) s;
2715   struct external_reloc *dst = (struct external_reloc *) d;
2716
2717   bfd_put_32 (abfd, src->r_vaddr, dst->r_vaddr);
2718   bfd_put_32 (abfd, src->r_symndx, dst->r_symndx);
2719   bfd_put_8 (abfd, src->r_type, dst->r_type);
2720   bfd_put_8 (abfd, src->r_size, dst->r_size);
2721
2722   return bfd_coff_relsz (abfd);
2723 }
2724
2725 /* Swap in the ldrel structure.  */
2726
2727 static void
2728 xcoff_swap_ldrel_in (abfd, s, dst)
2729      bfd *abfd;
2730      const PTR s;
2731      struct internal_ldrel *dst;
2732 {
2733   const struct external_ldrel *src = (const struct external_ldrel *) s;
2734
2735   dst->l_vaddr = bfd_get_32 (abfd, src->l_vaddr);
2736   dst->l_symndx = bfd_get_32 (abfd, src->l_symndx);
2737   dst->l_rtype = bfd_get_16 (abfd, src->l_rtype);
2738   dst->l_rsecnm = bfd_get_16 (abfd, src->l_rsecnm);
2739 }
2740
2741 /* Swap out the ldrel structure.  */
2742
2743 static void
2744 xcoff_swap_ldrel_out (abfd, src, d)
2745      bfd *abfd;
2746      const struct internal_ldrel *src;
2747      PTR d;
2748 {
2749   struct external_ldrel *dst = (struct external_ldrel *) d;
2750
2751   bfd_put_32 (abfd, src->l_vaddr, dst->l_vaddr);
2752   bfd_put_32 (abfd, src->l_symndx, dst->l_symndx);
2753   bfd_put_16 (abfd, (bfd_vma) src->l_rtype, dst->l_rtype);
2754   bfd_put_16 (abfd, (bfd_vma) src->l_rsecnm, dst->l_rsecnm);
2755 }
2756 \f
2757
2758 bfd_boolean
2759 xcoff_reloc_type_noop (input_bfd, input_section, output_bfd, rel, sym, howto,
2760                        val, addend, relocation, contents)
2761      bfd *input_bfd ATTRIBUTE_UNUSED;
2762      asection *input_section ATTRIBUTE_UNUSED;
2763      bfd *output_bfd ATTRIBUTE_UNUSED;
2764      struct internal_reloc *rel ATTRIBUTE_UNUSED;
2765      struct internal_syment *sym ATTRIBUTE_UNUSED;
2766      struct reloc_howto_struct *howto ATTRIBUTE_UNUSED;
2767      bfd_vma val ATTRIBUTE_UNUSED;
2768      bfd_vma addend ATTRIBUTE_UNUSED;
2769      bfd_vma *relocation ATTRIBUTE_UNUSED;
2770      bfd_byte *contents ATTRIBUTE_UNUSED;
2771 {
2772   return TRUE;
2773 }
2774
2775 bfd_boolean
2776 xcoff_reloc_type_fail (input_bfd, input_section, output_bfd, rel, sym, howto,
2777                        val, addend, relocation, contents)
2778      bfd *input_bfd;
2779      asection *input_section ATTRIBUTE_UNUSED;
2780      bfd *output_bfd ATTRIBUTE_UNUSED;
2781      struct internal_reloc *rel;
2782      struct internal_syment *sym ATTRIBUTE_UNUSED;
2783      struct reloc_howto_struct *howto ATTRIBUTE_UNUSED;
2784      bfd_vma val ATTRIBUTE_UNUSED;
2785      bfd_vma addend ATTRIBUTE_UNUSED;
2786      bfd_vma *relocation ATTRIBUTE_UNUSED;
2787      bfd_byte *contents ATTRIBUTE_UNUSED;
2788 {
2789   (*_bfd_error_handler)
2790     (_("%s: unsupported relocation type 0x%02x"),
2791      bfd_get_filename (input_bfd), (unsigned int) rel->r_type);
2792   bfd_set_error (bfd_error_bad_value);
2793   return FALSE;
2794 }
2795
2796 bfd_boolean
2797 xcoff_reloc_type_pos (input_bfd, input_section, output_bfd, rel, sym, howto,
2798                       val, addend, relocation, contents)
2799      bfd *input_bfd ATTRIBUTE_UNUSED;
2800      asection *input_section ATTRIBUTE_UNUSED;
2801      bfd *output_bfd ATTRIBUTE_UNUSED;
2802      struct internal_reloc *rel ATTRIBUTE_UNUSED;
2803      struct internal_syment *sym ATTRIBUTE_UNUSED;
2804      struct reloc_howto_struct *howto ATTRIBUTE_UNUSED;
2805      bfd_vma val;
2806      bfd_vma addend;
2807      bfd_vma *relocation;
2808      bfd_byte *contents ATTRIBUTE_UNUSED;
2809 {
2810   *relocation = val + addend;
2811   return TRUE;
2812 }
2813
2814 bfd_boolean
2815 xcoff_reloc_type_neg (input_bfd, input_section, output_bfd, rel, sym, howto,
2816                       val, addend, relocation, contents)
2817      bfd *input_bfd ATTRIBUTE_UNUSED;
2818      asection *input_section ATTRIBUTE_UNUSED;
2819      bfd *output_bfd ATTRIBUTE_UNUSED;
2820      struct internal_reloc *rel ATTRIBUTE_UNUSED;
2821      struct internal_syment *sym ATTRIBUTE_UNUSED;
2822      struct reloc_howto_struct *howto ATTRIBUTE_UNUSED;
2823      bfd_vma val;
2824      bfd_vma addend;
2825      bfd_vma *relocation;
2826      bfd_byte *contents ATTRIBUTE_UNUSED;
2827 {
2828   *relocation = addend - val;
2829   return TRUE;
2830 }
2831
2832 bfd_boolean
2833 xcoff_reloc_type_rel (input_bfd, input_section, output_bfd, rel, sym, howto,
2834                       val, addend, relocation, contents)
2835      bfd *input_bfd ATTRIBUTE_UNUSED;
2836      asection *input_section;
2837      bfd *output_bfd ATTRIBUTE_UNUSED;
2838      struct internal_reloc *rel ATTRIBUTE_UNUSED;
2839      struct internal_syment *sym ATTRIBUTE_UNUSED;
2840      struct reloc_howto_struct *howto;
2841      bfd_vma val;
2842      bfd_vma addend;
2843      bfd_vma *relocation;
2844      bfd_byte *contents ATTRIBUTE_UNUSED;
2845 {
2846   howto->pc_relative = TRUE;
2847
2848   /* A PC relative reloc includes the section address.  */
2849   addend += input_section->vma;
2850
2851   *relocation = val + addend;
2852   *relocation -= (input_section->output_section->vma
2853                   + input_section->output_offset);
2854   return TRUE;
2855 }
2856
2857 bfd_boolean
2858 xcoff_reloc_type_toc (input_bfd, input_section, output_bfd, rel, sym, howto,
2859                       val, addend, relocation, contents)
2860      bfd *input_bfd;
2861      asection *input_section ATTRIBUTE_UNUSED;
2862      bfd *output_bfd;
2863      struct internal_reloc *rel;
2864      struct internal_syment *sym;
2865      struct reloc_howto_struct *howto ATTRIBUTE_UNUSED;
2866      bfd_vma val;
2867      bfd_vma addend ATTRIBUTE_UNUSED;
2868      bfd_vma *relocation;
2869      bfd_byte *contents ATTRIBUTE_UNUSED;
2870 {
2871   struct xcoff_link_hash_entry *h;
2872
2873   if (0 > rel->r_symndx)
2874     return FALSE;
2875
2876   h = obj_xcoff_sym_hashes (input_bfd)[rel->r_symndx];
2877
2878   if (h != NULL && h->smclas != XMC_TD)
2879     {
2880       if (h->toc_section == NULL)
2881         {
2882           (*_bfd_error_handler)
2883             (_("%s: TOC reloc at 0x%x to symbol `%s' with no TOC entry"),
2884              bfd_get_filename (input_bfd), rel->r_vaddr,
2885              h->root.root.string);
2886           bfd_set_error (bfd_error_bad_value);
2887           return FALSE;
2888         }
2889
2890       BFD_ASSERT ((h->flags & XCOFF_SET_TOC) == 0);
2891       val = (h->toc_section->output_section->vma
2892               + h->toc_section->output_offset);
2893     }
2894
2895   *relocation = ((val - xcoff_data (output_bfd)->toc)
2896                  - (sym->n_value - xcoff_data (input_bfd)->toc));
2897   return TRUE;
2898 }
2899
2900 bfd_boolean
2901 xcoff_reloc_type_ba (input_bfd, input_section, output_bfd, rel, sym, howto,
2902                      val, addend, relocation, contents)
2903      bfd *input_bfd ATTRIBUTE_UNUSED;
2904      asection *input_section ATTRIBUTE_UNUSED;
2905      bfd *output_bfd ATTRIBUTE_UNUSED;
2906      struct internal_reloc *rel ATTRIBUTE_UNUSED;
2907      struct internal_syment *sym ATTRIBUTE_UNUSED;
2908      struct reloc_howto_struct *howto;
2909      bfd_vma val;
2910      bfd_vma addend;
2911      bfd_vma *relocation;
2912      bfd_byte *contents ATTRIBUTE_UNUSED;
2913 {
2914   howto->src_mask &= ~3;
2915   howto->dst_mask = howto->src_mask;
2916
2917   *relocation = val + addend;
2918
2919   return TRUE;
2920 }
2921
2922 static bfd_boolean
2923 xcoff_reloc_type_br (input_bfd, input_section, output_bfd, rel, sym, howto,
2924                      val, addend, relocation, contents)
2925      bfd *input_bfd;
2926      asection *input_section;
2927      bfd *output_bfd ATTRIBUTE_UNUSED;
2928      struct internal_reloc *rel;
2929      struct internal_syment *sym ATTRIBUTE_UNUSED;
2930      struct reloc_howto_struct *howto;
2931      bfd_vma val;
2932      bfd_vma addend;
2933      bfd_vma *relocation;
2934      bfd_byte *contents;
2935 {
2936   struct xcoff_link_hash_entry *h;
2937
2938   if (0 > rel->r_symndx)
2939     return FALSE;
2940
2941   h = obj_xcoff_sym_hashes (input_bfd)[rel->r_symndx];
2942
2943   /* If we see an R_BR or R_RBR reloc which is jumping to global
2944      linkage code, and it is followed by an appropriate cror nop
2945      instruction, we replace the cror with lwz r2,20(r1).  This
2946      restores the TOC after the glink code.  Contrariwise, if the
2947      call is followed by a lwz r2,20(r1), but the call is not
2948      going to global linkage code, we can replace the load with a
2949      cror.  */
2950   if (NULL != h
2951       && bfd_link_hash_defined == h->root.type
2952       && (rel->r_vaddr - input_section->vma + 8
2953           <= input_section->_cooked_size))
2954     {
2955       bfd_byte *pnext;
2956       unsigned long next;
2957
2958       pnext = contents + (rel->r_vaddr - input_section->vma) + 4;
2959       next = bfd_get_32 (input_bfd, pnext);
2960
2961       /* The _ptrgl function is magic.  It is used by the AIX
2962          compiler to call a function through a pointer.  */
2963       if (h->smclas == XMC_GL || strcmp (h->root.root.string, "._ptrgl") == 0)
2964         {
2965           if (next == 0x4def7b82                        /* cror 15,15,15 */
2966               || next == 0x4ffffb82                     /* cror 31,31,31 */
2967               || next == 0x60000000)                    /* ori r0,r0,0 */
2968             bfd_put_32 (input_bfd, 0x80410014, pnext);  /* lwz r1,20(r1) */
2969
2970         }
2971       else
2972         {
2973           if (next == 0x80410014)                       /* lwz r1,20(r1) */
2974             bfd_put_32 (input_bfd, 0x60000000, pnext);  /* ori r0,r0,0 */
2975         }
2976     }
2977   else if (NULL != h && bfd_link_hash_undefined == h->root.type)
2978     {
2979       /* Normally, this relocation is against a defined symbol.  In the
2980          case where this is a partial link and the output section offset
2981          is greater than 2^25, the linker will return an invalid error
2982          message that the relocation has been truncated.  Yes it has been
2983          truncated but no it not important.  For this case, disable the
2984          overflow checking. */
2985
2986       howto->complain_on_overflow = complain_overflow_dont;
2987     }
2988
2989   howto->pc_relative = TRUE;
2990   howto->src_mask &= ~3;
2991   howto->dst_mask = howto->src_mask;
2992
2993   /* A PC relative reloc includes the section address.  */
2994   addend += input_section->vma;
2995
2996   *relocation = val + addend;
2997   *relocation -= (input_section->output_section->vma
2998                   + input_section->output_offset);
2999   return TRUE;
3000 }
3001
3002 bfd_boolean
3003 xcoff_reloc_type_crel (input_bfd, input_section, output_bfd, rel, sym, howto,
3004                        val, addend, relocation, contents)
3005      bfd *input_bfd ATTRIBUTE_UNUSED;
3006      asection *input_section;
3007      bfd *output_bfd ATTRIBUTE_UNUSED;
3008      struct internal_reloc *rel ATTRIBUTE_UNUSED;
3009      struct internal_syment *sym ATTRIBUTE_UNUSED;
3010      struct reloc_howto_struct *howto;
3011      bfd_vma val ATTRIBUTE_UNUSED;
3012      bfd_vma addend;
3013      bfd_vma *relocation;
3014      bfd_byte *contents ATTRIBUTE_UNUSED;
3015 {
3016   howto->pc_relative = TRUE;
3017   howto->src_mask &= ~3;
3018   howto->dst_mask = howto->src_mask;
3019
3020   /* A PC relative reloc includes the section address.  */
3021   addend += input_section->vma;
3022
3023   *relocation = val + addend;
3024   *relocation -= (input_section->output_section->vma
3025                   + input_section->output_offset);
3026   return TRUE;
3027 }
3028
3029 static bfd_boolean
3030 xcoff_complain_overflow_dont_func (input_bfd, val, relocation, howto)
3031      bfd *input_bfd ATTRIBUTE_UNUSED;
3032      bfd_vma val ATTRIBUTE_UNUSED;
3033      bfd_vma relocation ATTRIBUTE_UNUSED;
3034      struct reloc_howto_struct *howto ATTRIBUTE_UNUSED;
3035 {
3036   return FALSE;
3037 }
3038
3039 static bfd_boolean
3040 xcoff_complain_overflow_bitfield_func (input_bfd, val, relocation, howto)
3041      bfd *input_bfd;
3042      bfd_vma val;
3043      bfd_vma relocation;
3044      struct reloc_howto_struct *howto;
3045 {
3046   bfd_vma addrmask, fieldmask, signmask, ss;
3047   bfd_vma a, b, sum;
3048
3049   /* Get the values to be added together.  For signed and unsigned
3050      relocations, we assume that all values should be truncated to
3051      the size of an address.  For bitfields, all the bits matter.
3052      See also bfd_check_overflow.  */
3053   fieldmask = N_ONES (howto->bitsize);
3054   addrmask = N_ONES (bfd_arch_bits_per_address (input_bfd)) | fieldmask;
3055   a = relocation;
3056   b = val & howto->src_mask;
3057
3058   /* Much like unsigned, except no trimming with addrmask.  In
3059      addition, the sum overflows if there is a carry out of
3060      the bfd_vma, i.e., the sum is less than either input
3061      operand.  */
3062   a >>= howto->rightshift;
3063   b >>= howto->bitpos;
3064
3065   /* Bitfields are sometimes used for signed numbers; for
3066      example, a 13-bit field sometimes represents values in
3067      0..8191 and sometimes represents values in -4096..4095.
3068      If the field is signed and a is -4095 (0x1001) and b is
3069      -1 (0x1fff), the sum is -4096 (0x1000), but (0x1001 +
3070      0x1fff is 0x3000).  It's not clear how to handle this
3071      everywhere, since there is not way to know how many bits
3072      are significant in the relocation, but the original code
3073      assumed that it was fully sign extended, and we will keep
3074      that assumption.  */
3075   signmask = (fieldmask >> 1) + 1;
3076
3077   if ((a & ~ fieldmask) != 0)
3078     {
3079       /* Some bits out of the field are set.  This might not
3080          be a problem: if this is a signed bitfield, it is OK
3081          iff all the high bits are set, including the sign
3082          bit.  We'll try setting all but the most significant
3083          bit in the original relocation value: if this is all
3084          ones, we are OK, assuming a signed bitfield.  */
3085       ss = (signmask << howto->rightshift) - 1;
3086       if ((ss | relocation) != ~ (bfd_vma) 0)
3087         return TRUE;
3088       a &= fieldmask;
3089     }
3090
3091   /* We just assume (b & ~ fieldmask) == 0.  */
3092
3093   /* We explicitly permit wrap around if this relocation
3094      covers the high bit of an address.  The Linux kernel
3095      relies on it, and it is the only way to write assembler
3096      code which can run when loaded at a location 0x80000000
3097      away from the location at which it is linked.  */
3098   if (howto->bitsize + howto->rightshift
3099       == bfd_arch_bits_per_address (input_bfd))
3100     return FALSE;
3101
3102   sum = a + b;
3103   if (sum < a || (sum & ~ fieldmask) != 0)
3104     {
3105       /* There was a carry out, or the field overflow.  Test
3106          for signed operands again.  Here is the overflow test
3107          is as for complain_overflow_signed.  */
3108       if (((~ (a ^ b)) & (a ^ sum)) & signmask)
3109         return TRUE;
3110     }
3111
3112   return FALSE;
3113 }
3114
3115 static bfd_boolean
3116 xcoff_complain_overflow_signed_func (input_bfd, val, relocation, howto)
3117      bfd *input_bfd;
3118      bfd_vma val;
3119      bfd_vma relocation;
3120      struct reloc_howto_struct *howto;
3121 {
3122   bfd_vma addrmask, fieldmask, signmask, ss;
3123   bfd_vma a, b, sum;
3124
3125   /* Get the values to be added together.  For signed and unsigned
3126      relocations, we assume that all values should be truncated to
3127      the size of an address.  For bitfields, all the bits matter.
3128      See also bfd_check_overflow.  */
3129   fieldmask = N_ONES (howto->bitsize);
3130   addrmask = N_ONES (bfd_arch_bits_per_address (input_bfd)) | fieldmask;
3131   a = relocation;
3132   b = val & howto->src_mask;
3133
3134   a = (a & addrmask) >> howto->rightshift;
3135
3136   /* If any sign bits are set, all sign bits must be set.
3137      That is, A must be a valid negative address after
3138      shifting.  */
3139   signmask = ~ (fieldmask >> 1);
3140   ss = a & signmask;
3141   if (ss != 0 && ss != ((addrmask >> howto->rightshift) & signmask))
3142     return TRUE;
3143
3144   /* We only need this next bit of code if the sign bit of B
3145      is below the sign bit of A.  This would only happen if
3146      SRC_MASK had fewer bits than BITSIZE.  Note that if
3147      SRC_MASK has more bits than BITSIZE, we can get into
3148      trouble; we would need to verify that B is in range, as
3149      we do for A above.  */
3150   signmask = ((~ howto->src_mask) >> 1) & howto->src_mask;
3151   if ((b & signmask) != 0)
3152     {
3153       /* Set all the bits above the sign bit.  */
3154       b -= signmask <<= 1;
3155     }
3156
3157   b = (b & addrmask) >> howto->bitpos;
3158
3159   /* Now we can do the addition.  */
3160   sum = a + b;
3161
3162   /* See if the result has the correct sign.  Bits above the
3163      sign bit are junk now; ignore them.  If the sum is
3164      positive, make sure we did not have all negative inputs;
3165      if the sum is negative, make sure we did not have all
3166      positive inputs.  The test below looks only at the sign
3167      bits, and it really just
3168      SIGN (A) == SIGN (B) && SIGN (A) != SIGN (SUM)
3169   */
3170   signmask = (fieldmask >> 1) + 1;
3171   if (((~ (a ^ b)) & (a ^ sum)) & signmask)
3172     return TRUE;
3173
3174   return FALSE;
3175 }
3176
3177 static bfd_boolean
3178 xcoff_complain_overflow_unsigned_func (input_bfd, val, relocation, howto)
3179      bfd *input_bfd;
3180      bfd_vma val;
3181      bfd_vma relocation;
3182      struct reloc_howto_struct *howto;
3183 {
3184   bfd_vma addrmask, fieldmask;
3185   bfd_vma a, b, sum;
3186
3187   /* Get the values to be added together.  For signed and unsigned
3188      relocations, we assume that all values should be truncated to
3189      the size of an address.  For bitfields, all the bits matter.
3190      See also bfd_check_overflow.  */
3191   fieldmask = N_ONES (howto->bitsize);
3192   addrmask = N_ONES (bfd_arch_bits_per_address (input_bfd)) | fieldmask;
3193   a = relocation;
3194   b = val & howto->src_mask;
3195
3196   /* Checking for an unsigned overflow is relatively easy:
3197      trim the addresses and add, and trim the result as well.
3198      Overflow is normally indicated when the result does not
3199      fit in the field.  However, we also need to consider the
3200      case when, e.g., fieldmask is 0x7fffffff or smaller, an
3201      input is 0x80000000, and bfd_vma is only 32 bits; then we
3202      will get sum == 0, but there is an overflow, since the
3203      inputs did not fit in the field.  Instead of doing a
3204      separate test, we can check for this by or-ing in the
3205      operands when testing for the sum overflowing its final
3206      field.  */
3207   a = (a & addrmask) >> howto->rightshift;
3208   b = (b & addrmask) >> howto->bitpos;
3209   sum = (a + b) & addrmask;
3210   if ((a | b | sum) & ~ fieldmask)
3211     return TRUE;
3212
3213   return FALSE;
3214 }
3215
3216 /* This is the relocation function for the RS/6000/POWER/PowerPC.
3217    This is currently the only processor which uses XCOFF; I hope that
3218    will never change.
3219
3220    I took the relocation type definitions from two documents:
3221    the PowerPC AIX Version 4 Application Binary Interface, First
3222    Edition (April 1992), and the PowerOpen ABI, Big-Endian
3223    32-Bit Hardware Implementation (June 30, 1994).  Differences
3224    between the documents are noted below.
3225
3226    Unsupported r_type's
3227
3228    R_RTB:
3229    R_RRTBI:
3230    R_RRTBA:
3231
3232    These relocs are defined by the PowerPC ABI to be
3233    relative branches which use half of the difference
3234    between the symbol and the program counter.  I can't
3235    quite figure out when this is useful.  These relocs are
3236    not defined by the PowerOpen ABI.
3237
3238    Supported r_type's
3239
3240    R_POS:
3241    Simple positive relocation.
3242
3243    R_NEG:
3244    Simple negative relocation.
3245
3246    R_REL:
3247    Simple PC relative relocation.
3248
3249    R_TOC:
3250    TOC relative relocation.  The value in the instruction in
3251    the input file is the offset from the input file TOC to
3252    the desired location.  We want the offset from the final
3253    TOC to the desired location.  We have:
3254    isym = iTOC + in
3255    iinsn = in + o
3256    osym = oTOC + on
3257    oinsn = on + o
3258    so we must change insn by on - in.
3259
3260    R_GL:
3261    GL linkage relocation.  The value of this relocation
3262    is the address of the entry in the TOC section.
3263
3264    R_TCL:
3265    Local object TOC address.  I can't figure out the
3266    difference between this and case R_GL.
3267
3268    R_TRL:
3269    TOC relative relocation.  A TOC relative load instruction
3270    which may be changed to a load address instruction.
3271    FIXME: We don't currently implement this optimization.
3272
3273    R_TRLA:
3274    TOC relative relocation.  This is a TOC relative load
3275    address instruction which may be changed to a load
3276    instruction.  FIXME: I don't know if this is the correct
3277    implementation.
3278
3279    R_BA:
3280    Absolute branch.  We don't want to mess with the lower
3281    two bits of the instruction.
3282
3283    R_CAI:
3284    The PowerPC ABI defines this as an absolute call which
3285    may be modified to become a relative call.  The PowerOpen
3286    ABI does not define this relocation type.
3287
3288    R_RBA:
3289    Absolute branch which may be modified to become a
3290    relative branch.
3291
3292    R_RBAC:
3293    The PowerPC ABI defines this as an absolute branch to a
3294    fixed address which may be modified to an absolute branch
3295    to a symbol.  The PowerOpen ABI does not define this
3296    relocation type.
3297
3298    R_RBRC:
3299    The PowerPC ABI defines this as an absolute branch to a
3300    fixed address which may be modified to a relative branch.
3301    The PowerOpen ABI does not define this relocation type.
3302
3303    R_BR:
3304    Relative branch.  We don't want to mess with the lower
3305    two bits of the instruction.
3306
3307    R_CREL:
3308    The PowerPC ABI defines this as a relative call which may
3309    be modified to become an absolute call.  The PowerOpen
3310    ABI does not define this relocation type.
3311
3312    R_RBR:
3313    A relative branch which may be modified to become an
3314    absolute branch.  FIXME: We don't implement this,
3315    although we should for symbols of storage mapping class
3316    XMC_XO.
3317
3318    R_RL:
3319    The PowerPC AIX ABI describes this as a load which may be
3320    changed to a load address.  The PowerOpen ABI says this
3321    is the same as case R_POS.
3322
3323    R_RLA:
3324    The PowerPC AIX ABI describes this as a load address
3325    which may be changed to a load.  The PowerOpen ABI says
3326    this is the same as R_POS.
3327 */
3328
3329 bfd_boolean
3330 xcoff_ppc_relocate_section (output_bfd, info, input_bfd,
3331                             input_section, contents, relocs, syms,
3332                             sections)
3333      bfd *output_bfd;
3334      struct bfd_link_info *info;
3335      bfd *input_bfd;
3336      asection *input_section;
3337      bfd_byte *contents;
3338      struct internal_reloc *relocs;
3339      struct internal_syment *syms;
3340      asection **sections;
3341 {
3342   struct internal_reloc *rel;
3343   struct internal_reloc *relend;
3344
3345   rel = relocs;
3346   relend = rel + input_section->reloc_count;
3347   for (; rel < relend; rel++)
3348     {
3349       long symndx;
3350       struct xcoff_link_hash_entry *h;
3351       struct internal_syment *sym;
3352       bfd_vma addend;
3353       bfd_vma val;
3354       struct reloc_howto_struct howto;
3355       bfd_vma relocation;
3356       bfd_vma value_to_relocate;
3357       bfd_vma address;
3358       bfd_byte *location;
3359
3360       /* Relocation type R_REF is a special relocation type which is
3361          merely used to prevent garbage collection from occurring for
3362          the csect including the symbol which it references.  */
3363       if (rel->r_type == R_REF)
3364         continue;
3365
3366       /* howto */
3367       howto.type = rel->r_type;
3368       howto.rightshift = 0;
3369       howto.bitsize = (rel->r_size & 0x1f) + 1;
3370       howto.size = howto.bitsize > 16 ? 2 : 1;
3371       howto.pc_relative = FALSE;
3372       howto.bitpos = 0;
3373       howto.complain_on_overflow = (rel->r_size & 0x80
3374                                     ? complain_overflow_signed
3375                                     : complain_overflow_bitfield);
3376       howto.special_function = NULL;
3377       howto.name = "internal";
3378       howto.partial_inplace = TRUE;
3379       howto.src_mask = howto.dst_mask = N_ONES (howto.bitsize);
3380       howto.pcrel_offset = FALSE;
3381
3382       /* symbol */
3383       val = 0;
3384       addend = 0;
3385       h = NULL;
3386       sym = NULL;
3387       symndx = rel->r_symndx;
3388
3389       if (-1 != symndx)
3390         {
3391           asection *sec;
3392
3393           h = obj_xcoff_sym_hashes (input_bfd)[symndx];
3394           sym = syms + symndx;
3395           addend = - sym->n_value;
3396
3397           if (NULL == h)
3398             {
3399               sec = sections[symndx];
3400               /* Hack to make sure we use the right TOC anchor value
3401                  if this reloc is against the TOC anchor.  */
3402               if (sec->name[3] == '0'
3403                   && strcmp (sec->name, ".tc0") == 0)
3404                 val = xcoff_data (output_bfd)->toc;
3405               else
3406                 val = (sec->output_section->vma
3407                        + sec->output_offset
3408                        + sym->n_value
3409                        - sec->vma);
3410             }
3411           else
3412             {
3413               if (h->root.type == bfd_link_hash_defined
3414                   || h->root.type == bfd_link_hash_defweak)
3415                 {
3416                   sec = h->root.u.def.section;
3417                   val = (h->root.u.def.value
3418                          + sec->output_section->vma
3419                          + sec->output_offset);
3420                 }
3421               else if (h->root.type == bfd_link_hash_common)
3422                 {
3423                   sec = h->root.u.c.p->section;
3424                   val = (sec->output_section->vma
3425                          + sec->output_offset);
3426
3427                 }
3428               else if ((0 == (h->flags & (XCOFF_DEF_DYNAMIC | XCOFF_IMPORT)))
3429                        && ! info->relocatable)
3430                 {
3431                   if (! ((*info->callbacks->undefined_symbol)
3432                          (info, h->root.root.string, input_bfd, input_section,
3433                           rel->r_vaddr - input_section->vma, TRUE)))
3434                     return FALSE;
3435
3436                   /* Don't try to process the reloc.  It can't help, and
3437                      it may generate another error.  */
3438                   continue;
3439                 }
3440             }
3441         }
3442
3443       if (rel->r_type >= XCOFF_MAX_CALCULATE_RELOCATION
3444           || !((*xcoff_calculate_relocation[rel->r_type])
3445                (input_bfd, input_section, output_bfd, rel, sym, &howto, val,
3446                 addend, &relocation, contents)))
3447         return FALSE;
3448
3449       /* address */
3450       address = rel->r_vaddr - input_section->vma;
3451       location = contents + address;
3452
3453       if (address > input_section->_raw_size)
3454         abort ();
3455
3456       /* Get the value we are going to relocate.  */
3457       if (1 == howto.size)
3458         value_to_relocate = bfd_get_16 (input_bfd, location);
3459       else
3460         value_to_relocate = bfd_get_32 (input_bfd, location);
3461
3462       /* overflow.
3463
3464          FIXME: We may drop bits during the addition
3465          which we don't check for.  We must either check at every single
3466          operation, which would be tedious, or we must do the computations
3467          in a type larger than bfd_vma, which would be inefficient.  */
3468
3469       if ((unsigned int) howto.complain_on_overflow
3470           >= XCOFF_MAX_COMPLAIN_OVERFLOW)
3471         abort ();
3472
3473       if (((*xcoff_complain_overflow[howto.complain_on_overflow])
3474            (input_bfd, value_to_relocate, relocation, &howto)))
3475         {
3476           const char *name;
3477           char buf[SYMNMLEN + 1];
3478           char reloc_type_name[10];
3479
3480           if (symndx == -1)
3481             {
3482               name = "*ABS*";
3483             }
3484           else if (h != NULL)
3485             {
3486               name = h->root.root.string;
3487             }
3488           else
3489             {
3490               name = _bfd_coff_internal_syment_name (input_bfd, sym, buf);
3491               if (name == NULL)
3492                 name = "UNKNOWN";
3493             }
3494           sprintf (reloc_type_name, "0x%02x", rel->r_type);
3495
3496           if (! ((*info->callbacks->reloc_overflow)
3497                  (info, name, reloc_type_name, (bfd_vma) 0, input_bfd,
3498                   input_section, rel->r_vaddr - input_section->vma)))
3499             return FALSE;
3500         }
3501
3502       /* Add RELOCATION to the right bits of VALUE_TO_RELOCATE.  */
3503       value_to_relocate = ((value_to_relocate & ~howto.dst_mask)
3504                            | (((value_to_relocate & howto.src_mask)
3505                                + relocation) & howto.dst_mask));
3506
3507       /* Put the value back in the object file.  */
3508       if (1 == howto.size)
3509         bfd_put_16 (input_bfd, value_to_relocate, location);
3510       else
3511         bfd_put_32 (input_bfd, value_to_relocate, location);
3512     }
3513
3514   return TRUE;
3515 }
3516
3517 static bfd_boolean
3518 _bfd_xcoff_put_ldsymbol_name (abfd, ldinfo, ldsym, name)
3519      bfd *abfd ATTRIBUTE_UNUSED;
3520          struct xcoff_loader_info *ldinfo;
3521          struct internal_ldsym *ldsym;
3522          const char *name;
3523 {
3524   size_t len;
3525   len = strlen (name);
3526
3527   if (len <= SYMNMLEN)
3528     strncpy (ldsym->_l._l_name, name, SYMNMLEN);
3529   else
3530     {
3531       if (ldinfo->string_size + len + 3 > ldinfo->string_alc)
3532         {
3533           bfd_size_type newalc;
3534           bfd_byte *newstrings;
3535
3536           newalc = ldinfo->string_alc * 2;
3537           if (newalc == 0)
3538             newalc = 32;
3539           while (ldinfo->string_size + len + 3 > newalc)
3540             newalc *= 2;
3541
3542           newstrings = ((bfd_byte *)
3543                         bfd_realloc ((PTR) ldinfo->strings, newalc));
3544           if (newstrings == NULL)
3545             {
3546               ldinfo->failed = TRUE;
3547               return FALSE;
3548             }
3549           ldinfo->string_alc = newalc;
3550           ldinfo->strings = newstrings;
3551         }
3552
3553       bfd_put_16 (ldinfo->output_bfd, (bfd_vma) (len + 1),
3554                   ldinfo->strings + ldinfo->string_size);
3555       strcpy (ldinfo->strings + ldinfo->string_size + 2, name);
3556       ldsym->_l._l_l._l_zeroes = 0;
3557       ldsym->_l._l_l._l_offset = ldinfo->string_size + 2;
3558       ldinfo->string_size += len + 3;
3559     }
3560
3561   return TRUE;
3562 }
3563
3564 static bfd_boolean
3565 _bfd_xcoff_put_symbol_name (bfd *abfd, struct bfd_strtab_hash *strtab,
3566                             struct internal_syment *sym,
3567                             const char *name)
3568 {
3569   if (strlen (name) <= SYMNMLEN)
3570     {
3571       strncpy (sym->_n._n_name, name, SYMNMLEN);
3572     }
3573   else
3574     {
3575       bfd_boolean hash;
3576       bfd_size_type indx;
3577
3578       hash = TRUE;
3579       if ((abfd->flags & BFD_TRADITIONAL_FORMAT) != 0)
3580         hash = FALSE;
3581       indx = _bfd_stringtab_add (strtab, name, hash, FALSE);
3582       if (indx == (bfd_size_type) -1)
3583         return FALSE;
3584       sym->_n._n_n._n_zeroes = 0;
3585       sym->_n._n_n._n_offset = STRING_SIZE_SIZE + indx;
3586     }
3587   return TRUE;
3588 }
3589
3590 static asection *
3591 xcoff_create_csect_from_smclas (abfd, aux, symbol_name)
3592      bfd *abfd;
3593      union internal_auxent *aux;
3594      const char *symbol_name;
3595 {
3596   asection *return_value = NULL;
3597
3598   /* .sv64 = x_smclas == 17
3599      This is an invalid csect for 32 bit apps.  */
3600   static const char *names[19] =
3601   {
3602     ".pr", ".ro", ".db", ".tc", ".ua", ".rw", ".gl", ".xo",
3603     ".sv", ".bs", ".ds", ".uc", ".ti", ".tb", NULL, ".tc0",
3604     ".td", NULL, ".sv3264"
3605   };
3606
3607   if ((19 >= aux->x_csect.x_smclas)
3608       && (NULL != names[aux->x_csect.x_smclas]))
3609     {
3610       return_value = bfd_make_section_anyway
3611         (abfd, names[aux->x_csect.x_smclas]);
3612     }
3613   else
3614     {
3615       (*_bfd_error_handler)
3616         (_("%s: symbol `%s' has unrecognized smclas %d"),
3617          bfd_archive_filename (abfd), symbol_name, aux->x_csect.x_smclas);
3618       bfd_set_error (bfd_error_bad_value);
3619     }
3620
3621   return return_value;
3622 }
3623
3624 static bfd_boolean
3625 xcoff_is_lineno_count_overflow (abfd, value)
3626     bfd *abfd ATTRIBUTE_UNUSED;
3627         bfd_vma value;
3628 {
3629   if (0xffff <= value)
3630     return TRUE;
3631
3632   return FALSE;
3633 }
3634
3635 static bfd_boolean
3636 xcoff_is_reloc_count_overflow (abfd, value)
3637     bfd *abfd ATTRIBUTE_UNUSED;
3638         bfd_vma value;
3639 {
3640   if (0xffff <= value)
3641     return TRUE;
3642
3643   return FALSE;
3644 }
3645
3646 static bfd_vma
3647 xcoff_loader_symbol_offset (abfd, ldhdr)
3648     bfd *abfd;
3649     struct internal_ldhdr *ldhdr ATTRIBUTE_UNUSED;
3650 {
3651   return bfd_xcoff_ldhdrsz (abfd);
3652 }
3653
3654 static bfd_vma
3655 xcoff_loader_reloc_offset (abfd, ldhdr)
3656     bfd *abfd;
3657     struct internal_ldhdr *ldhdr;
3658 {
3659   return bfd_xcoff_ldhdrsz (abfd) + ldhdr->l_nsyms * bfd_xcoff_ldsymsz (abfd);
3660 }
3661
3662 static bfd_boolean
3663 xcoff_generate_rtinit  (abfd, init, fini, rtld)
3664      bfd *abfd;
3665      const char *init;
3666      const char *fini;
3667      bfd_boolean rtld;
3668 {
3669   bfd_byte filehdr_ext[FILHSZ];
3670   bfd_byte scnhdr_ext[SCNHSZ];
3671   bfd_byte syment_ext[SYMESZ * 10];
3672   bfd_byte reloc_ext[RELSZ * 3];
3673   bfd_byte *data_buffer;
3674   bfd_size_type data_buffer_size;
3675   bfd_byte *string_table = NULL, *st_tmp = NULL;
3676   bfd_size_type string_table_size;
3677   bfd_vma val;
3678   size_t initsz, finisz;
3679   struct internal_filehdr filehdr;
3680   struct internal_scnhdr scnhdr;
3681   struct internal_syment syment;
3682   union internal_auxent auxent;
3683   struct internal_reloc reloc;
3684
3685   char *data_name = ".data";
3686   char *rtinit_name = "__rtinit";
3687   char *rtld_name = "__rtld";
3688
3689   if (! bfd_xcoff_rtinit_size (abfd))
3690     return FALSE;
3691
3692   initsz = (init == NULL ? 0 : 1 + strlen (init));
3693   finisz = (fini == NULL ? 0 : 1 + strlen (fini));
3694
3695   /* file header */
3696   memset (filehdr_ext, 0, FILHSZ);
3697   memset (&filehdr, 0, sizeof (struct internal_filehdr));
3698   filehdr.f_magic = bfd_xcoff_magic_number (abfd);
3699   filehdr.f_nscns = 1;
3700   filehdr.f_timdat = 0;
3701   filehdr.f_nsyms = 0;  /* at least 6, no more than 10 */
3702   filehdr.f_symptr = 0; /* set below */
3703   filehdr.f_opthdr = 0;
3704   filehdr.f_flags = 0;
3705
3706   /* section header */
3707   memset (scnhdr_ext, 0, SCNHSZ);
3708   memset (&scnhdr, 0, sizeof (struct internal_scnhdr));
3709   memcpy (scnhdr.s_name, data_name, strlen (data_name));
3710   scnhdr.s_paddr = 0;
3711   scnhdr.s_vaddr = 0;
3712   scnhdr.s_size = 0;    /* set below */
3713   scnhdr.s_scnptr = FILHSZ + SCNHSZ;
3714   scnhdr.s_relptr = 0;  /* set below */
3715   scnhdr.s_lnnoptr = 0;
3716   scnhdr.s_nreloc = 0;  /* either 1 or 2 */
3717   scnhdr.s_nlnno = 0;
3718   scnhdr.s_flags = STYP_DATA;
3719
3720   /* .data
3721      0x0000           0x00000000 : rtl
3722      0x0004           0x00000010 : offset to init, or 0
3723      0x0008           0x00000028 : offset to fini, or 0
3724      0x000C           0x0000000C : size of descriptor
3725      0x0010           0x00000000 : init, needs a reloc
3726      0x0014           0x00000040 : offset to init name
3727      0x0018           0x00000000 : flags, padded to a word
3728      0x001C           0x00000000 : empty init
3729      0x0020           0x00000000 :
3730      0x0024           0x00000000 :
3731      0x0028           0x00000000 : fini, needs a reloc
3732      0x002C           0x00000??? : offset to fini name
3733      0x0030           0x00000000 : flags, padded to a word
3734      0x0034           0x00000000 : empty fini
3735      0x0038           0x00000000 :
3736      0x003C           0x00000000 :
3737      0x0040           init name
3738      0x0040 + initsz  fini name */
3739
3740   data_buffer_size = 0x0040 + initsz + finisz;
3741   data_buffer_size = (data_buffer_size + 7) &~ (bfd_size_type) 7;
3742   data_buffer = NULL;
3743   data_buffer = (bfd_byte *) bfd_zmalloc (data_buffer_size);
3744   if (data_buffer == NULL)
3745     return FALSE;
3746
3747   if (initsz)
3748     {
3749       val = 0x10;
3750       bfd_h_put_32 (abfd, val, &data_buffer[0x04]);
3751       val = 0x40;
3752       bfd_h_put_32 (abfd, val, &data_buffer[0x14]);
3753       memcpy (&data_buffer[val], init, initsz);
3754     }
3755
3756   if (finisz)
3757     {
3758       val = 0x28;
3759       bfd_h_put_32 (abfd, val, &data_buffer[0x08]);
3760       val = 0x40 + initsz;
3761       bfd_h_put_32 (abfd, val, &data_buffer[0x2C]);
3762       memcpy (&data_buffer[val], fini, finisz);
3763     }
3764
3765   val = 0x0C;
3766   bfd_h_put_32 (abfd, val, &data_buffer[0x0C]);
3767
3768   scnhdr.s_size = data_buffer_size;
3769
3770   /* string table */
3771   string_table_size = 0;
3772   if (initsz > 9)
3773     string_table_size += initsz;
3774   if (finisz > 9)
3775     string_table_size += finisz;
3776   if (string_table_size)
3777     {
3778       string_table_size += 4;
3779       string_table = (bfd_byte *) bfd_zmalloc (string_table_size);
3780       if (string_table == NULL)
3781         return FALSE;
3782
3783       val = string_table_size;
3784       bfd_h_put_32 (abfd, val, &string_table[0]);
3785       st_tmp = string_table + 4;
3786     }
3787
3788   /* symbols
3789      0. .data csect
3790      2. __rtinit
3791      4. init function
3792      6. fini function
3793      8. __rtld  */
3794   memset (syment_ext, 0, 10 * SYMESZ);
3795   memset (reloc_ext, 0, 3 * RELSZ);
3796
3797   /* .data csect */
3798   memset (&syment, 0, sizeof (struct internal_syment));
3799   memset (&auxent, 0, sizeof (union internal_auxent));
3800   memcpy (syment._n._n_name, data_name, strlen (data_name));
3801   syment.n_scnum = 1;
3802   syment.n_sclass = C_HIDEXT;
3803   syment.n_numaux = 1;
3804   auxent.x_csect.x_scnlen.l = data_buffer_size;
3805   auxent.x_csect.x_smtyp = 3 << 3 | XTY_SD;
3806   auxent.x_csect.x_smclas = XMC_RW;
3807   bfd_coff_swap_sym_out (abfd, &syment,
3808                          &syment_ext[filehdr.f_nsyms * SYMESZ]);
3809   bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0,
3810                          syment.n_numaux,
3811                          &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]);
3812   filehdr.f_nsyms += 2;
3813
3814   /* __rtinit */
3815   memset (&syment, 0, sizeof (struct internal_syment));
3816   memset (&auxent, 0, sizeof (union internal_auxent));
3817   memcpy (syment._n._n_name, rtinit_name, strlen (rtinit_name));
3818   syment.n_scnum = 1;
3819   syment.n_sclass = C_EXT;
3820   syment.n_numaux = 1;
3821   auxent.x_csect.x_smtyp = XTY_LD;
3822   auxent.x_csect.x_smclas = XMC_RW;
3823   bfd_coff_swap_sym_out (abfd, &syment,
3824                          &syment_ext[filehdr.f_nsyms * SYMESZ]);
3825   bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0,
3826                          syment.n_numaux,
3827                          &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]);
3828   filehdr.f_nsyms += 2;
3829
3830   /* init */
3831   if (initsz)
3832     {
3833       memset (&syment, 0, sizeof (struct internal_syment));
3834       memset (&auxent, 0, sizeof (union internal_auxent));
3835
3836       if (initsz > 9)
3837         {
3838           syment._n._n_n._n_offset = st_tmp - string_table;
3839           memcpy (st_tmp, init, initsz);
3840           st_tmp += initsz;
3841         }
3842       else
3843         memcpy (syment._n._n_name, init, initsz - 1);
3844
3845       syment.n_sclass = C_EXT;
3846       syment.n_numaux = 1;
3847       bfd_coff_swap_sym_out (abfd, &syment,
3848                              &syment_ext[filehdr.f_nsyms * SYMESZ]);
3849       bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0,
3850                              syment.n_numaux,
3851                              &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]);
3852
3853       /* reloc */
3854       memset (&reloc, 0, sizeof (struct internal_reloc));
3855       reloc.r_vaddr = 0x0010;
3856       reloc.r_symndx = filehdr.f_nsyms;
3857       reloc.r_type = R_POS;
3858       reloc.r_size = 31;
3859       bfd_coff_swap_reloc_out (abfd, &reloc, &reloc_ext[0]);
3860
3861       filehdr.f_nsyms += 2;
3862       scnhdr.s_nreloc += 1;
3863     }
3864
3865   /* fini */
3866   if (finisz)
3867     {
3868       memset (&syment, 0, sizeof (struct internal_syment));
3869       memset (&auxent, 0, sizeof (union internal_auxent));
3870
3871       if (finisz > 9)
3872         {
3873           syment._n._n_n._n_offset = st_tmp - string_table;
3874           memcpy (st_tmp, fini, finisz);
3875           st_tmp += finisz;
3876         }
3877       else
3878         memcpy (syment._n._n_name, fini, finisz - 1);
3879
3880       syment.n_sclass = C_EXT;
3881       syment.n_numaux = 1;
3882       bfd_coff_swap_sym_out (abfd, &syment,
3883                              &syment_ext[filehdr.f_nsyms * SYMESZ]);
3884       bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0,
3885                              syment.n_numaux,
3886                              &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]);
3887
3888       /* reloc */
3889       memset (&reloc, 0, sizeof (struct internal_reloc));
3890       reloc.r_vaddr = 0x0028;
3891       reloc.r_symndx = filehdr.f_nsyms;
3892       reloc.r_type = R_POS;
3893       reloc.r_size = 31;
3894       bfd_coff_swap_reloc_out (abfd, &reloc,
3895                                &reloc_ext[scnhdr.s_nreloc * RELSZ]);
3896
3897       filehdr.f_nsyms += 2;
3898       scnhdr.s_nreloc += 1;
3899     }
3900
3901   if (rtld)
3902     {
3903       memset (&syment, 0, sizeof (struct internal_syment));
3904       memset (&auxent, 0, sizeof (union internal_auxent));
3905       memcpy (syment._n._n_name, rtld_name, strlen (rtld_name));
3906       syment.n_sclass = C_EXT;
3907       syment.n_numaux = 1;
3908       bfd_coff_swap_sym_out (abfd, &syment,
3909                              &syment_ext[filehdr.f_nsyms * SYMESZ]);
3910       bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0,
3911                              syment.n_numaux,
3912                              &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]);
3913
3914       /* reloc */
3915       memset (&reloc, 0, sizeof (struct internal_reloc));
3916       reloc.r_vaddr = 0x0000;
3917       reloc.r_symndx = filehdr.f_nsyms;
3918       reloc.r_type = R_POS;
3919       reloc.r_size = 31;
3920       bfd_coff_swap_reloc_out (abfd, &reloc,
3921                                &reloc_ext[scnhdr.s_nreloc * RELSZ]);
3922
3923       filehdr.f_nsyms += 2;
3924       scnhdr.s_nreloc += 1;
3925     }
3926
3927   scnhdr.s_relptr = scnhdr.s_scnptr + data_buffer_size;
3928   filehdr.f_symptr = scnhdr.s_relptr + scnhdr.s_nreloc * RELSZ;
3929
3930   bfd_coff_swap_filehdr_out (abfd, &filehdr, filehdr_ext);
3931   bfd_bwrite (filehdr_ext, FILHSZ, abfd);
3932   bfd_coff_swap_scnhdr_out (abfd, &scnhdr, scnhdr_ext);
3933   bfd_bwrite (scnhdr_ext, SCNHSZ, abfd);
3934   bfd_bwrite (data_buffer, data_buffer_size, abfd);
3935   bfd_bwrite (reloc_ext, scnhdr.s_nreloc * RELSZ, abfd);
3936   bfd_bwrite (syment_ext, filehdr.f_nsyms * SYMESZ, abfd);
3937   bfd_bwrite (string_table, string_table_size, abfd);
3938
3939   free (data_buffer);
3940   data_buffer = NULL;
3941
3942   return TRUE;
3943 }
3944
3945
3946 static reloc_howto_type xcoff_dynamic_reloc =
3947 HOWTO (0,                       /* type */
3948        0,                       /* rightshift */
3949        2,                       /* size (0 = byte, 1 = short, 2 = long) */
3950        32,                      /* bitsize */
3951        FALSE,                   /* pc_relative */
3952        0,                       /* bitpos */
3953        complain_overflow_bitfield, /* complain_on_overflow */
3954        0,                       /* special_function */
3955        "R_POS",                 /* name */
3956        TRUE,                    /* partial_inplace */
3957        0xffffffff,              /* src_mask */
3958        0xffffffff,              /* dst_mask */
3959        FALSE);                  /* pcrel_offset */
3960
3961 /*  glink
3962
3963    The first word of global linkage code must be modified by filling in
3964    the correct TOC offset.  */
3965
3966 static unsigned long xcoff_glink_code[9] =
3967   {
3968     0x81820000, /* lwz r12,0(r2) */
3969     0x90410014, /* stw r2,20(r1) */
3970     0x800c0000, /* lwz r0,0(r12) */
3971     0x804c0004, /* lwz r2,4(r12) */
3972     0x7c0903a6, /* mtctr r0 */
3973     0x4e800420, /* bctr */
3974     0x00000000, /* start of traceback table */
3975     0x000c8000, /* traceback table */
3976     0x00000000, /* traceback table */
3977   };
3978
3979
3980 static const struct xcoff_backend_data_rec bfd_xcoff_backend_data =
3981   {
3982     { /* COFF backend, defined in libcoff.h.  */
3983       _bfd_xcoff_swap_aux_in,
3984       _bfd_xcoff_swap_sym_in,
3985       coff_swap_lineno_in,
3986       _bfd_xcoff_swap_aux_out,
3987       _bfd_xcoff_swap_sym_out,
3988       coff_swap_lineno_out,
3989       xcoff_swap_reloc_out,
3990       coff_swap_filehdr_out,
3991       coff_swap_aouthdr_out,
3992       coff_swap_scnhdr_out,
3993       FILHSZ,
3994       AOUTSZ,
3995       SCNHSZ,
3996       SYMESZ,
3997       AUXESZ,
3998       RELSZ,
3999       LINESZ,
4000       FILNMLEN,
4001       TRUE,                     /* _bfd_coff_long_filenames */
4002       FALSE,                    /* _bfd_coff_long_section_names */
4003       3,                        /* _bfd_coff_default_section_alignment_power */
4004       FALSE,                    /* _bfd_coff_force_symnames_in_strings */
4005       2,                        /* _bfd_coff_debug_string_prefix_length */
4006       coff_swap_filehdr_in,
4007       coff_swap_aouthdr_in,
4008       coff_swap_scnhdr_in,
4009       xcoff_swap_reloc_in,
4010       coff_bad_format_hook,
4011       coff_set_arch_mach_hook,
4012       coff_mkobject_hook,
4013       styp_to_sec_flags,
4014       coff_set_alignment_hook,
4015       coff_slurp_symbol_table,
4016       symname_in_debug_hook,
4017       coff_pointerize_aux_hook,
4018       coff_print_aux,
4019       dummy_reloc16_extra_cases,
4020       dummy_reloc16_estimate,
4021       NULL,                     /* bfd_coff_sym_is_global */
4022       coff_compute_section_file_positions,
4023       NULL,                     /* _bfd_coff_start_final_link */
4024       xcoff_ppc_relocate_section,
4025       coff_rtype_to_howto,
4026       NULL,                     /* _bfd_coff_adjust_symndx */
4027       _bfd_generic_link_add_one_symbol,
4028       coff_link_output_has_begun,
4029       coff_final_link_postscript
4030     },
4031
4032     0x01DF,                     /* magic number */
4033     bfd_arch_rs6000,
4034     bfd_mach_rs6k,
4035
4036     /* Function pointers to xcoff specific swap routines.  */
4037     xcoff_swap_ldhdr_in,
4038     xcoff_swap_ldhdr_out,
4039     xcoff_swap_ldsym_in,
4040     xcoff_swap_ldsym_out,
4041     xcoff_swap_ldrel_in,
4042     xcoff_swap_ldrel_out,
4043
4044     /* Sizes.  */
4045     LDHDRSZ,
4046     LDSYMSZ,
4047     LDRELSZ,
4048     12,                         /* _xcoff_function_descriptor_size */
4049     SMALL_AOUTSZ,
4050
4051     /* Versions.  */
4052     1,                          /* _xcoff_ldhdr_version */
4053
4054     _bfd_xcoff_put_symbol_name,
4055     _bfd_xcoff_put_ldsymbol_name,
4056     &xcoff_dynamic_reloc,
4057     xcoff_create_csect_from_smclas,
4058
4059     /* Lineno and reloc count overflow.  */
4060     xcoff_is_lineno_count_overflow,
4061     xcoff_is_reloc_count_overflow,
4062
4063     xcoff_loader_symbol_offset,
4064     xcoff_loader_reloc_offset,
4065
4066     /* glink.  */
4067     &xcoff_glink_code[0],
4068     36,                         /* _xcoff_glink_size */
4069
4070     /* rtinit */
4071     64,                         /* _xcoff_rtinit_size */
4072     xcoff_generate_rtinit,
4073   };
4074
4075 /* The transfer vector that leads the outside world to all of the above.  */
4076 const bfd_target rs6000coff_vec =
4077   {
4078     "aixcoff-rs6000",
4079     bfd_target_xcoff_flavour,
4080     BFD_ENDIAN_BIG,             /* data byte order is big */
4081     BFD_ENDIAN_BIG,             /* header byte order is big */
4082
4083     (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | DYNAMIC
4084      | HAS_SYMS | HAS_LOCALS | WP_TEXT),
4085
4086     SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA,
4087     0,                          /* leading char */
4088     '/',                        /* ar_pad_char */
4089     15,                         /* ar_max_namelen */
4090
4091     /* data */
4092     bfd_getb64,
4093     bfd_getb_signed_64,
4094     bfd_putb64,
4095     bfd_getb32,
4096     bfd_getb_signed_32,
4097     bfd_putb32,
4098     bfd_getb16,
4099     bfd_getb_signed_16,
4100     bfd_putb16,
4101
4102     /* hdrs */
4103     bfd_getb64,
4104     bfd_getb_signed_64,
4105     bfd_putb64,
4106     bfd_getb32,
4107     bfd_getb_signed_32,
4108     bfd_putb32,
4109     bfd_getb16,
4110     bfd_getb_signed_16,
4111     bfd_putb16,
4112
4113     { /* bfd_check_format */
4114       _bfd_dummy_target,
4115       coff_object_p,
4116       _bfd_xcoff_archive_p,
4117       CORE_FILE_P
4118     },
4119
4120     { /* bfd_set_format */
4121       bfd_false,
4122       coff_mkobject,
4123       _bfd_generic_mkarchive,
4124       bfd_false
4125     },
4126
4127     {/* bfd_write_contents */
4128       bfd_false,
4129       coff_write_object_contents,
4130       _bfd_xcoff_write_archive_contents,
4131       bfd_false
4132     },
4133
4134     /* Generic */
4135     bfd_true,
4136     bfd_true,
4137     coff_new_section_hook,
4138     _bfd_generic_get_section_contents,
4139     _bfd_generic_get_section_contents_in_window,
4140
4141     /* Copy */
4142     _bfd_xcoff_copy_private_bfd_data,
4143     ((bfd_boolean (*) (bfd *, bfd *)) bfd_true),
4144     ((bfd_boolean (*) (bfd *, asection *, bfd *, asection *)) bfd_true),
4145     ((bfd_boolean (*) (bfd *, asymbol *, bfd *, asymbol *)) bfd_true),
4146     ((bfd_boolean (*) (bfd *, flagword)) bfd_true),
4147     ((bfd_boolean (*) (bfd *, void * )) bfd_true),
4148
4149     /* Core */
4150     coff_core_file_failing_command,
4151     coff_core_file_failing_signal,
4152     coff_core_file_matches_executable_p,
4153
4154     /* Archive */
4155     _bfd_xcoff_slurp_armap,
4156     bfd_false,
4157     ((bfd_boolean (*) (bfd *, char **, bfd_size_type *, const char **)) bfd_false),
4158     bfd_dont_truncate_arname,
4159     _bfd_xcoff_write_armap,
4160     _bfd_xcoff_read_ar_hdr,
4161     _bfd_xcoff_openr_next_archived_file,
4162     _bfd_generic_get_elt_at_index,
4163     _bfd_xcoff_stat_arch_elt,
4164     bfd_true,
4165
4166     /* Symbols */
4167     coff_get_symtab_upper_bound,
4168     coff_canonicalize_symtab,
4169     coff_make_empty_symbol,
4170     coff_print_symbol,
4171     coff_get_symbol_info,
4172     _bfd_xcoff_is_local_label_name,
4173     coff_get_lineno,
4174     coff_find_nearest_line,
4175     coff_bfd_make_debug_symbol,
4176     _bfd_generic_read_minisymbols,
4177     _bfd_generic_minisymbol_to_symbol,
4178
4179     /* Reloc */
4180     coff_get_reloc_upper_bound,
4181     coff_canonicalize_reloc,
4182     _bfd_xcoff_reloc_type_lookup,
4183
4184     /* Write */
4185     coff_set_arch_mach,
4186     coff_set_section_contents,
4187
4188     /* Link */
4189     _bfd_xcoff_sizeof_headers,
4190     bfd_generic_get_relocated_section_contents,
4191     bfd_generic_relax_section,
4192     _bfd_xcoff_bfd_link_hash_table_create,
4193     _bfd_generic_link_hash_table_free,
4194     _bfd_xcoff_bfd_link_add_symbols,
4195     _bfd_generic_link_just_syms,
4196     _bfd_xcoff_bfd_final_link,
4197     _bfd_generic_link_split_section,
4198     bfd_generic_gc_sections,
4199     bfd_generic_merge_sections,
4200     bfd_generic_discard_group,
4201
4202     /* Dynamic */
4203     _bfd_xcoff_get_dynamic_symtab_upper_bound,
4204     _bfd_xcoff_canonicalize_dynamic_symtab,
4205     _bfd_xcoff_get_dynamic_reloc_upper_bound,
4206     _bfd_xcoff_canonicalize_dynamic_reloc,
4207
4208     /* Opposite endian version, none exists */
4209     NULL,
4210
4211     (void *) &bfd_xcoff_backend_data,
4212   };
4213
4214 /* xcoff-powermac target
4215    Old target.
4216    Only difference between this target and the rs6000 target is the
4217    the default architecture and machine type used in coffcode.h
4218
4219    PowerPC Macs use the same magic numbers as RS/6000
4220    (because that's how they were bootstrapped originally),
4221    but they are always PowerPC architecture.  */
4222 static const struct xcoff_backend_data_rec bfd_pmac_xcoff_backend_data =
4223   {
4224     { /* COFF backend, defined in libcoff.h.  */
4225       _bfd_xcoff_swap_aux_in,
4226       _bfd_xcoff_swap_sym_in,
4227       coff_swap_lineno_in,
4228       _bfd_xcoff_swap_aux_out,
4229       _bfd_xcoff_swap_sym_out,
4230       coff_swap_lineno_out,
4231       xcoff_swap_reloc_out,
4232       coff_swap_filehdr_out,
4233       coff_swap_aouthdr_out,
4234       coff_swap_scnhdr_out,
4235       FILHSZ,
4236       AOUTSZ,
4237       SCNHSZ,
4238       SYMESZ,
4239       AUXESZ,
4240       RELSZ,
4241       LINESZ,
4242       FILNMLEN,
4243       TRUE,                     /* _bfd_coff_long_filenames */
4244       FALSE,                    /* _bfd_coff_long_section_names */
4245       3,                        /* _bfd_coff_default_section_alignment_power */
4246       FALSE,                    /* _bfd_coff_force_symnames_in_strings */
4247       2,                        /* _bfd_coff_debug_string_prefix_length */
4248       coff_swap_filehdr_in,
4249       coff_swap_aouthdr_in,
4250       coff_swap_scnhdr_in,
4251       xcoff_swap_reloc_in,
4252       coff_bad_format_hook,
4253       coff_set_arch_mach_hook,
4254       coff_mkobject_hook,
4255       styp_to_sec_flags,
4256       coff_set_alignment_hook,
4257       coff_slurp_symbol_table,
4258       symname_in_debug_hook,
4259       coff_pointerize_aux_hook,
4260       coff_print_aux,
4261       dummy_reloc16_extra_cases,
4262       dummy_reloc16_estimate,
4263       NULL,                     /* bfd_coff_sym_is_global */
4264       coff_compute_section_file_positions,
4265       NULL,                     /* _bfd_coff_start_final_link */
4266       xcoff_ppc_relocate_section,
4267       coff_rtype_to_howto,
4268       NULL,                     /* _bfd_coff_adjust_symndx */
4269       _bfd_generic_link_add_one_symbol,
4270       coff_link_output_has_begun,
4271       coff_final_link_postscript
4272     },
4273
4274     0x01DF,                     /* magic number */
4275     bfd_arch_powerpc,
4276     bfd_mach_ppc,
4277
4278     /* Function pointers to xcoff specific swap routines.  */
4279     xcoff_swap_ldhdr_in,
4280     xcoff_swap_ldhdr_out,
4281     xcoff_swap_ldsym_in,
4282     xcoff_swap_ldsym_out,
4283     xcoff_swap_ldrel_in,
4284     xcoff_swap_ldrel_out,
4285
4286     /* Sizes.  */
4287     LDHDRSZ,
4288     LDSYMSZ,
4289     LDRELSZ,
4290     12,                         /* _xcoff_function_descriptor_size */
4291     SMALL_AOUTSZ,
4292
4293     /* Versions.  */
4294     1,                          /* _xcoff_ldhdr_version */
4295
4296     _bfd_xcoff_put_symbol_name,
4297     _bfd_xcoff_put_ldsymbol_name,
4298     &xcoff_dynamic_reloc,
4299     xcoff_create_csect_from_smclas,
4300
4301     /* Lineno and reloc count overflow.  */
4302     xcoff_is_lineno_count_overflow,
4303     xcoff_is_reloc_count_overflow,
4304
4305     xcoff_loader_symbol_offset,
4306     xcoff_loader_reloc_offset,
4307
4308     /* glink.  */
4309     &xcoff_glink_code[0],
4310     36,                         /* _xcoff_glink_size */
4311
4312     /* rtinit */
4313     0,                          /* _xcoff_rtinit_size */
4314     xcoff_generate_rtinit,
4315   };
4316
4317 /* The transfer vector that leads the outside world to all of the above.  */
4318 const bfd_target pmac_xcoff_vec =
4319   {
4320     "xcoff-powermac",
4321     bfd_target_xcoff_flavour,
4322     BFD_ENDIAN_BIG,             /* data byte order is big */
4323     BFD_ENDIAN_BIG,             /* header byte order is big */
4324
4325     (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | DYNAMIC
4326      | HAS_SYMS | HAS_LOCALS | WP_TEXT),
4327
4328     SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA,
4329     0,                          /* leading char */
4330     '/',                        /* ar_pad_char */
4331     15,                         /* ar_max_namelen */
4332
4333     /* data */
4334     bfd_getb64,
4335     bfd_getb_signed_64,
4336     bfd_putb64,
4337     bfd_getb32,
4338     bfd_getb_signed_32,
4339     bfd_putb32,
4340     bfd_getb16,
4341     bfd_getb_signed_16,
4342     bfd_putb16,
4343
4344     /* hdrs */
4345     bfd_getb64,
4346     bfd_getb_signed_64,
4347     bfd_putb64,
4348     bfd_getb32,
4349     bfd_getb_signed_32,
4350     bfd_putb32,
4351     bfd_getb16,
4352     bfd_getb_signed_16,
4353     bfd_putb16,
4354
4355     { /* bfd_check_format */
4356       _bfd_dummy_target,
4357       coff_object_p,
4358       _bfd_xcoff_archive_p,
4359       CORE_FILE_P
4360     },
4361
4362     { /* bfd_set_format */
4363       bfd_false,
4364       coff_mkobject,
4365       _bfd_generic_mkarchive,
4366       bfd_false
4367     },
4368
4369     {/* bfd_write_contents */
4370       bfd_false,
4371       coff_write_object_contents,
4372       _bfd_xcoff_write_archive_contents,
4373       bfd_false
4374     },
4375
4376     /* Generic */
4377     bfd_true,
4378     bfd_true,
4379     coff_new_section_hook,
4380     _bfd_generic_get_section_contents,
4381     _bfd_generic_get_section_contents_in_window,
4382
4383     /* Copy */
4384     _bfd_xcoff_copy_private_bfd_data,
4385     ((bfd_boolean (*) (bfd *, bfd *)) bfd_true),
4386     ((bfd_boolean (*) (bfd *, asection *, bfd *, asection *)) bfd_true),
4387     ((bfd_boolean (*) (bfd *, asymbol *, bfd *, asymbol *)) bfd_true),
4388     ((bfd_boolean (*) (bfd *, flagword)) bfd_true),
4389     ((bfd_boolean (*) (bfd *, void * )) bfd_true),
4390
4391     /* Core */
4392     coff_core_file_failing_command,
4393     coff_core_file_failing_signal,
4394     coff_core_file_matches_executable_p,
4395
4396     /* Archive */
4397     _bfd_xcoff_slurp_armap,
4398     bfd_false,
4399     ((bfd_boolean (*) (bfd *, char **, bfd_size_type *, const char **)) bfd_false),
4400     bfd_dont_truncate_arname,
4401     _bfd_xcoff_write_armap,
4402     _bfd_xcoff_read_ar_hdr,
4403     _bfd_xcoff_openr_next_archived_file,
4404     _bfd_generic_get_elt_at_index,
4405     _bfd_xcoff_stat_arch_elt,
4406     bfd_true,
4407
4408     /* Symbols */
4409     coff_get_symtab_upper_bound,
4410     coff_canonicalize_symtab,
4411     coff_make_empty_symbol,
4412     coff_print_symbol,
4413     coff_get_symbol_info,
4414     _bfd_xcoff_is_local_label_name,
4415     coff_get_lineno,
4416     coff_find_nearest_line,
4417     coff_bfd_make_debug_symbol,
4418     _bfd_generic_read_minisymbols,
4419     _bfd_generic_minisymbol_to_symbol,
4420
4421     /* Reloc */
4422     coff_get_reloc_upper_bound,
4423     coff_canonicalize_reloc,
4424     _bfd_xcoff_reloc_type_lookup,
4425
4426     /* Write */
4427     coff_set_arch_mach,
4428     coff_set_section_contents,
4429
4430     /* Link */
4431     _bfd_xcoff_sizeof_headers,
4432     bfd_generic_get_relocated_section_contents,
4433     bfd_generic_relax_section,
4434     _bfd_xcoff_bfd_link_hash_table_create,
4435     _bfd_generic_link_hash_table_free,
4436     _bfd_xcoff_bfd_link_add_symbols,
4437     _bfd_generic_link_just_syms,
4438     _bfd_xcoff_bfd_final_link,
4439     _bfd_generic_link_split_section,
4440     bfd_generic_gc_sections,
4441     bfd_generic_merge_sections,
4442     bfd_generic_discard_group,
4443
4444     /* Dynamic */
4445     _bfd_xcoff_get_dynamic_symtab_upper_bound,
4446     _bfd_xcoff_canonicalize_dynamic_symtab,
4447     _bfd_xcoff_get_dynamic_reloc_upper_bound,
4448     _bfd_xcoff_canonicalize_dynamic_reloc,
4449
4450     /* Opposite endian version, none exists */
4451     NULL,
4452
4453     (void *) &bfd_pmac_xcoff_backend_data,
4454   };