This is the mail archive of the binutils@sources.redhat.com mailing list for the binutils project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

PATCH, XCOFF <bigaf> archives


This patch fixes writing <bigaf> archives.    Previously only writing
<aiaff> was supported.  This patch makes <bigaf> the default.    It has
been tested on Aix 4.3.3 and  cross built on Linux x86.

Tom

--
Tom Rix
GCC Engineer
trix@redhat.com


2001-12-27  Tom Rix  <trix@redhat.com>
	
	* coff-rs6000.c (xcoff_generate_rtinit): Clean data_buffer alloc/free.
	* coff64-rs6000.c (xcoff64_generate_rtinit): Same.
	(xcoff_write_archive_contents_big): Rewrite.
	(xcoff_write_armap_big): Rewrite.
	(xcoff_write_one_armap_big): Delete.
	* libxcoff.h : Clean up. 

diff -rcp src-old/bfd/coff-rs6000.c src/bfd/coff-rs6000.c
*** src-old/bfd/coff-rs6000.c	Sun Dec 23 09:45:28 2001
--- src/bfd/coff-rs6000.c	Fri Dec 28 18:26:08 2001
*************** extern int rs6000coff_core_file_failing_
*** 113,121 ****
  static const char *normalize_filename PARAMS ((bfd *));
  static boolean xcoff_write_armap_old
    PARAMS ((bfd *, unsigned int, struct orl *, unsigned int, int));
- static boolean xcoff_write_one_armap_big
-   PARAMS ((bfd *, struct orl *, unsigned int, unsigned int, unsigned int,
- 	   int, const char *, char *));
  static boolean xcoff_write_armap_big
    PARAMS ((bfd *, unsigned int, struct orl *, unsigned int, int));
  static boolean xcoff_write_archive_contents_old PARAMS ((bfd *));
--- 113,118 ----
*************** static bfd_vma xcoff_loader_symbol_offse
*** 146,151 ****
--- 143,151 ----
    PARAMS ((bfd *, struct internal_ldhdr *));
  static bfd_vma xcoff_loader_reloc_offset
    PARAMS ((bfd *, struct internal_ldhdr *));
+ static boolean xcoff_generate_rtinit 
+   PARAMS((bfd *, const char *, const char *));
+ 
  
  /* We use our own tdata type.  Its first field is the COFF tdata type,
     so the COFF routines are compatible.  */
*************** xcoff_write_armap_old (abfd, elength, ma
*** 1462,1468 ****
    memset (&hdr, 0, sizeof hdr);
    sprintf (hdr.size, "%ld", (long) (4 + orl_count * 4 + stridx));
    sprintf (hdr.nextoff, "%d", 0);
!   memcpy (hdr.prevoff, xcoff_ardata (abfd)->memoff, 12);
    sprintf (hdr.date, "%d", 0);
    sprintf (hdr.uid, "%d", 0);
    sprintf (hdr.gid, "%d", 0);
--- 1462,1468 ----
    memset (&hdr, 0, sizeof hdr);
    sprintf (hdr.size, "%ld", (long) (4 + orl_count * 4 + stridx));
    sprintf (hdr.nextoff, "%d", 0);
!   memcpy (hdr.prevoff, xcoff_ardata (abfd)->memoff, XCOFFARMAG_ELEMENT_SIZE);
    sprintf (hdr.date, "%d", 0);
    sprintf (hdr.uid, "%d", 0);
    sprintf (hdr.gid, "%d", 0);
*************** xcoff_write_armap_old (abfd, elength, ma
*** 1531,1715 ****
    return true;
  }
  
! /* Write a single armap in the big format.  */
  
  static boolean
! xcoff_write_one_armap_big (abfd, map, orl_count, orl_ccount, stridx, bits64,
! 			   prevoff, nextoff)
       bfd *abfd;
       struct orl *map;
       unsigned int orl_count;
!      unsigned int orl_ccount;
!      unsigned int stridx;
!      int bits64;
!      const char *prevoff;
!      char *nextoff;
  {
!   struct xcoff_ar_hdr_big hdr;
!   char *p;
!   unsigned char buf[4];
!   bfd *sub;
!   file_ptr fileoff;
    const bfd_arch_info_type *arch_info = NULL;
!   bfd *object_bfd;
!   unsigned int i;
  
!   memset (&hdr, 0, sizeof hdr);
!   /* XXX This call actually should use %lld (at least on 32-bit
!      machines) since the fields's width is 20 and there numbers with
!      more than 32 bits can be represented.  */
!   sprintf (hdr.size, "%ld", (long) (4 + orl_ccount * 4 + stridx));
!   if (bits64)
!     {
!       sprintf (hdr.nextoff, "%d", 0);
!     }
!   else
      {
!       /* Do explict cast to long to remove compiler warning.  */
!       sprintf (hdr.nextoff, "%ld", (strtol (prevoff, (char **) NULL, 10)
! 				    + (long) (4 + orl_ccount * 4 + stridx)));
!     }
! 
!   memcpy (hdr.prevoff, prevoff, sizeof (hdr.prevoff));
!   sprintf (hdr.date, "%d", 0);
!   sprintf (hdr.uid, "%d", 0);
!   sprintf (hdr.gid, "%d", 0);
!   sprintf (hdr.mode, "%d", 0);
!   sprintf (hdr.namlen, "%d", 0);
  
!   /* We need spaces, not null bytes, in the header.  */
!   for (p = (char *) &hdr; p < (char *) &hdr + SIZEOF_AR_HDR_BIG; p++)
!     if (*p == '\0')
!       *p = ' ';
  
!   memcpy (nextoff, hdr.nextoff, sizeof (hdr.nextoff));
  
!   if ((bfd_bwrite ((PTR) &hdr, (bfd_size_type) SIZEOF_AR_HDR_BIG, abfd)
!        != SIZEOF_AR_HDR_BIG)
!       || (bfd_bwrite (XCOFFARFMAG, (bfd_size_type) SXCOFFARFMAG, abfd)
! 	  != SXCOFFARFMAG))
!     return false;
  
!   H_PUT_32 (abfd, orl_ccount, buf);
!   if (bfd_bwrite (buf, (bfd_size_type) 4, abfd) != 4)
!     return false;
  
!   sub = abfd->archive_head;
!   fileoff = SIZEOF_AR_FILE_HDR_BIG;
!   i = 0;
!   while (sub != NULL && i < orl_count)
!     {
!       size_t namlen;
  
!       if ((bfd_arch_bits_per_address (map[i].u.abfd) == 64) == bits64)
! 	while (map[i].u.abfd == sub)
! 	  {
! 	    H_PUT_32 (abfd, fileoff, buf);
! 	    if (bfd_bwrite (buf, (bfd_size_type) 4, abfd) != 4)
! 	      return false;
! 	    i++;
! 	  }
        else
! 	while (map[i].u.abfd == sub)
! 	  i++;
! 
!       namlen = strlen (normalize_filename (sub));
!       namlen = (namlen + 1) &~ (size_t) 1;
!       fileoff += (SIZEOF_AR_HDR_BIG
! 		  + namlen
! 		  + SXCOFFARFMAG
! 		  + arelt_size (sub));
!       fileoff = (fileoff + 1) &~ 1;
!       sub = sub->next;
!     }
! 
!   object_bfd = NULL;
!   for (i = 0; i < orl_count; i++)
!     {
!       const char *name;
!       size_t namlen;
!       bfd *ob = map[i].u.abfd;
  
!       if (ob != object_bfd)
! 	arch_info = bfd_get_arch_info (ob);
!       if ((arch_info->bits_per_address == 64) != bits64)
! 	continue;
  
!       name = *map[i].name;
!       namlen = strlen (name);
!       if (bfd_bwrite (name, (bfd_size_type) (namlen + 1), abfd) != namlen + 1)
! 	return false;
!     }
  
!   if ((stridx & 1) != 0)
!     {
!       char b;
  
!       b = '\0';
!       if (bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1)
! 	return false;
      }
! 
!   return true;
! }
! 
! static boolean
! xcoff_write_armap_big (abfd, elength, map, orl_count, stridx)
!      bfd *abfd;
!      unsigned int elength ATTRIBUTE_UNUSED;
!      struct orl *map;
!      unsigned int orl_count;
!      int stridx;
! {
!   unsigned int i;
!   unsigned int orl_count_32, orl_count_64;
!   unsigned int stridx_32, stridx_64;
!   const bfd_arch_info_type *arch_info = NULL;
!   bfd *object_bfd;
! 
!   /* First, we look through the symbols and work out which are
!      from 32-bit objects and which from 64-bit ones.  */
!   orl_count_32 = 0;
!   orl_count_64 = 0;
!   stridx_32 = 0;
!   stridx_64 = 0;
!   object_bfd = NULL;
!   for (i = 0; i < orl_count; i++)
      {
!       bfd *ob = map[i].u.abfd;
!       unsigned int len;
!       if (ob != object_bfd)
! 	arch_info = bfd_get_arch_info (ob);
!       len = strlen (*map[i].name) + 1;
!       if (arch_info->bits_per_address == 64)
  	{
! 	  orl_count_64++;
! 	  stridx_64 += len;
! 	}
!       else
  	{
! 	  orl_count_32++;
! 	  stridx_32 += len;
  	}
-       object_bfd = ob;
-     }
-   /* A quick sanity check... */
-   BFD_ASSERT (orl_count_64 + orl_count_32 == orl_count);
-   /* Explicit cast to int for compiler.  */
-   BFD_ASSERT ((int)(stridx_64 + stridx_32) == stridx);
  
!   /* Now write out each map.  */
!   if (! xcoff_write_one_armap_big (abfd, map, orl_count, orl_count_32,
! 				   stridx_32, false,
! 				   xcoff_ardata_big (abfd)->memoff,
! 				   xcoff_ardata_big (abfd)->symoff))
!     return false;
!   if (! xcoff_write_one_armap_big (abfd, map, orl_count, orl_count_64,
! 				   stridx_64, true,
! 				   xcoff_ardata_big (abfd)->symoff,
! 				   xcoff_ardata_big (abfd)->symoff64))
!     return false;
  
    return true;
  }
  
--- 1531,1844 ----
    return true;
  }
  
