gcc/profile.c

   1 /* Calculate branch probabilities, and basic block execution counts.
   2    Copyright (C) 1990, 1991, 1992, 1993, 1994, 1996, 1997, 1998, 1999,
   3    2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008
   4    Free Software Foundation, Inc.
   5    Contributed by James E. Wilson, UC Berkeley/Cygnus Support;
   6    based on some ideas from Dain Samples of UC Berkeley.
   7    Further mangling by Bob Manson, Cygnus Support.
   8
   9 This file is part of GCC.
  10
  11 GCC is free software; you can redistribute it and/or modify it under
  12 the terms of the GNU General Public License as published by the Free
  13 Software Foundation; either version 3, or (at your option) any later
  14 version.
  15
  16 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  17 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  18 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  19 for more details.
  20
  21 You should have received a copy of the GNU General Public License
  22 along with GCC; see the file COPYING3.  If not see
  23 <http://www.gnu.org/licenses/>.  */
  24
  25 /* Generate basic block profile instrumentation and auxiliary files.
  26    Profile generation is optimized, so that not all arcs in the basic
  27    block graph need instrumenting. First, the BB graph is closed with
  28    one entry (function start), and one exit (function exit).  Any
  29    ABNORMAL_EDGE cannot be instrumented (because there is no control
  30    path to place the code). We close the graph by inserting fake
  31    EDGE_FAKE edges to the EXIT_BLOCK, from the sources of abnormal
  32    edges that do not go to the exit_block. We ignore such abnormal
  33    edges.  Naturally these fake edges are never directly traversed,
  34    and so *cannot* be directly instrumented.  Some other graph
  35    massaging is done. To optimize the instrumentation we generate the
  36    BB minimal span tree, only edges that are not on the span tree
  37    (plus the entry point) need instrumenting. From that information
  38    all other edge counts can be deduced.  By construction all fake
  39    edges must be on the spanning tree. We also attempt to place
  40    EDGE_CRITICAL edges on the spanning tree.
  41
  42    The auxiliary files generated are <dumpbase>.gcno (at compile time)
  43    and <dumpbase>.gcda (at run time).  The format is
  44    described in full in gcov-io.h.  */
  45
  46 /* ??? Register allocation should use basic block execution counts to
  47    give preference to the most commonly executed blocks.  */
  48
  49 /* ??? Should calculate branch probabilities before instrumenting code, since
  50    then we can use arc counts to help decide which arcs to instrument.  */
  51
  52 #include "config.h"
  53 #include "system.h"
  54 #include "coretypes.h"
  55 #include "tm.h"
  56 #include "rtl.h"
  57 #include "flags.h"
  58 #include "output.h"
  59 #include "regs.h"
  60 #include "expr.h"
  61 #include "function.h"
  62 #include "toplev.h"
  63 #include "coverage.h"
  64 #include "value-prof.h"
  65 #include "tree.h"
  66 #include "cfghooks.h"
  67 #include "tree-flow.h"
  68 #include "timevar.h"
  69 #include "cfgloop.h"
  70 #include "tree-pass.h"
  71
  72 #include "profile.h"
  73
  74 /* Hooks for profiling.  */
  75 static struct profile_hooks* profile_hooks;
  76
  77 struct bb_info {
  78   unsigned int count_valid : 1;
  79
  80   /* Number of successor and predecessor edges.  */
  81   gcov_type succ_count;
  82   gcov_type pred_count;
  83 };
  84
  85 #define BB_INFO(b)  ((struct bb_info *) (b)->aux)
  86
  87
  88 /* Counter summary from the last set of coverage counts read.  */
  89
  90 const struct gcov_ctr_summary *profile_info;
  91
  92 /* Collect statistics on the performance of this pass for the entire source
  93    file.  */
  94
  95 static int total_num_blocks;
  96 static int total_num_edges;
  97 static int total_num_edges_ignored;
  98 static int total_num_edges_instrumented;
  99 static int total_num_blocks_created;
 100 static int total_num_passes;
 101 static int total_num_times_called;
 102 static int total_hist_br_prob[20];
 103 static int total_num_never_executed;
 104 static int total_num_branches;
 105
 106 /* Forward declarations.  */
 107 static void find_spanning_tree (struct edge_list *);
 108 static unsigned instrument_edges (struct edge_list *);
 109 static void instrument_values (histogram_values);
 110 static void compute_branch_probabilities (void);
 111 static void compute_value_histograms (histogram_values);
 112 static gcov_type * get_exec_counts (void);
 113 static basic_block find_group (basic_block);
 114 static void union_groups (basic_block, basic_block);
 115
 116 /* Add edge instrumentation code to the entire insn chain.
 117
 118    F is the first insn of the chain.
 119    NUM_BLOCKS is the number of basic blocks found in F.  */
 120
 121 static unsigned
 122 instrument_edges (struct edge_list *el)
 123 {
 124   unsigned num_instr_edges = 0;
 125   int num_edges = NUM_EDGES (el);
 126   basic_block bb;
 127
 128   FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, NULL, next_bb)
 129     {
 130       edge e;
 131       edge_iterator ei;
 132
 133       FOR_EACH_EDGE (e, ei, bb->succs)
 134         {
 135           struct edge_info *inf = EDGE_INFO (e);
 136
 137           if (!inf->ignore && !inf->on_tree)
 138             {
 139               gcc_assert (!(e->flags & EDGE_ABNORMAL));
 140               if (dump_file)
 141                 fprintf (dump_file, "Edge %d to %d instrumented%s\n",
 142                          e->src->index, e->dest->index,
 143                          EDGE_CRITICAL_P (e) ? " (and split)" : "");
 144               (profile_hooks->gen_edge_profiler) (num_instr_edges++, e);
 145             }
 146         }
 147     }
 148
 149   total_num_blocks_created += num_edges;
 150   if (dump_file)
 151     fprintf (dump_file, "%d edges instrumented\n", num_instr_edges);
 152   return num_instr_edges;
 153 }
 154
 155 /* Add code to measure histograms for values in list VALUES.  */
 156 static void
 157 instrument_values (histogram_values values)
 158 {
 159   unsigned i, t;
 160
 161   /* Emit code to generate the histograms before the insns.  */
 162
 163   for (i = 0; i < VEC_length (histogram_value, values); i++)
 164     {
 165       histogram_value hist = VEC_index (histogram_value, values, i);
 166       switch (hist->type)
 167         {
 168         case HIST_TYPE_INTERVAL:
 169           t = GCOV_COUNTER_V_INTERVAL;
 170           break;
 171
 172         case HIST_TYPE_POW2:
 173           t = GCOV_COUNTER_V_POW2;
 174           break;
 175
 176         case HIST_TYPE_SINGLE_VALUE:
 177           t = GCOV_COUNTER_V_SINGLE;
 178           break;
 179
 180         case HIST_TYPE_CONST_DELTA:
 181           t = GCOV_COUNTER_V_DELTA;
 182           break;
 183
 184         case HIST_TYPE_INDIR_CALL:
 185           t = GCOV_COUNTER_V_INDIR;
 186           break;
 187
 188         case HIST_TYPE_AVERAGE:
 189           t = GCOV_COUNTER_AVERAGE;
 190           break;
 191
 192         case HIST_TYPE_IOR:
 193           t = GCOV_COUNTER_IOR;
 194           break;
 195
 196         default:
 197           gcc_unreachable ();
 198         }
 199       if (!coverage_counter_alloc (t, hist->n_counters))
 200         continue;
 201
 202       switch (hist->type)
 203         {
 204         case HIST_TYPE_INTERVAL:
 205           (profile_hooks->gen_interval_profiler) (hist, t, 0);
 206           break;
 207
 208         case HIST_TYPE_POW2:
 209           (profile_hooks->gen_pow2_profiler) (hist, t, 0);
 210           break;
 211
 212         case HIST_TYPE_SINGLE_VALUE:
 213           (profile_hooks->gen_one_value_profiler) (hist, t, 0);
 214           break;
 215
 216         case HIST_TYPE_CONST_DELTA:
 217           (profile_hooks->gen_const_delta_profiler) (hist, t, 0);
 218           break;
 219
 220         case HIST_TYPE_INDIR_CALL:
 221           (profile_hooks->gen_ic_profiler) (hist, t, 0);
 222           break;
 223
 224         case HIST_TYPE_AVERAGE:
 225           (profile_hooks->gen_average_profiler) (hist, t, 0);
 226           break;
 227
 228         case HIST_TYPE_IOR:
 229           (profile_hooks->gen_ior_profiler) (hist, t, 0);
 230           break;
 231
 232         default:
 233           gcc_unreachable ();
 234         }
 235     }
 236 }
 237 \f
 238
 239 /* Computes hybrid profile for all matching entries in da_file.  */
 240
 241 static gcov_type *
 242 get_exec_counts (void)
 243 {
 244   unsigned num_edges = 0;
 245   basic_block bb;
 246   gcov_type *counts;
 247
 248   /* Count the edges to be (possibly) instrumented.  */
 249   FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, NULL, next_bb)
 250     {
 251       edge e;
 252       edge_iterator ei;
 253
 254       FOR_EACH_EDGE (e, ei, bb->succs)
 255         if (!EDGE_INFO (e)->ignore && !EDGE_INFO (e)->on_tree)
 256           num_edges++;
 257     }
 258
 259   counts = get_coverage_counts (GCOV_COUNTER_ARCS, num_edges, &profile_info);
 260   if (!counts)
 261     return NULL;
 262
 263   if (dump_file && profile_info)
 264     fprintf(dump_file, "Merged %u profiles with maximal count %u.\n",
 265             profile_info->runs, (unsigned) profile_info->sum_max);
 266
 267   return counts;
 268 }
 269
 270
 271 static bool
 272 is_edge_inconsistent (VEC(edge,gc) *edges)
 273 {
 274   edge e;
 275   edge_iterator ei;
 276   FOR_EACH_EDGE (e, ei, edges)
 277     {
 278       if (!EDGE_INFO (e)->ignore)
 279         {
 280           if (e->count < 0
 281               && (!(e->flags & EDGE_FAKE)
 282                   || !block_ends_with_call_p (e->src)))
 283             {
 284               if (dump_file)
 285                 {
 286                   fprintf (dump_file,
 287                            "Edge %i->%i is inconsistent, count"HOST_WIDEST_INT_PRINT_DEC,
 288                            e->src->index, e->dest->index, e->count);
 289                   dump_bb (e->src, dump_file, 0);
 290                   dump_bb (e->dest, dump_file, 0);
 291                 }
 292               return true;
 293             }
 294         }
 295     }
 296   return false;
 297 }
 298
 299 static void
 300 correct_negative_edge_counts (void)
 301 {
 302   basic_block bb;
 303   edge e;
 304   edge_iterator ei;
 305
 306   FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, NULL, next_bb)
 307     {
 308       FOR_EACH_EDGE (e, ei, bb->succs)
 309         {
 310            if (e->count < 0)
 311              e->count = 0;
 312         }
 313     }
 314 }
 315
 316 /* Check consistency.
 317    Return true if inconsistency is found.  */
 318 static bool
 319 is_inconsistent (void)
 320 {
 321   basic_block bb;
 322   bool inconsistent = false;
 323   FOR_EACH_BB (bb)
 324     {
 325       inconsistent |= is_edge_inconsistent (bb->preds);
 326       if (!dump_file && inconsistent)
 327         return true;
 328       inconsistent |= is_edge_inconsistent (bb->succs);
 329       if (!dump_file && inconsistent)
 330         return true;
 331       if (bb->count < 0)
 332         {
 333           if (dump_file)
 334             {
 335               fprintf (dump_file, "BB %i count is negative "
 336                        HOST_WIDEST_INT_PRINT_DEC,
 337                        bb->index,
 338                        bb->count);
 339               dump_bb (bb, dump_file, 0);
 340             }
 341           inconsistent = true;
 342         }
 343       if (bb->count != sum_edge_counts (bb->preds))
 344         {
 345           if (dump_file)
 346             {
 347               fprintf (dump_file, "BB %i count does not match sum of incomming edges "
 348                        HOST_WIDEST_INT_PRINT_DEC" should be " HOST_WIDEST_INT_PRINT_DEC,
 349                        bb->index,
 350                        bb->count,
 351                        sum_edge_counts (bb->preds));
 352               dump_bb (bb, dump_file, 0);
 353             }
 354           inconsistent = true;
 355         }
 356       if (bb->count != sum_edge_counts (bb->succs) &&
 357           ! (find_edge (bb, EXIT_BLOCK_PTR) != NULL && block_ends_with_call_p (bb)))
 358         {
 359           if (dump_file)
 360             {
 361               fprintf (dump_file, "BB %i count does not match sum of outgoing edges "
 362                        HOST_WIDEST_INT_PRINT_DEC" should be " HOST_WIDEST_INT_PRINT_DEC,
 363                        bb->index,
 364                        bb->count,
 365                        sum_edge_counts (bb->succs));
 366               dump_bb (bb, dump_file, 0);
 367             }
 368           inconsistent = true;
 369         }
 370       if (!dump_file && inconsistent)
 371         return true;
 372     }
 373
 374   return inconsistent;
 375 }
 376
 377 /* Set each basic block count to the sum of its outgoing edge counts */
 378 static void
 379 set_bb_counts (void)
 380 {
 381   basic_block bb;
 382   FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, NULL, next_bb)
 383     {
 384       bb->count = sum_edge_counts (bb->succs);
 385       gcc_assert (bb->count >= 0);
 386     }
 387 }
 388
 389 /* Reads profile data and returns total number of edge counts read */
 390 static int
 391 read_profile_edge_counts (gcov_type *exec_counts)
 392 {
 393   basic_block bb;
 394   int num_edges = 0;
 395   int exec_counts_pos = 0;
 396   /* For each edge not on the spanning tree, set its execution count from
 397      the .da file.  */
 398   /* The first count in the .da file is the number of times that the function
 399      was entered.  This is the exec_count for block zero.  */
 400
 401   FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, NULL, next_bb)
 402     {
 403       edge e;
 404       edge_iterator ei;
 405
 406       FOR_EACH_EDGE (e, ei, bb->succs)
 407         if (!EDGE_INFO (e)->ignore && !EDGE_INFO (e)->on_tree)
 408           {
 409             num_edges++;
 410             if (exec_counts)
 411               {
 412                 e->count = exec_counts[exec_counts_pos++];
 413                 if (e->count > profile_info->sum_max)
 414                   {
 415                     error ("corrupted profile info: edge from %i to %i exceeds maximal count",
 416                            bb->index, e->dest->index);
 417                   }
 418               }
 419             else
 420               e->count = 0;
 421
 422             EDGE_INFO (e)->count_valid = 1;
 423             BB_INFO (bb)->succ_count--;
 424             BB_INFO (e->dest)->pred_count--;
 425             if (dump_file)
 426               {
 427                 fprintf (dump_file, "\nRead edge from %i to %i, count:",
 428                          bb->index, e->dest->index);
 429                 fprintf (dump_file, HOST_WIDEST_INT_PRINT_DEC,
 430                          (HOST_WIDEST_INT) e->count);
 431               }
 432           }
 433     }
 434
 435     return num_edges;
 436 }
 437
 438 /* Compute the branch probabilities for the various branches.
 439    Annotate them accordingly.  */
 440
 441 static void
 442 compute_branch_probabilities (void)
 443 {
 444   basic_block bb;
 445   int i;
 446   int num_edges = 0;
 447   int changes;
 448   int passes;
 449   int hist_br_prob[20];
 450   int num_never_executed;
 451   int num_branches;
 452   gcov_type *exec_counts = get_exec_counts ();
 453   int inconsistent = 0;
 454
 455   /* Very simple sanity checks so we catch bugs in our profiling code.  */
 456   if (!profile_info)
 457     return;
 458   if (profile_info->run_max * profile_info->runs < profile_info->sum_max)
 459     {
 460       error ("corrupted profile info: run_max * runs < sum_max");
 461       exec_counts = NULL;
 462     }
 463
 464   if (profile_info->sum_all < profile_info->sum_max)
 465     {
 466       error ("corrupted profile info: sum_all is smaller than sum_max");
 467       exec_counts = NULL;
 468     }
 469
 470   /* Attach extra info block to each bb.  */
 471   alloc_aux_for_blocks (sizeof (struct bb_info));
 472   FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, NULL, next_bb)
 473     {
 474       edge e;
 475       edge_iterator ei;
 476
 477       FOR_EACH_EDGE (e, ei, bb->succs)
 478         if (!EDGE_INFO (e)->ignore)
 479           BB_INFO (bb)->succ_count++;
 480       FOR_EACH_EDGE (e, ei, bb->preds)
 481         if (!EDGE_INFO (e)->ignore)
 482           BB_INFO (bb)->pred_count++;
 483     }
 484
 485   /* Avoid predicting entry on exit nodes.  */
 486   BB_INFO (EXIT_BLOCK_PTR)->succ_count = 2;
 487   BB_INFO (ENTRY_BLOCK_PTR)->pred_count = 2;
 488
 489   num_edges = read_profile_edge_counts (exec_counts);
 490
 491   if (dump_file)
 492     fprintf (dump_file, "\n%d edge counts read\n", num_edges);
 493
 494   /* For every block in the file,
 495      - if every exit/entrance edge has a known count, then set the block count
 496      - if the block count is known, and every exit/entrance edge but one has
 497      a known execution count, then set the count of the remaining edge
 498
 499      As edge counts are set, decrement the succ/pred count, but don't delete
 500      the edge, that way we can easily tell when all edges are known, or only
 501      one edge is unknown.  */
 502
 503   /* The order that the basic blocks are iterated through is important.
 504      Since the code that finds spanning trees starts with block 0, low numbered
 505      edges are put on the spanning tree in preference to high numbered edges.
 506      Hence, most instrumented edges are at the end.  Graph solving works much
 507      faster if we propagate numbers from the end to the start.
 508
 509      This takes an average of slightly more than 3 passes.  */
 510
 511   changes = 1;
 512   passes = 0;
 513   while (changes)
 514     {
 515       passes++;
 516       changes = 0;
 517       FOR_BB_BETWEEN (bb, EXIT_BLOCK_PTR, NULL, prev_bb)
 518         {
 519           struct bb_info *bi = BB_INFO (bb);
 520           if (! bi->count_valid)
 521             {
 522               if (bi->succ_count == 0)
 523                 {
 524                   edge e;
 525                   edge_iterator ei;
 526                   gcov_type total = 0;
 527
 528                   FOR_EACH_EDGE (e, ei, bb->succs)
 529                     total += e->count;
 530                   bb->count = total;
 531                   bi->count_valid = 1;
 532                   changes = 1;
 533                 }
 534               else if (bi->pred_count == 0)
 535                 {
 536                   edge e;
 537                   edge_iterator ei;
 538                   gcov_type total = 0;
 539
 540                   FOR_EACH_EDGE (e, ei, bb->preds)
 541                     total += e->count;
 542                   bb->count = total;
 543                   bi->count_valid = 1;
 544                   changes = 1;
 545                 }
 546             }
 547           if (bi->count_valid)
 548             {
 549               if (bi->succ_count == 1)
 550                 {
 551                   edge e;
 552                   edge_iterator ei;
 553                   gcov_type total = 0;
 554
 555                   /* One of the counts will be invalid, but it is zero,
 556                      so adding it in also doesn't hurt.  */
 557                   FOR_EACH_EDGE (e, ei, bb->succs)
 558                     total += e->count;
 559
 560                   /* Search for the invalid edge, and set its count.  */
 561                   FOR_EACH_EDGE (e, ei, bb->succs)
 562                     if (! EDGE_INFO (e)->count_valid && ! EDGE_INFO (e)->ignore)
 563                       break;
 564
 565                   /* Calculate count for remaining edge by conservation.  */
 566                   total = bb->count - total;
 567
 568                   gcc_assert (e);
 569                   EDGE_INFO (e)->count_valid = 1;
 570                   e->count = total;
 571                   bi->succ_count--;
 572
 573                   BB_INFO (e->dest)->pred_count--;
 574                   changes = 1;
 575                 }
 576               if (bi->pred_count == 1)
 577                 {
 578                   edge e;
 579                   edge_iterator ei;
 580                   gcov_type total = 0;
 581
 582                   /* One of the counts will be invalid, but it is zero,
 583                      so adding it in also doesn't hurt.  */
 584                   FOR_EACH_EDGE (e, ei, bb->preds)
 585                     total += e->count;
 586
 587                   /* Search for the invalid edge, and set its count.  */
 588                   FOR_EACH_EDGE (e, ei, bb->preds)
 589                     if (!EDGE_INFO (e)->count_valid && !EDGE_INFO (e)->ignore)
 590                       break;
 591
 592                   /* Calculate count for remaining edge by conservation.  */
 593                   total = bb->count - total + e->count;
 594
 595                   gcc_assert (e);
 596                   EDGE_INFO (e)->count_valid = 1;
 597                   e->count = total;
 598                   bi->pred_count--;
 599
 600                   BB_INFO (e->src)->succ_count--;
 601                   changes = 1;
 602                 }
 603             }
 604         }
 605     }
 606   if (dump_file)
 607     dump_flow_info (dump_file, dump_flags);
 608
 609   total_num_passes += passes;
 610   if (dump_file)
 611     fprintf (dump_file, "Graph solving took %d passes.\n\n", passes);
 612
 613   /* If the graph has been correctly solved, every block will have a
 614      succ and pred count of zero.  */
 615   FOR_EACH_BB (bb)
 616     {
 617       gcc_assert (!BB_INFO (bb)->succ_count && !BB_INFO (bb)->pred_count);
 618     }
 619
 620   /* Check for inconsistent basic block counts */
 621   inconsistent = is_inconsistent ();
 622
 623   if (inconsistent)
 624    {
 625      if (flag_profile_correction)
 626        {
 627          /* Inconsistency detected. Make it flow-consistent. */
 628          static int informed = 0;
 629          if (informed == 0)
 630            {
 631              informed = 1;
 632              inform (input_location, "correcting inconsistent profile data");
 633            }
 634          correct_negative_edge_counts ();
 635          /* Set bb counts to the sum of the outgoing edge counts */
 636          set_bb_counts ();
 637          if (dump_file)
 638            fprintf (dump_file, "\nCalling mcf_smooth_cfg\n");
 639          mcf_smooth_cfg ();
 640        }
 641      else
 642        error ("corrupted profile info: profile data is not flow-consistent");
 643    }
 644
 645   /* For every edge, calculate its branch probability and add a reg_note
 646      to the branch insn to indicate this.  */
 647
 648   for (i = 0; i < 20; i++)
 649     hist_br_prob[i] = 0;
 650   num_never_executed = 0;
 651   num_branches = 0;
 652
 653   FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, NULL, next_bb)
 654     {
 655       edge e;
 656       edge_iterator ei;
 657
 658       if (bb->count < 0)
 659         {
 660           error ("corrupted profile info: number of iterations for basic block %d thought to be %i",
 661                  bb->index, (int)bb->count);
 662           bb->count = 0;
 663         }
 664       FOR_EACH_EDGE (e, ei, bb->succs)
 665         {
 666           /* Function may return twice in the cased the called function is
 667              setjmp or calls fork, but we can't represent this by extra
 668              edge from the entry, since extra edge from the exit is
 669              already present.  We get negative frequency from the entry
 670              point.  */
 671           if ((e->count < 0
 672                && e->dest == EXIT_BLOCK_PTR)
 673               || (e->count > bb->count
 674                   && e->dest != EXIT_BLOCK_PTR))
 675             {
 676               if (block_ends_with_call_p (bb))
 677                 e->count = e->count < 0 ? 0 : bb->count;
 678             }
 679           if (e->count < 0 || e->count > bb->count)
 680             {
 681               error ("corrupted profile info: number of executions for edge %d-%d thought to be %i",
 682                      e->src->index, e->dest->index,
 683                      (int)e->count);
 684               e->count = bb->count / 2;
 685             }
 686         }
 687       if (bb->count)
 688         {
 689           FOR_EACH_EDGE (e, ei, bb->succs)
 690             e->probability = (e->count * REG_BR_PROB_BASE + bb->count / 2) / bb->count;
 691           if (bb->index >= NUM_FIXED_BLOCKS
 692               && block_ends_with_condjump_p (bb)
 693               && EDGE_COUNT (bb->succs) >= 2)
 694             {
 695               int prob;
 696               edge e;
 697               int index;
 698
 699               /* Find the branch edge.  It is possible that we do have fake
 700                  edges here.  */
 701               FOR_EACH_EDGE (e, ei, bb->succs)
 702                 if (!(e->flags & (EDGE_FAKE | EDGE_FALLTHRU)))
 703                   break;
 704
 705               prob = e->probability;
 706               index = prob * 20 / REG_BR_PROB_BASE;
 707
 708               if (index == 20)
 709                 index = 19;
 710               hist_br_prob[index]++;
 711
 712               num_branches++;
 713             }
 714         }
 715       /* As a last resort, distribute the probabilities evenly.
 716          Use simple heuristics that if there are normal edges,
 717          give all abnormals frequency of 0, otherwise distribute the
 718          frequency over abnormals (this is the case of noreturn
 719          calls).  */
 720       else if (profile_status == PROFILE_ABSENT)
 721         {
 722           int total = 0;
 723
 724           FOR_EACH_EDGE (e, ei, bb->succs)
 725             if (!(e->flags & (EDGE_COMPLEX | EDGE_FAKE)))
 726               total ++;
 727           if (total)
 728             {
 729               FOR_EACH_EDGE (e, ei, bb->succs)
 730                 if (!(e->flags & (EDGE_COMPLEX | EDGE_FAKE)))
 731                   e->probability = REG_BR_PROB_BASE / total;
 732                 else
 733                   e->probability = 0;
 734             }
 735           else
 736             {
 737               total += EDGE_COUNT (bb->succs);
 738               FOR_EACH_EDGE (e, ei, bb->succs)
 739                 e->probability = REG_BR_PROB_BASE / total;
 740             }
 741           if (bb->index >= NUM_FIXED_BLOCKS
 742               && block_ends_with_condjump_p (bb)
 743               && EDGE_COUNT (bb->succs) >= 2)
 744             num_branches++, num_never_executed;
 745         }
 746     }
 747   counts_to_freqs ();
 748   profile_status = PROFILE_READ;
 749
 750   if (dump_file)
 751     {
 752       fprintf (dump_file, "%d branches\n", num_branches);
 753       fprintf (dump_file, "%d branches never executed\n",
 754                num_never_executed);
 755       if (num_branches)
 756         for (i = 0; i < 10; i++)
 757           fprintf (dump_file, "%d%% branches in range %d-%d%%\n",
 758                    (hist_br_prob[i] + hist_br_prob[19-i]) * 100 / num_branches,
 759                    5 * i, 5 * i + 5);
 760
 761       total_num_branches += num_branches;
 762       total_num_never_executed += num_never_executed;
 763       for (i = 0; i < 20; i++)
 764         total_hist_br_prob[i] += hist_br_prob[i];
 765
 766       fputc ('\n', dump_file);
 767       fputc ('\n', dump_file);
 768     }
 769
 770   free_aux_for_blocks ();
 771 }
 772
 773 /* Load value histograms values whose description is stored in VALUES array
 774    from .gcda file.  */
 775
 776 static void
 777 compute_value_histograms (histogram_values values)
 778 {
 779   unsigned i, j, t, any;
 780   unsigned n_histogram_counters[GCOV_N_VALUE_COUNTERS];
 781   gcov_type *histogram_counts[GCOV_N_VALUE_COUNTERS];
 782   gcov_type *act_count[GCOV_N_VALUE_COUNTERS];
 783   gcov_type *aact_count;
 784
 785   for (t = 0; t < GCOV_N_VALUE_COUNTERS; t++)
 786     n_histogram_counters[t] = 0;
 787
 788   for (i = 0; i < VEC_length (histogram_value, values); i++)
 789     {
 790       histogram_value hist = VEC_index (histogram_value, values, i);
 791       n_histogram_counters[(int) hist->type] += hist->n_counters;
 792     }
 793
 794   any = 0;
 795   for (t = 0; t < GCOV_N_VALUE_COUNTERS; t++)
 796     {
 797       if (!n_histogram_counters[t])
 798         {
 799           histogram_counts[t] = NULL;
 800           continue;
 801         }
 802
 803       histogram_counts[t] =
 804         get_coverage_counts (COUNTER_FOR_HIST_TYPE (t),
 805                              n_histogram_counters[t], NULL);
 806       if (histogram_counts[t])
 807         any = 1;
 808       act_count[t] = histogram_counts[t];
 809     }
 810   if (!any)
 811     return;
 812
 813   for (i = 0; i < VEC_length (histogram_value, values); i++)
 814     {
 815       histogram_value hist = VEC_index (histogram_value, values, i);
 816       gimple stmt = hist->hvalue.stmt;
 817
 818       t = (int) hist->type;
 819
 820       aact_count = act_count[t];
 821       act_count[t] += hist->n_counters;
 822
 823       gimple_add_histogram_value (cfun, stmt, hist);
 824       hist->hvalue.counters =  XNEWVEC (gcov_type, hist->n_counters);
 825       for (j = 0; j < hist->n_counters; j++)
 826         hist->hvalue.counters[j] = aact_count[j];
 827     }
 828
 829   for (t = 0; t < GCOV_N_VALUE_COUNTERS; t++)
 830     if (histogram_counts[t])
 831       free (histogram_counts[t]);
 832 }
 833
 834 /* The entry basic block will be moved around so that it has index=1,
 835    there is nothing at index 0 and the exit is at n_basic_block.  */
 836 #define BB_TO_GCOV_INDEX(bb)  ((bb)->index - 1)
 837 /* When passed NULL as file_name, initialize.
 838    When passed something else, output the necessary commands to change
 839    line to LINE and offset to FILE_NAME.  */
 840 static void
 841 output_location (char const *file_name, int line,
 842                  gcov_position_t *offset, basic_block bb)
 843 {
 844   static char const *prev_file_name;
 845   static int prev_line;
 846   bool name_differs, line_differs;
 847
 848   if (!file_name)
 849     {
 850       prev_file_name = NULL;
 851       prev_line = -1;
 852       return;
 853     }
 854
 855   name_differs = !prev_file_name || strcmp (file_name, prev_file_name);
 856   line_differs = prev_line != line;
 857
 858   if (name_differs || line_differs)
 859     {
 860       if (!*offset)
 861         {
 862           *offset = gcov_write_tag (GCOV_TAG_LINES);
 863           gcov_write_unsigned (BB_TO_GCOV_INDEX (bb));
 864           name_differs = line_differs=true;
 865         }
 866
 867       /* If this is a new source file, then output the
 868          file's name to the .bb file.  */
 869       if (name_differs)
 870         {
 871           prev_file_name = file_name;
 872           gcov_write_unsigned (0);
 873           gcov_write_string (prev_file_name);
 874         }
 875       if (line_differs)
 876         {
 877           gcov_write_unsigned (line);
 878           prev_line = line;
 879         }
 880      }
 881 }
 882
 883 /* Instrument and/or analyze program behavior based on program flow graph.
 884    In either case, this function builds a flow graph for the function being
 885    compiled.  The flow graph is stored in BB_GRAPH.
 886
 887    When FLAG_PROFILE_ARCS is nonzero, this function instruments the edges in
 888    the flow graph that are needed to reconstruct the dynamic behavior of the
 889    flow graph.
 890
 891    When FLAG_BRANCH_PROBABILITIES is nonzero, this function reads auxiliary
 892    information from a data file containing edge count information from previous
 893    executions of the function being compiled.  In this case, the flow graph is
 894    annotated with actual execution counts, which are later propagated into the
 895    rtl for optimization purposes.
 896
 897    Main entry point of this file.  */
 898
 899 void
 900 branch_prob (void)
 901 {
 902   basic_block bb;
 903   unsigned i;
 904   unsigned num_edges, ignored_edges;
 905   unsigned num_instrumented;
 906   struct edge_list *el;
 907   histogram_values values = NULL;
 908
 909   total_num_times_called++;
 910
 911   flow_call_edges_add (NULL);
 912   add_noreturn_fake_exit_edges ();
 913
 914   /* We can't handle cyclic regions constructed using abnormal edges.
 915      To avoid these we replace every source of abnormal edge by a fake
 916      edge from entry node and every destination by fake edge to exit.
 917      This keeps graph acyclic and our calculation exact for all normal
 918      edges except for exit and entrance ones.
 919
 920      We also add fake exit edges for each call and asm statement in the
 921      basic, since it may not return.  */
 922
 923   FOR_EACH_BB (bb)
 924     {
 925       int need_exit_edge = 0, need_entry_edge = 0;
 926       int have_exit_edge = 0, have_entry_edge = 0;
 927       edge e;
 928       edge_iterator ei;
 929
 930       /* Functions returning multiple times are not handled by extra edges.
 931          Instead we simply allow negative counts on edges from exit to the
 932          block past call and corresponding probabilities.  We can't go
 933          with the extra edges because that would result in flowgraph that
 934          needs to have fake edges outside the spanning tree.  */
 935
 936       FOR_EACH_EDGE (e, ei, bb->succs)
 937         {
 938           gimple_stmt_iterator gsi;
 939           gimple last = NULL;
 940
 941           /* It may happen that there are compiler generated statements
 942              without a locus at all.  Go through the basic block from the
 943              last to the first statement looking for a locus.  */
 944           for (gsi = gsi_last_bb (bb); !gsi_end_p (gsi); gsi_prev (&gsi))
 945             {
 946               last = gsi_stmt (gsi);
 947               if (gimple_has_location (last))
 948                 break;
 949             }
 950
 951           /* Edge with goto locus might get wrong coverage info unless
 952              it is the only edge out of BB.
 953              Don't do that when the locuses match, so
 954              if (blah) goto something;
 955              is not computed twice.  */
 956           if (last
 957               && gimple_has_location (last)
 958               && e->goto_locus != UNKNOWN_LOCATION
 959               && !single_succ_p (bb)
 960               && (LOCATION_FILE (e->goto_locus)
 961                   != LOCATION_FILE (gimple_location (last))
 962                   || (LOCATION_LINE (e->goto_locus)
 963                       != LOCATION_LINE (gimple_location (last)))))
 964             {
 965               basic_block new_bb = split_edge (e);
 966               edge ne = single_succ_edge (new_bb);
 967               ne->goto_locus = e->goto_locus;
 968               ne->goto_block = e->goto_block;
 969             }
 970           if ((e->flags & (EDGE_ABNORMAL | EDGE_ABNORMAL_CALL))
 971                && e->dest != EXIT_BLOCK_PTR)
 972             need_exit_edge = 1;
 973           if (e->dest == EXIT_BLOCK_PTR)
 974             have_exit_edge = 1;
 975         }
 976       FOR_EACH_EDGE (e, ei, bb->preds)
 977         {
 978           if ((e->flags & (EDGE_ABNORMAL | EDGE_ABNORMAL_CALL))
 979                && e->src != ENTRY_BLOCK_PTR)
 980             need_entry_edge = 1;
 981           if (e->src == ENTRY_BLOCK_PTR)
 982             have_entry_edge = 1;
 983         }
 984
 985       if (need_exit_edge && !have_exit_edge)
 986         {
 987           if (dump_file)
 988             fprintf (dump_file, "Adding fake exit edge to bb %i\n",
 989                      bb->index);
 990           make_edge (bb, EXIT_BLOCK_PTR, EDGE_FAKE);
 991         }
 992       if (need_entry_edge && !have_entry_edge)
 993         {
 994           if (dump_file)
 995             fprintf (dump_file, "Adding fake entry edge to bb %i\n",
 996                      bb->index);
 997           make_edge (ENTRY_BLOCK_PTR, bb, EDGE_FAKE);
 998         }
 999     }
1000
1001   el = create_edge_list ();
1002   num_edges = NUM_EDGES (el);
1003   alloc_aux_for_edges (sizeof (struct edge_info));
1004
1005   /* The basic blocks are expected to be numbered sequentially.  */
1006   compact_blocks ();
1007
1008   ignored_edges = 0;
1009   for (i = 0 ; i < num_edges ; i++)
1010     {
1011       edge e = INDEX_EDGE (el, i);
1012       e->count = 0;
1013
1014       /* Mark edges we've replaced by fake edges above as ignored.  */
1015       if ((e->flags & (EDGE_ABNORMAL | EDGE_ABNORMAL_CALL))
1016           && e->src != ENTRY_BLOCK_PTR && e->dest != EXIT_BLOCK_PTR)
1017         {
1018           EDGE_INFO (e)->ignore = 1;
1019           ignored_edges++;
1020         }
1021     }
1022
1023   /* Create spanning tree from basic block graph, mark each edge that is
1024      on the spanning tree.  We insert as many abnormal and critical edges
1025      as possible to minimize number of edge splits necessary.  */
1026
1027   find_spanning_tree (el);
1028
1029   /* Fake edges that are not on the tree will not be instrumented, so
1030      mark them ignored.  */
1031   for (num_instrumented = i = 0; i < num_edges; i++)
1032     {
1033       edge e = INDEX_EDGE (el, i);
1034       struct edge_info *inf = EDGE_INFO (e);
1035
1036       if (inf->ignore || inf->on_tree)
1037         /*NOP*/;
1038       else if (e->flags & EDGE_FAKE)
1039         {
1040           inf->ignore = 1;
1041           ignored_edges++;
1042         }
1043       else
1044         num_instrumented++;
1045     }
1046
1047   total_num_blocks += n_basic_blocks;
1048   if (dump_file)
1049     fprintf (dump_file, "%d basic blocks\n", n_basic_blocks);
1050
1051   total_num_edges += num_edges;
1052   if (dump_file)
1053     fprintf (dump_file, "%d edges\n", num_edges);
1054
1055   total_num_edges_ignored += ignored_edges;
1056   if (dump_file)
1057     fprintf (dump_file, "%d ignored edges\n", ignored_edges);
1058
1059   /* Write the data from which gcov can reconstruct the basic block
1060      graph.  */
1061
1062   /* Basic block flags */
1063   if (coverage_begin_output ())
1064     {
1065       gcov_position_t offset;
1066
1067       offset = gcov_write_tag (GCOV_TAG_BLOCKS);
1068       for (i = 0; i != (unsigned) (n_basic_blocks); i++)
1069         gcov_write_unsigned (0);
1070       gcov_write_length (offset);
1071     }
1072
1073    /* Keep all basic block indexes nonnegative in the gcov output.
1074       Index 0 is used for entry block, last index is for exit block.
1075       */
1076   ENTRY_BLOCK_PTR->index = 1;
1077   EXIT_BLOCK_PTR->index = last_basic_block;
1078
1079   /* Arcs */
1080   if (coverage_begin_output ())
1081     {
1082       gcov_position_t offset;
1083
1084       FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR, next_bb)
1085         {
1086           edge e;
1087           edge_iterator ei;
1088
1089           offset = gcov_write_tag (GCOV_TAG_ARCS);
1090           gcov_write_unsigned (BB_TO_GCOV_INDEX (bb));
1091
1092           FOR_EACH_EDGE (e, ei, bb->succs)
1093             {
1094               struct edge_info *i = EDGE_INFO (e);
1095               if (!i->ignore)
1096                 {
1097                   unsigned flag_bits = 0;
1098
1099                   if (i->on_tree)
1100                     flag_bits |= GCOV_ARC_ON_TREE;
1101                   if (e->flags & EDGE_FAKE)
1102                     flag_bits |= GCOV_ARC_FAKE;
1103                   if (e->flags & EDGE_FALLTHRU)
1104                     flag_bits |= GCOV_ARC_FALLTHROUGH;
1105                   /* On trees we don't have fallthru flags, but we can
1106                      recompute them from CFG shape.  */
1107                   if (e->flags & (EDGE_TRUE_VALUE | EDGE_FALSE_VALUE)
1108                       && e->src->next_bb == e->dest)
1109                     flag_bits |= GCOV_ARC_FALLTHROUGH;
1110
1111                   gcov_write_unsigned (BB_TO_GCOV_INDEX (e->dest));
1112                   gcov_write_unsigned (flag_bits);
1113                 }
1114             }
1115
1116           gcov_write_length (offset);
1117         }
1118     }
1119
1120   /* Line numbers.  */
1121   if (coverage_begin_output ())
1122     {
1123       gcov_position_t offset;
1124
1125       /* Initialize the output.  */
1126       output_location (NULL, 0, NULL, NULL);
1127
1128       FOR_EACH_BB (bb)
1129         {
1130           gimple_stmt_iterator gsi;
1131
1132           offset = 0;
1133
1134           if (bb == ENTRY_BLOCK_PTR->next_bb)
1135             {
1136               expanded_location curr_location =
1137                 expand_location (DECL_SOURCE_LOCATION (current_function_decl));
1138               output_location (curr_location.file, curr_location.line,
1139                                &offset, bb);
1140             }
1141
1142           for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
1143             {
1144               gimple stmt = gsi_stmt (gsi);
1145               if (gimple_has_location (stmt))
1146                 output_location (gimple_filename (stmt), gimple_lineno (stmt),
1147                                  &offset, bb);
1148             }
1149
1150           /* Notice GOTO expressions we eliminated while constructing the
1151              CFG.  */
1152           if (single_succ_p (bb)
1153               && single_succ_edge (bb)->goto_locus != UNKNOWN_LOCATION)
1154             {
1155               location_t curr_location = single_succ_edge (bb)->goto_locus;
1156               /* ??? The FILE/LINE API is inconsistent for these cases.  */
1157               output_location (LOCATION_FILE (curr_location),
1158                                LOCATION_LINE (curr_location), &offset, bb);
1159             }
1160
1161           if (offset)
1162             {
1163               /* A file of NULL indicates the end of run.  */
1164               gcov_write_unsigned (0);
1165               gcov_write_string (NULL);
1166               gcov_write_length (offset);
1167             }
1168         }
1169     }
1170
1171   ENTRY_BLOCK_PTR->index = ENTRY_BLOCK;
1172   EXIT_BLOCK_PTR->index = EXIT_BLOCK;
1173 #undef BB_TO_GCOV_INDEX
1174
1175   if (flag_profile_values)
1176     find_values_to_profile (&values);
1177
1178   if (flag_branch_probabilities)
1179     {
1180       compute_branch_probabilities ();
1181       if (flag_profile_values)
1182         compute_value_histograms (values);
1183     }
1184
1185   remove_fake_edges ();
1186
1187   /* For each edge not on the spanning tree, add counting code.  */
1188   if (profile_arc_flag
1189       && coverage_counter_alloc (GCOV_COUNTER_ARCS, num_instrumented))
1190     {
1191       unsigned n_instrumented;
1192
1193       profile_hooks->init_edge_profiler ();
1194
1195       n_instrumented = instrument_edges (el);
1196
1197       gcc_assert (n_instrumented == num_instrumented);
1198
1199       if (flag_profile_values)
1200         instrument_values (values);
1201
1202       /* Commit changes done by instrumentation.  */
1203       gsi_commit_edge_inserts ();
1204     }
1205
1206   free_aux_for_edges ();
1207
1208   VEC_free (histogram_value, heap, values);
1209   free_edge_list (el);
1210   coverage_end_function ();
1211 }
1212 \f
1213 /* Union find algorithm implementation for the basic blocks using
1214    aux fields.  */
1215
1216 static basic_block
1217 find_group (basic_block bb)
1218 {
1219   basic_block group = bb, bb1;
1220
1221   while ((basic_block) group->aux != group)
1222     group = (basic_block) group->aux;
1223
1224   /* Compress path.  */
1225   while ((basic_block) bb->aux != group)
1226     {
1227       bb1 = (basic_block) bb->aux;
1228       bb->aux = (void *) group;
1229       bb = bb1;
1230     }
1231   return group;
1232 }
1233
1234 static void
1235 union_groups (basic_block bb1, basic_block bb2)
1236 {
1237   basic_block bb1g = find_group (bb1);
1238   basic_block bb2g = find_group (bb2);
1239
1240   /* ??? I don't have a place for the rank field.  OK.  Lets go w/o it,
1241      this code is unlikely going to be performance problem anyway.  */
1242   gcc_assert (bb1g != bb2g);
1243
1244   bb1g->aux = bb2g;
1245 }
1246 \f
1247 /* This function searches all of the edges in the program flow graph, and puts
1248    as many bad edges as possible onto the spanning tree.  Bad edges include
1249    abnormals edges, which can't be instrumented at the moment.  Since it is
1250    possible for fake edges to form a cycle, we will have to develop some
1251    better way in the future.  Also put critical edges to the tree, since they
1252    are more expensive to instrument.  */
1253
1254 static void
1255 find_spanning_tree (struct edge_list *el)
1256 {
1257   int i;
1258   int num_edges = NUM_EDGES (el);
1259   basic_block bb;
1260
1261   /* We use aux field for standard union-find algorithm.  */
1262   FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, NULL, next_bb)
1263     bb->aux = bb;
1264
1265   /* Add fake edge exit to entry we can't instrument.  */
1266   union_groups (EXIT_BLOCK_PTR, ENTRY_BLOCK_PTR);
1267
1268   /* First add all abnormal edges to the tree unless they form a cycle. Also
1269      add all edges to EXIT_BLOCK_PTR to avoid inserting profiling code behind
1270      setting return value from function.  */
1271   for (i = 0; i < num_edges; i++)
1272     {
1273       edge e = INDEX_EDGE (el, i);
1274       if (((e->flags & (EDGE_ABNORMAL | EDGE_ABNORMAL_CALL | EDGE_FAKE))
1275            || e->dest == EXIT_BLOCK_PTR)
1276           && !EDGE_INFO (e)->ignore
1277           && (find_group (e->src) != find_group (e->dest)))
1278         {
1279           if (dump_file)
1280             fprintf (dump_file, "Abnormal edge %d to %d put to tree\n",
1281                      e->src->index, e->dest->index);
1282           EDGE_INFO (e)->on_tree = 1;
1283           union_groups (e->src, e->dest);
1284         }
1285     }
1286
1287   /* Now insert all critical edges to the tree unless they form a cycle.  */
1288   for (i = 0; i < num_edges; i++)
1289     {
1290       edge e = INDEX_EDGE (el, i);
1291       if (EDGE_CRITICAL_P (e) && !EDGE_INFO (e)->ignore
1292           && find_group (e->src) != find_group (e->dest))
1293         {
1294           if (dump_file)
1295             fprintf (dump_file, "Critical edge %d to %d put to tree\n",
1296                      e->src->index, e->dest->index);
1297           EDGE_INFO (e)->on_tree = 1;
1298           union_groups (e->src, e->dest);
1299         }
1300     }
1301
1302   /* And now the rest.  */
1303   for (i = 0; i < num_edges; i++)
1304     {
1305       edge e = INDEX_EDGE (el, i);
1306       if (!EDGE_INFO (e)->ignore
1307           && find_group (e->src) != find_group (e->dest))
1308         {
1309           if (dump_file)
1310             fprintf (dump_file, "Normal edge %d to %d put to tree\n",
1311                      e->src->index, e->dest->index);
1312           EDGE_INFO (e)->on_tree = 1;
1313           union_groups (e->src, e->dest);
1314         }
1315     }
1316
1317   FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, NULL, next_bb)
1318     bb->aux = NULL;
1319 }
1320 \f
1321 /* Perform file-level initialization for branch-prob processing.  */
1322
1323 void
1324 init_branch_prob (void)
1325 {
1326   int i;
1327
1328   total_num_blocks = 0;
1329   total_num_edges = 0;
1330   total_num_edges_ignored = 0;
1331   total_num_edges_instrumented = 0;
1332   total_num_blocks_created = 0;
1333   total_num_passes = 0;
1334   total_num_times_called = 0;
1335   total_num_branches = 0;
1336   total_num_never_executed = 0;
1337   for (i = 0; i < 20; i++)
1338     total_hist_br_prob[i] = 0;
1339 }
1340
1341 /* Performs file-level cleanup after branch-prob processing
1342    is completed.  */
1343
1344 void
1345 end_branch_prob (void)
1346 {
1347   if (dump_file)
1348     {
1349       fprintf (dump_file, "\n");
1350       fprintf (dump_file, "Total number of blocks: %d\n",
1351                total_num_blocks);
1352       fprintf (dump_file, "Total number of edges: %d\n", total_num_edges);
1353       fprintf (dump_file, "Total number of ignored edges: %d\n",
1354                total_num_edges_ignored);
1355       fprintf (dump_file, "Total number of instrumented edges: %d\n",
1356                total_num_edges_instrumented);
1357       fprintf (dump_file, "Total number of blocks created: %d\n",
1358                total_num_blocks_created);
1359       fprintf (dump_file, "Total number of graph solution passes: %d\n",
1360                total_num_passes);
1361       if (total_num_times_called != 0)
1362         fprintf (dump_file, "Average number of graph solution passes: %d\n",
1363                  (total_num_passes + (total_num_times_called  >> 1))
1364                  / total_num_times_called);
1365       fprintf (dump_file, "Total number of branches: %d\n",
1366                total_num_branches);
1367       fprintf (dump_file, "Total number of branches never executed: %d\n",
1368                total_num_never_executed);
1369       if (total_num_branches)
1370         {
1371           int i;
1372
1373           for (i = 0; i < 10; i++)
1374             fprintf (dump_file, "%d%% branches in range %d-%d%%\n",
1375                      (total_hist_br_prob[i] + total_hist_br_prob[19-i]) * 100
1376                      / total_num_branches, 5*i, 5*i+5);
1377         }
1378     }
1379 }
1380
1381 /* Set up hooks to enable tree-based profiling.  */
1382
1383 void
1384 tree_register_profile_hooks (void)
1385 {
1386   gcc_assert (current_ir_type () == IR_GIMPLE);
1387   profile_hooks = &tree_profile_hooks;
1388 }