[thirdparty/binutils-gdb.git] / gprof / gprof.c

/* Copyright (c) 1983, 1998, 2001, 2002 Regents of the University of California.
   All rights reserved.

   Redistribution and use in source and binary forms, with or without
   modification, are permitted provided that the following conditions are met:

    * Redistributions of source code must retain the above copyright notice,
      this list of conditions and the following disclaimer.
    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in the
      documentation and/or other materials provided with the distribution.
    * Neither the name of the University of California, Berkeley nor the
      names of its contributors may be used to endorse or promote products
      derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  THE POSSIBILITY OF SUCH DAMAGE.  */

#include "libiberty.h"
#include "gprof.h"
#include "search_list.h"
#include "source.h"
#include "symtab.h"
#include "basic_blocks.h"
#include "call_graph.h"
#include "cg_arcs.h"
#include "cg_print.h"
#include "corefile.h"
#include "gmon_io.h"
#include "hertz.h"
#include "hist.h"
#include "sym_ids.h"
#include "demangle.h"
#include "getopt.h"

static void usage PARAMS ((FILE *, int)) ATTRIBUTE_NORETURN;
int main PARAMS ((int, char **));

const char *whoami;
const char *function_mapping_file;
const char *a_out_name = A_OUTNAME;
long hz = HZ_WRONG;

/*
 * Default options values:
 */
int debug_level = 0;
int output_style = 0;
int output_width = 80;
boolean bsd_style_output = false;
boolean demangle = true;
boolean discard_underscores = true;
boolean ignore_direct_calls = false;
boolean ignore_static_funcs = false;
boolean ignore_zeros = true;
boolean line_granularity = false;
boolean print_descriptions = true;
boolean print_path = false;
boolean ignore_non_functions = false;
File_Format file_format = FF_AUTO;

boolean first_output = true;

char copyright[] =
 "@(#) Copyright (c) 1983 Regents of the University of California.\n\
 All rights reserved.\n";

static char *gmon_name = GMONNAME;	/* profile filename */

bfd *abfd;

/*
 * Functions that get excluded by default:
 */
static char *default_excluded_list[] =
{
  "_gprof_mcount", "mcount", "_mcount", "__mcount", "__mcount_internal",
  "__mcleanup",
  "<locore>", "<hicore>",
  0
};

/* Codes used for the long options with no short synonyms.  150 isn't
   special; it's just an arbitrary non-ASCII char value.  */

#define OPTION_DEMANGLE		(150)
#define OPTION_NO_DEMANGLE	(OPTION_DEMANGLE + 1)

static struct option long_options[] =
{
  {"line", no_argument, 0, 'l'},
  {"no-static", no_argument, 0, 'a'},
  {"ignore-non-functions", no_argument, 0, 'D'},

    /* output styles: */

  {"annotated-source", optional_argument, 0, 'A'},
  {"no-annotated-source", optional_argument, 0, 'J'},
  {"flat-profile", optional_argument, 0, 'p'},
  {"no-flat-profile", optional_argument, 0, 'P'},
  {"graph", optional_argument, 0, 'q'},
  {"no-graph", optional_argument, 0, 'Q'},
  {"exec-counts", optional_argument, 0, 'C'},
  {"no-exec-counts", optional_argument, 0, 'Z'},
  {"function-ordering", no_argument, 0, 'r'},
  {"file-ordering", required_argument, 0, 'R'},
  {"file-info", no_argument, 0, 'i'},
  {"sum", no_argument, 0, 's'},

    /* various options to affect output: */

  {"all-lines", no_argument, 0, 'x'},
  {"demangle", optional_argument, 0, OPTION_DEMANGLE},
  {"no-demangle", no_argument, 0, OPTION_NO_DEMANGLE},
  {"directory-path", required_argument, 0, 'I'},
  {"display-unused-functions", no_argument, 0, 'z'},
  {"min-count", required_argument, 0, 'm'},
  {"print-path", no_argument, 0, 'L'},
  {"separate-files", no_argument, 0, 'y'},
  {"static-call-graph", no_argument, 0, 'c'},
  {"table-length", required_argument, 0, 't'},
  {"time", required_argument, 0, 'n'},
  {"no-time", required_argument, 0, 'N'},
  {"width", required_argument, 0, 'w'},
    /*
     * These are for backwards-compatibility only.  Their functionality
     * is provided by the output style options already:
     */
  {"", required_argument, 0, 'e'},
  {"", required_argument, 0, 'E'},
  {"", required_argument, 0, 'f'},
  {"", required_argument, 0, 'F'},
  {"", required_argument, 0, 'k'},

    /* miscellaneous: */

  {"brief", no_argument, 0, 'b'},
  {"debug", optional_argument, 0, 'd'},
  {"help", no_argument, 0, 'h'},
  {"file-format", required_argument, 0, 'O'},
  {"traditional", no_argument, 0, 'T'},
  {"version", no_argument, 0, 'v'},
  {0, no_argument, 0, 0}
};


