libgo: add misc/cgo files
[official-gcc.git] / gcc / profile.c
blob51ca248f5adcb7aa4601ade7d80fa4ee957230c0
1 /* Calculate branch probabilities, and basic block execution counts.
2 Copyright (C) 1990-2017 Free Software Foundation, Inc.
3 Contributed by James E. Wilson, UC Berkeley/Cygnus Support;
4 based on some ideas from Dain Samples of UC Berkeley.
5 Further mangling by Bob Manson, Cygnus Support.
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it under
10 the terms of the GNU General Public License as published by the Free
11 Software Foundation; either version 3, or (at your option) any later
12 version.
14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
23 /* Generate basic block profile instrumentation and auxiliary files.
24 Profile generation is optimized, so that not all arcs in the basic
25 block graph need instrumenting. First, the BB graph is closed with
26 one entry (function start), and one exit (function exit). Any
27 ABNORMAL_EDGE cannot be instrumented (because there is no control
28 path to place the code). We close the graph by inserting fake
29 EDGE_FAKE edges to the EXIT_BLOCK, from the sources of abnormal
30 edges that do not go to the exit_block. We ignore such abnormal
31 edges. Naturally these fake edges are never directly traversed,
32 and so *cannot* be directly instrumented. Some other graph
33 massaging is done. To optimize the instrumentation we generate the
34 BB minimal span tree, only edges that are not on the span tree
35 (plus the entry point) need instrumenting. From that information
36 all other edge counts can be deduced. By construction all fake
37 edges must be on the spanning tree. We also attempt to place
38 EDGE_CRITICAL edges on the spanning tree.
40 The auxiliary files generated are <dumpbase>.gcno (at compile time)
41 and <dumpbase>.gcda (at run time). The format is
42 described in full in gcov-io.h. */
44 /* ??? Register allocation should use basic block execution counts to
45 give preference to the most commonly executed blocks. */
47 /* ??? Should calculate branch probabilities before instrumenting code, since
48 then we can use arc counts to help decide which arcs to instrument. */
50 #include "config.h"
51 #include "system.h"
52 #include "coretypes.h"
53 #include "backend.h"
54 #include "rtl.h"
55 #include "tree.h"
56 #include "gimple.h"
57 #include "cfghooks.h"
58 #include "cgraph.h"
59 #include "coverage.h"
60 #include "diagnostic-core.h"
61 #include "cfganal.h"
62 #include "value-prof.h"
63 #include "gimple-iterator.h"
64 #include "tree-cfg.h"
65 #include "dumpfile.h"
66 #include "cfgloop.h"
68 #include "profile.h"
70 /* Map from BBs/edges to gcov counters. */
71 vec<gcov_type> bb_gcov_counts;
72 hash_map<edge,gcov_type> *edge_gcov_counts;
74 struct bb_profile_info {
75 unsigned int count_valid : 1;
77 /* Number of successor and predecessor edges. */
78 gcov_type succ_count;
79 gcov_type pred_count;
82 #define BB_INFO(b) ((struct bb_profile_info *) (b)->aux)
85 /* Counter summary from the last set of coverage counts read. */
87 const struct gcov_ctr_summary *profile_info;
89 /* Counter working set information computed from the current counter
90 summary. Not initialized unless profile_info summary is non-NULL. */
91 static gcov_working_set_t gcov_working_sets[NUM_GCOV_WORKING_SETS];
93 /* Collect statistics on the performance of this pass for the entire source
94 file. */
96 static int total_num_blocks;
97 static int total_num_edges;
98 static int total_num_edges_ignored;
99 static int total_num_edges_instrumented;
100 static int total_num_blocks_created;
101 static int total_num_passes;
102 static int total_num_times_called;
103 static int total_hist_br_prob[20];
104 static int total_num_branches;
106 /* Helper function to update gcov_working_sets. */
108 void add_working_set (gcov_working_set_t *set) {
109 int i = 0;
110 for (; i < NUM_GCOV_WORKING_SETS; i++)
111 gcov_working_sets[i] = set[i];
114 /* Forward declarations. */
115 static void find_spanning_tree (struct edge_list *);
117 /* Add edge instrumentation code to the entire insn chain.
119 F is the first insn of the chain.
120 NUM_BLOCKS is the number of basic blocks found in F. */
122 static unsigned
123 instrument_edges (struct edge_list *el)
125 unsigned num_instr_edges = 0;
126 int num_edges = NUM_EDGES (el);
127 basic_block bb;
129 FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR_FOR_FN (cfun), NULL, next_bb)
131 edge e;
132 edge_iterator ei;
134 FOR_EACH_EDGE (e, ei, bb->succs)
136 struct edge_profile_info *inf = EDGE_INFO (e);
138 if (!inf->ignore && !inf->on_tree)
140 gcc_assert (!(e->flags & EDGE_ABNORMAL));
141 if (dump_file)
142 fprintf (dump_file, "Edge %d to %d instrumented%s\n",
143 e->src->index, e->dest->index,
144 EDGE_CRITICAL_P (e) ? " (and split)" : "");
145 gimple_gen_edge_profiler (num_instr_edges++, e);
150 total_num_blocks_created += num_edges;
151 if (dump_file)
152 fprintf (dump_file, "%d edges instrumented\n", num_instr_edges);
153 return num_instr_edges;
156 /* Add code to measure histograms for values in list VALUES. */
157 static void
158 instrument_values (histogram_values values)
160 unsigned i;
162 /* Emit code to generate the histograms before the insns. */
164 for (i = 0; i < values.length (); i++)
166 histogram_value hist = values[i];
167 unsigned t = COUNTER_FOR_HIST_TYPE (hist->type);
169 if (!coverage_counter_alloc (t, hist->n_counters))
170 continue;
172 switch (hist->type)
174 case HIST_TYPE_INTERVAL:
175 gimple_gen_interval_profiler (hist, t, 0);
176 break;
178 case HIST_TYPE_POW2:
179 gimple_gen_pow2_profiler (hist, t, 0);
180 break;
182 case HIST_TYPE_SINGLE_VALUE:
183 gimple_gen_one_value_profiler (hist, t, 0);
184 break;
186 case HIST_TYPE_INDIR_CALL:
187 case HIST_TYPE_INDIR_CALL_TOPN:
188 gimple_gen_ic_profiler (hist, t, 0);
189 break;
191 case HIST_TYPE_AVERAGE:
192 gimple_gen_average_profiler (hist, t, 0);
193 break;
195 case HIST_TYPE_IOR:
196 gimple_gen_ior_profiler (hist, t, 0);
197 break;
199 case HIST_TYPE_TIME_PROFILE:
200 gimple_gen_time_profiler (t, 0);
201 break;
203 default:
204 gcc_unreachable ();
210 /* Fill the working set information into the profile_info structure. */
212 void
213 get_working_sets (void)
215 unsigned ws_ix, pctinc, pct;
216 gcov_working_set_t *ws_info;
218 if (!profile_info)
219 return;
221 compute_working_sets (profile_info, gcov_working_sets);
223 if (dump_file)
225 fprintf (dump_file, "Counter working sets:\n");
226 /* Multiply the percentage by 100 to avoid float. */
227 pctinc = 100 * 100 / NUM_GCOV_WORKING_SETS;
228 for (ws_ix = 0, pct = pctinc; ws_ix < NUM_GCOV_WORKING_SETS;
229 ws_ix++, pct += pctinc)
231 if (ws_ix == NUM_GCOV_WORKING_SETS - 1)
232 pct = 9990;
233 ws_info = &gcov_working_sets[ws_ix];
234 /* Print out the percentage using int arithmatic to avoid float. */
235 fprintf (dump_file, "\t\t%u.%02u%%: num counts=%u, min counter="
236 "%" PRId64 "\n",
237 pct / 100, pct - (pct / 100 * 100),
238 ws_info->num_counters,
239 (int64_t)ws_info->min_counter);
244 /* Given a the desired percentage of the full profile (sum_all from the
245 summary), multiplied by 10 to avoid float in PCT_TIMES_10, returns
246 the corresponding working set information. If an exact match for
247 the percentage isn't found, the closest value is used. */
249 gcov_working_set_t *
250 find_working_set (unsigned pct_times_10)
252 unsigned i;
253 if (!profile_info)
254 return NULL;
255 gcc_assert (pct_times_10 <= 1000);
256 if (pct_times_10 >= 999)
257 return &gcov_working_sets[NUM_GCOV_WORKING_SETS - 1];
258 i = pct_times_10 * NUM_GCOV_WORKING_SETS / 1000;
259 if (!i)
260 return &gcov_working_sets[0];
261 return &gcov_working_sets[i - 1];
264 /* Computes hybrid profile for all matching entries in da_file.
266 CFG_CHECKSUM is the precomputed checksum for the CFG. */
268 static gcov_type *
269 get_exec_counts (unsigned cfg_checksum, unsigned lineno_checksum)
271 unsigned num_edges = 0;
272 basic_block bb;
273 gcov_type *counts;
275 /* Count the edges to be (possibly) instrumented. */
276 FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR_FOR_FN (cfun), NULL, next_bb)
278 edge e;
279 edge_iterator ei;
281 FOR_EACH_EDGE (e, ei, bb->succs)
282 if (!EDGE_INFO (e)->ignore && !EDGE_INFO (e)->on_tree)
283 num_edges++;
286 counts = get_coverage_counts (GCOV_COUNTER_ARCS, num_edges, cfg_checksum,
287 lineno_checksum, &profile_info);
288 if (!counts)
289 return NULL;
291 get_working_sets ();
293 if (dump_file && profile_info)
294 fprintf (dump_file, "Merged %u profiles with maximal count %u.\n",
295 profile_info->runs, (unsigned) profile_info->sum_max);
297 return counts;
301 static bool
302 is_edge_inconsistent (vec<edge, va_gc> *edges)
304 edge e;
305 edge_iterator ei;
306 FOR_EACH_EDGE (e, ei, edges)
308 if (!EDGE_INFO (e)->ignore)
310 if (edge_gcov_count (e) < 0
311 && (!(e->flags & EDGE_FAKE)
312 || !block_ends_with_call_p (e->src)))
314 if (dump_file)
316 fprintf (dump_file,
317 "Edge %i->%i is inconsistent, count%" PRId64,
318 e->src->index, e->dest->index, edge_gcov_count (e));
319 dump_bb (dump_file, e->src, 0, TDF_DETAILS);
320 dump_bb (dump_file, e->dest, 0, TDF_DETAILS);
322 return true;
326 return false;
329 static void
330 correct_negative_edge_counts (void)
332 basic_block bb;
333 edge e;
334 edge_iterator ei;
336 FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR_FOR_FN (cfun), NULL, next_bb)
338 FOR_EACH_EDGE (e, ei, bb->succs)
340 if (edge_gcov_count (e) < 0)
341 edge_gcov_count (e) = 0;
346 /* Check consistency.
347 Return true if inconsistency is found. */
348 static bool
349 is_inconsistent (void)
351 basic_block bb;
352 bool inconsistent = false;
353 FOR_EACH_BB_FN (bb, cfun)
355 inconsistent |= is_edge_inconsistent (bb->preds);
356 if (!dump_file && inconsistent)
357 return true;
358 inconsistent |= is_edge_inconsistent (bb->succs);
359 if (!dump_file && inconsistent)
360 return true;
361 if (bb_gcov_count (bb) < 0)
363 if (dump_file)
365 fprintf (dump_file, "BB %i count is negative "
366 "%" PRId64,
367 bb->index,
368 bb_gcov_count (bb));
369 dump_bb (dump_file, bb, 0, TDF_DETAILS);
371 inconsistent = true;
373 if (bb_gcov_count (bb) != sum_edge_counts (bb->preds))
375 if (dump_file)
377 fprintf (dump_file, "BB %i count does not match sum of incoming edges "
378 "%" PRId64" should be %" PRId64,
379 bb->index,
380 bb_gcov_count (bb),
381 sum_edge_counts (bb->preds));
382 dump_bb (dump_file, bb, 0, TDF_DETAILS);
384 inconsistent = true;
386 if (bb_gcov_count (bb) != sum_edge_counts (bb->succs) &&
387 ! (find_edge (bb, EXIT_BLOCK_PTR_FOR_FN (cfun)) != NULL
388 && block_ends_with_call_p (bb)))
390 if (dump_file)
392 fprintf (dump_file, "BB %i count does not match sum of outgoing edges "
393 "%" PRId64" should be %" PRId64,
394 bb->index,
395 bb_gcov_count (bb),
396 sum_edge_counts (bb->succs));
397 dump_bb (dump_file, bb, 0, TDF_DETAILS);
399 inconsistent = true;
401 if (!dump_file && inconsistent)
402 return true;
405 return inconsistent;
408 /* Set each basic block count to the sum of its outgoing edge counts */
409 static void
410 set_bb_counts (void)
412 basic_block bb;
413 FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR_FOR_FN (cfun), NULL, next_bb)
415 bb_gcov_count (bb) = sum_edge_counts (bb->succs);
416 gcc_assert (bb_gcov_count (bb) >= 0);
420 /* Reads profile data and returns total number of edge counts read */
421 static int
422 read_profile_edge_counts (gcov_type *exec_counts)
424 basic_block bb;
425 int num_edges = 0;
426 int exec_counts_pos = 0;
427 /* For each edge not on the spanning tree, set its execution count from
428 the .da file. */
429 /* The first count in the .da file is the number of times that the function
430 was entered. This is the exec_count for block zero. */
432 FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR_FOR_FN (cfun), NULL, next_bb)
434 edge e;
435 edge_iterator ei;
437 FOR_EACH_EDGE (e, ei, bb->succs)
438 if (!EDGE_INFO (e)->ignore && !EDGE_INFO (e)->on_tree)
440 num_edges++;
441 if (exec_counts)
443 edge_gcov_count (e) = exec_counts[exec_counts_pos++];
444 if (edge_gcov_count (e) > profile_info->sum_max)
446 if (flag_profile_correction)
448 static bool informed = 0;
449 if (dump_enabled_p () && !informed)
450 dump_printf_loc (MSG_NOTE, input_location,
451 "corrupted profile info: edge count"
452 " exceeds maximal count\n");
453 informed = 1;
455 else
456 error ("corrupted profile info: edge from %i to %i exceeds maximal count",
457 bb->index, e->dest->index);
460 else
461 edge_gcov_count (e) = 0;
463 EDGE_INFO (e)->count_valid = 1;
464 BB_INFO (bb)->succ_count--;
465 BB_INFO (e->dest)->pred_count--;
466 if (dump_file)
468 fprintf (dump_file, "\nRead edge from %i to %i, count:",
469 bb->index, e->dest->index);
470 fprintf (dump_file, "%" PRId64,
471 (int64_t) edge_gcov_count (e));
476 return num_edges;
479 #define OVERLAP_BASE 10000
481 /* Compare the static estimated profile to the actual profile, and
482 return the "degree of overlap" measure between them.
484 Degree of overlap is a number between 0 and OVERLAP_BASE. It is
485 the sum of each basic block's minimum relative weights between
486 two profiles. And overlap of OVERLAP_BASE means two profiles are
487 identical. */
489 static int
490 compute_frequency_overlap (void)
492 gcov_type count_total = 0, freq_total = 0;
493 int overlap = 0;
494 basic_block bb;
496 FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR_FOR_FN (cfun), NULL, next_bb)
498 count_total += bb_gcov_count (bb);
499 freq_total += bb->frequency;
502 if (count_total == 0 || freq_total == 0)
503 return 0;
505 FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR_FOR_FN (cfun), NULL, next_bb)
506 overlap += MIN (bb_gcov_count (bb) * OVERLAP_BASE / count_total,
507 bb->frequency * OVERLAP_BASE / freq_total);
509 return overlap;
512 /* Compute the branch probabilities for the various branches.
513 Annotate them accordingly.
515 CFG_CHECKSUM is the precomputed checksum for the CFG. */
517 static void
518 compute_branch_probabilities (unsigned cfg_checksum, unsigned lineno_checksum)
520 basic_block bb;
521 int i;
522 int num_edges = 0;
523 int changes;
524 int passes;
525 int hist_br_prob[20];
526 int num_branches;
527 gcov_type *exec_counts = get_exec_counts (cfg_checksum, lineno_checksum);
528 int inconsistent = 0;
530 /* Very simple sanity checks so we catch bugs in our profiling code. */
531 if (!profile_info)
532 return;
534 bb_gcov_counts.safe_grow_cleared (last_basic_block_for_fn (cfun));
535 edge_gcov_counts = new hash_map<edge,gcov_type>;
537 if (profile_info->sum_all < profile_info->sum_max)
539 error ("corrupted profile info: sum_all is smaller than sum_max");
540 exec_counts = NULL;
543 /* Attach extra info block to each bb. */
544 alloc_aux_for_blocks (sizeof (struct bb_profile_info));
545 FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR_FOR_FN (cfun), NULL, next_bb)
547 edge e;
548 edge_iterator ei;
550 FOR_EACH_EDGE (e, ei, bb->succs)
551 if (!EDGE_INFO (e)->ignore)
552 BB_INFO (bb)->succ_count++;
553 FOR_EACH_EDGE (e, ei, bb->preds)
554 if (!EDGE_INFO (e)->ignore)
555 BB_INFO (bb)->pred_count++;
558 /* Avoid predicting entry on exit nodes. */
559 BB_INFO (EXIT_BLOCK_PTR_FOR_FN (cfun))->succ_count = 2;
560 BB_INFO (ENTRY_BLOCK_PTR_FOR_FN (cfun))->pred_count = 2;
562 num_edges = read_profile_edge_counts (exec_counts);
564 if (dump_file)
565 fprintf (dump_file, "\n%d edge counts read\n", num_edges);
567 /* For every block in the file,
568 - if every exit/entrance edge has a known count, then set the block count
569 - if the block count is known, and every exit/entrance edge but one has
570 a known execution count, then set the count of the remaining edge
572 As edge counts are set, decrement the succ/pred count, but don't delete
573 the edge, that way we can easily tell when all edges are known, or only
574 one edge is unknown. */
576 /* The order that the basic blocks are iterated through is important.
577 Since the code that finds spanning trees starts with block 0, low numbered
578 edges are put on the spanning tree in preference to high numbered edges.
579 Hence, most instrumented edges are at the end. Graph solving works much
580 faster if we propagate numbers from the end to the start.
582 This takes an average of slightly more than 3 passes. */
584 changes = 1;
585 passes = 0;
586 while (changes)
588 passes++;
589 changes = 0;
590 FOR_BB_BETWEEN (bb, EXIT_BLOCK_PTR_FOR_FN (cfun), NULL, prev_bb)
592 struct bb_profile_info *bi = BB_INFO (bb);
593 if (! bi->count_valid)
595 if (bi->succ_count == 0)
597 edge e;
598 edge_iterator ei;
599 gcov_type total = 0;
601 FOR_EACH_EDGE (e, ei, bb->succs)
602 total += edge_gcov_count (e);
603 bb_gcov_count (bb) = total;
604 bi->count_valid = 1;
605 changes = 1;
607 else if (bi->pred_count == 0)
609 edge e;
610 edge_iterator ei;
611 gcov_type total = 0;
613 FOR_EACH_EDGE (e, ei, bb->preds)
614 total += edge_gcov_count (e);
615 bb_gcov_count (bb) = total;
616 bi->count_valid = 1;
617 changes = 1;
620 if (bi->count_valid)
622 if (bi->succ_count == 1)
624 edge e;
625 edge_iterator ei;
626 gcov_type total = 0;
628 /* One of the counts will be invalid, but it is zero,
629 so adding it in also doesn't hurt. */
630 FOR_EACH_EDGE (e, ei, bb->succs)
631 total += edge_gcov_count (e);
633 /* Search for the invalid edge, and set its count. */
634 FOR_EACH_EDGE (e, ei, bb->succs)
635 if (! EDGE_INFO (e)->count_valid && ! EDGE_INFO (e)->ignore)
636 break;
638 /* Calculate count for remaining edge by conservation. */
639 total = bb_gcov_count (bb) - total;
641 gcc_assert (e);
642 EDGE_INFO (e)->count_valid = 1;
643 edge_gcov_count (e) = total;
644 bi->succ_count--;
646 BB_INFO (e->dest)->pred_count--;
647 changes = 1;
649 if (bi->pred_count == 1)
651 edge e;
652 edge_iterator ei;
653 gcov_type total = 0;
655 /* One of the counts will be invalid, but it is zero,
656 so adding it in also doesn't hurt. */
657 FOR_EACH_EDGE (e, ei, bb->preds)
658 total += edge_gcov_count (e);
660 /* Search for the invalid edge, and set its count. */
661 FOR_EACH_EDGE (e, ei, bb->preds)
662 if (!EDGE_INFO (e)->count_valid && !EDGE_INFO (e)->ignore)
663 break;
665 /* Calculate count for remaining edge by conservation. */
666 total = bb_gcov_count (bb) - total + edge_gcov_count (e);
668 gcc_assert (e);
669 EDGE_INFO (e)->count_valid = 1;
670 edge_gcov_count (e) = total;
671 bi->pred_count--;
673 BB_INFO (e->src)->succ_count--;
674 changes = 1;
679 if (dump_file)
681 int overlap = compute_frequency_overlap ();
682 gimple_dump_cfg (dump_file, dump_flags);
683 fprintf (dump_file, "Static profile overlap: %d.%d%%\n",
684 overlap / (OVERLAP_BASE / 100),
685 overlap % (OVERLAP_BASE / 100));
688 total_num_passes += passes;
689 if (dump_file)
690 fprintf (dump_file, "Graph solving took %d passes.\n\n", passes);
692 /* If the graph has been correctly solved, every block will have a
693 succ and pred count of zero. */
694 FOR_EACH_BB_FN (bb, cfun)
696 gcc_assert (!BB_INFO (bb)->succ_count && !BB_INFO (bb)->pred_count);
699 /* Check for inconsistent basic block counts */
700 inconsistent = is_inconsistent ();
702 if (inconsistent)
704 if (flag_profile_correction)
706 /* Inconsistency detected. Make it flow-consistent. */
707 static int informed = 0;
708 if (dump_enabled_p () && informed == 0)
710 informed = 1;
711 dump_printf_loc (MSG_NOTE, input_location,
712 "correcting inconsistent profile data\n");
714 correct_negative_edge_counts ();
715 /* Set bb counts to the sum of the outgoing edge counts */
716 set_bb_counts ();
717 if (dump_file)
718 fprintf (dump_file, "\nCalling mcf_smooth_cfg\n");
719 mcf_smooth_cfg ();
721 else
722 error ("corrupted profile info: profile data is not flow-consistent");
725 /* For every edge, calculate its branch probability and add a reg_note
726 to the branch insn to indicate this. */
728 for (i = 0; i < 20; i++)
729 hist_br_prob[i] = 0;
730 num_branches = 0;
732 FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR_FOR_FN (cfun), NULL, next_bb)
734 edge e;
735 edge_iterator ei;
737 if (bb_gcov_count (bb) < 0)
739 error ("corrupted profile info: number of iterations for basic block %d thought to be %i",
740 bb->index, (int)bb_gcov_count (bb));
741 bb_gcov_count (bb) = 0;
743 FOR_EACH_EDGE (e, ei, bb->succs)
745 /* Function may return twice in the cased the called function is
746 setjmp or calls fork, but we can't represent this by extra
747 edge from the entry, since extra edge from the exit is
748 already present. We get negative frequency from the entry
749 point. */
750 if ((edge_gcov_count (e) < 0
751 && e->dest == EXIT_BLOCK_PTR_FOR_FN (cfun))
752 || (edge_gcov_count (e) > bb_gcov_count (bb)
753 && e->dest != EXIT_BLOCK_PTR_FOR_FN (cfun)))
755 if (block_ends_with_call_p (bb))
756 edge_gcov_count (e) = edge_gcov_count (e) < 0
757 ? 0 : bb_gcov_count (bb);
759 if (edge_gcov_count (e) < 0
760 || edge_gcov_count (e) > bb_gcov_count (bb))
762 error ("corrupted profile info: number of executions for edge %d-%d thought to be %i",
763 e->src->index, e->dest->index,
764 (int)edge_gcov_count (e));
765 edge_gcov_count (e) = bb_gcov_count (bb) / 2;
768 if (bb_gcov_count (bb))
770 FOR_EACH_EDGE (e, ei, bb->succs)
771 e->probability = GCOV_COMPUTE_SCALE (edge_gcov_count (e),
772 bb_gcov_count (bb));
773 if (bb->index >= NUM_FIXED_BLOCKS
774 && block_ends_with_condjump_p (bb)
775 && EDGE_COUNT (bb->succs) >= 2)
777 int prob;
778 edge e;
779 int index;
781 /* Find the branch edge. It is possible that we do have fake
782 edges here. */
783 FOR_EACH_EDGE (e, ei, bb->succs)
784 if (!(e->flags & (EDGE_FAKE | EDGE_FALLTHRU)))
785 break;
787 prob = e->probability;
788 index = prob * 20 / REG_BR_PROB_BASE;
790 if (index == 20)
791 index = 19;
792 hist_br_prob[index]++;
794 num_branches++;
797 /* As a last resort, distribute the probabilities evenly.
798 Use simple heuristics that if there are normal edges,
799 give all abnormals frequency of 0, otherwise distribute the
800 frequency over abnormals (this is the case of noreturn
801 calls). */
802 else if (profile_status_for_fn (cfun) == PROFILE_ABSENT)
804 int total = 0;
806 FOR_EACH_EDGE (e, ei, bb->succs)
807 if (!(e->flags & (EDGE_COMPLEX | EDGE_FAKE)))
808 total ++;
809 if (total)
811 FOR_EACH_EDGE (e, ei, bb->succs)
812 if (!(e->flags & (EDGE_COMPLEX | EDGE_FAKE)))
813 e->probability = REG_BR_PROB_BASE / total;
814 else
815 e->probability = 0;
817 else
819 total += EDGE_COUNT (bb->succs);
820 FOR_EACH_EDGE (e, ei, bb->succs)
821 e->probability = REG_BR_PROB_BASE / total;
823 if (bb->index >= NUM_FIXED_BLOCKS
824 && block_ends_with_condjump_p (bb)
825 && EDGE_COUNT (bb->succs) >= 2)
826 num_branches++;
830 FOR_ALL_BB_FN (bb, cfun)
832 edge e;
833 edge_iterator ei;
835 bb->count = profile_count::from_gcov_type (bb_gcov_count (bb));
836 FOR_EACH_EDGE (e, ei, bb->succs)
837 e->count = profile_count::from_gcov_type (edge_gcov_count (e));
839 bb_gcov_counts.release ();
840 delete edge_gcov_counts;
841 edge_gcov_counts = NULL;
843 counts_to_freqs ();
845 if (dump_file)
847 fprintf (dump_file, "%d branches\n", num_branches);
848 if (num_branches)
849 for (i = 0; i < 10; i++)
850 fprintf (dump_file, "%d%% branches in range %d-%d%%\n",
851 (hist_br_prob[i] + hist_br_prob[19-i]) * 100 / num_branches,
852 5 * i, 5 * i + 5);
854 total_num_branches += num_branches;
855 for (i = 0; i < 20; i++)
856 total_hist_br_prob[i] += hist_br_prob[i];
858 fputc ('\n', dump_file);
859 fputc ('\n', dump_file);
862 free_aux_for_blocks ();
865 /* Load value histograms values whose description is stored in VALUES array
866 from .gcda file.
868 CFG_CHECKSUM is the precomputed checksum for the CFG. */
870 static void
871 compute_value_histograms (histogram_values values, unsigned cfg_checksum,
872 unsigned lineno_checksum)
874 unsigned i, j, t, any;
875 unsigned n_histogram_counters[GCOV_N_VALUE_COUNTERS];
876 gcov_type *histogram_counts[GCOV_N_VALUE_COUNTERS];
877 gcov_type *act_count[GCOV_N_VALUE_COUNTERS];
878 gcov_type *aact_count;
879 struct cgraph_node *node;
881 for (t = 0; t < GCOV_N_VALUE_COUNTERS; t++)
882 n_histogram_counters[t] = 0;
884 for (i = 0; i < values.length (); i++)
886 histogram_value hist = values[i];
887 n_histogram_counters[(int) hist->type] += hist->n_counters;
890 any = 0;
891 for (t = 0; t < GCOV_N_VALUE_COUNTERS; t++)
893 if (!n_histogram_counters[t])
895 histogram_counts[t] = NULL;
896 continue;
899 histogram_counts[t] =
900 get_coverage_counts (COUNTER_FOR_HIST_TYPE (t),
901 n_histogram_counters[t], cfg_checksum,
902 lineno_checksum, NULL);
903 if (histogram_counts[t])
904 any = 1;
905 act_count[t] = histogram_counts[t];
907 if (!any)
908 return;
910 for (i = 0; i < values.length (); i++)
912 histogram_value hist = values[i];
913 gimple *stmt = hist->hvalue.stmt;
915 t = (int) hist->type;
917 aact_count = act_count[t];
919 if (act_count[t])
920 act_count[t] += hist->n_counters;
922 gimple_add_histogram_value (cfun, stmt, hist);
923 hist->hvalue.counters = XNEWVEC (gcov_type, hist->n_counters);
924 for (j = 0; j < hist->n_counters; j++)
925 if (aact_count)
926 hist->hvalue.counters[j] = aact_count[j];
927 else
928 hist->hvalue.counters[j] = 0;
930 /* Time profiler counter is not related to any statement,
931 so that we have to read the counter and set the value to
932 the corresponding call graph node. */
933 if (hist->type == HIST_TYPE_TIME_PROFILE)
935 node = cgraph_node::get (hist->fun->decl);
936 node->tp_first_run = hist->hvalue.counters[0];
938 if (dump_file)
939 fprintf (dump_file, "Read tp_first_run: %d\n", node->tp_first_run);
943 for (t = 0; t < GCOV_N_VALUE_COUNTERS; t++)
944 free (histogram_counts[t]);
947 /* When passed NULL as file_name, initialize.
948 When passed something else, output the necessary commands to change
949 line to LINE and offset to FILE_NAME. */
950 static void
951 output_location (char const *file_name, int line,
952 gcov_position_t *offset, basic_block bb)
954 static char const *prev_file_name;
955 static int prev_line;
956 bool name_differs, line_differs;
958 if (!file_name)
960 prev_file_name = NULL;
961 prev_line = -1;
962 return;
965 name_differs = !prev_file_name || filename_cmp (file_name, prev_file_name);
966 line_differs = prev_line != line;
968 if (!*offset)
970 *offset = gcov_write_tag (GCOV_TAG_LINES);
971 gcov_write_unsigned (bb->index);
972 name_differs = line_differs = true;
975 /* If this is a new source file, then output the
976 file's name to the .bb file. */
977 if (name_differs)
979 prev_file_name = file_name;
980 gcov_write_unsigned (0);
981 gcov_write_filename (prev_file_name);
983 if (line_differs)
985 gcov_write_unsigned (line);
986 prev_line = line;
990 /* Helper for qsort so edges get sorted from highest frequency to smallest.
991 This controls the weight for minimal spanning tree algorithm */
992 static int
993 compare_freqs (const void *p1, const void *p2)
995 const_edge e1 = *(const const_edge *)p1;
996 const_edge e2 = *(const const_edge *)p2;
998 /* Critical edges needs to be split which introduce extra control flow.
999 Make them more heavy. */
1000 int m1 = EDGE_CRITICAL_P (e1) ? 2 : 1;
1001 int m2 = EDGE_CRITICAL_P (e2) ? 2 : 1;
1003 if (EDGE_FREQUENCY (e1) * m1 + m1 != EDGE_FREQUENCY (e2) * m2 + m2)
1004 return EDGE_FREQUENCY (e2) * m2 + m2 - EDGE_FREQUENCY (e1) * m1 - m1;
1005 /* Stabilize sort. */
1006 if (e1->src->index != e2->src->index)
1007 return e2->src->index - e1->src->index;
1008 return e2->dest->index - e1->dest->index;
1011 /* Instrument and/or analyze program behavior based on program the CFG.
1013 This function creates a representation of the control flow graph (of
1014 the function being compiled) that is suitable for the instrumentation
1015 of edges and/or converting measured edge counts to counts on the
1016 complete CFG.
1018 When FLAG_PROFILE_ARCS is nonzero, this function instruments the edges in
1019 the flow graph that are needed to reconstruct the dynamic behavior of the
1020 flow graph. This data is written to the gcno file for gcov.
1022 When FLAG_BRANCH_PROBABILITIES is nonzero, this function reads auxiliary
1023 information from the gcda file containing edge count information from
1024 previous executions of the function being compiled. In this case, the
1025 control flow graph is annotated with actual execution counts by
1026 compute_branch_probabilities().
1028 Main entry point of this file. */
1030 void
1031 branch_prob (void)
1033 basic_block bb;
1034 unsigned i;
1035 unsigned num_edges, ignored_edges;
1036 unsigned num_instrumented;
1037 struct edge_list *el;
1038 histogram_values values = histogram_values ();
1039 unsigned cfg_checksum, lineno_checksum;
1041 total_num_times_called++;
1043 flow_call_edges_add (NULL);
1044 add_noreturn_fake_exit_edges ();
1046 /* We can't handle cyclic regions constructed using abnormal edges.
1047 To avoid these we replace every source of abnormal edge by a fake
1048 edge from entry node and every destination by fake edge to exit.
1049 This keeps graph acyclic and our calculation exact for all normal
1050 edges except for exit and entrance ones.
1052 We also add fake exit edges for each call and asm statement in the
1053 basic, since it may not return. */
1055 FOR_EACH_BB_FN (bb, cfun)
1057 int need_exit_edge = 0, need_entry_edge = 0;
1058 int have_exit_edge = 0, have_entry_edge = 0;
1059 edge e;
1060 edge_iterator ei;
1062 /* Functions returning multiple times are not handled by extra edges.
1063 Instead we simply allow negative counts on edges from exit to the
1064 block past call and corresponding probabilities. We can't go
1065 with the extra edges because that would result in flowgraph that
1066 needs to have fake edges outside the spanning tree. */
1068 FOR_EACH_EDGE (e, ei, bb->succs)
1070 gimple_stmt_iterator gsi;
1071 gimple *last = NULL;
1073 /* It may happen that there are compiler generated statements
1074 without a locus at all. Go through the basic block from the
1075 last to the first statement looking for a locus. */
1076 for (gsi = gsi_last_nondebug_bb (bb);
1077 !gsi_end_p (gsi);
1078 gsi_prev_nondebug (&gsi))
1080 last = gsi_stmt (gsi);
1081 if (!RESERVED_LOCATION_P (gimple_location (last)))
1082 break;
1085 /* Edge with goto locus might get wrong coverage info unless
1086 it is the only edge out of BB.
1087 Don't do that when the locuses match, so
1088 if (blah) goto something;
1089 is not computed twice. */
1090 if (last
1091 && gimple_has_location (last)
1092 && !RESERVED_LOCATION_P (e->goto_locus)
1093 && !single_succ_p (bb)
1094 && (LOCATION_FILE (e->goto_locus)
1095 != LOCATION_FILE (gimple_location (last))
1096 || (LOCATION_LINE (e->goto_locus)
1097 != LOCATION_LINE (gimple_location (last)))))
1099 basic_block new_bb = split_edge (e);
1100 edge ne = single_succ_edge (new_bb);
1101 ne->goto_locus = e->goto_locus;
1103 if ((e->flags & (EDGE_ABNORMAL | EDGE_ABNORMAL_CALL))
1104 && e->dest != EXIT_BLOCK_PTR_FOR_FN (cfun))
1105 need_exit_edge = 1;
1106 if (e->dest == EXIT_BLOCK_PTR_FOR_FN (cfun))
1107 have_exit_edge = 1;
1109 FOR_EACH_EDGE (e, ei, bb->preds)
1111 if ((e->flags & (EDGE_ABNORMAL | EDGE_ABNORMAL_CALL))
1112 && e->src != ENTRY_BLOCK_PTR_FOR_FN (cfun))
1113 need_entry_edge = 1;
1114 if (e->src == ENTRY_BLOCK_PTR_FOR_FN (cfun))
1115 have_entry_edge = 1;
1118 if (need_exit_edge && !have_exit_edge)
1120 if (dump_file)
1121 fprintf (dump_file, "Adding fake exit edge to bb %i\n",
1122 bb->index);
1123 make_edge (bb, EXIT_BLOCK_PTR_FOR_FN (cfun), EDGE_FAKE);
1125 if (need_entry_edge && !have_entry_edge)
1127 if (dump_file)
1128 fprintf (dump_file, "Adding fake entry edge to bb %i\n",
1129 bb->index);
1130 make_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun), bb, EDGE_FAKE);
1131 /* Avoid bbs that have both fake entry edge and also some
1132 exit edge. One of those edges wouldn't be added to the
1133 spanning tree, but we can't instrument any of them. */
1134 if (have_exit_edge || need_exit_edge)
1136 gimple_stmt_iterator gsi;
1137 gimple *first;
1139 gsi = gsi_start_nondebug_after_labels_bb (bb);
1140 gcc_checking_assert (!gsi_end_p (gsi));
1141 first = gsi_stmt (gsi);
1142 /* Don't split the bbs containing __builtin_setjmp_receiver
1143 or ABNORMAL_DISPATCHER calls. These are very
1144 special and don't expect anything to be inserted before
1145 them. */
1146 if (is_gimple_call (first)
1147 && (gimple_call_builtin_p (first, BUILT_IN_SETJMP_RECEIVER)
1148 || (gimple_call_flags (first) & ECF_RETURNS_TWICE)
1149 || (gimple_call_internal_p (first)
1150 && (gimple_call_internal_fn (first)
1151 == IFN_ABNORMAL_DISPATCHER))))
1152 continue;
1154 if (dump_file)
1155 fprintf (dump_file, "Splitting bb %i after labels\n",
1156 bb->index);
1157 split_block_after_labels (bb);
1162 el = create_edge_list ();
1163 num_edges = NUM_EDGES (el);
1164 qsort (el->index_to_edge, num_edges, sizeof (edge), compare_freqs);
1165 alloc_aux_for_edges (sizeof (struct edge_profile_info));
1167 /* The basic blocks are expected to be numbered sequentially. */
1168 compact_blocks ();
1170 ignored_edges = 0;
1171 for (i = 0 ; i < num_edges ; i++)
1173 edge e = INDEX_EDGE (el, i);
1175 /* Mark edges we've replaced by fake edges above as ignored. */
1176 if ((e->flags & (EDGE_ABNORMAL | EDGE_ABNORMAL_CALL))
1177 && e->src != ENTRY_BLOCK_PTR_FOR_FN (cfun)
1178 && e->dest != EXIT_BLOCK_PTR_FOR_FN (cfun))
1180 EDGE_INFO (e)->ignore = 1;
1181 ignored_edges++;
1185 /* Create spanning tree from basic block graph, mark each edge that is
1186 on the spanning tree. We insert as many abnormal and critical edges
1187 as possible to minimize number of edge splits necessary. */
1189 find_spanning_tree (el);
1191 /* Fake edges that are not on the tree will not be instrumented, so
1192 mark them ignored. */
1193 for (num_instrumented = i = 0; i < num_edges; i++)
1195 edge e = INDEX_EDGE (el, i);
1196 struct edge_profile_info *inf = EDGE_INFO (e);
1198 if (inf->ignore || inf->on_tree)
1199 /*NOP*/;
1200 else if (e->flags & EDGE_FAKE)
1202 inf->ignore = 1;
1203 ignored_edges++;
1205 else
1206 num_instrumented++;
1209 total_num_blocks += n_basic_blocks_for_fn (cfun);
1210 if (dump_file)
1211 fprintf (dump_file, "%d basic blocks\n", n_basic_blocks_for_fn (cfun));
1213 total_num_edges += num_edges;
1214 if (dump_file)
1215 fprintf (dump_file, "%d edges\n", num_edges);
1217 total_num_edges_ignored += ignored_edges;
1218 if (dump_file)
1219 fprintf (dump_file, "%d ignored edges\n", ignored_edges);
1221 total_num_edges_instrumented += num_instrumented;
1222 if (dump_file)
1223 fprintf (dump_file, "%d instrumentation edges\n", num_instrumented);
1225 /* Compute two different checksums. Note that we want to compute
1226 the checksum in only once place, since it depends on the shape
1227 of the control flow which can change during
1228 various transformations. */
1229 cfg_checksum = coverage_compute_cfg_checksum (cfun);
1230 lineno_checksum = coverage_compute_lineno_checksum ();
1232 /* Write the data from which gcov can reconstruct the basic block
1233 graph and function line numbers (the gcno file). */
1234 if (coverage_begin_function (lineno_checksum, cfg_checksum))
1236 gcov_position_t offset;
1238 /* Basic block flags */
1239 offset = gcov_write_tag (GCOV_TAG_BLOCKS);
1240 gcov_write_unsigned (n_basic_blocks_for_fn (cfun));
1241 gcov_write_length (offset);
1243 /* Arcs */
1244 FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR_FOR_FN (cfun),
1245 EXIT_BLOCK_PTR_FOR_FN (cfun), next_bb)
1247 edge e;
1248 edge_iterator ei;
1250 offset = gcov_write_tag (GCOV_TAG_ARCS);
1251 gcov_write_unsigned (bb->index);
1253 FOR_EACH_EDGE (e, ei, bb->succs)
1255 struct edge_profile_info *i = EDGE_INFO (e);
1256 if (!i->ignore)
1258 unsigned flag_bits = 0;
1260 if (i->on_tree)
1261 flag_bits |= GCOV_ARC_ON_TREE;
1262 if (e->flags & EDGE_FAKE)
1263 flag_bits |= GCOV_ARC_FAKE;
1264 if (e->flags & EDGE_FALLTHRU)
1265 flag_bits |= GCOV_ARC_FALLTHROUGH;
1266 /* On trees we don't have fallthru flags, but we can
1267 recompute them from CFG shape. */
1268 if (e->flags & (EDGE_TRUE_VALUE | EDGE_FALSE_VALUE)
1269 && e->src->next_bb == e->dest)
1270 flag_bits |= GCOV_ARC_FALLTHROUGH;
1272 gcov_write_unsigned (e->dest->index);
1273 gcov_write_unsigned (flag_bits);
1277 gcov_write_length (offset);
1280 /* Line numbers. */
1281 /* Initialize the output. */
1282 output_location (NULL, 0, NULL, NULL);
1284 FOR_EACH_BB_FN (bb, cfun)
1286 gimple_stmt_iterator gsi;
1287 gcov_position_t offset = 0;
1289 if (bb == ENTRY_BLOCK_PTR_FOR_FN (cfun)->next_bb)
1291 expanded_location curr_location =
1292 expand_location (DECL_SOURCE_LOCATION (current_function_decl));
1293 output_location (curr_location.file, curr_location.line,
1294 &offset, bb);
1297 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
1299 gimple *stmt = gsi_stmt (gsi);
1300 if (!RESERVED_LOCATION_P (gimple_location (stmt)))
1301 output_location (gimple_filename (stmt), gimple_lineno (stmt),
1302 &offset, bb);
1305 /* Notice GOTO expressions eliminated while constructing the CFG. */
1306 if (single_succ_p (bb)
1307 && !RESERVED_LOCATION_P (single_succ_edge (bb)->goto_locus))
1309 expanded_location curr_location
1310 = expand_location (single_succ_edge (bb)->goto_locus);
1311 output_location (curr_location.file, curr_location.line,
1312 &offset, bb);
1315 if (offset)
1317 /* A file of NULL indicates the end of run. */
1318 gcov_write_unsigned (0);
1319 gcov_write_string (NULL);
1320 gcov_write_length (offset);
1325 if (flag_profile_values)
1326 gimple_find_values_to_profile (&values);
1328 if (flag_branch_probabilities)
1330 compute_branch_probabilities (cfg_checksum, lineno_checksum);
1331 if (flag_profile_values)
1332 compute_value_histograms (values, cfg_checksum, lineno_checksum);
1335 remove_fake_edges ();
1337 /* For each edge not on the spanning tree, add counting code. */
1338 if (profile_arc_flag
1339 && coverage_counter_alloc (GCOV_COUNTER_ARCS, num_instrumented))
1341 unsigned n_instrumented;
1343 gimple_init_gcov_profiler ();
1345 n_instrumented = instrument_edges (el);
1347 gcc_assert (n_instrumented == num_instrumented);
1349 if (flag_profile_values)
1350 instrument_values (values);
1352 /* Commit changes done by instrumentation. */
1353 gsi_commit_edge_inserts ();
1356 free_aux_for_edges ();
1358 values.release ();
1359 free_edge_list (el);
1360 coverage_end_function (lineno_checksum, cfg_checksum);
1361 if (flag_branch_probabilities && profile_info)
1363 struct loop *loop;
1364 if (dump_file && (dump_flags & TDF_DETAILS))
1365 report_predictor_hitrates ();
1366 profile_status_for_fn (cfun) = PROFILE_READ;
1368 /* At this moment we have precise loop iteration count estimates.
1369 Record them to loop structure before the profile gets out of date. */
1370 FOR_EACH_LOOP (loop, 0)
1371 if (loop->header->count > 0)
1373 gcov_type nit = expected_loop_iterations_unbounded (loop);
1374 widest_int bound = gcov_type_to_wide_int (nit);
1375 loop->any_estimate = false;
1376 record_niter_bound (loop, bound, true, false);
1378 compute_function_frequency ();
1382 /* Union find algorithm implementation for the basic blocks using
1383 aux fields. */
1385 static basic_block
1386 find_group (basic_block bb)
1388 basic_block group = bb, bb1;
1390 while ((basic_block) group->aux != group)
1391 group = (basic_block) group->aux;
1393 /* Compress path. */
1394 while ((basic_block) bb->aux != group)
1396 bb1 = (basic_block) bb->aux;
1397 bb->aux = (void *) group;
1398 bb = bb1;
1400 return group;
1403 static void
1404 union_groups (basic_block bb1, basic_block bb2)
1406 basic_block bb1g = find_group (bb1);
1407 basic_block bb2g = find_group (bb2);
1409 /* ??? I don't have a place for the rank field. OK. Lets go w/o it,
1410 this code is unlikely going to be performance problem anyway. */
1411 gcc_assert (bb1g != bb2g);
1413 bb1g->aux = bb2g;
1416 /* This function searches all of the edges in the program flow graph, and puts
1417 as many bad edges as possible onto the spanning tree. Bad edges include
1418 abnormals edges, which can't be instrumented at the moment. Since it is
1419 possible for fake edges to form a cycle, we will have to develop some
1420 better way in the future. Also put critical edges to the tree, since they
1421 are more expensive to instrument. */
1423 static void
1424 find_spanning_tree (struct edge_list *el)
1426 int i;
1427 int num_edges = NUM_EDGES (el);
1428 basic_block bb;
1430 /* We use aux field for standard union-find algorithm. */
1431 FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR_FOR_FN (cfun), NULL, next_bb)
1432 bb->aux = bb;
1434 /* Add fake edge exit to entry we can't instrument. */
1435 union_groups (EXIT_BLOCK_PTR_FOR_FN (cfun), ENTRY_BLOCK_PTR_FOR_FN (cfun));
1437 /* First add all abnormal edges to the tree unless they form a cycle. Also
1438 add all edges to the exit block to avoid inserting profiling code behind
1439 setting return value from function. */
1440 for (i = 0; i < num_edges; i++)
1442 edge e = INDEX_EDGE (el, i);
1443 if (((e->flags & (EDGE_ABNORMAL | EDGE_ABNORMAL_CALL | EDGE_FAKE))
1444 || e->dest == EXIT_BLOCK_PTR_FOR_FN (cfun))
1445 && !EDGE_INFO (e)->ignore
1446 && (find_group (e->src) != find_group (e->dest)))
1448 if (dump_file)
1449 fprintf (dump_file, "Abnormal edge %d to %d put to tree\n",
1450 e->src->index, e->dest->index);
1451 EDGE_INFO (e)->on_tree = 1;
1452 union_groups (e->src, e->dest);
1456 /* And now the rest. Edge list is sorted according to frequencies and
1457 thus we will produce minimal spanning tree. */
1458 for (i = 0; i < num_edges; i++)
1460 edge e = INDEX_EDGE (el, i);
1461 if (!EDGE_INFO (e)->ignore
1462 && find_group (e->src) != find_group (e->dest))
1464 if (dump_file)
1465 fprintf (dump_file, "Normal edge %d to %d put to tree\n",
1466 e->src->index, e->dest->index);
1467 EDGE_INFO (e)->on_tree = 1;
1468 union_groups (e->src, e->dest);
1472 clear_aux_for_blocks ();
1475 /* Perform file-level initialization for branch-prob processing. */
1477 void
1478 init_branch_prob (void)
1480 int i;
1482 total_num_blocks = 0;
1483 total_num_edges = 0;
1484 total_num_edges_ignored = 0;
1485 total_num_edges_instrumented = 0;
1486 total_num_blocks_created = 0;
1487 total_num_passes = 0;
1488 total_num_times_called = 0;
1489 total_num_branches = 0;
1490 for (i = 0; i < 20; i++)
1491 total_hist_br_prob[i] = 0;
1494 /* Performs file-level cleanup after branch-prob processing
1495 is completed. */
1497 void
1498 end_branch_prob (void)
1500 if (dump_file)
1502 fprintf (dump_file, "\n");
1503 fprintf (dump_file, "Total number of blocks: %d\n",
1504 total_num_blocks);
1505 fprintf (dump_file, "Total number of edges: %d\n", total_num_edges);
1506 fprintf (dump_file, "Total number of ignored edges: %d\n",
1507 total_num_edges_ignored);
1508 fprintf (dump_file, "Total number of instrumented edges: %d\n",
1509 total_num_edges_instrumented);
1510 fprintf (dump_file, "Total number of blocks created: %d\n",
1511 total_num_blocks_created);
1512 fprintf (dump_file, "Total number of graph solution passes: %d\n",
1513 total_num_passes);
1514 if (total_num_times_called != 0)
1515 fprintf (dump_file, "Average number of graph solution passes: %d\n",
1516 (total_num_passes + (total_num_times_called >> 1))
1517 / total_num_times_called);
1518 fprintf (dump_file, "Total number of branches: %d\n",
1519 total_num_branches);
1520 if (total_num_branches)
1522 int i;
1524 for (i = 0; i < 10; i++)
1525 fprintf (dump_file, "%d%% branches in range %d-%d%%\n",
1526 (total_hist_br_prob[i] + total_hist_br_prob[19-i]) * 100
1527 / total_num_branches, 5*i, 5*i+5);