! static char buff20[XCOFFARMAGBIG_ELEMENT_SIZE + 1];
! #define FMT20  "%-20lld"
! #define FMT12  "%-12d"
! #define FMT12_OCTAL  "%-12o"
! #define FMT4  "%-4d"
! #define PRINT20(d, v) \
!   sprintf (buff20, FMT20, (long long)(v)), \
!   memcpy ((void *) (d), buff20, 20)
! 
! #define PRINT12(d, v) \
!   sprintf (buff20, FMT12, (int)(v)), \
!   memcpy ((void *) (d), buff20, 12) 
! 
! #define PRINT12_OCTAL(d, v) \
!   sprintf (buff20, FMT12_OCTAL, (unsigned int)(v)), \
!   memcpy ((void *) (d), buff20, 12)
! 
! #define PRINT4(d, v) \
!   sprintf (buff20, FMT4, (int)(v)), \
!   memcpy ((void *) (d), buff20, 4) 
! 
! #define READ20(d, v) \
!   buff20[20] = 0, \
!   memcpy (buff20, (d), 20), \
!   (v) = strtoull (buff20, (char **) NULL, 10)
  
  static boolean
! xcoff_write_armap_big (abfd, elength, map, orl_count, stridx)
       bfd *abfd;
+      unsigned int elength ATTRIBUTE_UNUSED;
       struct orl *map;
       unsigned int orl_count;
