From b5b4294e653c033981eb8eee4f0473e520e0b5d5 Mon Sep 17 00:00:00 2001 From: John Gilmore Date: Tue, 14 Sep 1993 04:13:43 +0000 Subject: 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. --- bfd/ChangeLog | 29 ++++++ bfd/archive.c | 329 +++++++++++++++++++++++++++++++++++++++++++++++++--------- bfd/libbfd.c | 102 ++++++++++++------ bfd/libbfd.h | 53 +++------- 4 files changed, 388 insertions(+), 125 deletions(-) diff --git a/bfd/ChangeLog b/bfd/ChangeLog index 16956d0..5cc8555 100644 --- a/bfd/ChangeLog +++ b/bfd/ChangeLog @@ -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). diff --git a/bfd/archive.c b/bfd/archive.c index 4f22658..f937d35 100644 --- a/bfd/archive.c +++ b/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 +#include /* For memchr, strrchr and friends */ +#include #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 : diff --git a/bfd/libbfd.c b/bfd/libbfd.c index 3133f10..1ab0fe3 100644 --- a/bfd/libbfd.c +++ b/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); } @@ -250,6 +268,21 @@ DEFUN(bfd_tell,(abfd), } 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 CONST file_ptr position 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; diff --git a/bfd/libbfd.h b/bfd/libbfd.h index 0335cab..8712e79 100644 --- a/bfd/libbfd.h +++ b/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)); -- cgit v1.1