Add support for attributes using DW_FORM_GNU_strp_alt

[deliverable/binutils-gdb.git] / gprof / gmon_io.c

diff --git a/gprof/gmon_io.c b/gprof/gmon_io.c
index af1d767745127f2c3c407f71c15e8b80e0b9316e..5686ebb6b99d679babd6374e012a97c10c2bae76 100644 (file)
--- a/gprof/gmon_io.c
+++ b/gprof/gmon_io.c
@@ -1,12 +1,12 @@
 /* gmon_io.c - Input and output from/to gmon.out files.
 
 /* gmon_io.c - Input and output from/to gmon.out files.
 

-   Copyright (C) 2000  Free Software Foundation, Inc.
+   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
 
    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 2 of the License, or
+   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,
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,


@@ -16,67 +16,280 @@
 
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
 
    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., 59 Temple Place - Suite 330, Boston, MA
-   02111-1307, USA.  */
+   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
+   02110-1301, USA.  */

 \f
 \f

+#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 "cg_arcs.h"
 #include "basic_blocks.h"

-#include "bfd.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 "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 "hertz.h"
 #include "hist.h"
 #include "libiberty.h"
 
 #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_input = 0;
 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:
     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);
     }
 }
 
       done (1);
     }
 }
 

+static enum gmon_ptr_signedness
+gmon_get_ptr_signedness (void)
+{
+  int sext;

 
 

-/* This probably ought to be in libbfd.  */
+  /* 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);
+}

 
 

-void
-DEFUN (put_vma, (abfd, val, addr), bfd * abfd AND bfd_vma val AND bfd_byte * addr)
+int
+gmon_io_read_32 (FILE *ifp, unsigned int *valp)
+{
+  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 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;
+
+#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)

 {
 {

-  switch (sizeof (char*))
+  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 4:
-      bfd_put_32 (abfd, val, addr);
+    case ptr_32bit:
+      if (gmon_io_read_32 (ifp, &cnt32))
+       return 1;
+      *cnt = cnt32;

       break;
       break;

-    case 8:
-      bfd_put_64 (abfd, val, addr);
+
+#ifdef BFD_HOST_U_64_BIT
+    case ptr_64bit:
+      if (gmon_io_read_64 (ifp, &cnt64))
+       return 1;
+      *cnt = cnt64;

       break;
       break;

+#endif
+

     default:
     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
 
 void

-DEFUN (gmon_out_read, (filename), const char *filename)
+gmon_out_read (const char *filename)

 {
   FILE *ifp;
   struct gmon_hdr ghdr;
 {
   FILE *ifp;
   struct gmon_hdr ghdr;


@@ -87,21 +300,19 @@ DEFUN (gmon_out_read, (filename), const char *filename)
   if (strcmp (filename, "-") == 0)
     {
       ifp = stdin;
   if (strcmp (filename, "-") == 0)
     {
       ifp = stdin;

-#ifdef SET_BINARY

       SET_BINARY (fileno (stdin));
       SET_BINARY (fileno (stdin));

-#endif

     }
   else
     {
       ifp = fopen (filename, FOPEN_RB);
     }
   else
     {
       ifp = fopen (filename, FOPEN_RB);

-      
+

       if (!ifp)
        {
          perror (filename);
          done (1);
        }
     }
       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"),
   if (fread (&ghdr, sizeof (struct gmon_hdr), 1, ifp) != 1)
     {
       fprintf (stderr, _("%s: file too short to be a gmon file\n"),


@@ -109,8 +320,8 @@ DEFUN (gmon_out_read, (filename), const char *filename)
       done (1);
     }
 
       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))
        {
     {
       if (file_format == FF_MAGIC && strncmp (&ghdr.cookie[0], GMON_MAGIC, 4))
        {


@@ -121,7 +332,7 @@ DEFUN (gmon_out_read, (filename), const char *filename)
 
       /* Right magic, so it's probably really a new gmon.out file.  */
       gmon_file_version = bfd_get_32 (core_bfd, (bfd_byte *) ghdr.version);
 
       /* 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,
       if (gmon_file_version != GMON_VERSION && gmon_file_version != 0)
        {
          fprintf (stderr,


@@ -169,53 +380,57 @@ DEFUN (gmon_out_read, (filename), const char *filename)
       {
        bfd_vma low_pc;
        bfd_vma high_pc;
       {
        bfd_vma low_pc;
        bfd_vma high_pc;

-       int ncnt;
+       unsigned int ncnt;

       };
       };

-      int i, samp_bytes, header_size;
+      unsigned int i;
+      int samp_bytes, header_size = 0;

       unsigned long count;
       bfd_vma from_pc, self_pc;
       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;
       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
 
       /* Information from a gmon.out file is in two parts: an array of

-         sampling hits within pc ranges, and the arcs.  */
+        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
       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?).  */
+        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 (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);
        }
                   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]);

 
 

