X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gprof%2Fgmon_io.c;h=5686ebb6b99d679babd6374e012a97c10c2bae76;hb=refs%2Fheads%2Fconcurrent-displaced-stepping-2020-04-01;hp=d66b969281ac98c41cd726bdcc67b8e3a8b6cfee;hpb=fa803dc60f0bf01297674c41d001798e18ade4dc;p=deliverable%2Fbinutils-gdb.git

diff --git a/gprof/gmon_io.c b/gprof/gmon_io.c
index d66b969281..5686ebb6b9 100644
--- a/gprof/gmon_io.c
+++ b/gprof/gmon_io.c
@@ -1,116 +1,347 @@
-/*
- * Input and output from/to gmon.out files.
- */
+/* gmon_io.c - Input and output from/to gmon.out files.
+
+   Copyright (C) 1999-2020 Free Software Foundation, Inc.
+
+   This file is part of GNU Binutils.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
+   02110-1301, USA.  */
+
+#include "gprof.h"
+#include "binary-io.h"
+#include "search_list.h"
+#include "source.h"
+#include "symtab.h"
 #include "cg_arcs.h"
 #include "basic_blocks.h"
-#include "bfd.h"
-#include "core.h"
+#include "corefile.h"
 #include "call_graph.h"
 #include "gmon_io.h"
 #include "gmon_out.h"
-#include "gmon.h"		/* fetch header for old format */
-#include "gprof.h"
+#include "gmon.h"		/* Fetch header for old format.  */
 #include "hertz.h"
 #include "hist.h"
 #include "libiberty.h"
 
+enum gmon_ptr_size {
+  ptr_32bit,
+  ptr_64bit
+};
+
+enum gmon_ptr_signedness {
+  ptr_signed,
+  ptr_unsigned
+};
+
+static enum gmon_ptr_size gmon_get_ptr_size (void);
+static enum gmon_ptr_signedness gmon_get_ptr_signedness (void);
+
+#ifdef BFD_HOST_U_64_BIT
+static int gmon_io_read_64 (FILE *, BFD_HOST_U_64_BIT *);
+static int gmon_io_write_64 (FILE *, BFD_HOST_U_64_BIT);
+#endif
+static int gmon_read_raw_arc
+  (FILE *, bfd_vma *, bfd_vma *, unsigned long *);
+static int gmon_write_raw_arc
+  (FILE *, bfd_vma, bfd_vma, unsigned long);
+
 int gmon_input = 0;
-int gmon_file_version = 0;	/* 0 == old (non-versioned) file format */
+int gmon_file_version = 0;	/* 0 == old (non-versioned) file format.  */
 
-/*
- * This probably ought to be in libbfd.
- */
-bfd_vma
-DEFUN (get_vma, (abfd, addr), bfd * abfd AND bfd_byte * addr)
+static enum gmon_ptr_size
+gmon_get_ptr_size (void)
 {
-  switch (sizeof (char*))
+  int size;
+
+  /* Pick best size for pointers.  Start with the ELF size, and if not
+     elf go with the architecture's address size.  */
+  size = bfd_get_arch_size (core_bfd);
+  if (size == -1)
+    size = bfd_arch_bits_per_address (core_bfd);
+
+  switch (size)
     {
-    case 4:
-      return bfd_get_32 (abfd, addr);
-    case 8:
-      return bfd_get_64 (abfd, addr);
+    case 32:
+      return ptr_32bit;
+
+    case 64:
+      return ptr_64bit;
+
     default:
-      fprintf (stderr, "%s: bfd_vma has unexpected size of %ld bytes\n",
-	       whoami, (long) sizeof (char*));
+      fprintf (stderr, _("%s: address size has unexpected value of %u\n"),
+	       whoami, size);
       done (1);
     }
 }
 
