bfd/coff-rs6000.c

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