!      int stridx;
  {
!   struct xcoff_ar_file_hdr_big *fhdr;
!   bfd_vma i, sym_32, sym_64, str_32, str_64;
    const bfd_arch_info_type *arch_info = NULL;
!   bfd *current_bfd;
!   size_t string_length;
!   ufile_ptr nextoff, prevoff;
!   
!   /* First, we look through the symbols and work out which are
!      from 32-bit objects and which from 64-bit ones.  */
!   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;
!     while (current_bfd != NULL && i < orl_count)
      {
!       while (map[i].u.abfd == current_bfd)
! 	{
! 	  string_length = strlen (*map[i].name) + 1;
  
! 	  if (arch_info->bits_per_address == 64)
! 	    {
! 	      sym_64++;
! 	      str_64 += string_length;
! 	    }
! 	  else
! 	    {
! 	      sym_32++;
! 	      str_32 += string_length;
! 	    }
! 	  i++;
! 	}
!       current_bfd = current_bfd->next;
!       if (current_bfd != NULL)
! 	arch_info = bfd_get_arch_info (current_bfd);
!     }
  
!   /* A quick sanity check... */
!   BFD_ASSERT (sym_64 + sym_32 == orl_count);
!   /* Explicit cast to int for compiler.  */
!   BFD_ASSERT ((int)(str_64 + str_32) == stridx);
  
!   fhdr = xcoff_ardata_big (abfd);
  
!   /* xcoff_write_archive_contents_big passes nextoff in symoff. */
!   READ20 (fhdr->memoff, prevoff);
!   READ20 (fhdr->symoff, nextoff);
  
!   BFD_ASSERT (nextoff == bfd_tell (abfd));
  
!   /* Write out the symbol table.  
!      Layout : 
!      
!      standard big archive header
!      0x0000                   ar_size   [0x14]
!      0x0014                   ar_nxtmem [0x14]
!      0x0028                   ar_prvmem [0x14]
!      0x003C                   ar_date   [0x0C]
!      0x0048                   ar_uid    [0x0C]
!      0x0054                   ar_gid    [0x0C]
!      0x0060                   ar_mod    [0x0C]
!      0x006C                   ar_namelen[0x04]
!      0x0070                   ar_fmag   [SXCOFFARFMAG]
!      
!      Symbol table 
!      0x0072                   num_syms  [0x08], binary
!      0x0078                   offsets   [0x08 * num_syms], binary
!      0x0086 + 0x08 * num_syms names     [??]
!      ??                       pad to even bytes.
!   */
! 
!   if (sym_32) 
!     {
!       struct xcoff_ar_hdr_big *hdr;
!       bfd_byte *symbol_table;
!       bfd_byte *st;
!       file_ptr fileoff;
! 
!       bfd_vma symbol_table_size = 
! 	SIZEOF_AR_HDR_BIG
! 	+ SXCOFFARFMAG
! 	+ 8 
! 	+ 8 * sym_32 
! 	+ str_32 + (str_32 & 1);
! 
!       symbol_table = NULL;
!       symbol_table = (bfd_byte *) bfd_malloc (symbol_table_size);
!       if (symbol_table == NULL)
! 	return false;
!       memset (symbol_table, 0, symbol_table_size);
! 
!       hdr = (struct xcoff_ar_hdr_big *) symbol_table;
! 	
!       PRINT20 (hdr->size, 8 + 8 * sym_32 + str_32 + (str_32 & 1));
! 	
!       if (sym_64)
! 	PRINT20 (hdr->nextoff, nextoff + symbol_table_size);
        else
! 	PRINT20 (hdr->nextoff, 0);
  
!       PRINT20 (hdr->prevoff, prevoff);
!       PRINT12 (hdr->date, 0);
!       PRINT12 (hdr->uid, 0);
!       PRINT12 (hdr->gid, 0);
!       PRINT12 (hdr->mode, 0);
!       PRINT4 (hdr->namlen, 0) ;
! 
!       st = symbol_table + SIZEOF_AR_HDR_BIG;
!       memcpy (st, XCOFFARFMAG, SXCOFFARFMAG);
!       st += SXCOFFARFMAG;
! 
!       bfd_h_put_64 (abfd, sym_32, st);
!       st += 8;
!       
!       /* 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;
!       while (current_bfd != NULL && i < orl_count)
! 	{
! 	  while (map[i].u.abfd == current_bfd)
! 	    {
! 	      if (arch_info->bits_per_address == 32)
! 		{
! 		  bfd_h_put_64 (abfd, fileoff, st);
! 		  st += 8;
! 		}
! 	      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->next;
! 	  if (current_bfd != NULL)
! 	    arch_info = bfd_get_arch_info (current_bfd);
! 	}
! 
!       /* 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;
!       while (current_bfd != NULL && i < orl_count)
! 	{
! 	  while (map[i].u.abfd == current_bfd)
! 	    {
! 	      if (arch_info->bits_per_address == 32)
! 		{
! 		  string_length = sprintf (st, "%s", *map[i].name);
! 		  st += string_length + 1;
! 		}
! 	      i++;
! 	    }
! 	  current_bfd = current_bfd->next;
! 	  if (current_bfd != NULL)
! 	    arch_info = bfd_get_arch_info (current_bfd);
! 	}
  
!       bfd_bwrite (symbol_table, symbol_table_size, abfd);
  
!       free (symbol_table);
!       symbol_table = NULL;
  
!       prevoff = nextoff;
!       nextoff = nextoff + symbol_table_size;
      }
!   else 
!     PRINT20 (fhdr->symoff, 0);
!   
!   if (sym_64) 
      {
!       struct xcoff_ar_hdr_big *hdr;
!       bfd_byte *symbol_table;
!       bfd_byte *st;
!       file_ptr fileoff;
! 
!       bfd_vma symbol_table_size = 
! 	SIZEOF_AR_HDR_BIG
! 	+ SXCOFFARFMAG
! 	+ 8 
! 	+ 8 * sym_64 
! 	+ str_64 + (str_64 & 1);
! 
!       symbol_table = NULL;
!       symbol_table = (bfd_byte *) bfd_malloc (symbol_table_size);
!       if (symbol_table == NULL)
! 	return false;
!       memset (symbol_table, 0, symbol_table_size);
! 
!       hdr = (struct xcoff_ar_hdr_big *) symbol_table;
! 
!       PRINT20 (hdr->size, 8 + 8 * sym_64 + str_64 + (str_64 & 1));
!       PRINT20 (hdr->nextoff, 0);
!       PRINT20 (hdr->prevoff, prevoff);
!       PRINT12 (hdr->date, 0);
!       PRINT12 (hdr->uid, 0);
!       PRINT12 (hdr->gid, 0);
!       PRINT12 (hdr->mode, 0);
!       PRINT4 (hdr->namlen, 0);
! 
!       st = symbol_table + SIZEOF_AR_HDR_BIG;
!       memcpy (st, XCOFFARFMAG, SXCOFFARFMAG);
!       st += SXCOFFARFMAG;
! 
!       bfd_h_put_64 (abfd, sym_64, st);
!       st += 8;
!       
!       /* 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;
!       while (current_bfd != NULL && i < orl_count)
  	{
! 	  while (map[i].u.abfd == current_bfd)
! 	    {
! 	      if (arch_info->bits_per_address == 64)
! 		{
! 		  bfd_h_put_64 (abfd, fileoff, st);
! 		  st += 8;
! 		}
! 	      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->next;
! 	  if (current_bfd != NULL)
! 	    arch_info = bfd_get_arch_info (current_bfd);
! 	}
! 
!       /* 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;
!       while (current_bfd != NULL && i < orl_count)
  	{
! 	  while (map[i].u.abfd == current_bfd)
! 	    {
! 	      if (arch_info->bits_per_address == 64)
! 		{
! 		  string_length = sprintf (st, "%s", *map[i].name);
! 		  st += string_length + 1;
! 		}
! 	      i++;
! 	    }
! 	  current_bfd = current_bfd->next;
! 	  if (current_bfd != NULL)
! 	    arch_info = bfd_get_arch_info (current_bfd);
  	}
  
!       bfd_bwrite (symbol_table, symbol_table_size, abfd);
  
+       free (symbol_table);
+       symbol_table = NULL;
+ 
+       PRINT20 (fhdr->symoff64, nextoff);
+     }
+   else 
+     PRINT20 (fhdr->symoff64, 0);
+   
    return true;
  }
  
*************** xcoff_write_archive_contents_old (abfd)
*** 1746,1752 ****
    struct xcoff_ar_hdr ahdr;
    bfd_size_type size;
    char *p;
!   char decbuf[13];
  
    memset (&fhdr, 0, sizeof fhdr);
    strncpy (fhdr.magic, XCOFFARMAG, SXCOFFARMAG);
--- 1875,1881 ----
    struct xcoff_ar_hdr ahdr;
    bfd_size_type size;
    char *p;
!   char decbuf[XCOFFARMAG_ELEMENT_SIZE + 1];
  
    memset (&fhdr, 0, sizeof fhdr);
    strncpy (fhdr.magic, XCOFFARMAG, SXCOFFARMAG);
*************** xcoff_write_archive_contents_old (abfd)
*** 1889,1895 ****
    sprintf (fhdr.memoff, "%ld", (long) nextoff);
  
    memset (&ahdr, 0, sizeof ahdr);
!   sprintf (ahdr.size, "%ld", (long) (12 + count * 12 + total_namlen));
    sprintf (ahdr.prevoff, "%ld", (long) prevoff);
    sprintf (ahdr.date, "%d", 0);
    sprintf (ahdr.uid, "%d", 0);
--- 2018,2026 ----
    sprintf (fhdr.memoff, "%ld", (long) nextoff);
  
    memset (&ahdr, 0, sizeof ahdr);
!   sprintf (ahdr.size, "%ld", (long) (XCOFFARMAG_ELEMENT_SIZE + 
! 				     count * XCOFFARMAG_ELEMENT_SIZE + 
! 				     total_namlen));
    sprintf (ahdr.prevoff, "%ld", (long) prevoff);
    sprintf (ahdr.date, "%d", 0);
    sprintf (ahdr.uid, "%d", 0);
*************** xcoff_write_archive_contents_old (abfd)
*** 1898,1905 ****
    sprintf (ahdr.namlen, "%d", 0);
  
    size = (SIZEOF_AR_HDR
! 	  + 12
! 	  + count * 12
  	  + total_namlen
  	  + SXCOFFARFMAG);
  
--- 2029,2036 ----
    sprintf (ahdr.namlen, "%d", 0);
  
    size = (SIZEOF_AR_HDR
! 	  + XCOFFARMAG_ELEMENT_SIZE
! 	  + count * XCOFFARMAG_ELEMENT_SIZE
  	  + total_namlen
  	  + SXCOFFARFMAG);
  
*************** xcoff_write_archive_contents_old (abfd)
*** 1923,1934 ****
      return false;
  
    sprintf (decbuf, "%-12ld", (long) count);
!   if (bfd_bwrite ((PTR) decbuf, (bfd_size_type) 12, abfd) != 12)
      return false;
    for (i = 0; i < (size_t) count; i++)
      {
        sprintf (decbuf, "%-12ld", (long) offsets[i]);
!       if (bfd_bwrite ((PTR) decbuf, (bfd_size_type) 12, abfd) != 12)
  	return false;
      }
    for (sub = abfd->archive_head; sub != NULL; sub = sub->next)
--- 2054,2067 ----
      return false;
  
    sprintf (decbuf, "%-12ld", (long) count);
!   if (bfd_bwrite ((PTR) decbuf, (bfd_size_type) XCOFFARMAG_ELEMENT_SIZE, abfd)
!       != XCOFFARMAG_ELEMENT_SIZE)
      return false;
    for (i = 0; i < (size_t) count; i++)
      {
        sprintf (decbuf, "%-12ld", (long) offsets[i]);
!       if (bfd_bwrite ((PTR) decbuf, (bfd_size_type) XCOFFARMAG_ELEMENT_SIZE, 
! 		      abfd) != XCOFFARMAG_ELEMENT_SIZE)
  	return false;
      }
    for (sub = abfd->archive_head; sub != NULL; sub = sub->next)
*************** xcoff_write_archive_contents_old (abfd)
*** 1951,1957 ****
      }
  
    /* Write out the armap, if appropriate.  */
- 
    if (! makemap || ! hasobjects)
      sprintf (fhdr.symoff, "%d", 0);
    else
--- 2084,2089 ----
*************** xcoff_write_archive_contents_big (abfd)
*** 1989,2017 ****
    boolean makemap;
    boolean hasobjects;
    ufile_ptr prevoff, nextoff;
!   bfd *sub;
    size_t i;
!   struct xcoff_ar_hdr_big ahdr;
    bfd_size_type size;
!   char *p;
!   char decbuf[13];
  
!   memset (&fhdr, 0, sizeof fhdr);
!   strncpy (fhdr.magic, XCOFFARMAGBIG, SXCOFFARMAG);
!   sprintf (fhdr.firstmemoff, "%d", SIZEOF_AR_FILE_HDR_BIG);
!   sprintf (fhdr.freeoff, "%d", 0);
  
!   count = 0;
!   total_namlen = 0;
!   for (sub = abfd->archive_head; sub != NULL; sub = sub->next)
      {
!       ++count;
!       total_namlen += strlen (normalize_filename (sub)) + 1;
      }
-   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_BIG, SEEK_SET) != 0)
      return false;
  
