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

/* basic_blocks.c  -  Basic-block level related code: reading/writing
   of basic-block info to/from gmon.out; computing and formatting of
   basic-block related statistics.

   Copyright (C) 2000  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 2 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., 59 Temple Place - Suite 330, Boston, MA
   02111-1307, USA.  */
\f
#include <stdio.h>
#include "basic_blocks.h"
#include "corefile.h"
#include "gmon_io.h"
#include "gmon_out.h"
#include "gprof.h"
#include "libiberty.h"
#include "source.h"
#include "sym_ids.h"
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif

/* Default option values:  */
bool bb_annotate_all_lines = FALSE;
unsigned long bb_min_calls = 1;
int bb_table_length = 10;

/* Variables used to compute annotated source listing stats:  */
static long num_executable_lines;
static long num_lines_executed;


/* Helper for sorting.  Compares two symbols and returns result
   such that sorting will be increasing according to filename, line
   number, and address (in that order).  */

static int
DEFUN (cmp_bb, (lp, rp), const void *lp AND const void *rp)
{
  int r;
  const Sym *left = *(const Sym **) lp;
  const Sym *right = *(const Sym **) rp;

  if (left->file && right->file)
    {
      r = strcmp (left->file->name, right->file->name);
      
      if (r)
	return r;

      if (left->line_num != right->line_num)
	return left->line_num - right->line_num;
    }

  if (left->addr < right->addr)
    return -1;
  else if (left->addr > right->addr)
    return 1;
  else
    return 0;
}


/* Helper for sorting.  Order basic blocks in decreasing number of
   calls, ties are broken in increasing order of line numbers.  */
static int
DEFUN (cmp_ncalls, (lp, rp), const void *lp AND const void *rp)
{
  const Sym *left = *(const Sym **) lp;
  const Sym *right = *(const Sym **) rp;

  if (!left)
    return 1;
  else if (!right)
    return -1;

  if (left->ncalls < right->ncalls)
    return 1;
  else if (left->ncalls > right->ncalls)
    return -1;

  return left->line_num - right->line_num;
}

/* Skip over variable length string.  */
static void
DEFUN (fskip_string, (fp), FILE * fp)
{
  int ch;

  while ((ch = fgetc (fp)) != EOF)
    {
      if (ch == '\0')
	break;
    }
}

/* Read a basic-block record from file IFP.  FILENAME is the name
   of file IFP and is provided for formatting error-messages only.  */

void
DEFUN (bb_read_rec, (ifp, filename), FILE * ifp AND const char *filename)
{
  int nblocks, b;
  bfd_vma addr;
  unsigned long ncalls;
  Sym *sym;

  if (fread (&nblocks, sizeof (nblocks), 1, ifp) != 1)
    {
      fprintf (stderr, _("%s: %s: unexpected end of file\n"), whoami, filename);
      done (1);
    }

  nblocks = bfd_get_32 (core_bfd, (bfd_byte *) & nblocks);
  
  if (gmon_file_version == 0)
    fskip_string (ifp);

  for (b = 0; b < nblocks; ++b)
    {
      if (gmon_file_version == 0)
	{
	  int line_num;
	  
	  /* Version 0 had lots of extra stuff that we don't
	     care about anymore.  */
	  if ((fread (&ncalls, sizeof (ncalls), 1, ifp) != 1)
	      || (fread (&addr, sizeof (addr), 1, ifp) != 1)
	      || (fskip_string (ifp), FALSE)
	      || (fskip_string (ifp), FALSE)
	      || (fread (&line_num, sizeof (line_num), 1, ifp) != 1))
	    {
	      perror (filename);
	      done (1);
	    }
	}
      else
	{
	  if (fread (&addr, sizeof (addr), 1, ifp) != 1
	      || fread (&ncalls, sizeof (ncalls), 1, ifp) != 1)
	    {
	      perror (filename);
	      done (1);
	    }
	}

      /* Basic-block execution counts are meaningful only if we're
         profiling at the line-by-line level:  */
      if (line_granularity)
	{
	  /* Convert from target to host endianness:  */
	  addr = get_vma (core_bfd, (bfd_byte *) & addr);
	  ncalls = bfd_get_32 (core_bfd, (bfd_byte *) &ncalls);

	  sym = sym_lookup (&symtab, addr);

	  if (sym)
	    {
	      int i;

	      DBG (BBDEBUG,
		   printf ("[bb_read_rec] 0x%lx->0x%lx (%s:%d) cnt=%lu\n",
			   (unsigned long) addr, (unsigned long) sym->addr,
			   sym->name, sym->line_num, ncalls));

	      for (i = 0; i < NBBS; i++)
		{
		  if (! sym->bb_addr[i] || sym->bb_addr[i] == addr)
		    {
		      sym->bb_addr[i] = addr;
		      sym->bb_calls[i] += ncalls;
		      break;
		    }
		}
	    }
	}
      else
	{
	  static bool user_warned = FALSE;

	  if (!user_warned)
	    {
	      user_warned = TRUE;
	      fprintf (stderr,
  _("%s: warning: ignoring basic-block exec counts (use -l or --line)\n"),
		       whoami);
	    }
	}
    }
  return;
}