static void
usage (stream, status)
     FILE *stream;
     int status;
{
  fprintf (stream, _("\
Usage: %s [-[abcDhilLsTvwxyz]] [-[ACeEfFJnNOpPqQZ][name]] [-I dirs]\n\
	[-d[num]] [-k from/to] [-m min-count] [-t table-length]\n\
	[--[no-]annotated-source[=name]] [--[no-]exec-counts[=name]]\n\
	[--[no-]flat-profile[=name]] [--[no-]graph[=name]]\n\
	[--[no-]time=name] [--all-lines] [--brief] [--debug[=level]]\n\
	[--function-ordering] [--file-ordering]\n\
	[--directory-path=dirs] [--display-unused-functions]\n\
	[--file-format=name] [--file-info] [--help] [--line] [--min-count=n]\n\
	[--no-static] [--print-path] [--separate-files]\n\
	[--static-call-graph] [--sum] [--table-length=len] [--traditional]\n\
	[--version] [--width=n] [--ignore-non-functions]\n\
	[--demangle[=STYLE]] [--no-demangle]\n\
	[image-file] [profile-file...]\n"),
	   whoami);
  if (status == 0)
    fprintf (stream, _("Report bugs to %s\n"), REPORT_BUGS_TO);
  done (status);
}


int
main (argc, argv)
     int argc;
     char **argv;
{
  char **sp, *str;
  Sym **cg = 0;
  int ch, user_specified = 0;

#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
  setlocale (LC_MESSAGES, "");
#endif
#if defined (HAVE_SETLOCALE)
  setlocale (LC_CTYPE, "");
#endif
  bindtextdomain (PACKAGE, LOCALEDIR);
  textdomain (PACKAGE);

  whoami = argv[0];
  xmalloc_set_program_name (whoami);

  while ((ch = getopt_long (argc, argv,
	"aA::bBcCd::De:E:f:F:hiI:J::k:lLm:n::N::O:p::P::q::Q::st:Tvw:xyzZ::",
			    long_options, 0))
	 != EOF)
    {
      switch (ch)
	{
	case 'a':
	  ignore_static_funcs = true;
	  break;
	case 'A':
	  if (optarg)
	    {
	      sym_id_add (optarg, INCL_ANNO);
	    }
	  output_style |= STYLE_ANNOTATED_SOURCE;
	  user_specified |= STYLE_ANNOTATED_SOURCE;
	  break;
	case 'b':
	  print_descriptions = false;
	  break;
	case 'B':
	  output_style |= STYLE_CALL_GRAPH;
	  user_specified |= STYLE_CALL_GRAPH;
	  break;
	case 'c':
	  ignore_direct_calls = true;
	  break;
	case 'C':
	  if (optarg)
	    {
	      sym_id_add (optarg, INCL_EXEC);
	    }
	  output_style |= STYLE_EXEC_COUNTS;
	  user_specified |= STYLE_EXEC_COUNTS;
	  break;
	case 'd':
	  if (optarg)
	    {
	      debug_level |= atoi (optarg);
	      debug_level |= ANYDEBUG;
	    }
	  else
	    {
	      debug_level = ~0;
	    }
	  DBG (ANYDEBUG, printf ("[main] debug-level=0x%x\n", debug_level));
#ifndef DEBUG
	  printf (_("%s: debugging not supported; -d ignored\n"), whoami);
#endif	/* DEBUG */
	  break;
	case 'D':
	  ignore_non_functions = true;
	  break;
	case 'E':
	  sym_id_add (optarg, EXCL_TIME);
	case 'e':
	  sym_id_add (optarg, EXCL_GRAPH);
	  break;
	case 'F':
	  sym_id_add (optarg, INCL_TIME);
	case 'f':
	  sym_id_add (optarg, INCL_GRAPH);
	  break;
	case 'g':
	  sym_id_add (optarg, EXCL_FLAT);
	  break;
	case 'G':
	  sym_id_add (optarg, INCL_FLAT);
	  break;
	case 'h':
	  usage (stdout, 0);
	case 'i':
	  output_style |= STYLE_GMON_INFO;
	  user_specified |= STYLE_GMON_INFO;
	  break;
	case 'I':
	  search_list_append (&src_search_list, optarg);
	  break;
	case 'J':
	  if (optarg)
	    {
	      sym_id_add (optarg, EXCL_ANNO);
	      output_style |= STYLE_ANNOTATED_SOURCE;
	    }
	  else
	    {
	      output_style &= ~STYLE_ANNOTATED_SOURCE;
	    }
	  user_specified |= STYLE_ANNOTATED_SOURCE;
	  break;
	case 'k':
	  sym_id_add (optarg, EXCL_ARCS);
	  break;
	case 'l':
	  line_granularity = true;
	  break;
	case 'L':
	  print_path = true;
	  break;
	case 'm':
	  bb_min_calls = (unsigned long) strtoul (optarg, (char **) NULL, 10);
	  break;
	case 'n':
	  sym_id_add (optarg, INCL_TIME);
	  break;
	case 'N':
	  sym_id_add (optarg, EXCL_TIME);
	  break;
	case 'O':
	  switch (optarg[0])
	    {
	    case 'a':
	      file_format = FF_AUTO;
	      break;
	    case 'm':
	      file_format = FF_MAGIC;
	      break;
	    case 'b':
	      file_format = FF_BSD;
	      break;
	    case '4':
	      file_format = FF_BSD44;
	      break;
	    case 'p':
	      file_format = FF_PROF;
	      break;
	    default:
	      fprintf (stderr, _("%s: unknown file format %s\n"),
		       optarg, whoami);
	      done (1);
	    }
	  break;
	case 'p':
	  if (optarg)
	    {
	      sym_id_add (optarg, INCL_FLAT);
	    }
	  output_style |= STYLE_FLAT_PROFILE;
	  user_specified |= STYLE_FLAT_PROFILE;
	  break;
	case 'P':
	  if (optarg)
	    {
	      sym_id_add (optarg, EXCL_FLAT);
	      output_style |= STYLE_FLAT_PROFILE;
	    }
	  else
	    {
	      output_style &= ~STYLE_FLAT_PROFILE;
	    }
	  user_specified |= STYLE_FLAT_PROFILE;
	  break;
	case 'q':
	  if (optarg)
	    {
	      if (strchr (optarg, '/'))
		{
		  sym_id_add (optarg, INCL_ARCS);
		}
	      else
		{
		  sym_id_add (optarg, INCL_GRAPH);
		}
	    }
	  output_style |= STYLE_CALL_GRAPH;
	  user_specified |= STYLE_CALL_GRAPH;
	  break;
	case 'r':
	  output_style |= STYLE_FUNCTION_ORDER;
	  user_specified |= STYLE_FUNCTION_ORDER;
	  break;
	case 'R':
	  output_style |= STYLE_FILE_ORDER;
	  user_specified |= STYLE_FILE_ORDER;
	  function_mapping_file = optarg;
	  break;
	case 'Q':
	  if (optarg)
	    {
	      if (strchr (optarg, '/'))
		{
		  sym_id_add (optarg, EXCL_ARCS);
		}
	      else
		{
		  sym_id_add (optarg, EXCL_GRAPH);
		}
	      output_style |= STYLE_CALL_GRAPH;
	    }
	  else
	    {
	      output_style &= ~STYLE_CALL_GRAPH;
	    }
	  user_specified |= STYLE_CALL_GRAPH;
	  break;
	case 's':
	  output_style |= STYLE_SUMMARY_FILE;
	  user_specified |= STYLE_SUMMARY_FILE;
	  break;
	case 't':
	  bb_table_length = atoi (optarg);
	  if (bb_table_length < 0)
	    {
	      bb_table_length = 0;
	    }
	  break;
	case 'T':
	  bsd_style_output = true;
	  break;
	case 'v':
	  /* This output is intended to follow the GNU standards document.  */
	  printf (_("GNU gprof %s\n"), VERSION);
	  printf (_("Based on BSD gprof, copyright 1983 Regents of the University of California.\n"));
	  printf (_("\
This program is free software.  This program has absolutely no warranty.\n"));
	  done (0);
	case 'w':
	  output_width = atoi (optarg);
	  if (output_width < 1)
	    {
	      output_width = 1;
	    }
	  break;
	case 'x':
	  bb_annotate_all_lines = true;
	  break;
	case 'y':
	  create_annotation_files = true;
	  break;
	case 'z':
	  ignore_zeros = false;
	  break;
	case 'Z':
	  if (optarg)
	    {
	      sym_id_add (optarg, EXCL_EXEC);
	      output_style |= STYLE_EXEC_COUNTS;
	    }
	  else
	    {
	      output_style &= ~STYLE_EXEC_COUNTS;
	    }
	  user_specified |= STYLE_ANNOTATED_SOURCE;
	  break;
	case OPTION_DEMANGLE:
	  demangle = true;
	  if (optarg != NULL)
	    {
	      enum demangling_styles style;

	      style = cplus_demangle_name_to_style (optarg);
	      if (style == unknown_demangling)
		{
		  fprintf (stderr,
			   _("%s: unknown demangling style `%s'\n"),
			   whoami, optarg);
		  xexit (1);
		}

	      cplus_demangle_set_style (style);
	   }
	  break;
	case OPTION_NO_DEMANGLE:
	  demangle = false;
	  break;
	default:
	  usage (stderr, 1);
	}
    }

  /* Don't allow both ordering options, they modify the arc data in-place.  */
  if ((user_specified & STYLE_FUNCTION_ORDER)
      && (user_specified & STYLE_FILE_ORDER))
    {
      fprintf (stderr,_("\
%s: Only one of --function-ordering and --file-ordering may be specified.\n"),
	       whoami);
      done (1);
    }

  /* --sum implies --line, otherwise we'd lose b-b counts in gmon.sum */
  if (output_style & STYLE_SUMMARY_FILE)
    {
      line_granularity = 1;
    }

  /* append value of GPROF_PATH to source search list if set: */
  str = (char *) getenv ("GPROF_PATH");
  if (str)
    {
      search_list_append (&src_search_list, str);
    }

  if (optind < argc)
    {
      a_out_name = argv[optind++];
    }
  if (optind < argc)
    {
      gmon_name = argv[optind++];
    }

  /*
   * Turn off default functions:
   */
  for (sp = &default_excluded_list[0]; *sp; sp++)
    {
      sym_id_add (*sp, EXCL_TIME);
      sym_id_add (*sp, EXCL_GRAPH);
#ifdef __alpha__
      sym_id_add (*sp, EXCL_FLAT);
#endif
    }

  /*
   * For line-by-line profiling, also want to keep those
   * functions off the flat profile:
   */
  if (line_granularity)
    {
      for (sp = &default_excluded_list[0]; *sp; sp++)
	{
	  sym_id_add (*sp, EXCL_FLAT);
	}
    }

  /*
   * Read symbol table from core file:
   */
  core_init (a_out_name);

  /*
   * If we should ignore direct function calls, we need to load
   * to core's text-space:
   */
  if (ignore_direct_calls)
    {
      core_get_text_space (core_bfd);
    }

  /*
   * Create symbols from core image:
   */
  if (line_granularity)
    {
      core_create_line_syms (core_bfd);
    }
  else
    {
      core_create_function_syms (core_bfd);
    }

  /*
   * Translate sym specs into syms:
   */
  sym_id_parse ();

  if (file_format == FF_PROF)
    {
#ifdef PROF_SUPPORT_IMPLEMENTED
      /*
       * Get information about mon.out file(s):
       */
      do
	{
	  mon_out_read (gmon_name);
	  if (optind < argc)
	    {
	      gmon_name = argv[optind];
	    }
	}
      while (optind++ < argc);
#else
      fprintf (stderr,
	       _("%s: sorry, file format `prof' is not yet supported\n"),
	       whoami);
      done (1);
#endif
    }
  else
    {
      /*
       * Get information about gmon.out file(s):
       */
      do
	{
	  gmon_out_read (gmon_name);
	  if (optind < argc)
	    {
	      gmon_name = argv[optind];
	    }
	}
      while (optind++ < argc);
    }

  /*
   * If user did not specify output style, try to guess something
   * reasonable:
   */
  if (output_style == 0)
    {
      if (gmon_input & (INPUT_HISTOGRAM | INPUT_CALL_GRAPH))
	{
	  output_style = STYLE_FLAT_PROFILE | STYLE_CALL_GRAPH;
	}
      else
	{
	  output_style = STYLE_EXEC_COUNTS;
	}
      output_style &= ~user_specified;
    }

  /*
   * Dump a gmon.sum file if requested (before any other processing!):
   */
  if (output_style & STYLE_SUMMARY_FILE)
    {
      gmon_out_write (GMONSUM);
    }

  if (gmon_input & INPUT_HISTOGRAM)
    {
      hist_assign_samples ();
    }

  if (gmon_input & INPUT_CALL_GRAPH)
    {
      cg = cg_assemble ();
    }

  /* do some simple sanity checks: */

  if ((output_style & STYLE_FLAT_PROFILE)
      && !(gmon_input & INPUT_HISTOGRAM))
    {
      fprintf (stderr, _("%s: gmon.out file is missing histogram\n"), whoami);
      done (1);
    }

  if ((output_style & STYLE_CALL_GRAPH) && !(gmon_input & INPUT_CALL_GRAPH))
    {
      fprintf (stderr,
	       _("%s: gmon.out file is missing call-graph data\n"), whoami);
      done (1);
    }

  /* output whatever user whishes to see: */

  if (cg && (output_style & STYLE_CALL_GRAPH) && bsd_style_output)
    {
      cg_print (cg);		/* print the dynamic profile */
    }

  if (output_style & STYLE_FLAT_PROFILE)
    {
      hist_print ();		/* print the flat profile */
    }

  if (cg && (output_style & STYLE_CALL_GRAPH))
    {
      if (!bsd_style_output)
	{
	  cg_print (cg);	/* print the dynamic profile */
	}
      cg_print_index ();
    }

  if (output_style & STYLE_EXEC_COUNTS)
    {
      print_exec_counts ();
    }

  if (output_style & STYLE_ANNOTATED_SOURCE)
    {
      print_annotated_source ();
    }
  if (output_style & STYLE_FUNCTION_ORDER)
    {
      cg_print_function_ordering ();
    }
  if (output_style & STYLE_FILE_ORDER)
    {
      cg_print_file_ordering ();
    }
  return 0;
}