--- 2121,2150 ----
    boolean makemap;
    boolean hasobjects;
    ufile_ptr prevoff, nextoff;
!   bfd *current_bfd;
    size_t i;
!   struct xcoff_ar_hdr_big *hdr, ahdr;
    bfd_size_type size;
!   bfd_byte *member_table, *mt;
!   bfd_vma member_table_size;
  
!   memcpy (fhdr.magic, XCOFFARMAGBIG, SXCOFFARMAG);
!   PRINT20 (fhdr.firstmemoff, SIZEOF_AR_FILE_HDR_BIG);
!   PRINT20 (fhdr.freeoff, 0);
! 
!   /* Calculate count and total_namlen */
!   for (current_bfd = abfd->archive_head, count = 0, total_namlen = 0; 
!        current_bfd != NULL; 
!        current_bfd = current_bfd->next, count++)
!     total_namlen += strlen (normalize_filename (current_bfd)) + 1;
  
!   offsets = NULL;
!   if (count)
      {
!       offsets = (file_ptr *) bfd_malloc (count * sizeof (file_ptr));
!       if (offsets == NULL)
! 	return false;
      }
    if (bfd_seek (abfd, (file_ptr) SIZEOF_AR_FILE_HDR_BIG, SEEK_SET) != 0)
      return false;
  
*************** xcoff_write_archive_contents_big (abfd)
*** 2019,2025 ****
    hasobjects = false;
    prevoff = 0;
    nextoff = SIZEOF_AR_FILE_HDR_BIG;
