Patchwork Add an intermediate coverage format for gcov

login
register
mail settings
Submitter Sharad Singhai
Date Nov. 7, 2011, 7:04 a.m.
Message ID <CAKxPW66NSeAzGAzAk1otW+uFohaMwRsLn-n246qtLC+foCjW1Q@mail.gmail.com>
Download mbox | patch
Permalink /patch/124010/
State New
Headers show

Comments

Sharad Singhai - Nov. 7, 2011, 7:04 a.m.
Sorry about the delay. I have updated the patch to output demangled
names under a new option (-m) and added a test case. Okay for trunk?

Sharad

2011-11-06   Sharad Singhai  <singhai@google.com>

	* doc/gcov.texi: Document gcov intermediate format.
	* gcov.c (print_usage): Handle new option.
	(process_args): Handle new option.
	(get_gcov_file_intermediate_name): New function.
	(output_intermediate_file): New function.
	(generate_results): Handle new option.
	* testsuite/lib/gcov.exp: Handle intermediate format.
	* testsuite/g++.dg/gcov/gcov-8.C: New testcase.
	* testsuite/g++.dg/gcov/gcov-9.C: New testcase.

+/* { dg-final { run-gcov intermediate { -i -b gcov-8.C } } } */

On Wed, Oct 19, 2011 at 1:41 PM, Mike Stump <mikestump@comcast.net> wrote:
> On Oct 19, 2011, at 12:12 PM, Sharad Singhai <singhai@google.com> wrote:
>> Sorry, I misunderstood your comment. I see that you are asking for
>> unmangled function names whereas the current patch supports only
>> mangled names. I can print unmangled names under another option. Would
>> that work?
>
> I defer to the person that says ok.  :-)
>
Mike Stump - Nov. 7, 2011, 4:05 p.m.
On Nov 6, 2011, at 11:04 PM, Sharad Singhai wrote:
> Sorry about the delay. I have updated the patch to output demangled
> names under a new option (-m) and added a test case.

I like it, now you just need a gcov type person to like it.  :-)

Patch