/* Write all basic-blocks with non-zero counts to file OFP.  FILENAME
   is the name of OFP and is provided for producing error-messages
   only.  */
void
DEFUN (bb_write_blocks, (ofp, filename), FILE * ofp AND const char *filename)
{
  const unsigned char tag = GMON_TAG_BB_COUNT;
  int nblocks = 0;
  bfd_vma addr;
  unsigned long ncalls;
  Sym *sym;
  int i;

  /* Count how many non-zero blocks with have:  */
  for (sym = symtab.base; sym < symtab.limit; ++sym)
    {
      for (i = 0; i < NBBS && sym->bb_addr[i]; i++)
	;
      nblocks += i;
    }

  /* Write header:  */
  bfd_put_32 (core_bfd, nblocks, (bfd_byte *) & nblocks);
  if (fwrite (&tag, sizeof (tag), 1, ofp) != 1
      || fwrite (&nblocks, sizeof (nblocks), 1, ofp) != 1)
    {
      perror (filename);
      done (1);
    }

  /* Write counts:  */
  for (sym = symtab.base; sym < symtab.limit; ++sym)
    {
      for (i = 0; i < NBBS && sym->bb_addr[i]; i++)
	{
	  put_vma (core_bfd, sym->bb_addr[i], (bfd_byte *) & addr);
	  bfd_put_32 (core_bfd, sym->bb_calls[i], (bfd_byte *) & ncalls);

	  if (fwrite (&addr, sizeof (addr), 1, ofp) != 1
	      || fwrite (&ncalls, sizeof (ncalls), 1, ofp) != 1)
	    {
	      perror (filename);
	      done (1);
	    }
	}
    }
}

/* Output basic-block statistics in a format that is easily parseable.
   Current the format is:
  
        <filename>:<line-number>: (<function-name>:<bb-addr): <ncalls>  */

void
DEFUN_VOID (print_exec_counts)
{
  Sym **sorted_bbs, *sym;
  int i, j, len;

  if (first_output)
    first_output = FALSE;
  else
    printf ("\f\n");

  /* Sort basic-blocks according to function name and line number:  */
  sorted_bbs = (Sym **) xmalloc (symtab.len * sizeof (sorted_bbs[0]));
  len = 0;
  
  for (sym = symtab.base; sym < symtab.limit; ++sym)
    {
      /* Accept symbol if it's in the INCL_EXEC table
         or there is no INCL_EXEC table
         and it does not appear in the EXCL_EXEC table.  */
      if (sym_lookup (&syms[INCL_EXEC], sym->addr)
	  || (syms[INCL_EXEC].len == 0
	      && !sym_lookup (&syms[EXCL_EXEC], sym->addr)))
	{
	  sorted_bbs[len++] = sym;
	}
    }
  
  qsort (sorted_bbs, len, sizeof (sorted_bbs[0]), cmp_bb);

  /* Output basic-blocks:  */

  for (i = 0; i < len; ++i)
    {
      if (sym->ncalls > 0 || ! ignore_zeros)
	{
	  /* FIXME: This only works if bfd_vma is unsigned long.  */
	  printf (_("%s:%d: (%s:0x%lx) %lu executions\n"),
		  sym->file ? sym->file->name : _("<unknown>"), sym->line_num,
		  sym->name, (unsigned long) sym->addr, sym->ncalls);
	}
      
      for (j = 0; j < NBBS && sym->bb_addr[j]; j ++)
	{
	  if (sym->bb_calls[j] > 0 || ! ignore_zeros)
	    {
	      /* FIXME: This only works if bfd_vma is unsigned long.  */
	      printf (_("%s:%d: (%s:0x%lx) %lu executions\n"),
		      sym->file ? sym->file->name : _("<unknown>"), sym->line_num,
		      sym->name, (unsigned long) sym->bb_addr[j],
		      sym->bb_calls[j]);
	    }
	}
    }
  free (sorted_bbs);
}

/* Helper for bb_annotated_source: format annotation containing
   number of line executions.  Depends on being called on each
   line of a file in sequential order.
  
   Global variable bb_annotate_all_lines enables execution count
   compression (counts are supressed if identical to the last one)
   and prints counts on all executed lines.  Otherwise, print
   all basic-block execution counts exactly once on the line
   that starts the basic-block.  */