void
done (status)
     int status;
{
  exit (status);
}
Commit	Line	Data
0461a601 NC	1	/* Copyright (c) 1983, 1998, 2001, 2002 Regents of the University of California.
	2	All rights reserved.
	3
	4	Redistribution and use in source and binary forms, with or without
	5	modification, are permitted provided that the following conditions are met:
	6
	7	* Redistributions of source code must retain the above copyright notice,
	8	this list of conditions and the following disclaimer.
	9	* Redistributions in binary form must reproduce the above copyright
	10	notice, this list of conditions and the following disclaimer in the
	11	documentation and/or other materials provided with the distribution.
	12	* Neither the name of the University of California, Berkeley nor the
	13	names of its contributors may be used to endorse or promote products
	14	derived from this software without specific prior written permission.
	15
	16	THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
	17	AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	18	IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	19	ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
	20	LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
	21	CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
	22	SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
	23	INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
	24	CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	25	ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
	26	THE POSSIBILITY OF SUCH DAMAGE. */
	27
252b5132 RH	28	#include "libiberty.h"
252b5132 RH	29	#include "gprof.h"
6d9c411a AM	30	#include "search_list.h"
	31	#include "source.h"
	32	#include "symtab.h"
252b5132 RH	33	#include "basic_blocks.h"
	34	#include "call_graph.h"
	35	#include "cg_arcs.h"
	36	#include "cg_print.h"
	37	#include "corefile.h"
	38	#include "gmon_io.h"
	39	#include "hertz.h"
	40	#include "hist.h"
