bfd/coff-rs6000.c

   1 /* BFD back-end for IBM RS/6000 "XCOFF" files.
   2    Copyright 1990, 91, 92, 93, 94, 95, 96, 97, 98, 1999
   3    Free Software Foundation, Inc.
   4    FIXME: Can someone provide a transliteration of this name into ASCII?
   5    Using the following chars caused a compiler warning on HIUX (so I replaced
   6    them with octal escapes), and isn't useful without an understanding of what
   7    character set it is.
   8    Written by Metin G. Ozisik, Mimi Ph\373\364ng-Th\345o V\365,
   9      and John Gilmore.
  10    Archive support from Damon A. Permezel.
  11    Contributed by IBM Corporation and Cygnus Support.
  12
  13 This file is part of BFD, the Binary File Descriptor library.
  14
  15 This program is free software; you can redistribute it and/or modify
  16 it under the terms of the GNU General Public License as published by
  17 the Free Software Foundation; either version 2 of the License, or
  18 (at your option) any later version.
  19
  20 This program is distributed in the hope that it will be useful,
  21 but WITHOUT ANY WARRANTY; without even the implied warranty of
  22 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  23 GNU General Public License for more details.
  24
  25 You should have received a copy of the GNU General Public License
  26 along with this program; if not, write to the Free Software
  27 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  28
  29 /* Internalcoff.h and coffcode.h modify themselves based on this flag.  */
  30 #define RS6000COFF_C 1
  31
  32 #include "bfd.h"
  33 #include "sysdep.h"
  34 #include "libbfd.h"
  35 #include "coff/internal.h"
  36 #include "coff/rs6000.h"
  37 #include "libcoff.h"
  38
  39 /* The main body of code is in coffcode.h.  */
  40
  41 boolean _bfd_xcoff_mkobject PARAMS ((bfd *));
  42 boolean _bfd_xcoff_copy_private_bfd_data PARAMS ((bfd *, bfd *));
  43 boolean _bfd_xcoff_is_local_label_name PARAMS ((bfd *, const char *));
  44 void _bfd_xcoff_rtype2howto
  45   PARAMS ((arelent *, struct internal_reloc *));
  46 reloc_howto_type *_bfd_xcoff_reloc_type_lookup
  47   PARAMS ((bfd *, bfd_reloc_code_real_type));
  48 boolean _bfd_xcoff_slurp_armap PARAMS ((bfd *));
  49 const bfd_target *_bfd_xcoff_archive_p PARAMS ((bfd *));
  50 PTR _bfd_xcoff_read_ar_hdr PARAMS ((bfd *));
  51 bfd *_bfd_xcoff_openr_next_archived_file PARAMS ((bfd *, bfd *));
  52 int _bfd_xcoff_generic_stat_arch_elt PARAMS ((bfd *, struct stat *));
  53 static const char *normalize_filename PARAMS ((bfd *));
  54 boolean _bfd_xcoff_write_armap
  55   PARAMS ((bfd *, unsigned int, struct orl *, unsigned int, int));
  56 boolean _bfd_xcoff_write_archive_contents PARAMS ((bfd *));
  57 int _bfd_xcoff_sizeof_headers PARAMS ((bfd *, boolean));
  58 \f
  59 /* We use our own tdata type.  Its first field is the COFF tdata type,
  60    so the COFF routines are compatible.  */
  61
  62 boolean
  63 _bfd_xcoff_mkobject (abfd)
  64      bfd *abfd;
  65 {
  66   coff_data_type *coff;
  67
  68   abfd->tdata.xcoff_obj_data =
  69     ((struct xcoff_tdata *)
  70      bfd_zalloc (abfd, sizeof (struct xcoff_tdata)));
  71   if (abfd->tdata.xcoff_obj_data == NULL)
  72     return false;
  73   coff = coff_data (abfd);
  74   coff->symbols = (coff_symbol_type *) NULL;
  75   coff->conversion_table = (unsigned int *) NULL;
  76   coff->raw_syments = (struct coff_ptr_struct *) NULL;
  77   coff->relocbase = 0;
  78
  79   xcoff_data (abfd)->modtype = ('1' << 8) | 'L';
  80
  81   /* We set cputype to -1 to indicate that it has not been
  82      initialized.  */
  83   xcoff_data (abfd)->cputype = -1;
  84
  85   xcoff_data (abfd)->csects = NULL;
  86   xcoff_data (abfd)->debug_indices = NULL;
  87
  88   return true;
  89 }
  90
  91 /* Copy XCOFF data from one BFD to another.  */
  92
  93 boolean
  94 _bfd_xcoff_copy_private_bfd_data (ibfd, obfd)
  95      bfd *ibfd;
  96      bfd *obfd;
  97 {
  98   struct xcoff_tdata *ix, *ox;
  99   asection *sec;
 100
 101   if (ibfd->xvec != obfd->xvec)
 102     return true;
 103   ix = xcoff_data (ibfd);
 104   ox = xcoff_data (obfd);
 105   ox->full_aouthdr = ix->full_aouthdr;
 106   ox->toc = ix->toc;
 107   if (ix->sntoc == 0)
 108     ox->sntoc = 0;
 109   else
 110     {
 111       sec = coff_section_from_bfd_index (ibfd, ix->sntoc);
 112       if (sec == NULL)
 113         ox->sntoc = 0;
 114       else
 115         ox->sntoc = sec->output_section->target_index;
 116     }
 117   if (ix->snentry == 0)
 118     ox->snentry = 0;
 119   else
 120     {
 121       sec = coff_section_from_bfd_index (ibfd, ix->snentry);
 122       if (sec == NULL)
 123         ox->snentry = 0;
 124       else
 125         ox->snentry = sec->output_section->target_index;
 126     }
 127   ox->text_align_power = ix->text_align_power;
 128   ox->data_align_power = ix->data_align_power;
 129   ox->modtype = ix->modtype;
 130   ox->cputype = ix->cputype;
 131   ox->maxdata = ix->maxdata;
 132   ox->maxstack = ix->maxstack;
 133   return true;
 134 }
 135
 136 /* I don't think XCOFF really has a notion of local labels based on
 137    name.  This will mean that ld -X doesn't actually strip anything.
 138    The AIX native linker does not have a -X option, and it ignores the
 139    -x option.  */
 140
 141 boolean
 142 _bfd_xcoff_is_local_label_name (abfd, name)
 143      bfd *abfd ATTRIBUTE_UNUSED;
 144      const char *name ATTRIBUTE_UNUSED;
 145 {
 146   return false;
 147 }
 148 \f
 149
 150 #define NO_COFF_SYMBOLS
 151
 152 static void xcoff_swap_sym_in PARAMS ((bfd *, PTR, PTR));
 153 static unsigned int xcoff_swap_sym_out PARAMS ((bfd *, PTR, PTR));
 154 static void xcoff_swap_aux_in PARAMS ((bfd *, PTR, int, int, int, int, PTR));
 155 static unsigned int xcoff_swap_aux_out PARAMS ((bfd *, PTR, int, int, int, int, PTR));
 156
 157 static void
 158 xcoff_swap_sym_in (abfd, ext1, in1)
 159      bfd            *abfd;
 160      PTR ext1;
 161      PTR in1;
 162 {
 163   SYMENT *ext = (SYMENT *)ext1;
 164   struct internal_syment      *in = (struct internal_syment *)in1;
 165
 166
 167   if(ext->e.e_name[0] != 0)
 168     {
 169       memcpy(in->_n._n_name, ext->e.e_name, SYMNMLEN);
 170     }
 171   else
 172     {
 173       in->_n._n_n._n_zeroes = 0;
 174       in->_n._n_n._n_offset =
 175           bfd_h_get_32(abfd, (bfd_byte *) ext->e.e.e_offset);
 176     }
 177
 178   in->n_value = bfd_h_get_32(abfd, (bfd_byte *) ext->e_value);
 179   in->n_scnum = bfd_h_get_16(abfd, (bfd_byte *) ext->e_scnum);
 180   in->n_type = bfd_h_get_16(abfd, (bfd_byte *) ext->e_type);
 181   in->n_sclass = bfd_h_get_8(abfd, ext->e_sclass);
 182   in->n_numaux = bfd_h_get_8(abfd, ext->e_numaux);
 183 }
 184
 185 static unsigned int
 186 xcoff_swap_sym_out (abfd, inp, extp)
 187      bfd       *abfd;
 188      PTR        inp;
 189      PTR        extp;
 190 {
 191   struct internal_syment *in = (struct internal_syment *)inp;
 192   SYMENT *ext =(SYMENT *)extp;
 193
 194   if(in->_n._n_name[0] != 0)
 195     {
 196       memcpy(ext->e.e_name, in->_n._n_name, SYMNMLEN);
 197     }
 198   else
 199     {
 200       bfd_h_put_32(abfd, 0, (bfd_byte *) ext->e.e.e_zeroes);
 201       bfd_h_put_32(abfd, in->_n._n_n._n_offset,
 202               (bfd_byte *)  ext->e.e.e_offset);
 203     }
 204
 205   bfd_h_put_32(abfd,  in->n_value , (bfd_byte *) ext->e_value);
 206   bfd_h_put_16(abfd,  in->n_scnum , (bfd_byte *) ext->e_scnum);
 207   bfd_h_put_16(abfd,  in->n_type , (bfd_byte *) ext->e_type);
 208   bfd_h_put_8(abfd,  in->n_sclass , ext->e_sclass);
 209   bfd_h_put_8(abfd,  in->n_numaux , ext->e_numaux);
 210   return bfd_coff_symesz (abfd);
 211 }
 212
 213 #define PUTWORD bfd_h_put_32
 214 #define PUTHALF bfd_h_put_16
 215 #define PUTBYTE bfd_h_put_8
 216 #define GETWORD bfd_h_get_32
 217 #define GETHALF bfd_h_get_16
 218 #define GETBYTE bfd_h_get_8
 219
 220 static void
 221 xcoff_swap_aux_in (abfd, ext1, type, class, indx, numaux, in1)
 222      bfd            *abfd;
 223      PTR              ext1;
 224      int             type;
 225      int             class;
 226      int              indx;
 227      int              numaux;
 228      PTR              in1;
 229 {
 230   AUXENT    *ext = (AUXENT *)ext1;
 231   union internal_auxent *in = (union internal_auxent *)in1;
 232
 233   switch (class) {
 234     case C_FILE:
 235       if (ext->x_file.x_fname[0] == 0) {
 236           in->x_file.x_n.x_zeroes = 0;
 237           in->x_file.x_n.x_offset =
 238            bfd_h_get_32(abfd, (bfd_byte *) ext->x_file.x_n.x_offset);
 239         } else {
 240             if (numaux > 1)
 241               {
 242                 if (indx == 0)
 243                   memcpy (in->x_file.x_fname, ext->x_file.x_fname,
 244                           numaux * sizeof (AUXENT));
 245               }
 246             else
 247               {
 248                 memcpy (in->x_file.x_fname, ext->x_file.x_fname, FILNMLEN);
 249               }
 250           }
 251       goto end;
 252
 253       /* RS/6000 "csect" auxents */
 254     case C_EXT:
 255     case C_HIDEXT:
 256       if (indx + 1 == numaux)
 257         {
 258           in->x_csect.x_scnlen.l =
 259               bfd_h_get_32 (abfd, ext->x_csect.x_scnlen);
 260           in->x_csect.x_parmhash = bfd_h_get_32 (abfd,
 261                                                  ext->x_csect.x_parmhash);
 262           in->x_csect.x_snhash   = bfd_h_get_16 (abfd, ext->x_csect.x_snhash);
 263           /* We don't have to hack bitfields in x_smtyp because it's
 264              defined by shifts-and-ands, which are equivalent on all
 265              byte orders.  */
 266           in->x_csect.x_smtyp    = bfd_h_get_8  (abfd, ext->x_csect.x_smtyp);
 267           in->x_csect.x_smclas   = bfd_h_get_8  (abfd, ext->x_csect.x_smclas);
 268           in->x_csect.x_stab     = bfd_h_get_32 (abfd, ext->x_csect.x_stab);
 269           in->x_csect.x_snstab   = bfd_h_get_16 (abfd, ext->x_csect.x_snstab);
 270           goto end;
 271         }
 272       break;
 273
 274     case C_STAT:
 275     case C_LEAFSTAT:
 276     case C_HIDDEN:
 277       if (type == T_NULL) {
 278           in->x_scn.x_scnlen = bfd_h_get_32(abfd,
 279                   (bfd_byte *) ext->x_scn.x_scnlen);
 280           in->x_scn.x_nreloc = bfd_h_get_16(abfd,
 281                   (bfd_byte *) ext->x_scn.x_nreloc);
 282           in->x_scn.x_nlinno = bfd_h_get_16(abfd,
 283                   (bfd_byte *) ext->x_scn.x_nlinno);
 284           /* PE defines some extra fields; we zero them out for
 285              safety.  */
 286           in->x_scn.x_checksum = 0;
 287           in->x_scn.x_associated = 0;
 288           in->x_scn.x_comdat = 0;
 289
 290           goto end;
 291         }
 292       break;
 293     }
 294
 295   in->x_sym.x_tagndx.l = bfd_h_get_32(abfd, (bfd_byte *) ext->x_sym.x_tagndx);
 296   in->x_sym.x_tvndx = bfd_h_get_16(abfd, (bfd_byte *) ext->x_sym.x_tvndx);
 297
 298   if (class == C_BLOCK || class == C_FCN || ISFCN (type) || ISTAG (class))
 299     {
 300       in->x_sym.x_fcnary.x_fcn.x_lnnoptr = bfd_h_get_32(abfd, (bfd_byte *)
 301               ext->x_sym.x_fcnary.x_fcn.x_lnnoptr);
 302       in->x_sym.x_fcnary.x_fcn.x_endndx.l = bfd_h_get_32(abfd, (bfd_byte *)
 303               ext->x_sym.x_fcnary.x_fcn.x_endndx);
 304     }
 305   else
 306     {
 307       in->x_sym.x_fcnary.x_ary.x_dimen[0] =
 308         bfd_h_get_16 (abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
 309       in->x_sym.x_fcnary.x_ary.x_dimen[1] =
 310         bfd_h_get_16 (abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
 311       in->x_sym.x_fcnary.x_ary.x_dimen[2] =
 312         bfd_h_get_16 (abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
 313       in->x_sym.x_fcnary.x_ary.x_dimen[3] =
 314         bfd_h_get_16 (abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
 315     }
 316   if (ISFCN(type)) {
 317     in->x_sym.x_misc.x_fsize = bfd_h_get_32(abfd, (bfd_byte *) ext->x_sym.x_misc.x_fsize);
 318   }
 319   else {
 320     in->x_sym.x_misc.x_lnsz.x_lnno = bfd_h_get_16(abfd, (bfd_byte *)
 321             ext->x_sym.x_misc.x_lnsz.x_lnno);
 322     in->x_sym.x_misc.x_lnsz.x_size = bfd_h_get_16(abfd, (bfd_byte *)
 323             ext->x_sym.x_misc.x_lnsz.x_size);
 324   }
 325
 326 end: ;
 327   /* the semicolon is because MSVC doesn't like labels at
 328      end of block. */
 329
 330 }
 331
 332
 333
 334 static unsigned int
 335 xcoff_swap_aux_out (abfd, inp, type, class, indx, numaux, extp)
 336      bfd   *abfd;
 337      PTR        inp;
 338      int   type;
 339      int   class;
 340      int   indx ATTRIBUTE_UNUSED;
 341      int   numaux ATTRIBUTE_UNUSED;
 342      PTR        extp;
 343 {
 344   union internal_auxent *in = (union internal_auxent *)inp;
 345   AUXENT *ext = (AUXENT *)extp;
 346
 347   memset((PTR)ext, 0, bfd_coff_auxesz (abfd));
 348   switch (class)
 349     {
 350   case C_FILE:
 351     if (in->x_file.x_fname[0] == 0)
 352       {
 353       PUTWORD(abfd, 0, (bfd_byte *) ext->x_file.x_n.x_zeroes);
 354       PUTWORD(abfd,
 355               in->x_file.x_n.x_offset,
 356               (bfd_byte *) ext->x_file.x_n.x_offset);
 357     }
 358     else
 359       {
 360       memcpy (ext->x_file.x_fname, in->x_file.x_fname, FILNMLEN);
 361       }
 362     goto end;
 363
 364   /* RS/6000 "csect" auxents */
 365   case C_EXT:
 366   case C_HIDEXT:
 367     if (indx + 1 == numaux)
 368       {
 369         PUTWORD (abfd, in->x_csect.x_scnlen.l,ext->x_csect.x_scnlen);
 370         PUTWORD (abfd, in->x_csect.x_parmhash,  ext->x_csect.x_parmhash);
 371         PUTHALF (abfd, in->x_csect.x_snhash,    ext->x_csect.x_snhash);
 372         /* We don't have to hack bitfields in x_smtyp because it's
 373            defined by shifts-and-ands, which are equivalent on all
 374            byte orders.  */
 375         PUTBYTE (abfd, in->x_csect.x_smtyp,     ext->x_csect.x_smtyp);
 376         PUTBYTE (abfd, in->x_csect.x_smclas,    ext->x_csect.x_smclas);
 377         PUTWORD (abfd, in->x_csect.x_stab,      ext->x_csect.x_stab);
 378         PUTHALF (abfd, in->x_csect.x_snstab,    ext->x_csect.x_snstab);
 379         goto end;
 380       }
 381     break;
 382
 383   case C_STAT:
 384   case C_LEAFSTAT:
 385   case C_HIDDEN:
 386     if (type == T_NULL) {
 387       bfd_h_put_32(abfd, in->x_scn.x_scnlen, (bfd_byte *) ext->x_scn.x_scnlen);
 388       bfd_h_put_16(abfd, in->x_scn.x_nreloc, (bfd_byte *) ext->x_scn.x_nreloc);
 389       bfd_h_put_16(abfd, in->x_scn.x_nlinno, (bfd_byte *) ext->x_scn.x_nlinno);
 390       goto end;
 391     }
 392     break;
 393   }
 394
 395   PUTWORD(abfd, in->x_sym.x_tagndx.l, (bfd_byte *) ext->x_sym.x_tagndx);
 396   PUTWORD(abfd, in->x_sym.x_tvndx , (bfd_byte *) ext->x_sym.x_tvndx);
 397
 398   if (class == C_BLOCK || class == C_FCN || ISFCN (type) || ISTAG (class))
 399     {
 400       bfd_h_put_32(abfd,  in->x_sym.x_fcnary.x_fcn.x_lnnoptr,
 401               (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_lnnoptr);
 402       PUTWORD(abfd,  in->x_sym.x_fcnary.x_fcn.x_endndx.l,
 403               (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_endndx);
 404     }
 405   else
 406     {
 407       bfd_h_put_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[0],
 408                     (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
 409       bfd_h_put_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[1],
 410                     (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
 411       bfd_h_put_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[2],
 412                     (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
 413       bfd_h_put_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[3],
 414                     (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
 415     }
 416
 417   if (ISFCN (type))
 418     PUTWORD (abfd, in->x_sym.x_misc.x_fsize,
 419              (bfd_byte *)  ext->x_sym.x_misc.x_fsize);
 420   else
 421     {
 422       bfd_h_put_16(abfd, in->x_sym.x_misc.x_lnsz.x_lnno,
 423               (bfd_byte *)ext->x_sym.x_misc.x_lnsz.x_lnno);
 424       bfd_h_put_16(abfd, in->x_sym.x_misc.x_lnsz.x_size,
 425               (bfd_byte *)ext->x_sym.x_misc.x_lnsz.x_size);
 426     }
 427
 428 end:
 429   return bfd_coff_auxesz (abfd);
 430 }
 431
 432
 433 \f
 434 /* The XCOFF reloc table.  Actually, XCOFF relocations specify the
 435    bitsize and whether they are signed or not, along with a
 436    conventional type.  This table is for the types, which are used for
 437    different algorithms for putting in the reloc.  Many of these
 438    relocs need special_function entries, which I have not written.  */
 439
 440 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
 441    from smaller values.  Start with zero, widen, *then* decrement.  */
 442 #define MINUS_ONE       (((bfd_vma)0) - 1)
 443
 444 reloc_howto_type xcoff_howto_table[] =
 445 {
 446   /* Standard 32 bit relocation.  */
 447   HOWTO (0,                     /* type */
 448          0,                     /* rightshift */
 449          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 450          32,                    /* bitsize */
 451          false,                 /* pc_relative */
 452          0,                     /* bitpos */
 453          complain_overflow_bitfield, /* complain_on_overflow */
 454          0,                     /* special_function */
 455          "R_POS",               /* name */
 456          true,                  /* partial_inplace */
 457          0xffffffff,            /* src_mask */
 458          0xffffffff,            /* dst_mask */
 459          false),                /* pcrel_offset */
 460
 461   /* 32 bit relocation, but store negative value.  */
 462   HOWTO (1,                     /* type */
 463          0,                     /* rightshift */
 464          -2,                    /* size (0 = byte, 1 = short, 2 = long) */
 465          32,                    /* bitsize */
 466          false,                 /* pc_relative */
 467          0,                     /* bitpos */
 468          complain_overflow_bitfield, /* complain_on_overflow */
 469          0,                     /* special_function */
 470          "R_NEG",               /* name */
 471          true,                  /* partial_inplace */
 472          0xffffffff,            /* src_mask */
 473          0xffffffff,            /* dst_mask */
 474          false),                /* pcrel_offset */
 475
 476   /* 32 bit PC relative relocation.  */
 477   HOWTO (2,                     /* type */
 478          0,                     /* rightshift */
 479          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 480          32,                    /* bitsize */
 481          true,                  /* pc_relative */
 482          0,                     /* bitpos */
 483          complain_overflow_signed, /* complain_on_overflow */
 484          0,                     /* special_function */
 485          "R_REL",               /* name */
 486          true,                  /* partial_inplace */
 487          0xffffffff,            /* src_mask */
 488          0xffffffff,            /* dst_mask */
 489          false),                /* pcrel_offset */
 490
 491   /* 16 bit TOC relative relocation.  */
 492   HOWTO (3,                     /* type */
 493          0,                     /* rightshift */
 494          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 495          16,                    /* bitsize */
 496          false,                 /* pc_relative */
 497          0,                     /* bitpos */
 498          complain_overflow_bitfield, /* complain_on_overflow */
 499          0,                     /* special_function */
 500          "R_TOC",               /* name */
 501          true,                  /* partial_inplace */
 502          0xffff,                /* src_mask */
 503          0xffff,                /* dst_mask */
 504          false),                /* pcrel_offset */
 505
 506   /* I don't really know what this is.  */
 507   HOWTO (4,                     /* type */
 508          1,                     /* rightshift */
 509          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 510          32,                    /* bitsize */
 511          false,                 /* pc_relative */
 512          0,                     /* bitpos */
 513          complain_overflow_bitfield, /* complain_on_overflow */
 514          0,                     /* special_function */
 515          "R_RTB",               /* name */
 516          true,                  /* partial_inplace */
 517          0xffffffff,            /* src_mask */
 518          0xffffffff,            /* dst_mask */
 519          false),                /* pcrel_offset */
 520
 521   /* External TOC relative symbol.  */
 522   HOWTO (5,                     /* type */
 523          0,                     /* rightshift */
 524          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 525          16,                    /* bitsize */
 526          false,                 /* pc_relative */
 527          0,                     /* bitpos */
 528          complain_overflow_bitfield, /* complain_on_overflow */
 529          0,                     /* special_function */
 530          "R_GL",                /* name */
 531          true,                  /* partial_inplace */
 532          0xffff,                /* src_mask */
 533          0xffff,                /* dst_mask */
 534          false),                /* pcrel_offset */
 535
 536   /* Local TOC relative symbol.  */
 537   HOWTO (6,                     /* type */
 538          0,                     /* rightshift */
 539          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 540          16,                    /* bitsize */
 541          false,                 /* pc_relative */
 542          0,                     /* bitpos */
 543          complain_overflow_bitfield, /* complain_on_overflow */
 544          0,                     /* special_function */
 545          "R_TCL",               /* name */
 546          true,                  /* partial_inplace */
 547          0xffff,                /* src_mask */
 548          0xffff,                /* dst_mask */
 549          false),                /* pcrel_offset */
 550
 551   EMPTY_HOWTO (7),
 552
 553   /* Non modifiable absolute branch.  */
 554   HOWTO (8,                     /* type */
 555          0,                     /* rightshift */
 556          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 557          26,                    /* bitsize */
 558          false,                 /* pc_relative */
 559          0,                     /* bitpos */
 560          complain_overflow_bitfield, /* complain_on_overflow */
 561          0,                     /* special_function */
 562          "R_BA",                /* name */
 563          true,                  /* partial_inplace */
 564          0x3fffffc,             /* src_mask */
 565          0x3fffffc,             /* dst_mask */
 566          false),                /* pcrel_offset */
 567
 568   EMPTY_HOWTO (9),
 569
 570   /* Non modifiable relative branch.  */
 571   HOWTO (0xa,                   /* type */
 572          0,                     /* rightshift */
 573          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 574          26,                    /* bitsize */
 575          true,                  /* pc_relative */
 576          0,                     /* bitpos */
 577          complain_overflow_signed, /* complain_on_overflow */
 578          0,                     /* special_function */
 579          "R_BR",                /* name */
 580          true,                  /* partial_inplace */
 581          0x3fffffc,             /* src_mask */
 582          0x3fffffc,             /* dst_mask */
 583          false),                /* pcrel_offset */
 584
 585   EMPTY_HOWTO (0xb),
 586
 587   /* Indirect load.  */
 588   HOWTO (0xc,                   /* type */
 589          0,                     /* rightshift */
 590          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 591          16,                    /* bitsize */
 592          false,                 /* pc_relative */
 593          0,                     /* bitpos */
 594          complain_overflow_bitfield, /* complain_on_overflow */
 595          0,                     /* special_function */
 596          "R_RL",                /* name */
 597          true,                  /* partial_inplace */
 598          0xffff,                /* src_mask */
 599          0xffff,                /* dst_mask */
 600          false),                /* pcrel_offset */
 601
 602   /* Load address.  */
 603   HOWTO (0xd,                   /* type */
 604          0,                     /* rightshift */
 605          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 606          16,                    /* bitsize */
 607          false,                 /* pc_relative */
 608          0,                     /* bitpos */
 609          complain_overflow_bitfield, /* complain_on_overflow */
 610          0,                     /* special_function */
 611          "R_RLA",               /* name */
 612          true,                  /* partial_inplace */
 613          0xffff,                /* src_mask */
 614          0xffff,                /* dst_mask */
 615          false),                /* pcrel_offset */
 616
 617   EMPTY_HOWTO (0xe),
 618
 619   /* Non-relocating reference.  */
 620   HOWTO (0xf,                   /* type */
 621          0,                     /* rightshift */
 622          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 623          32,                    /* bitsize */
 624          false,                 /* pc_relative */
 625          0,                     /* bitpos */
 626          complain_overflow_bitfield, /* complain_on_overflow */
 627          0,                     /* special_function */
 628          "R_REF",               /* name */
 629          false,                 /* partial_inplace */
 630          0,                     /* src_mask */
 631          0,                     /* dst_mask */
 632          false),                /* pcrel_offset */
 633
 634   EMPTY_HOWTO (0x10),
 635   EMPTY_HOWTO (0x11),
 636
 637   /* TOC relative indirect load.  */
 638   HOWTO (0x12,                  /* type */
 639          0,                     /* rightshift */
 640          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 641          16,                    /* bitsize */
 642          false,                 /* pc_relative */
 643          0,                     /* bitpos */
 644          complain_overflow_bitfield, /* complain_on_overflow */
 645          0,                     /* special_function */
 646          "R_TRL",               /* name */
 647          true,                  /* partial_inplace */
 648          0xffff,                /* src_mask */
 649          0xffff,                /* dst_mask */
 650          false),                /* pcrel_offset */
 651
 652   /* TOC relative load address.  */
 653   HOWTO (0x13,                  /* type */
 654          0,                     /* rightshift */
 655          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 656          16,                    /* bitsize */
 657          false,                 /* pc_relative */
 658          0,                     /* bitpos */
 659          complain_overflow_bitfield, /* complain_on_overflow */
 660          0,                     /* special_function */
 661          "R_TRLA",              /* name */
 662          true,                  /* partial_inplace */
 663          0xffff,                /* src_mask */
 664          0xffff,                /* dst_mask */
 665          false),                /* pcrel_offset */
 666
 667   /* Modifiable relative branch.  */
 668   HOWTO (0x14,                  /* type */
 669          1,                     /* rightshift */
 670          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 671          32,                    /* bitsize */
 672          false,                 /* pc_relative */
 673          0,                     /* bitpos */
 674          complain_overflow_bitfield, /* complain_on_overflow */
 675          0,                     /* special_function */
 676          "R_RRTBI",             /* name */
 677          true,                  /* partial_inplace */
 678          0xffffffff,            /* src_mask */
 679          0xffffffff,            /* dst_mask */
 680          false),                /* pcrel_offset */
 681
 682   /* Modifiable absolute branch.  */
 683   HOWTO (0x15,                  /* type */
 684          1,                     /* rightshift */
 685          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 686          32,                    /* bitsize */
 687          false,                 /* pc_relative */
 688          0,                     /* bitpos */
 689          complain_overflow_bitfield, /* complain_on_overflow */
 690          0,                     /* special_function */
 691          "R_RRTBA",             /* name */
 692          true,                  /* partial_inplace */
 693          0xffffffff,            /* src_mask */
 694          0xffffffff,            /* dst_mask */
 695          false),                /* pcrel_offset */
 696
 697   /* Modifiable call absolute indirect.  */
 698   HOWTO (0x16,                  /* type */
 699          0,                     /* rightshift */
 700          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 701          16,                    /* bitsize */
 702          false,                 /* pc_relative */
 703          0,                     /* bitpos */
 704          complain_overflow_bitfield, /* complain_on_overflow */
 705          0,                     /* special_function */
 706          "R_CAI",               /* name */
 707          true,                  /* partial_inplace */
 708          0xffff,                /* src_mask */
 709          0xffff,                /* dst_mask */
 710          false),                /* pcrel_offset */
 711
 712   /* Modifiable call relative.  */
 713   HOWTO (0x17,                  /* type */
 714          0,                     /* rightshift */
 715          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 716          16,                    /* bitsize */
 717          false,                 /* pc_relative */
 718          0,                     /* bitpos */
 719          complain_overflow_bitfield, /* complain_on_overflow */
 720          0,                     /* special_function */
 721          "R_CREL",              /* name */
 722          true,                  /* partial_inplace */
 723          0xffff,                /* src_mask */
 724          0xffff,                /* dst_mask */
 725          false),                /* pcrel_offset */
 726
 727   /* Modifiable branch absolute.  */
 728   HOWTO (0x18,                  /* type */
 729          0,                     /* rightshift */
 730          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 731          16,                    /* bitsize */
 732          false,                 /* pc_relative */
 733          0,                     /* bitpos */
 734          complain_overflow_bitfield, /* complain_on_overflow */
 735          0,                     /* special_function */
 736          "R_RBA",               /* name */
 737          true,                  /* partial_inplace */
 738          0xffff,                /* src_mask */
 739          0xffff,                /* dst_mask */
 740          false),                /* pcrel_offset */
 741
 742   /* Modifiable branch absolute.  */
 743   HOWTO (0x19,                  /* type */
 744          0,                     /* rightshift */
 745          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 746          16,                    /* bitsize */
 747          false,                 /* pc_relative */
 748          0,                     /* bitpos */
 749          complain_overflow_bitfield, /* complain_on_overflow */
 750          0,                     /* special_function */
 751          "R_RBAC",              /* name */
 752          true,                  /* partial_inplace */
 753          0xffff,                /* src_mask */
 754          0xffff,                /* dst_mask */
 755          false),                /* pcrel_offset */
 756
 757   /* Modifiable branch relative.  */
 758   HOWTO (0x1a,                  /* type */
 759          0,                     /* rightshift */
 760          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 761          26,                    /* bitsize */
 762          false,                 /* pc_relative */
 763          0,                     /* bitpos */
 764          complain_overflow_signed, /* complain_on_overflow */
 765          0,                     /* special_function */
 766          "R_RBR",               /* name */
 767          true,                  /* partial_inplace */
 768          0xffff,                /* src_mask */
 769          0xffff,                /* dst_mask */
 770          false),                /* pcrel_offset */
 771
 772   /* Modifiable branch absolute.  */
 773   HOWTO (0x1b,                  /* type */
 774          0,                     /* rightshift */
 775          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 776          16,                    /* bitsize */
 777          false,                 /* pc_relative */
 778          0,                     /* bitpos */
 779          complain_overflow_bitfield, /* complain_on_overflow */
 780          0,                     /* special_function */
 781          "R_RBRC",              /* name */
 782          true,                  /* partial_inplace */
 783          0xffff,                /* src_mask */
 784          0xffff,                /* dst_mask */
 785          false),                /* pcrel_offset */
 786   HOWTO (0,                     /* type */
 787          0,                     /* rightshift */
 788          4,                     /* size (0 = byte, 1 = short, 2 = long) */
 789          64,                    /* bitsize */
 790          false,                 /* pc_relative */
 791          0,                     /* bitpos */
 792          complain_overflow_bitfield, /* complain_on_overflow */
 793          0,                     /* special_function */
 794          "R_POS",               /* name */
 795          true,                  /* partial_inplace */
 796          MINUS_ONE,             /* src_mask */
 797          MINUS_ONE,             /* dst_mask */
 798          false)                 /* pcrel_offset */
 799
 800 };
 801
 802 /* These are the first two like the above but for 16-bit relocs.  */
 803 static reloc_howto_type xcoff_howto_table_16[] =
 804 {
 805   /* Standard 16 bit relocation.  */
 806   HOWTO (0,                     /* type */
 807          0,                     /* rightshift */
 808          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 809          16,                    /* bitsize */
 810          false,                 /* pc_relative */
 811          0,                     /* bitpos */
 812          complain_overflow_bitfield, /* complain_on_overflow */
 813          0,                     /* special_function */
 814          "R_POS_16",            /* name */
 815          true,                  /* partial_inplace */
 816          0xffffffff,            /* src_mask */
 817          0xffffffff,            /* dst_mask */
 818          false),                /* pcrel_offset */
 819
 820   /* 16 bit relocation, but store negative value.  */
 821   HOWTO (1,                     /* type */
 822          0,                     /* rightshift */
 823          -2,                    /* size (0 = byte, 1 = short, 2 = long) */
 824          16,                    /* bitsize */
 825          false,                 /* pc_relative */
 826          0,                     /* bitpos */
 827          complain_overflow_bitfield, /* complain_on_overflow */
 828          0,                     /* special_function */
 829          "R_NEG_16",            /* name */
 830          true,                  /* partial_inplace */
 831          0xffffffff,            /* src_mask */
 832          0xffffffff,            /* dst_mask */
 833          false),                /* pcrel_offset */
 834
 835   /* 16 bit PC relative relocation.  */
 836   HOWTO (2,                     /* type */
 837          0,                     /* rightshift */
 838          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 839          32,                    /* bitsize */
 840          true,                  /* pc_relative */
 841          0,                     /* bitpos */
 842          complain_overflow_signed, /* complain_on_overflow */
 843          0,                     /* special_function */
 844          "R_REL_16",            /* name */
 845          true,                  /* partial_inplace */
 846          0xffffffff,            /* src_mask */
 847          0xffffffff,            /* dst_mask */
 848          false)                /* pcrel_offset */
 849   };
 850
 851 void
 852 _bfd_xcoff_rtype2howto (relent, internal)
 853      arelent *relent;
 854      struct internal_reloc *internal;
 855 {
 856   relent->howto = xcoff_howto_table + internal->r_type;
 857
 858   if (relent->howto->bitsize != ((unsigned int) internal->r_size & 0x1f) + 1
 859       && (internal->r_type
 860           < sizeof(xcoff_howto_table_16)/sizeof(xcoff_howto_table_16[0])))
 861     relent->howto = xcoff_howto_table_16 + internal->r_type;
 862
 863   /* The r_size field of an XCOFF reloc encodes the bitsize of the
 864      relocation, as well as indicating whether it is signed or not.
 865      Doublecheck that the relocation information gathered from the
 866      type matches this information.  */
 867   if (relent->howto->bitsize != ((unsigned int) internal->r_size & 0x1f) + 1)
 868     abort ();
 869 #if 0
 870   if ((internal->r_size & 0x80) != 0
 871       ? (relent->howto->complain_on_overflow != complain_overflow_signed)
 872       : (relent->howto->complain_on_overflow != complain_overflow_bitfield))
 873     abort ();
 874 #endif
 875 }
 876
 877 reloc_howto_type *
 878 _bfd_xcoff_reloc_type_lookup (abfd, code)
 879      bfd *abfd ATTRIBUTE_UNUSED;
 880      bfd_reloc_code_real_type code;
 881 {
 882   switch (code)
 883     {
 884     case BFD_RELOC_PPC_B26:
 885       return &xcoff_howto_table[0xa];
 886     case BFD_RELOC_PPC_BA26:
 887       return &xcoff_howto_table[8];
 888     case BFD_RELOC_PPC_TOC16:
 889       return &xcoff_howto_table[3];
 890     case BFD_RELOC_32:
 891     case BFD_RELOC_CTOR:
 892       return &xcoff_howto_table[0];
 893     case BFD_RELOC_64:
 894       return &xcoff_howto_table[0x1c];
 895     default:
 896       return NULL;
 897     }
 898 }
 899
 900 #define SELECT_RELOC(internal, howto)                                   \
 901   {                                                                     \
 902     internal.r_type = howto->type;                                      \
 903     internal.r_size =                                                   \
 904       ((howto->complain_on_overflow == complain_overflow_signed         \
 905         ? 0x80                                                          \
 906         : 0)                                                            \
 907        | (howto->bitsize - 1));                                         \
 908   }
 909 \f
 910 #define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (3)
 911
 912 #define COFF_LONG_FILENAMES
 913
 914 #define RTYPE2HOWTO(cache_ptr, dst) _bfd_xcoff_rtype2howto (cache_ptr, dst)
 915
 916 #define coff_SWAP_sym_in xcoff_swap_sym_in
 917 #define coff_SWAP_sym_out xcoff_swap_sym_out
 918 #define coff_SWAP_aux_in xcoff_swap_aux_in
 919 #define coff_SWAP_aux_out xcoff_swap_aux_out
 920 #define coff_mkobject _bfd_xcoff_mkobject
 921 #define coff_bfd_copy_private_bfd_data _bfd_xcoff_copy_private_bfd_data
 922 #define coff_bfd_is_local_label_name _bfd_xcoff_is_local_label_name
 923 #define coff_bfd_reloc_type_lookup _bfd_xcoff_reloc_type_lookup
 924 #define coff_relocate_section _bfd_ppc_xcoff_relocate_section
 925
 926 #include "coffcode.h"
 927 \f
 928 /* XCOFF archive support.  The original version of this code was by
 929    Damon A. Permezel.  It was enhanced to permit cross support, and
 930    writing archive files, by Ian Lance Taylor, Cygnus Support.
 931
 932    XCOFF uses its own archive format.  Everything is hooked together
 933    with file offset links, so it is possible to rapidly update an
 934    archive in place.  Of course, we don't do that.  An XCOFF archive
 935    has a real file header, not just an ARMAG string.  The structure of
 936    the file header and of each archive header appear below.
 937
 938    An XCOFF archive also has a member table, which is a list of
 939    elements in the archive (you can get that by looking through the
 940    linked list, but you have to read a lot more of the file).  The
 941    member table has a normal archive header with an empty name.  It is
 942    normally (and perhaps must be) the second to last entry in the
 943    archive.  The member table data is almost printable ASCII.  It
 944    starts with a 12 character decimal string which is the number of
 945    entries in the table.  For each entry it has a 12 character decimal
 946    string which is the offset in the archive of that member.  These
 947    entries are followed by a series of null terminated strings which
 948    are the member names for each entry.
 949
 950    Finally, an XCOFF archive has a global symbol table, which is what
 951    we call the armap.  The global symbol table has a normal archive
 952    header with an empty name.  It is normally (and perhaps must be)
 953    the last entry in the archive.  The contents start with a four byte
 954    binary number which is the number of entries.  This is followed by
 955    a that many four byte binary numbers; each is the file offset of an
 956    entry in the archive.  These numbers are followed by a series of
 957    null terminated strings, which are symbol names.
 958
 959    AIX 4.3 introduced a new archive format which can handle larger
 960    files and also 32- and 64-bit objects in the same archive.  The
 961    things said above remain true except that there is now more than
 962    one global symbol table.  The one is used to index 32-bit objects,
 963    the other for 64-bit objects.
 964
 965    The new archives (recognizable by the new ARMAG string) has larger
 966    field lengths so that we cannot really share any code.  Also we have
 967    to take care that we are not generating the new form of archives
 968    on AIX 4.2 or earlier systems.  */
 969
 970 /* XCOFF archives use this as a magic string.  Note that both strings
 971    have the same length.  */
 972
 973 #define XCOFFARMAG    "<aiaff>\012"
 974 #define XCOFFARMAGBIG "<bigaf>\012"
 975 #define SXCOFFARMAG   8
 976
 977 /* This terminates an XCOFF archive member name.  */
 978
 979 #define XCOFFARFMAG "`\012"
 980 #define SXCOFFARFMAG 2
 981
 982 /* XCOFF archives start with this (printable) structure.  */
 983
 984 struct xcoff_ar_file_hdr
 985 {
 986   /* Magic string.  */
 987   char magic[SXCOFFARMAG];
 988
 989   /* Offset of the member table (decimal ASCII string).  */
 990   char memoff[12];
 991
 992   /* Offset of the global symbol table (decimal ASCII string).  */
 993   char symoff[12];
 994
 995   /* Offset of the first member in the archive (decimal ASCII string).  */
 996   char firstmemoff[12];
 997
 998   /* Offset of the last member in the archive (decimal ASCII string).  */
 999   char lastmemoff[12];
1000
1001   /* Offset of the first member on the free list (decimal ASCII
1002      string).  */
1003   char freeoff[12];
1004 };
1005
1006 #define SIZEOF_AR_FILE_HDR (5 * 12 + SXCOFFARMAG)
1007
1008 /* This is the equivalent data structure for the big archive format.  */
1009
1010 struct xcoff_ar_file_hdr_big
1011 {
1012   /* Magic string.  */
1013   char magic[SXCOFFARMAG];
1014
1015   /* Offset of the member table (decimal ASCII string).  */
1016   char memoff[20];
1017
1018   /* Offset of the global symbol table for 32-bit objects (decimal ASCII
1019      string).  */
1020   char symoff[20];
1021
1022   /* Offset of the global symbol table for 64-bit objects (decimal ASCII
1023      string).  */
1024   char symoff64[20];
1025
1026   /* Offset of the first member in the archive (decimal ASCII string).  */
1027   char firstmemoff[20];
1028
1029   /* Offset of the last member in the archive (decimal ASCII string).  */
1030   char lastmemoff[20];
1031
1032   /* Offset of the first member on the free list (decimal ASCII
1033      string).  */
1034   char freeoff[20];
1035 };
1036
1037 #define SIZEOF_AR_FILE_HDR_BIG (6 * 20 + SXCOFFARMAG)
1038
1039
1040 /* Each XCOFF archive member starts with this (printable) structure.  */
1041
1042 struct xcoff_ar_hdr
1043 {
1044   /* File size not including the header (decimal ASCII string).  */
1045   char size[12];
1046
1047   /* File offset of next archive member (decimal ASCII string).  */
1048   char nextoff[12];
1049
1050   /* File offset of previous archive member (decimal ASCII string).  */
1051   char prevoff[12];
1052
1053   /* File mtime (decimal ASCII string).  */
1054   char date[12];
1055
1056   /* File UID (decimal ASCII string).  */
1057   char uid[12];
1058
1059   /* File GID (decimal ASCII string).  */
1060   char gid[12];
1061
1062   /* File mode (octal ASCII string).  */
1063   char mode[12];
1064
1065   /* Length of file name (decimal ASCII string).  */
1066   char namlen[4];
1067
1068   /* This structure is followed by the file name.  The length of the
1069      name is given in the namlen field.  If the length of the name is
1070      odd, the name is followed by a null byte.  The name and optional
1071      null byte are followed by XCOFFARFMAG, which is not included in
1072      namlen.  The contents of the archive member follow; the number of
1073      bytes is given in the size field.  */
1074 };
1075
1076 #define SIZEOF_AR_HDR (7 * 12 + 4)
1077
1078 /* The equivalent for the big archive format.  */
1079
1080 struct xcoff_ar_hdr_big
1081 {
1082   /* File size not including the header (decimal ASCII string).  */
1083   char size[20];
1084
1085   /* File offset of next archive member (decimal ASCII string).  */
1086   char nextoff[20];
1087
1088   /* File offset of previous archive member (decimal ASCII string).  */
1089   char prevoff[20];
1090
1091   /* File mtime (decimal ASCII string).  */
1092   char date[12];
1093
1094   /* File UID (decimal ASCII string).  */
1095   char uid[12];
1096
1097   /* File GID (decimal ASCII string).  */
1098   char gid[12];
1099
1100   /* File mode (octal ASCII string).  */
1101   char mode[12];
1102
1103   /* Length of file name (decimal ASCII string).  */
1104   char namlen[4];
1105
1106   /* This structure is followed by the file name.  The length of the
1107      name is given in the namlen field.  If the length of the name is
1108      odd, the name is followed by a null byte.  The name and optional
1109      null byte are followed by XCOFFARFMAG, which is not included in
1110      namlen.  The contents of the archive member follow; the number of
1111      bytes is given in the size field.  */
1112 };
1113
1114 #define SIZEOF_AR_HDR_BIG (3 * 20 + 4 * 12 + 4)
1115
1116
1117 /* We often have to distinguish between the old and big file format.
1118    Make it a bit cleaner.  We can use `xcoff_ardata' here because the
1119    `hdr' member has the same size and position in both formats.  */
1120 #define xcoff_big_format_p(abfd) \
1121   (xcoff_ardata (abfd)->magic[1] == 'b')
1122
1123 /* We store a copy of the xcoff_ar_file_hdr in the tdata field of the
1124    artdata structure.  Similar for the big archive.  */
1125 #define xcoff_ardata(abfd) \
1126   ((struct xcoff_ar_file_hdr *) bfd_ardata (abfd)->tdata)
1127 #define xcoff_ardata_big(abfd) \
1128   ((struct xcoff_ar_file_hdr_big *) bfd_ardata (abfd)->tdata)
1129
1130 /* We store a copy of the xcoff_ar_hdr in the arelt_data field of an
1131    archive element.  Similar for the big archive.  */
1132 #define arch_eltdata(bfd) ((struct areltdata *) ((bfd)->arelt_data))
1133 #define arch_xhdr(bfd) \
1134   ((struct xcoff_ar_hdr *) arch_eltdata (bfd)->arch_header)
1135 #define arch_xhdr_big(bfd) \
1136   ((struct xcoff_ar_hdr_big *) arch_eltdata (bfd)->arch_header)
1137
1138 /* XCOFF archives do not have anything which corresponds to an
1139    extended name table.  */
1140
1141 #define _bfd_xcoff_slurp_extended_name_table bfd_false
1142 #define _bfd_xcoff_construct_extended_name_table \
1143   ((boolean (*) PARAMS ((bfd *, char **, bfd_size_type *, const char **))) \
1144    bfd_false)
1145 #define _bfd_xcoff_truncate_arname bfd_dont_truncate_arname
1146
1147 /* We can use the standard get_elt_at_index routine.  */
1148
1149 #define _bfd_xcoff_get_elt_at_index _bfd_generic_get_elt_at_index
1150
1151 /* XCOFF archives do not have a timestamp.  */
1152
1153 #define _bfd_xcoff_update_armap_timestamp bfd_true
1154
1155 /* Read in the armap of an XCOFF archive.  */
1156
1157 boolean
1158 _bfd_xcoff_slurp_armap (abfd)
1159      bfd *abfd;
1160 {
1161   file_ptr off;
1162   size_t namlen;
1163   bfd_size_type sz;
1164   bfd_byte *contents, *cend;
1165   unsigned int c, i;
1166   carsym *arsym;
1167   bfd_byte *p;
1168
1169   if (xcoff_ardata (abfd) == NULL)
1170     {
1171       bfd_has_map (abfd) = false;
1172       return true;
1173     }
1174
1175   if (! xcoff_big_format_p (abfd))
1176     {
1177       /* This is for the old format.  */
1178       struct xcoff_ar_hdr hdr;
1179
1180       off = strtol (xcoff_ardata (abfd)->symoff, (char **) NULL, 10);
1181       if (off == 0)
1182         {
1183           bfd_has_map (abfd) = false;
1184           return true;
1185         }
1186
1187       if (bfd_seek (abfd, off, SEEK_SET) != 0)
1188         return false;
1189
1190       /* The symbol table starts with a normal archive header.  */
1191       if (bfd_read ((PTR) &hdr, SIZEOF_AR_HDR, 1, abfd) != SIZEOF_AR_HDR)
1192         return false;
1193
1194       /* Skip the name (normally empty).  */
1195       namlen = strtol (hdr.namlen, (char **) NULL, 10);
1196       if (bfd_seek (abfd, ((namlen + 1) & ~1) + SXCOFFARFMAG, SEEK_CUR) != 0)
1197         return false;
1198
1199       sz = strtol (hdr.size, (char **) NULL, 10);
1200     }
1201   else
1202     {
1203       /* This is for the new format.  */
1204       struct xcoff_ar_hdr_big hdr;
1205
1206       off = strtol (xcoff_ardata_big (abfd)->symoff, (char **) NULL, 10);
1207       if (off == 0)
1208         {
1209           bfd_has_map (abfd) = false;
1210           return true;
1211         }
1212
1213       if (bfd_seek (abfd, off, SEEK_SET) != 0)
1214         return false;
1215
1216       /* The symbol table starts with a normal archive header.  */
1217       if (bfd_read ((PTR) &hdr, SIZEOF_AR_HDR_BIG, 1, abfd)
1218           != SIZEOF_AR_HDR_BIG)
1219         return false;
1220
1221       /* Skip the name (normally empty).  */
1222       namlen = strtol (hdr.namlen, (char **) NULL, 10);
1223       if (bfd_seek (abfd, ((namlen + 1) & ~1) + SXCOFFARFMAG, SEEK_CUR) != 0)
1224         return false;
1225
1226       /* XXX This actually has to be a call to strtoll (at least on 32-bit
1227          machines) since the field width is 20 and there numbers with more
1228          than 32 bits can be represented.  */
1229       sz = strtol (hdr.size, (char **) NULL, 10);
1230     }
1231
1232   /* Read in the entire symbol table.  */
1233   contents = (bfd_byte *) bfd_alloc (abfd, sz);
1234   if (contents == NULL)
1235     return false;
1236   if (bfd_read ((PTR) contents, 1, sz, abfd) != sz)
1237     return false;
1238
1239   /* The symbol table starts with a four byte count.  */
1240   c = bfd_h_get_32 (abfd, contents);
1241
1242   if (c * 4 >= sz)
1243     {
1244       bfd_set_error (bfd_error_bad_value);
1245       return false;
1246     }
1247
1248   bfd_ardata (abfd)->symdefs = ((carsym *)
1249                                 bfd_alloc (abfd, c * sizeof (carsym)));
1250   if (bfd_ardata (abfd)->symdefs == NULL)
1251     return false;
1252
1253   /* After the count comes a list of four byte file offsets.  */
1254   for (i = 0, arsym = bfd_ardata (abfd)->symdefs, p = contents + 4;
1255        i < c;
1256        ++i, ++arsym, p += 4)
1257     arsym->file_offset = bfd_h_get_32 (abfd, p);
1258
1259   /* After the file offsets come null terminated symbol names.  */
1260   cend = contents + sz;
1261   for (i = 0, arsym = bfd_ardata (abfd)->symdefs;
1262        i < c;
1263        ++i, ++arsym, p += strlen ((char *) p) + 1)
1264     {
1265       if (p >= cend)
1266         {
1267           bfd_set_error (bfd_error_bad_value);
1268           return false;
1269         }
1270       arsym->name = (char *) p;
1271     }
1272
1273   bfd_ardata (abfd)->symdef_count = c;
1274   bfd_has_map (abfd) = true;
1275
1276   return true;
1277 }
1278
1279 /* See if this is an XCOFF archive.  */
1280
1281 const bfd_target *
1282 _bfd_xcoff_archive_p (abfd)
1283      bfd *abfd;
1284 {
1285   char magic[SXCOFFARMAG];
1286
1287   if (bfd_read ((PTR) magic, SXCOFFARMAG, 1, abfd) != SXCOFFARMAG)
1288     {
1289       if (bfd_get_error () != bfd_error_system_call)
1290         bfd_set_error (bfd_error_wrong_format);
1291       return NULL;
1292     }
1293
1294   if (strncmp (magic, XCOFFARMAG, SXCOFFARMAG) != 0
1295       && strncmp (magic, XCOFFARMAGBIG, SXCOFFARMAG) != 0)
1296     {
1297       bfd_set_error (bfd_error_wrong_format);
1298       return NULL;
1299     }
1300
1301   /* We are setting bfd_ardata(abfd) here, but since bfd_ardata
1302      involves a cast, we can't do it as the left operand of
1303      assignment.  */
1304   abfd->tdata.aout_ar_data =
1305     (struct artdata *) bfd_zalloc (abfd, sizeof (struct artdata));
1306
1307   if (bfd_ardata (abfd) == (struct artdata *) NULL)
1308     return NULL;
1309
1310   bfd_ardata (abfd)->cache = NULL;
1311   bfd_ardata (abfd)->archive_head = NULL;
1312   bfd_ardata (abfd)->symdefs = NULL;
1313   bfd_ardata (abfd)->extended_names = NULL;
1314
1315   /* Now handle the two formats.  */
1316   if (magic[1] != 'b')
1317     {
1318       /* This is the old format.  */
1319       struct xcoff_ar_file_hdr hdr;
1320
1321       /* Copy over the magic string.  */
1322       memcpy (hdr.magic, magic, SXCOFFARMAG);
1323
1324       /* Now read the rest of the file header.  */
1325       if (bfd_read ((PTR) &hdr.memoff, SIZEOF_AR_FILE_HDR - SXCOFFARMAG, 1,
1326                     abfd) != SIZEOF_AR_FILE_HDR - SXCOFFARMAG)
1327         {
1328           if (bfd_get_error () != bfd_error_system_call)
1329             bfd_set_error (bfd_error_wrong_format);
1330           return NULL;
1331         }
1332
1333       bfd_ardata (abfd)->first_file_filepos = strtol (hdr.firstmemoff,
1334                                                       (char **) NULL, 10);
1335
1336       bfd_ardata (abfd)->tdata = bfd_zalloc (abfd, SIZEOF_AR_FILE_HDR);
1337       if (bfd_ardata (abfd)->tdata == NULL)
1338         return NULL;
1339
1340       memcpy (bfd_ardata (abfd)->tdata, &hdr, SIZEOF_AR_FILE_HDR);
1341     }
1342   else
1343     {
1344       /* This is the new format.  */
1345       struct xcoff_ar_file_hdr_big hdr;
1346
1347       /* Copy over the magic string.  */
1348       memcpy (hdr.magic, magic, SXCOFFARMAG);
1349
1350       /* Now read the rest of the file header.  */
1351       if (bfd_read ((PTR) &hdr.memoff, SIZEOF_AR_FILE_HDR_BIG - SXCOFFARMAG, 1,
1352                     abfd) != SIZEOF_AR_FILE_HDR_BIG - SXCOFFARMAG)
1353         {
1354           if (bfd_get_error () != bfd_error_system_call)
1355             bfd_set_error (bfd_error_wrong_format);
1356           return NULL;
1357         }
1358
1359       /* XXX This actually has to be a call to strtoll (at least on 32-bit
1360          machines) since the field width is 20 and there numbers with more
1361          than 32 bits can be represented.  */
1362       bfd_ardata (abfd)->first_file_filepos = strtol (hdr.firstmemoff,
1363                                                       (char **) NULL, 10);
1364
1365       bfd_ardata (abfd)->tdata = bfd_zalloc (abfd, SIZEOF_AR_FILE_HDR_BIG);
1366       if (bfd_ardata (abfd)->tdata == NULL)
1367         return NULL;
1368
1369       memcpy (bfd_ardata (abfd)->tdata, &hdr, SIZEOF_AR_FILE_HDR_BIG);
1370     }
1371
1372   if (! _bfd_xcoff_slurp_armap (abfd))
1373     {
1374       bfd_release (abfd, bfd_ardata (abfd));
1375       abfd->tdata.aout_ar_data = (struct artdata *) NULL;
1376       return NULL;
1377     }
1378
1379   return abfd->xvec;
1380 }
1381
1382 /* Read the archive header in an XCOFF archive.  */
1383
1384 PTR
1385 _bfd_xcoff_read_ar_hdr (abfd)
1386      bfd *abfd;
1387 {
1388   size_t namlen;
1389   struct areltdata *ret;
1390
1391   ret = (struct areltdata *) bfd_alloc (abfd, sizeof (struct areltdata));
1392   if (ret == NULL)
1393     return NULL;
1394
1395   if (! xcoff_big_format_p (abfd))
1396     {
1397       struct xcoff_ar_hdr hdr;
1398       struct xcoff_ar_hdr *hdrp;
1399
1400       if (bfd_read ((PTR) &hdr, SIZEOF_AR_HDR, 1, abfd) != SIZEOF_AR_HDR)
1401         {
1402           free (ret);
1403           return NULL;
1404         }
1405
1406       namlen = strtol (hdr.namlen, (char **) NULL, 10);
1407       hdrp = (struct xcoff_ar_hdr *) bfd_alloc (abfd,
1408                                                 SIZEOF_AR_HDR + namlen + 1);
1409       if (hdrp == NULL)
1410         {
1411           free (ret);
1412           return NULL;
1413         }
1414       memcpy (hdrp, &hdr, SIZEOF_AR_HDR);
1415       if (bfd_read ((char *) hdrp + SIZEOF_AR_HDR, 1, namlen, abfd) != namlen)
1416         {
1417           free (ret);
1418           return NULL;
1419         }
1420       ((char *) hdrp)[SIZEOF_AR_HDR + namlen] = '\0';
1421
1422       ret->arch_header = (char *) hdrp;
1423       ret->parsed_size = strtol (hdr.size, (char **) NULL, 10);
1424       ret->filename = (char *) hdrp + SIZEOF_AR_HDR;
1425     }
1426   else
1427     {
1428       struct xcoff_ar_hdr_big hdr;
1429       struct xcoff_ar_hdr_big *hdrp;
1430
1431       if (bfd_read ((PTR) &hdr, SIZEOF_AR_HDR_BIG, 1, abfd)
1432           != SIZEOF_AR_HDR_BIG)
1433         {
1434           free (ret);
1435           return NULL;
1436         }
1437
1438       namlen = strtol (hdr.namlen, (char **) NULL, 10);
1439       hdrp = (struct xcoff_ar_hdr_big *) bfd_alloc (abfd,
1440                                                     SIZEOF_AR_HDR_BIG
1441                                                     + namlen + 1);
1442       if (hdrp == NULL)
1443         {
1444           free (ret);
1445           return NULL;
1446         }
1447       memcpy (hdrp, &hdr, SIZEOF_AR_HDR_BIG);
1448       if (bfd_read ((char *) hdrp + SIZEOF_AR_HDR_BIG, 1, namlen, abfd) != namlen)
1449         {
1450           free (ret);
1451           return NULL;
1452         }
1453       ((char *) hdrp)[SIZEOF_AR_HDR_BIG + namlen] = '\0';
1454
1455       ret->arch_header = (char *) hdrp;
1456       /* XXX This actually has to be a call to strtoll (at least on 32-bit
1457          machines) since the field width is 20 and there numbers with more
1458          than 32 bits can be represented.  */
1459       ret->parsed_size = strtol (hdr.size, (char **) NULL, 10);
1460       ret->filename = (char *) hdrp + SIZEOF_AR_HDR_BIG;
1461     }
1462
1463   /* Skip over the XCOFFARFMAG at the end of the file name.  */
1464   if (bfd_seek (abfd, (namlen & 1) + SXCOFFARFMAG, SEEK_CUR) != 0)
1465     return NULL;
1466
1467   return (PTR) ret;
1468 }
1469
1470 /* Open the next element in an XCOFF archive.  */
1471
1472 bfd *
1473 _bfd_xcoff_openr_next_archived_file (archive, last_file)
1474      bfd *archive;
1475      bfd *last_file;
1476 {
1477   file_ptr filestart;
1478
1479   if (xcoff_ardata (archive) == NULL)
1480     {
1481       bfd_set_error (bfd_error_invalid_operation);
1482       return NULL;
1483     }
1484
1485   if (! xcoff_big_format_p (archive))
1486     {
1487       if (last_file == NULL)
1488         filestart = bfd_ardata (archive)->first_file_filepos;
1489       else
1490         filestart = strtol (arch_xhdr (last_file)->nextoff, (char **) NULL,
1491                             10);
1492
1493       if (filestart == 0
1494           || filestart == strtol (xcoff_ardata (archive)->memoff,
1495                                   (char **) NULL, 10)
1496           || filestart == strtol (xcoff_ardata (archive)->symoff,
1497                                   (char **) NULL, 10))
1498         {
1499           bfd_set_error (bfd_error_no_more_archived_files);
1500           return NULL;
1501         }
1502     }
1503   else
1504     {
1505       if (last_file == NULL)
1506         filestart = bfd_ardata (archive)->first_file_filepos;
1507       else
1508         /* XXX These actually have to be a calls to strtoll (at least
1509            on 32-bit machines) since the fields's width is 20 and
1510            there numbers with more than 32 bits can be represented.  */
1511         filestart = strtol (arch_xhdr_big (last_file)->nextoff, (char **) NULL,
1512                             10);
1513
1514       /* XXX These actually have to be calls to strtoll (at least on 32-bit
1515          machines) since the fields's width is 20 and there numbers with more
1516          than 32 bits can be represented.  */
1517       if (filestart == 0
1518           || filestart == strtol (xcoff_ardata_big (archive)->memoff,
1519                                   (char **) NULL, 10)
1520           || filestart == strtol (xcoff_ardata_big (archive)->symoff,
1521                                   (char **) NULL, 10))
1522         {
1523           bfd_set_error (bfd_error_no_more_archived_files);
1524           return NULL;
1525         }
1526     }
1527
1528   return _bfd_get_elt_at_filepos (archive, filestart);
1529 }
1530
1531 /* Stat an element in an XCOFF archive.  */
1532
1533 int
1534 _bfd_xcoff_generic_stat_arch_elt (abfd, s)
1535      bfd *abfd;
1536      struct stat *s;
1537 {
1538   if (abfd->arelt_data == NULL)
1539     {
1540       bfd_set_error (bfd_error_invalid_operation);
1541       return -1;
1542     }
1543
1544   if (! xcoff_big_format_p (abfd))
1545     {
1546       struct xcoff_ar_hdr *hdrp = arch_xhdr (abfd);
1547
1548       s->st_mtime = strtol (hdrp->date, (char **) NULL, 10);
1549       s->st_uid = strtol (hdrp->uid, (char **) NULL, 10);
1550       s->st_gid = strtol (hdrp->gid, (char **) NULL, 10);
1551       s->st_mode = strtol (hdrp->mode, (char **) NULL, 8);
1552       s->st_size = arch_eltdata (abfd)->parsed_size;
1553     }
1554   else
1555     {
1556       struct xcoff_ar_hdr_big *hdrp = arch_xhdr_big (abfd);
1557
1558       s->st_mtime = strtol (hdrp->date, (char **) NULL, 10);
1559       s->st_uid = strtol (hdrp->uid, (char **) NULL, 10);
1560       s->st_gid = strtol (hdrp->gid, (char **) NULL, 10);
1561       s->st_mode = strtol (hdrp->mode, (char **) NULL, 8);
1562       s->st_size = arch_eltdata (abfd)->parsed_size;
1563     }
1564
1565   return 0;
1566 }
1567
1568 /* Normalize a file name for inclusion in an archive.  */
1569
1570 static const char *
1571 normalize_filename (abfd)
1572      bfd *abfd;
1573 {
1574   const char *file;
1575   const char *filename;
1576
1577   file = bfd_get_filename (abfd);
1578   filename = strrchr (file, '/');
1579   if (filename != NULL)
1580     filename++;
1581   else
1582     filename = file;
1583   return filename;
1584 }
1585
1586 /* Write out an XCOFF armap.  */
1587
1588 /*ARGSUSED*/
1589 static boolean
1590 xcoff_write_armap_old (abfd, elength, map, orl_count, stridx)
1591      bfd *abfd;
1592      unsigned int elength ATTRIBUTE_UNUSED;
1593      struct orl *map;
1594      unsigned int orl_count;
1595      int stridx;
1596 {
1597   struct xcoff_ar_hdr hdr;
1598   char *p;
1599   unsigned char buf[4];
1600   bfd *sub;
1601   file_ptr fileoff;
1602   unsigned int i;
1603
1604   memset (&hdr, 0, sizeof hdr);
1605   sprintf (hdr.size, "%ld", (long) (4 + orl_count * 4 + stridx));
1606   sprintf (hdr.nextoff, "%d", 0);
1607   memcpy (hdr.prevoff, xcoff_ardata (abfd)->memoff, 12);
1608   sprintf (hdr.date, "%d", 0);
1609   sprintf (hdr.uid, "%d", 0);
1610   sprintf (hdr.gid, "%d", 0);
1611   sprintf (hdr.mode, "%d", 0);
1612   sprintf (hdr.namlen, "%d", 0);
1613
1614   /* We need spaces, not null bytes, in the header.  */
1615   for (p = (char *) &hdr; p < (char *) &hdr + SIZEOF_AR_HDR; p++)
1616     if (*p == '\0')
1617       *p = ' ';
1618
1619   if (bfd_write ((PTR) &hdr, SIZEOF_AR_HDR, 1, abfd) != SIZEOF_AR_HDR
1620       || bfd_write (XCOFFARFMAG, 1, SXCOFFARFMAG, abfd) != SXCOFFARFMAG)
1621     return false;
1622
1623   bfd_h_put_32 (abfd, orl_count, buf);
1624   if (bfd_write (buf, 1, 4, abfd) != 4)
1625     return false;
1626
1627   sub = abfd->archive_head;
1628   fileoff = SIZEOF_AR_FILE_HDR;
1629   i = 0;
1630   while (sub != NULL && i < orl_count)
1631     {
1632       size_t namlen;
1633
1634       while (((bfd *) (map[i]).pos) == sub)
1635         {
1636           bfd_h_put_32 (abfd, fileoff, buf);
1637           if (bfd_write (buf, 1, 4, abfd) != 4)
1638             return false;
1639           ++i;
1640         }
1641       namlen = strlen (normalize_filename (sub));
1642       namlen = (namlen + 1) &~ 1;
1643       fileoff += (SIZEOF_AR_HDR
1644                   + namlen
1645                   + SXCOFFARFMAG
1646                   + arelt_size (sub));
1647       fileoff = (fileoff + 1) &~ 1;
1648       sub = sub->next;
1649     }
1650
1651   for (i = 0; i < orl_count; i++)
1652     {
1653       const char *name;
1654       size_t namlen;
1655
1656       name = *map[i].name;
1657       namlen = strlen (name);
1658       if (bfd_write (name, 1, namlen + 1, abfd) != namlen + 1)
1659         return false;
1660     }
1661
1662   if ((stridx & 1) != 0)
1663     {
1664       char b;
1665
1666       b = '\0';
1667       if (bfd_write (&b, 1, 1, abfd) != 1)
1668         return false;
1669     }
1670
1671   return true;
1672 }
1673
1674 /*ARGSUSED*/
1675 static boolean
1676 xcoff_write_armap_big (abfd, elength, map, orl_count, stridx)
1677      bfd *abfd;
1678      unsigned int elength ATTRIBUTE_UNUSED;
1679      struct orl *map;
1680      unsigned int orl_count;
1681      int stridx;
1682 {
1683   struct xcoff_ar_hdr_big hdr;
1684   char *p;
1685   unsigned char buf[4];
1686   bfd *sub;
1687   file_ptr fileoff;
1688   unsigned int i;
1689
1690   memset (&hdr, 0, sizeof hdr);
1691   /* XXX This call actually should use %lld (at least on 32-bit
1692      machines) since the fields's width is 20 and there numbers with
1693      more than 32 bits can be represented.  */
1694   sprintf (hdr.size, "%ld", (long) (4 + orl_count * 4 + stridx));
1695   sprintf (hdr.nextoff, "%d", 0);
1696   memcpy (hdr.prevoff, xcoff_ardata (abfd)->memoff, 12);
1697   sprintf (hdr.date, "%d", 0);
1698   sprintf (hdr.uid, "%d", 0);
1699   sprintf (hdr.gid, "%d", 0);
1700   sprintf (hdr.mode, "%d", 0);
1701   sprintf (hdr.namlen, "%d", 0);
1702
1703   /* We need spaces, not null bytes, in the header.  */
1704   for (p = (char *) &hdr; p < (char *) &hdr + SIZEOF_AR_HDR_BIG; p++)
1705     if (*p == '\0')
1706       *p = ' ';
1707
1708   if (bfd_write ((PTR) &hdr, SIZEOF_AR_HDR_BIG, 1, abfd) != SIZEOF_AR_HDR_BIG
1709       || bfd_write (XCOFFARFMAG, 1, SXCOFFARFMAG, abfd) != SXCOFFARFMAG)
1710     return false;
1711
1712   bfd_h_put_32 (abfd, orl_count, buf);
1713   if (bfd_write (buf, 1, 4, abfd) != 4)
1714     return false;
1715
1716   sub = abfd->archive_head;
1717   fileoff = SIZEOF_AR_FILE_HDR_BIG;
1718   i = 0;
1719   while (sub != NULL && i < orl_count)
1720     {
1721       size_t namlen;
1722
1723       while (((bfd *) (map[i]).pos) == sub)
1724         {
1725           bfd_h_put_32 (abfd, fileoff, buf);
1726           if (bfd_write (buf, 1, 4, abfd) != 4)
1727             return false;
1728           ++i;
1729         }
1730       namlen = strlen (normalize_filename (sub));
1731       namlen = (namlen + 1) &~ 1;
1732       fileoff += (SIZEOF_AR_HDR_BIG
1733                   + namlen
1734                   + SXCOFFARFMAG
1735                   + arelt_size (sub));
1736       fileoff = (fileoff + 1) &~ 1;
1737       sub = sub->next;
1738     }
1739
1740   for (i = 0; i < orl_count; i++)
1741     {
1742       const char *name;
1743       size_t namlen;
1744
1745       name = *map[i].name;
1746       namlen = strlen (name);
1747       if (bfd_write (name, 1, namlen + 1, abfd) != namlen + 1)
1748         return false;
1749     }
1750
1751   if ((stridx & 1) != 0)
1752     {
1753       char b;
1754
1755       b = '\0';
1756       if (bfd_write (&b, 1, 1, abfd) != 1)
1757         return false;
1758     }
1759
1760   return true;
1761 }
1762
1763 /*ARGSUSED*/
1764 boolean
1765 _bfd_xcoff_write_armap (abfd, elength, map, orl_count, stridx)
1766      bfd *abfd;
1767      unsigned int elength ATTRIBUTE_UNUSED;
1768      struct orl *map;
1769      unsigned int orl_count;
1770      int stridx;
1771 {
1772   if (! xcoff_big_format_p (abfd))
1773     return xcoff_write_armap_old (abfd, elength, map, orl_count, stridx);
1774   else
1775     return xcoff_write_armap_big (abfd, elength, map, orl_count, stridx);
1776 }
1777
1778 /* Write out an XCOFF archive.  We always write an entire archive,
1779    rather than fussing with the freelist and so forth.  */
1780
1781 static boolean
1782 xcoff_write_archive_contents_old (abfd)
1783      bfd *abfd;
1784 {
1785   struct xcoff_ar_file_hdr fhdr;
1786   size_t count;
1787   size_t total_namlen;
1788   file_ptr *offsets;
1789   boolean makemap;
1790   boolean hasobjects;
1791   file_ptr prevoff, nextoff;
1792   bfd *sub;
1793   unsigned int i;
1794   struct xcoff_ar_hdr ahdr;
1795   bfd_size_type size;
1796   char *p;
1797   char decbuf[13];
1798
1799   memset (&fhdr, 0, sizeof fhdr);
1800   strncpy (fhdr.magic, XCOFFARMAG, SXCOFFARMAG);
1801   sprintf (fhdr.firstmemoff, "%d", SIZEOF_AR_FILE_HDR);
1802   sprintf (fhdr.freeoff, "%d", 0);
1803
1804   count = 0;
1805   total_namlen = 0;
1806   for (sub = abfd->archive_head; sub != NULL; sub = sub->next)
1807     {
1808       ++count;
1809       total_namlen += strlen (normalize_filename (sub)) + 1;
1810     }
1811   offsets = (file_ptr *) bfd_alloc (abfd, count * sizeof (file_ptr));
1812   if (offsets == NULL)
1813     return false;
1814
1815   if (bfd_seek (abfd, SIZEOF_AR_FILE_HDR, SEEK_SET) != 0)
1816     return false;
1817
1818   makemap = bfd_has_map (abfd);
1819   hasobjects = false;
1820   prevoff = 0;
1821   nextoff = SIZEOF_AR_FILE_HDR;
1822   for (sub = abfd->archive_head, i = 0; sub != NULL; sub = sub->next, i++)
1823     {
1824       const char *name;
1825       size_t namlen;
1826       struct xcoff_ar_hdr *ahdrp;
1827       bfd_size_type remaining;
1828
1829       if (makemap && ! hasobjects)
1830         {
1831           if (bfd_check_format (sub, bfd_object))
1832             hasobjects = true;
1833         }
1834
1835       name = normalize_filename (sub);
1836       namlen = strlen (name);
1837
1838       if (sub->arelt_data != NULL)
1839         ahdrp = arch_xhdr (sub);
1840       else
1841         ahdrp = NULL;
1842
1843       if (ahdrp == NULL)
1844         {
1845           struct stat s;
1846
1847           memset (&ahdr, 0, sizeof ahdr);
1848           ahdrp = &ahdr;
1849           if (stat (bfd_get_filename (sub), &s) != 0)
1850             {
1851               bfd_set_error (bfd_error_system_call);
1852               return false;
1853             }
1854
1855           sprintf (ahdrp->size, "%ld", (long) s.st_size);
1856           sprintf (ahdrp->date, "%ld", (long) s.st_mtime);
1857           sprintf (ahdrp->uid, "%ld", (long) s.st_uid);
1858           sprintf (ahdrp->gid, "%ld", (long) s.st_gid);
1859           sprintf (ahdrp->mode, "%o", (unsigned int) s.st_mode);
1860
1861           if (sub->arelt_data == NULL)
1862             {
1863               sub->arelt_data = bfd_alloc (sub, sizeof (struct areltdata));
1864               if (sub->arelt_data == NULL)
1865                 return false;
1866             }
1867
1868           arch_eltdata (sub)->parsed_size = s.st_size;
1869         }
1870
1871       sprintf (ahdrp->prevoff, "%ld", (long) prevoff);
1872       sprintf (ahdrp->namlen, "%ld", (long) namlen);
1873
1874       /* If the length of the name is odd, we write out the null byte
1875          after the name as well.  */
1876       namlen = (namlen + 1) &~ 1;
1877
1878       remaining = arelt_size (sub);
1879       size = (SIZEOF_AR_HDR
1880               + namlen
1881               + SXCOFFARFMAG
1882               + remaining);
1883
1884       BFD_ASSERT (nextoff == bfd_tell (abfd));
1885
1886       offsets[i] = nextoff;
1887
1888       prevoff = nextoff;
1889       nextoff += size + (size & 1);
1890
1891       sprintf (ahdrp->nextoff, "%ld", (long) nextoff);
1892
1893       /* We need spaces, not null bytes, in the header.  */
1894       for (p = (char *) ahdrp; p < (char *) ahdrp + SIZEOF_AR_HDR; p++)
1895         if (*p == '\0')
1896           *p = ' ';
1897
1898       if (bfd_write ((PTR) ahdrp, 1, SIZEOF_AR_HDR, abfd) != SIZEOF_AR_HDR
1899           || bfd_write ((PTR) name, 1, namlen, abfd) != namlen
1900           || (bfd_write ((PTR) XCOFFARFMAG, 1, SXCOFFARFMAG, abfd)
1901               != SXCOFFARFMAG))
1902         return false;
1903
1904       if (bfd_seek (sub, (file_ptr) 0, SEEK_SET) != 0)
1905         return false;
1906       while (remaining != 0)
1907         {
1908           bfd_size_type amt;
1909           bfd_byte buffer[DEFAULT_BUFFERSIZE];
1910
1911           amt = sizeof buffer;
1912           if (amt > remaining)
1913             amt = remaining;
1914           if (bfd_read (buffer, 1, amt, sub) != amt
1915               || bfd_write (buffer, 1, amt, abfd) != amt)
1916             return false;
1917           remaining -= amt;
1918         }
1919
1920       if ((size & 1) != 0)
1921         {
1922           bfd_byte b;
1923
1924           b = '\0';
1925           if (bfd_write (&b, 1, 1, abfd) != 1)
1926             return false;
1927         }
1928     }
1929
1930   sprintf (fhdr.lastmemoff, "%ld", (long) prevoff);
1931
1932   /* Write out the member table.  */
1933
1934   BFD_ASSERT (nextoff == bfd_tell (abfd));
1935   sprintf (fhdr.memoff, "%ld", (long) nextoff);
1936
1937   memset (&ahdr, 0, sizeof ahdr);
1938   sprintf (ahdr.size, "%ld", (long) (12 + count * 12 + total_namlen));
1939   sprintf (ahdr.prevoff, "%ld", (long) prevoff);
1940   sprintf (ahdr.date, "%d", 0);
1941   sprintf (ahdr.uid, "%d", 0);
1942   sprintf (ahdr.gid, "%d", 0);
1943   sprintf (ahdr.mode, "%d", 0);
1944   sprintf (ahdr.namlen, "%d", 0);
1945
1946   size = (SIZEOF_AR_HDR
1947           + 12
1948           + count * 12
1949           + total_namlen
1950           + SXCOFFARFMAG);
1951
1952   prevoff = nextoff;
1953   nextoff += size + (size & 1);
1954
1955   if (makemap && hasobjects)
1956     sprintf (ahdr.nextoff, "%ld", (long) nextoff);
1957   else
1958     sprintf (ahdr.nextoff, "%d", 0);
1959
1960   /* We need spaces, not null bytes, in the header.  */
1961   for (p = (char *) &ahdr; p < (char *) &ahdr + SIZEOF_AR_HDR; p++)
1962     if (*p == '\0')
1963       *p = ' ';
1964
1965   if (bfd_write ((PTR) &ahdr, 1, SIZEOF_AR_HDR, abfd) != SIZEOF_AR_HDR
1966       || (bfd_write ((PTR) XCOFFARFMAG, 1, SXCOFFARFMAG, abfd)
1967           != SXCOFFARFMAG))
1968     return false;
1969
1970   sprintf (decbuf, "%-12ld", (long) count);
1971   if (bfd_write ((PTR) decbuf, 1, 12, abfd) != 12)
1972     return false;
1973   for (i = 0; i < count; i++)
1974     {
1975       sprintf (decbuf, "%-12ld", (long) offsets[i]);
1976       if (bfd_write ((PTR) decbuf, 1, 12, abfd) != 12)
1977         return false;
1978     }
1979   for (sub = abfd->archive_head; sub != NULL; sub = sub->next)
1980     {
1981       const char *name;
1982       size_t namlen;
1983
1984       name = normalize_filename (sub);
1985       namlen = strlen (name);
1986       if (bfd_write ((PTR) name, 1, namlen + 1, abfd) != namlen + 1)
1987         return false;
1988     }
1989   if ((size & 1) != 0)
1990     {
1991       bfd_byte b;
1992
1993       b = '\0';
1994       if (bfd_write ((PTR) &b, 1, 1, abfd) != 1)
1995         return false;
1996     }
1997
1998   /* Write out the armap, if appropriate.  */
1999
2000   if (! makemap || ! hasobjects)
2001     sprintf (fhdr.symoff, "%d", 0);
2002   else
2003     {
2004       BFD_ASSERT (nextoff == bfd_tell (abfd));
2005       sprintf (fhdr.symoff, "%ld", (long) nextoff);
2006       bfd_ardata (abfd)->tdata = (PTR) &fhdr;
2007       if (! _bfd_compute_and_write_armap (abfd, 0))
2008         return false;
2009     }
2010
2011   /* Write out the archive file header.  */
2012
2013   /* We need spaces, not null bytes, in the header.  */
2014   for (p = (char *) &fhdr; p < (char *) &fhdr + SIZEOF_AR_FILE_HDR; p++)
2015     if (*p == '\0')
2016       *p = ' ';
2017
2018   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
2019       || (bfd_write ((PTR) &fhdr, SIZEOF_AR_FILE_HDR, 1, abfd) !=
2020           SIZEOF_AR_FILE_HDR))
2021     return false;
2022
2023   return true;
2024 }
2025
2026 static boolean
2027 xcoff_write_archive_contents_big (abfd)
2028      bfd *abfd;
2029 {
2030   struct xcoff_ar_file_hdr_big fhdr;
2031   size_t count;
2032   size_t total_namlen;
2033   file_ptr *offsets;
2034   boolean makemap;
2035   boolean hasobjects;
2036   file_ptr prevoff, nextoff;
2037   bfd *sub;
2038   unsigned int i;
2039   struct xcoff_ar_hdr_big ahdr;
2040   bfd_size_type size;
2041   char *p;
2042   char decbuf[13];
2043
2044   memset (&fhdr, 0, sizeof fhdr);
2045   strncpy (fhdr.magic, XCOFFARMAGBIG, SXCOFFARMAG);
2046   sprintf (fhdr.firstmemoff, "%d", SIZEOF_AR_FILE_HDR_BIG);
2047   sprintf (fhdr.freeoff, "%d", 0);
2048
2049   count = 0;
2050   total_namlen = 0;
2051   for (sub = abfd->archive_head; sub != NULL; sub = sub->next)
2052     {
2053       ++count;
2054       total_namlen += strlen (normalize_filename (sub)) + 1;
2055     }
2056   offsets = (file_ptr *) bfd_alloc (abfd, count * sizeof (file_ptr));
2057   if (offsets == NULL)
2058     return false;
2059
2060   if (bfd_seek (abfd, SIZEOF_AR_FILE_HDR_BIG, SEEK_SET) != 0)
2061     return false;
2062
2063   makemap = bfd_has_map (abfd);
2064   hasobjects = false;
2065   prevoff = 0;
2066   nextoff = SIZEOF_AR_FILE_HDR_BIG;
2067   for (sub = abfd->archive_head, i = 0; sub != NULL; sub = sub->next, i++)
2068     {
2069       const char *name;
2070       size_t namlen;
2071       struct xcoff_ar_hdr_big *ahdrp;
2072       bfd_size_type remaining;
2073
2074       if (makemap && ! hasobjects)
2075         {
2076           if (bfd_check_format (sub, bfd_object))
2077             hasobjects = true;
2078         }
2079
2080       name = normalize_filename (sub);
2081       namlen = strlen (name);
2082
2083       if (sub->arelt_data != NULL)
2084         ahdrp = arch_xhdr_big (sub);
2085       else
2086         ahdrp = NULL;
2087
2088       if (ahdrp == NULL)
2089         {
2090           struct stat s;
2091
2092           memset (&ahdr, 0, sizeof ahdr);
2093           ahdrp = &ahdr;
2094           /* XXX This should actually be a call to stat64 (at least on
2095              32-bit machines).  */
2096           if (stat (bfd_get_filename (sub), &s) != 0)
2097             {
2098               bfd_set_error (bfd_error_system_call);
2099               return false;
2100             }
2101
2102           /* XXX This call actually should use %lld (at least on 32-bit
2103              machines) since the fields's width is 20 and there numbers with
2104              more than 32 bits can be represented.  */
2105           sprintf (ahdrp->size, "%ld", (long) s.st_size);
2106           sprintf (ahdrp->date, "%ld", (long) s.st_mtime);
2107           sprintf (ahdrp->uid, "%ld", (long) s.st_uid);
2108           sprintf (ahdrp->gid, "%ld", (long) s.st_gid);
2109           sprintf (ahdrp->mode, "%o", (unsigned int) s.st_mode);
2110
2111           if (sub->arelt_data == NULL)
2112             {
2113               sub->arelt_data = bfd_alloc (sub, sizeof (struct areltdata));
2114               if (sub->arelt_data == NULL)
2115                 return false;
2116             }
2117
2118           arch_eltdata (sub)->parsed_size = s.st_size;
2119         }
2120
2121       /* XXX These calls actually should use %lld (at least on 32-bit
2122          machines) since the fields's width is 20 and there numbers with
2123          more than 32 bits can be represented.  */
2124       sprintf (ahdrp->prevoff, "%ld", (long) prevoff);
2125       sprintf (ahdrp->namlen, "%ld", (long) namlen);
2126
2127       /* If the length of the name is odd, we write out the null byte
2128          after the name as well.  */
2129       namlen = (namlen + 1) &~ 1;
2130
2131       remaining = arelt_size (sub);
2132       size = (SIZEOF_AR_HDR_BIG
2133               + namlen
2134               + SXCOFFARFMAG
2135               + remaining);
2136
2137       BFD_ASSERT (nextoff == bfd_tell (abfd));
2138
2139       offsets[i] = nextoff;
2140
2141       prevoff = nextoff;
2142       nextoff += size + (size & 1);
2143
2144       sprintf (ahdrp->nextoff, "%ld", (long) nextoff);
2145
2146       /* We need spaces, not null bytes, in the header.  */
2147       for (p = (char *) ahdrp; p < (char *) ahdrp + SIZEOF_AR_HDR_BIG; p++)
2148         if (*p == '\0')
2149           *p = ' ';
2150
2151       if (bfd_write ((PTR) ahdrp, 1, SIZEOF_AR_HDR_BIG, abfd)
2152           != SIZEOF_AR_HDR_BIG
2153           || bfd_write ((PTR) name, 1, namlen, abfd) != namlen
2154           || (bfd_write ((PTR) XCOFFARFMAG, 1, SXCOFFARFMAG, abfd)
2155               != SXCOFFARFMAG))
2156         return false;
2157
2158       if (bfd_seek (sub, (file_ptr) 0, SEEK_SET) != 0)
2159         return false;
2160       while (remaining != 0)
2161         {
2162           bfd_size_type amt;
2163           bfd_byte buffer[DEFAULT_BUFFERSIZE];
2164
2165           amt = sizeof buffer;
2166           if (amt > remaining)
2167             amt = remaining;
2168           if (bfd_read (buffer, 1, amt, sub) != amt
2169               || bfd_write (buffer, 1, amt, abfd) != amt)
2170             return false;
2171           remaining -= amt;
2172         }
2173
2174       if ((size & 1) != 0)
2175         {
2176           bfd_byte b;
2177
2178           b = '\0';
2179           if (bfd_write (&b, 1, 1, abfd) != 1)
2180             return false;
2181         }
2182     }
2183
2184   /* XXX This call actually should use %lld (at least on 32-bit
2185      machines) since the fields's width is 20 and there numbers with
2186      more than 32 bits can be represented.  */
2187   sprintf (fhdr.lastmemoff, "%ld", (long) prevoff);
2188
2189   /* Write out the member table.  */
2190
2191   BFD_ASSERT (nextoff == bfd_tell (abfd));
2192   /* XXX This call actually should use %lld (at least on 32-bit
2193      machines) since the fields's width is 20 and there numbers with
2194      more than 32 bits can be represented.  */
2195   sprintf (fhdr.memoff, "%ld", (long) nextoff);
2196
2197   memset (&ahdr, 0, sizeof ahdr);
2198   /* XXX The next two calls actually should use %lld (at least on 32-bit
2199      machines) since the fields's width is 20 and there numbers with
2200      more than 32 bits can be represented.  */
2201   sprintf (ahdr.size, "%ld", (long) (12 + count * 12 + total_namlen));
2202   sprintf (ahdr.prevoff, "%ld", (long) prevoff);
2203   sprintf (ahdr.date, "%d", 0);
2204   sprintf (ahdr.uid, "%d", 0);
2205   sprintf (ahdr.gid, "%d", 0);
2206   sprintf (ahdr.mode, "%d", 0);
2207   sprintf (ahdr.namlen, "%d", 0);
2208
2209   size = (SIZEOF_AR_HDR_BIG
2210           + 12
2211           + count * 12
2212           + total_namlen
2213           + SXCOFFARFMAG);
2214
2215   prevoff = nextoff;
2216   nextoff += size + (size & 1);
2217
2218   if (makemap && hasobjects)
2219     /* XXX This call actually should use %lld (at least on 32-bit
2220        machines) since the fields's width is 20 and there numbers with
2221        more than 32 bits can be represented.  */
2222     sprintf (ahdr.nextoff, "%ld", (long) nextoff);
2223   else
2224     sprintf (ahdr.nextoff, "%d", 0);
2225
2226   /* We need spaces, not null bytes, in the header.  */
2227   for (p = (char *) &ahdr; p < (char *) &ahdr + SIZEOF_AR_HDR_BIG; p++)
2228     if (*p == '\0')
2229       *p = ' ';
2230
2231   if (bfd_write ((PTR) &ahdr, 1, SIZEOF_AR_HDR_BIG, abfd) != SIZEOF_AR_HDR_BIG
2232       || (bfd_write ((PTR) XCOFFARFMAG, 1, SXCOFFARFMAG, abfd)
2233           != SXCOFFARFMAG))
2234     return false;
2235
2236   sprintf (decbuf, "%-12ld", (long) count);
2237   if (bfd_write ((PTR) decbuf, 1, 12, abfd) != 12)
2238     return false;
2239   for (i = 0; i < count; i++)
2240     {
2241       sprintf (decbuf, "%-12ld", (long) offsets[i]);
2242       if (bfd_write ((PTR) decbuf, 1, 12, abfd) != 12)
2243         return false;
2244     }
2245   for (sub = abfd->archive_head; sub != NULL; sub = sub->next)
2246     {
2247       const char *name;
2248       size_t namlen;
2249
2250       name = normalize_filename (sub);
2251       namlen = strlen (name);
2252       if (bfd_write ((PTR) name, 1, namlen + 1, abfd) != namlen + 1)
2253         return false;
2254     }
2255   if ((size & 1) != 0)
2256     {
2257       bfd_byte b;
2258
2259       b = '\0';
2260       if (bfd_write ((PTR) &b, 1, 1, abfd) != 1)
2261         return false;
2262     }
2263
2264   /* Write out the armap, if appropriate.  */
2265
2266   if (! makemap || ! hasobjects)
2267     sprintf (fhdr.symoff, "%d", 0);
2268   else
2269     {
2270       BFD_ASSERT (nextoff == bfd_tell (abfd));
2271       /* XXX This call actually should use %lld (at least on 32-bit
2272          machines) since the fields's width is 20 and there numbers with
2273          more than 32 bits can be represented.  */
2274       sprintf (fhdr.symoff, "%ld", (long) nextoff);
2275       bfd_ardata (abfd)->tdata = (PTR) &fhdr;
2276       if (! _bfd_compute_and_write_armap (abfd, 0))
2277         return false;
2278     }
2279
2280   /* Write out the archive file header.  */
2281
2282   /* We need spaces, not null bytes, in the header.  */
2283   for (p = (char *) &fhdr; p < (char *) &fhdr + SIZEOF_AR_FILE_HDR_BIG; p++)
2284     if (*p == '\0')
2285       *p = ' ';
2286
2287   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
2288       || (bfd_write ((PTR) &fhdr, SIZEOF_AR_FILE_HDR_BIG, 1, abfd) !=
2289           SIZEOF_AR_FILE_HDR_BIG))
2290     return false;
2291
2292   return true;
2293 }
2294
2295 boolean
2296 _bfd_xcoff_write_archive_contents (abfd)
2297      bfd *abfd;
2298 {
2299   if (! xcoff_big_format_p (abfd))
2300     return xcoff_write_archive_contents_old (abfd);
2301   else
2302     return xcoff_write_archive_contents_big (abfd);
2303 }
2304 \f
2305 /* We can't use the usual coff_sizeof_headers routine, because AIX
2306    always uses an a.out header.  */
2307
2308 /*ARGSUSED*/
2309 int
2310 _bfd_xcoff_sizeof_headers (abfd, reloc)
2311      bfd *abfd;
2312      boolean reloc ATTRIBUTE_UNUSED;
2313 {
2314   int size;
2315
2316   size = FILHSZ;
2317   if (xcoff_data (abfd)->full_aouthdr)
2318     size += AOUTSZ;
2319   else
2320     size += SMALL_AOUTSZ;
2321   size += abfd->section_count * SCNHSZ;
2322   return size;
2323 }
2324 \f
2325 #define CORE_FILE_P _bfd_dummy_target
2326
2327 #define coff_core_file_failing_command _bfd_nocore_core_file_failing_command
2328 #define coff_core_file_failing_signal _bfd_nocore_core_file_failing_signal
2329 #define coff_core_file_matches_executable_p \
2330   _bfd_nocore_core_file_matches_executable_p
2331
2332 #ifdef AIX_CORE
2333 #undef CORE_FILE_P
2334 #define CORE_FILE_P rs6000coff_core_p
2335 extern const bfd_target * rs6000coff_core_p ();
2336 extern boolean rs6000coff_get_section_contents ();
2337 extern boolean rs6000coff_core_file_matches_executable_p ();
2338
2339 #undef  coff_core_file_matches_executable_p
2340 #define coff_core_file_matches_executable_p  \
2341                                      rs6000coff_core_file_matches_executable_p
2342
2343 extern char *rs6000coff_core_file_failing_command PARAMS ((bfd *abfd));
2344 #undef coff_core_file_failing_command
2345 #define coff_core_file_failing_command rs6000coff_core_file_failing_command
2346
2347 extern int rs6000coff_core_file_failing_signal PARAMS ((bfd *abfd));
2348 #undef coff_core_file_failing_signal
2349 #define coff_core_file_failing_signal rs6000coff_core_file_failing_signal
2350
2351 #undef  coff_get_section_contents
2352 #define coff_get_section_contents       rs6000coff_get_section_contents
2353 #endif /* AIX_CORE */
2354
2355 #ifdef LYNX_CORE
2356
2357 #undef CORE_FILE_P
2358 #define CORE_FILE_P lynx_core_file_p
2359 extern const bfd_target *lynx_core_file_p PARAMS ((bfd *abfd));
2360
2361 extern boolean lynx_core_file_matches_executable_p PARAMS ((bfd *core_bfd,
2362                                                             bfd *exec_bfd));
2363 #undef  coff_core_file_matches_executable_p
2364 #define coff_core_file_matches_executable_p lynx_core_file_matches_executable_p
2365
2366 extern char *lynx_core_file_failing_command PARAMS ((bfd *abfd));
2367 #undef coff_core_file_failing_command
2368 #define coff_core_file_failing_command lynx_core_file_failing_command
2369
2370 extern int lynx_core_file_failing_signal PARAMS ((bfd *abfd));
2371 #undef coff_core_file_failing_signal
2372 #define coff_core_file_failing_signal lynx_core_file_failing_signal
2373
2374 #endif /* LYNX_CORE */
2375
2376 #define _bfd_xcoff_bfd_get_relocated_section_contents \
2377   coff_bfd_get_relocated_section_contents
2378 #define _bfd_xcoff_bfd_relax_section coff_bfd_relax_section
2379 #define _bfd_xcoff_bfd_gc_sections coff_bfd_gc_sections
2380 #define _bfd_xcoff_bfd_link_split_section coff_bfd_link_split_section
2381
2382 /* The transfer vector that leads the outside world to all of the above. */
2383
2384 const bfd_target
2385 #ifdef TARGET_SYM
2386   TARGET_SYM =
2387 #else
2388   rs6000coff_vec =
2389 #endif
2390 {
2391 #ifdef TARGET_NAME
2392   TARGET_NAME,
2393 #else
2394   "aixcoff-rs6000",             /* name */
2395 #endif
2396   bfd_target_coff_flavour,
2397   BFD_ENDIAN_BIG,               /* data byte order is big */
2398   BFD_ENDIAN_BIG,               /* header byte order is big */
2399
2400   (HAS_RELOC | EXEC_P |         /* object flags */
2401    HAS_LINENO | HAS_DEBUG | DYNAMIC |
2402    HAS_SYMS | HAS_LOCALS | WP_TEXT),
2403
2404   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
2405   0,                            /* leading char */
2406   '/',                          /* ar_pad_char */
2407   15,                           /* ar_max_namelen??? FIXMEmgo */
2408
2409   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
2410      bfd_getb32, bfd_getb_signed_32, bfd_putb32,
2411      bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* data */
2412   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
2413      bfd_getb32, bfd_getb_signed_32, bfd_putb32,
2414      bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */
2415
2416   {_bfd_dummy_target, coff_object_p,    /* bfd_check_format */
2417      _bfd_xcoff_archive_p, CORE_FILE_P},
2418   {bfd_false, coff_mkobject,            /* bfd_set_format */
2419      _bfd_generic_mkarchive, bfd_false},
2420   {bfd_false, coff_write_object_contents,       /* bfd_write_contents */
2421      _bfd_xcoff_write_archive_contents, bfd_false},
2422
2423      BFD_JUMP_TABLE_GENERIC (coff),
2424      BFD_JUMP_TABLE_COPY (coff),
2425      BFD_JUMP_TABLE_CORE (coff),
2426      BFD_JUMP_TABLE_ARCHIVE (_bfd_xcoff),
2427      BFD_JUMP_TABLE_SYMBOLS (coff),
2428      BFD_JUMP_TABLE_RELOCS (coff),
2429      BFD_JUMP_TABLE_WRITE (coff),
2430      BFD_JUMP_TABLE_LINK (_bfd_xcoff),
2431      BFD_JUMP_TABLE_DYNAMIC (_bfd_xcoff),
2432
2433   NULL,
2434
2435   COFF_SWAP_TABLE
2436 };