static void
DEFUN (annotate_with_count, (buf, width, line_num, arg),
       char *buf AND int width AND int line_num AND void *arg)
{
  Source_File *sf = arg;
  Sym *b;
  int i;
  static unsigned long last_count;
  unsigned long last_print = (unsigned long) -1;

  b = NULL;
  
  if (line_num <= sf->num_lines)
    b = sf->line[line_num - 1];

  if (!b)
    {
      for (i = 0; i < width; i++)
	buf[i] = ' ';
      buf[width] = '\0';
    }
  else
    {
      char tmpbuf[NBBS * 30];
      char *p;
      unsigned long ncalls;
      int ncalls_set;
      int len;

      ++num_executable_lines;

      p = tmpbuf;
      *p = '\0';

      ncalls = 0;
      ncalls_set = 0;

      /* If this is a function entry point, label the line no matter what.
         Otherwise, we're in the middle of a function, so check to see
         if the first basic-block address is larger than the starting
         address of the line.  If so, then this line begins with a
         a portion of the previous basic-block, so print that prior
         execution count (if bb_annotate_all_lines is set).  */
      if (b->is_func)
	{
	  sprintf (p, "%lu", b->ncalls);
	  p += strlen (p);
	  last_count = b->ncalls;
	  last_print = last_count;
	  ncalls = b->ncalls;
	  ncalls_set = 1;
	}
      else if (bb_annotate_all_lines
	       && b->bb_addr[0] && b->bb_addr[0] > b->addr)
	{
	  sprintf (p, "%lu", last_count);
	  p += strlen (p);
	  last_print = last_count;
	  ncalls = last_count;
	  ncalls_set = 1;
	}

      /* Loop through all of this line's basic-blocks.  For each one,
         update last_count, then compress sequential identical counts
         (if bb_annotate_all_lines) and print the execution count.  */

      for (i = 0; i < NBBS && b->bb_addr[i]; i++)
	{
	  last_count = b->bb_calls[i];
	  if (! ncalls_set)
	    {
	      ncalls = 0;
	      ncalls_set = 1;
	    }
	  ncalls += last_count;

	  if (bb_annotate_all_lines && last_count == last_print)
	    continue;

	  if (p > tmpbuf)
	    *p++ = ',';
	  sprintf (p, "%lu", last_count);
	  p += strlen (p);

	  last_print = last_count;
	}

      /* We're done.  If nothing has been printed on this line,
         print the last execution count (bb_annotate_all_lines),
         which could be from either a previous line (if there were
         no BBs on this line), or from this line (if all our BB
         counts were compressed out because they were identical).  */

      if (bb_annotate_all_lines && p == tmpbuf)
	{
	  sprintf (p, "%lu", last_count);
	  p += strlen (p);
	  ncalls = last_count;
	  ncalls_set = 1;
	}

      if (! ncalls_set)
	{
	  int c;

	  for (c = 0; c < width; c++)
	    buf[c] = ' ';
	  buf[width] = '\0';
	  return;
	}

      ++num_lines_executed;

      if (ncalls < bb_min_calls)
	{
	  strcpy (tmpbuf, "#####");
	  p = tmpbuf + 5;
	}

      strcpy (p, " -> ");
      p += 4;

      len = p - tmpbuf;
      if (len >= width)
	{
	  strncpy (buf, tmpbuf, width);
	  buf[width] = '\0';
	}
      else
	{
	  int c;

	  strcpy (buf + width - len, tmpbuf);
	  for (c = 0; c < width - len; ++c)
	    buf[c] = ' ';
	}
    }
}

/* Annotate the files named in SOURCE_FILES with basic-block statistics
   (execution counts).  After each source files, a few statistics
   regarding that source file are printed.  */

