/* BFD back-end for archive files (libraries).
- Copyright (C) 1990-1991 Free Software Foundation, Inc.
+ Copyright 1990, 1991, 1992 Free Software Foundation, Inc.
Written by Cygnus Support. Mostly Gumby Henkel-Wallace's fault.
This file is part of BFD, the Binary File Descriptor library.
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
-/*doc*
+/*
@setfilename archive-info
SECTION
Archives
DESCRIPTION
- Gumby, you promised to write this bit...
-
Archives are supported in BFD in <<archive.c>>.
- An archive is represented internally just like another BFD,
- with a pointer to a chain of contained BFDs. Archives can be
- created by opening BFDs, linking them together and attaching
- them as children to another BFD and then closing the parent
- BFD.
-
+ An archive (or library) is just another BFD. It has a symbol
+ table, although there's not much a user program will do with it.
+
+ The big difference between an archive BFD and an ordinary BFD
+ is that the archive doesn't have sections. Instead it has a
+ chain of BFDs considered its contents. These BFDs can be
+ manipulated just like any other. The BFDs contained in an
+ archive opened for reading will all be opened for reading; you
+ may put either input or output BFDs into an archive opened for
+ output; it will be handled correctly when the archive is closed.
+
+ Use <<bfd_openr_next_archived_file>> to step through all
+ the contents of an archive opened for input. It's not
+ required that you read the entire archive if you don't want
+ to! Read it until you find what you want.
+
+ Archive contents of output BFDs are chained through the
+ <<next>> pointer in a BFD. The first one is findable through
+ the <<archive_head>> slot of the archive. Set it with
+ <<set_archive_head>> (q.v.). A given BFD may be in only one
+ open output archive at a time.
+
+ As expected, the BFD archive code is more general than the
+ archive code of any given environment. BFD archives may
+ contain files of different formats (e.g., a.out and coff) and
+ even different architectures. You may even place archives
+ recursively into archives!
+
+ This can cause unexpected confusion, since some archive
+ formats are more expressive than others. For instance, Intel
+ COFF archives can preserve long filenames; Sun a.out archives
+ cannot. If you move a file from the first to the second
+ format and back again, the filename may be truncated.
+ Likewise, different a.out environments have different
+ conventions as to how they truncate filenames, whether they
+ preserve directory names in filenames, etc. When
+ interoperating with native tools, be sure your files are
+ homogeneous.
+
+ Beware: most of these formats do not react well to the
+ presence of spaces in filenames. We do the best we can, but
+ can't always handle this due to restrctions in the format of
+ archives. Many unix utilities are braindead in regards to
+ spaces and such in filenames anyway, so this shouldn't be much
+ of a restriction.
*/
/* Assumes:
o - all arch headers are the same size (across architectures).
*/
-/* $Id$ */
+/* Some formats provide a way to cram a long filename into the short
+ (16 chars) space provided by a bsd archive. The trick is: make a
+ special "file" in the front of the archive, sort of like the SYMDEF
+ entry. If the filename is too long to fit, put it in the extended
+ name table, and use its index as the filename. To prevent
+ confusion prepend the index with a space. This means you can't
+ have filenames that start with a space, but then again, many unix
+ utilities can't handle that anyway.
+
+ This scheme unfortunately requires that you stand on your head in
+ order to write an archive since you need to put a magic file at the
+ front, and need to touch every entry to do so. C'est la vie.
+*/
#include "bfd.h"
#include "sysdep.h"
#include "libbfd.h"
-#include "ar.h"
-#include "ranlib.h"
+#include "aout/ar.h"
+#include "aout/ranlib.h"
+#include <errno.h>
+
+#ifndef errno
+extern int errno;
+#endif
#ifdef GNU960
#define BFD_GNU960_ARMAG(abfd) (BFD_COFF_FILE_P((abfd)) ? ARMAG : ARMAGB)
/* We keep a cache of archive filepointers to archive elements to
speed up searching the archive by filepos. We only add an entry to
the cache when we actually read one. We also don't sort the cache;
- it's short enough to search linearly.
+ it's generally short enough to search linearly.
Note that the pointers here point to the front of the ar_hdr, not
to the front of the contents!
*/
_bfd_generic_mkarchive (abfd)
bfd *abfd;
{
- set_tdata (abfd, bfd_zalloc(abfd, sizeof (struct artdata)));
+ abfd->tdata.aout_ar_data = (struct artdata *)bfd_zalloc(abfd, sizeof (struct artdata));
if (bfd_ardata (abfd) == NULL) {
- bfd_error = no_memory;
- return false;
- }
+ bfd_error = no_memory;
+ return false;
+ }
bfd_ardata(abfd)->cache = 0;
return true;
}
FUNCTION
bfd_get_next_mapent
+SYNOPSIS
+ symindex bfd_get_next_mapent(bfd *, symindex previous, carsym ** sym);
+
DESCRIPTION
- What this does
+ This function steps through an archive's symbol table (if it
+ has one). Successively updates <<sym>> with the next symbol's
+ information, returning that symbol's (internal) index into the
+ symbol table.
-SYNOPSIS
- symindex bfd_get_next_mapent(bfd *, symindex, carsym **);
+ Supply BFD_NO_MORE_SYMBOLS as the <<previous>> entry to get
+ the first one; returns BFD_NO_MORE_SYMBOLS when you're already
+ got the last one.
+
+ A <<carsym>> is a canonical archive symbol. The only
+ user-visible element is its name, a null-terminated string.
*/
+
symindex
-bfd_get_next_mapent (abfd, prev, entry)
- bfd *abfd;
- symindex prev;
- carsym **entry;
+DEFUN(bfd_get_next_mapent,(abfd, prev, entry),
+ bfd *abfd AND
+ symindex prev AND
+ carsym **entry)
{
if (!bfd_has_map (abfd)) {
bfd_error = invalid_operation;
return prev;
}
-
/* To be called by backends only */
bfd *
_bfd_create_empty_archive_element_shell (obfd)
FUNCTION
bfd_set_archive_head
-DESCRIPTION
- Used whilst processing archives. Sets the head of the chain of
- BFDs contained in an archive to @var{new_head}. (see chapter
- on archives)
-
SYNOPSIS
boolean bfd_set_archive_head(bfd *output, bfd *new_head);
+DESCRIPTION
+ Used whilst processing archives. Sets the head of the chain of
+ BFDs contained in an archive to @var{new_head}.
*/
boolean
/* The name begins with space. Hence the rest of the name is an index into
the string table. */
-
char *
get_extended_arelt_filename (arch, name)
bfd *arch;
char *name;
{
-#ifndef errno
- extern int errno;
-#endif
- unsigned long index = 0;
-
- /* Should extract string so that I can guarantee not to overflow into
- the next region, but I"m too lazy. */
- errno = 0;
- index = strtol (name, NULL, 10);
- if (errno != 0) {
- bfd_error = malformed_archive;
- return NULL;
+ unsigned long index = 0;
+
+ /* Should extract string so that I can guarantee not to overflow into
+ the next region, but I'm too lazy. */
+ errno = 0;
+ /* Skip first char, which is '/' in SVR4 or ' ' in some other variants. */
+ index = strtol (name+1, NULL, 10);
+ if (errno != 0) {
+ bfd_error = malformed_archive;
+ return NULL;
}
- return bfd_ardata (arch)->extended_names + index;
+ return bfd_ardata (arch)->extended_names + index;
}
/* This functions reads an arch header and returns an areltdata pointer, or
/* extract the filename from the archive - there are two ways to
specify an extendend name table, either the first char of the
- name is a space, or it's a slash */
- if ((hdr.ar_name[0] == '/' || hdr.ar_name[0] == ' ') && bfd_ardata (abfd)->extended_names != NULL) {
+ name is a space, or it's a slash. */
+ if ((hdr.ar_name[0] == '/'
+ || (hdr.ar_name[0] == ' '
+ && memchr (hdr.ar_name, '/', ar_maxnamelen(abfd)) == NULL))
+ && bfd_ardata (abfd)->extended_names != NULL) {
filename = get_extended_arelt_filename (abfd, hdr.ar_name);
if (filename == NULL) {
bfd_error = malformed_archive;
}
else
{
- /* We judge the end of the name by looking for a space or a
- padchar */
+ /* We judge the end of the name by looking for '/' or ' '.
+ Note: The SYSV format (terminated by '/') allows embedded
+ spaces, so only look for ' ' if we don't find '/'. */
namelen = 0;
-
- while (namelen < (unsigned)ar_maxnamelen(abfd) &&
- ( hdr.ar_name[namelen] != 0 &&
- hdr.ar_name[namelen] != ' ' &&
- hdr.ar_name[namelen] != ar_padchar(abfd))) {
+ while (hdr.ar_name[namelen] != '\0' &&
+ hdr.ar_name[namelen] != '/') {
namelen++;
+ if (namelen == (unsigned)ar_maxnamelen(abfd)) {
+ namelen = 0;
+ while (hdr.ar_name[namelen] != ' '
+ && namelen < (unsigned)ar_maxnamelen(abfd)) {
+ namelen++;
+ }
+ break;
+ }
}
allocsize += namelen + 1;
return ared;
}
\f
+/* This is an internal function; it's mainly used when indexing
+ through the archive symbol table, but also used to get the next
+ element, since it handles the bookkeeping so nicely for us.
+*/
+
bfd *
get_elt_at_filepos (archive, filepos)
bfd *archive;
FUNCTION
bfd_get_elt_at_index
-DESCRIPTION
- Return the sub bfd contained within the archive at archive index n.
-
SYNOPSIS
- bfd *bfd_get_elt_at_index(bfd *, int);
+ bfd *bfd_get_elt_at_index(bfd * archive, int index);
+
+DESCRIPTION
+ Return the bfd which is referenced by the symbol indexed by <<index>>.
+ <<index>> should have been returned by <<bfd_get_next_mapent>> (q.v.).
*/
bfd *
-bfd_get_elt_at_index (abfd, index)
- bfd *abfd;
- int index;
+DEFUN(bfd_get_elt_at_index,(abfd, index),
+ bfd *abfd AND
+ int index)
{
bfd *result =
get_elt_at_filepos
FUNCTION
bfd_openr_next_archived_file
+SYNOPSIS
+ bfd* bfd_openr_next_archived_file(bfd *archive, bfd *previous);
+
DESCRIPTION
Initially provided a BFD containing an archive and NULL, opens
- a BFD on the first contained element and returns that.
+ an inpout BFD on the first contained element and returns that.
Subsequent calls to bfd_openr_next_archived_file should pass
the archive and the previous return value to return a created
BFD to the next contained element. NULL is returned when there
are no more.
-SYNOPSIS
- bfd* bfd_openr_next_archived_file(bfd *archive, bfd *previous);
-
*/
bfd *
bfd*last_file)
{
- if ((bfd_get_format (archive) != bfd_archive) ||
- (archive->direction == write_direction)) {
- bfd_error = invalid_operation;
- return NULL;
- }
+ if ((bfd_get_format (archive) != bfd_archive) ||
+ (archive->direction == write_direction)) {
+ bfd_error = invalid_operation;
+ return NULL;
+ }
- return BFD_SEND (archive,
- openr_next_archived_file,
- (archive,
- last_file));
+ return BFD_SEND (archive,
+ openr_next_archived_file,
+ (archive,
+ last_file));
}
return get_elt_at_filepos (archive, filestart);
}
-\f
+
bfd_target *
bfd_generic_archive_p (abfd)
#ifdef GNU960
if (strncmp (armag, BFD_GNU960_ARMAG(abfd), SARMAG)) return 0;
#else
- if (strncmp (armag, ARMAG, SARMAG)) return 0;
+ if (strncmp (armag, ARMAG, SARMAG) &&
+ strncmp (armag, ARMAGB, SARMAG)) return 0;
#endif
+
+
/* We are setting bfd_ardata(abfd) here, but since bfd_ardata
involves a cast, we can't do it as the left operand of assignment. */
- set_tdata (abfd, bfd_zalloc(abfd,sizeof (struct artdata)));
+ abfd->tdata.aout_ar_data = (struct artdata *) bfd_zalloc(abfd,sizeof (struct artdata));
if (bfd_ardata (abfd) == NULL) {
bfd_error = no_memory;
bfd_ardata (abfd)->first_file_filepos = SARMAG;
- if (!BFD_SEND (abfd, _bfd_slurp_armap, (abfd))) {
+ if (!bfd_slurp_armap (abfd)) {
bfd_release(abfd, bfd_ardata (abfd));
- abfd->tdata = NULL;
+ abfd->tdata.aout_ar_data = NULL;
return 0;
}
if (!BFD_SEND (abfd, _bfd_slurp_extended_name_table, (abfd))) {
bfd_release(abfd, bfd_ardata (abfd));
- abfd->tdata = NULL;
+ abfd->tdata.aout_ar_data = NULL;
return 0;
}
}
/* Returns false on error, true otherwise */
-boolean
-bfd_slurp_bsd_armap (abfd)
+static boolean
+do_slurp_bsd_armap (abfd)
bfd *abfd;
{
int *raw_armap, *rbase;
struct artdata *ardata = bfd_ardata (abfd);
char *stringbase;
+ unsigned int parsed_size;
- /* FIXME, if the read fails, this routine quietly returns "true"!!
- It should probably do that if the read gives 0 bytes (empty archive),
- but fail for any other size... */
- if (bfd_read ((PTR)nextname, 1, 16, abfd) == 16) {
- /* The archive has at least 16 bytes in it */
- bfd_seek (abfd, -16L, SEEK_CUR);
-
- /* This should be using RANLIBMAG, but at least it can be grepped for
- in this comment. */
- if (strncmp (nextname, "__.SYMDEF ", 16)) {
- bfd_has_map (abfd) = false;
- return true;
- }
-
- mapdata = snarf_ar_hdr (abfd);
- if (mapdata == NULL) return false;
-
- raw_armap = (int *) bfd_zalloc(abfd,mapdata->parsed_size);
- if (raw_armap == NULL) {
- bfd_error = no_memory;
- byebye:
- bfd_release (abfd, (PTR)mapdata);
- return false;
- }
-
- if (bfd_read ((PTR)raw_armap, 1, mapdata->parsed_size, abfd) !=
- mapdata->parsed_size) {
- bfd_error = malformed_archive;
- bfd_release (abfd, (PTR)raw_armap);
- goto byebye;
- }
-
- ardata->symdef_count = bfd_h_get_32(abfd, (PTR)raw_armap) / sizeof (struct symdef);
- ardata->cache = 0;
- rbase = raw_armap+1;
- ardata->symdefs = (carsym *) rbase;
- stringbase = ((char *) (ardata->symdefs + ardata->symdef_count)) + 4;
-
- for (;counter < ardata->symdef_count; counter++) {
- struct symdef *sym = ((struct symdef *) rbase) + counter;
- sym->s.name = bfd_h_get_32(abfd, (PTR)(&(sym->s.string_offset))) + stringbase;
- sym->file_offset = bfd_h_get_32(abfd, (PTR)( &(sym->file_offset)));
- }
+ mapdata = snarf_ar_hdr (abfd);
+ if (mapdata == NULL) return false;
+ parsed_size = mapdata->parsed_size;
+ bfd_release (abfd, (PTR)mapdata); /* Don't need it any more. */
+
+ raw_armap = (int *) bfd_zalloc(abfd, parsed_size);
+ if (raw_armap == NULL) {
+ bfd_error = no_memory;
+ return false;
+ }
+
+ if (bfd_read ((PTR)raw_armap, 1, parsed_size, abfd) != parsed_size) {
+ bfd_error = malformed_archive;
+ byebye:
+ bfd_release (abfd, (PTR)raw_armap);
+ return false;
+ }
+
+ ardata->symdef_count =
+ bfd_h_get_32(abfd, (PTR)raw_armap) / sizeof (struct symdef);
+
+ if (ardata->symdef_count * sizeof (struct symdef)
+ > parsed_size - sizeof (*raw_armap)) {
+ /* Probably we're using the wrong byte ordering. */
+ bfd_error = wrong_format;
+ goto byebye;
+ }
+
+ ardata->cache = 0;
+ rbase = raw_armap+1;
+ ardata->symdefs = (carsym *) rbase;
+ stringbase = ((char *) (ardata->symdefs + ardata->symdef_count)) + 4;
- ardata->first_file_filepos = bfd_tell (abfd);
- /* Pad to an even boundary if you have to */
- ardata->first_file_filepos += (ardata-> first_file_filepos) %2;
- /* FIXME, we should provide some way to free raw_ardata when
- we are done using the strings from it. For now, it seems
- to be allocated on an obstack anyway... */
- bfd_has_map (abfd) = true;
+ for (;counter < ardata->symdef_count; counter++) {
+ struct symdef *sym = ((struct symdef *) rbase) + counter;
+ sym->s.name = bfd_h_get_32(abfd, (PTR)(&(sym->s.string_offset))) + stringbase;
+ sym->file_offset = bfd_h_get_32(abfd, (PTR)( &(sym->file_offset)));
}
+
+ ardata->first_file_filepos = bfd_tell (abfd);
+ /* Pad to an even boundary if you have to */
+ ardata->first_file_filepos += (ardata-> first_file_filepos) %2;
+ /* FIXME, we should provide some way to free raw_ardata when
+ we are done using the strings from it. For now, it seems
+ to be allocated on an obstack anyway... */
+ bfd_has_map (abfd) = true;
return true;
}
/* Returns false on error, true otherwise */
-boolean
-bfd_slurp_coff_armap (abfd)
+static boolean
+do_slurp_coff_armap (abfd)
bfd *abfd;
{
struct areltdata *mapdata;
struct artdata *ardata = bfd_ardata (abfd);
char *stringbase;
unsigned int stringsize;
+ unsigned int parsed_size;
carsym *carsyms;
int result;
+ unsigned int nsymz; /* Number of symbols in armap. */
- result = bfd_read ((PTR)&nextname, 1, 1, abfd);
- bfd_seek (abfd, -1L, SEEK_CUR);
-
- if (result != 1 || nextname != '/') {
- /* Actually I think this is an error for a COFF archive */
- bfd_has_map (abfd) = false;
- return true;
- }
-
+ bfd_vma (*swap)();
+ char int_buf[sizeof(long)];
+ unsigned int carsym_size, ptrsize, i;
+
mapdata = snarf_ar_hdr (abfd);
if (mapdata == NULL) return false;
+ parsed_size = mapdata->parsed_size;
+ bfd_release (abfd, (PTR)mapdata); /* Don't need it any more. */
- raw_armap = (int *) bfd_alloc(abfd,mapdata->parsed_size);
-
- if (raw_armap == NULL)
- {
- bfd_error = no_memory;
- byebye:
- bfd_release (abfd, (PTR)mapdata);
+ if (bfd_read ((PTR)int_buf, 1, 4, abfd) != 4) {
+ bfd_error = malformed_archive;
return false;
}
-
- /* read in the raw map */
- if (bfd_read ((PTR)raw_armap, 1, mapdata->parsed_size, abfd) !=
- mapdata->parsed_size) {
- bfd_error = malformed_archive;
- oops:
- bfd_release (abfd, (PTR)raw_armap);
- goto byebye;
+ /* It seems that all numeric information in a coff archive is always
+ in big endian format, nomatter the host or target. */
+ swap = _do_getb32;
+ nsymz = _do_getb32((PTR)int_buf);
+ stringsize = parsed_size - (4 * nsymz) - 4;
+
+#if 1
+ /* ... except that some archive formats are broken, and it may be our
+ fault - the i960 little endian coff sometimes has big and sometimes
+ little, because our tools changed. Here's a horrible hack to clean
+ up the crap. */
+
+ if (stringsize > 0xfffff) {
+ /* This looks dangerous, let's do it the other way around */
+ nsymz = _do_getl32((PTR)int_buf);
+ stringsize = parsed_size - (4 * nsymz) - 4;
+ swap = _do_getl32;
}
+#endif
/* The coff armap must be read sequentially. So we construct a bsd-style
- one in core all at once, for simplicity.
-
- It seems that all numeric information in a coff archive is always
- in big endian format, nomatter the host or target. */
-
- stringsize = mapdata->parsed_size - (4 * (_do_getb32((PTR)raw_armap))) - 4;
+ one in core all at once, for simplicity. */
+
+ carsym_size = (nsymz * sizeof (carsym));
+ ptrsize = (4 * nsymz);
- {
- unsigned int nsymz = _do_getb32( (PTR)raw_armap);
- unsigned int carsym_size = (nsymz * sizeof (carsym));
- unsigned int ptrsize = (4 * nsymz);
- unsigned int i;
- ardata->symdefs = (carsym *) bfd_zalloc(abfd,carsym_size + stringsize + 1);
- if (ardata->symdefs == NULL) {
+ ardata->symdefs = (carsym *) bfd_zalloc(abfd, carsym_size + stringsize + 1);
+ if (ardata->symdefs == NULL) {
bfd_error = no_memory;
- goto oops;
- }
- carsyms = ardata->symdefs;
-
- stringbase = ((char *) ardata->symdefs) + carsym_size;
- memcpy (stringbase, (char*)raw_armap + ptrsize + 4, stringsize);
+ return false;
+ }
+ carsyms = ardata->symdefs;
+ stringbase = ((char *) ardata->symdefs) + carsym_size;
+ /* Allocate and read in the raw offsets. */
+ raw_armap = (int *) bfd_alloc(abfd, ptrsize);
+ if (raw_armap == NULL) {
+ bfd_error = no_memory;
+ goto release_symdefs;
+ }
+ if (bfd_read ((PTR)raw_armap, 1, ptrsize, abfd) != ptrsize
+ || bfd_read ((PTR)stringbase, 1, stringsize, abfd) != stringsize) {
+ bfd_error = malformed_archive;
+ goto release_raw_armap;
+ }
- /* OK, build the carsyms */
- for (i = 0; i < nsymz; i++)
- {
- rawptr = raw_armap + i + 1;
- carsyms->file_offset = _do_getb32((PTR)rawptr);
- carsyms->name = stringbase;
- for (; *(stringbase++););
- carsyms++;
- }
- *stringbase = 0;
+ /* OK, build the carsyms */
+ for (i = 0; i < nsymz; i++) {
+ rawptr = raw_armap + i;
+ carsyms->file_offset = swap((PTR)rawptr);
+ carsyms->name = stringbase;
+ while (*stringbase++) ;
+ carsyms++;
}
- ardata->symdef_count = _do_getb32((PTR)raw_armap);
+ *stringbase = 0;
+
+ ardata->symdef_count = nsymz;
ardata->first_file_filepos = bfd_tell (abfd);
/* Pad to an even boundary if you have to */
ardata->first_file_filepos += (ardata->first_file_filepos) %2;
- /* We'd like to release these allocations, but we have allocated stuff
- since then (using the same obstack, if bfd_release is obstack based).
- So they will stick around until the BFD is closed. */
- /* bfd_release (abfd, (PTR)raw_armap);
- bfd_release (abfd, (PTR)mapdata); */
bfd_has_map (abfd) = true;
+ bfd_release (abfd, (PTR)raw_armap);
+ return true;
+
+ release_raw_armap:
+ bfd_release (abfd, (PTR)raw_armap);
+ release_symdefs:
+ bfd_release (abfd, (PTR)(ardata)->symdefs);
+ return false;
+}
+
+/* This routine can handle either coff-style or bsd-style armaps.
+ Returns false on error, true otherwise */
+
+boolean
+bfd_slurp_armap (abfd)
+ bfd *abfd;
+{
+ char nextname[17];
+ int i = bfd_read ((PTR)nextname, 1, 16, abfd);
+
+ if (i == 0)
+ return true;
+ if (i != 16)
+ return false;
+
+ bfd_seek (abfd, (file_ptr) -16, SEEK_CUR);
+
+ if (!strncmp (nextname, "__.SYMDEF ", 16))
+ return do_slurp_bsd_armap (abfd);
+ else if (!strncmp (nextname, "/ ", 16))
+ return do_slurp_coff_armap (abfd);
+
+ bfd_has_map (abfd) = false;
return true;
}
\f
Intel has extended the format: longer names are stored in a special
element (the first in the archive, or second if there is an armap);
the name in the ar_hdr is replaced by <space><index into filename
- element>. Index is the P.R. of an int (radix: 8). Data General have
+ element>. Index is the P.R. of an int (decimal). Data General have
extended the format by using the prefix // for the special element */
/* Returns false on error, true otherwise */
we probably don't want to return true. */
if (bfd_read ((PTR)nextname, 1, 16, abfd) == 16) {
- bfd_seek (abfd, -16L, SEEK_CUR);
+ bfd_seek (abfd, (file_ptr) -16, SEEK_CUR);
if (strncmp (nextname, "ARFILENAMES/ ", 16) != 0 &&
strncmp (nextname, "// ", 16) != 0)
/* Since the archive is supposed to be printable if it contains
text, the entries in the list are newline-padded, not null
- padded. We'll fix that there.. */
+ padded. In SVR4-style archives, the names also have a
+ trailing '/'. We'll fix both problems here.. */
{
char *temp = bfd_ardata (abfd)->extended_names;
- for (; *temp != '\0'; ++temp)
- if (*temp == '\n') *temp = '\0';
+ char *limit = temp + namedata->parsed_size;
+ for (; temp < limit; ++temp)
+ if (*temp == '\n')
+ temp[temp[-1] == '/' ? -1 : 0] = '\0';
}
/* Pad to an even boundary if you have to */
return true;
}
+#ifdef VMS
+
+/* Return a copy of the stuff in the filename between any :]> and a
+ semicolon */
+static CONST char *
+DEFUN(normalize,(file),
+ CONST char *file)
+{
+ CONST char *first;
+ CONST char *last;
+ char *copy;
+
+ first = file + strlen(file)-1;
+ last = first+1;
+
+ while (first != file)
+ {
+ if (*first == ';')
+ last = first;
+ if (*first == ':' || *first == ']' ||*first == '>')
+ {
+ first++;
+ break;
+ }
+ first --;
+ }
+
+
+ copy = malloc(last - first + 1);
+ memcpy(copy, first, last-first);
+ copy[last-first] = 0;
+
+ return copy;
+}
+
+#else
static
-char *normalize(file)
-char *file;
+CONST char *normalize(file)
+CONST char *file;
{
- char * filename = strrchr(file, '/');
- if (filename != (char *)NULL) {
- filename ++;
+ CONST char * filename = strrchr(file, '/');
+
+ if (filename != (char *)NULL) {
+ filename ++;
}
- else {
- filename = file;
+ else {
+ filename = file;
}
-return filename;
+ return filename;
}
-
+#endif
/* Follows archive_head and produces an extended name table if necessary.
Returns (in tabloc) a pointer to an extended name table, and in tablen
the length of the table. If it makes an entry it clobbers the filename
for (current = abfd->archive_head; current != NULL; current =
current->next) {
- char *normal =normalize( current->filename);
+ CONST char *normal =normalize( current->filename);
unsigned int thislen = strlen (normal);
if (thislen > maxname) {
/* Works for now; may need to be re-engineered if we encounter an oddball
hdr->ar_name[0] = ' ';
/* We know there will always be enough room (one of the few cases
where you may safely use sprintf). */
- sprintf ((hdr->ar_name) + 1, "%-o", (unsigned) (strptr - *tabloc));
+ sprintf ((hdr->ar_name) + 1, "%-d", (unsigned) (strptr - *tabloc));
/* Kinda Kludgy. We should just use the returned value of sprintf
but not all implementations get this right */
{
return ared;
}
+/* This is magic required by the "ar" program. Since it's
+ undocumented, it's undocumented. You may think that it would
+ take a strong stomach to write this, and it does, but it takes
+ even a stronger stomach to try to code around such a thing!
+*/
+
struct ar_hdr *
DEFUN(bfd_special_undocumented_glue, (abfd, filename),
bfd *abfd AND
struct ar_hdr *hdr = (struct ar_hdr *) arhdr;
int length;
- CONST char *filename = strrchr (pathname, '/');
+ CONST char *filename = normalize(pathname);
int maxlen = ar_maxnamelen (abfd);
- if (filename == NULL)
- filename = pathname;
- else
- ++filename;
-
length = strlen (filename);
if (length <= maxlen)
bfd *current;
char *etable = NULL;
unsigned int elength = 0;
+
boolean makemap = bfd_has_map (arch);
boolean hasobjects = false; /* if no .o's, don't bother to make a map */
unsigned int i;
if (!bfd_construct_extended_name_table (arch, &etable, &elength))
return false;
- bfd_seek (arch, 0, SEEK_SET);
+ bfd_seek (arch, (file_ptr) 0, SEEK_SET);
#ifdef GNU960
bfd_write (BFD_GNU960_ARMAG(arch), 1, SARMAG, arch);
#else
bfd_error = system_call_error;
return false;
}
- if (bfd_seek (current, 0L, SEEK_SET) != 0L) goto syserr;
+ if (bfd_seek (current, (file_ptr) 0, SEEK_SET) != 0) goto syserr;
while (remaining)
{
unsigned int amt = DEFAULT_BUFFERSIZE;
if (amt > remaining) {
amt = remaining;
}
- if (bfd_read (buffer, amt, 1, current) != amt) goto syserr;
+ errno = 0;
+ if (bfd_read (buffer, amt, 1, current) != amt) {
+ if (errno) goto syserr;
+ /* Looks like a truncated archive. */
+ bfd_error = malformed_archive;
+ return false;
+ }
if (bfd_write (buffer, amt, 1, arch) != amt) goto syserr;
remaining -= amt;
}
/* Now map over all the symbols, picking out the ones we want */
for (src_count = 0; src_count <symcount; src_count++) {
- flagword flags = (syms[src_count])->flags;
- if ((flags & BSF_GLOBAL) ||
- (flags & BSF_FORT_COMM)) {
+ flagword flags =
+ (syms[src_count])->flags;
+ asection *sec =
+ syms[src_count]->section;
+
+ if ((flags & BSF_GLOBAL ||
+ flags & BSF_INDIRECT ||
+ sec == &bfd_com_section)
+ && (sec != &bfd_und_section)) {
/* This symbol will go into the archive header */
if (orl_count == orl_max)
unsigned int orl_count;
int stridx;
{
+ int padit = stridx & 1;
unsigned int ranlibsize = orl_count * sizeof (struct ranlib);
- unsigned int stringsize = stridx + 4;
- unsigned int mapsize = stringsize + ranlibsize + 4;
+ unsigned int stringsize = stridx + padit;
+ /* Include 8 bytes to store ranlibsize and stringsize in output. */
+ unsigned int mapsize = ranlibsize + stringsize + 8;
file_ptr firstreal;
bfd *current = arch->archive_head;
- bfd *last_elt = current; /* last element arch seen */
+ bfd *last_elt = current; /* last element arch seen */
int temp;
int count;
struct ar_hdr hdr;
struct stat statbuf;
unsigned int i;
- int padit = mapsize & 1;
-
- if (padit) mapsize ++;
firstreal = mapsize + elength + sizeof (struct ar_hdr) + SARMAG;
stat (arch->filename, &statbuf);
memset ((char *)(&hdr), 0, sizeof (struct ar_hdr));
sprintf (hdr.ar_name, RANLIBMAG);
- sprintf (hdr.ar_date, "%ld", statbuf.st_mtime);
+
+ /* write the timestamp of the archive header to be just a little bit
+ later than the timestamp of the file, otherwise the linker will
+ complain that the index is out of date.
+ */
+
+ sprintf (hdr.ar_date, "%ld", statbuf.st_mtime + 60);
sprintf (hdr.ar_uid, "%d", getuid());
sprintf (hdr.ar_gid, "%d", getgid());
sprintf (hdr.ar_size, "%-10d", (int) mapsize);
hdr.ar_fmag[0] = '`'; hdr.ar_fmag[1] = '\n';
for (i = 0; i < sizeof (struct ar_hdr); i++)
- if (((char *)(&hdr))[i] == '\0') (((char *)(&hdr))[i]) = ' ';
+ if (((char *)(&hdr))[i] == '\0') (((char *)(&hdr))[i]) = ' ';
bfd_write ((char *)&hdr, 1, sizeof (struct ar_hdr), arch);
bfd_h_put_32(arch, ranlibsize, (PTR)&temp);
bfd_write (&temp, 1, sizeof (temp), arch);
struct symdef *outp = &outs;
if (((bfd *)(map[count]).pos) != last_elt) {
- do {
- firstreal += arelt_size (current) + sizeof (struct ar_hdr);
- firstreal += firstreal % 2;
- current = current->next;
- } while (current != (bfd *)(map[count]).pos);
- } /* if new archive element */
+ do {
+ firstreal += arelt_size (current) + sizeof (struct ar_hdr);
+ firstreal += firstreal % 2;
+ current = current->next;
+ } while (current != (bfd *)(map[count]).pos);
+ } /* if new archive element */
last_elt = current;
bfd_h_put_32(arch, ((map[count]).namidx),(PTR) &outs.s.string_offset);
}
/* now write the strings themselves */
- bfd_h_put_32(arch, stridx, (PTR)&temp);
+ bfd_h_put_32(arch, stringsize, (PTR)&temp);
bfd_write ((PTR)&temp, 1, sizeof (temp), arch);
for (count = 0; count < orl_count; count++)
- bfd_write (*((map[count]).name), 1, strlen (*((map[count]).name))+1, arch);
+ bfd_write (*((map[count]).name), 1, strlen (*((map[count]).name))+1, arch);
/* The spec sez this should be a newline. But in order to be
bug-compatible for sun's ar we use a null. */
if (padit)
- bfd_write("\0",1,1,arch);
+ bfd_write("\0",1,1,arch);
return true;
}
number of symbols
offset of file for symbol 0
offset of file for symbol 1
- ..
+
offset of file for symbol n-1
symbol name 0
symbol name 1
- ..
+
symbol name n-1
*/
-
+
boolean
coff_write_armap (arch, elength, map, symbol_count, stridx)
bfd *arch;
unsigned int mapsize = stringsize + ranlibsize;
file_ptr archive_member_file_ptr;
bfd *current = arch->archive_head;
- bfd *last_elt = current; /* last element arch seen */
int count;
struct ar_hdr hdr;
unsigned int i;
bfd_write_bigendian_4byte_int(arch, symbol_count);
/* Two passes, first write the file offsets for each symbol -
- remembering that each offset is on a two byte boundary
- */
+ remembering that each offset is on a two byte boundary. */
/* Write out the file offset for the file associated with each
- symbol, and remember to keep the offsets padded out */
+ symbol, and remember to keep the offsets padded out. */
current = arch->archive_head;
count = 0;
projects / deliverable / binutils-gdb.git / blobdiff