Deal with target architecture that have a pointer size that is different from

the host architectures pointer size.

1 files changed, 228 insertions, 104 deletions

diff --git a/gprof/gmon_io.c b/gprof/gmon_io.c
index bf8efef..0bc5caa 100644
--- a/gprof/gmon_io.c
+++ b/gprof/gmon_io.c
@@ -1,6 +1,6 @@
 /* gmon_io.c - Input and output from/to gmon.out files.
 
-   Copyright 2000, 2001 Free Software Foundation, Inc.
+   Copyright 2000, 2001, 2002 Free Software Foundation, Inc.
 
    This file is part of GNU Binutils.
 
@@ -38,49 +38,81 @@ int gmon_input = 0;
 int gmon_file_version = 0;	/* 0 == old (non-versioned) file format.  */
 
 int
-DEFUN (gmon_io_read_vma, (ifp, valp), FILE * ifp AND bfd_vma *valp)
+DEFUN (gmon_io_read_32, (ifp, valp), FILE * ifp AND unsigned int *valp)
+{
+  char buf[4];
+
+  if (fread (buf, 1, 4, ifp) != 4)
+    return 1;
+  *valp = bfd_get_32 (core_bfd, buf);
+  return 0;
+}
+
+int
+DEFUN (gmon_io_read_64, (ifp, valp), FILE * ifp AND BFD_HOST_U_64_BIT *valp)
 {
   char buf[8];
-  bfd_vma val;
 
-  switch (GMON_PTR_SIZE)
+  if (fread (buf, 1, 8, ifp) != 8)
+    return 1;
+  *valp = bfd_get_64 (core_bfd, buf);
+  return 0;
+}
+
+int
+DEFUN (gmon_io_read_vma, (ifp, valp), FILE * ifp AND bfd_vma *valp)
+{
+  unsigned int val32;
+  BFD_HOST_U_64_BIT val64;
+
+  switch (bfd_arch_bits_per_address (core_bfd))
     {
-    case 4:
-      if (fread (buf, 1, 4, ifp) != 4)
+    case 32:
+      if (gmon_io_read_32 (ifp, &val32))
 	return 1;
-      val = bfd_get_32 (core_bfd, buf);
+      *valp = val32;
       break;
 
-    case 8:
-      if (fread (buf, 1, 8, ifp) != 8)
+    case 64:
+      if (gmon_io_read_64 (ifp, &val64))
 	return 1;
-      val = bfd_get_64 (core_bfd, buf);
+      *valp = val64;
       break;
 
     default:
-      fprintf (stderr, _("%s: GMON_PTR_SIZE has unexpected value of %u\n"),
-	       whoami, GMON_PTR_SIZE);
+      fprintf (stderr, _("%s: bits per address has unexpected value of %u\n"),
+	       whoami, bfd_arch_bits_per_address (core_bfd));
       done (1);
     }
-  *valp = val;
   return 0;
 }
 
 int
-DEFUN (gmon_io_read_32, (ifp, valp), FILE * ifp AND unsigned int *valp)
+DEFUN (gmon_io_read, (ifp, buf, n), FILE * ifp AND char *buf AND size_t n)
+{
+  if (fread (buf, 1, n, ifp) != n)
+    return 1;
+  return 0;
+}
+
+int
+DEFUN (gmon_io_write_32, (ofp, val), FILE * ofp AND unsigned int val)
 {
   char buf[4];
 
-  if (fread (buf, 1, 4, ifp) != 4)
+  bfd_put_32 (core_bfd, val, buf);
+  if (fwrite (buf, 1, 4, ofp) != 4)
     return 1;
-  *valp = bfd_get_32 (core_bfd, buf);
   return 0;
 }
 
 int
-DEFUN (gmon_io_read, (ifp, buf, n), FILE * ifp AND char *buf AND size_t n)
+DEFUN (gmon_io_write_64, (ofp, val), FILE * ofp AND BFD_HOST_U_64_BIT val)
 {
-  if (fread (buf, 1, n, ifp) != n)
+  char buf[8];
+
+  bfd_put_64 (core_bfd, val, buf);
+  if (fwrite (buf, 1, 8, ofp) != 8)
     return 1;
   return 0;
 }