void
DEFUN_VOID (print_annotated_source)
{
  Sym *sym, *line_stats, *new_line;
  Source_File *sf;
  int i, table_len;
  FILE *ofp;

  /* Find maximum line number for each source file that user is
     interested in:  */
  for (sym = symtab.base; sym < symtab.limit; ++sym)
    {
      /* Accept symbol if it's file is known, its line number is
         bigger than anything we have seen for that file so far and
         if it's in the INCL_ANNO table or there is no INCL_ANNO
         table and it does not appear in the EXCL_ANNO table.  */
      if (sym->file && sym->line_num > sym->file->num_lines
	  && (sym_lookup (&syms[INCL_ANNO], sym->addr)
	      || (syms[INCL_ANNO].len == 0
		  && !sym_lookup (&syms[EXCL_ANNO], sym->addr))))
	{
	  sym->file->num_lines = sym->line_num;
	}
    }

  /* Allocate line descriptors:  */
  for (sf = first_src_file; sf; sf = sf->next)
    {
      if (sf->num_lines > 0)
	{
	  sf->line = (void *) xmalloc (sf->num_lines * sizeof (sf->line[0]));
	  memset (sf->line, 0, sf->num_lines * sizeof (sf->line[0]));
	}
    }

  /* Count executions per line:  */
  for (sym = symtab.base; sym < symtab.limit; ++sym)
    {
      if (sym->file && sym->file->num_lines
	  && (sym_lookup (&syms[INCL_ANNO], sym->addr)
	      || (syms[INCL_ANNO].len == 0
		  && !sym_lookup (&syms[EXCL_ANNO], sym->addr))))
	{
	  sym->file->ncalls += sym->ncalls;
	  line_stats = sym->file->line[sym->line_num - 1];
	  
	  if (!line_stats)
	    {
	      /* Common case has at most one basic-block per source line:  */
	      sym->file->line[sym->line_num - 1] = sym;
	    }
	  else if (!line_stats->addr)
	    {
	      /* sym is the 3rd .. nth basic block for this line:  */
	      line_stats->ncalls += sym->ncalls;
	    }
	  else
	    {
	      /* sym is the second basic block for this line.  */
	      new_line = (Sym *) xmalloc (sizeof (*new_line));
	      *new_line = *line_stats;
	      new_line->addr = 0;
	      new_line->ncalls += sym->ncalls;
	      sym->file->line[sym->line_num - 1] = new_line;
	    }
	}
    }

  /* Plod over source files, annotating them:  */
  for (sf = first_src_file; sf; sf = sf->next)
    {
      if (!sf->num_lines || (ignore_zeros && sf->ncalls == 0))
	continue;

      num_executable_lines = num_lines_executed = 0;
      
      ofp = annotate_source (sf, 16, annotate_with_count, sf);
      if (!ofp)
	continue;

      if (bb_table_length > 0)
	{
	  fprintf (ofp, _("\n\nTop %d Lines:\n\n     Line      Count\n\n"),
		   bb_table_length);

	  /* Abuse line arrays---it's not needed anymore:  */
	  qsort (sf->line, sf->num_lines, sizeof (sf->line[0]), cmp_ncalls);
	  table_len = bb_table_length;
	  
	  if (table_len > sf->num_lines)
	    table_len = sf->num_lines;
	  
	  for (i = 0; i < table_len; ++i)
	    {
	      sym = sf->line[i];
	      
	      if (!sym || sym->ncalls == 0)
		  break;

	      fprintf (ofp, "%9d %10lu\n", sym->line_num, sym->ncalls);
	    }
	}

      free (sf->line);
      sf->line = 0;

      fprintf (ofp, _("\nExecution Summary:\n\n"));
      fprintf (ofp, _("%9ld   Executable lines in this file\n"),
	       num_executable_lines);
      fprintf (ofp, _("%9ld   Lines executed\n"), num_lines_executed);
      fprintf (ofp, _("%9.2f   Percent of the file executed\n"),
	       num_executable_lines
	       ? 100.0 * num_lines_executed / (double) num_executable_lines
	       : 100.0);
      fprintf (ofp, _("\n%9lu   Total number of line executions\n"),
	       sf->ncalls);
      fprintf (ofp, _("%9.2f   Average executions per line\n"),
	       num_executable_lines
	       ? (double) sf->ncalls / (double) num_executable_lines
	       : 0.0);
      
      if (ofp != stdout)
	fclose (ofp);
    }
}
Commit	Line	Data
ef368dac NC	1	/* basic_blocks.c - Basic-block level related code: reading/writing
	2	of basic-block info to/from gmon.out; computing and formatting of
	3	basic-block related statistics.
	4
	5	Copyright (C) 2000 Free Software Foundation, Inc.
	6
	7	This file is part of GNU Binutils.
	8
	9	This program is free software; you can redistribute it and/or modify
	10	it under the terms of the GNU General Public License as published by
	11	the Free Software Foundation; either version 2 of the License, or
	12	(at your option) any later version.
	13
	14	This program is distributed in the hope that it will be useful,
	15	but WITHOUT ANY WARRANTY; without even the implied warranty of
	16	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	17	GNU General Public License for more details.
	18
	19	You should have received a copy of the GNU General Public License
	20	along with this program; if not, write to the Free Software
	21	Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
	22	02111-1307, USA. */
	23	\f
252b5132	24	#include <stdio.h>
252b5132 RH	25	#include "basic_blocks.h"
	26	#include "corefile.h"
	27	#include "gmon_io.h"
	28	#include "gmon_out.h"
	29	#include "gprof.h"
	30	#include "libiberty.h"
	31	#include "source.h"
	32	#include "sym_ids.h"
b71c67ab MS	33	#ifdef HAVE_UNISTD_H
	34	#include <unistd.h>
	35	#endif
252b5132	36
ef368dac	37	/* Default option values: */
252b5132 RH	38	bool bb_annotate_all_lines = FALSE;
	39	unsigned long bb_min_calls = 1;
	40	int bb_table_length = 10;
	41
ef368dac	42	/* Variables used to compute annotated source listing stats: */
252b5132 RH	43	static long num_executable_lines;
	44	static long num_lines_executed;
	45
	46
ef368dac NC	47	/* Helper for sorting. Compares two symbols and returns result
	48	such that sorting will be increasing according to filename, line
	49	number, and address (in that order). */
252b5132 RH	50
	51	static int
	52	DEFUN (cmp_bb, (lp, rp), const void lp AND const void rp)
	53	{
	54	int r;
	55	const Sym left = (const Sym **) lp;
	56	const Sym right = (const Sym **) rp;
	57
	58	if (left->file && right->file)
	59	{
	60	r = strcmp (left->file->name, right->file->name);
ef368dac	61
252b5132	62	if (r)
ef368dac	63	return r;
252b5132 RH	64
252b5132 RH	65	if (left->line_num != right->line_num)
ef368dac	66	return left->line_num - right->line_num;
252b5132 RH	67	}
	68
	69	if (left->addr < right->addr)
ef368dac	70	return -1;
252b5132	71	else if (left->addr > right->addr)
ef368dac	72	return 1;
252b5132	73	else
ef368dac	74	return 0;
252b5132 RH	75	}
	76
	77
