===================================================================
@@ -64,7 +64,11 @@ GCOV_LINKAGE struct gcov_var
} gcov_var;
/* Save the current position in the gcov file. */
-static inline gcov_position_t
+/* We need to expose this function when compiling for gcov-tool. */
+#ifndef IN_GCOV_TOOL
+static inline
+#endif
+gcov_position_t
gcov_position (void)
{
gcc_assert (gcov_var.mode > 0);
@@ -72,7 +76,11 @@ gcov_position (void)
}
/* Return nonzero if the error flag is set. */
-static inline int
+/* We need to expose this function when compiling for gcov-tool. */
+#ifndef IN_GCOV_TOOL
+static inline
+#endif
+int
gcov_is_error (void)
{
return gcov_var.file ? gcov_var.error : 1;
@@ -560,11 +568,13 @@ gcov_read_counter (void)
return value;
}
+/* We need to expose the below function when compiling for gcov-tool. */
+
+#if !IN_LIBGCOV || defined (IN_GCOV_TOOL)
/* Read string from coverage file. Returns a pointer to a static
buffer, or NULL on empty string. You must copy the string before
calling another gcov function. */
-#if !IN_LIBGCOV
GCOV_LINKAGE const char *
gcov_read_string (void)
{
@@ -641,7 +651,9 @@ gcov_read_summary (struct gcov_summary *summary)
}
}
-#if !IN_LIBGCOV
+/* We need to expose the below function when compiling for gcov-tool. */
+
+#if !IN_LIBGCOV || defined (IN_GCOV_TOOL)
/* Reset to a known position. BASE should have been obtained from
gcov_position, LENGTH should be a record length. */
===================================================================
@@ -240,50 +240,31 @@ typedef unsigned HOST_WIDEST_INT gcov_type_unsigne
/* Counters that are collected. */
-#define GCOV_COUNTER_ARCS 0 /* Arc transitions. */
-#define GCOV_COUNTERS_SUMMABLE 1 /* Counters which can be
- summaried. */
-#define GCOV_FIRST_VALUE_COUNTER 1 /* The first of counters used for value
- profiling. They must form a consecutive
- interval and their order must match
- the order of HIST_TYPEs in
- value-prof.h. */
-#define GCOV_COUNTER_V_INTERVAL 1 /* Histogram of value inside an interval. */
-#define GCOV_COUNTER_V_POW2 2 /* Histogram of exact power2 logarithm
- of a value. */
-#define GCOV_COUNTER_V_SINGLE 3 /* The most common value of expression. */
-#define GCOV_COUNTER_V_DELTA 4 /* The most common difference between
- consecutive values of expression. */
-#define GCOV_COUNTER_V_INDIR 5 /* The most common indirect address */
-#define GCOV_COUNTER_AVERAGE 6 /* Compute average value passed to the
- counter. */
-#define GCOV_COUNTER_IOR 7 /* IOR of the all values passed to
- counter. */
-#define GCOV_TIME_PROFILER 8 /* Time profile collecting first run of a function */
-#define GCOV_LAST_VALUE_COUNTER 8 /* The last of counters used for value
- profiling. */
-#define GCOV_COUNTERS 9
+#ifdef DEF_GCOV_COUNTER
+#undef DEF_GCOV_COUNTER
+#endif
+#define DEF_GCOV_COUNTER(COUNTER, NAME, MERGE_FN) COUNTER,
+enum {
+#include "gcov-counter.def"
+GCOV_COUNTERS
+};
+/* Counters which can be summaried. */
+#define GCOV_COUNTERS_SUMMABLE (GCOV_COUNTER_ARCS + 1)
+
+/* The first of counters used for value profiling. They must form a
+ consecutive interval and their order must match the order of
+ HIST_TYPEs in value-prof.h. */
+#define GCOV_FIRST_VALUE_COUNTER GCOV_COUNTERS_SUMMABLE
+
+/* The last of counters used for value profiling. */
+#define GCOV_LAST_VALUE_COUNTER (GCOV_COUNTERS - 1)
+
/* Number of counters used for value profiling. */
#define GCOV_N_VALUE_COUNTERS \
(GCOV_LAST_VALUE_COUNTER - GCOV_FIRST_VALUE_COUNTER + 1)
- /* A list of human readable names of the counters */
-#define GCOV_COUNTER_NAMES {"arcs", "interval", "pow2", "single", \
- "delta", "indirect_call", "average", "ior", "time_profiler"}
-
- /* Names of merge functions for counters. */
-#define GCOV_MERGE_FUNCTIONS {"__gcov_merge_add", \
- "__gcov_merge_add", \
- "__gcov_merge_add", \
- "__gcov_merge_single", \
- "__gcov_merge_delta", \
- "__gcov_merge_single", \
- "__gcov_merge_add", \
- "__gcov_merge_ior", \
- "__gcov_merge_time_profile" }
-
/* Convert a counter index to a tag. */
#define GCOV_TAG_FOR_COUNTER(COUNT) \
(GCOV_TAG_COUNTER_BASE + ((gcov_unsigned_t)(COUNT) << 17))
===================================================================
@@ -149,14 +149,14 @@ print_version (void)
}
static void
-print_prefix (const char *filename, unsigned depth, gcov_position_t position)
+print_prefix (const char *filename ATTRIBUTE_UNUSED, unsigned depth ATTRIBUTE_UNUSED, gcov_position_t position)
{
static const char prefix[] = " ";
- printf ("%s:", filename);
+ printf ("%s:", "xur");
if (flag_dump_positions)
printf ("%lu:", (unsigned long) position);
- printf ("%.*s", (int) depth, prefix);
+ printf ("%.*s", (int) 0, prefix);
}
static void
@@ -193,7 +193,7 @@ dump_gcov_file (const char *filename)
GCOV_UNSIGNED2STRING (v, version);
GCOV_UNSIGNED2STRING (m, magic);
- printf ("%s:%s:magic `%.4s':version `%.4s'%s\n", filename, type,
+ printf ("%s:magic `%.4s':version `%.4s'%s\n", type,
m, v, endianness < 0 ? " (swapped endianness)" : "");
if (version != GCOV_VERSION)
{
@@ -208,7 +208,7 @@ dump_gcov_file (const char *filename)
{
unsigned stamp = gcov_read_unsigned ();
- printf ("%s:stamp %lu\n", filename, (unsigned long)stamp);
+ printf ("stamp %lu\n", (unsigned long)stamp);
}
while (1)
@@ -253,7 +253,7 @@ dump_gcov_file (const char *filename)
}
print_prefix (filename, tag_depth, position);
- printf ("%08x:%4u:%s", tag, length, format->name);
+ printf ("%08x:%4u:%s", tag, /*length*/0, format->name);
if (format->proc)
(*format->proc) (filename, tag, length);
@@ -422,7 +422,11 @@ static void
tag_counters (const char *filename ATTRIBUTE_UNUSED,
unsigned tag ATTRIBUTE_UNUSED, unsigned length ATTRIBUTE_UNUSED)
{
- static const char *const counter_names[] = GCOV_COUNTER_NAMES;
+#undef DEF_GCOV_COUNTER
+#define DEF_GCOV_COUNTER(COUNTER, NAME, MERGE_FN) NAME,
+ static const char *const counter_names[] = {
+#include "gcov-counter.def"
+};
unsigned n_counts = GCOV_TAG_COUNTER_NUM (length);
printf (" %s %u counts",
@@ -454,12 +458,13 @@ tag_summary (const char *filename ATTRIBUTE_UNUSED
unsigned tag ATTRIBUTE_UNUSED, unsigned length ATTRIBUTE_UNUSED)
{
struct gcov_summary summary;
- unsigned ix, h_ix;
- gcov_bucket_type *histo_bucket;
+ /*unsigned ix, h_ix;
+ gcov_bucket_type *histo_bucket; */
gcov_read_summary (&summary);
- printf (" checksum=0x%08x", summary.checksum);
+/* printf (" checksum=0x%08x", summary.checksum); */
+#if 0
for (ix = 0; ix != GCOV_COUNTERS_SUMMABLE; ix++)
{
printf ("\n");
@@ -495,9 +500,12 @@ tag_summary (const char *filename ATTRIBUTE_UNUSED
if (flag_dump_working_sets)
dump_working_sets (filename, &summary.ctrs[ix]);
}
+#endif
}
-static void
+#if 1
+
+ATTRIBUTE_UNUSED void
dump_working_sets (const char *filename ATTRIBUTE_UNUSED,
const struct gcov_ctr_summary *summary)
{
@@ -528,3 +536,4 @@ dump_working_sets (const char *filename ATTRIBUTE_
(HOST_WIDEST_INT)ws_info->min_counter);
}
}
+#endif
===================================================================
@@ -120,9 +120,22 @@ static unsigned bbg_file_stamp;
static char *da_file_name;
/* The names of merge functions for counters. */
-static const char *const ctr_merge_functions[GCOV_COUNTERS] = GCOV_MERGE_FUNCTIONS;
-static const char *const ctr_names[GCOV_COUNTERS] = GCOV_COUNTER_NAMES;
+#ifdef DEF_GCOV_COUNTER
+#undef DEF_GCOV_COUNTER
+#endif
+#define STR(str) #str
+#define DEF_GCOV_COUNTER(COUNTER, NAME, FN_TYPE) STR(__gcov_merge ## FN_TYPE),
+static const char *const ctr_merge_functions[GCOV_COUNTERS] = {
+#include "gcov-counter.def"
+};
+#undef STR
+#undef DEF_GCOV_COUNTER
+#define DEF_GCOV_COUNTER(COUNTER, NAME, FN_TYPE) NAME,
+static const char *const ctr_names[GCOV_COUNTERS] = {
+#include "gcov-counter.def"
+};
+
/* Forward declarations. */
static void read_counts_file (void);
static tree build_var (tree, tree, int);
===================================================================
@@ -0,0 +1,466 @@
+/* Gcc offline profile processing tool support. */
+/* Compile this one with gcc. */
+/* Copyright (C) 2014 Free Software Foundation, Inc.
+ Contributed by Rong Xu <xur@google.com>.
+
+This file is part of GCC.
+
+GCC 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 3, or (at your option) any later
+version.
+
+GCC 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.
+
+Under Section 7 of GPL version 3, you are granted additional
+permissions described in the GCC Runtime Library Exception, version
+3.1, as published by the Free Software Foundation.
+
+You should have received a copy of the GNU General Public License and
+a copy of the GCC Runtime Library Exception along with this program;
+see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+<http://www.gnu.org/licenses/>. */
+
+#include "config.h"
+#include "system.h"
+#include "coretypes.h"
+#include "tm.h"
+#include "intl.h"
+#include "diagnostic.h"
+#include "version.h"
+#include "gcov-io.h"
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <ftw.h>
+#include <getopt.h>
+
+extern int gcov_profile_merge (struct gcov_info*, struct gcov_info*, int, int);
+extern int gcov_profile_normalize (struct gcov_info*, gcov_type);
+extern int gcov_profile_scale (struct gcov_info*, float, int, int);
+extern struct gcov_info* gcov_read_profile_dir (const char*, int);
+extern void gcov_exit (void);
+extern void set_gcov_list (struct gcov_info *);
+extern void gcov_set_verbose (void);
+
+static int verbose;
+
+/* Remove file NAME if it has a gcda suffix. */
+
+static int
+unlink_gcda_file (const char *name,
+ const struct stat *status ATTRIBUTE_UNUSED,
+ int type ATTRIBUTE_UNUSED,
+ struct FTW *ftwbuf ATTRIBUTE_UNUSED)
+{
+ int ret = 0;
+ int len = strlen (name);
+ int len1 = strlen (GCOV_DATA_SUFFIX);
+
+ if (len > len1 && !strncmp (len -len1 + name, GCOV_DATA_SUFFIX, len1))
+ remove (name);
+
+ if (ret)
+ {
+ fnotice (stderr, "error in removing %s\n", name);
+ exit (FATAL_EXIT_CODE);
+ }
+
+ return ret;
+}
+
+/* Remove the gcda files in PATH recursively. */
+
+static int
+unlink_profile_dir (const char *path)
+{
+ return nftw(path, unlink_gcda_file, 64, FTW_DEPTH | FTW_PHYS);
+}
+
+/* Merging profile D1 and D2 with weight as W1 and W2, respectively.
+ The result profile is written to directory OUT.
+ Return 0 on success. */
+
+static int
+profile_merge (const char *d1, const char *d2, const char *out, int w1, int w2)
+{
+ char *pwd;
+ int ret;
+ struct gcov_info * d1_profile;
+ struct gcov_info * d2_profile;
+
+
+ d1_profile = gcov_read_profile_dir (d1, 0);
+ if (!d1_profile)
+ return 1;
+
+ if (d2)
+ {
+ d2_profile = gcov_read_profile_dir (d2, 0);
+ if (!d2_profile)
+ return 1;
+
+ /* The actual merge: we overwrite to d1_profile. */
+ ret = gcov_profile_merge (d1_profile, d2_profile, w1, w2);
+
+ if (ret)
+ return ret;
+ }
+
+ /* Output new profile. */
+ unlink_profile_dir (out);
+ mkdir (out, 0755);
+ pwd = getcwd (NULL, 0);
+ gcc_assert (pwd);
+ ret = chdir (out);
+ gcc_assert (ret == 0);
+
+ set_gcov_list (d1_profile);
+ gcov_exit ();
+
+ ret = chdir (pwd);
+ free (pwd);
+ return 0;
+}
+
+/* Usage message for profile merge. */
+
+static void
+print_merge_usage_message (int error_p)
+{
+ FILE *file = error_p ? stderr : stdout;
+
+ fnotice (file, " merge [options] <dir1> <dir2> Merge coverage file contents\n");
+ fnotice (file, " -v, --verbose Verbose mode\n");
+ fnotice (file, " -o, --output <dir> Output directory\n");
+ fnotice (file, " -w, --weight <w1,w2> Set weights (float point values)\n");
+}
+
+static const struct option merge_options[] =
+{
+ { "verbose", no_argument, NULL, 'v' },
+ { "output", required_argument, NULL, 'o' },
+ { "weight", required_argument, NULL, 'w' },
+ { 0, 0, 0, 0 }
+};
+
+/* Print merge usage and exit. */
+
+static void
+merge_usage (void)
+{
+ fnotice (stderr, "Merge subcomand usage:");
+ print_merge_usage_message (true);
+ exit (FATAL_EXIT_CODE);
+}
+
+/* Driver for profile merge sub-command. */
+
+static int
+do_merge (int argc, char **argv)
+{
+ int opt;
+ int ret;
+ const char *output_dir = 0;
+ int w1 = 1, w2 = 1;
+
+ optind = 0;
+ while ((opt = getopt_long (argc, argv, "vo:w:", merge_options, NULL)) != -1)
+ {
+ switch (opt)
+ {
+ case 'v':
+ verbose = 1;
+ gcov_set_verbose ();
+ break;
+ case 'o':
+ output_dir = optarg;
+ break;
+ case 'w':
+ sscanf (optarg, "%d,%d", &w1, &w2);
+ if (w1 < 0 || w2 < 0)
+ {
+ fnotice (stderr, "weights need to be non-negative\n");
+ exit (FATAL_EXIT_CODE);
+ }
+ break;
+ default:
+ merge_usage ();
+ }
+ }
+
+ if (output_dir == NULL)
+ output_dir = "merged_profile";
+
+ if (argc - optind == 2)
+ ret = profile_merge (argv[optind], argv[optind+1], output_dir, w1, w2);
+ else
+ merge_usage ();
+
+ return ret;
+}
+
+/* If N_VAL is no-zero, normalize the profile by setting the largest counter
+ counter value to N_VAL and scale others counters proportionally.
+ Otherwise, multiply the all counters by SCALE. */
+
+static int
+profile_rewrite (const char *d1, const char *out, long long n_val,
+ float scale, int n, int d)
+{
+ char *pwd;
+ int ret;
+ struct gcov_info * d1_profile;
+
+
+ d1_profile = gcov_read_profile_dir (d1, 0);
+ if (!d1_profile)
+ return 1;
+
+ /* Output new profile. */
+ unlink_profile_dir (out);
+ mkdir (out, 0755);
+ pwd = getcwd (NULL, 0);
+ gcc_assert (pwd);
+ ret = chdir (out);
+ gcc_assert (ret == 0);
+
+ if (n_val)
+ gcov_profile_normalize (d1_profile, (gcov_type) n_val);
+ else
+ gcov_profile_scale (d1_profile, scale, n, d);
+
+ set_gcov_list (d1_profile);
+ gcov_exit ();
+
+ ret = chdir (pwd);
+ free (pwd);
+ return 0;
+}
+
+/* Usage function for profile rewrite. */
+
+static void
+print_rewrite_usage_message (int error_p)
+{
+ FILE *file = error_p ? stderr : stdout;
+
+ fnotice (file, " rewrite [options] <dir> Rewrite coverage file contents\n");
+ fnotice (file, " -v, --verbose Verbose mode\n");
+ fnotice (file, " -o, --output <dir> Output directory\n");
+ fnotice (file, " -s, --scale <float or simple-frac> Scale the profile counters\n");
+ fnotice (file, " -n, --normalize <long long> Normalize the profile\n");
+}
+
+static const struct option rewrite_options[] =
+{
+ { "verbose", no_argument, NULL, 'v' },
+ { "output", required_argument, NULL, 'o' },
+ { "scale", required_argument, NULL, 's' },
+ { "normalize", required_argument, NULL, 'n' },
+ { 0, 0, 0, 0 }
+};
+
+/* Print profile rewrite usage and exit. */
+
+static void
+rewrite_usage (void)
+{
+ fnotice (stderr, "Rewrite subcommand usage:");
+ print_rewrite_usage_message (true);
+ exit (FATAL_EXIT_CODE);
+}
+
+/* Driver for profile rewrite sub-command. */
+
+static int
+do_rewrite (int argc, char **argv)
+{
+ int opt;
+ int ret;
+ const char *output_dir = 0;
+ long long normalize_val = 0;
+ float scale = 0.0;
+ int numerator = 1;
+ int denominator = 1;
+ int do_scaling = 0;
+
+ optind = 0;
+ while ((opt = getopt_long (argc, argv, "vo:s:n:", rewrite_options, NULL)) != -1)
+ {
+ switch (opt)
+ {
+ case 'v':
+ verbose = 1;
+ gcov_set_verbose ();
+ break;
+ case 'o':
+ output_dir = optarg;
+ break;
+ case 'n':
+ if (!do_scaling)
+ normalize_val = atoll (optarg);
+ else
+ fnotice (stderr, "scaling cannot co-exist with normalization,"
+ " skipping\n");
+ break;
+ case 's':
+ ret = 0;
+ do_scaling = 1;
+ if (strstr (optarg, "/"))
+ {
+ ret = sscanf (optarg, "%d/%d", &numerator, &denominator);
+ if (ret == 2)
+ {
+ gcc_assert (numerator >= 0);
+ gcc_assert (denominator > 0);
+ }
+ }
+ if (ret != 2)
+ {
+ ret = sscanf (optarg, "%f", &scale);
+ gcc_assert (ret == 1);
+ denominator = 0;
+ }
+
+ if (scale < 0.0)
+ {
+ fnotice (stderr, "scale needs to be non-negative\n");
+ exit (FATAL_EXIT_CODE);
+ }
+ if (normalize_val != 0)
+ {
+ fnotice (stderr, "normalization cannot co-exist with scaling\n");
+ normalize_val = 0;
+ }
+ break;
+ default:
+ rewrite_usage ();
+ }
+ }
+
+ if (output_dir == NULL)
+ output_dir = "rewrite_profile";
+
+ if (argc - optind == 1)
+ {
+ if (denominator > 0)
+ ret = profile_rewrite (argv[optind], output_dir, 0, 0.0, numerator, denominator);
+ else
+ ret = profile_rewrite (argv[optind], output_dir, normalize_val, scale, 0, 0);
+ }
+ else
+ rewrite_usage ();
+
+ return ret;
+}
+
+/* Print a usage message and exit. If ERROR_P is nonzero, this is an error,
+ otherwise the output of --help. */
+
+static void
+print_usage (int error_p)
+{
+ FILE *file = error_p ? stderr : stdout;
+ int status = error_p ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE;
+
+ fnotice (file, "Usage: %s [OPTION]... SUB_COMMAND [OPTION]...\n\n", progname);
+ fnotice (file, "Offline tool to handle gcda counts\n\n");
+ fnotice (file, " -h, --help Print this help, then exit\n");
+ fnotice (file, " -v, --version Print version number, then exit\n");
+ print_merge_usage_message (error_p);
+ print_rewrite_usage_message (error_p);
+ fnotice (file, "\nFor bug reporting instructions, please see:\n%s.\n",
+ bug_report_url);
+ exit (status);
+}
+
+/* Print version information and exit. */
+
+static void
+print_version (void)
+{
+ fnotice (stdout, "%s %s%s\n", progname, pkgversion_string, version_string);
+ fnotice (stdout, "Copyright %s 2014 Free Software Foundation, Inc.\n",
+ _("(C)"));
+ fnotice (stdout,
+ _("This is free software; see the source for copying conditions.\n"
+ "There is NO warranty; not even for MERCHANTABILITY or \n"
+ "FITNESS FOR A PARTICULAR PURPOSE.\n\n"));
+ exit (SUCCESS_EXIT_CODE);
+}
+
+static const struct option options[] =
+{
+ { "help", no_argument, NULL, 'h' },
+ { "version", no_argument, NULL, 'v' },
+ { 0, 0, 0, 0 }
+};
+
+/* Process args, return index to first non-arg. */
+
+static int
+process_args (int argc, char **argv)
+{
+ int opt;
+
+ while ((opt = getopt_long (argc, argv, "+hv", options, NULL)) != -1)
+ {
+ switch (opt)
+ {
+ case 'h':
+ print_usage (false);
+ /* Print_usage will exit. */
+ case 'v':
+ print_version ();
+ /* Print_version will exit. */
+ default:
+ print_usage (true);
+ /* Print_usage will exit. */
+ }
+ }
+
+ return optind;
+}
+
+/* Main function for gcov-tool. */
+
+int
+main (int argc, char **argv)
+{
+ const char *p;
+ const char *sub_command;
+
+ p = argv[0] + strlen (argv[0]);
+ while (p != argv[0] && !IS_DIR_SEPARATOR (p[-1]))
+ --p;
+ progname = p;
+
+ xmalloc_set_program_name (progname);
+
+ /* Unlock the stdio streams. */
+ unlock_std_streams ();
+
+ gcc_init_libintl ();
+
+ diagnostic_initialize (global_dc, 0);
+
+ /* Handle response files. */
+ expandargv (&argc, &argv);
+
+ process_args (argc, argv);
+ if (optind >= argc)
+ print_usage (true);
+
+ sub_command = argv[optind];
+
+ if (!strcmp (sub_command, "merge"))
+ return do_merge (argc - optind, argv + optind);
+ else if (!strcmp (sub_command, "rewrite"))
+ return do_rewrite (argc - optind, argv + optind);
+
+ print_usage (true);
+}
===================================================================
@@ -123,7 +123,8 @@ SUBDIRS =@subdirs@ build
# Selection of languages to be made.
CONFIG_LANGUAGES = @all_selected_languages@
-LANGUAGES = c gcov$(exeext) gcov-dump$(exeext) $(CONFIG_LANGUAGES)
+LANGUAGES = c gcov$(exeext) gcov-dump$(exeext) gcov-tool$(exeext) \
+ $(CONFIG_LANGUAGES)
# Default values for variables overridden in Makefile fragments.
# CFLAGS is for the user to override to, e.g., do a cross build with -O2.
@@ -196,6 +197,9 @@ GCC_WARN_CXXFLAGS = $(LOOSE_WARN) $($(@D)-warn) $(
# flex output may yield harmless "no previous prototype" warnings
build/gengtype-lex.o-warn = -Wno-error
gengtype-lex.o-warn = -Wno-error
+libgcov-util.o-warn = -Wno-error
+libgcov-driver-tool.o-warn = -Wno-error
+libgcov-merge-tool.o-warn = -Wno-error
# All warnings have to be shut off in stage1 if the compiler used then
# isn't gcc; configure determines that. WARN_CFLAGS will be either
@@ -769,6 +773,7 @@ GCC_INSTALL_NAME := $(shell echo gcc|sed '$(progra
GCC_TARGET_INSTALL_NAME := $(target_noncanonical)-$(shell echo gcc|sed '$(program_transform_name)')
CPP_INSTALL_NAME := $(shell echo cpp|sed '$(program_transform_name)')
GCOV_INSTALL_NAME := $(shell echo gcov|sed '$(program_transform_name)')
+GCOV_TOOL_INSTALL_NAME := $(shell echo gcov-tool|sed '$(program_transform_name)')
# Setup the testing framework, if you have one
EXPECT = `if [ -f $${rootme}/../expect/expect ] ; then \
@@ -890,7 +895,7 @@ BASIC_BLOCK_H = basic-block.h $(PREDICT_H) $(VEC_H
GIMPLE_H = gimple.h gimple.def gsstruct.def pointer-set.h $(VEC_H) \
$(GGC_H) $(BASIC_BLOCK_H) $(TREE_H) tree-ssa-operands.h \
tree-ssa-alias.h $(INTERNAL_FN_H) $(HASH_TABLE_H) is-a.h
-GCOV_IO_H = gcov-io.h gcov-iov.h auto-host.h
+GCOV_IO_H = gcov-io.h gcov-iov.h auto-host.h gcov-counter.def
RECOG_H = recog.h
EMIT_RTL_H = emit-rtl.h
FLAGS_H = flags.h flag-types.h $(OPTIONS_H)
@@ -1486,7 +1491,7 @@ ALL_HOST_FRONTEND_OBJS = $(foreach v,$(CONFIG_LANG
ALL_HOST_BACKEND_OBJS = $(GCC_OBJS) $(OBJS) $(OBJS-libcommon) \
$(OBJS-libcommon-target) @TREEBROWSER@ main.o c-family/cppspec.o \
$(COLLECT2_OBJS) $(EXTRA_GCC_OBJS) $(GCOV_OBJS) $(GCOV_DUMP_OBJS) \
- lto-wrapper.o
+ $(GCOV_TOOL_OBJS) lto-wrapper.o
# This lists all host object files, whether they are included in this
# compilation or not.
@@ -1511,6 +1516,7 @@ MOSTLYCLEANFILES = insn-flags.h insn-config.h insn
$(SPECS) collect2$(exeext) gcc-ar$(exeext) gcc-nm$(exeext) \
gcc-ranlib$(exeext) \
gcov-iov$(build_exeext) gcov$(exeext) gcov-dump$(exeext) \
+ gcov-tool$(exeect) \
gengtype$(exeext) *.[0-9][0-9].* *.[si] *-checksum.c libbackend.a \
libcommon-target.a libcommon.a libgcc.mk
@@ -2569,6 +2575,22 @@ GCOV_DUMP_OBJS = gcov-dump.o
gcov-dump$(exeext): $(GCOV_DUMP_OBJS) $(LIBDEPS)
+$(LINKER) $(ALL_LINKERFLAGS) $(LDFLAGS) $(GCOV_DUMP_OBJS) \
$(LIBS) -o $@
+
+GCOV_TOOL_DEP_FILES = $(srcdir)/../libgcc/libgcov-util.c gcov-io.c $(GCOV_IO_H) \
+ $(srcdir)/../libgcc/libgcov-driver.c $(srcdir)/../libgcc/libgcov-driver-system.c \
+ $(srcdir)/../libgcc/libgcov-merge.c \
+ $(SYSTEM_H) coretypes.h $(TM_H) $(CONFIG_H) version.h intl.h $(DIAGNOSTIC_H)
+libgcov-util.o: $(srcdir)/../libgcc/libgcov-util.c $(GCOV_TOOL_DEP_FILES)
+ +$(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) -o $@ $<
+libgcov-driver-tool.o: $(srcdir)/../libgcc/libgcov-driver.c $(GCOV_TOOL_DEP_FILES)
+ +$(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) \
+ -DIN_GCOV_TOOL=1 -o $@ $<
+libgcov-merge-tool.o: $(srcdir)/../libgcc/libgcov-merge.c $(GCOV_TOOL_DEP_FILES)
+ +$(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) \
+ -DIN_GCOV_TOOL=1 -o $@ $<
+GCOV_TOOL_OBJS = gcov-tool.o libgcov-util.o libgcov-driver-tool.o libgcov-merge-tool.o
+gcov-tool$(exeext): $(GCOV_TOOL_OBJS) $(LIBDEPS)
+ +$(LINKER) $(ALL_LINKERFLAGS) $(LDFLAGS) $(GCOV_TOOL_OBJS) $(LIBS) -o $@
#
# Build the include directories. The stamp files are stmp-* rather than
# s-* so that mostlyclean does not force the include directory to
@@ -3205,6 +3227,13 @@ install-common: native lang.install-common install
rm -f $(DESTDIR)$(bindir)/$(GCOV_INSTALL_NAME)$(exeext); \
$(INSTALL_PROGRAM) gcov$(exeext) $(DESTDIR)$(bindir)/$(GCOV_INSTALL_NAME)$(exeext); \
fi
+# Install gcov-tool if it was compiled.
+ -if [ -f gcov-tool$(exeext) ]; \
+ then \
+ rm -f $(DESTDIR)$(bindir)/$(GCOV_TOOL_INSTALL_NAME)$(exeext); \
+ $(INSTALL_PROGRAM) \
+ gcov-tool$(exeext) $(DESTDIR)$(bindir)/$(GCOV_TOOL_INSTALL_NAME)$(exeext); \
+ fi
# Install the driver program as $(target_noncanonical)-gcc,
# $(target_noncanonical)-gcc-$(version), and also as gcc if native.
===================================================================
@@ -0,0 +1,54 @@
+/* Definitions for the gcov counters in the GNU compiler.
+ Copyright (C) 2001-2014 Free Software Foundation, Inc.
+
+This file is part of GCC.
+
+GCC 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 3, or (at your option) any later
+version.
+
+GCC 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 GCC; see the file COPYING3. If not see
+<http://www.gnu.org/licenses/>. */
+
+/* Before including this file, define a macro:
+
+ DEF_GCOV_COUNTER(COUNTER, NAME, FN_TYPE)
+
+ This macro will be expanded to all supported gcov counters, their
+ names, or the type of handler functions. FN_TYPE will be
+ expanded to a handler function, like in gcov_merge, it is
+ expanded to __gcov_merge ## FN_TYPE. */
+
+/* Arc transitions. */
+DEF_GCOV_COUNTER(GCOV_COUNTER_ARCS=0, "arcs", _add)
+
+/* Histogram of value inside an interval. */
+DEF_GCOV_COUNTER(GCOV_COUNTER_V_INTERVAL, "interval", _add)
+
+/* Histogram of exact power2 logarithm of a value. */
+DEF_GCOV_COUNTER(GCOV_COUNTER_V_POW2, "pow2", _add)
+
+/* The most common value of expression. */
+DEF_GCOV_COUNTER(GCOV_COUNTER_V_SINGLE, "single", _single)
+
+/* The most common difference between consecutive values of expression. */
+DEF_GCOV_COUNTER(GCOV_COUNTER_V_DELTA, "delta", _delta)
+
+/* The most common indirect address. */
+DEF_GCOV_COUNTER(GCOV_COUNTER_V_INDIR, "indirect_call", _single)
+
+/* Compute average value passed to the counter. */
+DEF_GCOV_COUNTER(GCOV_COUNTER_AVERAGE, "average", _add)
+
+/* IOR of the all values passed to counter. */
+DEF_GCOV_COUNTER(GCOV_COUNTER_IOR, "ior", _ior)
+
+/* Time profile collecting first run of a function */
+DEF_GCOV_COUNTER(GCOV_TIME_PROFILER, "time_profiler", _time_profile)
===================================================================
@@ -77,7 +77,11 @@ set_gcov_list (struct gcov_info *head)
}
/* Size of the longest file name. */
-static size_t gcov_max_filename = 0;
+/* We need to expose this static variable when compiling for gcov-tool. */
+#ifndef IN_GCOV_TOOL
+static
+#endif
+size_t gcov_max_filename = 0;
/* Flag when the profile has already been dumped via __gcov_dump(). */
static int gcov_dump_complete;
===================================================================
@@ -53,7 +53,7 @@ void
__gcov_merge_add (gcov_type *counters, unsigned n_counters)
{
for (; n_counters; counters++, n_counters--)
- *counters += gcov_read_counter ();
+ *counters += GCOV_GET_COUNTER;
}
#endif /* L_gcov_merge_add */
@@ -65,7 +65,7 @@ void
__gcov_merge_ior (gcov_type *counters, unsigned n_counters)
{
for (; n_counters; counters++, n_counters--)
- *counters |= gcov_read_counter ();
+ *counters |= GCOV_GET_COUNTER;
}
#endif
@@ -81,7 +81,7 @@ __gcov_merge_time_profile (gcov_type *counters, un
for (i = 0; i < n_counters; i++)
{
- value = gcov_read_counter ();
+ value = GCOV_GET_COUNTER;
if (value && (!counters[i] || value < counters[i]))
counters[i] = value;
@@ -109,9 +109,9 @@ __gcov_merge_single (gcov_type *counters, unsigned
n_measures = n_counters / 3;
for (i = 0; i < n_measures; i++, counters += 3)
{
- value = gcov_read_counter ();
- counter = gcov_read_counter ();
- all = gcov_read_counter ();
+ value = GCOV_GET_COUNTER_TARGET;
+ counter = GCOV_GET_COUNTER;
+ all = GCOV_GET_COUNTER;
if (counters[0] == value)
counters[1] += counter;
@@ -148,10 +148,10 @@ __gcov_merge_delta (gcov_type *counters, unsigned
n_measures = n_counters / 4;
for (i = 0; i < n_measures; i++, counters += 4)
{
- /* last = */ gcov_read_counter ();
- value = gcov_read_counter ();
- counter = gcov_read_counter ();
- all = gcov_read_counter ();
+ /* last = */ GCOV_GET_COUNTER;
+ value = GCOV_GET_COUNTER_TARGET;
+ counter = GCOV_GET_COUNTER;
+ all = GCOV_GET_COUNTER;
if (counters[1] == value)
counters[2] += counter;
===================================================================
@@ -0,0 +1,866 @@
+/* Utility functions for reading gcda files into in-memory
+ gcov_info structures and offline profile processing. */
+/* Copyright (C) 2014 Free Software Foundation, Inc.
+ Contributed by Rong Xu <xur@google.com>.
+
+This file is part of GCC.
+
+GCC 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 3, or (at your option) any later
+version.
+
+GCC 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.
+
+Under Section 7 of GPL version 3, you are granted additional
+permissions described in the GCC Runtime Library Exception, version
+3.1, as published by the Free Software Foundation.
+
+You should have received a copy of the GNU General Public License and
+a copy of the GCC Runtime Library Exception along with this program;
+see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+<http://www.gnu.org/licenses/>. */
+
+
+#define IN_GCOV_TOOL 1
+
+#include "libgcov.h"
+#include "intl.h"
+#include "diagnostic.h"
+#include "version.h"
+#include "demangle.h"
+
+/* Borrowed from basic-block.h. */
+#define RDIV(X,Y) (((X) + (Y) / 2) / (Y))
+
+/*extern gcov_type gcov_read_counter_mem();
+extern unsigned gcov_get_merge_weight(); */
+
+/* TBD: xur */
+extern gcov_position_t gcov_position();
+extern int gcov_is_error();
+extern gcov_unsigned_t gcov_max_filename;
+
+/* We need the dumping and merge part of code in libgcov. */
+/*#include "libgcov-driver.c"
+#include "libgcov-merge.c" */
+
+/* Verbose mode for debug. */
+static int verbose;
+
+/* Set verbose flag. */
+void gcov_set_verbose (void)
+{
+ verbose = 1;
+}
+
+/* The following part is to read Gcda and reconstruct GCOV_INFO. */
+
+#include "obstack.h"
+#include <unistd.h>
+#include <ftw.h>
+
+static void tag_function (unsigned, unsigned);
+static void tag_blocks (unsigned, unsigned);
+static void tag_arcs (unsigned, unsigned);
+static void tag_lines (unsigned, unsigned);
+static void tag_counters (unsigned, unsigned);
+static void tag_summary (unsigned, unsigned);
+
+/* The gcov_info for the first module. */
+static struct gcov_info *curr_gcov_info;
+/* The gcov_info being processed. */
+static struct gcov_info *gcov_info_head;
+/* This variable contains all the functions in current module. */
+static struct obstack fn_info;
+/* The function being processed. */
+static struct gcov_fn_info *curr_fn_info;
+/* The number of functions seen so far. */
+static unsigned num_fn_info;
+/* This variable contains all the counters for current module. */
+static int k_ctrs_mask[GCOV_COUNTERS];
+/* The kind of counters that have been seen. */
+static struct gcov_ctr_info k_ctrs[GCOV_COUNTERS];
+/* Number of kind of counters that have been seen. */
+static int k_ctrs_types;
+/* The longest length of all the filenames. */
+static int max_filename_len;
+
+/* Merge functions for counters. */
+#ifdef DEF_GCOV_COUNTER
+#undef DEF_GCOV_COUNTER
+#endif
+#define DEF_GCOV_COUNTER(COUNTER, NAME, FN_TYPE) __gcov_merge ## FN_TYPE,
+static gcov_merge_fn ctr_merge_functions[GCOV_COUNTERS] = {
+#include "gcov-counter.def"
+};
+
+/* Set the ctrs field in gcov_fn_info object FN_INFO. */
+
+static void
+set_fn_ctrs (struct gcov_fn_info *fn_info)
+{
+ int j = 0, i;
+
+ for (i = 0; i < GCOV_COUNTERS; i++)
+ {
+ if (k_ctrs_mask[i] == 0)
+ continue;
+ fn_info->ctrs[j].num = k_ctrs[i].num;
+ fn_info->ctrs[j].values = k_ctrs[i].values;
+ j++;
+ }
+ if (k_ctrs_types == 0)
+ k_ctrs_types = j;
+ else
+ gcc_assert (j == k_ctrs_types);
+}
+
+/* For each tag in gcda file, we have an entry here.
+ TAG is the tag value; NAME is the tag name; and
+ PROC is the handler function. */
+
+typedef struct tag_format
+{
+ unsigned tag;
+ char const *name;
+ void (*proc) (unsigned, unsigned);
+} tag_format_t;
+
+/* Handler table for various Tags. */
+
+static const tag_format_t tag_table[] =
+{
+ {0, "NOP", NULL},
+ {0, "UNKNOWN", NULL},
+ {0, "COUNTERS", tag_counters},
+ {GCOV_TAG_FUNCTION, "FUNCTION", tag_function},
+ {GCOV_TAG_BLOCKS, "BLOCKS", tag_blocks},
+ {GCOV_TAG_ARCS, "ARCS", tag_arcs},
+ {GCOV_TAG_LINES, "LINES", tag_lines},
+ {GCOV_TAG_OBJECT_SUMMARY, "OBJECT_SUMMARY", tag_summary},
+ {GCOV_TAG_PROGRAM_SUMMARY, "PROGRAM_SUMMARY", tag_summary},
+ {0, NULL, NULL}
+};
+
+/* Handler for reading function tag. */
+
+static void
+tag_function (unsigned tag ATTRIBUTE_UNUSED, unsigned length ATTRIBUTE_UNUSED)
+{
+ int i;
+
+ /* write out previous fn_info. */
+ if (num_fn_info)
+ {
+ set_fn_ctrs (curr_fn_info);
+ obstack_ptr_grow (&fn_info, curr_fn_info);
+ }
+
+ /* Here we over allocate a bit, using GCOV_COUNTERS instead of the actual active
+ counter types. */
+ curr_fn_info = (struct gcov_fn_info *) xcalloc (sizeof (struct gcov_fn_info)
+ + GCOV_COUNTERS * sizeof (struct gcov_ctr_info), 1);
+
+ for (i = 0; i < GCOV_COUNTERS; i++)
+ k_ctrs[i].num = 0;
+ k_ctrs_types = 0;
+
+ curr_fn_info->key = curr_gcov_info;
+ curr_fn_info->ident = gcov_read_unsigned ();
+ curr_fn_info->lineno_checksum = gcov_read_unsigned ();
+ curr_fn_info->cfg_checksum = gcov_read_unsigned ();
+ num_fn_info++;
+
+ if (verbose)
+ fprintf (stdout, "tag one function id=%d\n", curr_fn_info->ident);
+}
+
+/* Handler for reading block tag. */
+
+static void
+tag_blocks (unsigned tag ATTRIBUTE_UNUSED, unsigned length ATTRIBUTE_UNUSED)
+{
+ /* TBD: gcov-tool currently does not handle gcno files. Assert here. */
+ gcc_unreachable ();
+}
+
+/* Handler for reading flow arc tag. */
+
+static void
+tag_arcs (unsigned tag ATTRIBUTE_UNUSED, unsigned length ATTRIBUTE_UNUSED)
+{
+ /* TBD: gcov-tool currently does not handle gcno files. Assert here. */
+ gcc_unreachable ();
+}
+
+/* Handler for reading line tag. */
+
+static void
+tag_lines (unsigned tag ATTRIBUTE_UNUSED, unsigned length ATTRIBUTE_UNUSED)
+{
+ /* TBD: gcov-tool currently does not handle gcno files. Assert here. */
+ gcc_unreachable ();
+}
+
+/* Handler for reading counters array tag with value as TAG and length of LENGTH. */
+
+static void
+tag_counters (unsigned tag, unsigned length)
+{
+ unsigned n_counts = GCOV_TAG_COUNTER_NUM (length);
+ gcov_type *values;
+ unsigned ix;
+ unsigned tag_ix;
+
+ tag_ix = GCOV_COUNTER_FOR_TAG (tag);
+ gcc_assert (tag_ix < GCOV_COUNTERS);
+ k_ctrs_mask [tag_ix] = 1;
+ gcc_assert (k_ctrs[tag_ix].num == 0);
+ k_ctrs[tag_ix].num = n_counts;
+
+ k_ctrs[tag_ix].values = values = (gcov_type *) xmalloc (n_counts * sizeof (gcov_type));
+ gcc_assert (values);
+
+ for (ix = 0; ix != n_counts; ix++)
+ values[ix] = gcov_read_counter ();
+}
+
+/* Handler for reading summary tag. */
+
+static void
+tag_summary (unsigned tag ATTRIBUTE_UNUSED, unsigned length ATTRIBUTE_UNUSED)
+{
+ struct gcov_summary summary;
+
+ gcov_read_summary (&summary);
+}
+
+/* This function is called at the end of reading a gcda file.
+ It flushes the contents in curr_fn_info to gcov_info object OBJ_INFO. */
+
+static void
+read_gcda_finalize (struct gcov_info *obj_info)
+{
+ int i;
+
+ set_fn_ctrs (curr_fn_info);
+ obstack_ptr_grow (&fn_info, curr_fn_info);
+
+ /* We set the following fields: merge, n_functions, and functions. */
+ obj_info->n_functions = num_fn_info;
+ obj_info->functions = (const struct gcov_fn_info**) obstack_finish (&fn_info);
+
+ /* wrap all the counter array. */
+ for (i=0; i< GCOV_COUNTERS; i++)
+ {
+ if (k_ctrs_mask[i])
+ obj_info->merge[i] = ctr_merge_functions[i];
+ }
+}
+
+/* Read the content of a gcda file FILENAME, and return a gcov_info data structure.
+ Program level summary CURRENT_SUMMARY will also be updated. */
+
+static struct gcov_info *
+read_gcda_file (const char *filename)
+{
+ unsigned tags[4];
+ unsigned depth = 0;
+ unsigned magic, version;
+ struct gcov_info *obj_info;
+ int i;
+
+ for (i=0; i< GCOV_COUNTERS; i++)
+ k_ctrs_mask[i] = 0;
+ k_ctrs_types = 0;
+
+ if (!gcov_open (filename))
+ {
+ fprintf (stderr, "%s:cannot open\n", filename);
+ return NULL;
+ }
+
+ /* Read magic. */
+ magic = gcov_read_unsigned ();
+ if (magic != GCOV_DATA_MAGIC)
+ {
+ fprintf (stderr, "%s:not a gcov data file\n", filename);
+ gcov_close ();
+ return NULL;
+ }
+
+ /* Read version. */
+ version = gcov_read_unsigned ();
+ if (version != GCOV_VERSION)
+ {
+ fprintf (stderr, "%s:incorrect gcov version %d vs %d \n", filename, version, GCOV_VERSION);
+ gcov_close ();
+ return NULL;
+ }
+
+ /* Instantiate a gcov_info object. */
+ curr_gcov_info = obj_info = (struct gcov_info *) xcalloc (sizeof (struct gcov_info) +
+ sizeof (struct gcov_ctr_info) * GCOV_COUNTERS, 1);
+
+ obj_info->version = version;
+ obstack_init (&fn_info);
+ num_fn_info = 0;
+ curr_fn_info = 0;
+ {
+ char *str_dup = (char*) xmalloc (strlen (filename) + 1);
+ int len;
+
+ strcpy (str_dup, filename);
+ obj_info->filename = str_dup;
+ if ((len = strlen (filename)) > max_filename_len)
+ max_filename_len = len;
+ }
+
+ /* Read stamp. */
+ obj_info->stamp = gcov_read_unsigned ();
+
+ while (1)
+ {
+ gcov_position_t base;
+ unsigned tag, length;
+ tag_format_t const *format;
+ unsigned tag_depth;
+ int error;
+ unsigned mask;
+
+ tag = gcov_read_unsigned ();
+ if (!tag)
+ break;
+ length = gcov_read_unsigned ();
+ base = gcov_position ();
+ mask = GCOV_TAG_MASK (tag) >> 1;
+ for (tag_depth = 4; mask; mask >>= 8)
+ {
+ if (((mask & 0xff) != 0xff))
+ {
+ fprintf (stderr, "warning: %s:tag `%08x' is invalid\n", filename, tag);
+ break;
+ }
+ tag_depth--;
+ }
+ for (format = tag_table; format->name; format++)
+ if (format->tag == tag)
+ goto found;
+ format = &tag_table[GCOV_TAG_IS_COUNTER (tag) ? 2 : 1];
+ found:;
+ if (tag)
+ {
+ if (depth && depth < tag_depth)
+ {
+ if (!GCOV_TAG_IS_SUBTAG (tags[depth - 1], tag))
+ fprintf (stderr, "warning: %s:tag `%08x' is incorrectly nested\n",
+ filename, tag);
+ }
+ depth = tag_depth;
+ tags[depth - 1] = tag;
+ }
+
+ if (format->proc)
+ {
+ unsigned long actual_length;
+
+ (*format->proc) (tag, length);
+
+ actual_length = gcov_position () - base;
+ if (actual_length > length)
+ fprintf (stderr,"warning: %s:record size mismatch %lu bytes overread\n",
+ filename, actual_length - length);
+ else if (length > actual_length)
+ fprintf (stderr,"warning: %s:record size mismatch %lu bytes unread\n",
+ filename, length - actual_length);
+ }
+
+ gcov_sync (base, length);
+ if ((error = gcov_is_error ()))
+ {
+ fprintf (stderr,error < 0 ? "warning:%s:counter overflow at %lu\n" :
+ "Warning:%s:read error at %lu\n", filename,
+ (long unsigned) gcov_position ());
+ break;
+ }
+ }
+
+ read_gcda_finalize (obj_info);
+ gcov_close ();
+
+ return obj_info;
+}
+
+/* This will be called by ftw(). It opens and read a gcda file FILENAME.
+ Return a non-zero value to stop the tree walk. */
+
+static int
+ftw_read_file (const char *filename,
+ const struct stat *status ATTRIBUTE_UNUSED,
+ int type)
+{
+ int filename_len;
+ int suffix_len;
+ struct gcov_info *obj_info;
+
+ /* Only read regular files. */
+ if (type != FTW_F)
+ return 0;
+
+ filename_len = strlen (filename);
+ suffix_len = strlen (GCOV_DATA_SUFFIX);
+
+ if (filename_len <= suffix_len)
+ return 0;
+
+ if (strcmp(filename + filename_len - suffix_len, GCOV_DATA_SUFFIX))
+ return 0;
+
+ if (verbose)
+ fprintf (stderr, "reading file: %s\n", filename);
+
+ obj_info = read_gcda_file (filename);
+
+ obj_info->next = gcov_info_head;
+ gcov_info_head = obj_info;
+
+ return 0;
+}
+
+/* Initializer for reading a profile dir. */
+
+static inline void
+read_profile_dir_init (void)
+{
+ gcov_info_head = 0;
+}
+
+/* Driver for read a profile directory and convert into gcov_info list in memory.
+ Return NULL on error,
+ Return the head of gcov_info list on success.
+ Note the file static variable GCOV_MAX_FILENAME is also set. */
+
+struct gcov_info *
+gcov_read_profile_dir (const char* dir_name, int recompute_summary ATTRIBUTE_UNUSED)
+{
+ char *pwd;
+ int ret;
+
+ read_profile_dir_init ();
+
+ if (access (dir_name, R_OK) != 0)
+ {
+ fprintf (stderr, "cannot access directory %s\n", dir_name);
+ return NULL;
+ }
+ pwd = getcwd (NULL, 0);
+ gcc_assert (pwd);
+ ret = chdir (dir_name);
+ if (ret !=0)
+ {
+ fprintf (stderr, "%s is not a directory\n", dir_name);
+ return NULL;
+ }
+ ftw (".", ftw_read_file, 50);
+ ret = chdir (pwd);
+ free (pwd);
+
+
+ /* gcov_max_filename is defined in libgcov.c that records the
+ max filename len. We need to set it here to allocate the
+ array for dumping. */
+ gcov_max_filename = max_filename_len;
+
+ return gcov_info_head;;
+}
+
+/* This part of the code is to merge profile counters. */
+
+static gcov_type *gcov_value_buf;
+static gcov_unsigned_t gcov_value_buf_size;
+static gcov_unsigned_t gcov_value_buf_pos;
+static unsigned gcov_merge_weight;
+
+/* Read a counter value from gcov_value_buf array. */
+
+gcov_type
+gcov_read_counter_mem (void)
+{
+ gcov_type ret;
+ gcc_assert (gcov_value_buf_pos < gcov_value_buf_size);
+ ret = *(gcov_value_buf + gcov_value_buf_pos);
+ ++gcov_value_buf_pos;
+ return ret;
+}
+
+/* Return the recorded merge weight. */
+
+unsigned
+gcov_get_merge_weight (void)
+{
+ return gcov_merge_weight;
+}
+
+/* A wrapper function for merge functions. It sets up the
+ value buffer and weights and then calls the merge function. */
+
+static void
+merge_wrapper (gcov_merge_fn f, gcov_type *v1, gcov_unsigned_t n,
+ gcov_type *v2, unsigned w)
+{
+ gcov_value_buf = v2;
+ gcov_value_buf_pos = 0;
+ gcov_value_buf_size = n;
+ gcov_merge_weight = w;
+ (*f) (v1, n);
+}
+
+/* Offline tool to manipulate profile data.
+ This tool targets on matched profiles. But it has some tolerance on
+ unmatched profiles.
+ When merging p1 to p2 (p2 is the dst),
+ * m.gcda in p1 but not in p2: append m.gcda to p2 with specified weight;
+ emit warning
+ * m.gcda in p2 but not in p1: keep m.gcda in p2 and multiply by
+ specified weight; emit warning.
+ * m.gcda in both p1 and p2:
+ ** p1->m.gcda->f checksum matches p2->m.gcda->f: simple merge.
+ ** p1->m.gcda->f checksum does not matches p2->m.gcda->f: keep
+ p2->m.gcda->f and
+ drop p1->m.gcda->f. A warning is emitted. */
+
+/* Add INFO2's counter to INFO1, multiplying by weight W. */
+
+static int
+gcov_merge (struct gcov_info *info1, struct gcov_info *info2, int w)
+{
+ unsigned f_ix;
+ unsigned n_functions = info1->n_functions;
+ int has_mismatch = 0;
+
+ gcc_assert (info2->n_functions == n_functions);
+ for (f_ix = 0; f_ix < n_functions; f_ix++)
+ {
+ unsigned t_ix;
+ const struct gcov_fn_info *gfi_ptr1 = info1->functions[f_ix];
+ const struct gcov_fn_info *gfi_ptr2 = info2->functions[f_ix];
+ const struct gcov_ctr_info *ci_ptr1, *ci_ptr2;
+
+ if (!gfi_ptr1 || gfi_ptr1->key != info1)
+ continue;
+ if (!gfi_ptr2 || gfi_ptr2->key != info2)
+ continue;
+
+ if (gfi_ptr1->cfg_checksum != gfi_ptr2->cfg_checksum)
+ {
+ fprintf (stderr, "in %s, cfg_checksum mismatch, skipping\n",
+ info1->filename);
+ has_mismatch = 1;
+ continue;
+ }
+ ci_ptr1 = gfi_ptr1->ctrs;
+ ci_ptr2 = gfi_ptr2->ctrs;
+ for (t_ix = 0; t_ix != GCOV_COUNTERS; t_ix++)
+ {
+ gcov_merge_fn merge1 = info1->merge[t_ix];
+ gcov_merge_fn merge2 = info2->merge[t_ix];
+
+ gcc_assert (merge1 == merge2);
+ if (!merge1)
+ continue;
+ gcc_assert (ci_ptr1->num == ci_ptr2->num);
+ merge_wrapper (merge1, ci_ptr1->values, ci_ptr1->num, ci_ptr2->values, w);
+ ci_ptr1++;
+ ci_ptr2++;
+ }
+ }
+
+ return has_mismatch;
+}
+
+/* Find and return the match gcov_info object for INFO from ARRAY.
+ SIZE is the length of ARRAY.
+ Return NULL if there is no match. */
+
+static struct gcov_info *
+find_match_gcov_info (struct gcov_info **array, int size, struct gcov_info *info)
+{
+ struct gcov_info *gi_ptr;
+ struct gcov_info *ret = NULL;
+ int i;
+
+ for (i = 0; i < size; i++)
+ {
+ gi_ptr = array[i];
+ if (gi_ptr == 0)
+ continue;
+ if (!strcmp (gi_ptr->filename, info->filename))
+ {
+ ret = gi_ptr;
+ array[i] = 0;
+ break;
+ }
+ }
+
+ if (ret && ret->n_functions != info->n_functions)
+ {
+ fprintf (stderr, "mismatched profiles in %s (%d functions"
+ " vs %d functions)\n",
+ ret->filename,
+ ret->n_functions,
+ info->n_functions);
+ ret = NULL;
+ }
+ return ret;
+}
+
+/* Merge the list of gcov_info objects from SRC_PROFILE to TGT_PROFILE.
+ Return 0 on success: without mismatch.
+ Reutrn 1 on error. */
+
+int
+gcov_profile_merge (struct gcov_info *tgt_profile, struct gcov_info *src_profile,
+ int w1, int w2)
+{
+ struct gcov_info *gi_ptr;
+ struct gcov_info **tgt_infos;
+ struct gcov_info *tgt_tail;
+ struct gcov_info **in_src_not_tgt;
+ unsigned tgt_cnt = 0, src_cnt = 0;
+ unsigned unmatch_info_cnt = 0;
+ unsigned int i;
+
+ for (gi_ptr = tgt_profile; gi_ptr; gi_ptr = gi_ptr->next)
+ tgt_cnt++;
+ for (gi_ptr = src_profile; gi_ptr; gi_ptr = gi_ptr->next)
+ src_cnt++;
+ tgt_infos = (struct gcov_info **) xmalloc (sizeof (struct gcov_info *)
+ * tgt_cnt);
+ gcc_assert (tgt_infos);
+ in_src_not_tgt = (struct gcov_info **) xmalloc (sizeof (struct gcov_info *)
+ * src_cnt);
+ gcc_assert (in_src_not_tgt);
+
+ for (gi_ptr = tgt_profile, i = 0; gi_ptr; gi_ptr = gi_ptr->next, i++)
+ tgt_infos[i] = gi_ptr;
+
+ tgt_tail = tgt_infos[tgt_cnt - 1];
+
+ /* First pass on tgt_profile, we multiply w1 to all counters. */
+ if (w1 > 1)
+ {
+ for (i = 0; i < tgt_cnt; i++)
+ gcov_merge (tgt_infos[i], tgt_infos[i], w1-1);
+ }
+
+ /* Second pass, add src_profile to the tgt_profile. */
+ for (gi_ptr = src_profile; gi_ptr; gi_ptr = gi_ptr->next)
+ {
+ struct gcov_info *gi_ptr1;
+
+ gi_ptr1 = find_match_gcov_info (tgt_infos, tgt_cnt, gi_ptr);
+ if (gi_ptr1 == NULL)
+ {
+ in_src_not_tgt[unmatch_info_cnt++] = gi_ptr;
+ continue;
+ }
+ gcov_merge (gi_ptr1, gi_ptr, w2);
+ }
+
+ /* For modules in src but not in tgt. We adjust the counter and append. */
+ for (i = 0; i < unmatch_info_cnt; i++)
+ {
+ gi_ptr = in_src_not_tgt[i];
+ gcov_merge (gi_ptr, gi_ptr, w2 - 1);
+ tgt_tail->next = gi_ptr;
+ tgt_tail = gi_ptr;
+ }
+
+ return 0;
+}
+
+typedef gcov_type (*counter_op_fn) (gcov_type, void*, void*);
+
+/* Performing FN upon arc counters. */
+
+static void
+__gcov_add_counter_op (gcov_type *counters, unsigned n_counters,
+ counter_op_fn fn, void *data1, void *data2)
+{
+ for (; n_counters; counters++, n_counters--)
+ {
+ gcov_type val = *counters;
+ *counters = fn(val, data1, data2);
+ }
+}
+
+/* Performing FN upon ior counters. */
+
+static void
+__gcov_ior_counter_op (gcov_type *counters ATTRIBUTE_UNUSED,
+ unsigned n_counters ATTRIBUTE_UNUSED,
+ counter_op_fn fn ATTRIBUTE_UNUSED,
+ void *data1 ATTRIBUTE_UNUSED,
+ void *data2 ATTRIBUTE_UNUSED)
+{
+ /* Do nothing. */
+}
+
+/* Performing FN upon time-profile counters. */
+
+static void
+__gcov_time_profile_counter_op (gcov_type *counters, unsigned n_counters,
+ counter_op_fn fn, void *data1, void *data2)
+{
+ __gcov_add_counter_op (counters, n_counters, fn, data1, data2);
+}
+
+/* Performaing FN upon delta counters. */
+
+static void
+__gcov_delta_counter_op (gcov_type *counters, unsigned n_counters,
+ counter_op_fn fn, void *data1, void *data2)
+{
+ unsigned i, n_measures;
+
+ gcc_assert (!(n_counters % 4));
+ n_measures = n_counters / 4;
+ for (i = 0; i < n_measures; i++, counters += 4)
+ {
+ counters[2] = fn (counters[2], data1, data2);
+ counters[3] = fn (counters[3], data1, data2);
+ }
+}
+
+/* Performing FN upon single counters. */
+
+static void
+__gcov_single_counter_op (gcov_type *counters, unsigned n_counters,
+ counter_op_fn fn, void *data1, void *data2)
+{
+ unsigned i, n_measures;
+
+ gcc_assert (!(n_counters % 3));
+ n_measures = n_counters / 3;
+ for (i = 0; i < n_measures; i++, counters += 3)
+ {
+ counters[1] = fn (counters[1], data1, data2);
+ counters[2] = fn (counters[2], data1, data2);
+ }
+}
+
+/* Scaling the counter value V by multiplying *(float*) DATA1. */
+
+static gcov_type
+fp_scale (gcov_type v, void *data1, void *data2 ATTRIBUTE_UNUSED)
+{
+ float f = *(float *) data1;
+ return (gcov_type) (v * f);
+}
+
+/* Scaling the counter value V by multiplying DATA2/DATA1. */
+
+static gcov_type
+int_scale (gcov_type v, void *data1, void *data2)
+{
+ int n = *(int *) data1;
+ int d = *(int *) data2;
+ return (gcov_type) ( RDIV (v,d) * n);
+}
+
+/* Type of function used to process counters. */
+typedef void (*gcov_counter_fn) (gcov_type *, gcov_unsigned_t,
+ counter_op_fn, void *, void *);
+
+/* Function array to process profile counters. */
+#undef DEF_GCOV_COUNTER
+#define DEF_GCOV_COUNTER(COUNTER, NAME, FN_TYPE) \
+ __gcov ## FN_TYPE ## _counter_op,
+static gcov_counter_fn ctr_functions[GCOV_COUNTERS] = {
+#include "gcov-counter.def"
+};
+
+/* Driver for scaling profile counters. */
+
+int
+gcov_profile_scale (struct gcov_info *profile, float scale_factor, int n, int d)
+{
+ struct gcov_info *gi_ptr;
+ unsigned f_ix;
+
+ if (verbose)
+ fprintf (stdout, "scale_factor is %f or %d/%d\n", scale_factor, n, d);
+
+ /* Scaling the counters. */
+ for (gi_ptr = profile; gi_ptr; gi_ptr = gi_ptr->next)
+ for (f_ix = 0; f_ix < gi_ptr->n_functions; f_ix++)
+ {
+ unsigned t_ix;
+ const struct gcov_fn_info *gfi_ptr = gi_ptr->functions[f_ix];
+ const struct gcov_ctr_info *ci_ptr;
+
+ if (!gfi_ptr || gfi_ptr->key != gi_ptr)
+ continue;
+
+ ci_ptr = gfi_ptr->ctrs;
+ for (t_ix = 0; t_ix != GCOV_COUNTERS; t_ix++)
+ {
+ gcov_merge_fn merge = gi_ptr->merge[t_ix];
+
+ if (!merge)
+ continue;
+ if (d == 0)
+ (*ctr_functions[t_ix]) (ci_ptr->values, ci_ptr->num,
+ fp_scale, &scale_factor, NULL);
+ else
+ (*ctr_functions[t_ix]) (ci_ptr->values, ci_ptr->num,
+ int_scale, &n, &d);
+ ci_ptr++;
+ }
+ }
+
+ return 0;
+}
+
+/* Driver to normalize profile counters. */
+
+int
+gcov_profile_normalize (struct gcov_info *profile, gcov_type max_val)
+{
+ struct gcov_info *gi_ptr;
+ gcov_type curr_max_val = 0;
+ unsigned f_ix;
+ unsigned int i;
+ float scale_factor;
+
+ /* Find the largest count value. */
+ for (gi_ptr = profile; gi_ptr; gi_ptr = gi_ptr->next)
+ for (f_ix = 0; f_ix < gi_ptr->n_functions; f_ix++)
+ {
+ unsigned t_ix;
+ const struct gcov_fn_info *gfi_ptr = gi_ptr->functions[f_ix];
+ const struct gcov_ctr_info *ci_ptr;
+
+ if (!gfi_ptr || gfi_ptr->key != gi_ptr)
+ continue;
+
+ ci_ptr = gfi_ptr->ctrs;
+ for (t_ix = 0; t_ix < 1; t_ix++)
+ {
+ for (i = 0; i < ci_ptr->num; i++)
+ if (ci_ptr->values[i] > curr_max_val)
+ curr_max_val = ci_ptr->values[i];
+ ci_ptr++;
+ }
+ }
+
+ scale_factor = (float)max_val / curr_max_val;
+ if (verbose)
+ fprintf (stdout, "max_val is %lld\n", (long long) curr_max_val);
+
+ return gcov_profile_scale (profile, scale_factor, 0, 0);
+}
===================================================================
@@ -33,6 +33,10 @@
#define xcalloc calloc
#endif
+#ifndef IN_GCOV_TOOL
+/* About the target. */
+/* This path will be used by libgcov runtime. */
+
#include "tconfig.h"
#include "tsystem.h"
#include "coretypes.h"
@@ -79,6 +83,60 @@ typedef unsigned gcov_type_unsigned __attribute__
#define GCOV_LOCKED 0
#endif
+/* "Counts" stored in gcda files can be a real counter value, or
+ an target address. When differentiate these two types because
+ when manipulating counts, we should only change real counter values,
+ rather target addresses.
+ Macro for Reading count values in libgcov runtime:
+ we read from gcda files. */
+#define GCOV_GET_COUNTER (gcov_read_counter ())
+#define GCOV_GET_COUNTER_TARGET (gcov_read_counter ())
+
+#else /* IN_GCOV_TOOL */
+/* About the host. */
+/* This path will be compiled for the host and linked into
+ gcov-tool binary. */
+
+#include "config.h"
+#include "system.h"
+#include "coretypes.h"
+#include "tm.h"
+
+typedef unsigned gcov_unsigned_t;
+typedef unsigned gcov_position_t;
+/* gcov_type is typedef'd elsewhere for the compiler */
+#if defined (HOST_HAS_F_SETLKW)
+#define GCOV_LOCKED 1
+#else
+#define GCOV_LOCKED 0
+#endif
+
+/* Some Macros specific to gcov-tool. */
+
+#define L_gcov 1
+#define L_gcov_merge_add 1
+#define L_gcov_merge_single 1
+#define L_gcov_merge_delta 1
+#define L_gcov_merge_ior 1
+#define L_gcov_merge_time_profile 1
+
+/* Rerfer the comment to same macro above. This version is for gcov-tool.
+ We read the value from memory and multiply it by the merge weight.
+ For target value, we do NOT multiply the weight. */
+
+#define GCOV_GET_COUNTER (gcov_read_counter_mem () * gcov_get_merge_weight ())
+#define GCOV_GET_COUNTER_TARGET (gcov_read_counter_mem ())
+
+/* Make certian internal functions/variables in libgcov available for
+ gcov-tool access. */
+#define GCOV_TOOL_LINKAGE
+
+extern gcov_type gcov_read_counter_mem();
+extern unsigned gcov_get_merge_weight();
+
+
+#endif /* !IN_GCOV_TOOL */
+
#if defined(inhibit_libc)
#define IN_LIBGCOV (-1)
#else
@@ -159,8 +217,13 @@ struct gcov_info
unused) */
unsigned n_functions; /* number of functions */
+
+#ifndef IN_GCOV_TOOL
const struct gcov_fn_info *const *functions; /* pointer to pointers
- to function information */
+ to function information */
+#else
+ const struct gcov_fn_info **functions;
+#endif /* !IN_GCOV_TOOL */
};
/* Register a new object file module. */