-      if (bfd_get_32 (core_bfd, (bfd_byte *) &raw.version[0])
-         == GMONVERSION)
+      /* Check to see if this a 4.4BSD-style header.  */
+      if (gmon_io_read_32 (ifp, &version))
+       goto bad_gmon_file;
+
+      if (version == GMONVERSION)

        {
        {

-         int profrate;
+         unsigned int profrate;

 
          /* 4.4BSD format header.  */
 
          /* 4.4BSD format header.  */

-         profrate = bfd_get_32 (core_bfd, (bfd_byte *) &raw.profrate[0]);
-         
-         if (!s_highpc)
+          if (gmon_io_read_32 (ifp, &profrate))
+           goto bad_gmon_file;
+
+         if (!histograms)

            hz = profrate;
            hz = profrate;

-         else if (hz != profrate)
+         else if (hz != (int) profrate)

            {
              fprintf (stderr,
                       _("%s: profiling rate incompatible with first gmon file\n"),
            {
              fprintf (stderr,
                       _("%s: profiling rate incompatible with first gmon file\n"),


@@ -223,7 +438,16 @@ DEFUN (gmon_out_read, (filename), const char *filename)
              done (1);
            }
 
              done (1);
            }
 

-         header_size = sizeof (struct raw_phdr);
+         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
        {
        }
       else
        {


@@ -235,62 +459,69 @@ DEFUN (gmon_out_read, (filename), const char *filename)
              done (1);
            }
 
              done (1);
            }
 

-         if (fseek (ifp, sizeof (struct old_raw_phdr), SEEK_SET) < 0)
+         switch (gmon_get_ptr_size ())

            {
            {

-             perror (filename);
-             done (1);
+           case ptr_32bit:
+             header_size = GMON_HDRSIZE_OLDBSD_32;
+             break;
+
+           case ptr_64bit:
+             header_size = GMON_HDRSIZE_OLDBSD_64;
+             break;

            }
            }

+       }

 
 

-         header_size = sizeof (struct old_raw_phdr);
+      /* Position the file to after the header.  */
+      if (fseek (ifp, header_size, SEEK_SET) < 0)
+       {
+         perror (filename);
+         done (1);

        }
 
        }
 

-      if (s_highpc && (tmp.low_pc != h.low_pc ||
-                      tmp.high_pc != h.high_pc || tmp.ncnt != h.ncnt))
+      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);
        }
        {
          fprintf (stderr, _("%s: incompatible with first gmon file\n"),
                   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 - header_size;
-      hist_num_bins = samp_bytes / sizeof (UNIT);
-      
+
+      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",
       DBG (SAMPLEDEBUG,
           printf ("[gmon_out_read] lowpc 0x%lx highpc 0x%lx ncnt %d\n",

-                  (unsigned long) h.low_pc, (unsigned long) h.high_pc,
-                  h.ncnt);
-          printf ("[gmon_out_read]   s_lowpc 0x%lx   s_highpc 0x%lx\n",
-                  (unsigned long) s_lowpc, (unsigned long) s_highpc);
-          printf ("[gmon_out_read]     lowpc 0x%lx     highpc 0x%lx\n",
-                  (unsigned long) lowpc, (unsigned long) 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));
 
       /* Make sure that we have sensible values.  */
           printf ("[gmon_out_read] samp_bytes %d hist_num_bins %d\n",
                   samp_bytes, hist_num_bins));
 
       /* Make sure that we have sensible values.  */

-      if (samp_bytes < 0 || lowpc > highpc)
-        {
-          fprintf (stderr, 
+      if (samp_bytes < 0 || histograms->lowpc > histograms->highpc)
+       {
+         fprintf (stderr,

            _("%s: file '%s' does not appear to be in gmon.out format\n"),
            whoami, filename);
            _("%s: file '%s' does not appear to be in gmon.out format\n"),
            whoami, filename);

-          done (1);
-        }
+         done (1);
+       }

 
       if (hist_num_bins)
        ++nhist;
 
 
       if (hist_num_bins)
        ++nhist;
 

-      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]));
-       }
-

       for (i = 0; i < hist_num_bins; ++i)
        {
          if (fread (raw_bin_count, sizeof (raw_bin_count), 1, ifp) != 1)
       for (i = 0; i < hist_num_bins; ++i)
        {
          if (fread (raw_bin_count, sizeof (raw_bin_count), 1, ifp) != 1)


@@ -300,35 +531,31 @@ DEFUN (gmon_out_read, (filename), const char *filename)
                       whoami, --i, hist_num_bins);
              done (1);
            }
                       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.  */
        }
 
       /* The rest of the file consists of a bunch of
         <from,self,count> tuples.  */