ef368dac NC	78	/* Helper for sorting. Order basic blocks in decreasing number of
ef368dac NC	79	calls, ties are broken in increasing order of line numbers. */
252b5132 RH	80	static int
	81	DEFUN (cmp_ncalls, (lp, rp), const void lp AND const void rp)
	82	{
	83	const Sym left = (const Sym **) lp;
	84	const Sym right = (const Sym **) rp;
	85
	86	if (!left)
ef368dac	87	return 1;
252b5132	88	else if (!right)
ef368dac	89	return -1;
252b5132 RH	90
	91	if (left->ncalls < right->ncalls)
	92	return 1;
	93	else if (left->ncalls > right->ncalls)
	94	return -1;
	95
	96	return left->line_num - right->line_num;
	97	}
	98
ef368dac	99	/* Skip over variable length string. */
252b5132 RH	100	static void
	101	DEFUN (fskip_string, (fp), FILE * fp)
	102	{
	103	int ch;
	104
	105	while ((ch = fgetc (fp)) != EOF)
	106	{
	107	if (ch == '\0')
ef368dac	108	break;
252b5132 RH	109	}
	110	}
	111
ef368dac NC	112	/* Read a basic-block record from file IFP. FILENAME is the name
ef368dac NC	113	of file IFP and is provided for formatting error-messages only. */
252b5132	114
252b5132 RH	115	void
	116	DEFUN (bb_read_rec, (ifp, filename), FILE * ifp AND const char *filename)
	117	{
	118	int nblocks, b;
	119	bfd_vma addr;
	120	unsigned long ncalls;
	121	Sym *sym;
	122
	123	if (fread (&nblocks, sizeof (nblocks), 1, ifp) != 1)
	124	{
	125	fprintf (stderr, _("%s: %s: unexpected end of file\n"), whoami, filename);
	126	done (1);
	127	}
	128
	129	nblocks = bfd_get_32 (core_bfd, (bfd_byte *) & nblocks);
ef368dac	130
252b5132	131	if (gmon_file_version == 0)
ef368dac	132	fskip_string (ifp);
252b5132 RH	133
	134	for (b = 0; b < nblocks; ++b)
	135	{
	136	if (gmon_file_version == 0)
	137	{
	138	int line_num;
ef368dac NC	139
	140	/* Version 0 had lots of extra stuff that we don't
	141	care about anymore. */
252b5132 RH	142	if ((fread (&ncalls, sizeof (ncalls), 1, ifp) != 1)
	143	\|\| (fread (&addr, sizeof (addr), 1, ifp) != 1)
	144	\|\| (fskip_string (ifp), FALSE)
	145	\|\| (fskip_string (ifp), FALSE)
	146	\|\| (fread (&line_num, sizeof (line_num), 1, ifp) != 1))
	147	{
	148	perror (filename);
	149	done (1);
	150	}
	151	}
	152	else
	153	{
	154	if (fread (&addr, sizeof (addr), 1, ifp) != 1
	155	\|\| fread (&ncalls, sizeof (ncalls), 1, ifp) != 1)
	156	{
	157	perror (filename);
	158	done (1);
	159	}
	160	}
	161
ef368dac NC	162	/* Basic-block execution counts are meaningful only if we're
ef368dac NC	163	profiling at the line-by-line level: */
252b5132 RH	164	if (line_granularity)
252b5132 RH	165	{
ef368dac	166	/* Convert from target to host endianness: */
252b5132 RH	167	addr = get_vma (core_bfd, (bfd_byte *) & addr);
	168	ncalls = bfd_get_32 (core_bfd, (bfd_byte *) &ncalls);
	169
	170	sym = sym_lookup (&symtab, addr);
	171
	172	if (sym)
	173	{
	174	int i;
	175
	176	DBG (BBDEBUG,
	177	printf ("[bb_read_rec] 0x%lx->0x%lx (%s:%d) cnt=%lu\n",
fdcf7d43 ILT	178	(unsigned long) addr, (unsigned long) sym->addr,
fdcf7d43 ILT	179	sym->name, sym->line_num, ncalls));
252b5132 RH	180
	181	for (i = 0; i < NBBS; i++)
	182	{
	183	if (! sym->bb_addr[i] \|\| sym->bb_addr[i] == addr)
	184	{
	185	sym->bb_addr[i] = addr;
	186	sym->bb_calls[i] += ncalls;
	187	break;
	188	}
	189	}
	190	}
	191	}
	192	else
	193	{
	194	static bool user_warned = FALSE;
	195
	196	if (!user_warned)
	197	{
	198	user_warned = TRUE;
	199	fprintf (stderr,
ef368dac	200	_("%s: warning: ignoring basic-block exec counts (use -l or --line)\n"),
252b5132 RH	201	whoami);
	202	}
	203	}
	204	}
	205	return;
	206	}
	207
ef368dac NC	208	/* Write all basic-blocks with non-zero counts to file OFP. FILENAME
	209	is the name of OFP and is provided for producing error-messages
	210	only. */