@@ -88,42 +120,28 @@ DEFUN (gmon_io_read, (ifp, buf, n), FILE * ifp AND char *buf AND size_t n)
 int
 DEFUN (gmon_io_write_vma, (ofp, val), FILE * ofp AND bfd_vma val)
 {
-  char buf[8];
 
-  switch (GMON_PTR_SIZE)
+  switch (bfd_arch_bits_per_address (core_bfd))
     {
-    case 4:
-      bfd_put_32 (core_bfd, val, buf);
-      if (fwrite (buf, 1, 4, ofp) != 4)
+    case 32:
+      if (gmon_io_write_32 (ofp, (unsigned int) val))
 	return 1;
       break;
 
-    case 8:
-      bfd_put_64 (core_bfd, val, buf);
-      if (fwrite (buf, 1, 8, ofp) != 8)
+    case 64:
+      if (gmon_io_write_64 (ofp, (BFD_HOST_U_64_BIT) val))
 	return 1;
       break;
 
     default:
-      fprintf (stderr, _("%s: GMON_PTR_SIZE has unexpected value of %u\n"),
-	       whoami, GMON_PTR_SIZE);
+      fprintf (stderr, _("%s: bits per address has unexpected value of %u\n"),
+	       whoami, bfd_arch_bits_per_address (core_bfd));
       done (1);
     }
   return 0;
 }
 
 int
-DEFUN (gmon_io_write_32, (ofp, val), FILE * ofp AND unsigned int val)
-{
-  char buf[4];
-
-  bfd_put_32 (core_bfd, val, buf);
-  if (fwrite (buf, 1, 4, ofp) != 4)
-    return 1;
-  return 0;
-}
-
-int
 DEFUN (gmon_io_write_8, (ofp, val), FILE * ofp AND unsigned char val)
 {
   char buf[1];
@@ -142,39 +160,64 @@ DEFUN (gmon_io_write, (ofp, buf, n), FILE * ofp AND char *buf AND size_t n)
   return 0;
 }
 
-/* get_vma and put_vma are for backwards compatibility only */
-static bfd_vma
-DEFUN (get_vma, (abfd, addr), bfd * abfd AND bfd_byte * addr)
+int
+DEFUN (gmon_read_raw_arc, (ifp, fpc, spc, cnt), FILE * ifp AND bfd_vma * fpc AND bfd_vma * spc AND unsigned long * cnt)
 {
-  switch (sizeof (char*))
+  BFD_HOST_U_64_BIT cnt64;
+  unsigned int cnt32;
+
+  if (gmon_io_read_vma (ifp, fpc)
+      || gmon_io_read_vma (ifp, spc))
+    return 1;
+
+  switch (bfd_arch_bits_per_address (core_bfd))
     {
-    case 4:
-      return bfd_get_32 (abfd, addr);
-    case 8:
-      return bfd_get_64 (abfd, addr);
+    case 32:
+      if (gmon_io_read_32 (ifp, &cnt32))
+	return 1;
+      *cnt = cnt32;
+      break;
+
+    case 64:
+      if (gmon_io_read_64 (ifp, &cnt64))
+	return 1;
+      *cnt = cnt64;
+      break;
+
     default:
-      fprintf (stderr, _("%s: bfd_vma has unexpected size of %ld bytes\n"),
-	       whoami, (long) sizeof (char*));
+      fprintf (stderr, _("%s: bits per address has unexpected value of %u\n"),
+	       whoami, bfd_arch_bits_per_address (core_bfd));
       done (1);
     }
+  return 0;
 }
 
-static void
-DEFUN (put_vma, (abfd, val, addr), bfd * abfd AND bfd_vma val AND bfd_byte * addr)
+int
+DEFUN (gmon_write_raw_arc, (ofp, fpc, spc, cnt), FILE * ofp AND bfd_vma fpc AND bfd_vma spc AND unsigned long cnt)
 {
-  switch (sizeof (char*))
+
+  if (gmon_io_write_vma (ofp, fpc)
+      || gmon_io_write_vma (ofp, spc))
+    return 1;
+
+  switch (bfd_arch_bits_per_address (core_bfd))
     {
-    case 4:
-      bfd_put_32 (abfd, val, addr);
+    case 32:
+      if (gmon_io_write_32 (ofp, (unsigned int) cnt))
+	return 1;
       break;
-    case 8:
-      bfd_put_64 (abfd, val, addr);
+
+    case 64:
+      if (gmon_io_write_64 (ofp, (BFD_HOST_U_64_BIT) cnt))
+	return 1;
       break;
+
     default:
-      fprintf (stderr, _("%s: bfd_vma has unexpected size of %ld bytes\n"),
-	       whoami, (long) sizeof (char*));
+      fprintf (stderr, _("%s: bits per address has unexpected value of %u\n"),
+	       whoami, bfd_arch_bits_per_address (core_bfd));
       done (1);
     }
+  return 0;
 }
 
 void
@@ -273,14 +316,13 @@ DEFUN (gmon_out_read, (filename), const char *filename)
 	bfd_vma high_pc;
 	int ncnt;
       };
