gcc/tree-profile.c

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