252b5132 RH	211	void
	212	DEFUN (bb_write_blocks, (ofp, filename), FILE * ofp AND const char *filename)
	213	{
	214	const unsigned char tag = GMON_TAG_BB_COUNT;
	215	int nblocks = 0;
	216	bfd_vma addr;
	217	unsigned long ncalls;
	218	Sym *sym;
	219	int i;
	220
ef368dac	221	/* Count how many non-zero blocks with have: */
252b5132 RH	222	for (sym = symtab.base; sym < symtab.limit; ++sym)
	223	{
	224	for (i = 0; i < NBBS && sym->bb_addr[i]; i++)
	225	;
	226	nblocks += i;
	227	}
	228
ef368dac	229	/* Write header: */
252b5132 RH	230	bfd_put_32 (core_bfd, nblocks, (bfd_byte *) & nblocks);
	231	if (fwrite (&tag, sizeof (tag), 1, ofp) != 1
	232	\|\| fwrite (&nblocks, sizeof (nblocks), 1, ofp) != 1)
	233	{
	234	perror (filename);
	235	done (1);
	236	}
	237
ef368dac	238	/* Write counts: */
252b5132 RH	239	for (sym = symtab.base; sym < symtab.limit; ++sym)
	240	{
	241	for (i = 0; i < NBBS && sym->bb_addr[i]; i++)
	242	{
	243	put_vma (core_bfd, sym->bb_addr[i], (bfd_byte *) & addr);
	244	bfd_put_32 (core_bfd, sym->bb_calls[i], (bfd_byte *) & ncalls);
	245
	246	if (fwrite (&addr, sizeof (addr), 1, ofp) != 1
	247	\|\| fwrite (&ncalls, sizeof (ncalls), 1, ofp) != 1)
	248	{
	249	perror (filename);
	250	done (1);
	251	}
	252	}
	253	}
	254	}
	255
ef368dac NC	256	/* Output basic-block statistics in a format that is easily parseable.
	257	Current the format is:
	258
	259	<filename>:<line-number>: (<function-name>:<bb-addr): <ncalls> */
252b5132	260
252b5132 RH	261	void
	262	DEFUN_VOID (print_exec_counts)
	263	{
	264	Sym *sorted_bbs, sym;
	265	int i, j, len;
	266
	267	if (first_output)
ef368dac	268	first_output = FALSE;
252b5132	269	else
ef368dac	270	printf ("\f\n");
252b5132	271
ef368dac	272	/* Sort basic-blocks according to function name and line number: */
252b5132 RH	273	sorted_bbs = (Sym *) xmalloc (symtab.len sizeof (sorted_bbs[0]));
252b5132 RH	274	len = 0;
ef368dac	275
252b5132 RH	276	for (sym = symtab.base; sym < symtab.limit; ++sym)
252b5132 RH	277	{
ef368dac NC	278	/* Accept symbol if it's in the INCL_EXEC table
	279	or there is no INCL_EXEC table
	280	and it does not appear in the EXCL_EXEC table. */
252b5132 RH	281	if (sym_lookup (&syms[INCL_EXEC], sym->addr)
	282	\|\| (syms[INCL_EXEC].len == 0
	283	&& !sym_lookup (&syms[EXCL_EXEC], sym->addr)))
	284	{
	285	sorted_bbs[len++] = sym;
	286	}
	287	}
ef368dac	288
252b5132 RH	289	qsort (sorted_bbs, len, sizeof (sorted_bbs[0]), cmp_bb);
252b5132 RH	290
ef368dac	291	/* Output basic-blocks: */
252b5132 RH	292
	293	for (i = 0; i < len; ++i)
	294	{
	295	if (sym->ncalls > 0 \|\| ! ignore_zeros)
	296	{
fdcf7d43	297	/* FIXME: This only works if bfd_vma is unsigned long. */
252b5132 RH	298	printf (_("%s:%d: (%s:0x%lx) %lu executions\n"),
252b5132 RH	299	sym->file ? sym->file->name : _("<unknown>"), sym->line_num,
fdcf7d43	300	sym->name, (unsigned long) sym->addr, sym->ncalls);
252b5132	301	}
ef368dac	302
252b5132 RH	303	for (j = 0; j < NBBS && sym->bb_addr[j]; j ++)
	304	{
	305	if (sym->bb_calls[j] > 0 \|\| ! ignore_zeros)
	306	{
fdcf7d43	307	/* FIXME: This only works if bfd_vma is unsigned long. */
252b5132 RH	308	printf (_("%s:%d: (%s:0x%lx) %lu executions\n"),
252b5132 RH	309	sym->file ? sym->file->name : _("<unknown>"), sym->line_num,
fdcf7d43 ILT	310	sym->name, (unsigned long) sym->bb_addr[j],
fdcf7d43 ILT	311	sym->bb_calls[j]);
252b5132 RH	312	}
	313	}
	314	}
	315	free (sorted_bbs);
	316	}
	317
ef368dac NC	318	/* Helper for bb_annotated_source: format annotation containing
	319	number of line executions. Depends on being called on each
	320	line of a file in sequential order.
	321
	322	Global variable bb_annotate_all_lines enables execution count
	323	compression (counts are supressed if identical to the last one)
	324	and prints counts on all executed lines. Otherwise, print
	325	all basic-block execution counts exactly once on the line
	326	that starts the basic-block. */
