This is the mail archive of the
binutils@sources.redhat.com
mailing list for the binutils project.
PATCH, XCOFF <bigaf> archives
- From: Tom Rix <trix at redhat dot com>
- To: binutils at sources dot redhat dot com
- Date: Fri, 28 Dec 2001 23:17:44 -0600
- Subject: 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. */