2018-06-01 Richard Biener <rguenther@suse.de>
[official-gcc.git] / gcc / ipa-profile.c
blob1ab838aca2ae9677cec2037c4875c2335bba1e7c
1 /* Basic IPA optimizations based on profile.
2 Copyright (C) 2003-2018 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
9 version.
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 for more details.
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
20 /* ipa-profile pass implements the following analysis propagating profille
21 inter-procedurally.
23 - Count histogram construction. This is a histogram analyzing how much
24 time is spent executing statements with a given execution count read
25 from profile feedback. This histogram is complete only with LTO,
26 otherwise it contains information only about the current unit.
28 Similar histogram is also estimated by coverage runtime. This histogram
29 is not dependent on LTO, but it suffers from various defects; first
30 gcov runtime is not weighting individual basic block by estimated execution
31 time and second the merging of multiple runs makes assumption that the
32 histogram distribution did not change. Consequentely histogram constructed
33 here may be more precise.
35 The information is used to set hot/cold thresholds.
36 - Next speculative indirect call resolution is performed: the local
37 profile pass assigns profile-id to each function and provide us with a
38 histogram specifying the most common target. We look up the callgraph
39 node corresponding to the target and produce a speculative call.
41 This call may or may not survive through IPA optimization based on decision
42 of inliner.
43 - Finally we propagate the following flags: unlikely executed, executed
44 once, executed at startup and executed at exit. These flags are used to
45 control code size/performance threshold and code placement (by producing
46 .text.unlikely/.text.hot/.text.startup/.text.exit subsections). */
47 #include "config.h"
48 #include "system.h"
49 #include "coretypes.h"
50 #include "backend.h"
51 #include "tree.h"
52 #include "gimple.h"
53 #include "predict.h"
54 #include "alloc-pool.h"
55 #include "tree-pass.h"
56 #include "cgraph.h"
57 #include "data-streamer.h"
58 #include "gimple-iterator.h"
59 #include "ipa-utils.h"
60 #include "profile.h"
61 #include "params.h"
62 #include "value-prof.h"
63 #include "tree-inline.h"
64 #include "symbol-summary.h"
65 #include "tree-vrp.h"
66 #include "ipa-prop.h"
67 #include "ipa-fnsummary.h"
69 /* Entry in the histogram. */
71 struct histogram_entry
73 gcov_type count;
74 int time;
75 int size;
78 /* Histogram of profile values.
79 The histogram is represented as an ordered vector of entries allocated via
80 histogram_pool. During construction a separate hashtable is kept to lookup
81 duplicate entries. */
83 vec<histogram_entry *> histogram;
84 static object_allocator<histogram_entry> histogram_pool ("IPA histogram");
86 /* Hashtable support for storing SSA names hashed by their SSA_NAME_VAR. */
88 struct histogram_hash : nofree_ptr_hash <histogram_entry>
90 static inline hashval_t hash (const histogram_entry *);
91 static inline int equal (const histogram_entry *, const histogram_entry *);
94 inline hashval_t
95 histogram_hash::hash (const histogram_entry *val)
97 return val->count;
100 inline int
101 histogram_hash::equal (const histogram_entry *val, const histogram_entry *val2)
103 return val->count == val2->count;
106 /* Account TIME and SIZE executed COUNT times into HISTOGRAM.
107 HASHTABLE is the on-side hash kept to avoid duplicates. */
109 static void
110 account_time_size (hash_table<histogram_hash> *hashtable,
111 vec<histogram_entry *> &histogram,
112 gcov_type count, int time, int size)
114 histogram_entry key = {count, 0, 0};
115 histogram_entry **val = hashtable->find_slot (&key, INSERT);
117 if (!*val)
119 *val = histogram_pool.allocate ();
120 **val = key;
121 histogram.safe_push (*val);
123 (*val)->time += time;
124 (*val)->size += size;
128 cmp_counts (const void *v1, const void *v2)
130 const histogram_entry *h1 = *(const histogram_entry * const *)v1;
131 const histogram_entry *h2 = *(const histogram_entry * const *)v2;
132 if (h1->count < h2->count)
133 return 1;
134 if (h1->count > h2->count)
135 return -1;
136 return 0;
139 /* Dump HISTOGRAM to FILE. */
141 static void
142 dump_histogram (FILE *file, vec<histogram_entry *> histogram)
144 unsigned int i;
145 gcov_type overall_time = 0, cumulated_time = 0, cumulated_size = 0, overall_size = 0;
147 fprintf (dump_file, "Histogram:\n");
148 for (i = 0; i < histogram.length (); i++)
150 overall_time += histogram[i]->count * histogram[i]->time;
151 overall_size += histogram[i]->size;
153 if (!overall_time)
154 overall_time = 1;
155 if (!overall_size)
156 overall_size = 1;
157 for (i = 0; i < histogram.length (); i++)
159 cumulated_time += histogram[i]->count * histogram[i]->time;
160 cumulated_size += histogram[i]->size;
161 fprintf (file, " %" PRId64": time:%i (%2.2f) size:%i (%2.2f)\n",
162 (int64_t) histogram[i]->count,
163 histogram[i]->time,
164 cumulated_time * 100.0 / overall_time,
165 histogram[i]->size,
166 cumulated_size * 100.0 / overall_size);
170 /* Collect histogram from CFG profiles. */
172 static void
173 ipa_profile_generate_summary (void)
175 struct cgraph_node *node;
176 gimple_stmt_iterator gsi;
177 basic_block bb;
179 hash_table<histogram_hash> hashtable (10);
181 FOR_EACH_FUNCTION_WITH_GIMPLE_BODY (node)
182 if (ENTRY_BLOCK_PTR_FOR_FN (DECL_STRUCT_FUNCTION (node->decl))->count.ipa_p ())
183 FOR_EACH_BB_FN (bb, DECL_STRUCT_FUNCTION (node->decl))
185 int time = 0;
186 int size = 0;
187 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
189 gimple *stmt = gsi_stmt (gsi);
190 if (gimple_code (stmt) == GIMPLE_CALL
191 && !gimple_call_fndecl (stmt))
193 histogram_value h;
194 h = gimple_histogram_value_of_type
195 (DECL_STRUCT_FUNCTION (node->decl),
196 stmt, HIST_TYPE_INDIR_CALL);
197 /* No need to do sanity check: gimple_ic_transform already
198 takes away bad histograms. */
199 if (h)
201 /* counter 0 is target, counter 1 is number of execution we called target,
202 counter 2 is total number of executions. */
203 if (h->hvalue.counters[2])
205 struct cgraph_edge * e = node->get_edge (stmt);
206 if (e && !e->indirect_unknown_callee)
207 continue;
208 e->indirect_info->common_target_id
209 = h->hvalue.counters [0];
210 e->indirect_info->common_target_probability
211 = GCOV_COMPUTE_SCALE (h->hvalue.counters [1], h->hvalue.counters [2]);
212 if (e->indirect_info->common_target_probability > REG_BR_PROB_BASE)
214 if (dump_file)
215 fprintf (dump_file, "Probability capped to 1\n");
216 e->indirect_info->common_target_probability = REG_BR_PROB_BASE;
219 gimple_remove_histogram_value (DECL_STRUCT_FUNCTION (node->decl),
220 stmt, h);
223 time += estimate_num_insns (stmt, &eni_time_weights);
224 size += estimate_num_insns (stmt, &eni_size_weights);
226 if (bb->count.ipa_p () && bb->count.initialized_p ())
227 account_time_size (&hashtable, histogram, bb->count.ipa ().to_gcov_type (),
228 time, size);
230 histogram.qsort (cmp_counts);
233 /* Serialize the ipa info for lto. */
235 static void
236 ipa_profile_write_summary (void)
238 struct lto_simple_output_block *ob
239 = lto_create_simple_output_block (LTO_section_ipa_profile);
240 unsigned int i;
242 streamer_write_uhwi_stream (ob->main_stream, histogram.length ());
243 for (i = 0; i < histogram.length (); i++)
245 streamer_write_gcov_count_stream (ob->main_stream, histogram[i]->count);
246 streamer_write_uhwi_stream (ob->main_stream, histogram[i]->time);
247 streamer_write_uhwi_stream (ob->main_stream, histogram[i]->size);
249 lto_destroy_simple_output_block (ob);
252 /* Deserialize the ipa info for lto. */
254 static void
255 ipa_profile_read_summary (void)
257 struct lto_file_decl_data ** file_data_vec
258 = lto_get_file_decl_data ();
259 struct lto_file_decl_data * file_data;
260 int j = 0;
262 hash_table<histogram_hash> hashtable (10);
264 while ((file_data = file_data_vec[j++]))
266 const char *data;
267 size_t len;
268 struct lto_input_block *ib
269 = lto_create_simple_input_block (file_data,
270 LTO_section_ipa_profile,
271 &data, &len);
272 if (ib)
274 unsigned int num = streamer_read_uhwi (ib);
275 unsigned int n;
276 for (n = 0; n < num; n++)
278 gcov_type count = streamer_read_gcov_count (ib);
279 int time = streamer_read_uhwi (ib);
280 int size = streamer_read_uhwi (ib);
281 account_time_size (&hashtable, histogram,
282 count, time, size);
284 lto_destroy_simple_input_block (file_data,
285 LTO_section_ipa_profile,
286 ib, data, len);
289 histogram.qsort (cmp_counts);
292 /* Data used by ipa_propagate_frequency. */
294 struct ipa_propagate_frequency_data
296 cgraph_node *function_symbol;
297 bool maybe_unlikely_executed;
298 bool maybe_executed_once;
299 bool only_called_at_startup;
300 bool only_called_at_exit;
303 /* Worker for ipa_propagate_frequency_1. */
305 static bool
306 ipa_propagate_frequency_1 (struct cgraph_node *node, void *data)
308 struct ipa_propagate_frequency_data *d;
309 struct cgraph_edge *edge;
311 d = (struct ipa_propagate_frequency_data *)data;
312 for (edge = node->callers;
313 edge && (d->maybe_unlikely_executed || d->maybe_executed_once
314 || d->only_called_at_startup || d->only_called_at_exit);
315 edge = edge->next_caller)
317 if (edge->caller != d->function_symbol)
319 d->only_called_at_startup &= edge->caller->only_called_at_startup;
320 /* It makes sense to put main() together with the static constructors.
321 It will be executed for sure, but rest of functions called from
322 main are definitely not at startup only. */
323 if (MAIN_NAME_P (DECL_NAME (edge->caller->decl)))
324 d->only_called_at_startup = 0;
325 d->only_called_at_exit &= edge->caller->only_called_at_exit;
328 /* When profile feedback is available, do not try to propagate too hard;
329 counts are already good guide on function frequencies and roundoff
330 errors can make us to push function into unlikely section even when
331 it is executed by the train run. Transfer the function only if all
332 callers are unlikely executed. */
333 if (profile_info
334 && !(edge->callee->count.ipa () == profile_count::zero ())
335 && (edge->caller->frequency != NODE_FREQUENCY_UNLIKELY_EXECUTED
336 || (edge->caller->global.inlined_to
337 && edge->caller->global.inlined_to->frequency
338 != NODE_FREQUENCY_UNLIKELY_EXECUTED)))
339 d->maybe_unlikely_executed = false;
340 if (edge->count.ipa ().initialized_p ()
341 && !edge->count.ipa ().nonzero_p ())
342 continue;
343 switch (edge->caller->frequency)
345 case NODE_FREQUENCY_UNLIKELY_EXECUTED:
346 break;
347 case NODE_FREQUENCY_EXECUTED_ONCE:
348 if (dump_file && (dump_flags & TDF_DETAILS))
349 fprintf (dump_file, " Called by %s that is executed once\n",
350 edge->caller->name ());
351 d->maybe_unlikely_executed = false;
352 if (ipa_call_summaries->get (edge)->loop_depth)
354 d->maybe_executed_once = false;
355 if (dump_file && (dump_flags & TDF_DETAILS))
356 fprintf (dump_file, " Called in loop\n");
358 break;
359 case NODE_FREQUENCY_HOT:
360 case NODE_FREQUENCY_NORMAL:
361 if (dump_file && (dump_flags & TDF_DETAILS))
362 fprintf (dump_file, " Called by %s that is normal or hot\n",
363 edge->caller->name ());
364 d->maybe_unlikely_executed = false;
365 d->maybe_executed_once = false;
366 break;
369 return edge != NULL;
372 /* Return ture if NODE contains hot calls. */
374 bool
375 contains_hot_call_p (struct cgraph_node *node)
377 struct cgraph_edge *e;
378 for (e = node->callees; e; e = e->next_callee)
379 if (e->maybe_hot_p ())
380 return true;
381 else if (!e->inline_failed
382 && contains_hot_call_p (e->callee))
383 return true;
384 for (e = node->indirect_calls; e; e = e->next_callee)
385 if (e->maybe_hot_p ())
386 return true;
387 return false;
390 /* See if the frequency of NODE can be updated based on frequencies of its
391 callers. */
392 bool
393 ipa_propagate_frequency (struct cgraph_node *node)
395 struct ipa_propagate_frequency_data d = {node, true, true, true, true};
396 bool changed = false;
398 /* We can not propagate anything useful about externally visible functions
399 nor about virtuals. */
400 if (!node->local.local
401 || node->alias
402 || (opt_for_fn (node->decl, flag_devirtualize)
403 && DECL_VIRTUAL_P (node->decl)))
404 return false;
405 gcc_assert (node->analyzed);
406 if (dump_file && (dump_flags & TDF_DETAILS))
407 fprintf (dump_file, "Processing frequency %s\n", node->name ());
409 node->call_for_symbol_and_aliases (ipa_propagate_frequency_1, &d,
410 true);
412 if ((d.only_called_at_startup && !d.only_called_at_exit)
413 && !node->only_called_at_startup)
415 node->only_called_at_startup = true;
416 if (dump_file)
417 fprintf (dump_file, "Node %s promoted to only called at startup.\n",
418 node->name ());
419 changed = true;
421 if ((d.only_called_at_exit && !d.only_called_at_startup)
422 && !node->only_called_at_exit)
424 node->only_called_at_exit = true;
425 if (dump_file)
426 fprintf (dump_file, "Node %s promoted to only called at exit.\n",
427 node->name ());
428 changed = true;
431 /* With profile we can decide on hot/normal based on count. */
432 if (node->count. ipa().initialized_p ())
434 bool hot = false;
435 if (!(node->count. ipa() == profile_count::zero ())
436 && node->count. ipa() >= get_hot_bb_threshold ())
437 hot = true;
438 if (!hot)
439 hot |= contains_hot_call_p (node);
440 if (hot)
442 if (node->frequency != NODE_FREQUENCY_HOT)
444 if (dump_file)
445 fprintf (dump_file, "Node %s promoted to hot.\n",
446 node->name ());
447 node->frequency = NODE_FREQUENCY_HOT;
448 return true;
450 return false;
452 else if (node->frequency == NODE_FREQUENCY_HOT)
454 if (dump_file)
455 fprintf (dump_file, "Node %s reduced to normal.\n",
456 node->name ());
457 node->frequency = NODE_FREQUENCY_NORMAL;
458 changed = true;
461 /* These come either from profile or user hints; never update them. */
462 if (node->frequency == NODE_FREQUENCY_HOT
463 || node->frequency == NODE_FREQUENCY_UNLIKELY_EXECUTED)
464 return changed;
465 if (d.maybe_unlikely_executed)
467 node->frequency = NODE_FREQUENCY_UNLIKELY_EXECUTED;
468 if (dump_file)
469 fprintf (dump_file, "Node %s promoted to unlikely executed.\n",
470 node->name ());
471 changed = true;
473 else if (d.maybe_executed_once && node->frequency != NODE_FREQUENCY_EXECUTED_ONCE)
475 node->frequency = NODE_FREQUENCY_EXECUTED_ONCE;
476 if (dump_file)
477 fprintf (dump_file, "Node %s promoted to executed once.\n",
478 node->name ());
479 changed = true;
481 return changed;
484 /* Simple ipa profile pass propagating frequencies across the callgraph. */
486 static unsigned int
487 ipa_profile (void)
489 struct cgraph_node **order;
490 struct cgraph_edge *e;
491 int order_pos;
492 bool something_changed = false;
493 int i;
494 gcov_type overall_time = 0, cutoff = 0, cumulated = 0, overall_size = 0;
495 struct cgraph_node *n,*n2;
496 int nindirect = 0, ncommon = 0, nunknown = 0, nuseless = 0, nconverted = 0;
497 int nmismatch = 0, nimpossible = 0;
498 bool node_map_initialized = false;
500 if (dump_file)
501 dump_histogram (dump_file, histogram);
502 for (i = 0; i < (int)histogram.length (); i++)
504 overall_time += histogram[i]->count * histogram[i]->time;
505 overall_size += histogram[i]->size;
507 if (overall_time)
509 gcov_type threshold;
511 gcc_assert (overall_size);
512 if (dump_file)
514 gcov_type min, cumulated_time = 0, cumulated_size = 0;
516 fprintf (dump_file, "Overall time: %" PRId64"\n",
517 (int64_t)overall_time);
518 min = get_hot_bb_threshold ();
519 for (i = 0; i < (int)histogram.length () && histogram[i]->count >= min;
520 i++)
522 cumulated_time += histogram[i]->count * histogram[i]->time;
523 cumulated_size += histogram[i]->size;
525 fprintf (dump_file, "GCOV min count: %" PRId64
526 " Time:%3.2f%% Size:%3.2f%%\n",
527 (int64_t)min,
528 cumulated_time * 100.0 / overall_time,
529 cumulated_size * 100.0 / overall_size);
531 cutoff = (overall_time * PARAM_VALUE (HOT_BB_COUNT_WS_PERMILLE) + 500) / 1000;
532 threshold = 0;
533 for (i = 0; cumulated < cutoff; i++)
535 cumulated += histogram[i]->count * histogram[i]->time;
536 threshold = histogram[i]->count;
538 if (!threshold)
539 threshold = 1;
540 if (dump_file)
542 gcov_type cumulated_time = 0, cumulated_size = 0;
544 for (i = 0;
545 i < (int)histogram.length () && histogram[i]->count >= threshold;
546 i++)
548 cumulated_time += histogram[i]->count * histogram[i]->time;
549 cumulated_size += histogram[i]->size;
551 fprintf (dump_file, "Determined min count: %" PRId64
552 " Time:%3.2f%% Size:%3.2f%%\n",
553 (int64_t)threshold,
554 cumulated_time * 100.0 / overall_time,
555 cumulated_size * 100.0 / overall_size);
557 if (threshold > get_hot_bb_threshold ()
558 || in_lto_p)
560 if (dump_file)
561 fprintf (dump_file, "Threshold updated.\n");
562 set_hot_bb_threshold (threshold);
565 histogram.release ();
566 histogram_pool.release ();
568 /* Produce speculative calls: we saved common traget from porfiling into
569 e->common_target_id. Now, at link time, we can look up corresponding
570 function node and produce speculative call. */
572 FOR_EACH_DEFINED_FUNCTION (n)
574 bool update = false;
576 if (!opt_for_fn (n->decl, flag_ipa_profile))
577 continue;
579 for (e = n->indirect_calls; e; e = e->next_callee)
581 if (n->count.initialized_p ())
582 nindirect++;
583 if (e->indirect_info->common_target_id)
585 if (!node_map_initialized)
586 init_node_map (false);
587 node_map_initialized = true;
588 ncommon++;
589 n2 = find_func_by_profile_id (e->indirect_info->common_target_id);
590 if (n2)
592 if (dump_file)
594 fprintf (dump_file, "Indirect call -> direct call from"
595 " other module %s => %s, prob %3.2f\n",
596 n->dump_name (),
597 n2->dump_name (),
598 e->indirect_info->common_target_probability
599 / (float)REG_BR_PROB_BASE);
601 if (e->indirect_info->common_target_probability
602 < REG_BR_PROB_BASE / 2)
604 nuseless++;
605 if (dump_file)
606 fprintf (dump_file,
607 "Not speculating: probability is too low.\n");
609 else if (!e->maybe_hot_p ())
611 nuseless++;
612 if (dump_file)
613 fprintf (dump_file,
614 "Not speculating: call is cold.\n");
616 else if (n2->get_availability () <= AVAIL_INTERPOSABLE
617 && n2->can_be_discarded_p ())
619 nuseless++;
620 if (dump_file)
621 fprintf (dump_file,
622 "Not speculating: target is overwritable "
623 "and can be discarded.\n");
625 else if (ipa_node_params_sum && ipa_edge_args_sum
626 && (!vec_safe_is_empty
627 (IPA_NODE_REF (n2)->descriptors))
628 && ipa_get_param_count (IPA_NODE_REF (n2))
629 != ipa_get_cs_argument_count (IPA_EDGE_REF (e))
630 && (ipa_get_param_count (IPA_NODE_REF (n2))
631 >= ipa_get_cs_argument_count (IPA_EDGE_REF (e))
632 || !stdarg_p (TREE_TYPE (n2->decl))))
634 nmismatch++;
635 if (dump_file)
636 fprintf (dump_file,
637 "Not speculating: "
638 "parameter count mistmatch\n");
640 else if (e->indirect_info->polymorphic
641 && !opt_for_fn (n->decl, flag_devirtualize)
642 && !possible_polymorphic_call_target_p (e, n2))
644 nimpossible++;
645 if (dump_file)
646 fprintf (dump_file,
647 "Not speculating: "
648 "function is not in the polymorphic "
649 "call target list\n");
651 else
653 /* Target may be overwritable, but profile says that
654 control flow goes to this particular implementation
655 of N2. Speculate on the local alias to allow inlining.
657 if (!n2->can_be_discarded_p ())
659 cgraph_node *alias;
660 alias = dyn_cast<cgraph_node *> (n2->noninterposable_alias ());
661 if (alias)
662 n2 = alias;
664 nconverted++;
665 e->make_speculative
666 (n2,
667 e->count.apply_probability
668 (e->indirect_info->common_target_probability));
669 update = true;
672 else
674 if (dump_file)
675 fprintf (dump_file, "Function with profile-id %i not found.\n",
676 e->indirect_info->common_target_id);
677 nunknown++;
681 if (update)
682 ipa_update_overall_fn_summary (n);
684 if (node_map_initialized)
685 del_node_map ();
686 if (dump_file && nindirect)
687 fprintf (dump_file,
688 "%i indirect calls trained.\n"
689 "%i (%3.2f%%) have common target.\n"
690 "%i (%3.2f%%) targets was not found.\n"
691 "%i (%3.2f%%) targets had parameter count mismatch.\n"
692 "%i (%3.2f%%) targets was not in polymorphic call target list.\n"
693 "%i (%3.2f%%) speculations seems useless.\n"
694 "%i (%3.2f%%) speculations produced.\n",
695 nindirect,
696 ncommon, ncommon * 100.0 / nindirect,
697 nunknown, nunknown * 100.0 / nindirect,
698 nmismatch, nmismatch * 100.0 / nindirect,
699 nimpossible, nimpossible * 100.0 / nindirect,
700 nuseless, nuseless * 100.0 / nindirect,
701 nconverted, nconverted * 100.0 / nindirect);
703 order = XCNEWVEC (struct cgraph_node *, symtab->cgraph_count);
704 order_pos = ipa_reverse_postorder (order);
705 for (i = order_pos - 1; i >= 0; i--)
707 if (order[i]->local.local
708 && opt_for_fn (order[i]->decl, flag_ipa_profile)
709 && ipa_propagate_frequency (order[i]))
711 for (e = order[i]->callees; e; e = e->next_callee)
712 if (e->callee->local.local && !e->callee->aux)
714 something_changed = true;
715 e->callee->aux = (void *)1;
718 order[i]->aux = NULL;
721 while (something_changed)
723 something_changed = false;
724 for (i = order_pos - 1; i >= 0; i--)
726 if (order[i]->aux
727 && opt_for_fn (order[i]->decl, flag_ipa_profile)
728 && ipa_propagate_frequency (order[i]))
730 for (e = order[i]->callees; e; e = e->next_callee)
731 if (e->callee->local.local && !e->callee->aux)
733 something_changed = true;
734 e->callee->aux = (void *)1;
737 order[i]->aux = NULL;
740 free (order);
741 return 0;
744 namespace {
746 const pass_data pass_data_ipa_profile =
748 IPA_PASS, /* type */
749 "profile_estimate", /* name */
750 OPTGROUP_NONE, /* optinfo_flags */
751 TV_IPA_PROFILE, /* tv_id */
752 0, /* properties_required */
753 0, /* properties_provided */
754 0, /* properties_destroyed */
755 0, /* todo_flags_start */
756 0, /* todo_flags_finish */
759 class pass_ipa_profile : public ipa_opt_pass_d
761 public:
762 pass_ipa_profile (gcc::context *ctxt)
763 : ipa_opt_pass_d (pass_data_ipa_profile, ctxt,
764 ipa_profile_generate_summary, /* generate_summary */
765 ipa_profile_write_summary, /* write_summary */
766 ipa_profile_read_summary, /* read_summary */
767 NULL, /* write_optimization_summary */
768 NULL, /* read_optimization_summary */
769 NULL, /* stmt_fixup */
770 0, /* function_transform_todo_flags_start */
771 NULL, /* function_transform */
772 NULL) /* variable_transform */
775 /* opt_pass methods: */
776 virtual bool gate (function *) { return flag_ipa_profile || in_lto_p; }
777 virtual unsigned int execute (function *) { return ipa_profile (); }
779 }; // class pass_ipa_profile
781 } // anon namespace
783 ipa_opt_pass_d *
784 make_pass_ipa_profile (gcc::context *ctxt)
786 return new pass_ipa_profile (ctxt);