OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [bfd/] [coff-rs6000.c] - Diff between revs 157 and 225

Go to most recent revision | Show entire file | Details | Blame | View Log

Rev 157 Rev 225
Line 1... Line 1...
/* BFD back-end for IBM RS/6000 "XCOFF" files.
/* BFD back-end for IBM RS/6000 "XCOFF" files.
   Copyright 1990-1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
   Copyright 1990-1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
   Free Software Foundation, Inc.
   2008, 2009  Free Software Foundation, Inc.
   Written by Metin G. Ozisik, Mimi Phuong-Thao Vo, and John Gilmore.
   Written by Metin G. Ozisik, Mimi Phuong-Thao Vo, and John Gilmore.
   Archive support from Damon A. Permezel.
   Archive support from Damon A. Permezel.
   Contributed by IBM Corporation and Cygnus Support.
   Contributed by IBM Corporation and Cygnus Support.
 
 
   This file is part of BFD, the Binary File Descriptor library.
   This file is part of BFD, the Binary File Descriptor library.
Line 126... Line 126...
#define coff_SWAP_aux_out _bfd_xcoff_swap_aux_out
#define coff_SWAP_aux_out _bfd_xcoff_swap_aux_out
#define coff_swap_reloc_in xcoff_swap_reloc_in
#define coff_swap_reloc_in xcoff_swap_reloc_in
#define coff_swap_reloc_out xcoff_swap_reloc_out
#define coff_swap_reloc_out xcoff_swap_reloc_out
#define NO_COFF_RELOCS
#define NO_COFF_RELOCS
 
 
 
#ifndef bfd_pe_print_pdata
 
#define bfd_pe_print_pdata      NULL
 
#endif
 
 
#include "coffcode.h"
#include "coffcode.h"
 
 
/* The main body of code is in coffcode.h.  */
/* The main body of code is in coffcode.h.  */
 
 
static const char *normalize_filename
static const char *normalize_filename
Line 174... Line 178...
  PARAMS ((bfd *, const char *, const char *, bfd_boolean));
  PARAMS ((bfd *, const char *, const char *, bfd_boolean));
static bfd_boolean do_pad
static bfd_boolean do_pad
  PARAMS ((bfd *, unsigned int));
  PARAMS ((bfd *, unsigned int));
static bfd_boolean do_copy
static bfd_boolean do_copy
  PARAMS ((bfd *, bfd *));
  PARAMS ((bfd *, bfd *));
static bfd_boolean do_shared_object_padding
 
  PARAMS ((bfd *, bfd *, file_ptr *, int));
 
 
 
/* Relocation functions */
/* Relocation functions */
static bfd_boolean xcoff_reloc_type_br
static bfd_boolean xcoff_reloc_type_br
  PARAMS ((XCOFF_RELOC_FUNCTION_ARGS));
  PARAMS ((XCOFF_RELOC_FUNCTION_ARGS));
 
 
Line 232... Line 234...
  xcoff_complain_overflow_bitfield_func,
  xcoff_complain_overflow_bitfield_func,
  xcoff_complain_overflow_signed_func,
  xcoff_complain_overflow_signed_func,
  xcoff_complain_overflow_unsigned_func,
  xcoff_complain_overflow_unsigned_func,
};
};
 
 
 
/* Information about one member of an archive.  */
 
struct member_layout {
 
  /* The archive member that this structure describes.  */
 
  bfd *member;
 
 
 
  /* The number of bytes of padding that must be inserted before the
 
     start of the member in order to ensure that the section contents
 
     are correctly aligned.  */
 
  unsigned int leading_padding;
 
 
 
  /* The offset of MEMBER from the start of the archive (i.e. the end
 
     of the leading padding).  */
 
  file_ptr offset;
 
 
 
  /* The normalized name of MEMBER.  */
 
  const char *name;
 
 
 
  /* The length of NAME, without padding.  */
 
  bfd_size_type namlen;
 
 
 
  /* The length of NAME, with padding.  */
 
  bfd_size_type padded_namlen;
 
 
 
  /* The size of MEMBER's header, including the name and magic sequence.  */
 
  bfd_size_type header_size;
 
 
 
  /* The size of the MEMBER's contents.  */
 
  bfd_size_type contents_size;
 
 
 
  /* The number of bytes of padding that must be inserted after MEMBER
 
     in order to preserve even alignment.  */
 
  bfd_size_type trailing_padding;
 
};
 
 
 
/* A structure used for iterating over the members of an archive.  */
 
struct archive_iterator {
 
  /* The archive itself.  */
 
  bfd *archive;
 
 
 
  /* Information about the current archive member.  */
 
  struct member_layout current;
 
 
 
  /* Information about the next archive member.  MEMBER is null if there
 
     are no more archive members, in which case OFFSET is the offset of
 
     the first unused byte.  */
 
  struct member_layout next;
 
};
 
 
 
/* Initialize INFO so that it describes member MEMBER of archive ARCHIVE.
 
   OFFSET is the even-padded offset of MEMBER, not including any leading
 
   padding needed for section alignment.  */
 
 
 
static void
 
member_layout_init (struct member_layout *info, bfd *archive,
 
                    bfd *member, file_ptr offset)
 
{
 
  info->member = member;
 
  info->leading_padding = 0;
 
  if (member)
 
    {
 
      info->name = normalize_filename (member);
 
      info->namlen = strlen (info->name);
 
      info->padded_namlen = info->namlen + (info->namlen & 1);
 
      if (xcoff_big_format_p (archive))
 
        info->header_size = SIZEOF_AR_HDR_BIG;
 
      else
 
        info->header_size = SIZEOF_AR_HDR;
 
      info->header_size += info->padded_namlen + SXCOFFARFMAG;
 
      info->contents_size = arelt_size (member);
 
      info->trailing_padding = info->contents_size & 1;
 
 
 
      if (bfd_check_format (member, bfd_object)
 
          && bfd_get_flavour (member) == bfd_target_xcoff_flavour
 
          && (member->flags & DYNAMIC) != 0)
 
        info->leading_padding
 
          = (-(offset + info->header_size)
 
             & ((1 << bfd_xcoff_text_align_power (member)) - 1));
 
    }
 
  info->offset = offset + info->leading_padding;
 
}
 
 
 
/* Set up ITERATOR to iterate through archive ARCHIVE.  */
 
 
 
static void
 
archive_iterator_begin (struct archive_iterator *iterator,
 
                        bfd *archive)
 
{
 
  iterator->archive = archive;
 
  member_layout_init (&iterator->next, archive, archive->archive_head,
 
                      xcoff_big_format_p (archive)
 
                      ? SIZEOF_AR_FILE_HDR_BIG
 
                      : SIZEOF_AR_FILE_HDR);
 
}
 
 
 
/* Make ITERATOR visit the first unvisited archive member.  Return true
 
   on success; return false if all members have been visited.  */
 
 
 
static bfd_boolean
 
archive_iterator_next (struct archive_iterator *iterator)
 
{
 
  if (!iterator->next.member)
 
    return FALSE;
 
 
 
  iterator->current = iterator->next;
 
  member_layout_init (&iterator->next, iterator->archive,
 
                      iterator->current.member->archive_next,
 
                      iterator->current.offset
 
                      + iterator->current.header_size
 
                      + iterator->current.contents_size
 
                      + iterator->current.trailing_padding);
 
  return TRUE;
 
}
 
 
/* We use our own tdata type.  Its first field is the COFF tdata type,
/* We use our own tdata type.  Its first field is the COFF tdata type,
   so the COFF routines are compatible.  */
   so the COFF routines are compatible.  */
 
 