252b5132	41	#include "sym_ids.h"
28c309a2	42	#include "demangle.h"
82fe033f	43	#include "getopt.h"
252b5132	44
1355568a AM	45	static void usage PARAMS ((FILE *, int)) ATTRIBUTE_NORETURN;
	46	int main PARAMS ((int, char **));
	47
252b5132 RH	48	const char *whoami;
	49	const char *function_mapping_file;
	50	const char *a_out_name = A_OUTNAME;
	51	long hz = HZ_WRONG;
	52
	53	/*
	54	* Default options values:
	55	*/
	56	int debug_level = 0;
	57	int output_style = 0;
	58	int output_width = 80;
bde52789 AM	59	boolean bsd_style_output = false;
	60	boolean demangle = true;
	61	boolean discard_underscores = true;
	62	boolean ignore_direct_calls = false;
	63	boolean ignore_static_funcs = false;
	64	boolean ignore_zeros = true;
	65	boolean line_granularity = false;
	66	boolean print_descriptions = true;
	67	boolean print_path = false;
	68	boolean ignore_non_functions = false;
252b5132 RH	69	File_Format file_format = FF_AUTO;
252b5132 RH	70
bde52789	71	boolean first_output = true;
252b5132 RH	72
252b5132 RH	73	char copyright[] =
ff096a7c AO	74	"@(#) Copyright (c) 1983 Regents of the University of California.\n\
ff096a7c AO	75	All rights reserved.\n";
252b5132 RH	76
	77	static char gmon_name = GMONNAME; / profile filename */
	78
	79	bfd *abfd;
	80
	81	/*
	82	* Functions that get excluded by default:
	83	*/
	84	static char *default_excluded_list[] =
	85	{
	86	"_gprof_mcount", "mcount", "_mcount", "__mcount", "__mcount_internal",
	87	"__mcleanup",
	88	"<locore>", "<hicore>",
	89	0
	90	};
	91
	92	/* Codes used for the long options with no short synonyms. 150 isn't
	93	special; it's just an arbitrary non-ASCII char value. */
	94
	95	#define OPTION_DEMANGLE (150)
	96	#define OPTION_NO_DEMANGLE (OPTION_DEMANGLE + 1)
	97
	98	static struct option long_options[] =
	99	{
	100	{"line", no_argument, 0, 'l'},
	101	{"no-static", no_argument, 0, 'a'},
	102	{"ignore-non-functions", no_argument, 0, 'D'},
	103
	104	/* output styles: */
	105
	106	{"annotated-source", optional_argument, 0, 'A'},
	107	{"no-annotated-source", optional_argument, 0, 'J'},
	108	{"flat-profile", optional_argument, 0, 'p'},
	109	{"no-flat-profile", optional_argument, 0, 'P'},
	110	{"graph", optional_argument, 0, 'q'},
	111	{"no-graph", optional_argument, 0, 'Q'},
	112	{"exec-counts", optional_argument, 0, 'C'},
	113	{"no-exec-counts", optional_argument, 0, 'Z'},
	114	{"function-ordering", no_argument, 0, 'r'},
	115	{"file-ordering", required_argument, 0, 'R'},
	116	{"file-info", no_argument, 0, 'i'},
	117	{"sum", no_argument, 0, 's'},
	118
	119	/* various options to affect output: */
	120
	121	{"all-lines", no_argument, 0, 'x'},
28c309a2	122	{"demangle", optional_argument, 0, OPTION_DEMANGLE},
252b5132 RH	123	{"no-demangle", no_argument, 0, OPTION_NO_DEMANGLE},
	124	{"directory-path", required_argument, 0, 'I'},
	125	{"display-unused-functions", no_argument, 0, 'z'},
	126	{"min-count", required_argument, 0, 'm'},
	127	{"print-path", no_argument, 0, 'L'},
	128	{"separate-files", no_argument, 0, 'y'},
	129	{"static-call-graph", no_argument, 0, 'c'},
	130	{"table-length", required_argument, 0, 't'},
	131	{"time", required_argument, 0, 'n'},
	132	{"no-time", required_argument, 0, 'N'},
	133	{"width", required_argument, 0, 'w'},
	134	/*
	135	* These are for backwards-compatibility only. Their functionality
	136	* is provided by the output style options already:
	137	*/
	138	{"", required_argument, 0, 'e'},
	139	{"", required_argument, 0, 'E'},
	140	{"", required_argument, 0, 'f'},
	141	{"", required_argument, 0, 'F'},
	142	{"", required_argument, 0, 'k'},
	143
	144	/* miscellaneous: */
	145
	146	{"brief", no_argument, 0, 'b'},
	147	{"debug", optional_argument, 0, 'd'},
	148	{"help", no_argument, 0, 'h'},
	149	{"file-format", required_argument, 0, 'O'},
	150	{"traditional", no_argument, 0, 'T'},
	151	{"version", no_argument, 0, 'v'},
	152	{0, no_argument, 0, 0}
	153	};
	154
	155
	156	static void
