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