bfd_boolean
bfd_boolean
_bfd_xcoff_mkobject (abfd)
_bfd_xcoff_mkobject (abfd)
Line 378... Line 493...
  H_PUT_8 (abfd, in->n_numaux, ext->e_numaux);
  H_PUT_8 (abfd, in->n_numaux, ext->e_numaux);
  return bfd_coff_symesz (abfd);
  return bfd_coff_symesz (abfd);
}
}
 
 
void
void
_bfd_xcoff_swap_aux_in (abfd, ext1, type, class, indx, numaux, in1)
_bfd_xcoff_swap_aux_in (abfd, ext1, type, in_class, indx, numaux, in1)
     bfd *abfd;
     bfd *abfd;
     PTR ext1;
     PTR ext1;
     int type;
     int type;
     int class;
     int in_class;
     int indx;
     int indx;
     int numaux;
     int numaux;
     PTR in1;
     PTR in1;
{
{
  AUXENT * ext = (AUXENT *)ext1;
  AUXENT * ext = (AUXENT *)ext1;
  union internal_auxent *in = (union internal_auxent *)in1;
  union internal_auxent *in = (union internal_auxent *)in1;
 
 
  switch (class)
  switch (in_class)
    {
    {
    case C_FILE:
    case C_FILE:
      if (ext->x_file.x_fname[0] == 0)
      if (ext->x_file.x_fname[0] == 0)
        {
        {
          in->x_file.x_n.x_zeroes = 0;
          in->x_file.x_n.x_zeroes = 0;
Line 416... Line 531...
        }
        }
      goto end;
      goto end;
 
 
      /* RS/6000 "csect" auxents */
      /* RS/6000 "csect" auxents */
    case C_EXT:
    case C_EXT:
 
    case C_AIX_WEAKEXT:
    case C_HIDEXT:
    case C_HIDEXT:
      if (indx + 1 == numaux)
      if (indx + 1 == numaux)
        {
        {
          in->x_csect.x_scnlen.l = H_GET_32 (abfd, ext->x_csect.x_scnlen);
          in->x_csect.x_scnlen.l = H_GET_32 (abfd, ext->x_csect.x_scnlen);
          in->x_csect.x_parmhash = H_GET_32 (abfd, ext->x_csect.x_parmhash);
          in->x_csect.x_parmhash = H_GET_32 (abfd, ext->x_csect.x_parmhash);
Line 455... Line 571...
    }
    }
 
 
  in->x_sym.x_tagndx.l = H_GET_32 (abfd, ext->x_sym.x_tagndx);
  in->x_sym.x_tagndx.l = H_GET_32 (abfd, ext->x_sym.x_tagndx);
  in->x_sym.x_tvndx = H_GET_16 (abfd, ext->x_sym.x_tvndx);
  in->x_sym.x_tvndx = H_GET_16 (abfd, ext->x_sym.x_tvndx);
 
 
  if (class == C_BLOCK || class == C_FCN || ISFCN (type) || ISTAG (class))
  if (in_class == C_BLOCK || in_class == C_FCN || ISFCN (type)
 
      || ISTAG (in_class))
    {
    {
      in->x_sym.x_fcnary.x_fcn.x_lnnoptr =
      in->x_sym.x_fcnary.x_fcn.x_lnnoptr =
        H_GET_32 (abfd, ext->x_sym.x_fcnary.x_fcn.x_lnnoptr);
        H_GET_32 (abfd, ext->x_sym.x_fcnary.x_fcn.x_lnnoptr);
      in->x_sym.x_fcnary.x_fcn.x_endndx.l =
      in->x_sym.x_fcnary.x_fcn.x_endndx.l =
        H_GET_32 (abfd, ext->x_sym.x_fcnary.x_fcn.x_endndx);
        H_GET_32 (abfd, ext->x_sym.x_fcnary.x_fcn.x_endndx);
Line 496... Line 613...
 
 
unsigned int _bfd_xcoff_swap_aux_out
unsigned int _bfd_xcoff_swap_aux_out
  PARAMS ((bfd *, PTR, int, int, int, int, PTR));
  PARAMS ((bfd *, PTR, int, int, int, int, PTR));
 
 
unsigned int
unsigned int
_bfd_xcoff_swap_aux_out (abfd, inp, type, class, indx, numaux, extp)
_bfd_xcoff_swap_aux_out (abfd, inp, type, in_class, indx, numaux, extp)
     bfd * abfd;
     bfd * abfd;
     PTR   inp;
     PTR   inp;
     int   type;
     int   type;
     int   class;
     int   in_class;
     int   indx ATTRIBUTE_UNUSED;
     int   indx ATTRIBUTE_UNUSED;
     int   numaux ATTRIBUTE_UNUSED;
     int   numaux ATTRIBUTE_UNUSED;
     PTR   extp;
     PTR   extp;
{
{
  union internal_auxent *in = (union internal_auxent *)inp;
  union internal_auxent *in = (union internal_auxent *)inp;
  AUXENT *ext = (AUXENT *)extp;
  AUXENT *ext = (AUXENT *)extp;
 
 
  memset ((PTR)ext, 0, bfd_coff_auxesz (abfd));
  memset ((PTR)ext, 0, bfd_coff_auxesz (abfd));
  switch (class)
  switch (in_class)
    {
    {
    case C_FILE:
    case C_FILE:
      if (in->x_file.x_fname[0] == 0)
      if (in->x_file.x_fname[0] == 0)
        {
        {
          H_PUT_32 (abfd, 0, ext->x_file.x_n.x_zeroes);
          H_PUT_32 (abfd, 0, ext->x_file.x_n.x_zeroes);
Line 525... Line 642...
        }
        }
      goto end;
      goto end;
 
 
      /* RS/6000 "csect" auxents */
      /* RS/6000 "csect" auxents */
    case C_EXT:
    case C_EXT:
 
    case C_AIX_WEAKEXT:
    case C_HIDEXT:
    case C_HIDEXT:
      if (indx + 1 == numaux)
      if (indx + 1 == numaux)
        {
        {
          H_PUT_32 (abfd, in->x_csect.x_scnlen.l, ext->x_csect.x_scnlen);
          H_PUT_32 (abfd, in->x_csect.x_scnlen.l, ext->x_csect.x_scnlen);
          H_PUT_32 (abfd, in->x_csect.x_parmhash, ext->x_csect.x_parmhash);
          H_PUT_32 (abfd, in->x_csect.x_parmhash, ext->x_csect.x_parmhash);
Line 558... Line 676...
    }
    }
 
 
  H_PUT_32 (abfd, in->x_sym.x_tagndx.l, ext->x_sym.x_tagndx);
  H_PUT_32 (abfd, in->x_sym.x_tagndx.l, ext->x_sym.x_tagndx);
  H_PUT_16 (abfd, in->x_sym.x_tvndx, ext->x_sym.x_tvndx);
  H_PUT_16 (abfd, in->x_sym.x_tvndx, ext->x_sym.x_tvndx);
 
 
  if (class == C_BLOCK || class == C_FCN || ISFCN (type) || ISTAG (class))
  if (in_class == C_BLOCK || in_class == C_FCN || ISFCN (type)
 
      || ISTAG (in_class))
    {
    {
      H_PUT_32 (abfd, in->x_sym.x_fcnary.x_fcn.x_lnnoptr,
      H_PUT_32 (abfd, in->x_sym.x_fcnary.x_fcn.x_lnnoptr,
                ext->x_sym.x_fcnary.x_fcn.x_lnnoptr);
                ext->x_sym.x_fcnary.x_fcn.x_lnnoptr);
      H_PUT_32 (abfd, in->x_sym.x_fcnary.x_fcn.x_endndx.l,
      H_PUT_32 (abfd, in->x_sym.x_fcnary.x_fcn.x_endndx.l,
                ext->x_sym.x_fcnary.x_fcn.x_endndx);
                ext->x_sym.x_fcnary.x_fcn.x_endndx);
Line 775... Line 894...
         0xffff,                /* dst_mask */
         0xffff,                /* dst_mask */
         FALSE),                /* pcrel_offset */
         FALSE),                /* pcrel_offset */
 
 
  EMPTY_HOWTO (0xe),
  EMPTY_HOWTO (0xe),
 
 
  /* Non-relocating reference.  */
  /* Non-relocating reference.  Bitsize is 1 so that r_rsize is 0.  */
  HOWTO (R_REF,                 /* type */
  HOWTO (R_REF,                 /* type */
         0,                      /* rightshift */
         0,                      /* rightshift */
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
         0,                      /* size (0 = byte, 1 = short, 2 = long) */
         32,                    /* bitsize */
         1,                     /* bitsize */
         FALSE,                 /* pc_relative */
         FALSE,                 /* pc_relative */
         0,                      /* bitpos */
         0,                      /* bitpos */
         complain_overflow_dont, /* complain_on_overflow */
         complain_overflow_dont, /* complain_on_overflow */
         0,                      /* special_function */
         0,                      /* special_function */
         "R_REF",               /* name */
         "R_REF",               /* name */
Line 1041... Line 1160...
    case BFD_RELOC_PPC_TOC16:
    case BFD_RELOC_PPC_TOC16:
      return &xcoff_howto_table[3];
      return &xcoff_howto_table[3];
    case BFD_RELOC_32:
    case BFD_RELOC_32:
    case BFD_RELOC_CTOR:
    case BFD_RELOC_CTOR:
      return &xcoff_howto_table[0];
      return &xcoff_howto_table[0];
 
    case BFD_RELOC_NONE:
 
      return &xcoff_howto_table[0xf];
    default:
    default:
      return NULL;
      return NULL;
    }
    }
}
}
 
 
Line 1595... Line 1716...
     unsigned int elength ATTRIBUTE_UNUSED;
     unsigned int elength ATTRIBUTE_UNUSED;
     struct orl *map;
     struct orl *map;
     unsigned int orl_count;
     unsigned int orl_count;
     int stridx;
     int stridx;
{
{
 
  struct archive_iterator iterator;
  struct xcoff_ar_hdr hdr;
  struct xcoff_ar_hdr hdr;
  char *p;
  char *p;
  unsigned char buf[4];
  unsigned char buf[4];
  bfd *sub;
 
  file_ptr fileoff;
 
  unsigned int i;
  unsigned int i;
 
 
  memset (&hdr, 0, sizeof hdr);
  memset (&hdr, 0, sizeof hdr);
  sprintf (hdr.size, "%ld", (long) (4 + orl_count * 4 + stridx));
  sprintf (hdr.size, "%ld", (long) (4 + orl_count * 4 + stridx));
  sprintf (hdr.nextoff, "%d", 0);
  sprintf (hdr.nextoff, "%d", 0);
Line 1627... Line 1747...
 
 
  H_PUT_32 (abfd, orl_count, buf);
  H_PUT_32 (abfd, orl_count, buf);
  if (bfd_bwrite (buf, (bfd_size_type) 4, abfd) != 4)
  if (bfd_bwrite (buf, (bfd_size_type) 4, abfd) != 4)
    return FALSE;
    return FALSE;
 
 
  sub = abfd->archive_head;
 
  fileoff = SIZEOF_AR_FILE_HDR;
 
  i = 0;
  i = 0;
  while (sub != NULL && i < orl_count)
  archive_iterator_begin (&iterator, abfd);
    {
  while (i < orl_count && archive_iterator_next (&iterator))
      size_t namlen;
    while (map[i].u.abfd == iterator.current.member)
 
 
      while (map[i].u.abfd == sub)
 
        {
        {
          H_PUT_32 (abfd, fileoff, buf);
        H_PUT_32 (abfd, iterator.current.offset, buf);
          if (bfd_bwrite (buf, (bfd_size_type) 4, abfd) != 4)
          if (bfd_bwrite (buf, (bfd_size_type) 4, abfd) != 4)
            return FALSE;
            return FALSE;
          ++i;
          ++i;
        }
        }
      namlen = strlen (normalize_filename (sub));
 
      namlen = (namlen + 1) &~ (size_t) 1;
 
      fileoff += (SIZEOF_AR_HDR
 
                  + namlen
 
                  + SXCOFFARFMAG
 
                  + arelt_size (sub));
 
      fileoff = (fileoff + 1) &~ 1;
 
      sub = sub->archive_next;
 
    }
 
 
 
  for (i = 0; i < orl_count; i++)
  for (i = 0; i < orl_count; i++)
    {
    {
      const char *name;
      const char *name;
      size_t namlen;
      size_t namlen;
Line 1751... Line 1858...
 
 
  return TRUE;
  return TRUE;
}
}
 
 
static bfd_boolean
static bfd_boolean
do_shared_object_padding (out_bfd, in_bfd, offset, ar_header_size)
 
     bfd *out_bfd;
 
     bfd *in_bfd;
 
     file_ptr *offset;
 
     int ar_header_size;
 
{
 
  if (bfd_check_format (in_bfd, bfd_object)
 
      && bfd_get_flavour (in_bfd) == bfd_target_xcoff_flavour
 
      && (in_bfd->flags & DYNAMIC) != 0)
 
    {
 
      bfd_size_type pad = 0;
 
      int text_align_power;
 
 
 
      text_align_power = bfd_xcoff_text_align_power (in_bfd);
 
 
 
      pad = 1 << text_align_power;
 
      pad -= (*offset + ar_header_size) & (pad - 1);
 
 
 
      if (! do_pad (out_bfd, pad))
 
        return FALSE;
 
 
 
      *offset += pad;
 
    }
 
 
 
  return TRUE;
 
}
 
 
 
static bfd_boolean
 
xcoff_write_armap_big (abfd, elength, map, orl_count, stridx)
xcoff_write_armap_big (abfd, elength, map, orl_count, stridx)
     bfd *abfd;
     bfd *abfd;
     unsigned int elength ATTRIBUTE_UNUSED;
     unsigned int elength ATTRIBUTE_UNUSED;
     struct orl *map;
     struct orl *map;
     unsigned int orl_count;
     unsigned int orl_count;
     int stridx;
     int stridx;
{
{
 
  struct archive_iterator iterator;
  struct xcoff_ar_file_hdr_big *fhdr;
  struct xcoff_ar_file_hdr_big *fhdr;
  bfd_vma i, sym_32, sym_64, str_32, str_64;
  bfd_vma i, sym_32, sym_64, str_32, str_64;
  const bfd_arch_info_type *arch_info = NULL;
  const bfd_arch_info_type *arch_info;
  bfd *current_bfd;
  bfd *current_bfd;
  size_t string_length;
  size_t string_length;
  file_ptr nextoff, prevoff;
  file_ptr nextoff, prevoff;
 
 
  /* First, we look through the symbols and work out which are
  /* First, we look through the symbols and work out which are
     from 32-bit objects and which from 64-bit ones.  */
     from 32-bit objects and which from 64-bit ones.  */
  sym_32 = sym_64 = str_32 = str_64 = 0;
  sym_32 = sym_64 = str_32 = str_64 = 0;
 
 
  current_bfd = abfd->archive_head;
 
  if (current_bfd != NULL)
 
    arch_info = bfd_get_arch_info (current_bfd);
 
    i = 0;
    i = 0;
    while (current_bfd != NULL && i < orl_count)
  for (current_bfd = abfd->archive_head;
 
       current_bfd != NULL && i < orl_count;
 
       current_bfd = current_bfd->archive_next)
    {
    {
 
      arch_info = bfd_get_arch_info (current_bfd);
      while (map[i].u.abfd == current_bfd)
      while (map[i].u.abfd == current_bfd)
        {
        {
          string_length = strlen (*map[i].name) + 1;
          string_length = strlen (*map[i].name) + 1;
 
 
          if (arch_info->bits_per_address == 64)
          if (arch_info->bits_per_address == 64)
            {
            {
              sym_64++;
              sym_64++;
              str_64 += string_length;
              str_64 += string_length;
            }
            }
Line 1819... Line 1898...
              sym_32++;
              sym_32++;
              str_32 += string_length;
              str_32 += string_length;
            }
            }
          i++;
          i++;
        }
        }
      current_bfd = current_bfd->archive_next;
 
      if (current_bfd != NULL)
 
        arch_info = bfd_get_arch_info (current_bfd);
 
    }
    }
 
 
  /* A quick sanity check... */
  /* A quick sanity check... */
  BFD_ASSERT (sym_64 + sym_32 == orl_count);
  BFD_ASSERT (sym_64 + sym_32 == orl_count);
  /* Explicit cast to int for compiler.  */
  /* Explicit cast to int for compiler.  */
Line 1863... Line 1939...
  if (sym_32)
  if (sym_32)
    {
    {
      struct xcoff_ar_hdr_big *hdr;
      struct xcoff_ar_hdr_big *hdr;
      char *symbol_table;
      char *symbol_table;
      char *st;
      char *st;
      file_ptr fileoff;
 
 
 
      bfd_vma symbol_table_size =
      bfd_vma symbol_table_size =
        SIZEOF_AR_HDR_BIG
        SIZEOF_AR_HDR_BIG
        + SXCOFFARFMAG
        + SXCOFFARFMAG
        + 8
        + 8
Line 1900... Line 1975...
 
 
      bfd_h_put_64 (abfd, sym_32, st);
      bfd_h_put_64 (abfd, sym_32, st);
      st += 8;
      st += 8;
 
 
      /* loop over the 32 bit offsets */
      /* loop over the 32 bit offsets */
      current_bfd = abfd->archive_head;
 
      if (current_bfd != NULL)
 
        arch_info = bfd_get_arch_info (current_bfd);
 
      fileoff = SIZEOF_AR_FILE_HDR_BIG;
 
      i = 0;
      i = 0;
      while (current_bfd != NULL && i < orl_count)
      archive_iterator_begin (&iterator, abfd);
 
      while (i < orl_count && archive_iterator_next (&iterator))
        {
        {
          while (map[i].u.abfd == current_bfd)
          arch_info = bfd_get_arch_info (iterator.current.member);
 
          while (map[i].u.abfd == iterator.current.member)
            {
            {
              if (arch_info->bits_per_address == 32)
              if (arch_info->bits_per_address == 32)
                {
                {
                  bfd_h_put_64 (abfd, fileoff, st);
                  bfd_h_put_64 (abfd, iterator.current.offset, st);
                  st += 8;
                  st += 8;
                }
                }
              i++;
              i++;
            }
            }
          string_length = strlen (normalize_filename (current_bfd));
 
          string_length += string_length & 1;
 
          fileoff += (SIZEOF_AR_HDR_BIG
 
                      + string_length
 
                      + SXCOFFARFMAG
 
                      + arelt_size (current_bfd));
 
          fileoff += fileoff & 1;
 
          current_bfd = current_bfd->archive_next;
 
          if (current_bfd != NULL)
 
            arch_info = bfd_get_arch_info (current_bfd);
 
        }
        }
 
 
      /* loop over the 32 bit symbol names */
      /* loop over the 32 bit symbol names */
      current_bfd = abfd->archive_head;
 
      if (current_bfd != NULL)
 
        arch_info = bfd_get_arch_info (current_bfd);
 
      i = 0;
      i = 0;
      while (current_bfd != NULL && i < orl_count)
      for (current_bfd = abfd->archive_head;
 
           current_bfd != NULL && i < orl_count;
 
           current_bfd = current_bfd->archive_next)
        {
        {
 
          arch_info = bfd_get_arch_info (current_bfd);
          while (map[i].u.abfd == current_bfd)
          while (map[i].u.abfd == current_bfd)
            {
            {
              if (arch_info->bits_per_address == 32)
              if (arch_info->bits_per_address == 32)
                {
                {
                  string_length = sprintf (st, "%s", *map[i].name);
                  string_length = sprintf (st, "%s", *map[i].name);
                  st += string_length + 1;
                  st += string_length + 1;
                }
                }
              i++;
              i++;
            }
            }
          current_bfd = current_bfd->archive_next;
 
          if (current_bfd != NULL)
 
            arch_info = bfd_get_arch_info (current_bfd);
 
        }
        }
 
 
      bfd_bwrite (symbol_table, symbol_table_size, abfd);
      bfd_bwrite (symbol_table, symbol_table_size, abfd);
 
 
      free (symbol_table);
      free (symbol_table);
Line 1964... Line 2024...
  if (sym_64)
  if (sym_64)
    {
    {
      struct xcoff_ar_hdr_big *hdr;
      struct xcoff_ar_hdr_big *hdr;
      char *symbol_table;
      char *symbol_table;
      char *st;
      char *st;
      file_ptr fileoff;
 
 
 
      bfd_vma symbol_table_size =
      bfd_vma symbol_table_size =
        SIZEOF_AR_HDR_BIG
        SIZEOF_AR_HDR_BIG
        + SXCOFFARFMAG
        + SXCOFFARFMAG
        + 8
        + 8
Line 1996... Line 2055...
 
 
      bfd_h_put_64 (abfd, sym_64, st);
      bfd_h_put_64 (abfd, sym_64, st);
      st += 8;
      st += 8;
 
 
      /* loop over the 64 bit offsets */
      /* loop over the 64 bit offsets */
      current_bfd = abfd->archive_head;
 
      if (current_bfd != NULL)
 
        arch_info = bfd_get_arch_info (current_bfd);
 
      fileoff = SIZEOF_AR_FILE_HDR_BIG;
 
      i = 0;
      i = 0;
      while (current_bfd != NULL && i < orl_count)
      archive_iterator_begin (&iterator, abfd);
 
      while (i < orl_count && archive_iterator_next (&iterator))
        {
        {
          while (map[i].u.abfd == current_bfd)
          arch_info = bfd_get_arch_info (iterator.current.member);
 
          while (map[i].u.abfd == iterator.current.member)
            {
            {
              if (arch_info->bits_per_address == 64)
              if (arch_info->bits_per_address == 64)
                {
                {
                  bfd_h_put_64 (abfd, fileoff, st);
                  bfd_h_put_64 (abfd, iterator.current.offset, st);
                  st += 8;
                  st += 8;
                }
                }
              i++;
              i++;
            }
            }
          string_length = strlen (normalize_filename (current_bfd));
 
          string_length += string_length & 1;
 
          fileoff += (SIZEOF_AR_HDR_BIG
 
                      + string_length
 
                      + SXCOFFARFMAG
 
                      + arelt_size (current_bfd));
 
          fileoff += fileoff & 1;
 
          current_bfd = current_bfd->archive_next;
 
          if (current_bfd != NULL)
 
            arch_info = bfd_get_arch_info (current_bfd);
 
        }
        }
 
 
      /* loop over the 64 bit symbol names */
      /* loop over the 64 bit symbol names */
      current_bfd = abfd->archive_head;
 
      if (current_bfd != NULL)
 
        arch_info = bfd_get_arch_info (current_bfd);
 
      i = 0;
      i = 0;
      while (current_bfd != NULL && i < orl_count)
      for (current_bfd = abfd->archive_head;
 
           current_bfd != NULL && i < orl_count;
 
           current_bfd = current_bfd->archive_next)
        {
        {
 
          arch_info = bfd_get_arch_info (current_bfd);
          while (map[i].u.abfd == current_bfd)
          while (map[i].u.abfd == current_bfd)
            {
            {
              if (arch_info->bits_per_address == 64)
              if (arch_info->bits_per_address == 64)
                {
                {
                  string_length = sprintf (st, "%s", *map[i].name);
                  string_length = sprintf (st, "%s", *map[i].name);
                  st += string_length + 1;
                  st += string_length + 1;
                }
                }
              i++;
              i++;
            }
            }
          current_bfd = current_bfd->archive_next;
 
          if (current_bfd != NULL)
 
            arch_info = bfd_get_arch_info (current_bfd);
 
        }
        }
 
 
      bfd_bwrite (symbol_table, symbol_table_size, abfd);
      bfd_bwrite (symbol_table, symbol_table_size, abfd);
 
 
      free (symbol_table);
      free (symbol_table);
Line 2078... Line 2122...
 
 
static bfd_boolean
static bfd_boolean
xcoff_write_archive_contents_old (abfd)
xcoff_write_archive_contents_old (abfd)
     bfd *abfd;
     bfd *abfd;
{
{
 
  struct archive_iterator iterator;
  struct xcoff_ar_file_hdr fhdr;
  struct xcoff_ar_file_hdr fhdr;
  bfd_size_type count;
  bfd_size_type count;
  bfd_size_type total_namlen;
  bfd_size_type total_namlen;
  file_ptr *offsets;
  file_ptr *offsets;
  bfd_boolean makemap;
  bfd_boolean makemap;
Line 2103... Line 2148...
  total_namlen = 0;
  total_namlen = 0;
  for (sub = abfd->archive_head; sub != NULL; sub = sub->archive_next)
  for (sub = abfd->archive_head; sub != NULL; sub = sub->archive_next)
    {
    {
      ++count;
      ++count;
      total_namlen += strlen (normalize_filename (sub)) + 1;
      total_namlen += strlen (normalize_filename (sub)) + 1;
    }
      if (sub->arelt_data == NULL)
  offsets = (file_ptr *) bfd_alloc (abfd, count * sizeof (file_ptr));
 
  if (offsets == NULL)
 
    return FALSE;
 
 
 
  if (bfd_seek (abfd, (file_ptr) SIZEOF_AR_FILE_HDR, SEEK_SET) != 0)
 
    return FALSE;
 
 
 
  makemap = bfd_has_map (abfd);
 
  hasobjects = FALSE;
 
  prevoff = 0;
 
  nextoff = SIZEOF_AR_FILE_HDR;
 
  for (sub = abfd->archive_head, i = 0;
 
       sub != NULL;
 
       sub = sub->archive_next, i++)
 
    {
 
      const char *name;
 
      bfd_size_type namlen;
 
      struct xcoff_ar_hdr *ahdrp;
 
      bfd_size_type remaining;
 
 
 
      if (makemap && ! hasobjects)
 
        {
        {
          if (bfd_check_format (sub, bfd_object))
          sub->arelt_data = bfd_zalloc (sub, sizeof (struct areltdata));
            hasobjects = TRUE;
          if (sub->arelt_data == NULL)
 
            return FALSE;
        }
        }
 
      if (arch_xhdr (sub) == NULL)
      name = normalize_filename (sub);
 
      namlen = strlen (name);
 
 
 
      if (sub->arelt_data != NULL)
 
        ahdrp = arch_xhdr (sub);
 
      else
 
        ahdrp = NULL;
 
 
 
      if (ahdrp == NULL)
 
        {
        {
 
          struct xcoff_ar_hdr *ahdrp;
          struct stat s;
          struct stat s;
 
 
          memset (&ahdr, 0, sizeof ahdr);
 
          ahdrp = &ahdr;
 
          if (stat (bfd_get_filename (sub), &s) != 0)
          if (stat (bfd_get_filename (sub), &s) != 0)
            {
            {
              bfd_set_error (bfd_error_system_call);
              bfd_set_error (bfd_error_system_call);
              return FALSE;
              return FALSE;
            }
            }
 
 
 
          ahdrp = bfd_zalloc (sub, sizeof (*ahdrp));
 
          if (ahdrp == NULL)
 
            return FALSE;
 
 
          sprintf (ahdrp->size, "%ld", (long) s.st_size);
          sprintf (ahdrp->size, "%ld", (long) s.st_size);
          sprintf (ahdrp->date, "%ld", (long) s.st_mtime);
          sprintf (ahdrp->date, "%ld", (long) s.st_mtime);
          sprintf (ahdrp->uid, "%ld", (long) s.st_uid);
          sprintf (ahdrp->uid, "%ld", (long) s.st_uid);
          sprintf (ahdrp->gid, "%ld", (long) s.st_gid);
          sprintf (ahdrp->gid, "%ld", (long) s.st_gid);
          sprintf (ahdrp->mode, "%o", (unsigned int) s.st_mode);
          sprintf (ahdrp->mode, "%o", (unsigned int) s.st_mode);
 
 
          if (sub->arelt_data == NULL)
          arch_eltdata (sub)->arch_header = (char *) ahdrp;
            {
 
              size = sizeof (struct areltdata);
 
              sub->arelt_data = bfd_alloc (sub, size);
 
              if (sub->arelt_data == NULL)
 
                return FALSE;
 
            }
 
 
 
          arch_eltdata (sub)->parsed_size = s.st_size;
          arch_eltdata (sub)->parsed_size = s.st_size;
        }
        }
 
    }
 
  offsets = (file_ptr *) bfd_alloc (abfd, count * sizeof (file_ptr));
 
  if (offsets == NULL)
 
    return FALSE;
 
 
      sprintf (ahdrp->prevoff, "%ld", (long) prevoff);
  if (bfd_seek (abfd, (file_ptr) SIZEOF_AR_FILE_HDR, SEEK_SET) != 0)
      sprintf (ahdrp->namlen, "%ld", (long) namlen);
    return FALSE;
 
 
      /* If the length of the name is odd, we write out the null byte
 
         after the name as well.  */
 
      namlen = (namlen + 1) &~ (bfd_size_type) 1;
 
 
 
      remaining = arelt_size (sub);
 
      size = (SIZEOF_AR_HDR
 
              + namlen
 
              + SXCOFFARFMAG
 
              + remaining);
 
 
 
      BFD_ASSERT (nextoff == bfd_tell (abfd));
 
 
 
      offsets[i] = nextoff;
  makemap = bfd_has_map (abfd);
 
  hasobjects = FALSE;
 
  prevoff = 0;
 
  for (archive_iterator_begin (&iterator, abfd), i = 0;
 
       archive_iterator_next (&iterator);
 
       i++)
 
    {
 
      bfd_size_type namlen;
 
      struct xcoff_ar_hdr *ahdrp;
 
 
      prevoff = nextoff;
      if (makemap && ! hasobjects)
      nextoff += size + (size & 1);
        {
 
          if (bfd_check_format (iterator.current.member, bfd_object))
 
            hasobjects = TRUE;
 
        }
 
 
      sprintf (ahdrp->nextoff, "%ld", (long) nextoff);
      ahdrp = arch_xhdr (iterator.current.member);
 
      sprintf (ahdrp->prevoff, "%ld", (long) prevoff);
 
      sprintf (ahdrp->namlen, "%ld", (long) iterator.current.namlen);
 
      sprintf (ahdrp->nextoff, "%ld", (long) iterator.next.offset);
 
 
      /* We need spaces, not null bytes, in the header.  */
      /* We need spaces, not null bytes, in the header.  */
      for (p = (char *) ahdrp; p < (char *) ahdrp + SIZEOF_AR_HDR; p++)
      for (p = (char *) ahdrp; p < (char *) ahdrp + SIZEOF_AR_HDR; p++)
        if (*p == '\0')
        if (*p == '\0')
          *p = ' ';
          *p = ' ';
 
 
      if ((bfd_bwrite ((PTR) ahdrp, (bfd_size_type) SIZEOF_AR_HDR, abfd)
      if (!do_pad (abfd, iterator.current.leading_padding))
           != SIZEOF_AR_HDR)
 
          || bfd_bwrite ((PTR) name, namlen, abfd) != namlen
 
          || bfd_bwrite ((PTR) XCOFFARFMAG, (bfd_size_type) SXCOFFARFMAG,
 
                         abfd) != SXCOFFARFMAG)
 
        return FALSE;
 
 
 
      if (bfd_seek (sub, (file_ptr) 0, SEEK_SET) != 0)
 
        return FALSE;
        return FALSE;
 
 
      if (! do_copy (abfd, sub))
      BFD_ASSERT (iterator.current.offset == bfd_tell (abfd));
 
      namlen = iterator.current.padded_namlen;
 
      if (bfd_bwrite (ahdrp, SIZEOF_AR_HDR, abfd) != SIZEOF_AR_HDR
 
          || bfd_bwrite (iterator.current.name, namlen, abfd) != namlen
 
          || bfd_bwrite (XCOFFARFMAG, SXCOFFARFMAG, abfd) != SXCOFFARFMAG
 
          || bfd_seek (iterator.current.member, 0, SEEK_SET) != 0
 
          || !do_copy (abfd, iterator.current.member)
 
          || !do_pad (abfd, iterator.current.trailing_padding))
        return FALSE;
        return FALSE;
 
 
      if (! do_pad (abfd, size & 1))
      offsets[i] = iterator.current.offset;
        return FALSE;
      prevoff = iterator.current.offset;
    }
    }
 
 
  sprintf (fhdr.lastmemoff, "%ld", (long) prevoff);
  sprintf (fhdr.lastmemoff, "%ld", (long) prevoff);
 
 
  /* Write out the member table.  */
  /* Write out the member table.  */
 
 
 
  nextoff = iterator.next.offset;
  BFD_ASSERT (nextoff == bfd_tell (abfd));
  BFD_ASSERT (nextoff == bfd_tell (abfd));
  sprintf (fhdr.memoff, "%ld", (long) nextoff);
  sprintf (fhdr.memoff, "%ld", (long) nextoff);
 
 
  memset (&ahdr, 0, sizeof ahdr);
  memset (&ahdr, 0, sizeof ahdr);
  sprintf (ahdr.size, "%ld", (long) (XCOFFARMAG_ELEMENT_SIZE
  sprintf (ahdr.size, "%ld", (long) (XCOFFARMAG_ELEMENT_SIZE
Line 2319... Line 2338...
  bfd_boolean makemap;
  bfd_boolean makemap;
  bfd_boolean hasobjects;
  bfd_boolean hasobjects;
  file_ptr prevoff, nextoff;
  file_ptr prevoff, nextoff;
  bfd *current_bfd;
  bfd *current_bfd;
  size_t i;
  size_t i;
  struct xcoff_ar_hdr_big *hdr, ahdr;
  struct xcoff_ar_hdr_big *hdr;
  bfd_size_type size;
  bfd_size_type size;
  char *member_table, *mt;
  char *member_table, *mt;
  bfd_vma member_table_size;
  bfd_vma member_table_size;
 
  struct archive_iterator iterator;
 
 
  memset (&fhdr, 0, SIZEOF_AR_FILE_HDR_BIG);
  memset (&fhdr, 0, SIZEOF_AR_FILE_HDR_BIG);
  memcpy (fhdr.magic, XCOFFARMAGBIG, SXCOFFARMAG);
  memcpy (fhdr.magic, XCOFFARMAGBIG, SXCOFFARMAG);
 
 
  if (bfd_seek (abfd, (file_ptr) SIZEOF_AR_FILE_HDR_BIG, SEEK_SET) != 0)
  if (bfd_seek (abfd, (file_ptr) SIZEOF_AR_FILE_HDR_BIG, SEEK_SET) != 0)
Line 2343... Line 2363...
 
 
      if (makemap
      if (makemap
          && ! hasobjects
          && ! hasobjects
          && bfd_check_format (current_bfd, bfd_object))
          && bfd_check_format (current_bfd, bfd_object))
        hasobjects = TRUE;
        hasobjects = TRUE;
    }
 
 
 
  offsets = NULL;
      if (current_bfd->arelt_data == NULL)
  if (count)
 
    {
    {
      offsets = (file_ptr *) bfd_malloc (count * sizeof (file_ptr));
          size = sizeof (struct areltdata);
      if (offsets == NULL)
          current_bfd->arelt_data = bfd_zalloc (current_bfd, size);
 
          if (current_bfd->arelt_data == NULL)
        return FALSE;
        return FALSE;
    }
    }
 
 
  prevoff = 0;
      if (arch_xhdr_big (current_bfd) == NULL)
  nextoff = SIZEOF_AR_FILE_HDR_BIG;
 
  for (current_bfd = abfd->archive_head, i = 0;
 
       current_bfd != NULL;
 
       current_bfd = current_bfd->archive_next, i++)
 
    {
    {
      const char *name;
 
      bfd_size_type namlen;
 
      struct xcoff_ar_hdr_big *ahdrp;
      struct xcoff_ar_hdr_big *ahdrp;
      bfd_size_type remaining;
 
 
 
      name = normalize_filename (current_bfd);
 
      namlen = strlen (name);
 
 
 
      if (current_bfd->arelt_data != NULL)
 
        ahdrp = arch_xhdr_big (current_bfd);
 
      else
 
        ahdrp = NULL;
 
 
 
      if (ahdrp == NULL)
 
        {
 
          struct stat s;
          struct stat s;
 
 
          ahdrp = &ahdr;
 
          /* XXX This should actually be a call to stat64 (at least on
          /* XXX This should actually be a call to stat64 (at least on
             32-bit machines).
             32-bit machines).
             XXX This call will fail if the original object is not found.  */
             XXX This call will fail if the original object is not found.  */
          if (stat (bfd_get_filename (current_bfd), &s) != 0)
          if (stat (bfd_get_filename (current_bfd), &s) != 0)
            {
            {
              bfd_set_error (bfd_error_system_call);
              bfd_set_error (bfd_error_system_call);
              return FALSE;
              return FALSE;
            }
            }
 
 
 
          ahdrp = bfd_zalloc (current_bfd, sizeof (*ahdrp));
 
          if (ahdrp == NULL)
 
            return FALSE;
 
 
          PRINT20 (ahdrp->size, s.st_size);
          PRINT20 (ahdrp->size, s.st_size);
          PRINT12 (ahdrp->date, s.st_mtime);
          PRINT12 (ahdrp->date, s.st_mtime);
          PRINT12 (ahdrp->uid,  s.st_uid);
          PRINT12 (ahdrp->uid,  s.st_uid);
          PRINT12 (ahdrp->gid,  s.st_gid);
          PRINT12 (ahdrp->gid,  s.st_gid);
          PRINT12_OCTAL (ahdrp->mode, s.st_mode);
          PRINT12_OCTAL (ahdrp->mode, s.st_mode);
 
 
          if (current_bfd->arelt_data == NULL)
          arch_eltdata (current_bfd)->arch_header = (char *) ahdrp;
            {
 
              size = sizeof (struct areltdata);
 
              current_bfd->arelt_data = bfd_alloc (current_bfd, size);
 
              if (current_bfd->arelt_data == NULL)
 
                return FALSE;
 
            }
 
 
 
          arch_eltdata (current_bfd)->parsed_size = s.st_size;
          arch_eltdata (current_bfd)->parsed_size = s.st_size;
        }
        }
 
    }
 
 
      PRINT20 (ahdrp->prevoff, prevoff);
  offsets = NULL;
      PRINT4 (ahdrp->namlen, namlen);
  if (count)
 
    {
      /* If the length of the name is odd, we write out the null byte
      offsets = (file_ptr *) bfd_malloc (count * sizeof (file_ptr));
         after the name as well.  */
      if (offsets == NULL)
      namlen = (namlen + 1) &~ (bfd_size_type) 1;
 
 
 
      remaining = arelt_size (current_bfd);
 
      size = (SIZEOF_AR_HDR_BIG
 
              + namlen
 
              + SXCOFFARFMAG
 
              + remaining);
 
 
 
      BFD_ASSERT (nextoff == bfd_tell (abfd));
 
 
 
      /* Check for xcoff shared objects.
 
         Their text section needs to be aligned wrt the archive file position.
 
         This requires extra padding before the archive header.  */
 
      if (! do_shared_object_padding (abfd, current_bfd, & nextoff,
 
                                      SIZEOF_AR_HDR_BIG + namlen
 
                                      + SXCOFFARFMAG))
 
        return FALSE;
        return FALSE;
 
    }
 
 
      offsets[i] = nextoff;
  prevoff = 0;
 
  for (archive_iterator_begin (&iterator, abfd), i = 0;
      prevoff = nextoff;
       archive_iterator_next (&iterator);
      nextoff += size + (size & 1);
       i++)
 
    {
      PRINT20 (ahdrp->nextoff, nextoff);
      bfd_size_type namlen;
 
      struct xcoff_ar_hdr_big *ahdrp;
 
 
      if ((bfd_bwrite ((PTR) ahdrp, (bfd_size_type) SIZEOF_AR_HDR_BIG, abfd)
      ahdrp = arch_xhdr_big (iterator.current.member);
           != SIZEOF_AR_HDR_BIG)
      PRINT20 (ahdrp->prevoff, prevoff);
          || bfd_bwrite ((PTR) name, (bfd_size_type) namlen, abfd) != namlen
      PRINT4 (ahdrp->namlen, iterator.current.namlen);
          || (bfd_bwrite ((PTR) XCOFFARFMAG, (bfd_size_type) SXCOFFARFMAG,
      PRINT20 (ahdrp->nextoff, iterator.next.offset);
                          abfd) != SXCOFFARFMAG))
 
        return FALSE;
 
 
 
      if (bfd_seek (current_bfd, (file_ptr) 0, SEEK_SET) != 0)
      if (!do_pad (abfd, iterator.current.leading_padding))
        return FALSE;
        return FALSE;
 
 
      if (! do_copy (abfd, current_bfd))
      BFD_ASSERT (iterator.current.offset == bfd_tell (abfd));
 
      namlen = iterator.current.padded_namlen;
 
      if (bfd_bwrite (ahdrp, SIZEOF_AR_HDR_BIG, abfd) != SIZEOF_AR_HDR_BIG
 
          || bfd_bwrite (iterator.current.name, namlen, abfd) != namlen
 
          || bfd_bwrite (XCOFFARFMAG, SXCOFFARFMAG, abfd) != SXCOFFARFMAG
 
          || bfd_seek (iterator.current.member, 0, SEEK_SET) != 0
 
          || !do_copy (abfd, iterator.current.member)
 
          || !do_pad (abfd, iterator.current.trailing_padding))
        return FALSE;
        return FALSE;
 
 
      if (! do_pad (abfd, size & 1))
      offsets[i] = iterator.current.offset;
        return FALSE;
      prevoff = iterator.current.offset;
    }
    }
 
 
  if (count)
  if (count)
    {
    {
      PRINT20 (fhdr.firstmemoff, offsets[0]);
      PRINT20 (fhdr.firstmemoff, offsets[0]);
Line 2477... Line 2466...
     0x0086                   offsets   [0x14 * counts]
     0x0086                   offsets   [0x14 * counts]
     0x0086 + 0x14 * counts   names     [??]
     0x0086 + 0x14 * counts   names     [??]
     ??                       pad to even bytes.
     ??                       pad to even bytes.
   */
   */
 
 
 
  nextoff = iterator.next.offset;
  BFD_ASSERT (nextoff == bfd_tell (abfd));
  BFD_ASSERT (nextoff == bfd_tell (abfd));
 
 
  member_table_size = (SIZEOF_AR_HDR_BIG
  member_table_size = (SIZEOF_AR_HDR_BIG
                       + SXCOFFARFMAG
                       + SXCOFFARFMAG
                       + XCOFFARMAGBIG_ELEMENT_SIZE
                       + XCOFFARMAGBIG_ELEMENT_SIZE
Line 2941... Line 2931...
     bfd_vma addend;
     bfd_vma addend;
     bfd_vma *relocation;
     bfd_vma *relocation;
     bfd_byte *contents;
     bfd_byte *contents;
{
{
  struct xcoff_link_hash_entry *h;
  struct xcoff_link_hash_entry *h;
 
  bfd_vma section_offset;
 
 
  if (0 > rel->r_symndx)
  if (0 > rel->r_symndx)
    return FALSE;
    return FALSE;
 
 
  h = obj_xcoff_sym_hashes (input_bfd)[rel->r_symndx];
  h = obj_xcoff_sym_hashes (input_bfd)[rel->r_symndx];
 
  section_offset = rel->r_vaddr - input_section->vma;
 
 
  /* If we see an R_BR or R_RBR reloc which is jumping to global
  /* If we see an R_BR or R_RBR reloc which is jumping to global
     linkage code, and it is followed by an appropriate cror nop
     linkage code, and it is followed by an appropriate cror nop
     instruction, we replace the cror with lwz r2,20(r1).  This
     instruction, we replace the cror with lwz r2,20(r1).  This
     restores the TOC after the glink code.  Contrariwise, if the
     restores the TOC after the glink code.  Contrariwise, if the
     call is followed by a lwz r2,20(r1), but the call is not
     call is followed by a lwz r2,20(r1), but the call is not
     going to global linkage code, we can replace the load with a
     going to global linkage code, we can replace the load with a
     cror.  */
     cror.  */
  if (NULL != h
  if (NULL != h
      && bfd_link_hash_defined == h->root.type
      && (bfd_link_hash_defined == h->root.type
      && rel->r_vaddr - input_section->vma + 8 <= input_section->size)
          || bfd_link_hash_defweak == h->root.type)
 
      && section_offset + 8 <= input_section->size)
    {
    {
      bfd_byte *pnext;
      bfd_byte *pnext;
      unsigned long next;
      unsigned long next;
 
 
      pnext = contents + (rel->r_vaddr - input_section->vma) + 4;
      pnext = contents + section_offset + 4;
      next = bfd_get_32 (input_bfd, pnext);
      next = bfd_get_32 (input_bfd, pnext);
 
 
      /* The _ptrgl function is magic.  It is used by the AIX
      /* The _ptrgl function is magic.  It is used by the AIX
         compiler to call a function through a pointer.  */
         compiler to call a function through a pointer.  */
      if (h->smclas == XMC_GL || strcmp (h->root.root.string, "._ptrgl") == 0)
      if (h->smclas == XMC_GL || strcmp (h->root.root.string, "._ptrgl") == 0)
        {
        {
          if (next == 0x4def7b82                        /* cror 15,15,15 */
          if (next == 0x4def7b82                        /* cror 15,15,15 */
              || next == 0x4ffffb82                     /* cror 31,31,31 */
              || next == 0x4ffffb82                     /* cror 31,31,31 */
              || next == 0x60000000)                    /* ori r0,r0,0 */
              || next == 0x60000000)                    /* ori r0,r0,0 */
            bfd_put_32 (input_bfd, 0x80410014, pnext);  /* lwz r1,20(r1) */
            bfd_put_32 (input_bfd, 0x80410014, pnext);  /* lwz r2,20(r1) */
 
 
        }
        }
      else
      else
        {
        {
          if (next == 0x80410014)                       /* lwz r1,20(r1) */
          if (next == 0x80410014)                       /* lwz r2,20(r1) */
            bfd_put_32 (input_bfd, 0x60000000, pnext);  /* ori r0,r0,0 */
            bfd_put_32 (input_bfd, 0x60000000, pnext);  /* ori r0,r0,0 */
        }
        }
    }
    }
  else if (NULL != h && bfd_link_hash_undefined == h->root.type)
  else if (NULL != h && bfd_link_hash_undefined == h->root.type)
    {
    {
Line 2992... Line 2985...
         overflow checking. */
         overflow checking. */
 
 
      howto->complain_on_overflow = complain_overflow_dont;
      howto->complain_on_overflow = complain_overflow_dont;
    }
    }
 
 
  howto->pc_relative = TRUE;
  /* The original PC-relative relocation is biased by -r_vaddr, so adding
 
     the value below will give the absolute target address.  */
 
  *relocation = val + addend + rel->r_vaddr;
 
 
  howto->src_mask &= ~3;
  howto->src_mask &= ~3;
  howto->dst_mask = howto->src_mask;
  howto->dst_mask = howto->src_mask;
 
 
  /* A PC relative reloc includes the section address.  */
  if (h != NULL
  addend += input_section->vma;
      && (h->root.type == bfd_link_hash_defined
 
          || h->root.type == bfd_link_hash_defweak)
 
      && bfd_is_abs_section (h->root.u.def.section)
 
      && section_offset + 4 <= input_section->size)
 
    {
 
      bfd_byte *ptr;
 
      bfd_vma insn;
 
 
  *relocation = val + addend;
      /* Turn the relative branch into an absolute one by setting the
 
         AA bit.  */
 
      ptr = contents + section_offset;
 
      insn = bfd_get_32 (input_bfd, ptr);
 
      insn |= 2;
 
      bfd_put_32 (input_bfd, insn, ptr);
 
 
 
      /* Make the howto absolute too.  */
 
      howto->pc_relative = FALSE;
 
      howto->complain_on_overflow = complain_overflow_bitfield;
 
    }
 
  else
 
    {
 
      /* Use a PC-relative howto and subtract the instruction's address
 
         from the target address we calculated above.  */
 
      howto->pc_relative = TRUE;
  *relocation -= (input_section->output_section->vma
  *relocation -= (input_section->output_section->vma
                  + input_section->output_offset);
                      + input_section->output_offset
 
                      + section_offset);
 
    }
  return TRUE;
  return TRUE;
}
}
 
 
bfd_boolean
bfd_boolean
xcoff_reloc_type_crel (input_bfd, input_section, output_bfd, rel, sym, howto,
xcoff_reloc_type_crel (input_bfd, input_section, output_bfd, rel, sym, howto,
Line 3317... Line 3336...
   be modified to become an absolute call.  The PowerOpen
   be modified to become an absolute call.  The PowerOpen
   ABI does not define this relocation type.
   ABI does not define this relocation type.
 
 
   R_RBR:
   R_RBR:
   A relative branch which may be modified to become an
   A relative branch which may be modified to become an
   absolute branch.  FIXME: We don't implement this,
   absolute branch.
   although we should for symbols of storage mapping class
 
   XMC_XO.
 
 
 
   R_RL:
   R_RL:
   The PowerPC AIX ABI describes this as a load which may be
   The PowerPC AIX ABI describes this as a load which may be
   changed to a load address.  The PowerOpen ABI says this
   changed to a load address.  The PowerOpen ABI says this
   is the same as case R_POS.
   is the same as case R_POS.
Line 3416... Line 3433...
                       + sym->n_value
                       + sym->n_value
                       - sec->vma);
                       - sec->vma);
            }
            }
          else
          else
            {
            {
 
              if (info->unresolved_syms_in_objects != RM_IGNORE
 
                  && (h->flags & XCOFF_WAS_UNDEFINED) != 0)
 
                {
 
                  if (! ((*info->callbacks->undefined_symbol)
 
                         (info, h->root.root.string,
 
                          input_bfd, input_section,
 
                          rel->r_vaddr - input_section->vma,
 
                          (info->unresolved_syms_in_objects
 
                           == RM_GENERATE_ERROR))))
 
                    return FALSE;
 
                }
              if (h->root.type == bfd_link_hash_defined
              if (h->root.type == bfd_link_hash_defined
                  || h->root.type == bfd_link_hash_defweak)
                  || h->root.type == bfd_link_hash_defweak)
                {
                {
                  sec = h->root.u.def.section;
                  sec = h->root.u.def.section;
                  val = (h->root.u.def.value
                  val = (h->root.u.def.value
Line 3431... Line 3459...
                  sec = h->root.u.c.p->section;
                  sec = h->root.u.c.p->section;
                  val = (sec->output_section->vma
                  val = (sec->output_section->vma
                         + sec->output_offset);
                         + sec->output_offset);
 
 
                }
                }
              else if ((0 == (h->flags & (XCOFF_DEF_DYNAMIC | XCOFF_IMPORT)))
              else
                       && ! info->relocatable)
 
                {
                {
                  if (! ((*info->callbacks->undefined_symbol)
                  BFD_ASSERT (info->relocatable
                         (info, h->root.root.string, input_bfd, input_section,
                              || (info->static_link
                          rel->r_vaddr - input_section->vma, TRUE)))
                                  && (h->flags & XCOFF_WAS_UNDEFINED) != 0)
                    return FALSE;
                              || (h->flags & XCOFF_DEF_DYNAMIC) != 0
 
                              || (h->flags & XCOFF_IMPORT) != 0);
                  /* Don't try to process the reloc.  It can't help, and
 
                     it may generate another error.  */
 
                  continue;
 
                }
                }
            }
            }
        }
        }
 
 
      if (rel->r_type >= XCOFF_MAX_CALCULATE_RELOCATION
      if (rel->r_type >= XCOFF_MAX_CALCULATE_RELOCATION
Line 4005... Line 4029...
      AUXESZ,
      AUXESZ,
      RELSZ,
      RELSZ,
      LINESZ,
      LINESZ,
      FILNMLEN,
      FILNMLEN,
      TRUE,                     /* _bfd_coff_long_filenames */
      TRUE,                     /* _bfd_coff_long_filenames */
      FALSE,                    /* _bfd_coff_long_section_names */
      XCOFF_NO_LONG_SECTION_NAMES,  /* _bfd_coff_long_section_names */
      3,                        /* _bfd_coff_default_section_alignment_power */
      3,                        /* _bfd_coff_default_section_alignment_power */
      FALSE,                    /* _bfd_coff_force_symnames_in_strings */
      FALSE,                    /* _bfd_coff_force_symnames_in_strings */
      2,                        /* _bfd_coff_debug_string_prefix_length */
      2,                        /* _bfd_coff_debug_string_prefix_length */
      coff_swap_filehdr_in,
      coff_swap_filehdr_in,
      coff_swap_aouthdr_in,
      coff_swap_aouthdr_in,
Line 4032... Line 4056...
      xcoff_ppc_relocate_section,
      xcoff_ppc_relocate_section,
      coff_rtype_to_howto,
      coff_rtype_to_howto,
      NULL,                     /* _bfd_coff_adjust_symndx */
      NULL,                     /* _bfd_coff_adjust_symndx */
      _bfd_generic_link_add_one_symbol,
      _bfd_generic_link_add_one_symbol,
      coff_link_output_has_begun,
      coff_link_output_has_begun,
      coff_final_link_postscript
      coff_final_link_postscript,
 
      NULL                      /* print_pdata.  */
    },
    },
 
 
    0x01DF,                     /* magic number */
    0x01DF,                     /* magic number */
    bfd_arch_rs6000,
    bfd_arch_rs6000,
    bfd_mach_rs6k,
    bfd_mach_rs6k,
Line 4212... Line 4237...
    bfd_generic_gc_sections,
    bfd_generic_gc_sections,
    bfd_generic_merge_sections,
    bfd_generic_merge_sections,
    bfd_generic_is_group_section,
    bfd_generic_is_group_section,
    bfd_generic_discard_group,
    bfd_generic_discard_group,
    _bfd_generic_section_already_linked,
    _bfd_generic_section_already_linked,
 
    _bfd_xcoff_define_common_symbol,
 
 
    /* Dynamic */
    /* Dynamic */
    _bfd_xcoff_get_dynamic_symtab_upper_bound,
    _bfd_xcoff_get_dynamic_symtab_upper_bound,
    _bfd_xcoff_canonicalize_dynamic_symtab,
    _bfd_xcoff_canonicalize_dynamic_symtab,
    _bfd_nodynamic_get_synthetic_symtab,
    _bfd_nodynamic_get_synthetic_symtab,
Line 4256... Line 4282...
      AUXESZ,
      AUXESZ,
      RELSZ,
      RELSZ,
      LINESZ,
      LINESZ,
      FILNMLEN,
      FILNMLEN,
      TRUE,                     /* _bfd_coff_long_filenames */
      TRUE,                     /* _bfd_coff_long_filenames */
      FALSE,                    /* _bfd_coff_long_section_names */
      XCOFF_NO_LONG_SECTION_NAMES,  /* _bfd_coff_long_section_names */
      3,                        /* _bfd_coff_default_section_alignment_power */
      3,                        /* _bfd_coff_default_section_alignment_power */
      FALSE,                    /* _bfd_coff_force_symnames_in_strings */
      FALSE,                    /* _bfd_coff_force_symnames_in_strings */
      2,                        /* _bfd_coff_debug_string_prefix_length */
      2,                        /* _bfd_coff_debug_string_prefix_length */
      coff_swap_filehdr_in,
      coff_swap_filehdr_in,
      coff_swap_aouthdr_in,
      coff_swap_aouthdr_in,
Line 4283... Line 4309...
      xcoff_ppc_relocate_section,
      xcoff_ppc_relocate_section,
      coff_rtype_to_howto,
      coff_rtype_to_howto,
      NULL,                     /* _bfd_coff_adjust_symndx */
      NULL,                     /* _bfd_coff_adjust_symndx */
      _bfd_generic_link_add_one_symbol,
      _bfd_generic_link_add_one_symbol,
      coff_link_output_has_begun,
      coff_link_output_has_begun,
      coff_final_link_postscript
      coff_final_link_postscript,
 
      NULL                      /* print_pdata.  */
    },
    },
 
 
    0x01DF,                     /* magic number */
    0x01DF,                     /* magic number */
    bfd_arch_powerpc,
    bfd_arch_powerpc,
    bfd_mach_ppc,
    bfd_mach_ppc,
Line 4463... Line 4490...
    bfd_generic_gc_sections,
    bfd_generic_gc_sections,
    bfd_generic_merge_sections,
    bfd_generic_merge_sections,
    bfd_generic_is_group_section,
    bfd_generic_is_group_section,
    bfd_generic_discard_group,
    bfd_generic_discard_group,
    _bfd_generic_section_already_linked,
    _bfd_generic_section_already_linked,
 
    _bfd_xcoff_define_common_symbol,
 
 
    /* Dynamic */
    /* Dynamic */
    _bfd_xcoff_get_dynamic_symtab_upper_bound,
    _bfd_xcoff_get_dynamic_symtab_upper_bound,
    _bfd_xcoff_canonicalize_dynamic_symtab,
    _bfd_xcoff_canonicalize_dynamic_symtab,
    _bfd_nodynamic_get_synthetic_symtab,
    _bfd_nodynamic_get_synthetic_symtab,

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.