2015-05-19 Christophe Lyon <christophe.lyon@linaro.org>
[official-gcc.git] / gcc / gcov-tool.c
blobb2a4583d43bdcf14a303c121c92663be302b71ce
1 /* Gcc offline profile processing tool support. */
2 /* Copyright (C) 2014-2015 Free Software Foundation, Inc.
3 Contributed by Rong Xu <xur@google.com>.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
10 version.
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15 for more details.
17 Under Section 7 of GPL version 3, you are granted additional
18 permissions described in the GCC Runtime Library Exception, version
19 3.1, as published by the Free Software Foundation.
21 You should have received a copy of the GNU General Public License and
22 a copy of the GCC Runtime Library Exception along with this program;
23 see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
24 <http://www.gnu.org/licenses/>. */
26 #include "config.h"
27 #include "system.h"
28 #include "coretypes.h"
29 #include "tm.h"
30 #include "intl.h"
31 #include "diagnostic.h"
32 #include "version.h"
33 #include "gcov-io.h"
34 #include <stdlib.h>
35 #include <stdio.h>
36 #include <sys/stat.h>
37 #include <unistd.h>
38 #if HAVE_FTW_H
39 #include <ftw.h>
40 #endif
41 #include <getopt.h>
43 extern int gcov_profile_merge (struct gcov_info*, struct gcov_info*, int, int);
44 extern int gcov_profile_overlap (struct gcov_info*, struct gcov_info*);
45 extern int gcov_profile_normalize (struct gcov_info*, gcov_type);
46 extern int gcov_profile_scale (struct gcov_info*, float, int, int);
47 extern struct gcov_info* gcov_read_profile_dir (const char*, int);
48 extern void gcov_do_dump (struct gcov_info *, int);
49 extern void gcov_set_verbose (void);
51 /* Set to verbose output mode. */
52 static bool verbose;
54 #if HAVE_FTW_H
56 /* Remove file NAME if it has a gcda suffix. */
58 static int
59 unlink_gcda_file (const char *name,
60 const struct stat *status ATTRIBUTE_UNUSED,
61 int type ATTRIBUTE_UNUSED,
62 struct FTW *ftwbuf ATTRIBUTE_UNUSED)
64 int ret = 0;
65 int len = strlen (name);
66 int len1 = strlen (GCOV_DATA_SUFFIX);
68 if (len > len1 && !strncmp (len -len1 + name, GCOV_DATA_SUFFIX, len1))
69 ret = remove (name);
71 if (ret)
72 fatal_error (input_location, "error in removing %s\n", name);
74 return ret;
76 #endif
78 /* Remove the gcda files in PATH recursively. */
80 static int
81 unlink_profile_dir (const char *path ATTRIBUTE_UNUSED)
83 #if HAVE_FTW_H
84 return nftw(path, unlink_gcda_file, 64, FTW_DEPTH | FTW_PHYS);
85 #else
86 return -1;
87 #endif
90 /* Output GCOV_INFO lists PROFILE to directory OUT. Note that
91 we will remove all the gcda files in OUT. */
93 static void
94 gcov_output_files (const char *out, struct gcov_info *profile)
96 char *pwd;
97 int ret;
99 /* Try to make directory if it doesn't already exist. */
100 if (access (out, F_OK) == -1)
102 if (mkdir (out, S_IRWXU | S_IRWXG | S_IRWXO) == -1 && errno != EEXIST)
103 fatal_error (input_location, "Cannot make directory %s", out);
104 } else
105 unlink_profile_dir (out);
107 /* Output new profile. */
108 pwd = getcwd (NULL, 0);
110 if (pwd == NULL)
111 fatal_error (input_location, "Cannot get current directory name");
113 ret = chdir (out);
114 if (ret)
115 fatal_error (input_location, "Cannot change directory to %s", out);
117 gcov_do_dump (profile, 0);
119 ret = chdir (pwd);
120 if (ret)
121 fatal_error (input_location, "Cannot change directory to %s", pwd);
123 free (pwd);
126 /* Merging profile D1 and D2 with weight as W1 and W2, respectively.
127 The result profile is written to directory OUT.
128 Return 0 on success. */
130 static int
131 profile_merge (const char *d1, const char *d2, const char *out, int w1, int w2)
133 struct gcov_info *d1_profile;
134 struct gcov_info *d2_profile;
135 int ret;
137 d1_profile = gcov_read_profile_dir (d1, 0);
138 if (!d1_profile)
139 return 1;
141 if (d2)
143 d2_profile = gcov_read_profile_dir (d2, 0);
144 if (!d2_profile)
145 return 1;
147 /* The actual merge: we overwrite to d1_profile. */
148 ret = gcov_profile_merge (d1_profile, d2_profile, w1, w2);
150 if (ret)
151 return ret;
154 gcov_output_files (out, d1_profile);
156 return 0;
159 /* Usage message for profile merge. */
161 static void
162 print_merge_usage_message (int error_p)
164 FILE *file = error_p ? stderr : stdout;
166 fnotice (file, " merge [options] <dir1> <dir2> Merge coverage file contents\n");
167 fnotice (file, " -v, --verbose Verbose mode\n");
168 fnotice (file, " -o, --output <dir> Output directory\n");
169 fnotice (file, " -w, --weight <w1,w2> Set weights (float point values)\n");
172 static const struct option merge_options[] =
174 { "verbose", no_argument, NULL, 'v' },
175 { "output", required_argument, NULL, 'o' },
176 { "weight", required_argument, NULL, 'w' },
177 { 0, 0, 0, 0 }
180 /* Print merge usage and exit. */
182 static void
183 merge_usage (void)
185 fnotice (stderr, "Merge subcomand usage:");
186 print_merge_usage_message (true);
187 exit (FATAL_EXIT_CODE);
190 /* Driver for profile merge sub-command. */
192 static int
193 do_merge (int argc, char **argv)
195 int opt;
196 const char *output_dir = 0;
197 int w1 = 1, w2 = 1;
199 optind = 0;
200 while ((opt = getopt_long (argc, argv, "vo:w:", merge_options, NULL)) != -1)
202 switch (opt)
204 case 'v':
205 verbose = true;
206 gcov_set_verbose ();
207 break;
208 case 'o':
209 output_dir = optarg;
210 break;
211 case 'w':
212 sscanf (optarg, "%d,%d", &w1, &w2);
213 if (w1 < 0 || w2 < 0)
214 fatal_error (input_location, "weights need to be non-negative\n");
215 break;
216 default:
217 merge_usage ();
221 if (output_dir == NULL)
222 output_dir = "merged_profile";
224 if (argc - optind != 2)
225 merge_usage ();
227 return profile_merge (argv[optind], argv[optind+1], output_dir, w1, w2);
230 /* If N_VAL is no-zero, normalize the profile by setting the largest counter
231 counter value to N_VAL and scale others counters proportionally.
232 Otherwise, multiply the all counters by SCALE. */
234 static int
235 profile_rewrite (const char *d1, const char *out, long long n_val,
236 float scale, int n, int d)
238 struct gcov_info * d1_profile;
240 d1_profile = gcov_read_profile_dir (d1, 0);
241 if (!d1_profile)
242 return 1;
244 if (n_val)
245 gcov_profile_normalize (d1_profile, (gcov_type) n_val);
246 else
247 gcov_profile_scale (d1_profile, scale, n, d);
249 gcov_output_files (out, d1_profile);
250 return 0;
253 /* Usage function for profile rewrite. */
255 static void
256 print_rewrite_usage_message (int error_p)
258 FILE *file = error_p ? stderr : stdout;
260 fnotice (file, " rewrite [options] <dir> Rewrite coverage file contents\n");
261 fnotice (file, " -v, --verbose Verbose mode\n");
262 fnotice (file, " -o, --output <dir> Output directory\n");
263 fnotice (file, " -s, --scale <float or simple-frac> Scale the profile counters\n");
264 fnotice (file, " -n, --normalize <long long> Normalize the profile\n");
267 static const struct option rewrite_options[] =
269 { "verbose", no_argument, NULL, 'v' },
270 { "output", required_argument, NULL, 'o' },
271 { "scale", required_argument, NULL, 's' },
272 { "normalize", required_argument, NULL, 'n' },
273 { 0, 0, 0, 0 }
276 /* Print profile rewrite usage and exit. */
278 static void
279 rewrite_usage (void)
281 fnotice (stderr, "Rewrite subcommand usage:");
282 print_rewrite_usage_message (true);
283 exit (FATAL_EXIT_CODE);
286 /* Driver for profile rewrite sub-command. */
288 static int
289 do_rewrite (int argc, char **argv)
291 int opt;
292 int ret;
293 const char *output_dir = 0;
294 #ifdef HAVE_LONG_LONG
295 long long normalize_val = 0;
296 #else
297 int64_t normalize_val = 0;
298 #endif
299 float scale = 0.0;
300 int numerator = 1;
301 int denominator = 1;
302 int do_scaling = 0;
304 optind = 0;
305 while ((opt = getopt_long (argc, argv, "vo:s:n:", rewrite_options, NULL)) != -1)
307 switch (opt)
309 case 'v':
310 verbose = true;
311 gcov_set_verbose ();
312 break;
313 case 'o':
314 output_dir = optarg;
315 break;
316 case 'n':
317 if (!do_scaling)
318 #if defined(HAVE_LONG_LONG)
319 normalize_val = strtoll (optarg, (char **)NULL, 10);
320 #elif defined(INT64_T_IS_LONG)
321 normalize_val = strtol (optarg, (char **)NULL, 10);
322 #else
323 sscanf (optarg, "%" SCNd64, &normalize_val);
324 #endif
325 else
326 fnotice (stderr, "scaling cannot co-exist with normalization,"
327 " skipping\n");
328 break;
329 case 's':
330 ret = 0;
331 do_scaling = 1;
332 if (strstr (optarg, "/"))
334 ret = sscanf (optarg, "%d/%d", &numerator, &denominator);
335 if (ret == 2)
337 if (numerator < 0 || denominator <= 0)
339 fnotice (stderr, "incorrect format in scaling, using 1/1\n");
340 denominator = 1;
341 numerator = 1;
345 if (ret != 2)
347 ret = sscanf (optarg, "%f", &scale);
348 if (ret != 1)
349 fnotice (stderr, "incorrect format in scaling, using 1/1\n");
350 else
351 denominator = 0;
354 if (scale < 0.0)
355 fatal_error (input_location, "scale needs to be non-negative\n");
357 if (normalize_val != 0)
359 fnotice (stderr, "normalization cannot co-exist with scaling\n");
360 normalize_val = 0;
362 break;
363 default:
364 rewrite_usage ();
368 if (output_dir == NULL)
369 output_dir = "rewrite_profile";
371 if (argc - optind == 1)
373 if (denominator > 0)
374 ret = profile_rewrite (argv[optind], output_dir, 0, 0.0, numerator, denominator);
375 else
376 ret = profile_rewrite (argv[optind], output_dir, normalize_val, scale, 0, 0);
378 else
379 rewrite_usage ();
381 return ret;
384 /* Driver function to computer the overlap score b/w profile D1 and D2.
385 Return 1 on error and 0 if OK. */
387 static int
388 profile_overlap (const char *d1, const char *d2)
390 struct gcov_info *d1_profile;
391 struct gcov_info *d2_profile;
393 d1_profile = gcov_read_profile_dir (d1, 0);
394 if (!d1_profile)
395 return 1;
397 if (d2)
399 d2_profile = gcov_read_profile_dir (d2, 0);
400 if (!d2_profile)
401 return 1;
403 return gcov_profile_overlap (d1_profile, d2_profile);
406 return 1;
409 /* Usage message for profile overlap. */
411 static void
412 print_overlap_usage_message (int error_p)
414 FILE *file = error_p ? stderr : stdout;
416 fnotice (file, " overlap [options] <dir1> <dir2> Compute the overlap of two profiles\n");
417 fnotice (file, " -v, --verbose Verbose mode\n");
418 fnotice (file, " -h, --hotonly Only print info for hot objects/functions\n");
419 fnotice (file, " -f, --function Print function level info\n");
420 fnotice (file, " -F, --fullname Print full filename\n");
421 fnotice (file, " -o, --object Print object level info\n");
422 fnotice (file, " -t <float>, --hot_threshold <float> Set the threshold for hotness\n");
426 static const struct option overlap_options[] =
428 { "verbose", no_argument, NULL, 'v' },
429 { "function", no_argument, NULL, 'f' },
430 { "fullname", no_argument, NULL, 'F' },
431 { "object", no_argument, NULL, 'o' },
432 { "hotonly", no_argument, NULL, 'h' },
433 { "hot_threshold", required_argument, NULL, 't' },
434 { 0, 0, 0, 0 }
437 /* Print overlap usage and exit. */
439 static void
440 overlap_usage (void)
442 fnotice (stderr, "Overlap subcomand usage:");
443 print_overlap_usage_message (true);
444 exit (FATAL_EXIT_CODE);
447 int overlap_func_level;
448 int overlap_obj_level;
449 int overlap_hot_only;
450 int overlap_use_fullname;
451 double overlap_hot_threshold = 0.005;
453 /* Driver for profile overlap sub-command. */
455 static int
456 do_overlap (int argc, char **argv)
458 int opt;
459 int ret;
461 optind = 0;
462 while ((opt = getopt_long (argc, argv, "vfFoht:", overlap_options, NULL)) != -1)
464 switch (opt)
466 case 'v':
467 verbose = true;
468 gcov_set_verbose ();
469 break;
470 case 'f':
471 overlap_func_level = 1;
472 break;
473 case 'F':
474 overlap_use_fullname = 1;
475 break;
476 case 'o':
477 overlap_obj_level = 1;
478 break;
479 case 'h':
480 overlap_hot_only = 1;
481 break;
482 case 't':
483 overlap_hot_threshold = atof (optarg);
484 break;
485 default:
486 overlap_usage ();
490 if (argc - optind == 2)
491 ret = profile_overlap (argv[optind], argv[optind+1]);
492 else
493 overlap_usage ();
495 return ret;
499 /* Print a usage message and exit. If ERROR_P is nonzero, this is an error,
500 otherwise the output of --help. */
502 static void
503 print_usage (int error_p)
505 FILE *file = error_p ? stderr : stdout;
506 int status = error_p ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE;
508 fnotice (file, "Usage: %s [OPTION]... SUB_COMMAND [OPTION]...\n\n", progname);
509 fnotice (file, "Offline tool to handle gcda counts\n\n");
510 fnotice (file, " -h, --help Print this help, then exit\n");
511 fnotice (file, " -v, --version Print version number, then exit\n");
512 print_merge_usage_message (error_p);
513 print_rewrite_usage_message (error_p);
514 print_overlap_usage_message (error_p);
515 fnotice (file, "\nFor bug reporting instructions, please see:\n%s.\n",
516 bug_report_url);
517 exit (status);
520 /* Print version information and exit. */
522 static void
523 print_version (void)
525 fnotice (stdout, "%s %s%s\n", progname, pkgversion_string, version_string);
526 fnotice (stdout, "Copyright %s 2014-2015 Free Software Foundation, Inc.\n",
527 _("(C)"));
528 fnotice (stdout,
529 _("This is free software; see the source for copying conditions.\n"
530 "There is NO warranty; not even for MERCHANTABILITY or \n"
531 "FITNESS FOR A PARTICULAR PURPOSE.\n\n"));
532 exit (SUCCESS_EXIT_CODE);
535 static const struct option options[] =
537 { "help", no_argument, NULL, 'h' },
538 { "version", no_argument, NULL, 'v' },
539 { 0, 0, 0, 0 }
542 /* Process args, return index to first non-arg. */
544 static int
545 process_args (int argc, char **argv)
547 int opt;
549 while ((opt = getopt_long (argc, argv, "+hv", options, NULL)) != -1)
551 switch (opt)
553 case 'h':
554 print_usage (false);
555 /* Print_usage will exit. */
556 case 'v':
557 print_version ();
558 /* Print_version will exit. */
559 default:
560 print_usage (true);
561 /* Print_usage will exit. */
565 return optind;
568 /* Main function for gcov-tool. */
571 main (int argc, char **argv)
573 const char *p;
574 const char *sub_command;
576 p = argv[0] + strlen (argv[0]);
577 while (p != argv[0] && !IS_DIR_SEPARATOR (p[-1]))
578 --p;
579 progname = p;
581 xmalloc_set_program_name (progname);
583 /* Unlock the stdio streams. */
584 unlock_std_streams ();
586 gcc_init_libintl ();
588 diagnostic_initialize (global_dc, 0);
590 /* Handle response files. */
591 expandargv (&argc, &argv);
593 process_args (argc, argv);
594 if (optind >= argc)
595 print_usage (true);
597 sub_command = argv[optind];
599 if (!strcmp (sub_command, "merge"))
600 return do_merge (argc - optind, argv + optind);
601 else if (!strcmp (sub_command, "rewrite"))
602 return do_rewrite (argc - optind, argv + optind);
603 else if (!strcmp (sub_command, "overlap"))
604 return do_overlap (argc - optind, argv + optind);
606 print_usage (true);