!   for (sub = abfd->archive_head, i = 0; sub != NULL; sub = sub->next, i++)
      {
        const char *name;
        bfd_size_type namlen;
--- 2152,2160 ----
    hasobjects = false;
    prevoff = 0;
    nextoff = SIZEOF_AR_FILE_HDR_BIG;
!   for (current_bfd = abfd->archive_head, i = 0; 
!        current_bfd != NULL; 
!        current_bfd = current_bfd->next, i++)
      {
        const char *name;
        bfd_size_type namlen;
*************** xcoff_write_archive_contents_big (abfd)
*** 2028,2042 ****
  
        if (makemap && ! hasobjects)
  	{
! 	  if (bfd_check_format (sub, bfd_object))
  	    hasobjects = true;
  	}
  
!       name = normalize_filename (sub);
        namlen = strlen (name);
  
!       if (sub->arelt_data != NULL)
! 	ahdrp = arch_xhdr_big (sub);
        else
  	ahdrp = NULL;
  
--- 2163,2177 ----
  
        if (makemap && ! hasobjects)
  	{
! 	  if (bfd_check_format (current_bfd, bfd_object))
  	    hasobjects = true;
  	}
  
!       name = normalize_filename (current_bfd);
        namlen = strlen (name);
  
!       if (current_bfd->arelt_data != NULL)
! 	ahdrp = arch_xhdr_big (current_bfd);
        else
  	ahdrp = NULL;
  
*************** xcoff_write_archive_contents_big (abfd)
*** 2044,2090 ****
  	{
  	  struct stat s;
  
- 	  memset (&ahdr, 0, sizeof ahdr);
  	  ahdrp = &ahdr;
  	  /* XXX This should actually be a call to stat64 (at least on
! 	     32-bit machines).  */
! 	  if (stat (bfd_get_filename (sub), &s) != 0)
  	    {
  	      bfd_set_error (bfd_error_system_call);
  	      return false;
  	    }
  
! 	  /* XXX This call actually should use %lld (at least on 32-bit
! 	     machines) since the fields's width is 20 and there numbers with
! 	     more than 32 bits can be represented.  */
! 	  sprintf (ahdrp->size, "%ld", (long) s.st_size);
! 	  sprintf (ahdrp->date, "%ld", (long) s.st_mtime);
! 	  sprintf (ahdrp->uid, "%ld", (long) s.st_uid);
! 	  sprintf (ahdrp->gid, "%ld", (long) s.st_gid);
! 	  sprintf (ahdrp->mode, "%o", (unsigned int) s.st_mode);
  
! 	  if (sub->arelt_data == NULL)
  	    {
  	      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;
  	}
  
!       /* XXX These calls actually should use %lld (at least on 32-bit
! 	 machines) since the fields's width is 20 and there numbers with
! 	 more than 32 bits can be represented.  */
!       sprintf (ahdrp->prevoff, "%ld", (long) prevoff);
!       sprintf (ahdrp->namlen, "%ld", (long) namlen);
  
        /* 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_BIG
  	      + namlen
  	      + SXCOFFARFMAG
--- 2179,2219 ----
  	{
  	  struct stat s;
  
  	  ahdrp = &ahdr;
  	  /* XXX This should actually be a call to stat64 (at least on
! 	     32-bit machines).  
! 	     XXX This call will fail if the original object is not found.  */
! 	  if (stat (bfd_get_filename (current_bfd), &s) != 0)
  	    {
  	      bfd_set_error (bfd_error_system_call);
  	      return false;
  	    }
  
! 	  PRINT20 (ahdrp->size, s.st_size);
! 	  PRINT12 (ahdrp->date, s.st_mtime);
! 	  PRINT12 (ahdrp->uid,  s.st_uid);
! 	  PRINT12 (ahdrp->gid,  s.st_gid);
! 	  PRINT12_OCTAL (ahdrp->mode, s.st_mode);
  
! 	  if (current_bfd->arelt_data == NULL)
  	    {
  	      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;
  	}
  
!       PRINT20 (ahdrp->prevoff, prevoff);
!       PRINT4 (ahdrp->namlen, namlen);
  
        /* 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 (current_bfd);
        size = (SIZEOF_AR_HDR_BIG
  	      + namlen
  	      + SXCOFFARFMAG
*************** xcoff_write_archive_contents_big (abfd)
*** 2097,2117 ****
        prevoff = nextoff;
        nextoff += size + (size & 1);
  
!       sprintf (ahdrp->nextoff, "%ld", (long) nextoff);
! 
!       /* We need spaces, not null bytes, in the header.  */
!       for (p = (char *) ahdrp; p < (char *) ahdrp + SIZEOF_AR_HDR_BIG; p++)
! 	if (*p == '\0')
! 	  *p = ' ';
  
        if ((bfd_bwrite ((PTR) ahdrp, (bfd_size_type) SIZEOF_AR_HDR_BIG, abfd)
  	   != SIZEOF_AR_HDR_BIG)
  	  || bfd_bwrite ((PTR) name, (bfd_size_type) 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;
        while (remaining != 0)
  	{
--- 2226,2241 ----
        prevoff = nextoff;
        nextoff += size + (size & 1);
  
!       PRINT20 (ahdrp->nextoff, nextoff);
  
        if ((bfd_bwrite ((PTR) ahdrp, (bfd_size_type) SIZEOF_AR_HDR_BIG, abfd)
  	   != SIZEOF_AR_HDR_BIG)
  	  || bfd_bwrite ((PTR) name, (bfd_size_type) namlen, abfd) != namlen
! 	  || (bfd_bwrite ((PTR) XCOFFARFMAG, (bfd_size_type) SXCOFFARFMAG, 
! 			  abfd) != SXCOFFARFMAG))
  	return false;
  
!       if (bfd_seek (current_bfd, (file_ptr) 0, SEEK_SET) != 0)
  	return false;
        while (remaining != 0)
  	{
*************** xcoff_write_archive_contents_big (abfd)
*** 2121,2127 ****
  	  amt = sizeof buffer;
  	  if (amt > remaining)
  	    amt = remaining;
! 	  if (bfd_bread (buffer, amt, sub) != amt
  	      || bfd_bwrite (buffer, amt, abfd) != amt)
  	    return false;
  	  remaining -= amt;
--- 2245,2251 ----
  	  amt = sizeof buffer;
  	  if (amt > remaining)
  	    amt = remaining;
! 	  if (bfd_bread (buffer, amt, current_bfd) != amt
  	      || bfd_bwrite (buffer, amt, abfd) != amt)
  	    return false;
  	  remaining -= amt;
*************** xcoff_write_archive_contents_big (abfd)
*** 2137,2234 ****
  	}
      }
  
!   /* XXX This call actually should use %lld (at least on 32-bit
!      machines) since the fields's width is 20 and there numbers with
!      more than 32 bits can be represented.  */
!   sprintf (fhdr.lastmemoff, "%ld", (long) prevoff);
  
!   /* Write out the member table.  */
  
!   BFD_ASSERT (nextoff == bfd_tell (abfd));
!   /* XXX This call actually should use %lld (at least on 32-bit
!      machines) since the fields's width is 20 and there numbers with
!      more than 32 bits can be represented.  */
!   sprintf (fhdr.memoff, "%ld", (long) nextoff);
  
!   memset (&ahdr, 0, sizeof ahdr);
!   /* XXX The next two calls actually should use %lld (at least on 32-bit
!      machines) since the fields's width is 20 and there numbers with
!      more than 32 bits can be represented.  */
!   sprintf (ahdr.size, "%ld", (long) (12 + count * 12 + total_namlen));
!   sprintf (ahdr.prevoff, "%ld", (long) prevoff);
!   sprintf (ahdr.date, "%d", 0);
!   sprintf (ahdr.uid, "%d", 0);
!   sprintf (ahdr.gid, "%d", 0);
!   sprintf (ahdr.mode, "%d", 0);
!   sprintf (ahdr.namlen, "%d", 0);
! 
!   size = (SIZEOF_AR_HDR_BIG
! 	  + 12
! 	  + count * 12
! 	  + total_namlen
! 	  + SXCOFFARFMAG);
  
!   prevoff = nextoff;
!   nextoff += size + (size & 1);
  
!   if (makemap && hasobjects)
!     /* XXX This call actually should use %lld (at least on 32-bit
!        machines) since the fields's width is 20 and there numbers with
!        more than 32 bits can be represented.  */
!     sprintf (ahdr.nextoff, "%ld", (long) nextoff);
!   else
!     sprintf (ahdr.nextoff, "%d", 0);
  
!   /* We need spaces, not null bytes, in the header.  */
!   for (p = (char *) &ahdr; p < (char *) &ahdr + SIZEOF_AR_HDR_BIG; p++)
!     if (*p == '\0')
!       *p = ' ';
! 
!   if ((bfd_bwrite ((PTR) &ahdr, (bfd_size_type) SIZEOF_AR_HDR_BIG, abfd)
!        != SIZEOF_AR_HDR_BIG)
!       || (bfd_bwrite ((PTR) XCOFFARFMAG, (bfd_size_type) SXCOFFARFMAG, abfd)
! 	  != SXCOFFARFMAG))
!     return false;
  
!   sprintf (decbuf, "%-12ld", (long) count);
!   if (bfd_bwrite ((PTR) decbuf, (bfd_size_type) 12, abfd) != 12)
!     return false;
    for (i = 0; i < (size_t) count; i++)
      {
!       sprintf (decbuf, "%-12ld", (long) offsets[i]);
!       if (bfd_bwrite ((PTR) decbuf, (bfd_size_type) 12, abfd) != 12)
! 	return false;
      }
!   for (sub = abfd->archive_head; sub != NULL; sub = sub->next)
      {
        const char *name;
        size_t namlen;
  
!       name = normalize_filename (sub);
!       namlen = strlen (name);
!       if (bfd_bwrite ((PTR) name, (bfd_size_type) (namlen + 1), abfd)
! 	  != namlen + 1)
! 	return false;
      }
!   if ((size & 1) != 0)
!     {
!       bfd_byte b;
  
!       b = '\0';
!       if (bfd_bwrite ((PTR) &b, (bfd_size_type) 1, abfd) != 1)
! 	return false;
!     }
  
    /* Write out the armap, if appropriate.  */
  
!   if (! makemap || ! hasobjects)
!     sprintf (fhdr.symoff, "%d", 0);
    else
      {
        BFD_ASSERT (nextoff == bfd_tell (abfd));
!       /* XXX This call actually should use %lld (at least on 32-bit
! 	 machines) since the fields's width is 20 and there numbers with
! 	 more than 32 bits can be represented.  */
        bfd_ardata (abfd)->tdata = (PTR) &fhdr;
        if (! _bfd_compute_and_write_armap (abfd, 0))
  	return false;
--- 2261,2371 ----
  	}
      }
  
!   PRINT20 (fhdr.lastmemoff, prevoff);
  
!   /* Write out the member table.  
!      Layout : 
  
!      standard big archive header
!      0x0000                   ar_size   [0x14]
!      0x0014                   ar_nxtmem [0x14]
!      0x0028                   ar_prvmem [0x14]
!      0x003C                   ar_date   [0x0C]
!      0x0048                   ar_uid    [0x0C]
!      0x0054                   ar_gid    [0x0C]
!      0x0060                   ar_mod    [0x0C]
!      0x006C                   ar_namelen[0x04]
!      0x0070                   ar_fmag   [0x02]
! 
!      Member table 
!      0x0072                   count     [0x14]
!      0x0086                   offsets   [0x14 * counts]
!      0x0086 + 0x14 * counts   names     [??]
!      ??                       pad to even bytes.
!    */
  
!   BFD_ASSERT (nextoff == bfd_tell (abfd));
  
!   member_table_size = (SIZEOF_AR_HDR_BIG
! 		       + SXCOFFARFMAG
! 		       + XCOFFARMAGBIG_ELEMENT_SIZE
! 		       + count * XCOFFARMAGBIG_ELEMENT_SIZE
! 		       + total_namlen);
! 
!   member_table_size += member_table_size & 1;
!   member_table = NULL;
!   member_table = (bfd_byte *) bfd_malloc (member_table_size);
!   if (member_table == NULL)
!     return false;
!   memset (member_table, 0, member_table_size);
  
!   hdr = (struct xcoff_ar_hdr_big *) member_table;
  
!   PRINT20 (hdr->size, (XCOFFARMAGBIG_ELEMENT_SIZE + 
! 		       count * XCOFFARMAGBIG_ELEMENT_SIZE + 
! 		       total_namlen + (total_namlen & 1)));
!   if (makemap && hasobjects) 
!     PRINT20 (hdr->nextoff, nextoff + member_table_size);
!   else
!     PRINT20 (hdr->nextoff, 0);
!   PRINT20 (hdr->prevoff, prevoff);
!   PRINT12 (hdr->date, 0);
!   PRINT12 (hdr->uid, 0);
!   PRINT12 (hdr->gid, 0);
!   PRINT12 (hdr->mode, 0);
!   PRINT4 (hdr->namlen, 0);
!   
!   mt = member_table + SIZEOF_AR_HDR_BIG;
!   memcpy (mt, XCOFFARFMAG, SXCOFFARFMAG);
!   mt += SXCOFFARFMAG;
  
!   PRINT20 (mt, count);
!   mt += XCOFFARMAGBIG_ELEMENT_SIZE;
    for (i = 0; i < (size_t) count; i++)
      {
!       PRINT20 (mt, offsets[i]);
!       mt += XCOFFARMAGBIG_ELEMENT_SIZE;
      }
! 
!   if (count) 
!     {
!       free (offsets);
!       offsets = NULL;
!     }
! 
!   for (current_bfd = abfd->archive_head; current_bfd != NULL; 
!        current_bfd = current_bfd->next)
      {
        const char *name;
        size_t namlen;
  
!       name = normalize_filename (current_bfd);
!       namlen = sprintf(mt, "%s", name);
!       mt += namlen + 1;
      }
!   
!   if (bfd_bwrite (member_table, member_table_size, abfd) != member_table_size)
!     return false;
  
!   free (member_table);
!   member_table = NULL;
! 
!   PRINT20 (fhdr.memoff, nextoff);
! 
!   prevoff = nextoff;
!   nextoff += member_table_size;
  
    /* Write out the armap, if appropriate.  */
  
!   if (! makemap || ! hasobjects) 
!     PRINT20 (fhdr.symoff, 0);
    else
      {
        BFD_ASSERT (nextoff == bfd_tell (abfd));
! 
!       /* Save nextoff in fhdr.symoff so the armap routine can use it.  */
!       PRINT20 (fhdr.symoff, nextoff);
!       
        bfd_ardata (abfd)->tdata = (PTR) &fhdr;
        if (! _bfd_compute_and_write_armap (abfd, 0))
  	return false;
*************** xcoff_write_archive_contents_big (abfd)
*** 2236,2251 ****
  
    /* Write out the archive file header.  */
  
-   /* We need spaces, not null bytes, in the header.  */
-   for (p = (char *) &fhdr; p < (char *) &fhdr + SIZEOF_AR_FILE_HDR_BIG; p++)
-     if (*p == '\0')
-       *p = ' ';
- 
    if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
!       || (bfd_bwrite ((PTR) &fhdr, (bfd_size_type) SIZEOF_AR_FILE_HDR_BIG, abfd)
! 	  != SIZEOF_AR_FILE_HDR_BIG))
      return false;
! 
    return true;
  }
  
--- 2373,2383 ----
  
    /* Write out the archive file header.  */
  
    if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
!       || (bfd_bwrite ((PTR) &fhdr, (bfd_size_type) SIZEOF_AR_FILE_HDR_BIG, 
! 		      abfd) != SIZEOF_AR_FILE_HDR_BIG))
      return false;
!   
    return true;
  }
  
*************** xcoff_generate_rtinit  (abfd, init, fini
*** 2997,3003 ****
  
    data_buffer_size = 0x0040 + initsz + finisz;
    data_buffer_size += (data_buffer_size & 7) ? 8 - (data_buffer_size & 7) : 0;
!   data_buffer = (bfd_byte *)bfd_malloc (data_buffer_size);
    memset (data_buffer, 0, data_buffer_size);
  
    if (initsz) 
--- 3129,3139 ----
  
    data_buffer_size = 0x0040 + initsz + finisz;
    data_buffer_size += (data_buffer_size & 7) ? 8 - (data_buffer_size & 7) : 0;
!   data_buffer = NULL;
!   data_buffer = (bfd_byte *) bfd_malloc (data_buffer_size);
!   if (data_buffer == NULL)
!     return false;
!   
    memset (data_buffer, 0, data_buffer_size);
  
    if (initsz) 
*************** xcoff_generate_rtinit  (abfd, init, fini
*** 3162,3167 ****
--- 3298,3306 ----
    bfd_bwrite (reloc_ext, scnhdr.s_nreloc * RELSZ, abfd);
    bfd_bwrite (syment_ext, filehdr.f_nsyms * SYMESZ, abfd);
    bfd_bwrite (string_table, string_table_size, abfd);
+ 
+   free (data_buffer);
+   data_buffer = NULL;
  
    return true;
  }
diff -rcp src-old/bfd/coff64-rs6000.c src/bfd/coff64-rs6000.c
*** src-old/bfd/coff64-rs6000.c	Sun Dec 23 09:45:28 2001
--- src/bfd/coff64-rs6000.c	Fri Dec 28 18:26:08 2001
*************** static bfd_vma xcoff64_loader_symbol_off
*** 143,148 ****
--- 143,151 ----
    PARAMS ((bfd *, struct internal_ldhdr *));
  static bfd_vma xcoff64_loader_reloc_offset
    PARAMS ((bfd *, struct internal_ldhdr *));
+ static boolean xcoff64_generate_rtinit 
+   PARAMS((bfd *, const char *, const char *));
+ 
  
  /* coffcode.h needs these to be defined */
  /* Internalcoff.h and coffcode.h modify themselves based on these flags.  */
*************** xcoff64_generate_rtinit  (abfd, init, fi
*** 2179,2185 ****
--- 2182,2192 ----
  
    data_buffer_size = 0x0058 + initsz + finisz;
    data_buffer_size += (data_buffer_size & 7) ? 8 - (data_buffer_size & 7) : 0;
+   data_buffer = NULL;
    data_buffer = (bfd_byte *)bfd_malloc (data_buffer_size);
+   if (data_buffer == NULL)
+     return false;
+   
    memset (data_buffer, 0, data_buffer_size);
  
    if (initsz) 
*************** xcoff64_generate_rtinit  (abfd, init, fi
*** 2336,2341 ****
--- 2343,2351 ----
    bfd_bwrite (reloc_ext, scnhdr.s_nreloc * RELSZ, abfd);
    bfd_bwrite (syment_ext, filehdr.f_nsyms * SYMESZ, abfd);
    bfd_bwrite (string_table, string_table_size, abfd);
+ 
+   free (data_buffer);
+   data_buffer = NULL;
  
    return true;
  }
diff -rcp src-old/bfd/libxcoff.h src/bfd/libxcoff.h
*** src-old/bfd/libxcoff.h	Sun Dec 23 09:45:32 2001
--- src/bfd/libxcoff.h	Fri Dec 28 18:26:08 2001
*************** Foundation, Inc., 59 Temple Place - Suit
*** 28,37 ****
  
  struct xcoff_backend_data_rec
  {
!   /*
!    * COFF backend information.  Must be the first field.
!    * This is where the std coff swap table goes
!    */
    bfd_coff_backend_data coff;
  
    /* Magic number */
--- 28,34 ----
  
  struct xcoff_backend_data_rec
  {
!   /* COFF backend information.  */
    bfd_coff_backend_data coff;
  
    /* Magic number */
*************** struct xcoff_backend_data_rec
*** 60,71 ****
    /* size of the small aout file header */
    unsigned int _xcoff_small_aout_header_size;
  
!   /*
!    * version
!    * loader version
!    * 1 : xcoff32
!    * 2 : xcoff64
!    */
    unsigned long _xcoff_ldhdr_version;
  
    boolean (* _xcoff_put_symbol_name)(bfd *, struct bfd_strtab_hash *,
--- 57,65 ----
    /* size of the small aout file header */
    unsigned int _xcoff_small_aout_header_size;
  
!   /* Loader version
!      1 : XCOFF32
!      2 : XCOFF64 */
    unsigned long _xcoff_ldhdr_version;
  
    boolean (* _xcoff_put_symbol_name)(bfd *, struct bfd_strtab_hash *,
*************** struct xcoff_backend_data_rec
*** 80,115 ****
  
    asection * (* _xcoff_create_csect_from_smclas) (bfd *, union internal_auxent *, const char *);
  
!   /*
!    * line_no and reloc overflow
!    * 32 overflows to another section when the line_no or reloc count go
!    * over 0xffff.  64 does not overflow.
!    */
    boolean (*_xcoff_is_lineno_count_overflow)(bfd *, bfd_vma);
    boolean (*_xcoff_is_reloc_count_overflow)(bfd *, bfd_vma);
  
!   /*
!    * .loader symbol table offset
!    * 32 is after the .loader header
!    * 64 is offset in .loader header
!    *
!    * Similar for the reloc table
!    */
    bfd_vma (*_xcoff_loader_symbol_offset)(bfd *, struct internal_ldhdr *);
    bfd_vma (*_xcoff_loader_reloc_offset)(bfd *, struct internal_ldhdr *);
! 
! 
!   /*
!    * Global linkage
!    *
!    * The first word of global linkage code must be be modified by
!    * filling in the correct TOC offset.
!    */
    unsigned long *_xcoff_glink_code;
! 
!   /*
!    * Size of the global link code in bytes of the xcoff_glink_code table
!    */
    unsigned long _xcoff_glink_size;
  
    /* rtinit */
--- 74,96 ----
  
    asection * (* _xcoff_create_csect_from_smclas) (bfd *, union internal_auxent *, const char *);
  
!   /* Line number and relocation overflow.
!      XCOFF32 overflows to another section when the line number or the 
!      relocation count exceeds 0xffff.  XCOFF64 does not overflow.  */
    boolean (*_xcoff_is_lineno_count_overflow)(bfd *, bfd_vma);
    boolean (*_xcoff_is_reloc_count_overflow)(bfd *, bfd_vma);
  
!   /* Loader section symbol and relocation table offset
!      XCOFF32 is after the .loader header
!      XCOFF64 is offset in .loader header  */
    bfd_vma (*_xcoff_loader_symbol_offset)(bfd *, struct internal_ldhdr *);
    bfd_vma (*_xcoff_loader_reloc_offset)(bfd *, struct internal_ldhdr *);
!   
!   /* Global linkage.  The first word of global linkage code must be be 
!      modified by filling in the correct TOC offset.  */
    unsigned long *_xcoff_glink_code;
!   
!   /* Size of the global link code in bytes of the xcoff_glink_code table.  */
    unsigned long _xcoff_glink_size;
  
    /* rtinit */
*************** struct xcoff_backend_data_rec
*** 212,274 ****
  
  #define bfd_xcoff_rtinit_size(a) ((xcoff_backend(a)->_xcoff_rtinit_size))
  #define bfd_xcoff_generate_rtinit(a, b, c) ((xcoff_backend(a)->_xcoff_generate_rtinit ((a), (b), (c))))
- 
- /* Functions in xcofflink.c.  */
- 
- extern long _bfd_xcoff_get_dynamic_symtab_upper_bound PARAMS ((bfd *));
- extern long _bfd_xcoff_canonicalize_dynamic_symtab
-   PARAMS ((bfd *, asymbol **));
- extern long _bfd_xcoff_get_dynamic_reloc_upper_bound PARAMS ((bfd *));
- extern long _bfd_xcoff_canonicalize_dynamic_reloc
-   PARAMS ((bfd *, arelent **, asymbol **));
- extern struct bfd_link_hash_table *_bfd_xcoff_bfd_link_hash_table_create
-   PARAMS ((bfd *));
- extern boolean _bfd_xcoff_bfd_link_add_symbols
-   PARAMS ((bfd *, struct bfd_link_info *));
- extern boolean _bfd_xcoff_bfd_final_link
-   PARAMS ((bfd *, struct bfd_link_info *));
- extern boolean _bfd_xcoff_slurp_symbol_table
-   PARAMS ((bfd *));
- extern long _bfd_xcoff_get_symbol_table
-   PARAMS ((bfd *, asymbol **));
- extern asymbol *_bfd_xcoff_make_empty_symbol
-   PARAMS ((bfd *));
- extern long _bfd_xcoff_get_symbol_table_upper_bound
-   PARAMS ((bfd *));
- extern void _bfd_xcoff_print_symbol
-   PARAMS ((bfd *, PTR, asymbol *, bfd_print_symbol_type));
- extern void _bfd_xcoff_get_symbol_info
-   PARAMS ((bfd *, asymbol *, symbol_info *));
- extern long _bfd_xcoff_canonicalize_reloc
-   PARAMS((bfd *, sec_ptr, arelent **, asymbol **));
- extern reloc_howto_type *_bfd_xcoff_rtype_to_howto
-   PARAMS ((bfd *, asection *, struct internal_reloc *,
- 	   struct coff_link_hash_entry *, struct internal_syment *,
- 	   bfd_vma *));
- extern boolean _bfd_xcoff_set_section_contents
-   PARAMS ((bfd *, asection *, PTR, file_ptr, bfd_size_type));
- boolean _bfd_xcoff_write_object_contents PARAMS ((bfd *));
- 
- 
- /* XCOFF support routines for the linker.  */
- 
- extern boolean bfd_xcoff_link_record_set
-   PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_hash_entry *,
- 	   bfd_size_type));
- extern boolean bfd_xcoff_import_symbol
-   PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_hash_entry *,
- 	   bfd_vma, const char *, const char *, const char *, unsigned int));
- extern boolean bfd_xcoff_export_symbol
-   PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_hash_entry *));
- extern boolean bfd_xcoff_link_count_reloc
-   PARAMS ((bfd *, struct bfd_link_info *, const char *));
- extern boolean bfd_xcoff_record_link_assignment
-   PARAMS ((bfd *, struct bfd_link_info *, const char *));
- extern boolean bfd_xcoff_size_dynamic_sections
-   PARAMS ((bfd *, struct bfd_link_info *, const char *, const char *,
- 	   unsigned long, unsigned long, unsigned long, boolean,
- 	   int, boolean, boolean, struct sec **));
- extern boolean xcoff_slurp_reloc_table
-   PARAMS ((bfd *, asection *, asymbol **));
  
  #endif /* LIBXCOFF_H */
--- 193,197 ----
diff -rcp src-old/include/coff/ChangeLog src/include/coff/ChangeLog
*** src-old/include/coff/ChangeLog	Sun Dec 23 09:45:35 2001
--- src/include/coff/ChangeLog	Fri Dec 28 18:26:08 2001
***************
*** 1,3 ****
--- 1,11 ----
+ 2001-12-24  Tom Rix  <trix@redhat.com>
+ 
+ 	* xcoff.h (xcoff_big_format_p): Make <bigaf> the default archive 
+ 	format.
+ 	(XCOFFARMAG_ELEMENT_SIZE, XCOFFARMAGBIG_ELEMENT_SIZE): Define for 
+ 	archive header ascii elements.  
+ 
+ 
  2001-12-17  Tom Rix  <trix@redhat.com>
  
  	* xcoff.h :  Add .except and .typchk section string and styp flags.
diff -rcp src-old/include/coff/xcoff.h src/include/coff/xcoff.h
*** src-old/include/coff/xcoff.h	Sun Dec 23 09:45:35 2001
--- src/include/coff/xcoff.h	Fri Dec 28 18:26:08 2001
*************** struct __rtinit_descriptor 
*** 459,464 ****
--- 459,468 ----
  #define XCOFFARMAGBIG "<bigaf>\012"
  #define SXCOFFARMAG   8
  
+ /* The size of the ascii archive elements */
+ #define XCOFFARMAG_ELEMENT_SIZE 12
+ #define XCOFFARMAGBIG_ELEMENT_SIZE 20
+ 
  /* This terminates an XCOFF archive member name.  */
  
  #define XCOFFARFMAG "`\012"
*************** struct xcoff_ar_file_hdr
*** 472,494 ****
    char magic[SXCOFFARMAG];
  
    /* Offset of the member table (decimal ASCII string).  */
!   char memoff[12];
  
    /* Offset of the global symbol table (decimal ASCII string).  */
!   char symoff[12];
  
    /* Offset of the first member in the archive (decimal ASCII string).  */
!   char firstmemoff[12];
  
    /* Offset of the last member in the archive (decimal ASCII string).  */
!   char lastmemoff[12];
  
    /* Offset of the first member on the free list (decimal ASCII
       string).  */
!   char freeoff[12];
  };
  
