gcc/tree-profile.c

   1 /* Calculate branch probabilities, and basic block execution counts.
   2    Copyright (C) 1990-2016 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.
   6    Converted to use trees by Dale Johannesen, Apple Computer.
   7
   8 This file is part of GCC.
   9
  10 GCC is free software; you can redistribute it and/or modify it under
  11 the terms of the GNU General Public License as published by the Free
  12 Software Foundation; either version 3, or (at your option) any later
  13 version.
  14
  15 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  16 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  17 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  18 for more details.
  19
  20 You should have received a copy of the GNU General Public License
  21 along with GCC; see the file COPYING3.  If not see
  22 <http://www.gnu.org/licenses/>.  */
  23
  24 /* Generate basic block profile instrumentation and auxiliary files.
  25    Tree-based version.  See profile.c for overview.  */
  26
  27 #include "config.h"
  28 #include "system.h"
  29 #include "coretypes.h"
  30 #include "backend.h"
  31 #include "target.h"
  32 #include "tree.h"
  33 #include "gimple.h"
  34 #include "cfghooks.h"
  35 #include "tree-pass.h"
  36 #include "ssa.h"
  37 #include "cgraph.h"
  38 #include "coverage.h"
  39 #include "diagnostic-core.h"
  40 #include "fold-const.h"
  41 #include "varasm.h"
  42 #include "tree-nested.h"
  43 #include "gimplify.h"
  44 #include "gimple-iterator.h"
  45 #include "gimplify-me.h"
  46 #include "tree-cfg.h"
  47 #include "tree-into-ssa.h"
  48 #include "value-prof.h"
  49 #include "profile.h"
  50 #include "tree-cfgcleanup.h"
  51 #include "params.h"
  52
  53 static GTY(()) tree gcov_type_node;
  54 static GTY(()) tree tree_interval_profiler_fn;
  55 static GTY(()) tree tree_pow2_profiler_fn;
  56 static GTY(()) tree tree_one_value_profiler_fn;
  57 static GTY(()) tree tree_indirect_call_profiler_fn;
  58 static GTY(()) tree tree_time_profiler_fn;
  59 static GTY(()) tree tree_average_profiler_fn;
  60 static GTY(()) tree tree_ior_profiler_fn;
  61
  62
  63 static GTY(()) tree ic_void_ptr_var;
  64 static GTY(()) tree ic_gcov_type_ptr_var;
  65 static GTY(()) tree ptr_void;
  66
  67 /* Do initialization work for the edge profiler.  */
  68
  69 /* Add code:
  70    __thread gcov*       __gcov_indirect_call_counters; // pointer to actual counter
  71    __thread void*       __gcov_indirect_call_callee; // actual callee address
  72    __thread int __gcov_function_counter; // time profiler function counter
  73 */
  74 static void
  75 init_ic_make_global_vars (void)
  76 {
  77   tree  gcov_type_ptr;
  78
  79   ptr_void = build_pointer_type (void_type_node);
  80
  81   ic_void_ptr_var
  82     = build_decl (UNKNOWN_LOCATION, VAR_DECL,
  83                   get_identifier (
  84                           (PARAM_VALUE (PARAM_INDIR_CALL_TOPN_PROFILE) ?
  85                            "__gcov_indirect_call_topn_callee" :
  86                            "__gcov_indirect_call_callee")),
  87                   ptr_void);
  88   TREE_PUBLIC (ic_void_ptr_var) = 1;
  89   DECL_EXTERNAL (ic_void_ptr_var) = 1;
  90   TREE_STATIC (ic_void_ptr_var) = 1;
  91   DECL_ARTIFICIAL (ic_void_ptr_var) = 1;
  92   DECL_INITIAL (ic_void_ptr_var) = NULL;
  93   if (targetm.have_tls)
  94     set_decl_tls_model (ic_void_ptr_var, decl_default_tls_model (ic_void_ptr_var));
  95
  96   varpool_node::finalize_decl (ic_void_ptr_var);
  97
  98   gcov_type_ptr = build_pointer_type (get_gcov_type ());
  99
 100   ic_gcov_type_ptr_var
 101     = build_decl (UNKNOWN_LOCATION, VAR_DECL,
 102                   get_identifier (
 103                           (PARAM_VALUE (PARAM_INDIR_CALL_TOPN_PROFILE) ?
 104                            "__gcov_indirect_call_topn_counters" :
 105                            "__gcov_indirect_call_counters")),
 106                   gcov_type_ptr);
 107   TREE_PUBLIC (ic_gcov_type_ptr_var) = 1;
 108   DECL_EXTERNAL (ic_gcov_type_ptr_var) = 1;
 109   TREE_STATIC (ic_gcov_type_ptr_var) = 1;
 110   DECL_ARTIFICIAL (ic_gcov_type_ptr_var) = 1;
 111   DECL_INITIAL (ic_gcov_type_ptr_var) = NULL;
 112   if (targetm.have_tls)
 113     set_decl_tls_model (ic_gcov_type_ptr_var, decl_default_tls_model (ic_gcov_type_ptr_var));
 114
 115   varpool_node::finalize_decl (ic_gcov_type_ptr_var);
 116 }
 117
 118 /* Create the type and function decls for the interface with gcov.  */
 119
 120 void
 121 gimple_init_edge_profiler (void)
 122 {
 123   tree interval_profiler_fn_type;
 124   tree pow2_profiler_fn_type;
 125   tree one_value_profiler_fn_type;
 126   tree gcov_type_ptr;
 127   tree ic_profiler_fn_type;
 128   tree average_profiler_fn_type;
 129   tree time_profiler_fn_type;
 130   const char *profiler_fn_name;
 131   const char *fn_name;
 132
 133   if (!gcov_type_node)
 134     {
 135       const char *fn_suffix
 136         = flag_profile_update == PROFILE_UPDATE_ATOMIC ? "_atomic" : "";
 137
 138       gcov_type_node = get_gcov_type ();
 139       gcov_type_ptr = build_pointer_type (gcov_type_node);
 140
 141       /* void (*) (gcov_type *, gcov_type, int, unsigned)  */
 142       interval_profiler_fn_type
 143               = build_function_type_list (void_type_node,
 144                                           gcov_type_ptr, gcov_type_node,
 145                                           integer_type_node,
 146                                           unsigned_type_node, NULL_TREE);
 147       fn_name = concat ("__gcov_interval_profiler", fn_suffix, NULL);
 148       tree_interval_profiler_fn = build_fn_decl (fn_name,
 149                                                  interval_profiler_fn_type);
 150       free (CONST_CAST (char *, fn_name));
 151       TREE_NOTHROW (tree_interval_profiler_fn) = 1;
 152       DECL_ATTRIBUTES (tree_interval_profiler_fn)
 153         = tree_cons (get_identifier ("leaf"), NULL,
 154                      DECL_ATTRIBUTES (tree_interval_profiler_fn));
 155
 156       /* void (*) (gcov_type *, gcov_type)  */
 157       pow2_profiler_fn_type
 158               = build_function_type_list (void_type_node,
 159                                           gcov_type_ptr, gcov_type_node,
 160                                           NULL_TREE);
 161       fn_name = concat ("__gcov_pow2_profiler", fn_suffix, NULL);
 162       tree_pow2_profiler_fn = build_fn_decl (fn_name, pow2_profiler_fn_type);
 163       free (CONST_CAST (char *, fn_name));
 164       TREE_NOTHROW (tree_pow2_profiler_fn) = 1;
 165       DECL_ATTRIBUTES (tree_pow2_profiler_fn)
 166         = tree_cons (get_identifier ("leaf"), NULL,
 167                      DECL_ATTRIBUTES (tree_pow2_profiler_fn));
 168
 169       /* void (*) (gcov_type *, gcov_type)  */
 170       one_value_profiler_fn_type
 171               = build_function_type_list (void_type_node,
 172                                           gcov_type_ptr, gcov_type_node,
 173                                           NULL_TREE);
 174       fn_name = concat ("__gcov_one_value_profiler", fn_suffix, NULL);
 175       tree_one_value_profiler_fn = build_fn_decl (fn_name,
 176                                                   one_value_profiler_fn_type);
 177       free (CONST_CAST (char *, fn_name));
 178       TREE_NOTHROW (tree_one_value_profiler_fn) = 1;
 179       DECL_ATTRIBUTES (tree_one_value_profiler_fn)
 180         = tree_cons (get_identifier ("leaf"), NULL,
 181                      DECL_ATTRIBUTES (tree_one_value_profiler_fn));
 182
 183       init_ic_make_global_vars ();
 184
 185       /* void (*) (gcov_type, void *)  */
 186       ic_profiler_fn_type
 187                = build_function_type_list (void_type_node,
 188                                           gcov_type_node,
 189                                           ptr_void,
 190                                           NULL_TREE);
 191       profiler_fn_name = "__gcov_indirect_call_profiler_v2";
 192       if (PARAM_VALUE (PARAM_INDIR_CALL_TOPN_PROFILE))
 193         profiler_fn_name = "__gcov_indirect_call_topn_profiler";
 194
 195       tree_indirect_call_profiler_fn
 196               = build_fn_decl (profiler_fn_name, ic_profiler_fn_type);
 197
 198       TREE_NOTHROW (tree_indirect_call_profiler_fn) = 1;
 199       DECL_ATTRIBUTES (tree_indirect_call_profiler_fn)
 200         = tree_cons (get_identifier ("leaf"), NULL,
 201                      DECL_ATTRIBUTES (tree_indirect_call_profiler_fn));
 202
 203       /* void (*) (gcov_type *, gcov_type, void *)  */
 204       time_profiler_fn_type
 205                = build_function_type_list (void_type_node,
 206                                           gcov_type_ptr, NULL_TREE);
 207       fn_name = concat ("__gcov_time_profiler", fn_suffix, NULL);
 208       tree_time_profiler_fn = build_fn_decl (fn_name, time_profiler_fn_type);
 209       free (CONST_CAST (char *, fn_name));
 210       TREE_NOTHROW (tree_time_profiler_fn) = 1;
 211       DECL_ATTRIBUTES (tree_time_profiler_fn)
 212         = tree_cons (get_identifier ("leaf"), NULL,
 213                      DECL_ATTRIBUTES (tree_time_profiler_fn));
 214
 215       /* void (*) (gcov_type *, gcov_type)  */
 216       average_profiler_fn_type
 217               = build_function_type_list (void_type_node,
 218                                           gcov_type_ptr, gcov_type_node, NULL_TREE);
 219       fn_name = concat ("__gcov_average_profiler", fn_suffix, NULL);
 220       tree_average_profiler_fn = build_fn_decl (fn_name,
 221                                                 average_profiler_fn_type);
 222       free (CONST_CAST (char *, fn_name));
 223       TREE_NOTHROW (tree_average_profiler_fn) = 1;
 224       DECL_ATTRIBUTES (tree_average_profiler_fn)
 225         = tree_cons (get_identifier ("leaf"), NULL,
 226                      DECL_ATTRIBUTES (tree_average_profiler_fn));
 227       fn_name = concat ("__gcov_ior_profiler", fn_suffix, NULL);
 228       tree_ior_profiler_fn = build_fn_decl (fn_name, average_profiler_fn_type);
 229       free (CONST_CAST (char *, fn_name));
 230       TREE_NOTHROW (tree_ior_profiler_fn) = 1;
 231       DECL_ATTRIBUTES (tree_ior_profiler_fn)
 232         = tree_cons (get_identifier ("leaf"), NULL,
 233                      DECL_ATTRIBUTES (tree_ior_profiler_fn));
 234
 235       /* LTO streamer needs assembler names.  Because we create these decls
 236          late, we need to initialize them by hand.  */
 237       DECL_ASSEMBLER_NAME (tree_interval_profiler_fn);
 238       DECL_ASSEMBLER_NAME (tree_pow2_profiler_fn);
 239       DECL_ASSEMBLER_NAME (tree_one_value_profiler_fn);
 240       DECL_ASSEMBLER_NAME (tree_indirect_call_profiler_fn);
 241       DECL_ASSEMBLER_NAME (tree_time_profiler_fn);
 242       DECL_ASSEMBLER_NAME (tree_average_profiler_fn);
 243       DECL_ASSEMBLER_NAME (tree_ior_profiler_fn);
 244     }
 245 }
 246
 247 /* Output instructions as GIMPLE trees to increment the edge
 248    execution count, and insert them on E.  We rely on
 249    gsi_insert_on_edge to preserve the order.  */
 250
 251 void
 252 gimple_gen_edge_profiler (int edgeno, edge e)
 253 {
 254   tree one;
 255
 256   one = build_int_cst (gcov_type_node, 1);
 257
 258   if (flag_profile_update == PROFILE_UPDATE_ATOMIC)
 259     {
 260       /* __atomic_fetch_add (&counter, 1, MEMMODEL_RELAXED); */
 261       tree addr = tree_coverage_counter_addr (GCOV_COUNTER_ARCS, edgeno);
 262       tree f = builtin_decl_explicit (LONG_LONG_TYPE_SIZE > 32
 263                                       ? BUILT_IN_ATOMIC_FETCH_ADD_8:
 264                                       BUILT_IN_ATOMIC_FETCH_ADD_4);
 265       gcall *stmt = gimple_build_call (f, 3, addr, one,
 266                                        build_int_cst (integer_type_node,
 267                                                       MEMMODEL_RELAXED));
 268       gsi_insert_on_edge (e, stmt);
 269     }
 270   else
 271     {
 272       tree ref = tree_coverage_counter_ref (GCOV_COUNTER_ARCS, edgeno);
 273       tree gcov_type_tmp_var = make_temp_ssa_name (gcov_type_node,
 274                                                    NULL, "PROF_edge_counter");
 275       gassign *stmt1 = gimple_build_assign (gcov_type_tmp_var, ref);
 276       gcov_type_tmp_var = make_temp_ssa_name (gcov_type_node,
 277                                               NULL, "PROF_edge_counter");
 278       gassign *stmt2 = gimple_build_assign (gcov_type_tmp_var, PLUS_EXPR,
 279                                             gimple_assign_lhs (stmt1), one);
 280       gassign *stmt3 = gimple_build_assign (unshare_expr (ref),
 281                                             gimple_assign_lhs (stmt2));
 282       gsi_insert_on_edge (e, stmt1);
 283       gsi_insert_on_edge (e, stmt2);
 284       gsi_insert_on_edge (e, stmt3);
 285     }
 286 }
 287
 288 /* Emits code to get VALUE to instrument at GSI, and returns the
 289    variable containing the value.  */
 290
 291 static tree
 292 prepare_instrumented_value (gimple_stmt_iterator *gsi, histogram_value value)
 293 {
 294   tree val = value->hvalue.value;
 295   if (POINTER_TYPE_P (TREE_TYPE (val)))
 296     val = fold_convert (build_nonstandard_integer_type
 297                           (TYPE_PRECISION (TREE_TYPE (val)), 1), val);
 298   return force_gimple_operand_gsi (gsi, fold_convert (gcov_type_node, val),
 299                                    true, NULL_TREE, true, GSI_SAME_STMT);
 300 }
 301
 302 /* Output instructions as GIMPLE trees to increment the interval histogram
 303    counter.  VALUE is the expression whose value is profiled.  TAG is the
 304    tag of the section for counters, BASE is offset of the counter position.  */
 305
 306 void
 307 gimple_gen_interval_profiler (histogram_value value, unsigned tag, unsigned base)
 308 {
 309   gimple *stmt = value->hvalue.stmt;
 310   gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
 311   tree ref = tree_coverage_counter_ref (tag, base), ref_ptr;
 312   gcall *call;
 313   tree val;
 314   tree start = build_int_cst_type (integer_type_node,
 315                                    value->hdata.intvl.int_start);
 316   tree steps = build_int_cst_type (unsigned_type_node,
 317                                    value->hdata.intvl.steps);
 318
 319   ref_ptr = force_gimple_operand_gsi (&gsi,
 320                                       build_addr (ref),
 321                                       true, NULL_TREE, true, GSI_SAME_STMT);
 322   val = prepare_instrumented_value (&gsi, value);
 323   call = gimple_build_call (tree_interval_profiler_fn, 4,
 324                             ref_ptr, val, start, steps);
 325   gsi_insert_before (&gsi, call, GSI_NEW_STMT);
 326 }
 327
 328 /* Output instructions as GIMPLE trees to increment the power of two histogram
 329    counter.  VALUE is the expression whose value is profiled.  TAG is the tag
 330    of the section for counters, BASE is offset of the counter position.  */
 331
 332 void
 333 gimple_gen_pow2_profiler (histogram_value value, unsigned tag, unsigned base)
 334 {
 335   gimple *stmt = value->hvalue.stmt;
 336   gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
 337   tree ref_ptr = tree_coverage_counter_addr (tag, base);
 338   gcall *call;
 339   tree val;
 340
 341   ref_ptr = force_gimple_operand_gsi (&gsi, ref_ptr,
 342                                       true, NULL_TREE, true, GSI_SAME_STMT);
 343   val = prepare_instrumented_value (&gsi, value);
 344   call = gimple_build_call (tree_pow2_profiler_fn, 2, ref_ptr, val);
 345   gsi_insert_before (&gsi, call, GSI_NEW_STMT);
 346 }
 347
 348 /* Output instructions as GIMPLE trees for code to find the most common value.
 349    VALUE is the expression whose value is profiled.  TAG is the tag of the
 350    section for counters, BASE is offset of the counter position.  */
 351
 352 void
 353 gimple_gen_one_value_profiler (histogram_value value, unsigned tag, unsigned base)
 354 {
 355   gimple *stmt = value->hvalue.stmt;
 356   gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
 357   tree ref_ptr = tree_coverage_counter_addr (tag, base);
 358   gcall *call;
 359   tree val;
 360
 361   ref_ptr = force_gimple_operand_gsi (&gsi, ref_ptr,
 362                                       true, NULL_TREE, true, GSI_SAME_STMT);
 363   val = prepare_instrumented_value (&gsi, value);
 364   call = gimple_build_call (tree_one_value_profiler_fn, 2, ref_ptr, val);
 365   gsi_insert_before (&gsi, call, GSI_NEW_STMT);
 366 }
 367
 368
 369 /* Output instructions as GIMPLE trees for code to find the most
 370    common called function in indirect call.
 371    VALUE is the call expression whose indirect callee is profiled.
 372    TAG is the tag of the section for counters, BASE is offset of the
 373    counter position.  */
 374
 375 void
 376 gimple_gen_ic_profiler (histogram_value value, unsigned tag, unsigned base)
 377 {
 378   tree tmp1;
 379   gassign *stmt1, *stmt2, *stmt3;
 380   gimple *stmt = value->hvalue.stmt;
 381   gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
 382   tree ref_ptr = tree_coverage_counter_addr (tag, base);
 383
 384   if ( (PARAM_VALUE (PARAM_INDIR_CALL_TOPN_PROFILE) &&
 385         tag == GCOV_COUNTER_V_INDIR) ||
 386        (!PARAM_VALUE (PARAM_INDIR_CALL_TOPN_PROFILE) &&
 387         tag == GCOV_COUNTER_ICALL_TOPNV))
 388     return;
 389
 390   ref_ptr = force_gimple_operand_gsi (&gsi, ref_ptr,
 391                                       true, NULL_TREE, true, GSI_SAME_STMT);
 392
 393   /* Insert code:
 394
 395     stmt1: __gcov_indirect_call_counters = get_relevant_counter_ptr ();
 396     stmt2: tmp1 = (void *) (indirect call argument value)
 397     stmt3: __gcov_indirect_call_callee = tmp1;
 398    */
 399
 400   stmt1 = gimple_build_assign (ic_gcov_type_ptr_var, ref_ptr);
 401   tmp1 = make_temp_ssa_name (ptr_void, NULL, "PROF");
 402   stmt2 = gimple_build_assign (tmp1, unshare_expr (value->hvalue.value));
 403   stmt3 = gimple_build_assign (ic_void_ptr_var, gimple_assign_lhs (stmt2));
 404
 405   gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
 406   gsi_insert_before (&gsi, stmt2, GSI_SAME_STMT);
 407   gsi_insert_before (&gsi, stmt3, GSI_SAME_STMT);
 408 }
 409
 410
 411 /* Output instructions as GIMPLE trees for code to find the most
 412    common called function in indirect call. Insert instructions at the
 413    beginning of every possible called function.
 414   */
 415
 416 void
 417 gimple_gen_ic_func_profiler (void)
 418 {
 419   struct cgraph_node * c_node = cgraph_node::get (current_function_decl);
 420   gimple_stmt_iterator gsi;
 421   gcall *stmt1;
 422   gassign *stmt2;
 423   tree tree_uid, cur_func, void0;
 424
 425   if (c_node->only_called_directly_p ())
 426     return;
 427
 428   gimple_init_edge_profiler ();
 429
 430   /* Insert code:
 431
 432     stmt1: __gcov_indirect_call_profiler_v2 (profile_id,
 433                                              &current_function_decl)
 434    */
 435   gsi = gsi_after_labels (split_edge (single_succ_edge
 436                                          (ENTRY_BLOCK_PTR_FOR_FN (cfun))));
 437
 438   cur_func = force_gimple_operand_gsi (&gsi,
 439                                        build_addr (current_function_decl),
 440                                        true, NULL_TREE,
 441                                        true, GSI_SAME_STMT);
 442   tree_uid = build_int_cst
 443               (gcov_type_node,
 444                cgraph_node::get (current_function_decl)->profile_id);
 445   stmt1 = gimple_build_call (tree_indirect_call_profiler_fn, 2,
 446                              tree_uid, cur_func);
 447   gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
 448
 449   /* Set __gcov_indirect_call_callee to 0,
 450      so that calls from other modules won't get misattributed
 451      to the last caller of the current callee. */
 452   void0 = build_int_cst (build_pointer_type (void_type_node), 0);
 453   stmt2 = gimple_build_assign (ic_void_ptr_var, void0);
 454   gsi_insert_before (&gsi, stmt2, GSI_SAME_STMT);
 455 }
 456
 457 /* Output instructions as GIMPLE tree at the beginning for each function.
 458    TAG is the tag of the section for counters, BASE is offset of the
 459    counter position and GSI is the iterator we place the counter.  */
 460
 461 void
 462 gimple_gen_time_profiler (unsigned tag, unsigned base,
 463                           gimple_stmt_iterator &gsi)
 464 {
 465   tree ref_ptr = tree_coverage_counter_addr (tag, base);
 466   gcall *call;
 467
 468   ref_ptr = force_gimple_operand_gsi (&gsi, ref_ptr,
 469                                       true, NULL_TREE, true, GSI_SAME_STMT);
 470   call = gimple_build_call (tree_time_profiler_fn, 1, ref_ptr);
 471   gsi_insert_before (&gsi, call, GSI_NEW_STMT);
 472 }
 473
 474 /* Output instructions as GIMPLE trees for code to find the most common value
 475    of a difference between two evaluations of an expression.
 476    VALUE is the expression whose value is profiled.  TAG is the tag of the
 477    section for counters, BASE is offset of the counter position.  */
 478
 479 void
 480 gimple_gen_const_delta_profiler (histogram_value value ATTRIBUTE_UNUSED,
 481                                unsigned tag ATTRIBUTE_UNUSED,
 482                                unsigned base ATTRIBUTE_UNUSED)
 483 {
 484   /* FIXME implement this.  */
 485   if (flag_checking)
 486     internal_error ("unimplemented functionality");
 487   gcc_unreachable ();
 488 }
 489
 490 /* Output instructions as GIMPLE trees to increment the average histogram
 491    counter.  VALUE is the expression whose value is profiled.  TAG is the
 492    tag of the section for counters, BASE is offset of the counter position.  */
 493
 494 void
 495 gimple_gen_average_profiler (histogram_value value, unsigned tag, unsigned base)
 496 {
 497   gimple *stmt = value->hvalue.stmt;
 498   gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
 499   tree ref_ptr = tree_coverage_counter_addr (tag, base);
 500   gcall *call;
 501   tree val;
 502
 503   ref_ptr = force_gimple_operand_gsi (&gsi, ref_ptr,
 504                                       true, NULL_TREE,
 505                                       true, GSI_SAME_STMT);
 506   val = prepare_instrumented_value (&gsi, value);
 507   call = gimple_build_call (tree_average_profiler_fn, 2, ref_ptr, val);
 508   gsi_insert_before (&gsi, call, GSI_NEW_STMT);
 509 }
 510
 511 /* Output instructions as GIMPLE trees to increment the ior histogram
 512    counter.  VALUE is the expression whose value is profiled.  TAG is the
 513    tag of the section for counters, BASE is offset of the counter position.  */
 514
 515 void
 516 gimple_gen_ior_profiler (histogram_value value, unsigned tag, unsigned base)
 517 {
 518   gimple *stmt = value->hvalue.stmt;
 519   gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
 520   tree ref_ptr = tree_coverage_counter_addr (tag, base);
 521   gcall *call;
 522   tree val;
 523
 524   ref_ptr = force_gimple_operand_gsi (&gsi, ref_ptr,
 525                                       true, NULL_TREE, true, GSI_SAME_STMT);
 526   val = prepare_instrumented_value (&gsi, value);
 527   call = gimple_build_call (tree_ior_profiler_fn, 2, ref_ptr, val);
 528   gsi_insert_before (&gsi, call, GSI_NEW_STMT);
 529 }
 530
 531 /* Profile all functions in the callgraph.  */
 532
 533 static unsigned int
 534 tree_profiling (void)
 535 {
 536   struct cgraph_node *node;
 537
 538   /* This is a small-ipa pass that gets called only once, from
 539      cgraphunit.c:ipa_passes().  */
 540   gcc_assert (symtab->state == IPA_SSA);
 541
 542   init_node_map (true);
 543
 544   FOR_EACH_DEFINED_FUNCTION (node)
 545     {
 546       if (!gimple_has_body_p (node->decl))
 547         continue;
 548
 549       /* Don't profile functions produced for builtin stuff.  */
 550       if (DECL_SOURCE_LOCATION (node->decl) == BUILTINS_LOCATION)
 551         continue;
 552
 553       if (lookup_attribute ("no_profile_instrument_function",
 554                             DECL_ATTRIBUTES (node->decl)))
 555         continue;
 556       /* Do not instrument extern inline functions when testing coverage.
 557          While this is not perfectly consistent (early inlined extern inlines
 558          will get acocunted), testsuite expects that.  */
 559       if (DECL_EXTERNAL (node->decl)
 560           && flag_test_coverage)
 561         continue;
 562
 563       push_cfun (DECL_STRUCT_FUNCTION (node->decl));
 564
 565       /* Local pure-const may imply need to fixup the cfg.  */
 566       if (execute_fixup_cfg () & TODO_cleanup_cfg)
 567         cleanup_tree_cfg ();
 568
 569       branch_prob ();
 570
 571       if (! flag_branch_probabilities
 572           && flag_profile_values)
 573         gimple_gen_ic_func_profiler ();
 574
 575       if (flag_branch_probabilities
 576           && flag_profile_values
 577           && flag_value_profile_transformations)
 578         gimple_value_profile_transformations ();
 579
 580       /* The above could hose dominator info.  Currently there is
 581          none coming in, this is a safety valve.  It should be
 582          easy to adjust it, if and when there is some.  */
 583       free_dominance_info (CDI_DOMINATORS);
 584       free_dominance_info (CDI_POST_DOMINATORS);
 585       pop_cfun ();
 586     }
 587
 588   /* Drop pure/const flags from instrumented functions.  */
 589   if (profile_arc_flag || flag_test_coverage)
 590     FOR_EACH_DEFINED_FUNCTION (node)
 591       {
 592         if (!gimple_has_body_p (node->decl)
 593             || !(!node->clone_of
 594             || node->decl != node->clone_of->decl))
 595           continue;
 596
 597         /* Don't profile functions produced for builtin stuff.  */
 598         if (DECL_SOURCE_LOCATION (node->decl) == BUILTINS_LOCATION)
 599           continue;
 600
 601         node->set_const_flag (false, false);
 602         node->set_pure_flag (false, false);
 603       }
 604
 605   /* Update call statements and rebuild the cgraph.  */
 606   FOR_EACH_DEFINED_FUNCTION (node)
 607     {
 608       basic_block bb;
 609
 610       if (!gimple_has_body_p (node->decl)
 611           || !(!node->clone_of
 612           || node->decl != node->clone_of->decl))
 613         continue;
 614
 615       /* Don't profile functions produced for builtin stuff.  */
 616       if (DECL_SOURCE_LOCATION (node->decl) == BUILTINS_LOCATION)
 617         continue;
 618
 619       push_cfun (DECL_STRUCT_FUNCTION (node->decl));
 620
 621       FOR_EACH_BB_FN (bb, cfun)
 622         {
 623           gimple_stmt_iterator gsi;
 624           for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 625             {
 626               gimple *stmt = gsi_stmt (gsi);
 627               if (is_gimple_call (stmt))
 628                 update_stmt (stmt);
 629             }
 630         }
 631
 632       /* re-merge split blocks.  */
 633       cleanup_tree_cfg ();
 634       update_ssa (TODO_update_ssa);
 635
 636       cgraph_edge::rebuild_edges ();
 637
 638       pop_cfun ();
 639     }
 640
 641   handle_missing_profiles ();
 642
 643   del_node_map ();
 644   return 0;
 645 }
 646
 647 namespace {
 648
 649 const pass_data pass_data_ipa_tree_profile =
 650 {
 651   SIMPLE_IPA_PASS, /* type */
 652   "profile", /* name */
 653   OPTGROUP_NONE, /* optinfo_flags */
 654   TV_IPA_PROFILE, /* tv_id */
 655   0, /* properties_required */
 656   0, /* properties_provided */
 657   0, /* properties_destroyed */
 658   0, /* todo_flags_start */
 659   TODO_dump_symtab, /* todo_flags_finish */
 660 };
 661
 662 class pass_ipa_tree_profile : public simple_ipa_opt_pass
 663 {
 664 public:
 665   pass_ipa_tree_profile (gcc::context *ctxt)
 666     : simple_ipa_opt_pass (pass_data_ipa_tree_profile, ctxt)
 667   {}
 668
 669   /* opt_pass methods: */
 670   virtual bool gate (function *);
 671   virtual unsigned int execute (function *) { return tree_profiling (); }
 672
 673 }; // class pass_ipa_tree_profile
 674
 675 bool
 676 pass_ipa_tree_profile::gate (function *)
 677 {
 678   /* When profile instrumentation, use or test coverage shall be performed.
 679      But for AutoFDO, this there is no instrumentation, thus this pass is
 680      diabled.  */
 681   return (!in_lto_p && !flag_auto_profile
 682           && (flag_branch_probabilities || flag_test_coverage
 683               || profile_arc_flag));
 684 }
 685
 686 } // anon namespace
 687
 688 simple_ipa_opt_pass *
 689 make_pass_ipa_tree_profile (gcc::context *ctxt)
 690 {
 691   return new pass_ipa_tree_profile (ctxt);
 692 }
 693
 694 #include "gt-tree-profile.h"