252b5132 RH	327
	328	static void
	329	DEFUN (annotate_with_count, (buf, width, line_num, arg),
	330	char buf AND int width AND int line_num AND void arg)
	331	{
	332	Source_File *sf = arg;
	333	Sym *b;
	334	int i;
	335	static unsigned long last_count;
	336	unsigned long last_print = (unsigned long) -1;
	337
	338	b = NULL;
ef368dac	339
252b5132	340	if (line_num <= sf->num_lines)
ef368dac NC	341	b = sf->line[line_num - 1];
ef368dac NC	342
252b5132 RH	343	if (!b)
	344	{
	345	for (i = 0; i < width; i++)
	346	buf[i] = ' ';
	347	buf[width] = '\0';
	348	}
	349	else
	350	{
	351	char tmpbuf[NBBS * 30];
	352	char *p;
	353	unsigned long ncalls;
	354	int ncalls_set;
	355	int len;
	356
	357	++num_executable_lines;
	358
	359	p = tmpbuf;
	360	*p = '\0';
	361
	362	ncalls = 0;
	363	ncalls_set = 0;
	364
	365	/* If this is a function entry point, label the line no matter what.
ef368dac NC	366	Otherwise, we're in the middle of a function, so check to see
	367	if the first basic-block address is larger than the starting
	368	address of the line. If so, then this line begins with a
	369	a portion of the previous basic-block, so print that prior
	370	execution count (if bb_annotate_all_lines is set). */
252b5132 RH	371	if (b->is_func)
	372	{
	373	sprintf (p, "%lu", b->ncalls);
	374	p += strlen (p);
	375	last_count = b->ncalls;
	376	last_print = last_count;
	377	ncalls = b->ncalls;
	378	ncalls_set = 1;
	379	}
	380	else if (bb_annotate_all_lines
	381	&& b->bb_addr[0] && b->bb_addr[0] > b->addr)
	382	{
	383	sprintf (p, "%lu", last_count);
	384	p += strlen (p);
	385	last_print = last_count;
	386	ncalls = last_count;
	387	ncalls_set = 1;
	388	}
	389
	390	/* Loop through all of this line's basic-blocks. For each one,
ef368dac NC	391	update last_count, then compress sequential identical counts
ef368dac NC	392	(if bb_annotate_all_lines) and print the execution count. */
252b5132 RH	393
	394	for (i = 0; i < NBBS && b->bb_addr[i]; i++)
	395	{
	396	last_count = b->bb_calls[i];
	397	if (! ncalls_set)
	398	{
	399	ncalls = 0;
	400	ncalls_set = 1;
	401	}
	402	ncalls += last_count;
	403
	404	if (bb_annotate_all_lines && last_count == last_print)
ef368dac	405	continue;
252b5132 RH	406
	407	if (p > tmpbuf)
	408	*p++ = ',';
	409	sprintf (p, "%lu", last_count);
	410	p += strlen (p);
	411
	412	last_print = last_count;
	413	}
	414
	415	/* We're done. If nothing has been printed on this line,
ef368dac NC	416	print the last execution count (bb_annotate_all_lines),
	417	which could be from either a previous line (if there were
	418	no BBs on this line), or from this line (if all our BB
	419	counts were compressed out because they were identical). */
252b5132 RH	420
	421	if (bb_annotate_all_lines && p == tmpbuf)
	422	{
	423	sprintf (p, "%lu", last_count);
	424	p += strlen (p);
	425	ncalls = last_count;
	426	ncalls_set = 1;
	427	}
	428
	429	if (! ncalls_set)
	430	{
	431	int c;
	432
	433	for (c = 0; c < width; c++)
	434	buf[c] = ' ';
	435	buf[width] = '\0';
	436	return;
	437	}
	438
	439	++num_lines_executed;
	440
	441	if (ncalls < bb_min_calls)
	442	{
	443	strcpy (tmpbuf, "#####");
	444	p = tmpbuf + 5;
	445	}
	446
	447	strcpy (p, " -> ");
	448	p += 4;
	449
	450	len = p - tmpbuf;
	451	if (len >= width)
	452	{
	453	strncpy (buf, tmpbuf, width);
	454	buf[width] = '\0';
	455	}
	456	else
	457	{
	458	int c;
	459
	460	strcpy (buf + width - len, tmpbuf);
	461	for (c = 0; c < width - len; ++c)
	462	buf[c] = ' ';
	463	}
	464	}
	465	}
	466
ef368dac NC	467	/* Annotate the files named in SOURCE_FILES with basic-block statistics
	468	(execution counts). After each source files, a few statistics
	469	regarding that source file are printed. */
	470