Index: doc/gcov.texi
===================================================================
--- doc/gcov.texi	(revision 179873)
+++ doc/gcov.texi	(working copy)
@@ -131,6 +131,8 @@  gcov [@option{-v}|@option{--version}] [@
      [@option{-o}|@option{--object-directory} @var{directory|file}]
@var{sourcefiles}
      [@option{-u}|@option{--unconditional-branches}]
      [@option{-d}|@option{--display-progress}]
+     [@option{-i}|@option{--intermediate-format}]
+     [@option{-m}|@option{--demangled-names}]
 @c man end
 @c man begin SEEALSO
 gpl(7), gfdl(7), fsf-funding(7), gcc(1) and the Info entry for @file{gcc}.
@@ -216,6 +218,49 @@  Unconditional branches are normally not
 @itemx --display-progress
 Display the progress on the standard output.

+@item -i
+@itemx --intermediate-format
+Output gcov file in an easy-to-parse intermediate text format that can
+be used by @command{lcov} or other tools. The output is a single
+@file{.gcov} file per @file{.gcda} file. No source code is required.
+
+The format of the intermediate @file{.gcov} file is plain text with
+one entry per line
+
+@smallexample
+file:@var{source_file_name}
+function:@var{line_number},@var{execution_count},@var{function_name}
+lcount:@var{line number},@var{execution_count}
+branch:@var{line_number},@var{branch_coverage_type}
+
+Where the @var{branch_coverage_type} is
+   notexec (Branch not executed)
+   taken (Branch executed and taken)
+   nottaken (Branch executed, but not taken)
+
+There can be multiple @var{file} entries in an intermediate gcov
+file. All entries following a @var{file} pertain to that source file
+until the next @var{file} entry.
+@end smallexample
+
+Here is a sample when @option{-i} is used in conjuction with
@option{-b} option:
+
+@smallexample
+file:array.cc
+function:11,1,_Z3sumRKSt6vectorIPiSaIS0_EE
+function:22,1,main
+lcount:11,1
+lcount:12,1
+lcount:14,1
+branch:14,taken
+lcount:26,1
+branch:28,nottaken
+@end smallexample
+
+@item -m
+@itemx --demangled-names
+Display demangled function names in output.
+
 @end table

 @command{gcov} should be run with the current directory the same as that
Index: gcov.c
===================================================================
--- gcov.c	(revision 179873)
+++ gcov.c	(working copy)
@@ -39,6 +39,7 @@  along with Gcov; see the file COPYING3.
 #include "intl.h"
 #include "diagnostic.h"
 #include "version.h"
+#include "demangle.h"

 #include <getopt.h>

@@ -168,6 +169,7 @@  typedef struct function_info
 {
   /* Name of function.  */
   char *name;
+  char *demangled_name;
   unsigned ident;
   unsigned lineno_checksum;
   unsigned cfg_checksum;
@@ -311,6 +313,14 @@  static int flag_gcov_file = 1;

 static int flag_display_progress = 0;

+/* Output *.gcov file in intermediate format used by 'lcov'.  */
+
+static int flag_intermediate_format = 0;
+
+/* Output demangled function names.  */
+
+static int flag_demangled_names = 0;
+
 /* For included files, make the gcov output file name include the name
    of the input source file.  For example, if x.h is included in a.c,
    then the output file name is a.c##x.h.gcov instead of x.h.gcov.  */
@@ -433,9 +443,11 @@  print_usage (int error_p)
   fnotice (file, "  -l, --long-file-names           Use long output
file names for included\n\
                                     source files\n");
   fnotice (file, "  -f, --function-summaries        Output summaries
for each function\n");
+  fnotice (file, "  -m, --demangled-names           Output demangled
function names\n");
   fnotice (file, "  -o, --object-directory DIR|FILE Search for object
files in DIR or called FILE\n");
   fnotice (file, "  -p, --preserve-paths            Preserve all
pathname components\n");
   fnotice (file, "  -u, --unconditional-branches    Show
unconditional branch counts too\n");
+  fnotice (file, "  -i, --intermediate-format       Output .gcov file
in intermediate text format\n");
   fnotice (file, "  -d, --display-progress          Display progress
information\n");
   fnotice (file, "\nFor bug reporting instructions, please see:\n%s.\n",
 	   bug_report_url);
@@ -467,11 +479,13 @@  static const struct option options[] =
   { "no-output",            no_argument,       NULL, 'n' },
   { "long-file-names",      no_argument,       NULL, 'l' },
   { "function-summaries",   no_argument,       NULL, 'f' },
+  { "demangled-names",      no_argument,       NULL, 'm' },
   { "preserve-paths",       no_argument,       NULL, 'p' },
   { "object-directory",     required_argument, NULL, 'o' },
   { "object-file",          required_argument, NULL, 'o' },
   { "unconditional-branches", no_argument,     NULL, 'u' },
   { "display-progress",     no_argument,       NULL, 'd' },
+  { "intermediate-format",  no_argument,       NULL, 'i' },
   { 0, 0, 0, 0 }
 };

@@ -482,7 +496,8 @@  process_args (int argc, char **argv)
 {
   int opt;

-  while ((opt = getopt_long (argc, argv, "abcdfhlno:puv", options,
NULL)) != -1)
+  while ((opt = getopt_long (argc, argv, "abcdfhilmno:puv", options, NULL)) !=
+         -1)
     {
       switch (opt)
 	{
@@ -504,6 +519,9 @@  process_args (int argc, char **argv)
 	case 'l':
 	  flag_long_names = 1;
 	  break;
+	case 'm':
+	  flag_demangled_names = 1;
+	  break;
 	case 'n':
 	  flag_gcov_file = 0;
 	  break;
@@ -516,6 +534,10 @@  process_args (int argc, char **argv)
 	case 'u':
 	  flag_unconditional = 1;
 	  break;
+	case 'i':
+          flag_intermediate_format = 1;
+          flag_gcov_file = 1;
+          break;
         case 'd':
           flag_display_progress = 1;
           break;
@@ -531,6 +553,101 @@  process_args (int argc, char **argv)
   return optind;
 }

+/* Get the name of the gcov file.  The return value must be free'd.
+
+   It appends the '.gcov' extension to the *basename* of the file.
+   The resulting file name will be in PWD.
+
+   e.g.,
+   input: foo.da,       output: foo.da.gcov
+   input: a/b/foo.cc,   output: foo.cc.gcov  */
+
+static char *
+get_gcov_file_intermediate_name (const char *file_name)
+{
+  const char *gcov = ".gcov";
+  char *result;
+  const char *cptr;
+
+  /* Find the 'basename'.  */
+  cptr = lbasename (file_name);
+
+  result = XNEWVEC(char, strlen (cptr) + strlen (gcov) + 1);
+  sprintf (result, "%s%s", cptr, gcov);
+
+  return result;
+}
+
+/* Output the result in intermediate format used by 'lcov'.
+
+The intermediate format contains a single file named 'foo.cc.gcov',
+with no source code included.
+
+file:/home/.../foo.h
+lcount:10,1
+lcount:35,1
+file:/home/.../bar.h
+lcount:12,0
+lcount:33,0
+file:/home/.../foo.cc
+function:foo,32,1
+lcount:42,0
+lcount:53,1
+branch:55,taken
+branch:57,notexec
+lcount:95,1
+...
+
+The default format would have 3 separate files: 'foo.h.gcov',
+'foo.cc.gcov', 'bar.h.gcov', each with source code included.  */
+
+static void
+output_intermediate_file (FILE *gcov_file, source_t *src)
+{
+  unsigned line_num;    /* current line number.  */
+  const line_t *line;   /* current line info ptr.  */
+  function_t *fn;       /* current function info ptr. */
+
+  fprintf (gcov_file, "file:%s\n", src->name);    /* source file name */
+
+  for (fn = src->functions; fn; fn = fn->line_next)
+    {
+      /* function:<name>,<line_number>,<execution_count> */
+      fprintf (gcov_file, "function:%d,%s,%s\n", fn->line,
+               format_gcov (fn->blocks[0].count, 0, -1),
+               flag_demangled_names ? fn->demangled_name : fn->name);
+    }
+
+  for (line_num = 1, line = &src->lines[line_num];
+       line_num < src->num_lines;
+       line_num++, line++)
+    {
+      arc_t *arc;
+      if (line->exists)
+        fprintf (gcov_file, "lcount:%u,%d\n", line_num,
+                 line->count != 0 ? 1 : 0);
+      if (flag_branches)
+        for (arc = line->u.branches; arc; arc = arc->line_next)
+          {
+            if (!arc->is_unconditional && !arc->is_call_non_return)
+              {
+                const char *branch_type;
+                /* branch:<line_num>,<branch_coverage_type>
+                   branch_coverage_type
+                     : notexec (Branch not executed)
+                     : taken (Branch executed and taken)
+                     : nottaken (Branch executed, but not taken)
+                */
+                if (arc->src->count)
+                  branch_type = (arc->count > 0) ? "taken" : "nottaken";
+                else
+                  branch_type = "notexec";
+                fprintf(gcov_file, "branch:%d,%s\n", line_num, branch_type);
+              }
+          }
+    }
+}
+
 /* Process a single source file.  */

 static void
@@ -570,6 +687,8 @@  generate_results (const char *file_name)
 {
   source_t *src;
   function_t *fn;
+  FILE *gcov_file_intermediate = NULL;
+  char *gcov_file_intermediate_name = NULL;

   for (src = sources; src; src = src->next)
     src->lines = XCNEWVEC (line_t, src->num_lines);
@@ -578,7 +697,7 @@  generate_results (const char *file_name)
       coverage_t coverage;

       memset (&coverage, 0, sizeof (coverage));
-      coverage.name = fn->name;
+      coverage.name = flag_demangled_names ? fn->demangled_name : fn->name;
       add_line_counts (flag_function_summary ? &coverage : NULL, fn);
       if (flag_function_summary)
 	{
@@ -587,31 +706,55 @@  generate_results (const char *file_name)
 	}
     }

+  if (flag_gcov_file && flag_intermediate_format)
+    {
+      /* Open the intermediate file.  */
+      gcov_file_intermediate_name =
+        get_gcov_file_intermediate_name (file_name);
+      gcov_file_intermediate = fopen (gcov_file_intermediate_name, "w");
+    }
   for (src = sources; src; src = src->next)
     {
       accumulate_line_counts (src);
       function_summary (&src->coverage, "File");
       if (flag_gcov_file)
 	{
-	  char *gcov_file_name = make_gcov_file_name (file_name, src->name);
-	  FILE *gcov_file = fopen (gcov_file_name, "w");
-
-	  if (gcov_file)
-	    {
-	      fnotice (stdout, "%s:creating '%s'\n",
-		       src->name, gcov_file_name);
-	      output_lines (gcov_file, src);
-	      if (ferror (gcov_file))
-		    fnotice (stderr, "%s:error writing output file '%s'\n",
-			     src->name, gcov_file_name);
-	      fclose (gcov_file);
-	    }
-	  else
-	    fnotice (stderr, "%s:could not open output file '%s'\n",
-		     src->name, gcov_file_name);
-	  free (gcov_file_name);
-	}
-      fnotice (stdout, "\n");
+         if (flag_intermediate_format)
+           /* Now output in the intermediate format without requiring
+              source files.  This outputs a section to a *single* file.  */
+           output_intermediate_file (gcov_file_intermediate, src);
+         else
+           {
+             /* Now output the version with source files.
+                This outputs a separate *.gcov file for each source file
+                involved.  */
+             char *gcov_file_name = make_gcov_file_name (file_name, src->name);
+             FILE *gcov_file = fopen (gcov_file_name, "w");
+
+             if (gcov_file)
+               {
+                 fnotice (stdout, "%s:creating '%s'\n",
+                          src->name, gcov_file_name);
+                 output_lines (gcov_file, src);
+                 if (ferror (gcov_file))
+                   fnotice (stderr, "%s:error writing output file '%s'\n",
+                            src->name, gcov_file_name);
+                 fclose (gcov_file);
+               }
+             else
+               fnotice (stderr, "%s:could not open output file '%s'\n",
+                        src->name, gcov_file_name);
+             free (gcov_file_name);
+           }
+         fnotice (stdout, "\n");
+        }
+    }
+
+  if (flag_gcov_file && flag_intermediate_format)
+    {
+      /* Now we've finished writing the intermediate file.  */
+      fclose (gcov_file_intermediate);
+      XDELETEVEC (gcov_file_intermediate_name);
     }
 }

@@ -649,6 +792,9 @@  release_structures (void)
 	}
       free (fn->blocks);
       free (fn->counts);
+      if (flag_demangled_names && fn->demangled_name != fn->name)
+        free (fn->demangled_name);
+      free (fn->name);
     }
 }

@@ -828,6 +974,12 @@  read_graph_file (void)

 	  fn = XCNEW (function_t);
 	  fn->name = function_name;
+          if (flag_demangled_names)
+            {
+              fn->demangled_name = cplus_demangle (fn->name, DMGL_PARAMS);
+              if (!fn->demangled_name)
+                fn->demangled_name = fn->name;
+            }
 	  fn->ident = ident;
 	  fn->lineno_checksum = lineno_checksum;
 	  fn->cfg_checksum = cfg_checksum;
@@ -1937,7 +2089,8 @@  output_lines (FILE *gcov_file, const sou
 	    if (arc->fake)
 	      return_count -= arc->count;

-	  fprintf (gcov_file, "function %s", fn->name);
+	  fprintf (gcov_file, "function %s", flag_demangled_names ?
+                   fn->demangled_name : fn->name);
 	  fprintf (gcov_file, " called %s",
 		   format_gcov (fn->blocks[0].count, 0, -1));
 	  fprintf (gcov_file, " returned %s",
Index: testsuite/lib/gcov.exp
===================================================================
--- testsuite/lib/gcov.exp	(revision 179873)
+++ testsuite/lib/gcov.exp	(working copy)
@@ -59,6 +59,60 @@  proc verify-lines { testcase file } {
     return $failed
 }

+
+#
+# verify-intermediate -- check that intermediate file has certain lines
+#
+# TESTCASE is the name of the test.
+# FILE is the name of the gcov output file.
+#
+# Checks are very loose, they are based on certain tags being present
+# in the output. They do not check for exact expected execution
+# counts. For that the regular gcov format should be checked.
+#
+proc verify-intermediate { testcase file } {
+    set failed 0
+    set srcfile 0
+    set function 0
+    set lcount 0
+    set branch 0
+    set fd [open $file r]
+    while { [gets $fd line] >= 0 } {
+	if [regexp "^file:" $line] {
+	    incr srcfile
+	}
+	if [regexp "^function:(\[0-9\]+),(\[0-9\]+),.*" $line] {
+	    incr function
+	}
+	if [regexp "^lcount:(\[0-9\]+),(\[0-9\]+)" $line] {
+	    incr lcount
+	}
+	if [regexp "^branch:(\[0-9\]+),(taken|nottaken|notexec)" $line] {
+	    incr branch
+	}
+    }
+
+    # We should see at least one tag of each type
+    if {$srcfile == 0} {
+	fail "expected 'file:' tag not found"
+	incr failed
+    }
+    if {$function == 0} {
+	fail "expected 'function:' tag not found"
+	incr failed
+    }
+    if {$lcount == 0} {
+	fail "expected 'lcount:' tag not found"
+	incr failed
+    }
+    if {$branch == 0} {
+	fail "expected 'branch:' tag not found"
+	incr failed
+    }
+    return $failed
+}
+
+
 #
 # verify-branches -- check that branch percentages are as expected
 #
@@ -234,6 +288,8 @@  proc run-gcov { args } {

     set gcov_verify_calls 0
     set gcov_verify_branches 0
+    set gcov_verify_lines 1
+    set gcov_verify_intermediate 0
     set gcov_execute_xfail ""
     set gcov_verify_xfail ""

@@ -242,6 +298,11 @@  proc run-gcov { args } {
 	  set gcov_verify_calls 1
 	} elseif { $a == "branches" } {
 	  set gcov_verify_branches 1
+	} elseif { $a == "intermediate" } {
+	  set gcov_verify_intermediate 1
+	  set gcov_verify_calls 0
+	  set gcov_verify_branches 0
+	  set gcov_verify_lines 0
 	}
     }

@@ -274,8 +335,12 @@  proc run-gcov { args } {
 	eval setup_xfail [split $gcov_verify_xfail]
     }

-    # Check that line execution counts are as expected.
-    set lfailed [verify-lines $testcase $testcase.gcov]
+    if { $gcov_verify_lines } {
+	# Check that line execution counts are as expected.
+	set lfailed [verify-lines $testcase $testcase.gcov]
+    } else {
+	set lfailed 0
+    }

     # If requested via the .x file, check that branch and call information
     # is correct.
@@ -289,12 +354,18 @@  proc run-gcov { args } {
     } else {
 	set cfailed 0
     }
+    if { $gcov_verify_intermediate } {
+	# Check that intermediate format has the expected format
+	set ifailed [verify-intermediate $testcase $testcase.gcov]
+    } else {
+	set ifailed 0
+    }

     # Report whether the gcov test passed or failed.  If there were
     # multiple failures then the message is a summary.
-    set tfailed [expr $lfailed + $bfailed + $cfailed]
+    set tfailed [expr $lfailed + $bfailed + $cfailed + $ifailed ]
     if { $tfailed > 0 } {
-	fail "$subdir/$testcase gcov: $lfailed failures in line counts,
$bfailed in branch percentages, $cfailed in return percentages"
+	fail "$subdir/$testcase gcov: $lfailed failures in line counts,
$bfailed in branch percentages, $cfailed in return percentages,
$ifailed in intermediate format"
     } else {
 	pass "$subdir/$testcase gcov"
 	clean-gcov $testcase
Index: testsuite/g++.dg/gcov/gcov-8.C
===================================================================
--- testsuite/g++.dg/gcov/gcov-8.C	(revision 0)
+++ testsuite/g++.dg/gcov/gcov-8.C	(revision 0)
@@ -0,0 +1,35 @@ 
+/* Verify that intermediate coverage format can be generated for
simple code. */
+
+/* { dg-options "-fprofile-arcs -ftest-coverage" } */
+/* { dg-do run { target native } } */
+
+class C {
+public:
+  C()
+  {
+    i = 0;
+  }
+  ~C() {}
+  void seti (int j)
+  {
+    if (j > 0)
+      i = j;
+    else
+      i = 0;
+  }
+private:
+  int i;
+};
+
+void foo()
+{
+  C c;
+  c.seti (1);
+}
+
+int main()
+{
+  foo();
+}
+