! #define SIZEOF_AR_FILE_HDR (5 * 12 + SXCOFFARMAG)
  
  /* This is the equivalent data structure for the big archive format.  */
  
--- 476,498 ----
    char magic[SXCOFFARMAG];
  
    /* Offset of the member table (decimal ASCII string).  */
!   char memoff[XCOFFARMAG_ELEMENT_SIZE];
  
    /* Offset of the global symbol table (decimal ASCII string).  */
!   char symoff[XCOFFARMAG_ELEMENT_SIZE];
  
    /* Offset of the first member in the archive (decimal ASCII string).  */
!   char firstmemoff[XCOFFARMAG_ELEMENT_SIZE];
  
    /* Offset of the last member in the archive (decimal ASCII string).  */
!   char lastmemoff[XCOFFARMAG_ELEMENT_SIZE];
  
    /* Offset of the first member on the free list (decimal ASCII
       string).  */
!   char freeoff[XCOFFARMAG_ELEMENT_SIZE];
  };
  
! #define SIZEOF_AR_FILE_HDR (SXCOFFARMAG + 5 * XCOFFARMAG_ELEMENT_SIZE)
  
  /* This is the equivalent data structure for the big archive format.  */
  
*************** struct xcoff_ar_file_hdr_big
*** 498,539 ****
    char magic[SXCOFFARMAG];
  
    /* Offset of the member table (decimal ASCII string).  */
