gprof/gprof.c

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