252b5132 RH	471	void
	472	DEFUN_VOID (print_annotated_source)
	473	{
	474	Sym sym, line_stats, *new_line;
	475	Source_File *sf;
	476	int i, table_len;
	477	FILE *ofp;
	478
ef368dac NC	479	/* Find maximum line number for each source file that user is
ef368dac NC	480	interested in: */
252b5132 RH	481	for (sym = symtab.base; sym < symtab.limit; ++sym)
252b5132 RH	482	{
ef368dac NC	483	/* Accept symbol if it's file is known, its line number is
	484	bigger than anything we have seen for that file so far and
	485	if it's in the INCL_ANNO table or there is no INCL_ANNO
	486	table and it does not appear in the EXCL_ANNO table. */
252b5132 RH	487	if (sym->file && sym->line_num > sym->file->num_lines
	488	&& (sym_lookup (&syms[INCL_ANNO], sym->addr)
	489	\|\| (syms[INCL_ANNO].len == 0
	490	&& !sym_lookup (&syms[EXCL_ANNO], sym->addr))))
	491	{
	492	sym->file->num_lines = sym->line_num;
	493	}
	494	}
	495
ef368dac	496	/* Allocate line descriptors: */
252b5132 RH	497	for (sf = first_src_file; sf; sf = sf->next)
	498	{
	499	if (sf->num_lines > 0)
	500	{
	501	sf->line = (void ) xmalloc (sf->num_lines sizeof (sf->line[0]));
	502	memset (sf->line, 0, sf->num_lines * sizeof (sf->line[0]));
	503	}
	504	}
	505
ef368dac	506	/* Count executions per line: */
252b5132 RH	507	for (sym = symtab.base; sym < symtab.limit; ++sym)
	508	{
	509	if (sym->file && sym->file->num_lines
	510	&& (sym_lookup (&syms[INCL_ANNO], sym->addr)
	511	\|\| (syms[INCL_ANNO].len == 0
	512	&& !sym_lookup (&syms[EXCL_ANNO], sym->addr))))
	513	{
	514	sym->file->ncalls += sym->ncalls;
	515	line_stats = sym->file->line[sym->line_num - 1];
ef368dac	516
252b5132 RH	517	if (!line_stats)
252b5132 RH	518	{
ef368dac	519	/* Common case has at most one basic-block per source line: */
252b5132 RH	520	sym->file->line[sym->line_num - 1] = sym;
	521	}
	522	else if (!line_stats->addr)
	523	{
ef368dac	524	/* sym is the 3rd .. nth basic block for this line: */
252b5132 RH	525	line_stats->ncalls += sym->ncalls;
	526	}
	527	else
	528	{
ef368dac	529	/* sym is the second basic block for this line. */
252b5132 RH	530	new_line = (Sym ) xmalloc (sizeof (new_line));
	531	new_line = line_stats;
	532	new_line->addr = 0;
	533	new_line->ncalls += sym->ncalls;
	534	sym->file->line[sym->line_num - 1] = new_line;
	535	}
	536	}
	537	}
	538
ef368dac	539	/* Plod over source files, annotating them: */
252b5132 RH	540	for (sf = first_src_file; sf; sf = sf->next)
	541	{
	542	if (!sf->num_lines \|\| (ignore_zeros && sf->ncalls == 0))
ef368dac	543	continue;
252b5132 RH	544
252b5132 RH	545	num_executable_lines = num_lines_executed = 0;
ef368dac	546
252b5132 RH	547	ofp = annotate_source (sf, 16, annotate_with_count, sf);
252b5132 RH	548	if (!ofp)
ef368dac	549	continue;
252b5132 RH	550
	551	if (bb_table_length > 0)
	552	{
	553	fprintf (ofp, _("\n\nTop %d Lines:\n\n Line Count\n\n"),
	554	bb_table_length);
	555
ef368dac	556	/* Abuse line arrays---it's not needed anymore: */
252b5132 RH	557	qsort (sf->line, sf->num_lines, sizeof (sf->line[0]), cmp_ncalls);
252b5132 RH	558	table_len = bb_table_length;
ef368dac	559
252b5132	560	if (table_len > sf->num_lines)
ef368dac NC	561	table_len = sf->num_lines;
ef368dac NC	562
252b5132 RH	563	for (i = 0; i < table_len; ++i)
	564	{
	565	sym = sf->line[i];
ef368dac	566
252b5132	567	if (!sym \|\| sym->ncalls == 0)
252b5132	568	break;
ef368dac	569
252b5132 RH	570	fprintf (ofp, "%9d %10lu\n", sym->line_num, sym->ncalls);
	571	}
	572	}
	573
	574	free (sf->line);
	575	sf->line = 0;
	576
	577	fprintf (ofp, _("\nExecution Summary:\n\n"));
	578	fprintf (ofp, _("%9ld Executable lines in this file\n"),
	579	num_executable_lines);
	580	fprintf (ofp, _("%9ld Lines executed\n"), num_lines_executed);
	581	fprintf (ofp, _("%9.2f Percent of the file executed\n"),
	582	num_executable_lines
	583	? 100.0 * num_lines_executed / (double) num_executable_lines
	584	: 100.0);
	585	fprintf (ofp, _("\n%9lu Total number of line executions\n"),
	586	sf->ncalls);
	587	fprintf (ofp, _("%9.2f Average executions per line\n"),
	588	num_executable_lines
	589	? (double) sf->ncalls / (double) num_executable_lines
	590	: 0.0);
ef368dac	591
252b5132	592	if (ofp != stdout)
ef368dac	593	fclose (ofp);
252b5132 RH	594	}
252b5132 RH	595	}