!   char memoff[20];
  
    /* Offset of the global symbol table for 32-bit objects (decimal ASCII
       string).  */
!   char symoff[20];
  
    /* Offset of the global symbol table for 64-bit objects (decimal ASCII
       string).  */
!   char symoff64[20];
  
    /* Offset of the first member in the archive (decimal ASCII string).  */
!   char firstmemoff[20];
  
    /* Offset of the last member in the archive (decimal ASCII string).  */
!   char lastmemoff[20];
  
    /* Offset of the first member on the free list (decimal ASCII
       string).  */
!   char freeoff[20];
  };
  
! #define SIZEOF_AR_FILE_HDR_BIG (6 * 20 + SXCOFFARMAG)
! 
  
  /* Each XCOFF archive member starts with this (printable) structure.  */
  
  struct xcoff_ar_hdr
  {
    /* File size not including the header (decimal ASCII string).  */
!   char size[12];
  
    /* File offset of next archive member (decimal ASCII string).  */
!   char nextoff[12];
  
    /* File offset of previous archive member (decimal ASCII string).  */
!   char prevoff[12];
  
    /* File mtime (decimal ASCII string).  */
    char date[12];
--- 502,542 ----
    char magic[SXCOFFARMAG];
  
    /* Offset of the member table (decimal ASCII string).  */
!   char memoff[XCOFFARMAGBIG_ELEMENT_SIZE];
  
    /* Offset of the global symbol table for 32-bit objects (decimal ASCII
       string).  */
!   char symoff[XCOFFARMAGBIG_ELEMENT_SIZE];
  
    /* Offset of the global symbol table for 64-bit objects (decimal ASCII
       string).  */
!   char symoff64[XCOFFARMAGBIG_ELEMENT_SIZE];
  
    /* Offset of the first member in the archive (decimal ASCII string).  */
!   char firstmemoff[XCOFFARMAGBIG_ELEMENT_SIZE];
  
    /* Offset of the last member in the archive (decimal ASCII string).  */
!   char lastmemoff[XCOFFARMAGBIG_ELEMENT_SIZE];
  
    /* Offset of the first member on the free list (decimal ASCII
       string).  */
!   char freeoff[XCOFFARMAGBIG_ELEMENT_SIZE];
  };
  
