Improve timestamp support in BSD archive files to avoid linker
warnings. * libbfd.h (struct artdata): Add armap_timestamp and armap_datepos. (bfd_flush, bfd_stat): Add prototypes. * libbfd.c (bfd_flush): Add, does fflush on a BFD. (bfd_stat): Add, does fstat on a BFD. * archive.c (_bfd_write_archive_contents): At end of file writing, verify and possibly update the timestamp in the armap, if a BSD archive. FIXME! Kludge recognizes BSD archive, rather than vectoring properly. Should add to xvec. (compute_and_write_armap): Move prototype to top, avoid PROTO. (bsd_write_armap): Save timestamp and file location thereof, when writing the armap in a BSD file. (bsd_update_armap_timestamp): New function to check and rewrite the timestamp.
This commit is contained in:
John Gilmore
parent
55fea07b55
commit
b5b4294e65
@ -1,5 +1,34 @@
|
||||
Mon Sep 13 21:03:18 1993 John Gilmore (gnu@cacophony.cygnus.com)
|
||||
|
||||
Improve timestamp support in BSD archive files to avoid linker
|
||||
warnings.
|
||||
|
||||
* libbfd.h (struct artdata): Add armap_timestamp and armap_datepos.
|
||||
(bfd_flush, bfd_stat): Add prototypes.
|
||||
* libbfd.c (bfd_flush): Add, does fflush on a BFD.
|
||||
(bfd_stat): Add, does fstat on a BFD.
|
||||
|
||||
* archive.c (_bfd_write_archive_contents): At end of file writing,
|
||||
verify and possibly update the timestamp in the armap, if a BSD
|
||||
archive. FIXME! Kludge recognizes BSD archive, rather than
|
||||
vectoring properly. Should add to xvec.
|
||||
(compute_and_write_armap): Move prototype to top, avoid PROTO.
|
||||
(bsd_write_armap): Save timestamp and file location thereof, when
|
||||
writing the armap in a BSD file.
|
||||
(bsd_update_armap_timestamp): New function to check and
|
||||
rewrite the timestamp.
|
||||
|
||||
Sat Sep 11 18:13:42 1993 Jim Kingdon (kingdon@poseidon.cygnus.com)
|
||||
|
||||
* hosts/i386sco.h: Define a bunch of stuff for core files.
|
||||
* sco-core.c: Remove, replace by trad-core.c.
|
||||
* trad-core.c: If HOST_STACK_START_ADDR is defined, use it.
|
||||
* config/i386sco.mh: Use trad-core not sco-core.
|
||||
* hosts/i386isc.h, config/i386isc.mh: Remove.
|
||||
* configure.host: Use i386sco for isc.
|
||||
* config/i386-sco.mt: Remove, identical to i386-coff.mt.
|
||||
* config.bfd: Use i386-coff not i386-sco.
|
||||
|
||||
* config.bfd: Recognize i[34]86-*-solaris2* specifically rather
|
||||
than using *-*-solaris2* (i486-unknown-solaris2 is i386-elf, not
|
||||
i486-elf which doesn't exist).
|
||||
|
||||
329
bfd/archive.c
329
bfd/archive.c
@ -1,5 +1,5 @@
|
||||
/* BFD back-end for archive files (libraries).
|
||||
Copyright 1990, 1991, 1992 Free Software Foundation, Inc.
|
||||
Copyright 1990, 1991, 1992, 1993 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.
|
||||
@ -91,14 +91,47 @@ DESCRIPTION
|
||||
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.
|
||||
|
||||
We support two variants of this idea:
|
||||
The SVR4 format (extended name table is named "//"),
|
||||
and an extended pseudo-BSD variant (extended name table is named
|
||||
"ARFILENAMES/"). The origin of the latter format is uncertain.
|
||||
|
||||
BSD 4.4 uses a third scheme: It writes a long filename
|
||||
directly after the header. This allows 'ar q' to work.
|
||||
We current can read BSD 4.4 archives, but not write them.
|
||||
*/
|
||||
|
||||
/* Summary of archive member names:
|
||||
|
||||
Symbol table (must be first):
|
||||
"__.SYMDEF " - Symbol table, Berkeley style, produced by ranlib.
|
||||
"/ " - Symbol table, system 5 style.
|
||||
|
||||
Long name table (must be before regular file members):
|
||||
"// " - Long name table, System 5 R4 style.
|
||||
"ARFILENAMES/ " - Long name table, non-standard extended BSD (not BSD 4.4).
|
||||
|
||||
Regular file members with short names:
|
||||
"filename.o/ " - Regular file, System 5 style (embedded spaces ok).
|
||||
"filename.o " - Regular file, Berkeley style (no embedded spaces).
|
||||
|
||||
Regular files with long names (or embedded spaces, for BSD variants):
|
||||
"/18 " - SVR4 style, name at offset 18 in name table.
|
||||
"#1/23 " - Long name (or embedded paces) 23 characters long,
|
||||
BSD 4.4 style, full name follows header.
|
||||
Implemented for reading, not writing.
|
||||
" 18 " - Long name 18 characters long, extended pseudo-BSD.
|
||||
*/
|
||||
|
||||
#include "bfd.h"
|
||||
#include "sysdep.h"
|
||||
#include "libbfd.h"
|
||||
#include "aout/ar.h"
|
||||
#include "aout/ranlib.h"
|
||||
#include <errno.h>
|
||||
#include <string.h> /* For memchr, strrchr and friends */
|
||||
#include <ctype.h>
|
||||
|
||||
#ifndef errno
|
||||
extern int errno;
|
||||
@ -124,14 +157,25 @@ struct ar_cache {
|
||||
#define ar_padchar(abfd) ((abfd)->xvec->ar_pad_char)
|
||||
#define ar_maxnamelen(abfd) ((abfd)->xvec->ar_max_namelen)
|
||||
|
||||
#define arch_hdr(bfd) ((struct ar_hdr *) \
|
||||
(((struct areltdata *)((bfd)->arelt_data))->arch_header))
|
||||
#define arch_eltdata(bfd) ((struct areltdata *)((bfd)->arelt_data))
|
||||
#define arch_hdr(bfd) ((struct ar_hdr *)arch_eltdata(bfd)->arch_header)
|
||||
|
||||
/* Forward declarations of functions */
|
||||
|
||||
boolean
|
||||
compute_and_write_armap PARAMS ((bfd *arch, unsigned int elength));
|
||||
|
||||
static boolean
|
||||
bsd_update_armap_timestamp PARAMS ((bfd *arch));
|
||||
|
||||
|
||||
|
||||
boolean
|
||||
_bfd_generic_mkarchive (abfd)
|
||||
bfd *abfd;
|
||||
{
|
||||
abfd->tdata.aout_ar_data = (struct artdata *)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;
|
||||
@ -309,7 +353,7 @@ snarf_ar_hdr (abfd)
|
||||
char *filename = NULL;
|
||||
unsigned int namelen = 0;
|
||||
unsigned int allocsize = sizeof (struct areltdata) + sizeof (struct ar_hdr);
|
||||
char *allocptr;
|
||||
char *allocptr = 0;
|
||||
|
||||
if (bfd_read ((PTR)hdrp, 1, sizeof (struct ar_hdr), abfd)
|
||||
!= sizeof (struct ar_hdr)) {
|
||||
@ -340,7 +384,30 @@ snarf_ar_hdr (abfd)
|
||||
bfd_error = malformed_archive;
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
}
|
||||
/* BSD4.4-style long filename.
|
||||
Only implemented for reading, so far! */
|
||||
else if (hdr.ar_name[0] == '#' && hdr.ar_name[1] == '1'
|
||||
&& hdr.ar_name[2] == '/' && isdigit(hdr.ar_name[3]))
|
||||
{
|
||||
/* BSD-4.4 extended name */
|
||||
namelen = atoi (&hdr.ar_name[3]);
|
||||
allocsize += namelen + 1;
|
||||
parsed_size -= namelen;
|
||||
|
||||
allocptr = bfd_zalloc(abfd, allocsize);
|
||||
if (allocptr == NULL) {
|
||||
bfd_error = no_memory;
|
||||
return NULL;
|
||||
}
|
||||
filename = allocptr
|
||||
+ (sizeof (struct areltdata) + sizeof (struct ar_hdr));
|
||||
if (bfd_read (filename, 1, namelen, abfd) != namelen) {
|
||||
bfd_error = no_more_archived_files;
|
||||
return NULL;
|
||||
}
|
||||
filename[namelen] = '\0';
|
||||
}
|
||||
else
|
||||
{
|
||||
/* We judge the end of the name by looking for '/' or ' '.
|
||||
@ -364,10 +431,12 @@ snarf_ar_hdr (abfd)
|
||||
allocsize += namelen + 1;
|
||||
}
|
||||
|
||||
allocptr = bfd_zalloc(abfd, allocsize);
|
||||
if (allocptr == NULL) {
|
||||
if (!allocptr) {
|
||||
allocptr = bfd_zalloc(abfd, allocsize);
|
||||
if (allocptr == NULL) {
|
||||
bfd_error = no_memory;
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
|
||||
ared = (struct areltdata *) allocptr;
|
||||
@ -394,9 +463,9 @@ snarf_ar_hdr (abfd)
|
||||
*/
|
||||
|
||||
bfd *
|
||||
get_elt_at_filepos (archive, filepos)
|
||||
bfd *archive;
|
||||
file_ptr filepos;
|
||||
DEFUN (get_elt_at_filepos, (archive, filepos),
|
||||
bfd *archive AND
|
||||
file_ptr filepos)
|
||||
{
|
||||
struct areltdata *new_areldata;
|
||||
bfd *n_nfd;
|
||||
@ -499,8 +568,11 @@ bfd *bfd_generic_openr_next_archived_file(archive, last_file)
|
||||
filestart = bfd_ardata (archive)->first_file_filepos;
|
||||
else {
|
||||
unsigned int size = arelt_size(last_file);
|
||||
/* Pad to an even boundary... */
|
||||
filestart = last_file->origin + size + size%2;
|
||||
/* Pad to an even boundary...
|
||||
Note that last_file->origin can be odd in the case of
|
||||
BSD-4.4-style element with a long odd size. */
|
||||
filestart = last_file->origin + size;
|
||||
filestart += filestart % 2;
|
||||
}
|
||||
|
||||
return get_elt_at_filepos (archive, filestart);
|
||||
@ -538,7 +610,7 @@ bfd_generic_archive_p (abfd)
|
||||
|
||||
bfd_ardata (abfd)->first_file_filepos = SARMAG;
|
||||
|
||||
if (!bfd_slurp_armap (abfd)) {
|
||||
if (!BFD_SEND (abfd, _bfd_slurp_armap, (abfd))) {
|
||||
bfd_release(abfd, bfd_ardata (abfd));
|
||||
abfd->tdata.aout_ar_data = NULL;
|
||||
return 0;
|
||||
@ -555,12 +627,10 @@ bfd_generic_archive_p (abfd)
|
||||
|
||||
/* Returns false on error, true otherwise */
|
||||
static boolean
|
||||
do_slurp_bsd_armap (abfd)
|
||||
bfd *abfd;
|
||||
DEFUN (do_slurp_bsd_armap, (abfd),
|
||||
bfd *abfd)
|
||||
{
|
||||
|
||||
struct areltdata *mapdata;
|
||||
char nextname[17];
|
||||
unsigned int counter = 0;
|
||||
int *raw_armap, *rbase;
|
||||
struct artdata *ardata = bfd_ardata (abfd);
|
||||
@ -618,21 +688,19 @@ do_slurp_bsd_armap (abfd)
|
||||
|
||||
/* Returns false on error, true otherwise */
|
||||
static boolean
|
||||
do_slurp_coff_armap (abfd)
|
||||
bfd *abfd;
|
||||
DEFUN (do_slurp_coff_armap, (abfd),
|
||||
bfd *abfd)
|
||||
{
|
||||
struct areltdata *mapdata;
|
||||
char nextname;
|
||||
int *raw_armap, *rawptr;
|
||||
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. */
|
||||
|
||||
bfd_vma (*swap)();
|
||||
bfd_vma (*swap) PARAMS ((bfd_byte*));
|
||||
char int_buf[sizeof(long)];
|
||||
unsigned int carsym_size, ptrsize, i;
|
||||
|
||||
@ -647,8 +715,8 @@ do_slurp_coff_armap (abfd)
|
||||
}
|
||||
/* 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);
|
||||
swap = bfd_getb32;
|
||||
nsymz = bfd_getb32((PTR)int_buf);
|
||||
stringsize = parsed_size - (4 * nsymz) - 4;
|
||||
|
||||
#if 1
|
||||
@ -659,9 +727,9 @@ do_slurp_coff_armap (abfd)
|
||||
|
||||
if (stringsize > 0xfffff) {
|
||||
/* This looks dangerous, let's do it the other way around */
|
||||
nsymz = _do_getl32((PTR)int_buf);
|
||||
nsymz = bfd_getl32((PTR)int_buf);
|
||||
stringsize = parsed_size - (4 * nsymz) - 4;
|
||||
swap = _do_getl32;
|
||||
swap = bfd_getl32;
|
||||
}
|
||||
#endif
|
||||
|
||||
@ -743,6 +811,96 @@ bfd_slurp_armap (abfd)
|
||||
return true;
|
||||
}
|
||||
|
||||
/* Returns false on error, true otherwise */
|
||||
/* flavor 2 of a bsd armap, similar to bfd_slurp_bsd_armap except the
|
||||
header is in a slightly different order and the map name is '/'.
|
||||
This flavour is used by hp300hpux. */
|
||||
boolean
|
||||
bfd_slurp_bsd_armap_f2 (abfd)
|
||||
bfd *abfd;
|
||||
{
|
||||
struct areltdata *mapdata;
|
||||
char nextname[17];
|
||||
unsigned int counter = 0;
|
||||
int *raw_armap, *rbase;
|
||||
struct artdata *ardata = bfd_ardata (abfd);
|
||||
char *stringbase;
|
||||
unsigned int stringsize;
|
||||
int i = bfd_read ((PTR)nextname, 1, 16, abfd);
|
||||
|
||||
if (i == 0)
|
||||
return true;
|
||||
if (i != 16)
|
||||
return false;
|
||||
|
||||
/* The archive has at least 16 bytes in it */
|
||||
bfd_seek (abfd, -16L, SEEK_CUR);
|
||||
|
||||
if (!strncmp (nextname, "__.SYMDEF ", 16))
|
||||
return do_slurp_bsd_armap (abfd);
|
||||
|
||||
if (strncmp (nextname, "/ ", 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;
|
||||
byebyebye:
|
||||
bfd_release (abfd, (PTR)raw_armap);
|
||||
goto byebye;
|
||||
}
|
||||
|
||||
ardata->symdef_count = bfd_h_get_16(abfd, (PTR)raw_armap);
|
||||
|
||||
if (ardata->symdef_count * sizeof (struct symdef)
|
||||
> mapdata->parsed_size - sizeof (*raw_armap))
|
||||
{
|
||||
/* Probably we're using the wrong byte ordering. */
|
||||
bfd_error = wrong_format;
|
||||
goto byebyebye;
|
||||
}
|
||||
|
||||
ardata->cache = 0;
|
||||
|
||||
stringsize = bfd_h_get_32(abfd, (PTR)(((char*)raw_armap)+2));
|
||||
/* skip sym count and string sz */
|
||||
rbase = (int*)(((char*)raw_armap) + 6);
|
||||
stringbase = (char *) rbase;
|
||||
ardata->symdefs = (carsym *)(((char*) rbase) + stringsize);
|
||||
|
||||
for (;counter < ardata->symdef_count; counter++)
|
||||
{
|
||||
struct symdef *sym = ((struct symdef *) ardata->symdefs) + 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;
|
||||
}
|
||||
|
||||
/** Extended name table.
|
||||
|
||||
Normally archives support only 14-character filenames.
|
||||
@ -845,7 +1003,7 @@ DEFUN(normalize,(file),
|
||||
}
|
||||
|
||||
|
||||
copy = malloc(last - first + 1);
|
||||
copy = bfd_xmalloc(last - first + 1);
|
||||
memcpy(copy, first, last-first);
|
||||
copy[last-first] = 0;
|
||||
|
||||
@ -853,9 +1011,9 @@ DEFUN(normalize,(file),
|
||||
}
|
||||
|
||||
#else
|
||||
static
|
||||
CONST char *normalize(file)
|
||||
CONST char *file;
|
||||
static CONST char *
|
||||
DEFUN (normalize, (file),
|
||||
CONST char *file)
|
||||
{
|
||||
CONST char * filename = strrchr(file, '/');
|
||||
|
||||
@ -876,10 +1034,10 @@ CONST char *file;
|
||||
A successful return may still involve a zero-length tablen!
|
||||
*/
|
||||
boolean
|
||||
bfd_construct_extended_name_table (abfd, tabloc, tablen)
|
||||
bfd *abfd;
|
||||
char **tabloc;
|
||||
unsigned int *tablen;
|
||||
DEFUN (bfd_construct_extended_name_table, (abfd, tabloc, tablen),
|
||||
bfd *abfd AND
|
||||
char **tabloc AND
|
||||
unsigned int *tablen)
|
||||
{
|
||||
unsigned int maxname = abfd->xvec->ar_max_namelen;
|
||||
unsigned int total_namelen = 0;
|
||||
@ -1033,7 +1191,8 @@ bfd_generic_stat_arch_elt (abfd, buf)
|
||||
foo (ar_uid, st_uid, 10);
|
||||
foo (ar_gid, st_gid, 10);
|
||||
foo (ar_mode, st_mode, 8);
|
||||
foo (ar_size, st_size, 10);
|
||||
|
||||
buf->st_size = arch_eltdata (abfd)->parsed_size;
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -1135,8 +1294,6 @@ bfd_gnu_truncate_arname (abfd, pathname, arhdr)
|
||||
}
|
||||
|
||||
|
||||
PROTO (boolean, compute_and_write_armap, (bfd *arch, unsigned int elength));
|
||||
|
||||
/* The BFD is open for write and has its format set to bfd_archive */
|
||||
boolean
|
||||
_bfd_write_archive_contents (arch)
|
||||
@ -1145,10 +1302,10 @@ _bfd_write_archive_contents (arch)
|
||||
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;
|
||||
int tries;
|
||||
|
||||
/* Verify the viability of all entries; if any of them live in the
|
||||
filesystem (as opposed to living in an archive open for input)
|
||||
@ -1245,7 +1402,36 @@ _bfd_write_archive_contents (arch)
|
||||
}
|
||||
if ((arelt_size (current) % 2) == 1) bfd_write ("\n", 1, 1, arch);
|
||||
}
|
||||
return true;
|
||||
|
||||
/* Verify the timestamp in the archive file. If it would
|
||||
not be accepted by the linker, rewrite it until it would be.
|
||||
If anything odd happens, break out and just return.
|
||||
(The Berkeley linker checks the timestamp and refuses to read the
|
||||
table-of-contents if it is >60 seconds less than the file's
|
||||
modified-time. That painful hack requires this painful hack. */
|
||||
|
||||
tries = 1;
|
||||
do {
|
||||
/* FIXME! This kludge is to avoid adding a member to the xvec,
|
||||
while generating a small patch for Adobe. FIXME! The
|
||||
update_armap_timestamp function call should be in the xvec,
|
||||
thus:
|
||||
|
||||
if (bfd_update_armap_timestamp (arch) == true) break;
|
||||
^
|
||||
|
||||
Instead, we check whether in a BSD archive, and call directly. */
|
||||
|
||||
if (arch->xvec->write_armap != bsd_write_armap)
|
||||
break;
|
||||
if (bsd_update_armap_timestamp(arch) == true) /* FIXME!!! Vector it */
|
||||
break;
|
||||
if (tries > 0)
|
||||
fprintf (stderr,
|
||||
"Warning: writing archive was slow: rewriting timestamp\n");
|
||||
} while (++tries < 6 );
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/* Note that the namidx for the first symbol is 0 */
|
||||
@ -1310,8 +1496,8 @@ compute_and_write_armap (arch, elength)
|
||||
syms[src_count]->section;
|
||||
|
||||
if ((flags & BSF_GLOBAL ||
|
||||
flags & BSF_INDIRECT ||
|
||||
sec == &bfd_com_section)
|
||||
flags & BSF_INDIRECT ||
|
||||
bfd_is_com_section (sec))
|
||||
&& (sec != &bfd_und_section)) {
|
||||
|
||||
/* This symbol will go into the archive header */
|
||||
@ -1371,13 +1557,10 @@ bsd_write_armap (arch, elength, map, orl_count, stridx)
|
||||
stat (arch->filename, &statbuf);
|
||||
memset ((char *)(&hdr), 0, sizeof (struct ar_hdr));
|
||||
sprintf (hdr.ar_name, RANLIBMAG);
|
||||
|
||||
/* 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);
|
||||
/* Remember the timestamp, to keep it holy. But fudge it a little. */
|
||||
bfd_ardata(arch)->armap_timestamp = statbuf.st_mtime + ARMAP_TIME_OFFSET;
|
||||
bfd_ardata(arch)->armap_datepos = SARMAG + offsetof(struct ar_hdr, ar_date);
|
||||
sprintf (hdr.ar_date, "%ld", bfd_ardata(arch)->armap_timestamp);
|
||||
sprintf (hdr.ar_uid, "%d", getuid());
|
||||
sprintf (hdr.ar_gid, "%d", getgid());
|
||||
sprintf (hdr.ar_size, "%-10d", (int) mapsize);
|
||||
@ -1385,7 +1568,7 @@ bsd_write_armap (arch, elength, map, orl_count, stridx)
|
||||
for (i = 0; i < sizeof (struct ar_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_h_put_32(arch, (bfd_vma) ranlibsize, (PTR)&temp);
|
||||
bfd_write (&temp, 1, sizeof (temp), arch);
|
||||
|
||||
for (count = 0; count < orl_count; count++) {
|
||||
@ -1419,6 +1602,52 @@ bsd_write_armap (arch, elength, map, orl_count, stridx)
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
/* At the end of archive file handling, update the timestamp in the
|
||||
file, so the linker will accept it.
|
||||
|
||||
Return true if the timestamp was OK, or an unusual problem happened.
|
||||
Return false if we updated the timestamp. */
|
||||
|
||||
static boolean
|
||||
bsd_update_armap_timestamp (arch)
|
||||
bfd *arch;
|
||||
{
|
||||
struct stat archstat;
|
||||
struct ar_hdr hdr;
|
||||
int i;
|
||||
|
||||
/* Flush writes, get last-write timestamp from file, and compare it
|
||||
to the timestamp IN the file. */
|
||||
bfd_flush (arch);
|
||||
if (bfd_stat (arch, &archstat) == -1) {
|
||||
perror ("Reading archive file mod timestamp");
|
||||
return true; /* Can't read mod time for some reason */
|
||||
}
|
||||
if (archstat.st_mtime <= bfd_ardata(arch)->armap_timestamp)
|
||||
return true; /* OK by the linker's rules */
|
||||
|
||||
/* Update the timestamp. */
|
||||
bfd_ardata(arch)->armap_timestamp = archstat.st_mtime + ARMAP_TIME_OFFSET;
|
||||
|
||||
/* Prepare an ASCII version suitable for writing. */
|
||||
memset (hdr.ar_date, 0, sizeof (hdr.ar_date));
|
||||
sprintf (hdr.ar_date, "%ld", bfd_ardata(arch)->armap_timestamp);
|
||||
for (i = 0; i < sizeof (hdr.ar_date); i++)
|
||||
if (hdr.ar_date[i] == '\0')
|
||||
(hdr.ar_date)[i] = ' ';
|
||||
|
||||
/* Write it into the file. */
|
||||
bfd_seek (arch, bfd_ardata(arch)->armap_datepos, SEEK_SET);
|
||||
if (bfd_write (hdr.ar_date, sizeof(hdr.ar_date), 1, arch)
|
||||
!= sizeof(hdr.ar_date)) {
|
||||
perror ("Writing updated armap timestamp");
|
||||
return true; /* Some error while writing */
|
||||
}
|
||||
|
||||
return false; /* We updated the timestamp successfully. */
|
||||
}
|
||||
|
||||
|
||||
/* A coff armap looks like :
|
||||
|
||||
102
bfd/libbfd.c
102
bfd/libbfd.c
@ -121,10 +121,10 @@ char *
|
||||
DEFUN(zalloc,(size),
|
||||
bfd_size_type size)
|
||||
{
|
||||
char *ptr = (char *) malloc ((int)size);
|
||||
char *ptr = (char *) malloc ((size_t)size);
|
||||
|
||||
if ((ptr != NULL) && (size != 0))
|
||||
memset(ptr,0, size);
|
||||
memset(ptr,0, (size_t) size);
|
||||
|
||||
return ptr;
|
||||
}
|
||||
@ -153,7 +153,7 @@ DEFUN(PTR bfd_xmalloc,(size),
|
||||
static CONST char no_memory_message[] = "Virtual memory exhausted!\n";
|
||||
PTR ptr;
|
||||
if (size == 0) size = 1;
|
||||
ptr = (PTR)malloc(size);
|
||||
ptr = (PTR)malloc((size_t) size);
|
||||
if (!ptr)
|
||||
{
|
||||
write (2, no_memory_message, sizeof(no_memory_message)-1);
|
||||
@ -161,6 +161,24 @@ DEFUN(PTR bfd_xmalloc,(size),
|
||||
}
|
||||
return ptr;
|
||||
}
|
||||
|
||||
/*
|
||||
INTERNAL_FUNCTION
|
||||
bfd_xmalloc_by_size_t
|
||||
|
||||
SYNOPSIS
|
||||
PTR bfd_xmalloc_by_size_t ( size_t size);
|
||||
|
||||
DESCRIPTION
|
||||
Like malloc, but exit if no more memory.
|
||||
Uses size_t, so it's suitable for use as obstack_chunk_alloc.
|
||||
*/
|
||||
PTR
|
||||
DEFUN(bfd_xmalloc_by_size_t, (size),
|
||||
size_t size)
|
||||
{
|
||||
return bfd_xmalloc ((bfd_size_type) size);
|
||||
}
|
||||
|
||||
/* Some IO code */
|
||||
|
||||
@ -221,7 +239,7 @@ SYNOPSIS
|
||||
|
||||
DESCRIPTION
|
||||
Writes a 4 byte integer to the outputing bfd, in big endian
|
||||
mode regardless of what else is going on. This is usefull in
|
||||
mode regardless of what else is going on. This is useful in
|
||||
archives.
|
||||
|
||||
*/
|
||||
@ -231,7 +249,7 @@ DEFUN(bfd_write_bigendian_4byte_int,(abfd, i),
|
||||
int i)
|
||||
{
|
||||
bfd_byte buffer[4];
|
||||
_do_putb32(i, buffer);
|
||||
bfd_putb32(i, buffer);
|
||||
bfd_write((PTR)buffer, 4, 1, abfd);
|
||||
}
|
||||
|
||||
@ -249,6 +267,21 @@ DEFUN(bfd_tell,(abfd),
|
||||
return ptr;
|
||||
}
|
||||
|
||||
int
|
||||
DEFUN(bfd_flush,(abfd),
|
||||
bfd *abfd)
|
||||
{
|
||||
return fflush (bfd_cache_lookup(abfd));
|
||||
}
|
||||
|
||||
int
|
||||
DEFUN(bfd_stat,(abfd, statbuf),
|
||||
bfd *abfd AND
|
||||
struct stat *statbuf)
|
||||
{
|
||||
return fstat (fileno(bfd_cache_lookup(abfd)), statbuf);
|
||||
}
|
||||
|
||||
int
|
||||
DEFUN(bfd_seek,(abfd, position, direction),
|
||||
bfd * CONST abfd AND
|
||||
@ -349,7 +382,7 @@ DEFUN(bfd_add_to_string_table,(table, new_string, table_length, free_ptr),
|
||||
take it next time */
|
||||
space_length = (string_length < DEFAULT_STRING_SPACE_SIZE ?
|
||||
DEFAULT_STRING_SPACE_SIZE : string_length+1);
|
||||
base = zalloc (space_length);
|
||||
base = zalloc ((bfd_size_type) space_length);
|
||||
|
||||
if (base == NULL) {
|
||||
bfd_error = no_memory;
|
||||
@ -515,35 +548,35 @@ DESCRIPTION
|
||||
(((x) ^ EIGHT_GAZILLION) - EIGHT_GAZILLION))
|
||||
|
||||
bfd_vma
|
||||
DEFUN(_do_getb16,(addr),
|
||||
DEFUN(bfd_getb16,(addr),
|
||||
register bfd_byte *addr)
|
||||
{
|
||||
return (addr[0] << 8) | addr[1];
|
||||
}
|
||||
|
||||
bfd_vma
|
||||
DEFUN(_do_getl16,(addr),
|
||||
DEFUN(bfd_getl16,(addr),
|
||||
register bfd_byte *addr)
|
||||
{
|
||||
return (addr[1] << 8) | addr[0];
|
||||
}
|
||||
|
||||
bfd_signed_vma
|
||||
DEFUN(_do_getb_signed_16,(addr),
|
||||
DEFUN(bfd_getb_signed_16,(addr),
|
||||
register bfd_byte *addr)
|
||||
{
|
||||
return COERCE16((addr[0] << 8) | addr[1]);
|
||||
}
|
||||
|
||||
bfd_signed_vma
|
||||
DEFUN(_do_getl_signed_16,(addr),
|
||||
DEFUN(bfd_getl_signed_16,(addr),
|
||||
register bfd_byte *addr)
|
||||
{
|
||||
return COERCE16((addr[1] << 8) | addr[0]);
|
||||
}
|
||||
|
||||
void
|
||||
DEFUN(_do_putb16,(data, addr),
|
||||
DEFUN(bfd_putb16,(data, addr),
|
||||
bfd_vma data AND
|
||||
register bfd_byte *addr)
|
||||
{
|
||||
@ -552,7 +585,7 @@ DEFUN(_do_putb16,(data, addr),
|
||||
}
|
||||
|
||||
void
|
||||
DEFUN(_do_putl16,(data, addr),
|
||||
DEFUN(bfd_putl16,(data, addr),
|
||||
bfd_vma data AND
|
||||
register bfd_byte *addr)
|
||||
{
|
||||
@ -561,21 +594,21 @@ DEFUN(_do_putl16,(data, addr),
|
||||
}
|
||||
|
||||
bfd_vma
|
||||
_do_getb32 (addr)
|
||||
bfd_getb32 (addr)
|
||||
register bfd_byte *addr;
|
||||
{
|
||||
return ((((addr[0] << 8) | addr[1]) << 8) | addr[2]) << 8 | addr[3];
|
||||
}
|
||||
|
||||
bfd_vma
|
||||
_do_getl32 (addr)
|
||||
bfd_getl32 (addr)
|
||||
register bfd_byte *addr;
|
||||
{
|
||||
return ((((addr[3] << 8) | addr[2]) << 8) | addr[1]) << 8 | addr[0];
|
||||
}
|
||||
|
||||
bfd_signed_vma
|
||||
_do_getb_signed_32 (addr)
|
||||
bfd_getb_signed_32 (addr)
|
||||
register bfd_byte *addr;
|
||||
{
|
||||
return COERCE32(((((addr[0] << 8) | addr[1]) << 8)
|
||||
@ -583,7 +616,7 @@ _do_getb_signed_32 (addr)
|
||||
}
|
||||
|
||||
bfd_signed_vma
|
||||
_do_getl_signed_32 (addr)
|
||||
bfd_getl_signed_32 (addr)
|
||||
register bfd_byte *addr;
|
||||
{
|
||||
return COERCE32(((((addr[3] << 8) | addr[2]) << 8)
|
||||
@ -591,10 +624,10 @@ _do_getl_signed_32 (addr)
|
||||
}
|
||||
|
||||
bfd_vma
|
||||
DEFUN(_do_getb64,(addr),
|
||||
DEFUN(bfd_getb64,(addr),
|
||||
register bfd_byte *addr)
|
||||
{
|
||||
#ifdef HOST_64_BIT
|
||||
#ifdef BFD64
|
||||
bfd_vma low, high;
|
||||
|
||||
high= ((((((((addr[0]) << 8) |
|
||||
@ -616,11 +649,11 @@ DEFUN(_do_getb64,(addr),
|
||||
}
|
||||
|
||||
bfd_vma
|
||||
DEFUN(_do_getl64,(addr),
|
||||
DEFUN(bfd_getl64,(addr),
|
||||
register bfd_byte *addr)
|
||||
{
|
||||
|
||||
#ifdef HOST_64_BIT
|
||||
#ifdef BFD64
|
||||
bfd_vma low, high;
|
||||
high= (((((((addr[7] << 8) |
|
||||
addr[6]) << 8) |
|
||||
@ -641,10 +674,10 @@ DEFUN(_do_getl64,(addr),
|
||||
}
|
||||
|
||||
bfd_signed_vma
|
||||
DEFUN(_do_getb_signed_64,(addr),
|
||||
DEFUN(bfd_getb_signed_64,(addr),
|
||||
register bfd_byte *addr)
|
||||
{
|
||||
#ifdef HOST_64_BIT
|
||||
#ifdef BFD64
|
||||
bfd_vma low, high;
|
||||
|
||||
high= ((((((((addr[0]) << 8) |
|
||||
@ -666,11 +699,11 @@ DEFUN(_do_getb_signed_64,(addr),
|
||||
}
|
||||
|
||||
bfd_signed_vma
|
||||
DEFUN(_do_getl_signed_64,(addr),
|
||||
DEFUN(bfd_getl_signed_64,(addr),
|
||||
register bfd_byte *addr)
|
||||
{
|
||||
|
||||
#ifdef HOST_64_BIT
|
||||
#ifdef BFD64
|
||||
bfd_vma low, high;
|
||||
high= (((((((addr[7] << 8) |
|
||||
addr[6]) << 8) |
|
||||
@ -691,7 +724,7 @@ DEFUN(_do_getl_signed_64,(addr),
|
||||
}
|
||||
|
||||
void
|
||||
DEFUN(_do_putb32,(data, addr),
|
||||
DEFUN(bfd_putb32,(data, addr),
|
||||
bfd_vma data AND
|
||||
register bfd_byte *addr)
|
||||
{
|
||||
@ -702,7 +735,7 @@ DEFUN(_do_putb32,(data, addr),
|
||||
}
|
||||
|
||||
void
|
||||
DEFUN(_do_putl32,(data, addr),
|
||||
DEFUN(bfd_putl32,(data, addr),
|
||||
bfd_vma data AND
|
||||
register bfd_byte *addr)
|
||||
{
|
||||
@ -712,11 +745,11 @@ DEFUN(_do_putl32,(data, addr),
|
||||
addr[3] = (bfd_byte)(data >> 24);
|
||||
}
|
||||
void
|
||||
DEFUN(_do_putb64,(data, addr),
|
||||
DEFUN(bfd_putb64,(data, addr),
|
||||
bfd_vma data AND
|
||||
register bfd_byte *addr)
|
||||
{
|
||||
#ifdef HOST_64_BIT
|
||||
#ifdef BFD64
|
||||
addr[0] = (bfd_byte)(data >> (7*8));
|
||||
addr[1] = (bfd_byte)(data >> (6*8));
|
||||
addr[2] = (bfd_byte)(data >> (5*8));
|
||||
@ -732,11 +765,11 @@ DEFUN(_do_putb64,(data, addr),
|
||||
}
|
||||
|
||||
void
|
||||
DEFUN(_do_putl64,(data, addr),
|
||||
DEFUN(bfd_putl64,(data, addr),
|
||||
bfd_vma data AND
|
||||
register bfd_byte *addr)
|
||||
{
|
||||
#ifdef HOST_64_BIT
|
||||
#ifdef BFD64
|
||||
addr[7] = (bfd_byte)(data >> (7*8));
|
||||
addr[6] = (bfd_byte)(data >> (6*8));
|
||||
addr[5] = (bfd_byte)(data >> (5*8));
|
||||
@ -801,13 +834,14 @@ DESCRIPTION
|
||||
arg of 1025 would return 11.
|
||||
|
||||
SYNOPSIS
|
||||
bfd_vma bfd_log2(bfd_vma x);
|
||||
unsigned int bfd_log2(bfd_vma x);
|
||||
*/
|
||||
|
||||
bfd_vma bfd_log2(x)
|
||||
bfd_vma x;
|
||||
unsigned
|
||||
bfd_log2(x)
|
||||
bfd_vma x;
|
||||
{
|
||||
bfd_vma result = 0;
|
||||
unsigned result = 0;
|
||||
while ( (bfd_vma)(1<< result) < x)
|
||||
result++;
|
||||
return result;
|
||||
|
||||
53
bfd/libbfd.h
53
bfd/libbfd.h
@ -44,6 +44,15 @@ struct artdata {
|
||||
carsym *symdefs; /* the symdef entries */
|
||||
symindex symdef_count; /* how many there are */
|
||||
char *extended_names; /* clever intel extension */
|
||||
|
||||
time_t armap_timestamp; /* Timestamp value written into armap.
|
||||
This is used for BSD archives to check
|
||||
that the timestamp is recent enough
|
||||
for the BSD linker to not complain,
|
||||
just before we finish writing an
|
||||
archive. */
|
||||
file_ptr armap_datepos; /* Position within archive to seek to
|
||||
rewrite the date field. */
|
||||
};
|
||||
|
||||
#define bfd_ardata(bfd) ((bfd)->tdata.aout_ar_data)
|
||||
@ -80,6 +89,9 @@ int bfd_seek PARAMS ((bfd* CONST abfd, CONST file_ptr fp,
|
||||
CONST int direction));
|
||||
long bfd_tell PARAMS ((bfd *abfd));
|
||||
|
||||
int bfd_flush PARAMS ((bfd *abfd));
|
||||
int bfd_stat PARAMS ((bfd *abfd, struct stat *));
|
||||
|
||||
bfd * _bfd_create_empty_archive_element_shell PARAMS ((bfd *obfd));
|
||||
bfd * look_for_bfd_in_cache PARAMS ((bfd *arch_bfd, file_ptr index));
|
||||
boolean _bfd_generic_mkarchive PARAMS ((bfd *abfd));
|
||||
@ -98,47 +110,6 @@ boolean bfd_add_to_string_table PARAMS ((char **table, char *new_string,
|
||||
unsigned int *table_length,
|
||||
char **free_ptr));
|
||||
|
||||
/* Byte swapping routines from libbfd.c */
|
||||
|
||||
/* namespace protection */
|
||||
#define _do_getb64 _bfd__do_getb64
|
||||
#define _do_getl64 _bfd__do_getl64
|
||||
#define _do_getb_signed_64 _bfd__do_getb_signed_64
|
||||
#define _do_getl_signed_64 _bfd__do_getl_signed_64
|
||||
#define _do_getb32 _bfd__do_getb32
|
||||
#define _do_getl32 _bfd__do_getl32
|
||||
#define _do_getb_signed_32 _bfd__do_getb_signed_32
|
||||
#define _do_getl_signed_32 _bfd__do_getl_signed_32
|
||||
#define _do_getb16 _bfd__do_getb16
|
||||
#define _do_getl16 _bfd__do_getl16
|
||||
#define _do_getb_signed_16 _bfd__do_getb_signed_16
|
||||
#define _do_getl_signed_16 _bfd__do_getl_signed_16
|
||||
#define _do_putb64 _bfd__do_putb64
|
||||
#define _do_putl64 _bfd__do_putl64
|
||||
#define _do_putb32 _bfd__do_putb32
|
||||
#define _do_putl32 _bfd__do_putl32
|
||||
#define _do_putb16 _bfd__do_putb16
|
||||
#define _do_putl16 _bfd__do_putl16
|
||||
|
||||
bfd_vma _do_getb64 PARAMS ((unsigned char *addr));
|
||||
bfd_vma _do_getl64 PARAMS ((unsigned char *addr));
|
||||
bfd_signed_vma _do_getb_signed_64 PARAMS ((unsigned char *addr));
|
||||
bfd_signed_vma _do_getl_signed_64 PARAMS ((unsigned char *addr));
|
||||
bfd_vma _do_getb32 PARAMS ((unsigned char *addr));
|
||||
bfd_vma _do_getl32 PARAMS ((unsigned char *addr));
|
||||
bfd_signed_vma _do_getb_signed_32 PARAMS ((unsigned char *addr));
|
||||
bfd_signed_vma _do_getl_signed_32 PARAMS ((unsigned char *addr));
|
||||
bfd_vma _do_getb16 PARAMS ((unsigned char *addr));
|
||||
bfd_vma _do_getl16 PARAMS ((unsigned char *addr));
|
||||
bfd_signed_vma _do_getb_signed_16 PARAMS ((unsigned char *addr));
|
||||
bfd_signed_vma _do_getl_signed_16 PARAMS ((unsigned char *addr));
|
||||
void _do_putb64 PARAMS ((bfd_vma data, unsigned char *addr));
|
||||
void _do_putl64 PARAMS ((bfd_vma data, unsigned char *addr));
|
||||
void _do_putb32 PARAMS ((bfd_vma data, unsigned char *addr));
|
||||
void _do_putl32 PARAMS ((bfd_vma data, unsigned char *addr));
|
||||
void _do_putb16 PARAMS ((bfd_vma data, unsigned char *addr));
|
||||
void _do_putl16 PARAMS ((bfd_vma data, unsigned char *addr));
|
||||
|
||||
boolean bfd_false PARAMS ((bfd *ignore));
|
||||
boolean bfd_true PARAMS ((bfd *ignore));
|
||||
PTR bfd_nullvoidptr PARAMS ((bfd *ignore));
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user