+static enum gmon_ptr_signedness
+gmon_get_ptr_signedness (void)
+{
+  int sext;
 
-/*
- * This probably ought to be in libbfd.
- */
-void
-DEFUN (put_vma, (abfd, val, addr), bfd * abfd AND bfd_vma val AND bfd_byte * addr)
+  /* Figure out whether to sign extend.  If BFD doesn't know, assume no.  */
+  sext = bfd_get_sign_extend_vma (core_bfd);
+  if (sext == -1)
+    return ptr_unsigned;
+  return (sext ? ptr_signed : ptr_unsigned);
+}
+
+int
+gmon_io_read_32 (FILE *ifp, unsigned int *valp)
 {
-  switch (sizeof (char*))
+  char buf[4];
+
+  if (fread (buf, 1, 4, ifp) != 4)
+    return 1;
+  *valp = bfd_get_32 (core_bfd, buf);
+  return 0;
+}
+
+#ifdef BFD_HOST_U_64_BIT
+static int
+gmon_io_read_64 (FILE *ifp, BFD_HOST_U_64_BIT *valp)
+{
+  char buf[8];
+
+  if (fread (buf, 1, 8, ifp) != 8)
+    return 1;
+  *valp = bfd_get_64 (core_bfd, buf);
+  return 0;
+}
+#endif
+
+int
+gmon_io_read_vma (FILE *ifp, bfd_vma *valp)
+{
+  unsigned int val32;
+#ifdef BFD_HOST_U_64_BIT
+  BFD_HOST_U_64_BIT val64;
+#endif
+
+  switch (gmon_get_ptr_size ())
     {
-    case 4:
-      bfd_put_32 (abfd, val, addr);
+    case ptr_32bit:
+      if (gmon_io_read_32 (ifp, &val32))
+	return 1;
+      if (gmon_get_ptr_signedness () == ptr_signed)
+        *valp = (int) val32;
+      else
+        *valp = val32;
       break;
-    case 8:
-      bfd_put_64 (abfd, val, addr);
+
+#ifdef BFD_HOST_U_64_BIT
+    case ptr_64bit:
+      if (gmon_io_read_64 (ifp, &val64))
+	return 1;
+#ifdef BFD_HOST_64_BIT
+      if (gmon_get_ptr_signedness () == ptr_signed)
+        *valp = (BFD_HOST_64_BIT) val64;
+      else
+#endif
+        *valp = val64;
       break;
+#endif
+    }
+  return 0;
+}
+
+int
+gmon_io_read (FILE *ifp, char *buf, size_t n)
+{
+  if (fread (buf, 1, n, ifp) != n)
+    return 1;
+  return 0;
+}
+
+int
+gmon_io_write_32 (FILE *ofp, unsigned int val)
+{
+  char buf[4];
+
+  bfd_put_32 (core_bfd, (bfd_vma) val, buf);
+  if (fwrite (buf, 1, 4, ofp) != 4)
+    return 1;
+  return 0;
+}
+
+#ifdef BFD_HOST_U_64_BIT
+static int
+gmon_io_write_64 (FILE *ofp, BFD_HOST_U_64_BIT val)
+{
+  char buf[8];
+
+  bfd_put_64 (core_bfd, (bfd_vma) val, buf);
+  if (fwrite (buf, 1, 8, ofp) != 8)
+    return 1;
+  return 0;
+}
+#endif
+
+int
+gmon_io_write_vma (FILE *ofp, bfd_vma val)
+{
+
+  switch (gmon_get_ptr_size ())
+    {
+    case ptr_32bit:
+      if (gmon_io_write_32 (ofp, (unsigned int) val))
+	return 1;
+      break;
+
+#ifdef BFD_HOST_U_64_BIT
+    case ptr_64bit:
+      if (gmon_io_write_64 (ofp, (BFD_HOST_U_64_BIT) val))
+	return 1;
+      break;
+#endif
+    }
+  return 0;
+}
+
+int
+gmon_io_write_8 (FILE *ofp, unsigned int val)
+{
+  char buf[1];
+
+  bfd_put_8 (core_bfd, val, buf);
+  if (fwrite (buf, 1, 1, ofp) != 1)
+    return 1;
+  return 0;
+}
+
+int
+gmon_io_write (FILE *ofp, char *buf, size_t n)
+{
+  if (fwrite (buf, 1, n, ofp) != n)
+    return 1;
+  return 0;
+}
+
+static int
+gmon_read_raw_arc (FILE *ifp, bfd_vma *fpc, bfd_vma *spc, unsigned long *cnt)
+{
+#ifdef BFD_HOST_U_64_BIT
+  BFD_HOST_U_64_BIT cnt64;
+#endif
+  unsigned int cnt32;
+
+  if (gmon_io_read_vma (ifp, fpc)
+      || gmon_io_read_vma (ifp, spc))
+    return 1;
+
+  switch (gmon_get_ptr_size ())
+    {
+    case ptr_32bit:
+      if (gmon_io_read_32 (ifp, &cnt32))
+	return 1;
+      *cnt = cnt32;
+      break;
+
+#ifdef BFD_HOST_U_64_BIT
+    case ptr_64bit:
+      if (gmon_io_read_64 (ifp, &cnt64))
+	return 1;
+      *cnt = cnt64;
+      break;
+#endif
+
     default:
-      fprintf (stderr, "%s: bfd_vma has unexpected size of %ld bytes\n",
-	       whoami, (long) sizeof (char*));
-      done (1);
+      return 1;
     }
+  return 0;
 }
 