-      int i, samp_bytes, header_size;
+      int i, 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;
+      int version;
 
       /* Information from a gmon.out file is in two parts: an array of
 	 sampling hits within pc ranges, and the arcs.  */
@@ -295,25 +337,29 @@ DEFUN (gmon_out_read, (filename), const char *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]);
+      /* Check to see if this a 4.4BSD-style header.  */
+      if (gmon_io_read_32 (ifp, &version))
+	goto bad_gmon_file;
 
-      if (bfd_get_32 (core_bfd, (bfd_byte *) &raw.version[0])
-	  == GMONVERSION)
+      if (version == GMONVERSION)
 	{
 	  int profrate;
 
 	  /* 4.4BSD format header.  */
-	  profrate = bfd_get_32 (core_bfd, (bfd_byte *) &raw.profrate[0]);
+          if (gmon_io_read_32 (ifp, &profrate))
+	    goto bad_gmon_file;
 
 	  if (!s_highpc)
 	    hz = profrate;
@@ -325,7 +371,22 @@ DEFUN (gmon_out_read, (filename), const char *filename)
 	      done (1);
 	    }
 
-	  header_size = sizeof (struct raw_phdr);
+	  switch (bfd_arch_bits_per_address (core_bfd))
+	    {
+	    case 32:
+	      header_size = GMON_HDRSIZE_BSD44_32;
+	      break;
+
+	    case 64:
+	      header_size = GMON_HDRSIZE_BSD44_64;
+	      break;
+
+	    default:
+              fprintf (stderr,
+                       _("%s: bits per address has unexpected value of %u\n"),
+	               whoami, bfd_arch_bits_per_address (core_bfd));
+              done (1);
+	    }
 	}
       else
 	{
@@ -337,13 +398,29 @@ DEFUN (gmon_out_read, (filename), const char *filename)
 	      done (1);
 	    }
 
-	  if (fseek (ifp, sizeof (struct old_raw_phdr), SEEK_SET) < 0)
+	  switch (bfd_arch_bits_per_address (core_bfd))
 	    {
-	      perror (filename);
-	      done (1);
+	    case 32:
+	      header_size = GMON_HDRSIZE_OLDBSD_32;
+	      break;
+
+	    case 64:
+	      header_size = GMON_HDRSIZE_OLDBSD_64;
+	      break;
+
+	    default:
+              fprintf (stderr,
+                       _("%s: bits per address has unexpected value of %u\n"),
+	               whoami, bfd_arch_bits_per_address (core_bfd));
+              done (1);
 	    }
+	}
 
-	  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
@@ -408,12 +485,9 @@ DEFUN (gmon_out_read, (filename), const char *filename)
 
       /* 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;
-	  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",
@@ -503,43 +577,97 @@ DEFUN (gmon_out_write, (filename), const char *filename)
     }
   else if (file_format == FF_BSD || file_format == FF_BSD44)
     {
-      struct raw_arc raw_arc;
       UNIT raw_bin_count;
-      struct raw_phdr h;
-      int i;
+      int i, hdrsize;
+      unsigned padsize;
+      char pad[3*4];
       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
-	  || 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 (bfd_arch_bits_per_address (core_bfd))
 	    {
-	      perror (filename);
-	      done (1);
+	    case 32:
+	      hdrsize = GMON_HDRSIZE_BSD44_32;
+	      break;
+
+	    case 64:
+	      hdrsize = GMON_HDRSIZE_BSD44_64;
+	      break;
+
+	    default:
+              fprintf (stderr,
+                       _("%s: bits per address has unexpected value of %u\n"),
+	               whoami, bfd_arch_bits_per_address (core_bfd));
+              done (1);
 	    }
 	}
       else
 	{
-	  if (fwrite (&h, sizeof (struct old_raw_phdr), 1, ofp) != 1)
+	  padsize = 0;
+	  switch (bfd_arch_bits_per_address (core_bfd))
+	    {
+	    case 32:
+	      hdrsize = GMON_HDRSIZE_OLDBSD_32;
+	      break;
+
+	    case 64:
+	      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;
+
+	    default:
+              fprintf (stderr,
+                       _("%s: bits per address has unexpected value of %u\n"),
+	               whoami, bfd_arch_bits_per_address (core_bfd));
+              done (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, s_lowpc)
+          || gmon_io_write_vma (ofp, s_highpc)
+          || gmon_io_write_32 (ofp, hist_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, 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);
+	}
+
       /* Dump the samples.  */
       for (i = 0; i < hist_num_bins; ++i)
 	{
@@ -556,12 +684,8 @@ DEFUN (gmon_out_write, (filename), const char *filename)
 	{
 	  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);