1 /* Calculate branch probabilities, and basic block execution counts.
2 Copyright (C) 1990-2018 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.
8 This file is part of GCC.
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
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
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/>. */
24 /* Generate basic block profile instrumentation and auxiliary files.
25 Tree-based version. See profile.c for overview. */
29 #include "coretypes.h"
36 #include "tree-pass.h"
40 #include "diagnostic-core.h"
41 #include "fold-const.h"
43 #include "tree-nested.h"
45 #include "gimple-iterator.h"
46 #include "gimplify-me.h"
48 #include "tree-into-ssa.h"
49 #include "value-prof.h"
51 #include "tree-cfgcleanup.h"
53 #include "stringpool.h"
55 #include "tree-pretty-print.h"
56 #include "langhooks.h"
57 #include "stor-layout.h"
60 static GTY(()) tree gcov_type_node
;
61 static GTY(()) tree tree_interval_profiler_fn
;
62 static GTY(()) tree tree_pow2_profiler_fn
;
63 static GTY(()) tree tree_one_value_profiler_fn
;
64 static GTY(()) tree tree_indirect_call_profiler_fn
;
65 static GTY(()) tree tree_average_profiler_fn
;
66 static GTY(()) tree tree_ior_profiler_fn
;
67 static GTY(()) tree tree_time_profiler_counter
;
70 static GTY(()) tree ic_tuple_var
;
71 static GTY(()) tree ic_tuple_counters_field
;
72 static GTY(()) tree ic_tuple_callee_field
;
74 /* Do initialization work for the edge profiler. */
77 __thread gcov* __gcov_indirect_call_counters; // pointer to actual counter
78 __thread void* __gcov_indirect_call_callee; // actual callee address
79 __thread int __gcov_function_counter; // time profiler function counter
82 init_ic_make_global_vars (void)
86 gcov_type_ptr
= build_pointer_type (get_gcov_type ());
88 tree tuple_type
= lang_hooks
.types
.make_type (RECORD_TYPE
);
91 ic_tuple_callee_field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
95 ic_tuple_counters_field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
,
96 NULL_TREE
, gcov_type_ptr
);
97 DECL_CHAIN (ic_tuple_counters_field
) = ic_tuple_callee_field
;
99 finish_builtin_struct (tuple_type
, "indirect_call_tuple",
100 ic_tuple_counters_field
, NULL_TREE
);
103 = build_decl (UNKNOWN_LOCATION
, VAR_DECL
,
105 (PARAM_VALUE (PARAM_INDIR_CALL_TOPN_PROFILE
) ?
106 "__gcov_indirect_call_topn" :
107 "__gcov_indirect_call")),
109 TREE_PUBLIC (ic_tuple_var
) = 1;
110 DECL_ARTIFICIAL (ic_tuple_var
) = 1;
111 DECL_INITIAL (ic_tuple_var
) = NULL
;
112 DECL_EXTERNAL (ic_tuple_var
) = 1;
113 if (targetm
.have_tls
)
114 set_decl_tls_model (ic_tuple_var
, decl_default_tls_model (tuple_type
));
117 /* Create the type and function decls for the interface with gcov. */
120 gimple_init_gcov_profiler (void)
122 tree interval_profiler_fn_type
;
123 tree pow2_profiler_fn_type
;
124 tree one_value_profiler_fn_type
;
126 tree ic_profiler_fn_type
;
127 tree average_profiler_fn_type
;
128 const char *profiler_fn_name
;
133 const char *fn_suffix
134 = flag_profile_update
== PROFILE_UPDATE_ATOMIC
? "_atomic" : "";
136 gcov_type_node
= get_gcov_type ();
137 gcov_type_ptr
= build_pointer_type (gcov_type_node
);
139 /* void (*) (gcov_type *, gcov_type, int, unsigned) */
140 interval_profiler_fn_type
141 = build_function_type_list (void_type_node
,
142 gcov_type_ptr
, gcov_type_node
,
144 unsigned_type_node
, NULL_TREE
);
145 fn_name
= concat ("__gcov_interval_profiler", fn_suffix
, NULL
);
146 tree_interval_profiler_fn
= build_fn_decl (fn_name
,
147 interval_profiler_fn_type
);
148 free (CONST_CAST (char *, fn_name
));
149 TREE_NOTHROW (tree_interval_profiler_fn
) = 1;
150 DECL_ATTRIBUTES (tree_interval_profiler_fn
)
151 = tree_cons (get_identifier ("leaf"), NULL
,
152 DECL_ATTRIBUTES (tree_interval_profiler_fn
));
154 /* void (*) (gcov_type *, gcov_type) */
155 pow2_profiler_fn_type
156 = build_function_type_list (void_type_node
,
157 gcov_type_ptr
, gcov_type_node
,
159 fn_name
= concat ("__gcov_pow2_profiler", fn_suffix
, NULL
);
160 tree_pow2_profiler_fn
= build_fn_decl (fn_name
, pow2_profiler_fn_type
);
161 free (CONST_CAST (char *, fn_name
));
162 TREE_NOTHROW (tree_pow2_profiler_fn
) = 1;
163 DECL_ATTRIBUTES (tree_pow2_profiler_fn
)
164 = tree_cons (get_identifier ("leaf"), NULL
,
165 DECL_ATTRIBUTES (tree_pow2_profiler_fn
));
167 /* void (*) (gcov_type *, gcov_type) */
168 one_value_profiler_fn_type
169 = build_function_type_list (void_type_node
,
170 gcov_type_ptr
, gcov_type_node
,
172 fn_name
= concat ("__gcov_one_value_profiler", fn_suffix
, NULL
);
173 tree_one_value_profiler_fn
= build_fn_decl (fn_name
,
174 one_value_profiler_fn_type
);
175 free (CONST_CAST (char *, fn_name
));
176 TREE_NOTHROW (tree_one_value_profiler_fn
) = 1;
177 DECL_ATTRIBUTES (tree_one_value_profiler_fn
)
178 = tree_cons (get_identifier ("leaf"), NULL
,
179 DECL_ATTRIBUTES (tree_one_value_profiler_fn
));
181 init_ic_make_global_vars ();
183 /* void (*) (gcov_type, void *) */
185 = build_function_type_list (void_type_node
,
189 profiler_fn_name
= "__gcov_indirect_call_profiler_v2";
190 if (PARAM_VALUE (PARAM_INDIR_CALL_TOPN_PROFILE
))
191 profiler_fn_name
= "__gcov_indirect_call_topn_profiler";
193 tree_indirect_call_profiler_fn
194 = build_fn_decl (profiler_fn_name
, ic_profiler_fn_type
);
196 TREE_NOTHROW (tree_indirect_call_profiler_fn
) = 1;
197 DECL_ATTRIBUTES (tree_indirect_call_profiler_fn
)
198 = tree_cons (get_identifier ("leaf"), NULL
,
199 DECL_ATTRIBUTES (tree_indirect_call_profiler_fn
));
201 tree_time_profiler_counter
202 = build_decl (UNKNOWN_LOCATION
, VAR_DECL
,
203 get_identifier ("__gcov_time_profiler_counter"),
205 TREE_PUBLIC (tree_time_profiler_counter
) = 1;
206 DECL_EXTERNAL (tree_time_profiler_counter
) = 1;
207 TREE_STATIC (tree_time_profiler_counter
) = 1;
208 DECL_ARTIFICIAL (tree_time_profiler_counter
) = 1;
209 DECL_INITIAL (tree_time_profiler_counter
) = NULL
;
211 /* void (*) (gcov_type *, gcov_type) */
212 average_profiler_fn_type
213 = build_function_type_list (void_type_node
,
214 gcov_type_ptr
, gcov_type_node
, NULL_TREE
);
215 fn_name
= concat ("__gcov_average_profiler", fn_suffix
, NULL
);
216 tree_average_profiler_fn
= build_fn_decl (fn_name
,
217 average_profiler_fn_type
);
218 free (CONST_CAST (char *, fn_name
));
219 TREE_NOTHROW (tree_average_profiler_fn
) = 1;
220 DECL_ATTRIBUTES (tree_average_profiler_fn
)
221 = tree_cons (get_identifier ("leaf"), NULL
,
222 DECL_ATTRIBUTES (tree_average_profiler_fn
));
223 fn_name
= concat ("__gcov_ior_profiler", fn_suffix
, NULL
);
224 tree_ior_profiler_fn
= build_fn_decl (fn_name
, average_profiler_fn_type
);
225 free (CONST_CAST (char *, fn_name
));
226 TREE_NOTHROW (tree_ior_profiler_fn
) = 1;
227 DECL_ATTRIBUTES (tree_ior_profiler_fn
)
228 = tree_cons (get_identifier ("leaf"), NULL
,
229 DECL_ATTRIBUTES (tree_ior_profiler_fn
));
231 /* LTO streamer needs assembler names. Because we create these decls
232 late, we need to initialize them by hand. */
233 DECL_ASSEMBLER_NAME (tree_interval_profiler_fn
);
234 DECL_ASSEMBLER_NAME (tree_pow2_profiler_fn
);
235 DECL_ASSEMBLER_NAME (tree_one_value_profiler_fn
);
236 DECL_ASSEMBLER_NAME (tree_indirect_call_profiler_fn
);
237 DECL_ASSEMBLER_NAME (tree_average_profiler_fn
);
238 DECL_ASSEMBLER_NAME (tree_ior_profiler_fn
);
242 /* Output instructions as GIMPLE trees to increment the edge
243 execution count, and insert them on E. We rely on
244 gsi_insert_on_edge to preserve the order. */
247 gimple_gen_edge_profiler (int edgeno
, edge e
)
251 one
= build_int_cst (gcov_type_node
, 1);
253 if (flag_profile_update
== PROFILE_UPDATE_ATOMIC
)
255 /* __atomic_fetch_add (&counter, 1, MEMMODEL_RELAXED); */
256 tree addr
= tree_coverage_counter_addr (GCOV_COUNTER_ARCS
, edgeno
);
257 tree f
= builtin_decl_explicit (LONG_LONG_TYPE_SIZE
> 32
258 ? BUILT_IN_ATOMIC_FETCH_ADD_8
:
259 BUILT_IN_ATOMIC_FETCH_ADD_4
);
260 gcall
*stmt
= gimple_build_call (f
, 3, addr
, one
,
261 build_int_cst (integer_type_node
,
263 gsi_insert_on_edge (e
, stmt
);
267 tree ref
= tree_coverage_counter_ref (GCOV_COUNTER_ARCS
, edgeno
);
268 tree gcov_type_tmp_var
= make_temp_ssa_name (gcov_type_node
,
269 NULL
, "PROF_edge_counter");
270 gassign
*stmt1
= gimple_build_assign (gcov_type_tmp_var
, ref
);
271 gcov_type_tmp_var
= make_temp_ssa_name (gcov_type_node
,
272 NULL
, "PROF_edge_counter");
273 gassign
*stmt2
= gimple_build_assign (gcov_type_tmp_var
, PLUS_EXPR
,
274 gimple_assign_lhs (stmt1
), one
);
275 gassign
*stmt3
= gimple_build_assign (unshare_expr (ref
),
276 gimple_assign_lhs (stmt2
));
277 gsi_insert_on_edge (e
, stmt1
);
278 gsi_insert_on_edge (e
, stmt2
);
279 gsi_insert_on_edge (e
, stmt3
);
283 /* Emits code to get VALUE to instrument at GSI, and returns the
284 variable containing the value. */
287 prepare_instrumented_value (gimple_stmt_iterator
*gsi
, histogram_value value
)
289 tree val
= value
->hvalue
.value
;
290 if (POINTER_TYPE_P (TREE_TYPE (val
)))
291 val
= fold_convert (build_nonstandard_integer_type
292 (TYPE_PRECISION (TREE_TYPE (val
)), 1), val
);
293 return force_gimple_operand_gsi (gsi
, fold_convert (gcov_type_node
, val
),
294 true, NULL_TREE
, true, GSI_SAME_STMT
);
297 /* Output instructions as GIMPLE trees to increment the interval histogram
298 counter. VALUE is the expression whose value is profiled. TAG is the
299 tag of the section for counters, BASE is offset of the counter position. */
302 gimple_gen_interval_profiler (histogram_value value
, unsigned tag
, unsigned base
)
304 gimple
*stmt
= value
->hvalue
.stmt
;
305 gimple_stmt_iterator gsi
= gsi_for_stmt (stmt
);
306 tree ref
= tree_coverage_counter_ref (tag
, base
), ref_ptr
;
309 tree start
= build_int_cst_type (integer_type_node
,
310 value
->hdata
.intvl
.int_start
);
311 tree steps
= build_int_cst_type (unsigned_type_node
,
312 value
->hdata
.intvl
.steps
);
314 ref_ptr
= force_gimple_operand_gsi (&gsi
,
316 true, NULL_TREE
, true, GSI_SAME_STMT
);
317 val
= prepare_instrumented_value (&gsi
, value
);
318 call
= gimple_build_call (tree_interval_profiler_fn
, 4,
319 ref_ptr
, val
, start
, steps
);
320 gsi_insert_before (&gsi
, call
, GSI_NEW_STMT
);
323 /* Output instructions as GIMPLE trees to increment the power of two histogram
324 counter. VALUE is the expression whose value is profiled. TAG is the tag
325 of the section for counters, BASE is offset of the counter position. */
328 gimple_gen_pow2_profiler (histogram_value value
, unsigned tag
, unsigned base
)
330 gimple
*stmt
= value
->hvalue
.stmt
;
331 gimple_stmt_iterator gsi
= gsi_for_stmt (stmt
);
332 tree ref_ptr
= tree_coverage_counter_addr (tag
, base
);
336 ref_ptr
= force_gimple_operand_gsi (&gsi
, ref_ptr
,
337 true, NULL_TREE
, true, GSI_SAME_STMT
);
338 val
= prepare_instrumented_value (&gsi
, value
);
339 call
= gimple_build_call (tree_pow2_profiler_fn
, 2, ref_ptr
, val
);
340 gsi_insert_before (&gsi
, call
, GSI_NEW_STMT
);
343 /* Output instructions as GIMPLE trees for code to find the most common value.
344 VALUE is the expression whose value is profiled. TAG is the tag of the
345 section for counters, BASE is offset of the counter position. */
348 gimple_gen_one_value_profiler (histogram_value value
, unsigned tag
, unsigned base
)
350 gimple
*stmt
= value
->hvalue
.stmt
;
351 gimple_stmt_iterator gsi
= gsi_for_stmt (stmt
);
352 tree ref_ptr
= tree_coverage_counter_addr (tag
, base
);
356 ref_ptr
= force_gimple_operand_gsi (&gsi
, ref_ptr
,
357 true, NULL_TREE
, true, GSI_SAME_STMT
);
358 val
= prepare_instrumented_value (&gsi
, value
);
359 call
= gimple_build_call (tree_one_value_profiler_fn
, 2, ref_ptr
, val
);
360 gsi_insert_before (&gsi
, call
, GSI_NEW_STMT
);
364 /* Output instructions as GIMPLE trees for code to find the most
365 common called function in indirect call.
366 VALUE is the call expression whose indirect callee is profiled.
367 TAG is the tag of the section for counters, BASE is offset of the
371 gimple_gen_ic_profiler (histogram_value value
, unsigned tag
, unsigned base
)
374 gassign
*stmt1
, *stmt2
, *stmt3
;
375 gimple
*stmt
= value
->hvalue
.stmt
;
376 gimple_stmt_iterator gsi
= gsi_for_stmt (stmt
);
377 tree ref_ptr
= tree_coverage_counter_addr (tag
, base
);
379 if ( (PARAM_VALUE (PARAM_INDIR_CALL_TOPN_PROFILE
) &&
380 tag
== GCOV_COUNTER_V_INDIR
) ||
381 (!PARAM_VALUE (PARAM_INDIR_CALL_TOPN_PROFILE
) &&
382 tag
== GCOV_COUNTER_ICALL_TOPNV
))
385 ref_ptr
= force_gimple_operand_gsi (&gsi
, ref_ptr
,
386 true, NULL_TREE
, true, GSI_SAME_STMT
);
390 stmt1: __gcov_indirect_call.counters = get_relevant_counter_ptr ();
391 stmt2: tmp1 = (void *) (indirect call argument value)
392 stmt3: __gcov_indirect_call.callee = tmp1;
396 __gcov_indirect_call.counters = &__gcov4.main[0];
398 __gcov_indirect_call_callee = PROF_9;
402 tree gcov_type_ptr
= build_pointer_type (get_gcov_type ());
404 tree counter_ref
= build3 (COMPONENT_REF
, gcov_type_ptr
,
405 ic_tuple_var
, ic_tuple_counters_field
, NULL_TREE
);
407 stmt1
= gimple_build_assign (counter_ref
, ref_ptr
);
408 tmp1
= make_temp_ssa_name (ptr_type_node
, NULL
, "PROF");
409 stmt2
= gimple_build_assign (tmp1
, unshare_expr (value
->hvalue
.value
));
410 tree callee_ref
= build3 (COMPONENT_REF
, ptr_type_node
,
411 ic_tuple_var
, ic_tuple_callee_field
, NULL_TREE
);
412 stmt3
= gimple_build_assign (callee_ref
, tmp1
);
414 gsi_insert_before (&gsi
, stmt1
, GSI_SAME_STMT
);
415 gsi_insert_before (&gsi
, stmt2
, GSI_SAME_STMT
);
416 gsi_insert_before (&gsi
, stmt3
, GSI_SAME_STMT
);
420 /* Output instructions as GIMPLE trees for code to find the most
421 common called function in indirect call. Insert instructions at the
422 beginning of every possible called function.
426 gimple_gen_ic_func_profiler (void)
428 struct cgraph_node
* c_node
= cgraph_node::get (current_function_decl
);
430 tree tree_uid
, cur_func
, void0
;
432 if (c_node
->only_called_directly_p ())
435 gimple_init_gcov_profiler ();
437 basic_block entry
= ENTRY_BLOCK_PTR_FOR_FN (cfun
);
438 basic_block cond_bb
= split_edge (single_succ_edge (entry
));
439 basic_block update_bb
= split_edge (single_succ_edge (cond_bb
));
441 /* We need to do an extra split in order to not create an input
442 for a possible PHI node. */
443 split_edge (single_succ_edge (update_bb
));
445 edge true_edge
= single_succ_edge (cond_bb
);
446 true_edge
->flags
= EDGE_TRUE_VALUE
;
448 profile_probability probability
;
449 if (DECL_VIRTUAL_P (current_function_decl
))
450 probability
= profile_probability::very_likely ();
452 probability
= profile_probability::unlikely ();
454 true_edge
->probability
= probability
;
455 edge e
= make_edge (cond_bb
, single_succ_edge (update_bb
)->dest
,
457 e
->probability
= true_edge
->probability
.invert ();
461 if (__gcov_indirect_call_callee != NULL)
462 __gcov_indirect_call_profiler_v2 (profile_id, ¤t_function_decl);
464 The function __gcov_indirect_call_profiler_v2 is responsible for
465 resetting __gcov_indirect_call_callee to NULL. */
467 gimple_stmt_iterator gsi
= gsi_start_bb (cond_bb
);
468 void0
= build_int_cst (ptr_type_node
, 0);
470 tree callee_ref
= build3 (COMPONENT_REF
, ptr_type_node
,
471 ic_tuple_var
, ic_tuple_callee_field
, NULL_TREE
);
473 tree ref
= force_gimple_operand_gsi (&gsi
, callee_ref
, true, NULL_TREE
,
474 true, GSI_SAME_STMT
);
476 gcond
*cond
= gimple_build_cond (NE_EXPR
, ref
,
478 gsi_insert_before (&gsi
, cond
, GSI_NEW_STMT
);
480 gsi
= gsi_after_labels (update_bb
);
482 cur_func
= force_gimple_operand_gsi (&gsi
,
483 build_addr (current_function_decl
),
485 true, GSI_SAME_STMT
);
486 tree_uid
= build_int_cst
488 cgraph_node::get (current_function_decl
)->profile_id
);
489 stmt1
= gimple_build_call (tree_indirect_call_profiler_fn
, 2,
491 gsi_insert_before (&gsi
, stmt1
, GSI_SAME_STMT
);
494 /* Output instructions as GIMPLE tree at the beginning for each function.
495 TAG is the tag of the section for counters, BASE is offset of the
496 counter position and GSI is the iterator we place the counter. */
499 gimple_gen_time_profiler (unsigned tag
, unsigned base
)
501 tree type
= get_gcov_type ();
502 basic_block entry
= ENTRY_BLOCK_PTR_FOR_FN (cfun
);
503 basic_block cond_bb
= split_edge (single_succ_edge (entry
));
504 basic_block update_bb
= split_edge (single_succ_edge (cond_bb
));
506 /* We need to do an extra split in order to not create an input
507 for a possible PHI node. */
508 split_edge (single_succ_edge (update_bb
));
510 edge true_edge
= single_succ_edge (cond_bb
);
511 true_edge
->flags
= EDGE_TRUE_VALUE
;
512 true_edge
->probability
= profile_probability::unlikely ();
514 = make_edge (cond_bb
, single_succ_edge (update_bb
)->dest
, EDGE_FALSE_VALUE
);
515 e
->probability
= true_edge
->probability
.invert ();
517 gimple_stmt_iterator gsi
= gsi_start_bb (cond_bb
);
518 tree original_ref
= tree_coverage_counter_ref (tag
, base
);
519 tree ref
= force_gimple_operand_gsi (&gsi
, original_ref
, true, NULL_TREE
,
520 true, GSI_SAME_STMT
);
521 tree one
= build_int_cst (type
, 1);
523 /* Emit: if (counters[0] != 0). */
524 gcond
*cond
= gimple_build_cond (EQ_EXPR
, ref
, build_int_cst (type
, 0),
526 gsi_insert_before (&gsi
, cond
, GSI_NEW_STMT
);
528 gsi
= gsi_start_bb (update_bb
);
530 /* Emit: counters[0] = ++__gcov_time_profiler_counter. */
531 if (flag_profile_update
== PROFILE_UPDATE_ATOMIC
)
533 tree ptr
= make_temp_ssa_name (build_pointer_type (type
), NULL
,
534 "time_profiler_counter_ptr");
535 tree addr
= build1 (ADDR_EXPR
, TREE_TYPE (ptr
),
536 tree_time_profiler_counter
);
537 gassign
*assign
= gimple_build_assign (ptr
, NOP_EXPR
, addr
);
538 gsi_insert_before (&gsi
, assign
, GSI_NEW_STMT
);
539 tree f
= builtin_decl_explicit (LONG_LONG_TYPE_SIZE
> 32
540 ? BUILT_IN_ATOMIC_ADD_FETCH_8
:
541 BUILT_IN_ATOMIC_ADD_FETCH_4
);
542 gcall
*stmt
= gimple_build_call (f
, 3, ptr
, one
,
543 build_int_cst (integer_type_node
,
545 tree result_type
= TREE_TYPE (TREE_TYPE (f
));
546 tree tmp
= make_temp_ssa_name (result_type
, NULL
, "time_profile");
547 gimple_set_lhs (stmt
, tmp
);
548 gsi_insert_after (&gsi
, stmt
, GSI_NEW_STMT
);
549 tmp
= make_temp_ssa_name (type
, NULL
, "time_profile");
550 assign
= gimple_build_assign (tmp
, NOP_EXPR
,
551 gimple_call_lhs (stmt
));
552 gsi_insert_after (&gsi
, assign
, GSI_NEW_STMT
);
553 assign
= gimple_build_assign (original_ref
, tmp
);
554 gsi_insert_after (&gsi
, assign
, GSI_NEW_STMT
);
558 tree tmp
= make_temp_ssa_name (type
, NULL
, "time_profile");
559 gassign
*assign
= gimple_build_assign (tmp
, tree_time_profiler_counter
);
560 gsi_insert_before (&gsi
, assign
, GSI_NEW_STMT
);
562 tmp
= make_temp_ssa_name (type
, NULL
, "time_profile");
563 assign
= gimple_build_assign (tmp
, PLUS_EXPR
, gimple_assign_lhs (assign
),
565 gsi_insert_after (&gsi
, assign
, GSI_NEW_STMT
);
566 assign
= gimple_build_assign (original_ref
, tmp
);
567 gsi_insert_after (&gsi
, assign
, GSI_NEW_STMT
);
568 assign
= gimple_build_assign (tree_time_profiler_counter
, tmp
);
569 gsi_insert_after (&gsi
, assign
, GSI_NEW_STMT
);
573 /* Output instructions as GIMPLE trees to increment the average histogram
574 counter. VALUE is the expression whose value is profiled. TAG is the
575 tag of the section for counters, BASE is offset of the counter position. */
578 gimple_gen_average_profiler (histogram_value value
, unsigned tag
, unsigned base
)
580 gimple
*stmt
= value
->hvalue
.stmt
;
581 gimple_stmt_iterator gsi
= gsi_for_stmt (stmt
);
582 tree ref_ptr
= tree_coverage_counter_addr (tag
, base
);
586 ref_ptr
= force_gimple_operand_gsi (&gsi
, ref_ptr
,
588 true, GSI_SAME_STMT
);
589 val
= prepare_instrumented_value (&gsi
, value
);
590 call
= gimple_build_call (tree_average_profiler_fn
, 2, ref_ptr
, val
);
591 gsi_insert_before (&gsi
, call
, GSI_NEW_STMT
);
594 /* Output instructions as GIMPLE trees to increment the ior histogram
595 counter. VALUE is the expression whose value is profiled. TAG is the
596 tag of the section for counters, BASE is offset of the counter position. */
599 gimple_gen_ior_profiler (histogram_value value
, unsigned tag
, unsigned base
)
601 gimple
*stmt
= value
->hvalue
.stmt
;
602 gimple_stmt_iterator gsi
= gsi_for_stmt (stmt
);
603 tree ref_ptr
= tree_coverage_counter_addr (tag
, base
);
607 ref_ptr
= force_gimple_operand_gsi (&gsi
, ref_ptr
,
608 true, NULL_TREE
, true, GSI_SAME_STMT
);
609 val
= prepare_instrumented_value (&gsi
, value
);
610 call
= gimple_build_call (tree_ior_profiler_fn
, 2, ref_ptr
, val
);
611 gsi_insert_before (&gsi
, call
, GSI_NEW_STMT
);
614 static vec
<regex_t
> profile_filter_files
;
615 static vec
<regex_t
> profile_exclude_files
;
617 /* Parse list of provided REGEX (separated with semi-collon) and
618 create expressions (of type regex_t) and save them into V vector.
619 If there is a regular expression parsing error, error message is
620 printed for FLAG_NAME. */
623 parse_profile_filter (const char *regex
, vec
<regex_t
> *v
,
624 const char *flag_name
)
629 char *str
= xstrdup (regex
);
630 for (char *p
= strtok (str
, ";"); p
!= NULL
; p
= strtok (NULL
, ";"))
633 if (regcomp (&r
, p
, REG_EXTENDED
| REG_NOSUB
) != 0)
635 error ("invalid regular expression '%s' in %<%s%>",
645 /* Parse values of -fprofile-filter-files and -fprofile-exclude-files
649 parse_profile_file_filtering ()
651 parse_profile_filter (flag_profile_filter_files
, &profile_filter_files
,
652 "-fprofile-filter-files");
653 parse_profile_filter (flag_profile_exclude_files
, &profile_exclude_files
,
654 "-fprofile-exclude-files");
657 /* Parse vectors of regular expressions. */
660 release_profile_file_filtering ()
662 profile_filter_files
.release ();
663 profile_exclude_files
.release ();
666 /* Return true when FILENAME should be instrumented based on
667 -fprofile-filter-files and -fprofile-exclude-files options. */
670 include_source_file_for_profile (const char *filename
)
672 /* First check whether file is included in flag_profile_exclude_files. */
673 for (unsigned i
= 0; i
< profile_exclude_files
.length (); i
++)
674 if (regexec (&profile_exclude_files
[i
],
675 filename
, 0, NULL
, 0) == REG_NOERROR
)
678 /* For non-empty flag_profile_filter_files include only files matching a
679 regex in the flag. */
680 if (profile_filter_files
.is_empty ())
683 for (unsigned i
= 0; i
< profile_filter_files
.length (); i
++)
684 if (regexec (&profile_filter_files
[i
], filename
, 0, NULL
, 0) == REG_NOERROR
)
690 #ifndef HAVE_sync_compare_and_swapsi
691 #define HAVE_sync_compare_and_swapsi 0
693 #ifndef HAVE_atomic_compare_and_swapsi
694 #define HAVE_atomic_compare_and_swapsi 0
697 #ifndef HAVE_sync_compare_and_swapdi
698 #define HAVE_sync_compare_and_swapdi 0
700 #ifndef HAVE_atomic_compare_and_swapdi
701 #define HAVE_atomic_compare_and_swapdi 0
704 /* Profile all functions in the callgraph. */
707 tree_profiling (void)
709 struct cgraph_node
*node
;
711 /* Verify whether we can utilize atomic update operations. */
712 bool can_support_atomic
= false;
713 unsigned HOST_WIDE_INT gcov_type_size
714 = tree_to_uhwi (TYPE_SIZE_UNIT (get_gcov_type ()));
715 if (gcov_type_size
== 4)
717 = HAVE_sync_compare_and_swapsi
|| HAVE_atomic_compare_and_swapsi
;
718 else if (gcov_type_size
== 8)
720 = HAVE_sync_compare_and_swapdi
|| HAVE_atomic_compare_and_swapdi
;
722 if (flag_profile_update
== PROFILE_UPDATE_ATOMIC
723 && !can_support_atomic
)
725 warning (0, "target does not support atomic profile update, "
726 "single mode is selected");
727 flag_profile_update
= PROFILE_UPDATE_SINGLE
;
729 else if (flag_profile_update
== PROFILE_UPDATE_PREFER_ATOMIC
)
730 flag_profile_update
= can_support_atomic
731 ? PROFILE_UPDATE_ATOMIC
: PROFILE_UPDATE_SINGLE
;
733 /* This is a small-ipa pass that gets called only once, from
734 cgraphunit.c:ipa_passes(). */
735 gcc_assert (symtab
->state
== IPA_SSA
);
737 init_node_map (true);
738 parse_profile_file_filtering ();
740 FOR_EACH_DEFINED_FUNCTION (node
)
742 if (!gimple_has_body_p (node
->decl
))
745 /* Don't profile functions produced for builtin stuff. */
746 if (DECL_SOURCE_LOCATION (node
->decl
) == BUILTINS_LOCATION
)
749 if (lookup_attribute ("no_profile_instrument_function",
750 DECL_ATTRIBUTES (node
->decl
)))
752 /* Do not instrument extern inline functions when testing coverage.
753 While this is not perfectly consistent (early inlined extern inlines
754 will get acocunted), testsuite expects that. */
755 if (DECL_EXTERNAL (node
->decl
)
756 && flag_test_coverage
)
759 const char *file
= LOCATION_FILE (DECL_SOURCE_LOCATION (node
->decl
));
760 if (!include_source_file_for_profile (file
))
763 push_cfun (DECL_STRUCT_FUNCTION (node
->decl
));
766 dump_function_header (dump_file
, cfun
->decl
, dump_flags
);
768 /* Local pure-const may imply need to fixup the cfg. */
769 if (execute_fixup_cfg () & TODO_cleanup_cfg
)
774 if (! flag_branch_probabilities
775 && flag_profile_values
)
776 gimple_gen_ic_func_profiler ();
778 if (flag_branch_probabilities
779 && flag_profile_values
780 && flag_value_profile_transformations
)
781 gimple_value_profile_transformations ();
783 /* The above could hose dominator info. Currently there is
784 none coming in, this is a safety valve. It should be
785 easy to adjust it, if and when there is some. */
786 free_dominance_info (CDI_DOMINATORS
);
787 free_dominance_info (CDI_POST_DOMINATORS
);
791 release_profile_file_filtering ();
793 /* Drop pure/const flags from instrumented functions. */
794 if (profile_arc_flag
|| flag_test_coverage
)
795 FOR_EACH_DEFINED_FUNCTION (node
)
797 if (!gimple_has_body_p (node
->decl
)
799 || node
->decl
!= node
->clone_of
->decl
))
802 /* Don't profile functions produced for builtin stuff. */
803 if (DECL_SOURCE_LOCATION (node
->decl
) == BUILTINS_LOCATION
)
806 node
->set_const_flag (false, false);
807 node
->set_pure_flag (false, false);
810 /* Update call statements and rebuild the cgraph. */
811 FOR_EACH_DEFINED_FUNCTION (node
)
815 if (!gimple_has_body_p (node
->decl
)
817 || node
->decl
!= node
->clone_of
->decl
))
820 /* Don't profile functions produced for builtin stuff. */
821 if (DECL_SOURCE_LOCATION (node
->decl
) == BUILTINS_LOCATION
)
824 push_cfun (DECL_STRUCT_FUNCTION (node
->decl
));
826 FOR_EACH_BB_FN (bb
, cfun
)
828 gimple_stmt_iterator gsi
;
829 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
831 gimple
*stmt
= gsi_stmt (gsi
);
832 if (is_gimple_call (stmt
))
837 /* re-merge split blocks. */
839 update_ssa (TODO_update_ssa
);
841 cgraph_edge::rebuild_edges ();
846 handle_missing_profiles ();
854 const pass_data pass_data_ipa_tree_profile
=
856 SIMPLE_IPA_PASS
, /* type */
857 "profile", /* name */
858 OPTGROUP_NONE
, /* optinfo_flags */
859 TV_IPA_PROFILE
, /* tv_id */
860 0, /* properties_required */
861 0, /* properties_provided */
862 0, /* properties_destroyed */
863 0, /* todo_flags_start */
864 TODO_dump_symtab
, /* todo_flags_finish */
867 class pass_ipa_tree_profile
: public simple_ipa_opt_pass
870 pass_ipa_tree_profile (gcc::context
*ctxt
)
871 : simple_ipa_opt_pass (pass_data_ipa_tree_profile
, ctxt
)
874 /* opt_pass methods: */
875 virtual bool gate (function
*);
876 virtual unsigned int execute (function
*) { return tree_profiling (); }
878 }; // class pass_ipa_tree_profile
881 pass_ipa_tree_profile::gate (function
*)
883 /* When profile instrumentation, use or test coverage shall be performed.
884 But for AutoFDO, this there is no instrumentation, thus this pass is
886 return (!in_lto_p
&& !flag_auto_profile
887 && (flag_branch_probabilities
|| flag_test_coverage
888 || profile_arc_flag
));
893 simple_ipa_opt_pass
*
894 make_pass_ipa_tree_profile (gcc::context
*ctxt
)
896 return new pass_ipa_tree_profile (ctxt
);
899 #include "gt-tree-profile.h"