1355568a AM	157	usage (stream, status)
	158	FILE *stream;
	159	int status;
252b5132 RH	160	{
	161	fprintf (stream, _("\
	162	Usage: %s [-[abcDhilLsTvwxyz]] [-[ACeEfFJnNOpPqQZ][name]] [-I dirs]\n\
	163	[-d[num]] [-k from/to] [-m min-count] [-t table-length]\n\
	164	[--[no-]annotated-source[=name]] [--[no-]exec-counts[=name]]\n\
	165	[--[no-]flat-profile[=name]] [--[no-]graph[=name]]\n\
	166	[--[no-]time=name] [--all-lines] [--brief] [--debug[=level]]\n\
	167	[--function-ordering] [--file-ordering]\n\
	168	[--directory-path=dirs] [--display-unused-functions]\n\
	169	[--file-format=name] [--file-info] [--help] [--line] [--min-count=n]\n\
	170	[--no-static] [--print-path] [--separate-files]\n\
	171	[--static-call-graph] [--sum] [--table-length=len] [--traditional]\n\
	172	[--version] [--width=n] [--ignore-non-functions]\n\
28c309a2	173	[--demangle[=STYLE]] [--no-demangle]\n\
252b5132 RH	174	[image-file] [profile-file...]\n"),
	175	whoami);
	176	if (status == 0)
8ad3436c	177	fprintf (stream, _("Report bugs to %s\n"), REPORT_BUGS_TO);
252b5132 RH	178	done (status);
	179	}
	180
	181
	182	int
