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