-      while (fread (&raw_arc, sizeof (raw_arc), 1, ifp) == 1)
+      while (gmon_read_raw_arc (ifp, &from_pc, &self_pc, &count) == 0)

        {
          ++narcs;
        {
          ++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 %lu\n",
                     (unsigned long) from_pc, (unsigned long) self_pc, count));
          DBG (SAMPLEDEBUG,
             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);
        }
          /* 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.  */
          hz = hertz ();
 
       if (hz == HZ_WRONG)
        {
          /* How many ticks per second?  If we can't tell, report
             time in ticks.  */
          hz = hertz ();

-         
+

          if (hz == HZ_WRONG)
            {
              hz = 1;
          if (hz == HZ_WRONG)
            {
              hz = 1;


@@ -343,23 +570,29 @@ DEFUN (gmon_out_read, (filename), const char *filename)
       done (1);
     }
 
       done (1);
     }
 

+  if (ifp != stdin)
+    fclose (ifp);
+

   if (output_style & STYLE_GMON_INFO)
     {
       printf (_("File `%s' (version %d) contains:\n"),
              filename, gmon_file_version);
   if (output_style & STYLE_GMON_INFO)
     {
       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
       first_output = FALSE;
     }
 }
 
 
 void

-DEFUN (gmon_out_write, (filename), const char *filename)
+gmon_out_write (const char *filename)

 {
   FILE *ofp;
   struct gmon_hdr ghdr;
 {
   FILE *ofp;
   struct gmon_hdr ghdr;


@@ -376,8 +609,8 @@ DEFUN (gmon_out_write, (filename), const char *filename)
       /* Write gmon header.  */
 
       memcpy (&ghdr.cookie[0], GMON_MAGIC, 4);
       /* 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);
       if (fwrite (&ghdr, sizeof (ghdr), 1, ofp) != 1)
        {
          perror (filename);


@@ -398,47 +631,91 @@ DEFUN (gmon_out_write, (filename), const char *filename)
     }
   else if (file_format == FF_BSD || file_format == FF_BSD44)
     {
     }
   else if (file_format == FF_BSD || file_format == FF_BSD44)
     {

-      struct raw_arc raw_arc;

       UNIT raw_bin_count;
       UNIT raw_bin_count;

-      struct raw_phdr h;
-      int i;
+      unsigned int i, hdrsize;
+      unsigned padsize;
+      char pad[3*4];

       Arc *arc;
       Sym *sym;
 
       Arc *arc;
       Sym *sym;
 

-      memset (&h, 0, sizeof h);
-      put_vma (core_bfd, s_lowpc, (bfd_byte *) &h.low_pc);
-      put_vma (core_bfd, s_highpc, (bfd_byte *) &h.high_pc);
-      bfd_put_32 (core_bfd,
-                 hist_num_bins * sizeof (UNIT) + sizeof (struct raw_phdr),
-                 (bfd_byte *) &h.ncnt);
+      memset (pad, 0, sizeof (pad));

 
 

-      /* Write header.  Use new style BSD format is explicitly
-         specified, or if the profiling rate is non-standard;
-         otherwise, use the old BSD format.  */
+      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
       if (file_format == FF_BSD44

-         || hz != hertz ())
+         || hz != hertz())

        {
        {

-         bfd_put_32 (core_bfd, GMONVERSION, (bfd_byte *) &h.version);
-         bfd_put_32 (core_bfd, hz, (bfd_byte *) &h.profrate);
-         if (fwrite (&h, sizeof (struct raw_phdr), 1, ofp) != 1)
+         padsize = 3*4;
+         switch (gmon_get_ptr_size ())

            {
            {

-             perror (filename);
-             done (1);
+           case ptr_32bit:
+             hdrsize = GMON_HDRSIZE_BSD44_32;
+             break;
+
+           case ptr_64bit:
+             hdrsize = GMON_HDRSIZE_BSD44_64;
+             break;

            }
        }
       else
        {
            }
        }
       else
        {

-         if (fwrite (&h, sizeof (struct old_raw_phdr), 1, ofp) != 1)
+         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 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);
+       }
+
+      /* 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);
            }
        }
 
            {
              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);
+       }
+

       /* Dump the samples.  */
       /* Dump the samples.  */

-      for (i = 0; i < hist_num_bins; ++i)
+      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);
          if (fwrite (&raw_bin_count[0], sizeof (raw_bin_count), 1, ofp) != 1)
            {
              perror (filename);


@@ -451,12 +728,8 @@ DEFUN (gmon_out_write, (filename), const char *filename)
        {
          for (arc = sym->cg.children; arc; arc = arc->next_child)
            {
        {
          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);
                {
                  perror (filename);
                  done (1);


@@ -467,7 +740,7 @@ DEFUN (gmon_out_write, (filename), const char *filename)
                           (unsigned long) arc->child->addr, arc->count));
            }
        }
                           (unsigned long) arc->child->addr, arc->count));
            }
        }

-      
+

       fclose (ofp);
     }
   else
       fclose (ofp);
     }
   else