bfd/coff-rs6000.c

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