! #define SIZEOF_AR_FILE_HDR_BIG (SXCOFFARMAG + 6 * XCOFFARMAGBIG_ELEMENT_SIZE)
  
  /* Each XCOFF archive member starts with this (printable) structure.  */
  
  struct xcoff_ar_hdr
  {
    /* File size not including the header (decimal ASCII string).  */
!   char size[XCOFFARMAG_ELEMENT_SIZE];
  
    /* File offset of next archive member (decimal ASCII string).  */
!   char nextoff[XCOFFARMAG_ELEMENT_SIZE];
  
    /* File offset of previous archive member (decimal ASCII string).  */
!   char prevoff[XCOFFARMAG_ELEMENT_SIZE];
  
    /* File mtime (decimal ASCII string).  */
    char date[12];
*************** struct xcoff_ar_hdr
*** 558,577 ****
       bytes is given in the size field.  */
  };
  
! #define SIZEOF_AR_HDR (7 * 12 + 4)
  
  /* The equivalent for the big archive format.  */
  
  struct xcoff_ar_hdr_big
  {
    /* File size not including the header (decimal ASCII string).  */
!   char size[20];
  
    /* File offset of next archive member (decimal ASCII string).  */
!   char nextoff[20];
  
    /* File offset of previous archive member (decimal ASCII string).  */
!   char prevoff[20];
  
    /* File mtime (decimal ASCII string).  */
    char date[12];
--- 561,580 ----
       bytes is given in the size field.  */
  };
  
! #define SIZEOF_AR_HDR (3 * XCOFFARMAG_ELEMENT_SIZE + 4 * 12 + 4)
  
  /* The equivalent for the big archive format.  */
  
  struct xcoff_ar_hdr_big
  {
    /* File size not including the header (decimal ASCII string).  */
!   char size[XCOFFARMAGBIG_ELEMENT_SIZE];
  
    /* File offset of next archive member (decimal ASCII string).  */
!   char nextoff[XCOFFARMAGBIG_ELEMENT_SIZE];
  
    /* File offset of previous archive member (decimal ASCII string).  */
!   char prevoff[XCOFFARMAGBIG_ELEMENT_SIZE];
  
    /* File mtime (decimal ASCII string).  */
    char date[12];
*************** struct xcoff_ar_hdr_big
*** 596,610 ****
       bytes is given in the size field.  */
  };
  
! #define SIZEOF_AR_HDR_BIG (3 * 20 + 4 * 12 + 4)
  
  /* We often have to distinguish between the old and big file format.
     Make it a bit cleaner.  We can use `xcoff_ardata' here because the
!    `hdr' member has the same size and position in both formats.  */
  #define xcoff_big_format_p(abfd) \
!   ((NULL != bfd_ardata(abfd)) && \
!    (NULL != xcoff_ardata(abfd)) && \
!    (xcoff_ardata (abfd)->magic[1] == 'b'))
  
  /* We store a copy of the xcoff_ar_file_hdr in the tdata field of the
     artdata structure.  Similar for the big archive.  */
--- 599,623 ----
       bytes is given in the size field.  */
  };
  
! #define SIZEOF_AR_HDR_BIG (3 * XCOFFARMAGBIG_ELEMENT_SIZE + 4 * 12 + 4)
  
  /* We often have to distinguish between the old and big file format.
     Make it a bit cleaner.  We can use `xcoff_ardata' here because the
!    `hdr' member has the same size and position in both formats.  
!    <bigaf> is the default format, return true even when xcoff_ardata is 
!    NULL. */
! #define xcoff_big_format_p(abfd) \
!   ((NULL != bfd_ardata (abfd) && NULL == xcoff_ardata (abfd)) || \
!    ((NULL != bfd_ardata (abfd)) && \
!     (NULL != xcoff_ardata (abfd)) && \
!     (xcoff_ardata (abfd)->magic[1] == 'b')))
! 
! /* For testing old format * /
! #undef xcoff_big_format_p
  #define xcoff_big_format_p(abfd) \
!   (((NULL != bfd_ardata (abfd)) && \
!     (NULL != xcoff_ardata (abfd)) && \
!     (xcoff_ardata (abfd)->magic[1] == 'b'))) / **/
  
  /* We store a copy of the xcoff_ar_file_hdr in the tdata field of the
     artdata structure.  Similar for the big archive.  */

Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]