+static int
+gmon_write_raw_arc (FILE *ofp, bfd_vma fpc, bfd_vma spc, unsigned long cnt)
+{
+
+  if (gmon_io_write_vma (ofp, fpc)
+      || gmon_io_write_vma (ofp, spc))
+    return 1;
+
+  switch (gmon_get_ptr_size ())
+    {
+    case ptr_32bit:
+      if (gmon_io_write_32 (ofp, (unsigned int) cnt))
+	return 1;
+      break;
+
+#ifdef BFD_HOST_U_64_BIT
+    case ptr_64bit:
+      if (gmon_io_write_64 (ofp, (BFD_HOST_U_64_BIT) cnt))
+	return 1;
+      break;
+#endif
+    }
+  return 0;
+}
 
 void
-DEFUN (gmon_out_read, (filename), const char *filename)
+gmon_out_read (const char *filename)
 {
   FILE *ifp;
   struct gmon_hdr ghdr;
   unsigned char tag;
   int nhist = 0, narcs = 0, nbbs = 0;
 
-  /* open gmon.out file: */
-
+  /* Open gmon.out file.  */
   if (strcmp (filename, "-") == 0)
     {
       ifp = stdin;
+      SET_BINARY (fileno (stdin));
     }
   else
     {
       ifp = fopen (filename, FOPEN_RB);
+
       if (!ifp)
 	{
 	  perror (filename);
 	  done (1);
 	}
     }
+
   if (fread (&ghdr, sizeof (struct gmon_hdr), 1, ifp) != 1)
     {
-      fprintf (stderr, "%s: file too short to be a gmon file\n",
+      fprintf (stderr, _("%s: file too short to be a gmon file\n"),
 	       filename);
       done (1);
     }
 
-  if ((file_format == FF_MAGIC) ||
-      (file_format == FF_AUTO && !strncmp (&ghdr.cookie[0], GMON_MAGIC, 4)))
+  if ((file_format == FF_MAGIC)
+      || (file_format == FF_AUTO && !strncmp (&ghdr.cookie[0], GMON_MAGIC, 4)))
     {
       if (file_format == FF_MAGIC && strncmp (&ghdr.cookie[0], GMON_MAGIC, 4))
 	{
-	  fprintf (stderr, "%s: file `%s' has bad magic cookie\n",
+	  fprintf (stderr, _("%s: file `%s' has bad magic cookie\n"),
 		   whoami, filename);
 	  done (1);
 	}
 
-      /* right magic, so it's probably really a new gmon.out file */
-
+      /* Right magic, so it's probably really a new gmon.out file.  */
       gmon_file_version = bfd_get_32 (core_bfd, (bfd_byte *) ghdr.version);
+
       if (gmon_file_version != GMON_VERSION && gmon_file_version != 0)
 	{
 	  fprintf (stderr,
-		   "%s: file `%s' has unsupported version %d\n",
+		   _("%s: file `%s' has unsupported version %d\n"),
 		   whoami, filename, gmon_file_version);
 	  done (1);
 	}
 
-      /* read in all the records: */
+      /* Read in all the records.  */
       while (fread (&tag, sizeof (tag), 1, ifp) == 1)
 	{
 	  switch (tag)
@@ -135,176 +366,233 @@ DEFUN (gmon_out_read, (filename), const char *filename)
 
 	    default:
 	      fprintf (stderr,
-		       "%s: %s: found bad tag %d (file corrupted?)\n",
+		       _("%s: %s: found bad tag %d (file corrupted?)\n"),
 		       whoami, filename, tag);
 	      done (1);
 	    }
 	}
     }
-  else if (file_format == FF_AUTO || file_format == FF_BSD)
+  else if (file_format == FF_AUTO
+	   || file_format == FF_BSD
+	   || file_format == FF_BSD44)
     {
       struct hdr
       {
 	bfd_vma low_pc;
 	bfd_vma high_pc;
-	int ncnt;
+	unsigned int ncnt;
       };
-      int i, samp_bytes, count;
+      unsigned int i;
+      int samp_bytes, header_size = 0;
+      unsigned long count;
       bfd_vma from_pc, self_pc;
-      struct raw_arc raw_arc;
-      struct raw_phdr raw;
-      static struct hdr h;
       UNIT raw_bin_count;
       struct hdr tmp;
+      unsigned int version;
+      unsigned int hist_num_bins;
 
-      /*
-       * Information from a gmon.out file is in two parts: an array of
-       * sampling hits within pc ranges, and the arcs.
-       */
+      /* Information from a gmon.out file is in two parts: an array of
+	 sampling hits within pc ranges, and the arcs.  */
       gmon_input = INPUT_HISTOGRAM | INPUT_CALL_GRAPH;
 
-      /*
-       * This fseek() ought to work even on stdin as long as it's
-       * not an interactive device (heck, is there anybody who would
-       * want to type in a gmon.out at the terminal?).
-       */
+      /* This fseek() ought to work even on stdin as long as it's
+	 not an interactive device (heck, is there anybody who would
+	 want to type in a gmon.out at the terminal?).  */
       if (fseek (ifp, 0, SEEK_SET) < 0)
 	{
 	  perror (filename);
 	  done (1);
 	}
-      if (fread (&raw, 1, sizeof (struct raw_phdr), ifp)
-	  != sizeof (struct raw_phdr))
+
+      /* The beginning of the old BSD header and the 4.4BSD header
+	 are the same: lowpc, highpc, ncnt  */
+      if (gmon_io_read_vma (ifp, &tmp.low_pc)
+          || gmon_io_read_vma (ifp, &tmp.high_pc)
+          || gmon_io_read_32 (ifp, &tmp.ncnt))
 	{
-	  fprintf (stderr, "%s: file too short to be a gmon file\n",
+ bad_gmon_file:
+          fprintf (stderr, _("%s: file too short to be a gmon file\n"),
 		   filename);
 	  done (1);
 	}
-      tmp.low_pc = get_vma (core_bfd, (bfd_byte *) &raw.low_pc[0]);
-      tmp.high_pc = get_vma (core_bfd, (bfd_byte *) &raw.high_pc[0]);
-      tmp.ncnt = bfd_get_32 (core_bfd, (bfd_byte *) &raw.ncnt[0]);
 
-#ifdef BSD44_FORMAT
-      {
-	int profrate;
-
-	profrate = bfd_get_32 (core_bfd, (bfd_byte *) &raw.profrate[0]);
-	if (!s_highpc)
-	  hz = profrate;
-	else if (hz != profrate)
-	  {
-	    fprintf (stderr,
-		     "%s: profiling rate incompatible with first gmon file\n",
-		     filename);
-	    done (1);
-	  }
-      }
-#endif
+      /* Check to see if this a 4.4BSD-style header.  */
+      if (gmon_io_read_32 (ifp, &version))
+	goto bad_gmon_file;
 
-      if (s_highpc && (tmp.low_pc != h.low_pc ||
-		       tmp.high_pc != h.high_pc || tmp.ncnt != h.ncnt))
+      if (version == GMONVERSION)
 	{
-	  fprintf (stderr, "%s: incompatible with first gmon file\n",
-		   filename);
+	  unsigned int profrate;
+
+	  /* 4.4BSD format header.  */
+          if (gmon_io_read_32 (ifp, &profrate))
+	    goto bad_gmon_file;
+
+	  if (!histograms)
+	    hz = profrate;
+	  else if (hz != (int) profrate)
+	    {
+	      fprintf (stderr,
+		       _("%s: profiling rate incompatible with first gmon file\n"),
+		       filename);
+	      done (1);
+	    }
+
+	  switch (gmon_get_ptr_size ())
+	    {
+	    case ptr_32bit:
+	      header_size = GMON_HDRSIZE_BSD44_32;
+	      break;
+
+	    case ptr_64bit:
+	      header_size = GMON_HDRSIZE_BSD44_64;
+	      break;
+	    }
+	}
+      else
+	{
+	  /* Old style BSD format.  */
+	  if (file_format == FF_BSD44)
+	    {
+	      fprintf (stderr, _("%s: file `%s' has bad magic cookie\n"),
+		       whoami, filename);
+	      done (1);
+	    }
+
+	  switch (gmon_get_ptr_size ())
+	    {
+	    case ptr_32bit:
+	      header_size = GMON_HDRSIZE_OLDBSD_32;
+	      break;
+
+	    case ptr_64bit:
+	      header_size = GMON_HDRSIZE_OLDBSD_64;
+	      break;
+	    }
+	}
+
+      /* Position the file to after the header.  */
+      if (fseek (ifp, header_size, SEEK_SET) < 0)
+	{
+	  perror (filename);
 	  done (1);
 	}
-      h = tmp;
-      s_lowpc = (bfd_vma) h.low_pc;
-      s_highpc = (bfd_vma) h.high_pc;
-      lowpc = (bfd_vma) h.low_pc / sizeof (UNIT);
-      highpc = (bfd_vma) h.high_pc / sizeof (UNIT);
-      samp_bytes = h.ncnt - sizeof (struct raw_phdr);
+
+      samp_bytes = tmp.ncnt - header_size;
       hist_num_bins = samp_bytes / sizeof (UNIT);
+      if (histograms && (tmp.low_pc != histograms->lowpc
+			 || tmp.high_pc != histograms->highpc
+			 || (hist_num_bins != histograms->num_bins)))
+	{
+	  fprintf (stderr, _("%s: incompatible with first gmon file\n"),
+		   filename);
+	  done (1);
+	}
+
+      if (!histograms)
+	{
+	  num_histograms = 1;
+	  histograms = (struct histogram *) xmalloc (sizeof (struct histogram));
+	  histograms->lowpc = tmp.low_pc;
+	  histograms->highpc = tmp.high_pc;
+	  histograms->num_bins = hist_num_bins;
+	  hist_scale = (double)((tmp.high_pc - tmp.low_pc) / sizeof (UNIT))
+	    / hist_num_bins;
+	  histograms->sample = (int *) xmalloc (hist_num_bins * sizeof (int));
+	  memset (histograms->sample, 0,
+		  hist_num_bins * sizeof (int));
+	}
+
       DBG (SAMPLEDEBUG,
 	   printf ("[gmon_out_read] lowpc 0x%lx highpc 0x%lx ncnt %d\n",
-		   h.low_pc, h.high_pc, h.ncnt);
-	   printf ("[gmon_out_read]   s_lowpc 0x%lx   s_highpc 0x%lx\n",
-		   s_lowpc, s_highpc);
-	   printf ("[gmon_out_read]     lowpc 0x%lx     highpc 0x%lx\n",
-		   lowpc, highpc);
+		   (unsigned long) tmp.low_pc, (unsigned long) tmp.high_pc,
+		   tmp.ncnt);
 	   printf ("[gmon_out_read] samp_bytes %d hist_num_bins %d\n",
 		   samp_bytes, hist_num_bins));
 
-      if (hist_num_bins)
+      /* Make sure that we have sensible values.  */
+      if (samp_bytes < 0 || histograms->lowpc > histograms->highpc)
 	{
-	  ++nhist;
+	  fprintf (stderr,
+	    _("%s: file '%s' does not appear to be in gmon.out format\n"),
+	    whoami, filename);
+	  done (1);
 	}
 
-      if (!hist_sample)
-	{
-	  hist_sample =
-	    (int *) xmalloc (hist_num_bins * sizeof (hist_sample[0]));
-	  memset (hist_sample, 0, hist_num_bins * sizeof (hist_sample[0]));
-	}
+      if (hist_num_bins)
+	++nhist;
 
       for (i = 0; i < hist_num_bins; ++i)
 	{
 	  if (fread (raw_bin_count, sizeof (raw_bin_count), 1, ifp) != 1)
 	    {
 	      fprintf (stderr,
-		       "%s: unexpected EOF after reading %d/%d bins\n",
+		       _("%s: unexpected EOF after reading %d/%d bins\n"),
 		       whoami, --i, hist_num_bins);
 	      done (1);
 	    }
-	  hist_sample[i] += bfd_get_16 (core_bfd, (bfd_byte *) raw_bin_count);
+
+	  histograms->sample[i]
+	    += bfd_get_16 (core_bfd, (bfd_byte *) raw_bin_count);
 	}
 
-      /*
-       * The rest of the file consists of a bunch of <from,self,count>
-       * tuples:
-       */
-      while (fread (&raw_arc, sizeof (raw_arc), 1, ifp) == 1)
+      /* The rest of the file consists of a bunch of
+	 <from,self,count> tuples.  */
+      while (gmon_read_raw_arc (ifp, &from_pc, &self_pc, &count) == 0)
 	{
 	  ++narcs;
-	  from_pc = get_vma (core_bfd, (bfd_byte *) raw_arc.from_pc);
-	  self_pc = get_vma (core_bfd, (bfd_byte *) raw_arc.self_pc);
-	  count = bfd_get_32 (core_bfd, (bfd_byte *) raw_arc.count);
+
 	  DBG (SAMPLEDEBUG,
-	     printf ("[gmon_out_read] frompc 0x%lx selfpc 0x%lx count %d\n",
-		     from_pc, self_pc, count));
-	  /* add this arc: */
+	     printf ("[gmon_out_read] frompc 0x%lx selfpc 0x%lx count %lu\n",
+		     (unsigned long) from_pc, (unsigned long) self_pc, count));
+
+	  /* Add this arc.  */
 	  cg_tally (from_pc, self_pc, count);
 	}
-      fclose (ifp);
 
       if (hz == HZ_WRONG)
 	{
-	  /*
-	   * How many ticks per second?  If we can't tell, report
-	   * time in ticks.
-	   */
+	  /* How many ticks per second?  If we can't tell, report
+	     time in ticks.  */
 	  hz = hertz ();
+
 	  if (hz == HZ_WRONG)
 	    {
 	      hz = 1;
-	      fprintf (stderr, "time is in ticks, not seconds\n");
+	      fprintf (stderr, _("time is in ticks, not seconds\n"));
 	    }
 	}
     }
   else
     {
-      fprintf (stderr, "%s: don't know how to deal with file format %d\n",
+      fprintf (stderr, _("%s: don't know how to deal with file format %d\n"),
 	       whoami, file_format);
       done (1);
     }
 
+  if (ifp != stdin)
+    fclose (ifp);
+
   if (output_style & STYLE_GMON_INFO)
     {
-      printf ("File `%s' (version %d) contains:\n",
+      printf (_("File `%s' (version %d) contains:\n"),
 	      filename, gmon_file_version);
-      printf ("\t%d histogram record%s\n",
-	      nhist, nhist == 1 ? "" : "s");
-      printf ("\t%d call-graph record%s\n",
-	      narcs, narcs == 1 ? "" : "s");
-      printf ("\t%d basic-block count record%s\n",
-	      nbbs, nbbs == 1 ? "" : "s");
+      printf (nhist == 1 ?
+	      _("\t%d histogram record\n") :
+	      _("\t%d histogram records\n"), nhist);
+      printf (narcs == 1 ?
+	      _("\t%d call-graph record\n") :
+	      _("\t%d call-graph records\n"), narcs);
+      printf (nbbs == 1 ?
+	      _("\t%d basic-block count record\n") :
+	      _("\t%d basic-block count records\n"), nbbs);
       first_output = FALSE;
     }
 }
 
 
 void
-DEFUN (gmon_out_write, (filename), const char *filename)
+gmon_out_write (const char *filename)
 {
   FILE *ofp;
   struct gmon_hdr ghdr;
@@ -318,63 +606,116 @@ DEFUN (gmon_out_write, (filename), const char *filename)
 
   if (file_format == FF_AUTO || file_format == FF_MAGIC)
     {
-      /* write gmon header: */
+      /* Write gmon header.  */
 
       memcpy (&ghdr.cookie[0], GMON_MAGIC, 4);
-      bfd_put_32 (core_bfd, GMON_VERSION, (bfd_byte *) ghdr.version);
+      bfd_put_32 (core_bfd, (bfd_vma) GMON_VERSION, (bfd_byte *) ghdr.version);
+
       if (fwrite (&ghdr, sizeof (ghdr), 1, ofp) != 1)
 	{
 	  perror (filename);
 	  done (1);
 	}
 
-      /* write execution time histogram if we have one: */
+      /* Write execution time histogram if we have one.  */
       if (gmon_input & INPUT_HISTOGRAM)
-	{
-	  hist_write_hist (ofp, filename);
-	}
+	hist_write_hist (ofp, filename);
 
-      /* write call graph arcs if we have any: */
+      /* Write call graph arcs if we have any.  */
       if (gmon_input & INPUT_CALL_GRAPH)
-	{
-	  cg_write_arcs (ofp, filename);
-	}
+	cg_write_arcs (ofp, filename);
 
-      /* write basic-block info if we have it: */
+      /* Write basic-block info if we have it.  */
       if (gmon_input & INPUT_BB_COUNTS)
-	{
-	  bb_write_blocks (ofp, filename);
-	}
+	bb_write_blocks (ofp, filename);
     }
-  else if (file_format == FF_BSD)
+  else if (file_format == FF_BSD || file_format == FF_BSD44)
     {
-      struct raw_arc raw_arc;
       UNIT raw_bin_count;
-      bfd_vma lpc, hpc;
-      int i, ncnt;
+      unsigned int i, hdrsize;
+      unsigned padsize;
+      char pad[3*4];
       Arc *arc;
       Sym *sym;
 
-      put_vma (core_bfd, s_lowpc, (bfd_byte *) & lpc);
-      put_vma (core_bfd, s_highpc, (bfd_byte *) & hpc);
-      bfd_put_32 (core_bfd,
-		  hist_num_bins * sizeof (UNIT) + sizeof (struct raw_phdr),
-		    (bfd_byte *) & ncnt);
+      memset (pad, 0, sizeof (pad));
+
+      hdrsize = 0;
+      /* Decide how large the header will be.  Use the 4.4BSD format
+         header if explicitly specified, or if the profiling rate is
+         non-standard.  Otherwise, use the old BSD format.  */
+      if (file_format == FF_BSD44
+	  || hz != hertz())
+	{
+	  padsize = 3*4;
+	  switch (gmon_get_ptr_size ())
+	    {
+	    case ptr_32bit:
+	      hdrsize = GMON_HDRSIZE_BSD44_32;
+	      break;
+
+	    case ptr_64bit:
+	      hdrsize = GMON_HDRSIZE_BSD44_64;
+	      break;
+	    }
+	}
+      else
+	{
+	  padsize = 0;
+	  switch (gmon_get_ptr_size ())
+	    {
+	    case ptr_32bit:
+	      hdrsize = GMON_HDRSIZE_OLDBSD_32;
+	      break;
+
+	    case ptr_64bit:
+	      hdrsize = GMON_HDRSIZE_OLDBSD_64;
+	      /* FIXME: Checking host compiler defines here means that we can't
+		 use a cross gprof alpha OSF.  */
+#if defined(__alpha__) && defined (__osf__)
+	      padsize = 4;
+#endif
+	      break;
+	    }
+	}
 
-      /* write header: */
-      if (fwrite (&lpc, sizeof (lpc), 1, ofp) != 1
-	  || fwrite (&hpc, sizeof (hpc), 1, ofp) != 1
-	  || fwrite (&ncnt, sizeof (ncnt), 1, ofp) != 1)
+      /* Write the parts of the headers that are common to both the
+	 old BSD and 4.4BSD formats.  */
+      if (gmon_io_write_vma (ofp, histograms->lowpc)
+          || gmon_io_write_vma (ofp, histograms->highpc)
+          || gmon_io_write_32 (ofp, histograms->num_bins
+			       * sizeof (UNIT) + hdrsize))
 	{
 	  perror (filename);
 	  done (1);
 	}
 
-      /* dump the samples: */
+      /* Write out the 4.4BSD header bits, if that's what we're using.  */
+      if (file_format == FF_BSD44
+	  || hz != hertz())
+	{
+          if (gmon_io_write_32 (ofp, GMONVERSION)
+	      || gmon_io_write_32 (ofp, (unsigned int) hz))
+	    {
+	      perror (filename);
+	      done (1);
+	    }
+	}
+
+      /* Now write out any necessary padding after the meaningful
+	 header bits.  */
+      if (padsize != 0
+          && fwrite (pad, 1, padsize, ofp) != padsize)
+        {
+          perror (filename);
+	  done (1);
+	}
 
-      for (i = 0; i < hist_num_bins; ++i)
+      /* Dump the samples.  */
+      for (i = 0; i < histograms->num_bins; ++i)
 	{
-	  bfd_put_16 (core_bfd, hist_sample[i], (bfd_byte *) & raw_bin_count[0]);
+	  bfd_put_16 (core_bfd, (bfd_vma) histograms->sample[i],
+		      (bfd_byte *) &raw_bin_count[0]);
 	  if (fwrite (&raw_bin_count[0], sizeof (raw_bin_count), 1, ofp) != 1)
 	    {
 	      perror (filename);
@@ -382,32 +723,29 @@ DEFUN (gmon_out_write, (filename), const char *filename)
 	    }
 	}
 
-      /* dump the normalized raw arc information: */
-
+      /* Dump the normalized raw arc information.  */
       for (sym = symtab.base; sym < symtab.limit; ++sym)
 	{
 	  for (arc = sym->cg.children; arc; arc = arc->next_child)
 	    {
-	      put_vma (core_bfd, arc->parent->addr,
-		       (bfd_byte *) raw_arc.from_pc);
-	      put_vma (core_bfd, arc->child->addr,
-		       (bfd_byte *) raw_arc.self_pc);
-	      bfd_put_32 (core_bfd, arc->count, (bfd_byte *) raw_arc.count);
-	      if (fwrite (&raw_arc, sizeof (raw_arc), 1, ofp) != 1)
+	      if (gmon_write_raw_arc (ofp, arc->parent->addr,
+				      arc->child->addr, arc->count))
 		{
 		  perror (filename);
 		  done (1);
 		}
 	      DBG (SAMPLEDEBUG,
-		   printf ("[dumpsum] frompc 0x%lx selfpc 0x%lx count %d\n",
-			   arc->parent->addr, arc->child->addr, arc->count));
+		   printf ("[dumpsum] frompc 0x%lx selfpc 0x%lx count %lu\n",
+			   (unsigned long) arc->parent->addr,
+			   (unsigned long) arc->child->addr, arc->count));
 	    }
 	}
+
       fclose (ofp);
     }
   else
     {
-      fprintf (stderr, "%s: don't know how to deal with file format %d\n",
+      fprintf (stderr, _("%s: don't know how to deal with file format %d\n"),
 	       whoami, file_format);
       done (1);
     }