|
0
|
1 /* Calculate branch probabilities, and basic block execution counts.
|
|
|
2 Copyright (C) 1990, 1991, 1992, 1993, 1994, 1996, 1997, 1998, 1999,
|
|
|
3 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
|
|
|
4 Free Software Foundation, Inc.
|
|
|
5 Contributed by James E. Wilson, UC Berkeley/Cygnus Support;
|
|
|
6 based on some ideas from Dain Samples of UC Berkeley.
|
|
|
7 Further mangling by Bob Manson, Cygnus Support.
|
|
|
8 Converted to use trees by Dale Johannesen, Apple Computer.
|
|
|
9
|
|
|
10 This file is part of GCC.
|
|
|
11
|
|
|
12 GCC is free software; you can redistribute it and/or modify it under
|
|
|
13 the terms of the GNU General Public License as published by the Free
|
|
|
14 Software Foundation; either version 3, or (at your option) any later
|
|
|
15 version.
|
|
|
16
|
|
|
17 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
|
18 WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
19 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
20 for more details.
|
|
|
21
|
|
|
22 You should have received a copy of the GNU General Public License
|
|
|
23 along with GCC; see the file COPYING3. If not see
|
|
|
24 <http://www.gnu.org/licenses/>. */
|
|
|
25
|
|
|
26 /* Generate basic block profile instrumentation and auxiliary files.
|
|
|
27 Tree-based version. See profile.c for overview. */
|
|
|
28
|
|
|
29 #include "config.h"
|
|
|
30 #include "system.h"
|
|
|
31 #include "coretypes.h"
|
|
|
32 #include "tm.h"
|
|
|
33 #include "rtl.h"
|
|
|
34 #include "flags.h"
|
|
|
35 #include "output.h"
|
|
|
36 #include "regs.h"
|
|
|
37 #include "expr.h"
|
|
|
38 #include "function.h"
|
|
|
39 #include "toplev.h"
|
|
|
40 #include "coverage.h"
|
|
|
41 #include "tree.h"
|
|
|
42 #include "tree-flow.h"
|
|
|
43 #include "tree-dump.h"
|
|
|
44 #include "tree-pass.h"
|
|
|
45 #include "timevar.h"
|
|
|
46 #include "value-prof.h"
|
|
|
47 #include "ggc.h"
|
|
|
48 #include "cgraph.h"
|
|
|
49
|
|
|
50 static GTY(()) tree gcov_type_node;
|
|
|
51 static GTY(()) tree gcov_type_tmp_var;
|
|
|
52 static GTY(()) tree tree_interval_profiler_fn;
|
|
|
53 static GTY(()) tree tree_pow2_profiler_fn;
|
|
|
54 static GTY(()) tree tree_one_value_profiler_fn;
|
|
|
55 static GTY(()) tree tree_indirect_call_profiler_fn;
|
|
|
56 static GTY(()) tree tree_average_profiler_fn;
|
|
|
57 static GTY(()) tree tree_ior_profiler_fn;
|
|
|
58
|
|
|
59
|
|
|
60 static GTY(()) tree ic_void_ptr_var;
|
|
|
61 static GTY(()) tree ic_gcov_type_ptr_var;
|
|
|
62 static GTY(()) tree ptr_void;
|
|
|
63
|
|
|
64 /* Do initialization work for the edge profiler. */
|
|
|
65
|
|
|
66 /* Add code:
|
|
|
67 static gcov* __gcov_indirect_call_counters; // pointer to actual counter
|
|
|
68 static void* __gcov_indirect_call_callee; // actual callee address
|
|
|
69 */
|
|
|
70 static void
|
|
|
71 tree_init_ic_make_global_vars (void)
|
|
|
72 {
|
|
|
73 tree gcov_type_ptr;
|
|
|
74
|
|
|
75 ptr_void = build_pointer_type (void_type_node);
|
|
|
76
|
|
|
77 ic_void_ptr_var
|
|
|
78 = build_decl (VAR_DECL,
|
|
|
79 get_identifier ("__gcov_indirect_call_callee"),
|
|
|
80 ptr_void);
|
|
|
81 TREE_STATIC (ic_void_ptr_var) = 1;
|
|
|
82 TREE_PUBLIC (ic_void_ptr_var) = 0;
|
|
|
83 DECL_ARTIFICIAL (ic_void_ptr_var) = 1;
|
|
|
84 DECL_INITIAL (ic_void_ptr_var) = NULL;
|
|
|
85 assemble_variable (ic_void_ptr_var, 0, 0, 0);
|
|
|
86
|
|
|
87 gcov_type_ptr = build_pointer_type (get_gcov_type ());
|
|
|
88 ic_gcov_type_ptr_var
|
|
|
89 = build_decl (VAR_DECL,
|
|
|
90 get_identifier ("__gcov_indirect_call_counters"),
|
|
|
91 gcov_type_ptr);
|
|
|
92 TREE_STATIC (ic_gcov_type_ptr_var) = 1;
|
|
|
93 TREE_PUBLIC (ic_gcov_type_ptr_var) = 0;
|
|
|
94 DECL_ARTIFICIAL (ic_gcov_type_ptr_var) = 1;
|
|
|
95 DECL_INITIAL (ic_gcov_type_ptr_var) = NULL;
|
|
|
96 assemble_variable (ic_gcov_type_ptr_var, 0, 0, 0);
|
|
|
97 }
|
|
|
98
|
|
|
99 static void
|
|
|
100 tree_init_edge_profiler (void)
|
|
|
101 {
|
|
|
102 tree interval_profiler_fn_type;
|
|
|
103 tree pow2_profiler_fn_type;
|
|
|
104 tree one_value_profiler_fn_type;
|
|
|
105 tree gcov_type_ptr;
|
|
|
106 tree ic_profiler_fn_type;
|
|
|
107 tree average_profiler_fn_type;
|
|
|
108
|
|
|
109 if (!gcov_type_node)
|
|
|
110 {
|
|
|
111 gcov_type_node = get_gcov_type ();
|
|
|
112 gcov_type_ptr = build_pointer_type (gcov_type_node);
|
|
|
113
|
|
|
114 /* void (*) (gcov_type *, gcov_type, int, unsigned) */
|
|
|
115 interval_profiler_fn_type
|
|
|
116 = build_function_type_list (void_type_node,
|
|
|
117 gcov_type_ptr, gcov_type_node,
|
|
|
118 integer_type_node,
|
|
|
119 unsigned_type_node, NULL_TREE);
|
|
|
120 tree_interval_profiler_fn
|
|
|
121 = build_fn_decl ("__gcov_interval_profiler",
|
|
|
122 interval_profiler_fn_type);
|
|
|
123
|
|
|
124 /* void (*) (gcov_type *, gcov_type) */
|
|
|
125 pow2_profiler_fn_type
|
|
|
126 = build_function_type_list (void_type_node,
|
|
|
127 gcov_type_ptr, gcov_type_node,
|
|
|
128 NULL_TREE);
|
|
|
129 tree_pow2_profiler_fn = build_fn_decl ("__gcov_pow2_profiler",
|
|
|
130 pow2_profiler_fn_type);
|
|
|
131
|
|
|
132 /* void (*) (gcov_type *, gcov_type) */
|
|
|
133 one_value_profiler_fn_type
|
|
|
134 = build_function_type_list (void_type_node,
|
|
|
135 gcov_type_ptr, gcov_type_node,
|
|
|
136 NULL_TREE);
|
|
|
137 tree_one_value_profiler_fn
|
|
|
138 = build_fn_decl ("__gcov_one_value_profiler",
|
|
|
139 one_value_profiler_fn_type);
|
|
|
140
|
|
|
141 tree_init_ic_make_global_vars ();
|
|
|
142
|
|
|
143 /* void (*) (gcov_type *, gcov_type, void *, void *) */
|
|
|
144 ic_profiler_fn_type
|
|
|
145 = build_function_type_list (void_type_node,
|
|
|
146 gcov_type_ptr, gcov_type_node,
|
|
|
147 ptr_void,
|
|
|
148 ptr_void, NULL_TREE);
|
|
|
149 tree_indirect_call_profiler_fn
|
|
|
150 = build_fn_decl ("__gcov_indirect_call_profiler",
|
|
|
151 ic_profiler_fn_type);
|
|
|
152 /* void (*) (gcov_type *, gcov_type) */
|
|
|
153 average_profiler_fn_type
|
|
|
154 = build_function_type_list (void_type_node,
|
|
|
155 gcov_type_ptr, gcov_type_node, NULL_TREE);
|
|
|
156 tree_average_profiler_fn
|
|
|
157 = build_fn_decl ("__gcov_average_profiler",
|
|
|
158 average_profiler_fn_type);
|
|
|
159 tree_ior_profiler_fn
|
|
|
160 = build_fn_decl ("__gcov_ior_profiler",
|
|
|
161 average_profiler_fn_type);
|
|
|
162 }
|
|
|
163 }
|
|
|
164
|
|
|
165 /* New call was added, make goto call edges if neccesary. */
|
|
|
166
|
|
|
167 static void
|
|
|
168 add_abnormal_goto_call_edges (gimple_stmt_iterator gsi)
|
|
|
169 {
|
|
|
170 gimple stmt = gsi_stmt (gsi);
|
|
|
171
|
|
|
172 if (!stmt_can_make_abnormal_goto (stmt))
|
|
|
173 return;
|
|
|
174 if (!gsi_end_p (gsi))
|
|
|
175 split_block (gimple_bb (stmt), stmt);
|
|
|
176 make_abnormal_goto_edges (gimple_bb (stmt), true);
|
|
|
177 }
|
|
|
178
|
|
|
179 /* Output instructions as GIMPLE trees to increment the edge
|
|
|
180 execution count, and insert them on E. We rely on
|
|
|
181 gsi_insert_on_edge to preserve the order. */
|
|
|
182
|
|
|
183 static void
|
|
|
184 tree_gen_edge_profiler (int edgeno, edge e)
|
|
|
185 {
|
|
|
186 tree ref, one;
|
|
|
187 gimple stmt1, stmt2, stmt3;
|
|
|
188
|
|
|
189 /* We share one temporary variable declaration per function. This
|
|
|
190 gets re-set in tree_profiling. */
|
|
|
191 if (gcov_type_tmp_var == NULL_TREE)
|
|
|
192 gcov_type_tmp_var = create_tmp_var (gcov_type_node, "PROF_edge_counter");
|
|
|
193 ref = tree_coverage_counter_ref (GCOV_COUNTER_ARCS, edgeno);
|
|
|
194 one = build_int_cst (gcov_type_node, 1);
|
|
|
195 stmt1 = gimple_build_assign (gcov_type_tmp_var, ref);
|
|
|
196 stmt2 = gimple_build_assign_with_ops (PLUS_EXPR, gcov_type_tmp_var,
|
|
|
197 gcov_type_tmp_var, one);
|
|
|
198 stmt3 = gimple_build_assign (unshare_expr (ref), gcov_type_tmp_var);
|
|
|
199 gsi_insert_on_edge (e, stmt1);
|
|
|
200 gsi_insert_on_edge (e, stmt2);
|
|
|
201 gsi_insert_on_edge (e, stmt3);
|
|
|
202 }
|
|
|
203
|
|
|
204 /* Emits code to get VALUE to instrument at GSI, and returns the
|
|
|
205 variable containing the value. */
|
|
|
206
|
|
|
207 static tree
|
|
|
208 prepare_instrumented_value (gimple_stmt_iterator *gsi, histogram_value value)
|
|
|
209 {
|
|
|
210 tree val = value->hvalue.value;
|
|
|
211 return force_gimple_operand_gsi (gsi, fold_convert (gcov_type_node, val),
|
|
|
212 true, NULL_TREE, true, GSI_SAME_STMT);
|
|
|
213 }
|
|
|
214
|
|
|
215 /* Output instructions as GIMPLE trees to increment the interval histogram
|
|
|
216 counter. VALUE is the expression whose value is profiled. TAG is the
|
|
|
217 tag of the section for counters, BASE is offset of the counter position. */
|
|
|
218
|
|
|
219 static void
|
|
|
220 tree_gen_interval_profiler (histogram_value value, unsigned tag, unsigned base)
|
|
|
221 {
|
|
|
222 gimple stmt = value->hvalue.stmt;
|
|
|
223 gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
|
|
|
224 tree ref = tree_coverage_counter_ref (tag, base), ref_ptr;
|
|
|
225 gimple call;
|
|
|
226 tree val;
|
|
|
227 tree start = build_int_cst_type (integer_type_node,
|
|
|
228 value->hdata.intvl.int_start);
|
|
|
229 tree steps = build_int_cst_type (unsigned_type_node,
|
|
|
230 value->hdata.intvl.steps);
|
|
|
231
|
|
|
232 ref_ptr = force_gimple_operand_gsi (&gsi,
|
|
|
233 build_addr (ref, current_function_decl),
|
|
|
234 true, NULL_TREE, true, GSI_SAME_STMT);
|
|
|
235 val = prepare_instrumented_value (&gsi, value);
|
|
|
236 call = gimple_build_call (tree_interval_profiler_fn, 4,
|
|
|
237 ref_ptr, val, start, steps);
|
|
|
238 gsi_insert_before (&gsi, call, GSI_NEW_STMT);
|
|
|
239 add_abnormal_goto_call_edges (gsi);
|
|
|
240 }
|
|
|
241
|
|
|
242 /* Output instructions as GIMPLE trees to increment the power of two histogram
|
|
|
243 counter. VALUE is the expression whose value is profiled. TAG is the tag
|
|
|
244 of the section for counters, BASE is offset of the counter position. */
|
|
|
245
|
|
|
246 static void
|
|
|
247 tree_gen_pow2_profiler (histogram_value value, unsigned tag, unsigned base)
|
|
|
248 {
|
|
|
249 gimple stmt = value->hvalue.stmt;
|
|
|
250 gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
|
|
|
251 tree ref_ptr = tree_coverage_counter_addr (tag, base);
|
|
|
252 gimple call;
|
|
|
253 tree val;
|
|
|
254
|
|
|
255 ref_ptr = force_gimple_operand_gsi (&gsi, ref_ptr,
|
|
|
256 true, NULL_TREE, true, GSI_SAME_STMT);
|
|
|
257 val = prepare_instrumented_value (&gsi, value);
|
|
|
258 call = gimple_build_call (tree_pow2_profiler_fn, 2, ref_ptr, val);
|
|
|
259 gsi_insert_before (&gsi, call, GSI_NEW_STMT);
|
|
|
260 add_abnormal_goto_call_edges (gsi);
|
|
|
261 }
|
|
|
262
|
|
|
263 /* Output instructions as GIMPLE trees for code to find the most common value.
|
|
|
264 VALUE is the expression whose value is profiled. TAG is the tag of the
|
|
|
265 section for counters, BASE is offset of the counter position. */
|
|
|
266
|
|
|
267 static void
|
|
|
268 tree_gen_one_value_profiler (histogram_value value, unsigned tag, unsigned base)
|
|
|
269 {
|
|
|
270 gimple stmt = value->hvalue.stmt;
|
|
|
271 gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
|
|
|
272 tree ref_ptr = tree_coverage_counter_addr (tag, base);
|
|
|
273 gimple call;
|
|
|
274 tree val;
|
|
|
275
|
|
|
276 ref_ptr = force_gimple_operand_gsi (&gsi, ref_ptr,
|
|
|
277 true, NULL_TREE, true, GSI_SAME_STMT);
|
|
|
278 val = prepare_instrumented_value (&gsi, value);
|
|
|
279 call = gimple_build_call (tree_one_value_profiler_fn, 2, ref_ptr, val);
|
|
|
280 gsi_insert_before (&gsi, call, GSI_NEW_STMT);
|
|
|
281 add_abnormal_goto_call_edges (gsi);
|
|
|
282 }
|
|
|
283
|
|
|
284
|
|
|
285 /* Output instructions as GIMPLE trees for code to find the most
|
|
|
286 common called function in indirect call.
|
|
|
287 VALUE is the call expression whose indirect callee is profiled.
|
|
|
288 TAG is the tag of the section for counters, BASE is offset of the
|
|
|
289 counter position. */
|
|
|
290
|
|
|
291 static void
|
|
|
292 tree_gen_ic_profiler (histogram_value value, unsigned tag, unsigned base)
|
|
|
293 {
|
|
|
294 tree tmp1;
|
|
|
295 gimple stmt1, stmt2, stmt3;
|
|
|
296 gimple stmt = value->hvalue.stmt;
|
|
|
297 gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
|
|
|
298 tree ref_ptr = tree_coverage_counter_addr (tag, base);
|
|
|
299
|
|
|
300 ref_ptr = force_gimple_operand_gsi (&gsi, ref_ptr,
|
|
|
301 true, NULL_TREE, true, GSI_SAME_STMT);
|
|
|
302
|
|
|
303 /* Insert code:
|
|
|
304
|
|
|
305 __gcov_indirect_call_counters = get_relevant_counter_ptr ();
|
|
|
306 __gcov_indirect_call_callee = (void *) indirect call argument;
|
|
|
307 */
|
|
|
308
|
|
|
309 tmp1 = create_tmp_var (ptr_void, "PROF");
|
|
|
310 stmt1 = gimple_build_assign (ic_gcov_type_ptr_var, ref_ptr);
|
|
|
311 stmt2 = gimple_build_assign (tmp1, unshare_expr (value->hvalue.value));
|
|
|
312 stmt3 = gimple_build_assign (ic_void_ptr_var, tmp1);
|
|
|
313
|
|
|
314 gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
|
|
|
315 gsi_insert_before (&gsi, stmt2, GSI_SAME_STMT);
|
|
|
316 gsi_insert_before (&gsi, stmt3, GSI_SAME_STMT);
|
|
|
317 }
|
|
|
318
|
|
|
319
|
|
|
320 /* Output instructions as GIMPLE trees for code to find the most
|
|
|
321 common called function in indirect call. Insert instructions at the
|
|
|
322 beginning of every possible called function.
|
|
|
323 */
|
|
|
324
|
|
|
325 static void
|
|
|
326 tree_gen_ic_func_profiler (void)
|
|
|
327 {
|
|
|
328 struct cgraph_node * c_node = cgraph_node (current_function_decl);
|
|
|
329 gimple_stmt_iterator gsi;
|
|
|
330 edge e;
|
|
|
331 basic_block bb;
|
|
|
332 edge_iterator ei;
|
|
|
333 gimple stmt1, stmt2;
|
|
|
334 tree tree_uid, cur_func;
|
|
|
335
|
|
|
336 if (!c_node->needed)
|
|
|
337 return;
|
|
|
338
|
|
|
339 tree_init_edge_profiler ();
|
|
|
340
|
|
|
341 FOR_EACH_EDGE (e, ei, ENTRY_BLOCK_PTR->succs)
|
|
|
342 {
|
|
|
343 tree void0;
|
|
|
344
|
|
|
345 bb = split_edge (e);
|
|
|
346 gsi = gsi_start_bb (bb);
|
|
|
347
|
|
|
348 cur_func = force_gimple_operand_gsi (&gsi,
|
|
|
349 build_addr (current_function_decl,
|
|
|
350 current_function_decl),
|
|
|
351 true, NULL_TREE,
|
|
|
352 true, GSI_SAME_STMT);
|
|
|
353 tree_uid = build_int_cst (gcov_type_node, c_node->pid);
|
|
|
354 stmt1 = gimple_build_call (tree_indirect_call_profiler_fn, 4,
|
|
|
355 ic_gcov_type_ptr_var,
|
|
|
356 tree_uid,
|
|
|
357 cur_func,
|
|
|
358 ic_void_ptr_var);
|
|
|
359 gsi_insert_after (&gsi, stmt1, GSI_NEW_STMT);
|
|
|
360 gcc_assert (EDGE_COUNT (bb->succs) == 1);
|
|
|
361 bb = split_edge (EDGE_I (bb->succs, 0));
|
|
|
362 add_abnormal_goto_call_edges (gsi);
|
|
|
363
|
|
|
364 gsi = gsi_start_bb (bb);
|
|
|
365 /* Set __gcov_indirect_call_callee to 0,
|
|
|
366 so that calls from other modules won't get misattributed
|
|
|
367 to the last caller of the current callee. */
|
|
|
368 void0 = build_int_cst (build_pointer_type (void_type_node), 0);
|
|
|
369 stmt2 = gimple_build_assign (ic_void_ptr_var, void0);
|
|
|
370 gsi_insert_after (&gsi, stmt2, GSI_NEW_STMT);
|
|
|
371 }
|
|
|
372 }
|
|
|
373
|
|
|
374 /* Output instructions as GIMPLE trees for code to find the most common value
|
|
|
375 of a difference between two evaluations of an expression.
|
|
|
376 VALUE is the expression whose value is profiled. TAG is the tag of the
|
|
|
377 section for counters, BASE is offset of the counter position. */
|
|
|
378
|
|
|
379 static void
|
|
|
380 tree_gen_const_delta_profiler (histogram_value value ATTRIBUTE_UNUSED,
|
|
|
381 unsigned tag ATTRIBUTE_UNUSED,
|
|
|
382 unsigned base ATTRIBUTE_UNUSED)
|
|
|
383 {
|
|
|
384 /* FIXME implement this. */
|
|
|
385 #ifdef ENABLE_CHECKING
|
|
|
386 internal_error ("unimplemented functionality");
|
|
|
387 #endif
|
|
|
388 gcc_unreachable ();
|
|
|
389 }
|
|
|
390
|
|
|
391 /* Output instructions as GIMPLE trees to increment the average histogram
|
|
|
392 counter. VALUE is the expression whose value is profiled. TAG is the
|
|
|
393 tag of the section for counters, BASE is offset of the counter position. */
|
|
|
394
|
|
|
395 static void
|
|
|
396 tree_gen_average_profiler (histogram_value value, unsigned tag, unsigned base)
|
|
|
397 {
|
|
|
398 gimple stmt = value->hvalue.stmt;
|
|
|
399 gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
|
|
|
400 tree ref_ptr = tree_coverage_counter_addr (tag, base);
|
|
|
401 gimple call;
|
|
|
402 tree val;
|
|
|
403
|
|
|
404 ref_ptr = force_gimple_operand_gsi (&gsi, ref_ptr,
|
|
|
405 true, NULL_TREE,
|
|
|
406 true, GSI_SAME_STMT);
|
|
|
407 val = prepare_instrumented_value (&gsi, value);
|
|
|
408 call = gimple_build_call (tree_average_profiler_fn, 2, ref_ptr, val);
|
|
|
409 gsi_insert_before (&gsi, call, GSI_NEW_STMT);
|
|
|
410 add_abnormal_goto_call_edges (gsi);
|
|
|
411 }
|
|
|
412
|
|
|
413 /* Output instructions as GIMPLE trees to increment the ior histogram
|
|
|
414 counter. VALUE is the expression whose value is profiled. TAG is the
|
|
|
415 tag of the section for counters, BASE is offset of the counter position. */
|
|
|
416
|
|
|
417 static void
|
|
|
418 tree_gen_ior_profiler (histogram_value value, unsigned tag, unsigned base)
|
|
|
419 {
|
|
|
420 gimple stmt = value->hvalue.stmt;
|
|
|
421 gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
|
|
|
422 tree ref_ptr = tree_coverage_counter_addr (tag, base);
|
|
|
423 gimple call;
|
|
|
424 tree val;
|
|
|
425
|
|
|
426 ref_ptr = force_gimple_operand_gsi (&gsi, ref_ptr,
|
|
|
427 true, NULL_TREE, true, GSI_SAME_STMT);
|
|
|
428 val = prepare_instrumented_value (&gsi, value);
|
|
|
429 call = gimple_build_call (tree_ior_profiler_fn, 2, ref_ptr, val);
|
|
|
430 gsi_insert_before (&gsi, call, GSI_NEW_STMT);
|
|
|
431 add_abnormal_goto_call_edges (gsi);
|
|
|
432 }
|
|
|
433
|
|
|
434 /* Return 1 if tree-based profiling is in effect, else 0.
|
|
|
435 If it is, set up hooks for tree-based profiling.
|
|
|
436 Gate for pass_tree_profile. */
|
|
|
437
|
|
|
438 static bool
|
|
|
439 do_tree_profiling (void)
|
|
|
440 {
|
|
|
441 if (profile_arc_flag || flag_test_coverage || flag_branch_probabilities)
|
|
|
442 {
|
|
|
443 tree_register_profile_hooks ();
|
|
|
444 gimple_register_value_prof_hooks ();
|
|
|
445 return true;
|
|
|
446 }
|
|
|
447 return false;
|
|
|
448 }
|
|
|
449
|
|
|
450 static unsigned int
|
|
|
451 tree_profiling (void)
|
|
|
452 {
|
|
|
453 /* Don't profile functions produced at destruction time, particularly
|
|
|
454 the gcov datastructure initializer. Don't profile if it has been
|
|
|
455 already instrumented either (when OpenMP expansion creates
|
|
|
456 child function from already instrumented body). */
|
|
|
457 if (cgraph_state == CGRAPH_STATE_FINISHED
|
|
|
458 || cfun->after_tree_profile)
|
|
|
459 return 0;
|
|
|
460
|
|
|
461 /* Re-set global shared temporary variable for edge-counters. */
|
|
|
462 gcov_type_tmp_var = NULL_TREE;
|
|
|
463
|
|
|
464 branch_prob ();
|
|
|
465
|
|
|
466 if (! flag_branch_probabilities
|
|
|
467 && flag_profile_values)
|
|
|
468 tree_gen_ic_func_profiler ();
|
|
|
469
|
|
|
470 if (flag_branch_probabilities
|
|
|
471 && flag_profile_values
|
|
|
472 && flag_value_profile_transformations)
|
|
|
473 value_profile_transformations ();
|
|
|
474 /* The above could hose dominator info. Currently there is
|
|
|
475 none coming in, this is a safety valve. It should be
|
|
|
476 easy to adjust it, if and when there is some. */
|
|
|
477 free_dominance_info (CDI_DOMINATORS);
|
|
|
478 free_dominance_info (CDI_POST_DOMINATORS);
|
|
|
479 cfun->after_tree_profile = 1;
|
|
|
480 return 0;
|
|
|
481 }
|
|
|
482
|
|
|
483 struct gimple_opt_pass pass_tree_profile =
|
|
|
484 {
|
|
|
485 {
|
|
|
486 GIMPLE_PASS,
|
|
|
487 "tree_profile", /* name */
|
|
|
488 do_tree_profiling, /* gate */
|
|
|
489 tree_profiling, /* execute */
|
|
|
490 NULL, /* sub */
|
|
|
491 NULL, /* next */
|
|
|
492 0, /* static_pass_number */
|
|
|
493 TV_BRANCH_PROB, /* tv_id */
|
|
|
494 PROP_gimple_leh | PROP_cfg, /* properties_required */
|
|
|
495 PROP_gimple_leh | PROP_cfg, /* properties_provided */
|
|
|
496 0, /* properties_destroyed */
|
|
|
497 0, /* todo_flags_start */
|
|
|
498 TODO_verify_stmts | TODO_dump_func /* todo_flags_finish */
|
|
|
499 }
|
|
|
500 };
|
|
|
501
|
|
|
502 struct profile_hooks tree_profile_hooks =
|
|
|
503 {
|
|
|
504 tree_init_edge_profiler, /* init_edge_profiler */
|
|
|
505 tree_gen_edge_profiler, /* gen_edge_profiler */
|
|
|
506 tree_gen_interval_profiler, /* gen_interval_profiler */
|
|
|
507 tree_gen_pow2_profiler, /* gen_pow2_profiler */
|
|
|
508 tree_gen_one_value_profiler, /* gen_one_value_profiler */
|
|
|
509 tree_gen_const_delta_profiler, /* gen_const_delta_profiler */
|
|
|
510 tree_gen_ic_profiler, /* gen_ic_profiler */
|
|
|
511 tree_gen_average_profiler, /* gen_average_profiler */
|
|
|
512 tree_gen_ior_profiler /* gen_ior_profiler */
|
|
|
513 };
|
|
|
514
|
|
|
515 #include "gt-tree-profile.h"
|
