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 to increment the average histogram
 475    counter.  VALUE is the expression whose value is profiled.  TAG is the
 476    tag of the section for counters, BASE is offset of the counter position.  */
 477
 478 void
 479 gimple_gen_average_profiler (histogram_value value, unsigned tag, unsigned base)
 480 {
 481   gimple *stmt = value->hvalue.stmt;
 482   gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
 483   tree ref_ptr = tree_coverage_counter_addr (tag, base);
 484   gcall *call;
 485   tree val;
 486
 487   ref_ptr = force_gimple_operand_gsi (&gsi, ref_ptr,
 488                                       true, NULL_TREE,
 489                                       true, GSI_SAME_STMT);
 490   val = prepare_instrumented_value (&gsi, value);
 491   call = gimple_build_call (tree_average_profiler_fn, 2, ref_ptr, val);
 492   gsi_insert_before (&gsi, call, GSI_NEW_STMT);
 493 }
 494
 495 /* Output instructions as GIMPLE trees to increment the ior histogram
 496    counter.  VALUE is the expression whose value is profiled.  TAG is the
 497    tag of the section for counters, BASE is offset of the counter position.  */
 498
 499 void
 500 gimple_gen_ior_profiler (histogram_value value, unsigned tag, unsigned base)
 501 {
 502   gimple *stmt = value->hvalue.stmt;
 503   gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
 504   tree ref_ptr = tree_coverage_counter_addr (tag, base);
 505   gcall *call;
 506   tree val;
 507
 508   ref_ptr = force_gimple_operand_gsi (&gsi, ref_ptr,
 509                                       true, NULL_TREE, true, GSI_SAME_STMT);
 510   val = prepare_instrumented_value (&gsi, value);
 511   call = gimple_build_call (tree_ior_profiler_fn, 2, ref_ptr, val);
 512   gsi_insert_before (&gsi, call, GSI_NEW_STMT);
 513 }
 514
 515 #ifndef HAVE_sync_compare_and_swapsi
 516 #define HAVE_sync_compare_and_swapsi 0
 517 #endif
 518 #ifndef HAVE_atomic_compare_and_swapsi
 519 #define HAVE_atomic_compare_and_swapsi 0
 520 #endif
 521
 522 #ifndef HAVE_sync_compare_and_swapdi
 523 #define HAVE_sync_compare_and_swapdi 0
 524 #endif
 525 #ifndef HAVE_atomic_compare_and_swapdi
 526 #define HAVE_atomic_compare_and_swapdi 0
 527 #endif
 528
 529 /* Profile all functions in the callgraph.  */
 530
 531 static unsigned int
 532 tree_profiling (void)
 533 {
 534   struct cgraph_node *node;
 535
 536   /* Verify whether we can utilize atomic update operations.  */
 537   if (flag_profile_update == PROFILE_UPDATE_ATOMIC)
 538     {
 539       bool can_support = false;
 540       unsigned HOST_WIDE_INT gcov_type_size
 541         = tree_to_uhwi (TYPE_SIZE_UNIT (get_gcov_type ()));
 542       if (gcov_type_size == 4)
 543         can_support
 544           = HAVE_sync_compare_and_swapsi || HAVE_atomic_compare_and_swapsi;
 545       else if (gcov_type_size == 8)
 546         can_support
 547           = HAVE_sync_compare_and_swapdi || HAVE_atomic_compare_and_swapdi;
 548
 549       if (!can_support)
 550       {
 551         warning (0, "target does not support atomic profile update, "
 552                  "single mode is selected");
 553         flag_profile_update = PROFILE_UPDATE_SINGLE;
 554       }
 555     }
 556
 557   /* This is a small-ipa pass that gets called only once, from
 558      cgraphunit.c:ipa_passes().  */
 559   gcc_assert (symtab->state == IPA_SSA);
 560
 561   init_node_map (true);
 562
 563   FOR_EACH_DEFINED_FUNCTION (node)
 564     {
 565       if (!gimple_has_body_p (node->decl))
 566         continue;
 567
 568       /* Don't profile functions produced for builtin stuff.  */
 569       if (DECL_SOURCE_LOCATION (node->decl) == BUILTINS_LOCATION)
 570         continue;
 571
 572       if (lookup_attribute ("no_profile_instrument_function",
 573                             DECL_ATTRIBUTES (node->decl)))
 574         continue;
 575       /* Do not instrument extern inline functions when testing coverage.
 576          While this is not perfectly consistent (early inlined extern inlines
 577          will get acocunted), testsuite expects that.  */
 578       if (DECL_EXTERNAL (node->decl)
 579           && flag_test_coverage)
 580         continue;
 581
 582       push_cfun (DECL_STRUCT_FUNCTION (node->decl));
 583
 584       /* Local pure-const may imply need to fixup the cfg.  */
 585       if (execute_fixup_cfg () & TODO_cleanup_cfg)
 586         cleanup_tree_cfg ();
 587
 588       branch_prob ();
 589
 590       if (! flag_branch_probabilities
 591           && flag_profile_values)
 592         gimple_gen_ic_func_profiler ();
 593
 594       if (flag_branch_probabilities
 595           && flag_profile_values
 596           && flag_value_profile_transformations)
 597         gimple_value_profile_transformations ();
 598
 599       /* The above could hose dominator info.  Currently there is
 600          none coming in, this is a safety valve.  It should be
 601          easy to adjust it, if and when there is some.  */
 602       free_dominance_info (CDI_DOMINATORS);
 603       free_dominance_info (CDI_POST_DOMINATORS);
 604       pop_cfun ();
 605     }
 606
 607   /* Drop pure/const flags from instrumented functions.  */
 608   if (profile_arc_flag || flag_test_coverage)
 609     FOR_EACH_DEFINED_FUNCTION (node)
 610       {
 611         if (!gimple_has_body_p (node->decl)
 612             || !(!node->clone_of
 613             || node->decl != node->clone_of->decl))
 614           continue;
 615
 616         /* Don't profile functions produced for builtin stuff.  */
 617         if (DECL_SOURCE_LOCATION (node->decl) == BUILTINS_LOCATION)
 618           continue;
 619
 620         node->set_const_flag (false, false);
 621         node->set_pure_flag (false, false);
 622       }
 623
 624   /* Update call statements and rebuild the cgraph.  */
 625   FOR_EACH_DEFINED_FUNCTION (node)
 626     {
 627       basic_block bb;
 628
 629       if (!gimple_has_body_p (node->decl)
 630           || !(!node->clone_of
 631           || node->decl != node->clone_of->decl))
 632         continue;
 633
 634       /* Don't profile functions produced for builtin stuff.  */
 635       if (DECL_SOURCE_LOCATION (node->decl) == BUILTINS_LOCATION)
 636         continue;
 637
 638       push_cfun (DECL_STRUCT_FUNCTION (node->decl));
 639
 640       FOR_EACH_BB_FN (bb, cfun)
 641         {
 642           gimple_stmt_iterator gsi;
 643           for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 644             {
 645               gimple *stmt = gsi_stmt (gsi);
 646               if (is_gimple_call (stmt))
 647                 update_stmt (stmt);
 648             }
 649         }
 650
 651       /* re-merge split blocks.  */
 652       cleanup_tree_cfg ();
 653       update_ssa (TODO_update_ssa);
 654
 655       cgraph_edge::rebuild_edges ();
 656
 657       pop_cfun ();
 658     }
 659
 660   handle_missing_profiles ();
 661
 662   del_node_map ();
 663   return 0;
 664 }
 665
 666 namespace {
 667
 668 const pass_data pass_data_ipa_tree_profile =
 669 {
 670   SIMPLE_IPA_PASS, /* type */
 671   "profile", /* name */
 672   OPTGROUP_NONE, /* optinfo_flags */
 673   TV_IPA_PROFILE, /* tv_id */
 674   0, /* properties_required */
 675   0, /* properties_provided */
 676   0, /* properties_destroyed */
 677   0, /* todo_flags_start */
 678   TODO_dump_symtab, /* todo_flags_finish */
 679 };
 680
 681 class pass_ipa_tree_profile : public simple_ipa_opt_pass
 682 {
 683 public:
 684   pass_ipa_tree_profile (gcc::context *ctxt)
 685     : simple_ipa_opt_pass (pass_data_ipa_tree_profile, ctxt)
 686   {}
 687
 688   /* opt_pass methods: */
 689   virtual bool gate (function *);
 690   virtual unsigned int execute (function *) { return tree_profiling (); }
 691
 692 }; // class pass_ipa_tree_profile
 693
 694 bool
 695 pass_ipa_tree_profile::gate (function *)
 696 {
 697   /* When profile instrumentation, use or test coverage shall be performed.
 698      But for AutoFDO, this there is no instrumentation, thus this pass is
 699      diabled.  */
 700   return (!in_lto_p && !flag_auto_profile
 701           && (flag_branch_probabilities || flag_test_coverage
 702               || profile_arc_flag));
 703 }
 704
 705 } // anon namespace
 706
 707 simple_ipa_opt_pass *
 708 make_pass_ipa_tree_profile (gcc::context *ctxt)
 709 {
 710   return new pass_ipa_tree_profile (ctxt);
 711 }
 712
 713 #include "gt-tree-profile.h"