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.

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 <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 :
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));