src/newlib/libgloss/mep/mep-bb.c - stadia-controller/gcc-arm-none-eabi - Git at Google

 /*
  * Copyright (c) 2000-2001  Red Hat, Inc. All rights reserved.
  *
  * This copyrighted material is made available to anyone wishing to use, modify,
  * copy, or redistribute it subject to the terms and conditions of the BSD
  * License.  This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY expressed or implied, including the implied
  * warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  A copy
  * of this license is available at http://www.opensource.org/licenses. Any
  * Red Hat trademarks that are incorporated in the source code or documentation
  * are not subject to the BSD License and may only be used or replicated with
  * the express permission of Red Hat, Inc.
  */

 /* Structure emitted by -a  */
 struct bb
 {
   long zero_word;
   const char *filename;
   long *counts;
   long ncounts;
   struct bb *next;
   const unsigned long *addresses;

   /* Older GCC's did not emit these fields.  */
   long nwords;
   const char **functions;
   const long *line_nums;
   const char **filenames;
   char *flags;
 };

 /* Simple minded basic block profiling output dumper for
    systems that don't provide tcov support.  At present,
    it requires atexit and stdio.  */

 #undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch.  */
 #include <stdio.h>
 #include <time.h>
 char *ctime (const time_t *);

 /*#include "gbl-ctors.h"*/
 #include "gcov-io.h"
 #include <string.h>

 static struct bb *bb_head;

 static int num_digits (long value, int base) __attribute__ ((const));

 /* Return the number of digits needed to print a value */
 /* __inline__ */ static int num_digits (long value, int base)
 {
   int minus = (value < 0 && base != 16);
   unsigned long v = (minus) ? -value : value;
   int ret = minus;

   do
     {
       v /= base;
       ret++;
     }
   while (v);

   return ret;
 }

 void
 __bb_exit_func (void)
 {
   FILE *da_file, *file;
   long time_value;
   int i;

   if (bb_head == 0)
     return;

   i = strlen (bb_head->filename) - 3;

   if (!strcmp (bb_head->filename+i, ".da"))
     {
       /* Must be -fprofile-arcs not -a.
 	 Dump data in a form that gcov expects.  */

       struct bb *ptr;

       for (ptr = bb_head; ptr != (struct bb *) 0; ptr = ptr->next)
 	{
 	  int firstchar;

 	  /* Make sure the output file exists -
 	     but don't clobber exiting data.  */
 	  if ((da_file = fopen (ptr->filename, "a")) != 0)
 	    fclose (da_file);

 	  /* Need to re-open in order to be able to write from the start.  */
 	  da_file = fopen (ptr->filename, "r+b");
 	  /* Some old systems might not allow the 'b' mode modifier.
 	     Therefore, try to open without it.  This can lead to a race
 	     condition so that when you delete and re-create the file, the
 	     file might be opened in text mode, but then, you shouldn't
 	     delete the file in the first place.  */
 	  if (da_file == 0)
 	    da_file = fopen (ptr->filename, "r+");
 	  if (da_file == 0)
 	    {
 	      fprintf (stderr, "arc profiling: Can't open output file %s.\n",
 		       ptr->filename);
 	      continue;
 	    }

 	  /* After a fork, another process might try to read and/or write
 	     the same file simultanously.  So if we can, lock the file to
 	     avoid race conditions.  */

 	  /* If the file is not empty, and the number of counts in it is the
 	     same, then merge them in.  */
 	  firstchar = fgetc (da_file);
 	  if (firstchar == EOF)
 	    {
 	      if (ferror (da_file))
 		{
 		  fprintf (stderr, "arc profiling: Can't read output file ");
 		  perror (ptr->filename);
 		}
 	    }
 	  else
 	    {
 	      long n_counts = 0;

 	      if (ungetc (firstchar, da_file) == EOF)
 		rewind (da_file);
 	      if (__read_long (&n_counts, da_file, 8) != 0)
 		{
 		  fprintf (stderr, "arc profiling: Can't read output file %s.\n",
 			   ptr->filename);
 		  continue;
 		}

 	      if (n_counts == ptr->ncounts)
 		{
 		  int i;

 		  for (i = 0; i < n_counts; i++)
 		    {
 		      long v = 0;

 		      if (__read_long (&v, da_file, 8) != 0)
 			{
 			  fprintf (stderr, "arc profiling: Can't read output file %s.\n",
 				   ptr->filename);
 			  break;
 			}
 		      ptr->counts[i] += v;
 		    }
 		}

 	    }

 	  rewind (da_file);

 	  /* ??? Should first write a header to the file.  Preferably, a 4 byte
 	     magic number, 4 bytes containing the time the program was
 	     compiled, 4 bytes containing the last modification time of the
 	     source file, and 4 bytes indicating the compiler options used.

 	     That way we can easily verify that the proper source/executable/
 	     data file combination is being used from gcov.  */

 	  if (__write_long (ptr->ncounts, da_file, 8) != 0)
 	    {

 	      fprintf (stderr, "arc profiling: Error writing output file %s.\n",
 		       ptr->filename);
 	    }
 	  else
 	    {
 	      int j;
 	      long *count_ptr = ptr->counts;
 	      int ret = 0;
 	      for (j = ptr->ncounts; j > 0; j--)
 		{
 		  if (__write_long (*count_ptr, da_file, 8) != 0)
 		    {
 		      ret=1;
 		      break;
 		    }
 		  count_ptr++;
 		}
 	      if (ret)
 		fprintf (stderr, "arc profiling: Error writing output file %s.\n",
 			 ptr->filename);
 	    }

 	  if (fclose (da_file) == EOF)
 	    fprintf (stderr, "arc profiling: Error closing output file %s.\n",
 		     ptr->filename);
 	}

       return;
     }

   /* Must be basic block profiling.  Emit a human readable output file.  */

   file = fopen ("bb.out", "a");

   if (!file)
     perror ("bb.out");

   else
     {
       struct bb *ptr;

       /* This is somewhat type incorrect, but it avoids worrying about
 	 exactly where time.h is included from.  It should be ok unless
 	 a void * differs from other pointer formats, or if sizeof (long)
 	 is < sizeof (time_t).  It would be nice if we could assume the
 	 use of rationale standards here.  */

       time ((void *) &time_value);
       fprintf (file, "Basic block profiling finished on %s\n", ctime ((void *) &time_value));

       /* We check the length field explicitly in order to allow compatibility
 	 with older GCC's which did not provide it.  */

       for (ptr = bb_head; ptr != (struct bb *) 0; ptr = ptr->next)
 	{
 	  int i;
 	  int func_p	= (ptr->nwords >= (long) sizeof (struct bb)
 			   && ptr->nwords <= 1000
 			   && ptr->functions);
 	  int line_p	= (func_p && ptr->line_nums);
 	  int file_p	= (func_p && ptr->filenames);
 	  int addr_p	= (ptr->addresses != 0);
 	  long ncounts	= ptr->ncounts;
 	  long cnt_max  = 0;
 	  long line_max = 0;
 	  long addr_max = 0;
 	  int file_len	= 0;
 	  int func_len	= 0;
 	  int blk_len	= num_digits (ncounts, 10);
 	  int cnt_len;
 	  int line_len;
 	  int addr_len;

 	  fprintf (file, "File %s, %ld basic blocks \n\n",
 		   ptr->filename, ncounts);

 	  /* Get max values for each field.  */
 	  for (i = 0; i < ncounts; i++)
 	    {
 	      const char *p;
 	      int len;

 	      if (cnt_max < ptr->counts[i])
 		cnt_max = ptr->counts[i];

 	      if (addr_p && (unsigned long) addr_max < ptr->addresses[i])
 		addr_max = ptr->addresses[i];

 	      if (line_p && line_max < ptr->line_nums[i])
 		line_max = ptr->line_nums[i];

 	      if (func_p)
 		{
 		  p = (ptr->functions[i]) ? (ptr->functions[i]) : "<none>";
 		  len = strlen (p);
 		  if (func_len < len)
 		    func_len = len;
 		}

 	      if (file_p)
 		{
 		  p = (ptr->filenames[i]) ? (ptr->filenames[i]) : "<none>";
 		  len = strlen (p);
 		  if (file_len < len)
 		    file_len = len;
 		}
 	    }

 	  addr_len = num_digits (addr_max, 16);
 	  cnt_len  = num_digits (cnt_max, 10);
 	  line_len = num_digits (line_max, 10);

 	  /* Now print out the basic block information.  */
 	  for (i = 0; i < ncounts; i++)
 	    {
 	      fprintf (file,
 		       "    Block #%*d: executed %*ld time(s)",
 		       blk_len, i+1,
 		       cnt_len, ptr->counts[i]);

 	      if (addr_p)
 		fprintf (file, " address= 0x%.*lx", addr_len,
 			 ptr->addresses[i]);

 	      if (func_p)
 		fprintf (file, " function= %-*s", func_len,
 			 (ptr->functions[i]) ? ptr->functions[i] : "<none>");

 	      if (line_p)
 		fprintf (file, " line= %*ld", line_len, ptr->line_nums[i]);

 	      if (file_p)
 		fprintf (file, " file= %s",
 			 (ptr->filenames[i]) ? ptr->filenames[i] : "<none>");

 	      fprintf (file, "\n");
 	    }

 	  fprintf (file, "\n");
 	  fflush (file);
 	}

       fprintf (file, "\n\n");
       fclose (file);
     }
 }

 void
 __bb_init_func (struct bb *blocks)
 {
   /* User is supposed to check whether the first word is non-0,
      but just in case....  */

   if (blocks->zero_word)
     return;

   /* Initialize destructor.  */
   if (!bb_head)
     atexit (__bb_exit_func);

   /* Set up linked list.  */
   blocks->zero_word = 1;
   blocks->next = bb_head;
   bb_head = blocks;
 }

 /* Called before fork or exec - write out profile information gathered so
    far and reset it to zero.  This avoids duplication or loss of the
    profile information gathered so far.  */
 void
 __bb_fork_func (void)
 {
   struct bb *ptr;

   __bb_exit_func ();
   for (ptr = bb_head; ptr != (struct bb *) 0; ptr = ptr->next)
     {
       long i;
       for (i = ptr->ncounts - 1; i >= 0; i--)
 	ptr->counts[i] = 0;
     }
 }

 #ifndef MACHINE_STATE_SAVE
 #define MACHINE_STATE_SAVE(ID)
 #endif
 #ifndef MACHINE_STATE_RESTORE
 #define MACHINE_STATE_RESTORE(ID)
 #endif

 /* Number of buckets in hashtable of basic block addresses.  */

 #define BB_BUCKETS 311

 /* Maximum length of string in file bb.in.  */

 #define BBINBUFSIZE 500

 struct bb_edge
 {
   struct bb_edge *next;
   unsigned long src_addr;
   unsigned long dst_addr;
   unsigned long count;
 };

 enum bb_func_mode
 {
   TRACE_KEEP = 0, TRACE_ON = 1, TRACE_OFF = 2
 };

 struct bb_func
 {
   struct bb_func *next;
   char *funcname;
   char *filename;
   enum bb_func_mode mode;
 };

 /* This is the connection to the outside world.
    The BLOCK_PROFILER macro must set __bb.blocks
    and __bb.blockno.  */

 struct {
   unsigned long blockno;
   struct bb *blocks;
 } __bb;

 /* Vars to store addrs of source and destination basic blocks
    of a jump.  */

 static unsigned long bb_src = 0;
 static unsigned long bb_dst = 0;

 static FILE *bb_tracefile = (FILE *) 0;
 static struct bb_edge **bb_hashbuckets = (struct bb_edge **) 0;
 static struct bb_func *bb_func_head = (struct bb_func *) 0;
 static unsigned long bb_callcount = 0;
 static int bb_mode = 0;

 static unsigned long *bb_stack = (unsigned long *) 0;
 static size_t bb_stacksize = 0;

 static int reported = 0;

 /* Trace modes:
 Always             :   Print execution frequencies of basic blocks
                        to file bb.out.
 bb_mode & 1 != 0   :   Dump trace of basic blocks to file bbtrace[.gz]
 bb_mode & 2 != 0   :   Print jump frequencies to file bb.out.
 bb_mode & 4 != 0   :   Cut call instructions from basic block flow.
 bb_mode & 8 != 0   :   Insert return instructions in basic block flow.
 */

 #ifdef HAVE_POPEN

 /*#include <sys/types.h>*/
 #include <sys/stat.h>
 /*#include <malloc.h>*/

 /* Commands executed by gopen.  */

 #define GOPENDECOMPRESS "gzip -cd "
 #define GOPENCOMPRESS "gzip -c >"

 /* Like fopen but pipes through gzip.  mode may only be "r" or "w".
    If it does not compile, simply replace gopen by fopen and delete
    '.gz' from any first parameter to gopen.  */

 static FILE *
 gopen (char *fn, char *mode)
 {
   int use_gzip;
   char *p;

   if (mode[1])
     return (FILE *) 0;

   if (mode[0] != 'r' && mode[0] != 'w')
     return (FILE *) 0;

   p = fn + strlen (fn)-1;
   use_gzip = ((p[-1] == '.' && (p[0] == 'Z' || p[0] == 'z'))
 	      || (p[-2] == '.' && p[-1] == 'g' && p[0] == 'z'));

   if (use_gzip)
     {
       if (mode[0]=='r')
         {
           FILE *f;
           char *s = (char *) malloc (sizeof (char) * strlen (fn)
 				     + sizeof (GOPENDECOMPRESS));
           strcpy (s, GOPENDECOMPRESS);
           strcpy (s + (sizeof (GOPENDECOMPRESS)-1), fn);
           f = popen (s, mode);
           free (s);
           return f;
         }

       else
         {
           FILE *f;
           char *s = (char *) malloc (sizeof (char) * strlen (fn)
 				     + sizeof (GOPENCOMPRESS));
           strcpy (s, GOPENCOMPRESS);
           strcpy (s + (sizeof (GOPENCOMPRESS)-1), fn);
           if (!(f = popen (s, mode)))
             f = fopen (s, mode);
           free (s);
           return f;
         }
     }

   else
     return fopen (fn, mode);
 }

 static int
 gclose (FILE *f)
 {
   struct stat buf;

   if (f != 0)
     {
       if (!fstat (fileno (f), &buf) && S_ISFIFO (buf.st_mode))
         return pclose (f);

       return fclose (f);
     }
   return 0;
 }

 #endif /* HAVE_POPEN */

 /* Called once per program.  */

 static void
 __bb_exit_trace_func (void)
 {
   FILE *file = fopen ("bb.out", "a");
   struct bb_func *f;
   struct bb *b;

   if (!file)
     perror ("bb.out");

   if (bb_mode & 1)
     {
       if (!bb_tracefile)
         perror ("bbtrace");
       else
 #ifdef HAVE_POPEN
         gclose (bb_tracefile);
 #else
         fclose (bb_tracefile);
 #endif /* HAVE_POPEN */
     }

   /* Check functions in `bb.in'.  */

   if (file)
     {
       long time_value;
       const struct bb_func *p;
       int printed_something = 0;
       struct bb *ptr;
       long blk;

       /* This is somewhat type incorrect.  */
       time ((void *) &time_value);

       for (p = bb_func_head; p != (struct bb_func *) 0; p = p->next)
         {
           for (ptr = bb_head; ptr != (struct bb *) 0; ptr = ptr->next)
             {
               if (!ptr->filename || (p->filename != (char *) 0 && strcmp (p->filename, ptr->filename)))
                 continue;
               for (blk = 0; blk < ptr->ncounts; blk++)
                 {
                   if (!strcmp (p->funcname, ptr->functions[blk]))
                     goto found;
                 }
             }

           if (!printed_something)
             {
               fprintf (file, "Functions in `bb.in' not executed during basic block profiling on %s\n", ctime ((void *) &time_value));
               printed_something = 1;
             }

           fprintf (file, "\tFunction %s", p->funcname);
           if (p->filename)
               fprintf (file, " of file %s", p->filename);
           fprintf (file, "\n" );

 found:        ;
         }

       if (printed_something)
        fprintf (file, "\n");

     }

   if (bb_mode & 2)
     {
       if (!bb_hashbuckets)
         {
           if (!reported)
             {
               fprintf (stderr, "Profiler: out of memory\n");
               reported = 1;
             }
           return;
         }

       else if (file)
         {
           long time_value;
           int i;
           unsigned long addr_max = 0;
           unsigned long cnt_max  = 0;
           int cnt_len;
           int addr_len;

           /* This is somewhat type incorrect, but it avoids worrying about
              exactly where time.h is included from.  It should be ok unless
              a void * differs from other pointer formats, or if sizeof (long)
              is < sizeof (time_t).  It would be nice if we could assume the
              use of rationale standards here.  */

           time ((void *) &time_value);
           fprintf (file, "Basic block jump tracing");

           switch (bb_mode & 12)
             {
               case 0:
                 fprintf (file, " (with call)");
               break;

               case 4:
 		/* Print nothing.  */
               break;

               case 8:
                 fprintf (file, " (with call & ret)");
               break;

               case 12:
                 fprintf (file, " (with ret)");
               break;
             }

           fprintf (file, " finished on %s\n", ctime ((void *) &time_value));

           for (i = 0; i < BB_BUCKETS; i++)
             {
                struct bb_edge *bucket = bb_hashbuckets[i];
                for ( ; bucket; bucket = bucket->next )
                  {
                    if (addr_max < bucket->src_addr)
                      addr_max = bucket->src_addr;
                    if (addr_max < bucket->dst_addr)
                      addr_max = bucket->dst_addr;
                    if (cnt_max < bucket->count)
                      cnt_max = bucket->count;
                  }
             }
           addr_len = num_digits (addr_max, 16);
           cnt_len  = num_digits (cnt_max, 10);

           for ( i = 0; i < BB_BUCKETS; i++)
             {
                struct bb_edge *bucket = bb_hashbuckets[i];
                for ( ; bucket; bucket = bucket->next )
                  {
                    fprintf (file,
 	"Jump from block 0x%.*lx to block 0x%.*lx executed %*lu time(s)\n",
                             addr_len, bucket->src_addr,
                             addr_len, bucket->dst_addr,
                             cnt_len, bucket->count);
                  }
             }

           fprintf (file, "\n");

         }
     }

    if (file)
      fclose (file);

    /* Free allocated memory.  */

    f = bb_func_head;
    while (f)
      {
        struct bb_func *old = f;

        f = f->next;
        if (old->funcname) free (old->funcname);
        if (old->filename) free (old->filename);
        free (old);
      }

    if (bb_stack)
      free (bb_stack);

    if (bb_hashbuckets)
      {
        int i;

        for (i = 0; i < BB_BUCKETS; i++)
          {
            struct bb_edge *old, *bucket = bb_hashbuckets[i];

            while (bucket)
              {
                old = bucket;
                bucket = bucket->next;
                free (old);
              }
          }
        free (bb_hashbuckets);
      }

    for (b = bb_head; b; b = b->next)
      if (b->flags) free (b->flags);
 }

 /* Called once per program.  */

 static void
 __bb_init_prg (void)
 {
   FILE *file;
   char buf[BBINBUFSIZE];
   const char *p;
   const char *pos;
   enum bb_func_mode m;
   int i;

   /* Initialize destructor.  */
   atexit (__bb_exit_func);

   if (!(file = fopen ("bb.in", "r")))
     return;

   while(fgets (buf, BBINBUFSIZE, file) != 0)
     {
       i = strlen (buf);
       if (buf[i-1] == '\n')
 	buf[--i] = '\0';

       p = buf;
       if (*p == '-')
         {
           m = TRACE_OFF;
           p++;
         }
       else
         {
           m = TRACE_ON;
         }
       if (!strcmp (p, "__bb_trace__"))
         bb_mode |= 1;
       else if (!strcmp (p, "__bb_jumps__"))
         bb_mode |= 2;
       else if (!strcmp (p, "__bb_hidecall__"))
         bb_mode |= 4;
       else if (!strcmp (p, "__bb_showret__"))
         bb_mode |= 8;
       else
         {
           struct bb_func *f = (struct bb_func *) malloc (sizeof (struct bb_func));
           if (f)
             {
               unsigned long l;
               f->next = bb_func_head;
               if ((pos = strchr (p, ':')))
                 {
                   if (!(f->funcname = (char *) malloc (strlen (pos+1)+1)))
                     continue;
                   strcpy (f->funcname, pos+1);
                   l = pos-p;
                   if ((f->filename = (char *) malloc (l+1)))
                     {
                       strncpy (f->filename, p, l);
                       f->filename[l] = '\0';
                     }
                   else
                     f->filename = (char *) 0;
                 }
               else
                 {
                   if (!(f->funcname = (char *) malloc (strlen (p)+1)))
                     continue;
                   strcpy (f->funcname, p);
                   f->filename = (char *) 0;
                 }
               f->mode = m;
               bb_func_head = f;
 	    }
          }
     }
   fclose (file);

 #ifdef HAVE_POPEN

   if (bb_mode & 1)
       bb_tracefile = gopen ("bbtrace.gz", "w");

 #else

   if (bb_mode & 1)
       bb_tracefile = fopen ("bbtrace", "w");

 #endif /* HAVE_POPEN */

   if (bb_mode & 2)
     {
       bb_hashbuckets = (struct bb_edge **)
                    malloc (BB_BUCKETS * sizeof (struct bb_edge *));
       if (bb_hashbuckets)
 	/* Use a loop here rather than calling bzero to avoid having to
 	   conditionalize its existance.  */
 	for (i = 0; i < BB_BUCKETS; i++)
 	  bb_hashbuckets[i] = 0;
     }

   if (bb_mode & 12)
     {
       bb_stacksize = 10;
       bb_stack = (unsigned long *) malloc (bb_stacksize * sizeof (*bb_stack));
     }

   /* Initialize destructor.  */
   atexit (__bb_exit_trace_func);
 }

 /* Called upon entering a basic block.  */

 void
 __bb_trace_func (void)
 {
   struct bb_edge *bucket;

   MACHINE_STATE_SAVE("1")

   if (!bb_callcount || (__bb.blocks->flags && (__bb.blocks->flags[__bb.blockno] & TRACE_OFF)))
     goto skip;

   bb_dst = __bb.blocks->addresses[__bb.blockno];
   __bb.blocks->counts[__bb.blockno]++;

   if (bb_tracefile)
     {
       fwrite (&bb_dst, sizeof (unsigned long), 1, bb_tracefile);
     }

   if (bb_hashbuckets)
     {
       struct bb_edge **startbucket, **oldnext;

       oldnext = startbucket
 	= & bb_hashbuckets[ (((int) bb_src*8) ^ (int) bb_dst) % BB_BUCKETS ];
       bucket = *startbucket;

       for (bucket = *startbucket; bucket;
            oldnext = &(bucket->next), bucket = *oldnext)
         {
           if (bucket->src_addr == bb_src
 	      && bucket->dst_addr == bb_dst)
             {
               bucket->count++;
               *oldnext = bucket->next;
               bucket->next = *startbucket;
               *startbucket = bucket;
               goto ret;
             }
         }

       bucket = (struct bb_edge *) malloc (sizeof (struct bb_edge));

       if (!bucket)
         {
           if (!reported)
             {
               fprintf (stderr, "Profiler: out of memory\n");
               reported = 1;
             }
         }

       else
         {
           bucket->src_addr = bb_src;
           bucket->dst_addr = bb_dst;
           bucket->next = *startbucket;
           *startbucket = bucket;
           bucket->count = 1;
         }
     }

 ret:
   bb_src = bb_dst;

 skip:
   ;

   MACHINE_STATE_RESTORE("1")

 }

 /* Called when returning from a function and `__bb_showret__' is set.  */

 static void
 __bb_trace_func_ret (void)
 {
   struct bb_edge *bucket;

   if (!bb_callcount || (__bb.blocks->flags && (__bb.blocks->flags[__bb.blockno] & TRACE_OFF)))
     goto skip;

   if (bb_hashbuckets)
     {
       struct bb_edge **startbucket, **oldnext;

       oldnext = startbucket
 	= & bb_hashbuckets[ (((int) bb_dst * 8) ^ (int) bb_src) % BB_BUCKETS ];
       bucket = *startbucket;

       for (bucket = *startbucket; bucket;
            oldnext = &(bucket->next), bucket = *oldnext)
         {
           if (bucket->src_addr == bb_dst
 	       && bucket->dst_addr == bb_src)
             {
               bucket->count++;
               *oldnext = bucket->next;
               bucket->next = *startbucket;
               *startbucket = bucket;
               goto ret;
             }
         }

       bucket = (struct bb_edge *) malloc (sizeof (struct bb_edge));

       if (!bucket)
         {
           if (!reported)
             {
               fprintf (stderr, "Profiler: out of memory\n");
               reported = 1;
             }
         }

       else
         {
           bucket->src_addr = bb_dst;
           bucket->dst_addr = bb_src;
           bucket->next = *startbucket;
           *startbucket = bucket;
           bucket->count = 1;
         }
     }

 ret:
   bb_dst = bb_src;

 skip:
   ;

 }

 /* Called upon entering the first function of a file.  */

 static void
 __bb_init_file (struct bb *blocks)
 {

   const struct bb_func *p;
   long blk, ncounts = blocks->ncounts;
   const char **functions = blocks->functions;

   /* Set up linked list.  */
   blocks->zero_word = 1;
   blocks->next = bb_head;
   bb_head = blocks;

   blocks->flags = 0;
   if (!bb_func_head
       || !(blocks->flags = (char *) malloc (sizeof (char) * blocks->ncounts)))
     return;

   for (blk = 0; blk < ncounts; blk++)
     blocks->flags[blk] = 0;

   for (blk = 0; blk < ncounts; blk++)
     {
       for (p = bb_func_head; p; p = p->next)
         {
           if (!strcmp (p->funcname, functions[blk])
 	      && (!p->filename || !strcmp (p->filename, blocks->filename)))
             {
               blocks->flags[blk] |= p->mode;
             }
         }
     }

 }

 /* Called when exiting from a function.  */

 void
 __bb_trace_ret (void)
 {

   MACHINE_STATE_SAVE("2")

   if (bb_callcount)
     {
       if ((bb_mode & 12) && bb_stacksize > bb_callcount)
         {
           bb_src = bb_stack[bb_callcount];
           if (bb_mode & 8)
             __bb_trace_func_ret ();
         }

       bb_callcount -= 1;
     }

   MACHINE_STATE_RESTORE("2")

 }

 /* Called when entering a function.  */

 void
 __bb_init_trace_func (struct bb *blocks, unsigned long blockno)
 {
   static int trace_init = 0;

   MACHINE_STATE_SAVE("3")

   if (!blocks->zero_word)
     {
       if (!trace_init)
         {
           trace_init = 1;
           __bb_init_prg ();
         }
       __bb_init_file (blocks);
     }

   if (bb_callcount)
     {

       bb_callcount += 1;

       if (bb_mode & 12)
         {
           if (bb_callcount >= bb_stacksize)
             {
               size_t newsize = bb_callcount + 100;

               bb_stack = (unsigned long *) realloc (bb_stack, newsize);
               if (! bb_stack)
                 {
                   if (!reported)
                     {
                       fprintf (stderr, "Profiler: out of memory\n");
                       reported = 1;
                     }
                   bb_stacksize = 0;
                   goto stack_overflow;
                 }
 	      bb_stacksize = newsize;
             }
           bb_stack[bb_callcount] = bb_src;

           if (bb_mode & 4)
             bb_src = 0;

         }

 stack_overflow:;

     }

   else if (blocks->flags && (blocks->flags[blockno] & TRACE_ON))
     {
       bb_callcount = 1;
       bb_src = 0;

       if (bb_stack)
           bb_stack[bb_callcount] = bb_src;
     }

   MACHINE_STATE_RESTORE("3")
 }
	/*
	* Copyright (c) 2000-2001 Red Hat, Inc. All rights reserved.
	*
	* This copyrighted material is made available to anyone wishing to use, modify,
	* copy, or redistribute it subject to the terms and conditions of the BSD
	* License. This program is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY expressed or implied, including the implied
	* warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. A copy
	* of this license is available at http://www.opensource.org/licenses. Any
	* Red Hat trademarks that are incorporated in the source code or documentation
	* are not subject to the BSD License and may only be used or replicated with
	* the express permission of Red Hat, Inc.
	*/

	/* Structure emitted by -a */
	struct bb
	{
	long zero_word;
	const char *filename;
	long *counts;
	long ncounts;
	struct bb *next;
	const unsigned long *addresses;

	/* Older GCC's did not emit these fields. */
	long nwords;
	const char **functions;
	const long *line_nums;
	const char **filenames;
	char *flags;
	};

	/* Simple minded basic block profiling output dumper for
	systems that don't provide tcov support. At present,
	it requires atexit and stdio. */

	#undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch. */
	#include <stdio.h>
	#include <time.h>
	char ctime (const time_t );

	/#include "gbl-ctors.h"/
	#include "gcov-io.h"
	#include <string.h>

	static struct bb *bb_head;

	static int num_digits (long value, int base) __attribute__ ((const));

	/* Return the number of digits needed to print a value */
	/* __inline__ */ static int num_digits (long value, int base)
	{
	int minus = (value < 0 && base != 16);
	unsigned long v = (minus) ? -value : value;
	int ret = minus;

	do
	{
	v /= base;
	ret++;
	}
	while (v);

	return ret;
	}

	void
	__bb_exit_func (void)
	{
	FILE da_file, file;
	long time_value;
	int i;

	if (bb_head == 0)
	return;

	i = strlen (bb_head->filename) - 3;

	if (!strcmp (bb_head->filename+i, ".da"))
	{
	/* Must be -fprofile-arcs not -a.
	Dump data in a form that gcov expects. */

	struct bb *ptr;

	for (ptr = bb_head; ptr != (struct bb *) 0; ptr = ptr->next)
	{
	int firstchar;

	/* Make sure the output file exists -
	but don't clobber exiting data. */
	if ((da_file = fopen (ptr->filename, "a")) != 0)
	fclose (da_file);

	/* Need to re-open in order to be able to write from the start. */
	da_file = fopen (ptr->filename, "r+b");
	/* Some old systems might not allow the 'b' mode modifier.
	Therefore, try to open without it. This can lead to a race
	condition so that when you delete and re-create the file, the
	file might be opened in text mode, but then, you shouldn't
	delete the file in the first place. */
	if (da_file == 0)
	da_file = fopen (ptr->filename, "r+");
	if (da_file == 0)
	{
	fprintf (stderr, "arc profiling: Can't open output file %s.\n",
	ptr->filename);
	continue;
	}

	/* After a fork, another process might try to read and/or write
	the same file simultanously. So if we can, lock the file to
	avoid race conditions. */

	/* If the file is not empty, and the number of counts in it is the
	same, then merge them in. */
	firstchar = fgetc (da_file);
	if (firstchar == EOF)
	{
	if (ferror (da_file))
	{
	fprintf (stderr, "arc profiling: Can't read output file ");
	perror (ptr->filename);
	}
	}
	else
	{
	long n_counts = 0;

	if (ungetc (firstchar, da_file) == EOF)
	rewind (da_file);
	if (__read_long (&n_counts, da_file, 8) != 0)
	{
	fprintf (stderr, "arc profiling: Can't read output file %s.\n",
	ptr->filename);
	continue;
	}

	if (n_counts == ptr->ncounts)
	{
	int i;

	for (i = 0; i < n_counts; i++)
	{
	long v = 0;

	if (__read_long (&v, da_file, 8) != 0)
	{
	fprintf (stderr, "arc profiling: Can't read output file %s.\n",
	ptr->filename);
	break;
	}
	ptr->counts[i] += v;
	}
	}

	}

	rewind (da_file);

	/* ??? Should first write a header to the file. Preferably, a 4 byte
	magic number, 4 bytes containing the time the program was
	compiled, 4 bytes containing the last modification time of the
	source file, and 4 bytes indicating the compiler options used.

	That way we can easily verify that the proper source/executable/
	data file combination is being used from gcov. */

	if (__write_long (ptr->ncounts, da_file, 8) != 0)
	{

	fprintf (stderr, "arc profiling: Error writing output file %s.\n",
	ptr->filename);
	}
	else
	{
	int j;
	long *count_ptr = ptr->counts;
	int ret = 0;
	for (j = ptr->ncounts; j > 0; j--)
	{
	if (__write_long (*count_ptr, da_file, 8) != 0)
	{
	ret=1;
	break;
	}
	count_ptr++;
	}
	if (ret)
	fprintf (stderr, "arc profiling: Error writing output file %s.\n",
	ptr->filename);
	}

	if (fclose (da_file) == EOF)
	fprintf (stderr, "arc profiling: Error closing output file %s.\n",
	ptr->filename);
	}

	return;
	}

	/* Must be basic block profiling. Emit a human readable output file. */

	file = fopen ("bb.out", "a");

	if (!file)
	perror ("bb.out");

	else
	{
	struct bb *ptr;

	/* This is somewhat type incorrect, but it avoids worrying about
	exactly where time.h is included from. It should be ok unless
	a void * differs from other pointer formats, or if sizeof (long)
	is < sizeof (time_t). It would be nice if we could assume the
	use of rationale standards here. */

	time ((void *) &time_value);
	fprintf (file, "Basic block profiling finished on %s\n", ctime ((void *) &time_value));

	/* We check the length field explicitly in order to allow compatibility
	with older GCC's which did not provide it. */

	for (ptr = bb_head; ptr != (struct bb *) 0; ptr = ptr->next)
	{
	int i;
	int func_p = (ptr->nwords >= (long) sizeof (struct bb)
	&& ptr->nwords <= 1000
	&& ptr->functions);
	int line_p = (func_p && ptr->line_nums);
	int file_p = (func_p && ptr->filenames);
	int addr_p = (ptr->addresses != 0);
	long ncounts = ptr->ncounts;
	long cnt_max = 0;
	long line_max = 0;
	long addr_max = 0;
	int file_len = 0;
	int func_len = 0;
	int blk_len = num_digits (ncounts, 10);
	int cnt_len;
	int line_len;
	int addr_len;

	fprintf (file, "File %s, %ld basic blocks \n\n",
	ptr->filename, ncounts);

	/* Get max values for each field. */
	for (i = 0; i < ncounts; i++)
	{
	const char *p;
	int len;

	if (cnt_max < ptr->counts[i])
	cnt_max = ptr->counts[i];

	if (addr_p && (unsigned long) addr_max < ptr->addresses[i])
	addr_max = ptr->addresses[i];

	if (line_p && line_max < ptr->line_nums[i])
	line_max = ptr->line_nums[i];

	if (func_p)
	{
	p = (ptr->functions[i]) ? (ptr->functions[i]) : "<none>";
	len = strlen (p);
	if (func_len < len)
	func_len = len;
	}

	if (file_p)
	{
	p = (ptr->filenames[i]) ? (ptr->filenames[i]) : "<none>";
	len = strlen (p);
	if (file_len < len)
	file_len = len;
	}
	}

	addr_len = num_digits (addr_max, 16);
	cnt_len = num_digits (cnt_max, 10);
	line_len = num_digits (line_max, 10);

	/* Now print out the basic block information. */
	for (i = 0; i < ncounts; i++)
	{
	fprintf (file,
	" Block #%d: executed %ld time(s)",
	blk_len, i+1,
	cnt_len, ptr->counts[i]);

	if (addr_p)
	fprintf (file, " address= 0x%.*lx", addr_len,
	ptr->addresses[i]);

	if (func_p)
	fprintf (file, " function= %-*s", func_len,
	(ptr->functions[i]) ? ptr->functions[i] : "<none>");

	if (line_p)
	fprintf (file, " line= %*ld", line_len, ptr->line_nums[i]);

	if (file_p)
	fprintf (file, " file= %s",
	(ptr->filenames[i]) ? ptr->filenames[i] : "<none>");

	fprintf (file, "\n");
	}

	fprintf (file, "\n");
	fflush (file);
	}

	fprintf (file, "\n\n");
	fclose (file);
	}
	}

	void
	__bb_init_func (struct bb *blocks)
	{
	/* User is supposed to check whether the first word is non-0,
	but just in case.... */

	if (blocks->zero_word)
	return;

	/* Initialize destructor. */
	if (!bb_head)
	atexit (__bb_exit_func);

	/* Set up linked list. */
	blocks->zero_word = 1;
	blocks->next = bb_head;
	bb_head = blocks;
	}

	/* Called before fork or exec - write out profile information gathered so
	far and reset it to zero. This avoids duplication or loss of the
	profile information gathered so far. */
	void
	__bb_fork_func (void)
	{
	struct bb *ptr;

	__bb_exit_func ();
	for (ptr = bb_head; ptr != (struct bb *) 0; ptr = ptr->next)
	{
	long i;
	for (i = ptr->ncounts - 1; i >= 0; i--)
	ptr->counts[i] = 0;
	}
	}

	#ifndef MACHINE_STATE_SAVE
	#define MACHINE_STATE_SAVE(ID)
	#endif
	#ifndef MACHINE_STATE_RESTORE
	#define MACHINE_STATE_RESTORE(ID)
	#endif

	/* Number of buckets in hashtable of basic block addresses. */

	#define BB_BUCKETS 311

	/* Maximum length of string in file bb.in. */

	#define BBINBUFSIZE 500

	struct bb_edge
	{
	struct bb_edge *next;
	unsigned long src_addr;
	unsigned long dst_addr;
	unsigned long count;
	};

	enum bb_func_mode
	{
	TRACE_KEEP = 0, TRACE_ON = 1, TRACE_OFF = 2
	};

	struct bb_func
	{
	struct bb_func *next;
	char *funcname;
	char *filename;
	enum bb_func_mode mode;
	};

	/* This is the connection to the outside world.
	The BLOCK_PROFILER macro must set __bb.blocks
	and __bb.blockno. */

	struct {
	unsigned long blockno;
	struct bb *blocks;
	} __bb;

	/* Vars to store addrs of source and destination basic blocks
	of a jump. */

	static unsigned long bb_src = 0;
	static unsigned long bb_dst = 0;

	static FILE bb_tracefile = (FILE ) 0;
	static struct bb_edge bb_hashbuckets = (struct bb_edge ) 0;
	static struct bb_func bb_func_head = (struct bb_func ) 0;
	static unsigned long bb_callcount = 0;
	static int bb_mode = 0;

	static unsigned long bb_stack = (unsigned long ) 0;
	static size_t bb_stacksize = 0;

	static int reported = 0;

	/* Trace modes:
	Always : Print execution frequencies of basic blocks
	to file bb.out.
	bb_mode & 1 != 0 : Dump trace of basic blocks to file bbtrace[.gz]
	bb_mode & 2 != 0 : Print jump frequencies to file bb.out.
	bb_mode & 4 != 0 : Cut call instructions from basic block flow.
	bb_mode & 8 != 0 : Insert return instructions in basic block flow.
	*/

	#ifdef HAVE_POPEN

	/#include <sys/types.h>/
	#include <sys/stat.h>
	/#include <malloc.h>/

	/* Commands executed by gopen. */

	#define GOPENDECOMPRESS "gzip -cd "
	#define GOPENCOMPRESS "gzip -c >"

	/* Like fopen but pipes through gzip. mode may only be "r" or "w".
	If it does not compile, simply replace gopen by fopen and delete
	'.gz' from any first parameter to gopen. */

	static FILE *
	gopen (char fn, char mode)
	{
	int use_gzip;
	char *p;

	if (mode[1])
	return (FILE *) 0;

	if (mode[0] != 'r' && mode[0] != 'w')
	return (FILE *) 0;

	p = fn + strlen (fn)-1;
	use_gzip = ((p[-1] == '.' && (p[0] == 'Z' \|\| p[0] == 'z'))
	\|\| (p[-2] == '.' && p[-1] == 'g' && p[0] == 'z'));

	if (use_gzip)
	{
	if (mode[0]=='r')
	{
	FILE *f;
	char s = (char ) malloc (sizeof (char) * strlen (fn)
	+ sizeof (GOPENDECOMPRESS));
	strcpy (s, GOPENDECOMPRESS);
	strcpy (s + (sizeof (GOPENDECOMPRESS)-1), fn);
	f = popen (s, mode);
	free (s);
	return f;
	}

	else
	{
	FILE *f;
	char s = (char ) malloc (sizeof (char) * strlen (fn)
	+ sizeof (GOPENCOMPRESS));
	strcpy (s, GOPENCOMPRESS);
	strcpy (s + (sizeof (GOPENCOMPRESS)-1), fn);
	if (!(f = popen (s, mode)))
	f = fopen (s, mode);
	free (s);
	return f;
	}
	}

	else
	return fopen (fn, mode);
	}

	static int
	gclose (FILE *f)
	{
	struct stat buf;

	if (f != 0)
	{
	if (!fstat (fileno (f), &buf) && S_ISFIFO (buf.st_mode))
	return pclose (f);

	return fclose (f);
	}
	return 0;
	}

	#endif /* HAVE_POPEN */

	/* Called once per program. */

	static void
	__bb_exit_trace_func (void)
	{
	FILE *file = fopen ("bb.out", "a");
	struct bb_func *f;
	struct bb *b;

	if (!file)
	perror ("bb.out");

	if (bb_mode & 1)
	{
	if (!bb_tracefile)
	perror ("bbtrace");
	else
	#ifdef HAVE_POPEN
	gclose (bb_tracefile);
	#else
	fclose (bb_tracefile);
	#endif /* HAVE_POPEN */
	}

	/* Check functions in `bb.in'. */

	if (file)
	{
	long time_value;
	const struct bb_func *p;
	int printed_something = 0;
	struct bb *ptr;
	long blk;

	/* This is somewhat type incorrect. */
	time ((void *) &time_value);

	for (p = bb_func_head; p != (struct bb_func *) 0; p = p->next)
	{
	for (ptr = bb_head; ptr != (struct bb *) 0; ptr = ptr->next)
	{
	if (!ptr->filename \|\| (p->filename != (char *) 0 && strcmp (p->filename, ptr->filename)))
	continue;
	for (blk = 0; blk < ptr->ncounts; blk++)
	{
	if (!strcmp (p->funcname, ptr->functions[blk]))
	goto found;
	}
	}

	if (!printed_something)
	{
	fprintf (file, "Functions in `bb.in' not executed during basic block profiling on %s\n", ctime ((void *) &time_value));
	printed_something = 1;
	}

	fprintf (file, "\tFunction %s", p->funcname);
	if (p->filename)
	fprintf (file, " of file %s", p->filename);
	fprintf (file, "\n" );

	found: ;
	}

	if (printed_something)
	fprintf (file, "\n");

	}

	if (bb_mode & 2)
	{
	if (!bb_hashbuckets)
	{
	if (!reported)
	{
	fprintf (stderr, "Profiler: out of memory\n");
	reported = 1;
	}
	return;
	}

	else if (file)
	{
	long time_value;
	int i;
	unsigned long addr_max = 0;
	unsigned long cnt_max = 0;
	int cnt_len;
	int addr_len;

	/* This is somewhat type incorrect, but it avoids worrying about
	exactly where time.h is included from. It should be ok unless
	a void * differs from other pointer formats, or if sizeof (long)
	is < sizeof (time_t). It would be nice if we could assume the
	use of rationale standards here. */

	time ((void *) &time_value);
	fprintf (file, "Basic block jump tracing");

	switch (bb_mode & 12)
	{
	case 0:
	fprintf (file, " (with call)");
	break;

	case 4:
	/* Print nothing. */
	break;

	case 8:
	fprintf (file, " (with call & ret)");
	break;

	case 12:
	fprintf (file, " (with ret)");
	break;
	}

	fprintf (file, " finished on %s\n", ctime ((void *) &time_value));

	for (i = 0; i < BB_BUCKETS; i++)
	{
	struct bb_edge *bucket = bb_hashbuckets[i];
	for ( ; bucket; bucket = bucket->next )
	{
	if (addr_max < bucket->src_addr)
	addr_max = bucket->src_addr;
	if (addr_max < bucket->dst_addr)
	addr_max = bucket->dst_addr;
	if (cnt_max < bucket->count)
	cnt_max = bucket->count;
	}
	}
	addr_len = num_digits (addr_max, 16);
	cnt_len = num_digits (cnt_max, 10);

	for ( i = 0; i < BB_BUCKETS; i++)
	{
	struct bb_edge *bucket = bb_hashbuckets[i];
	for ( ; bucket; bucket = bucket->next )
	{
	fprintf (file,
	"Jump from block 0x%.lx to block 0x%.lx executed %*lu time(s)\n",
	addr_len, bucket->src_addr,
	addr_len, bucket->dst_addr,
	cnt_len, bucket->count);
	}
	}

	fprintf (file, "\n");

	}
	}

	if (file)
	fclose (file);

	/* Free allocated memory. */

	f = bb_func_head;
	while (f)
	{
	struct bb_func *old = f;

	f = f->next;
	if (old->funcname) free (old->funcname);
	if (old->filename) free (old->filename);
	free (old);
	}

	if (bb_stack)
	free (bb_stack);

	if (bb_hashbuckets)
	{
	int i;

	for (i = 0; i < BB_BUCKETS; i++)
	{
	struct bb_edge old, bucket = bb_hashbuckets[i];

	while (bucket)
	{
	old = bucket;
	bucket = bucket->next;
	free (old);
	}
	}
	free (bb_hashbuckets);
	}

	for (b = bb_head; b; b = b->next)
	if (b->flags) free (b->flags);
	}

	/* Called once per program. */

	static void
	__bb_init_prg (void)
	{
	FILE *file;
	char buf[BBINBUFSIZE];
	const char *p;
	const char *pos;
	enum bb_func_mode m;
	int i;

	/* Initialize destructor. */
	atexit (__bb_exit_func);

	if (!(file = fopen ("bb.in", "r")))
	return;

	while(fgets (buf, BBINBUFSIZE, file) != 0)
	{
	i = strlen (buf);
	if (buf[i-1] == '\n')
	buf[--i] = '\0';

	p = buf;
	if (*p == '-')
	{
	m = TRACE_OFF;
	p++;
	}
	else
	{
	m = TRACE_ON;
	}
	if (!strcmp (p, "__bb_trace__"))
	bb_mode \|= 1;
	else if (!strcmp (p, "__bb_jumps__"))
	bb_mode \|= 2;
	else if (!strcmp (p, "__bb_hidecall__"))
	bb_mode \|= 4;
	else if (!strcmp (p, "__bb_showret__"))
	bb_mode \|= 8;
	else
	{
	struct bb_func f = (struct bb_func ) malloc (sizeof (struct bb_func));
	if (f)
	{
	unsigned long l;
	f->next = bb_func_head;
	if ((pos = strchr (p, ':')))
	{
	if (!(f->funcname = (char *) malloc (strlen (pos+1)+1)))
	continue;
	strcpy (f->funcname, pos+1);
	l = pos-p;
	if ((f->filename = (char *) malloc (l+1)))
	{
	strncpy (f->filename, p, l);
	f->filename[l] = '\0';
	}
	else
	f->filename = (char *) 0;
	}
	else
	{
	if (!(f->funcname = (char *) malloc (strlen (p)+1)))
	continue;
	strcpy (f->funcname, p);
	f->filename = (char *) 0;
	}
	f->mode = m;
	bb_func_head = f;
	}
	}
	}
	fclose (file);

	#ifdef HAVE_POPEN

	if (bb_mode & 1)
	bb_tracefile = gopen ("bbtrace.gz", "w");

	#else

	if (bb_mode & 1)
	bb_tracefile = fopen ("bbtrace", "w");

	#endif /* HAVE_POPEN */

	if (bb_mode & 2)
	{
	bb_hashbuckets = (struct bb_edge **)
	malloc (BB_BUCKETS * sizeof (struct bb_edge *));
	if (bb_hashbuckets)
	/* Use a loop here rather than calling bzero to avoid having to
	conditionalize its existance. */
	for (i = 0; i < BB_BUCKETS; i++)
	bb_hashbuckets[i] = 0;
	}

	if (bb_mode & 12)
	{
	bb_stacksize = 10;
	bb_stack = (unsigned long ) malloc (bb_stacksize sizeof (*bb_stack));
	}

	/* Initialize destructor. */
	atexit (__bb_exit_trace_func);
	}

	/* Called upon entering a basic block. */

	void
	__bb_trace_func (void)
	{
	struct bb_edge *bucket;

	MACHINE_STATE_SAVE("1")

	if (!bb_callcount \|\| (__bb.blocks->flags && (__bb.blocks->flags[__bb.blockno] & TRACE_OFF)))
	goto skip;

	bb_dst = __bb.blocks->addresses[__bb.blockno];
	__bb.blocks->counts[__bb.blockno]++;

	if (bb_tracefile)
	{
	fwrite (&bb_dst, sizeof (unsigned long), 1, bb_tracefile);
	}

	if (bb_hashbuckets)
	{
	struct bb_edge startbucket, oldnext;

	oldnext = startbucket
	= & bb_hashbuckets[ (((int) bb_src*8) ^ (int) bb_dst) % BB_BUCKETS ];
	bucket = *startbucket;

	for (bucket = *startbucket; bucket;
	oldnext = &(bucket->next), bucket = *oldnext)
	{
	if (bucket->src_addr == bb_src
	&& bucket->dst_addr == bb_dst)
	{
	bucket->count++;
	*oldnext = bucket->next;
	bucket->next = *startbucket;
	*startbucket = bucket;
	goto ret;
	}
	}

	bucket = (struct bb_edge *) malloc (sizeof (struct bb_edge));

	if (!bucket)
	{
	if (!reported)
	{
	fprintf (stderr, "Profiler: out of memory\n");
	reported = 1;
	}
	}

	else
	{
	bucket->src_addr = bb_src;
	bucket->dst_addr = bb_dst;
	bucket->next = *startbucket;
	*startbucket = bucket;
	bucket->count = 1;
	}
	}

	ret:
	bb_src = bb_dst;

	skip:
	;

	MACHINE_STATE_RESTORE("1")

	}

	/* Called when returning from a function and `__bb_showret__' is set. */

	static void
	__bb_trace_func_ret (void)
	{
	struct bb_edge *bucket;

	if (!bb_callcount \|\| (__bb.blocks->flags && (__bb.blocks->flags[__bb.blockno] & TRACE_OFF)))
	goto skip;

	if (bb_hashbuckets)
	{
	struct bb_edge startbucket, oldnext;

	oldnext = startbucket
	= & bb_hashbuckets[ (((int) bb_dst * 8) ^ (int) bb_src) % BB_BUCKETS ];
	bucket = *startbucket;

	for (bucket = *startbucket; bucket;
	oldnext = &(bucket->next), bucket = *oldnext)
	{
	if (bucket->src_addr == bb_dst
	&& bucket->dst_addr == bb_src)
	{
	bucket->count++;
	*oldnext = bucket->next;
	bucket->next = *startbucket;
	*startbucket = bucket;
	goto ret;
	}
	}

	bucket = (struct bb_edge *) malloc (sizeof (struct bb_edge));

	if (!bucket)
	{
	if (!reported)
	{
	fprintf (stderr, "Profiler: out of memory\n");
	reported = 1;
	}
	}

	else
	{
	bucket->src_addr = bb_dst;
	bucket->dst_addr = bb_src;
	bucket->next = *startbucket;
	*startbucket = bucket;
	bucket->count = 1;
	}
	}

	ret:
	bb_dst = bb_src;

	skip:
	;

	}

	/* Called upon entering the first function of a file. */

	static void
	__bb_init_file (struct bb *blocks)
	{

	const struct bb_func *p;
	long blk, ncounts = blocks->ncounts;
	const char **functions = blocks->functions;

	/* Set up linked list. */
	blocks->zero_word = 1;
	blocks->next = bb_head;
	bb_head = blocks;

	blocks->flags = 0;
	if (!bb_func_head
	\|\| !(blocks->flags = (char ) malloc (sizeof (char) blocks->ncounts)))
	return;

	for (blk = 0; blk < ncounts; blk++)
	blocks->flags[blk] = 0;

	for (blk = 0; blk < ncounts; blk++)
	{
	for (p = bb_func_head; p; p = p->next)
	{
	if (!strcmp (p->funcname, functions[blk])
	&& (!p->filename \|\| !strcmp (p->filename, blocks->filename)))
	{
	blocks->flags[blk] \|= p->mode;
	}
	}
	}

	}

	/* Called when exiting from a function. */

	void
	__bb_trace_ret (void)
	{

	MACHINE_STATE_SAVE("2")

	if (bb_callcount)
	{
	if ((bb_mode & 12) && bb_stacksize > bb_callcount)
	{
	bb_src = bb_stack[bb_callcount];
	if (bb_mode & 8)
	__bb_trace_func_ret ();
	}

	bb_callcount -= 1;
	}

	MACHINE_STATE_RESTORE("2")

	}

	/* Called when entering a function. */

	void
	__bb_init_trace_func (struct bb *blocks, unsigned long blockno)
	{
	static int trace_init = 0;

	MACHINE_STATE_SAVE("3")

	if (!blocks->zero_word)
	{
	if (!trace_init)
	{
	trace_init = 1;
	__bb_init_prg ();
	}
	__bb_init_file (blocks);
	}

	if (bb_callcount)
	{

	bb_callcount += 1;

	if (bb_mode & 12)
	{
	if (bb_callcount >= bb_stacksize)
	{
	size_t newsize = bb_callcount + 100;

	bb_stack = (unsigned long *) realloc (bb_stack, newsize);
	if (! bb_stack)
	{
	if (!reported)
	{
	fprintf (stderr, "Profiler: out of memory\n");
	reported = 1;
	}
	bb_stacksize = 0;
	goto stack_overflow;
	}
	bb_stacksize = newsize;
	}
	bb_stack[bb_callcount] = bb_src;

	if (bb_mode & 4)
	bb_src = 0;

	}

	stack_overflow:;

	}

	else if (blocks->flags && (blocks->flags[blockno] & TRACE_ON))
	{
	bb_callcount = 1;
	bb_src = 0;

	if (bb_stack)
	bb_stack[bb_callcount] = bb_src;
	}

	MACHINE_STATE_RESTORE("3")
	}