1355568a AM	183	main (argc, argv)
	184	int argc;
	185	char **argv;
252b5132 RH	186	{
	187	char *sp, str;
	188	Sym **cg = 0;
	189	int ch, user_specified = 0;
	190
	191	#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
	192	setlocale (LC_MESSAGES, "");
3882b010 L	193	#endif
	194	#if defined (HAVE_SETLOCALE)
	195	setlocale (LC_CTYPE, "");
252b5132 RH	196	#endif
	197	bindtextdomain (PACKAGE, LOCALEDIR);
	198	textdomain (PACKAGE);
	199
	200	whoami = argv[0];
	201	xmalloc_set_program_name (whoami);
	202
	203	while ((ch = getopt_long (argc, argv,
a799cbe2	204	"aA::bBcCd::De:E:f:F:hiI:J::k:lLm:n::N::O:p::P::q::Q::st:Tvw:xyzZ::",
252b5132 RH	205	long_options, 0))
	206	!= EOF)
	207	{
	208	switch (ch)
	209	{
	210	case 'a':
bde52789	211	ignore_static_funcs = true;
252b5132 RH	212	break;
	213	case 'A':
	214	if (optarg)
	215	{
	216	sym_id_add (optarg, INCL_ANNO);
	217	}
	218	output_style \|= STYLE_ANNOTATED_SOURCE;
	219	user_specified \|= STYLE_ANNOTATED_SOURCE;
	220	break;
	221	case 'b':
bde52789	222	print_descriptions = false;
252b5132 RH	223	break;
	224	case 'B':
	225	output_style \|= STYLE_CALL_GRAPH;
	226	user_specified \|= STYLE_CALL_GRAPH;
	227	break;
	228	case 'c':
bde52789	229	ignore_direct_calls = true;
252b5132 RH	230	break;
	231	case 'C':
	232	if (optarg)
	233	{
	234	sym_id_add (optarg, INCL_EXEC);
	235	}
	236	output_style \|= STYLE_EXEC_COUNTS;
	237	user_specified \|= STYLE_EXEC_COUNTS;
	238	break;
	239	case 'd':
	240	if (optarg)
	241	{
	242	debug_level \|= atoi (optarg);
	243	debug_level \|= ANYDEBUG;
	244	}
	245	else
	246	{
	247	debug_level = ~0;
	248	}
	249	DBG (ANYDEBUG, printf ("[main] debug-level=0x%x\n", debug_level));
	250	#ifndef DEBUG
	251	printf (_("%s: debugging not supported; -d ignored\n"), whoami);
	252	#endif /* DEBUG */
	253	break;
	254	case 'D':
bde52789	255	ignore_non_functions = true;
252b5132 RH	256	break;
	257	case 'E':
	258	sym_id_add (optarg, EXCL_TIME);
	259	case 'e':
	260	sym_id_add (optarg, EXCL_GRAPH);
	261	break;
	262	case 'F':
	263	sym_id_add (optarg, INCL_TIME);
	264	case 'f':
	265	sym_id_add (optarg, INCL_GRAPH);
	266	break;
	267	case 'g':
	268	sym_id_add (optarg, EXCL_FLAT);
	269	break;
	270	case 'G':
	271	sym_id_add (optarg, INCL_FLAT);
	272	break;
	273	case 'h':
	274	usage (stdout, 0);
	275	case 'i':
	276	output_style \|= STYLE_GMON_INFO;
	277	user_specified \|= STYLE_GMON_INFO;
	278	break;
	279	case 'I':
	280	search_list_append (&src_search_list, optarg);
	281	break;
	282	case 'J':
	283	if (optarg)
	284	{
	285	sym_id_add (optarg, EXCL_ANNO);
	286	output_style \|= STYLE_ANNOTATED_SOURCE;
	287	}
	288	else
	289	{
	290	output_style &= ~STYLE_ANNOTATED_SOURCE;
	291	}
	292	user_specified \|= STYLE_ANNOTATED_SOURCE;
	293	break;
	294	case 'k':
	295	sym_id_add (optarg, EXCL_ARCS);
	296	break;
	297	case 'l':
bde52789	298	line_granularity = true;
252b5132 RH	299	break;
252b5132 RH	300	case 'L':
bde52789	301	print_path = true;
252b5132 RH	302	break;
	303	case 'm':
	304	bb_min_calls = (unsigned long) strtoul (optarg, (char **) NULL, 10);
	305	break;
	306	case 'n':
	307	sym_id_add (optarg, INCL_TIME);
	308	break;
	309	case 'N':
	310	sym_id_add (optarg, EXCL_TIME);
	311	break;
	312	case 'O':
	313	switch (optarg[0])
	314	{
	315	case 'a':
	316	file_format = FF_AUTO;
	317	break;
	318	case 'm':
	319	file_format = FF_MAGIC;
	320	break;
	321	case 'b':
	322	file_format = FF_BSD;
	323	break;
	324	case '4':
	325	file_format = FF_BSD44;
	326	break;
	327	case 'p':
	328	file_format = FF_PROF;
	329	break;
	330	default:
	331	fprintf (stderr, _("%s: unknown file format %s\n"),
	332	optarg, whoami);
	333	done (1);
	334	}
	335	break;
	336	case 'p':
	337	if (optarg)
	338	{
	339	sym_id_add (optarg, INCL_FLAT);
	340	}
	341	output_style \|= STYLE_FLAT_PROFILE;
	342	user_specified \|= STYLE_FLAT_PROFILE;
	343	break;
	344	case 'P':
	345	if (optarg)
	346	{
	347	sym_id_add (optarg, EXCL_FLAT);
	348	output_style \|= STYLE_FLAT_PROFILE;
	349	}
	350	else
	351	{
	352	output_style &= ~STYLE_FLAT_PROFILE;
	353	}
	354	user_specified \|= STYLE_FLAT_PROFILE;
	355	break;
	356	case 'q':
	357	if (optarg)
	358	{
	359	if (strchr (optarg, '/'))
	360	{
	361	sym_id_add (optarg, INCL_ARCS);
	362	}
	363	else
	364	{
	365	sym_id_add (optarg, INCL_GRAPH);
366	}
367	}
368	output_style \|= STYLE_CALL_GRAPH;
369	user_specified \|= STYLE_CALL_GRAPH;
370	break;
371	case 'r':
372	output_style \|= STYLE_FUNCTION_ORDER;
373	user_specified \|= STYLE_FUNCTION_ORDER;
374	break;
375	case 'R':
376	output_style \|= STYLE_FILE_ORDER;
377	user_specified \|= STYLE_FILE_ORDER;
378	function_mapping_file = optarg;
379	break;
380	case 'Q':
381	if (optarg)
382	{
383	if (strchr (optarg, '/'))
384	{
385	sym_id_add (optarg, EXCL_ARCS);
386	}
387	else
388	{
389	sym_id_add (optarg, EXCL_GRAPH);
390	}
391	output_style \|= STYLE_CALL_GRAPH;
392	}
393	else
394	{
395	output_style &= ~STYLE_CALL_GRAPH;
396	}
397	user_specified \|= STYLE_CALL_GRAPH;
398	break;
399	case 's':
400	output_style \|= STYLE_SUMMARY_FILE;
401	user_specified \|= STYLE_SUMMARY_FILE;
402	break;
403	case 't':
404	bb_table_length = atoi (optarg);
405	if (bb_table_length < 0)
406	{
407	bb_table_length = 0;
408	}
409	break;
410	case 'T':
bde52789	411	bsd_style_output = true;
252b5132 RH	412	break;
	413	case 'v':
	414	/* This output is intended to follow the GNU standards document. */
	415	printf (_("GNU gprof %s\n"), VERSION);
	416	printf (_("Based on BSD gprof, copyright 1983 Regents of the University of California.\n"));
	417	printf (_("\
	418	This program is free software. This program has absolutely no warranty.\n"));
	419	done (0);
	420	case 'w':
	421	output_width = atoi (optarg);
	422	if (output_width < 1)
	423	{
	424	output_width = 1;
	425	}
	426	break;
	427	case 'x':
bde52789	428	bb_annotate_all_lines = true;
252b5132 RH	429	break;
252b5132 RH	430	case 'y':
bde52789	431	create_annotation_files = true;
252b5132 RH	432	break;
252b5132 RH	433	case 'z':
bde52789	434	ignore_zeros = false;
252b5132 RH	435	break;
	436	case 'Z':
	437	if (optarg)
	438	{
	439	sym_id_add (optarg, EXCL_EXEC);
	440	output_style \|= STYLE_EXEC_COUNTS;
	441	}
	442	else
	443	{
	444	output_style &= ~STYLE_EXEC_COUNTS;
	445	}
	446	user_specified \|= STYLE_ANNOTATED_SOURCE;
	447	break;
	448	case OPTION_DEMANGLE:
bde52789	449	demangle = true;
28c309a2 NC	450	if (optarg != NULL)
	451	{
	452	enum demangling_styles style;
0eee5820	453
28c309a2	454	style = cplus_demangle_name_to_style (optarg);
0eee5820	455	if (style == unknown_demangling)
28c309a2 NC	456	{
	457	fprintf (stderr,
	458	_("%s: unknown demangling style `%s'\n"),
	459	whoami, optarg);
	460	xexit (1);
	461	}
0eee5820	462
28c309a2	463	cplus_demangle_set_style (style);
0eee5820	464	}
252b5132 RH	465	break;
252b5132 RH	466	case OPTION_NO_DEMANGLE:
bde52789	467	demangle = false;
252b5132 RH	468	break;
	469	default:
	470	usage (stderr, 1);
	471	}
	472	}
	473
	474	/* Don't allow both ordering options, they modify the arc data in-place. */
	475	if ((user_specified & STYLE_FUNCTION_ORDER)
	476	&& (user_specified & STYLE_FILE_ORDER))
	477	{
	478	fprintf (stderr,_("\
	479	%s: Only one of --function-ordering and --file-ordering may be specified.\n"),
	480	whoami);
	481	done (1);
	482	}
	483
	484	/* --sum implies --line, otherwise we'd lose b-b counts in gmon.sum */
	485	if (output_style & STYLE_SUMMARY_FILE)
	486	{
	487	line_granularity = 1;
	488	}
	489
	490	/* append value of GPROF_PATH to source search list if set: */
	491	str = (char *) getenv ("GPROF_PATH");
	492	if (str)
	493	{
	494	search_list_append (&src_search_list, str);
	495	}
	496
	497	if (optind < argc)
	498	{
	499	a_out_name = argv[optind++];
	500	}
	501	if (optind < argc)
	502	{
	503	gmon_name = argv[optind++];
	504	}
	505
	506	/*
	507	* Turn off default functions:
	508	*/
	509	for (sp = &default_excluded_list[0]; *sp; sp++)
	510	{
	511	sym_id_add (*sp, EXCL_TIME);
	512	sym_id_add (*sp, EXCL_GRAPH);
	513	#ifdef __alpha__
	514	sym_id_add (*sp, EXCL_FLAT);
	515	#endif
	516	}
	517
	518	/*
	519	* For line-by-line profiling, also want to keep those
	520	* functions off the flat profile:
	521	*/
	522	if (line_granularity)
	523	{
	524	for (sp = &default_excluded_list[0]; *sp; sp++)
	525	{
	526	sym_id_add (*sp, EXCL_FLAT);
	527	}
	528	}
	529
	530	/*
	531	* Read symbol table from core file:
532	*/
533	core_init (a_out_name);
534
535	/*
536	* If we should ignore direct function calls, we need to load
537	* to core's text-space:
538	*/
539	if (ignore_direct_calls)
540	{
541	core_get_text_space (core_bfd);
542	}
543
544	/*
545	* Create symbols from core image:
546	*/
547	if (line_granularity)
548	{
549	core_create_line_syms (core_bfd);
550	}
551	else
552	{
553	core_create_function_syms (core_bfd);
554	}
555
556	/*
557	* Translate sym specs into syms:
558	*/
559	sym_id_parse ();
560
561	if (file_format == FF_PROF)
562	{
563	#ifdef PROF_SUPPORT_IMPLEMENTED
564	/*
565	* Get information about mon.out file(s):
566	*/
567	do
568	{
569	mon_out_read (gmon_name);
570	if (optind < argc)
571	{
572	gmon_name = argv[optind];
573	}
574	}
575	while (optind++ < argc);
576	#else
577	fprintf (stderr,
578	_("%s: sorry, file format `prof' is not yet supported\n"),
579	whoami);
580	done (1);
581	#endif
582	}
583	else
584	{
585	/*
586	* Get information about gmon.out file(s):
587	*/
588	do
589	{
590	gmon_out_read (gmon_name);
591	if (optind < argc)
592	{
593	gmon_name = argv[optind];
594	}
595	}
596	while (optind++ < argc);
597	}
598
599	/*
600	* If user did not specify output style, try to guess something
601	* reasonable:
602	*/
603	if (output_style == 0)
604	{
605	if (gmon_input & (INPUT_HISTOGRAM \| INPUT_CALL_GRAPH))
606	{
607	output_style = STYLE_FLAT_PROFILE \| STYLE_CALL_GRAPH;
608	}
609	else
610	{
611	output_style = STYLE_EXEC_COUNTS;
612	}
613	output_style &= ~user_specified;
614	}
615
616	/*
617	* Dump a gmon.sum file if requested (before any other processing!):
618	*/
619	if (output_style & STYLE_SUMMARY_FILE)
620	{
621	gmon_out_write (GMONSUM);
622	}
623
624	if (gmon_input & INPUT_HISTOGRAM)
625	{
626	hist_assign_samples ();
627	}
628
629	if (gmon_input & INPUT_CALL_GRAPH)
630	{
631	cg = cg_assemble ();
632	}
633
634	/* do some simple sanity checks: */
635
636	if ((output_style & STYLE_FLAT_PROFILE)
637	&& !(gmon_input & INPUT_HISTOGRAM))
638	{
639	fprintf (stderr, _("%s: gmon.out file is missing histogram\n"), whoami);
640	done (1);
641	}
642
643	if ((output_style & STYLE_CALL_GRAPH) && !(gmon_input & INPUT_CALL_GRAPH))
644	{
645	fprintf (stderr,
646	_("%s: gmon.out file is missing call-graph data\n"), whoami);
647	done (1);
648	}
649
650	/* output whatever user whishes to see: */
651
652	if (cg && (output_style & STYLE_CALL_GRAPH) && bsd_style_output)
653	{
654	cg_print (cg); /* print the dynamic profile */
655	}
656
657	if (output_style & STYLE_FLAT_PROFILE)
658	{
659	hist_print (); /* print the flat profile */
660	}
661
662	if (cg && (output_style & STYLE_CALL_GRAPH))
663	{
664	if (!bsd_style_output)
665	{
666	cg_print (cg); /* print the dynamic profile */
667	}
668	cg_print_index ();
669	}
670
671	if (output_style & STYLE_EXEC_COUNTS)
672	{
673	print_exec_counts ();
674	}
675
676	if (output_style & STYLE_ANNOTATED_SOURCE)
677	{
678	print_annotated_source ();
679	}
680	if (output_style & STYLE_FUNCTION_ORDER)
681	{
682	cg_print_function_ordering ();
683	}
684	if (output_style & STYLE_FILE_ORDER)
685	{
686	cg_print_file_ordering ();
687	}
688	return 0;
689	}
690
691	void
692	done (status)
693	int status;
694	{
695	exit (status);
696	}