Daily bump.
[official-gcc.git] / gcc / ipa-fnsummary.h
blobfdfbd660e70ea49db951c6f91e1f7d0e2aa0380d
1 /* IPA function body analysis.
2 Copyright (C) 2003-2021 Free Software Foundation, Inc.
3 Contributed by Jan Hubicka
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
10 version.
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15 for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
21 #ifndef GCC_IPA_SUMMARY_H
22 #define GCC_IPA_SUMMARY_H
24 #include "sreal.h"
25 #include "ipa-predicate.h"
28 /* Hints are reasons why IPA heuristics should prefer specializing given
29 function. They are represented as bitmap of the following values. */
30 enum ipa_hints_vals {
31 /* When specialization turns indirect call into a direct call,
32 it is good idea to do so. */
33 INLINE_HINT_indirect_call = 1,
34 /* Inlining may make loop iterations or loop stride known. It is good idea
35 to do so because it enables loop optimizations. */
36 INLINE_HINT_loop_iterations = 2,
37 INLINE_HINT_loop_stride = 4,
38 /* Inlining within same strongly connected component of callgraph is often
39 a loss due to increased stack frame usage and prologue setup costs. */
40 INLINE_HINT_same_scc = 8,
41 /* Inlining functions in strongly connected component is not such a great
42 win. */
43 INLINE_HINT_in_scc = 16,
44 /* If function is declared inline by user, it may be good idea to inline
45 it. Set by simple_edge_hints in ipa-inline-analysis.c. */
46 INLINE_HINT_declared_inline = 32,
47 /* Programs are usually still organized for non-LTO compilation and thus
48 if functions are in different modules, inlining may not be so important.
49 Set by simple_edge_hints in ipa-inline-analysis.c. */
50 INLINE_HINT_cross_module = 64,
51 /* We know that the callee is hot by profile. */
52 INLINE_HINT_known_hot = 128,
53 /* There is builtin_constant_p dependent on parameter which is usually
54 a strong hint to inline. */
55 INLINE_HINT_builtin_constant_p = 256
58 typedef int ipa_hints;
60 /* Simple description of whether a memory load or a condition refers to a load
61 from an aggregate and if so, how and where from in the aggregate.
62 Individual fields have the same meaning like fields with the same name in
63 struct condition. */
65 struct agg_position_info
67 HOST_WIDE_INT offset;
68 bool agg_contents;
69 bool by_ref;
72 /* Representation of function body size and time depending on the call
73 context. We keep simple array of record, every containing of predicate
74 and time/size to account. */
75 class size_time_entry
77 public:
78 /* Predicate for code to be executed. */
79 ipa_predicate exec_predicate;
80 /* Predicate for value to be constant and optimized out in a specialized copy.
81 When deciding on specialization this makes it possible to see how much
82 the executed code paths will simplify. */
83 ipa_predicate nonconst_predicate;
84 int size;
85 sreal time;
88 /* Summary about function and stack frame sizes. We keep this info
89 for inline clones and also for WPA streaming. For this reason this is not
90 part of ipa_fn_summary which exists only for offline functions. */
91 class ipa_size_summary
93 public:
94 /* Estimated stack frame consumption by the function. */
95 HOST_WIDE_INT estimated_self_stack_size;
96 /* Size of the function body. */
97 int self_size;
98 /* Estimated size of the function after inlining. */
99 int size;
101 ipa_size_summary ()
102 : estimated_self_stack_size (0), self_size (0), size (0)
107 /* Structure to capture how frequently some interesting events occur given a
108 particular predicate. The structure is used to estimate how often we
109 encounter loops with known iteration count or stride in various
110 contexts. */
112 struct GTY(()) ipa_freqcounting_predicate
114 /* The described event happens with this frequency... */
115 sreal freq;
116 /* ...when this predicate evaluates to false. */
117 ipa_predicate * GTY((skip)) predicate;
120 /* Function inlining information. */
121 class GTY(()) ipa_fn_summary
123 public:
124 /* Keep all field empty so summary dumping works during its computation.
125 This is useful for debugging. */
126 ipa_fn_summary ()
127 : min_size (0),
128 inlinable (false), single_caller (false),
129 fp_expressions (false),
130 estimated_stack_size (false),
131 time (0), conds (NULL),
132 size_time_table (), call_size_time_table (vNULL),
133 loop_iterations (NULL), loop_strides (NULL),
134 builtin_constant_p_parms (vNULL),
135 growth (0), scc_no (0)
139 /* Copy constructor. */
140 ipa_fn_summary (const ipa_fn_summary &s)
141 : min_size (s.min_size),
142 inlinable (s.inlinable), single_caller (s.single_caller),
143 fp_expressions (s.fp_expressions),
144 estimated_stack_size (s.estimated_stack_size),
145 time (s.time), conds (s.conds), size_time_table (),
146 call_size_time_table (vNULL),
147 loop_iterations (s.loop_iterations), loop_strides (s.loop_strides),
148 builtin_constant_p_parms (s.builtin_constant_p_parms),
149 growth (s.growth), scc_no (s.scc_no)
152 /* Default constructor. */
153 ~ipa_fn_summary ();
155 /* Information about the function body itself. */
157 /* Minimal size increase after inlining. */
158 int min_size;
160 /* False when there something makes inlining impossible (such as va_arg). */
161 unsigned inlinable : 1;
162 /* True wen there is only one caller of the function before small function
163 inlining. */
164 unsigned int single_caller : 1;
165 /* True if function contains any floating point expressions. */
166 unsigned int fp_expressions : 1;
168 /* Information about function that will result after applying all the
169 inline decisions present in the callgraph. Generally kept up to
170 date only for functions that are not inline clones. */
172 /* Estimated stack frame consumption by the function. */
173 HOST_WIDE_INT estimated_stack_size;
174 /* Estimated runtime of function after inlining. */
175 sreal GTY((skip)) time;
177 /* Conditional size/time information. The summaries are being
178 merged during inlining. */
179 conditions conds;
180 /* Normal code is accounted in size_time_table, while calls are
181 accounted in call_size_time_table. This is because calls
182 are often adjusted by IPA optimizations and thus this summary
183 is generated from call summary information when needed. */
184 auto_vec<size_time_entry> GTY((skip)) size_time_table;
185 /* Unlike size_time_table that is initialized for all summaries
186 call_size_time_table is allocated only for functions with
187 many calls. Use effecient vl_ptr storage. */
188 vec<size_time_entry, va_heap, vl_ptr> GTY((skip)) call_size_time_table;
190 /* Predicates on when some loops in the function can have known bounds. */
191 vec<ipa_freqcounting_predicate, va_gc> *loop_iterations;
192 /* Predicates on when some loops in the function can have known strides. */
193 vec<ipa_freqcounting_predicate, va_gc> *loop_strides;
194 /* Parameters tested by builtin_constant_p. */
195 vec<int, va_heap, vl_ptr> GTY((skip)) builtin_constant_p_parms;
196 /* Estimated growth for inlining all copies of the function before start
197 of small functions inlining.
198 This value will get out of date as the callers are duplicated, but
199 using up-to-date value in the badness metric mean a lot of extra
200 expenses. */
201 int growth;
202 /* Number of SCC on the beginning of inlining process. */
203 int scc_no;
205 /* Record time and size under given predicates. */
206 void account_size_time (int, sreal, const ipa_predicate &,
207 const ipa_predicate &,
208 bool call = false);
210 /* We keep values scaled up, so fractional sizes can be accounted. */
211 static const int size_scale = 2;
212 /* Maximal size of size_time_table before we start to be conservative. */
213 static const int max_size_time_table_size = 256;
216 class GTY((user)) ipa_fn_summary_t:
217 public fast_function_summary <ipa_fn_summary *, va_gc>
219 public:
220 ipa_fn_summary_t (symbol_table *symtab):
221 fast_function_summary <ipa_fn_summary *, va_gc> (symtab) {}
223 static ipa_fn_summary_t *create_ggc (symbol_table *symtab)
225 class ipa_fn_summary_t *summary
226 = new (ggc_alloc_no_dtor<ipa_fn_summary_t> ()) ipa_fn_summary_t (symtab);
227 summary->disable_insertion_hook ();
228 return summary;
231 /* Remove ipa_fn_summary for all callees of NODE. */
232 void remove_callees (cgraph_node *node);
234 virtual void insert (cgraph_node *, ipa_fn_summary *);
235 virtual void remove (cgraph_node *node, ipa_fn_summary *)
237 remove_callees (node);
240 virtual void duplicate (cgraph_node *src, cgraph_node *dst,
241 ipa_fn_summary *src_data, ipa_fn_summary *dst_data);
244 extern GTY(()) fast_function_summary <ipa_fn_summary *, va_gc>
245 *ipa_fn_summaries;
247 class ipa_size_summary_t:
248 public fast_function_summary <ipa_size_summary *, va_heap>
250 public:
251 ipa_size_summary_t (symbol_table *symtab):
252 fast_function_summary <ipa_size_summary *, va_heap> (symtab)
254 disable_insertion_hook ();
257 virtual void duplicate (cgraph_node *, cgraph_node *,
258 ipa_size_summary *src_data,
259 ipa_size_summary *dst_data)
261 *dst_data = *src_data;
264 extern fast_function_summary <ipa_size_summary *, va_heap>
265 *ipa_size_summaries;
267 /* Information kept about callgraph edges. */
268 class ipa_call_summary
270 public:
271 /* Keep all field empty so summary dumping works during its computation.
272 This is useful for debugging. */
273 ipa_call_summary ()
274 : predicate (NULL), param (vNULL), call_stmt_size (0), call_stmt_time (0),
275 loop_depth (0), is_return_callee_uncaptured (false)
279 /* Copy constructor. */
280 ipa_call_summary (const ipa_call_summary &s):
281 predicate (s.predicate), param (s.param), call_stmt_size (s.call_stmt_size),
282 call_stmt_time (s.call_stmt_time), loop_depth (s.loop_depth),
283 is_return_callee_uncaptured (s.is_return_callee_uncaptured)
287 /* Default destructor. */
288 ~ipa_call_summary ();
290 ipa_predicate *predicate;
291 /* Vector indexed by parameters. */
292 vec<inline_param_summary> param;
293 /* Estimated size and time of the call statement. */
294 int call_stmt_size;
295 int call_stmt_time;
296 /* Depth of loop nest, 0 means no nesting. */
297 unsigned int loop_depth;
298 /* Indicates whether the caller returns the value of it's callee. */
299 bool is_return_callee_uncaptured;
302 class ipa_call_summary_t: public fast_call_summary <ipa_call_summary *, va_heap>
304 public:
305 ipa_call_summary_t (symbol_table *symtab):
306 fast_call_summary <ipa_call_summary *, va_heap> (symtab) {}
308 /* Hook that is called by summary when an edge is duplicated. */
309 virtual void duplicate (cgraph_edge *src, cgraph_edge *dst,
310 ipa_call_summary *src_data,
311 ipa_call_summary *dst_data);
314 /* Estimated execution times, code sizes and other information about the
315 code executing a call described by ipa_call_context. */
317 struct ipa_call_estimates
319 /* Estimated size needed to execute call in the given context. */
320 int size;
322 /* Minimal size needed for the call that is + independent on the call context
323 and can be used for fast estimates. */
324 int min_size;
326 /* Estimated time needed to execute call in the given context. */
327 sreal time;
329 /* Estimated time needed to execute the function when not ignoring
330 computations known to be constant in this context. */
331 sreal nonspecialized_time;
333 /* Further discovered reasons why to inline or specialize the give calls. */
334 ipa_hints hints;
336 /* Frequency how often a loop with known number of iterations is encountered.
337 Calculated with hints. */
338 sreal loops_with_known_iterations;
340 /* Frequency how often a loop with known strides is encountered. Calculated
341 with hints. */
342 sreal loops_with_known_strides;
345 class ipa_cached_call_context;
347 /* This object describe a context of call. That is a summary of known
348 information about its parameters. Main purpose of this context is
349 to give more realistic estimations of function runtime, size and
350 inline hints. */
351 class ipa_call_context
353 public:
354 ipa_call_context (cgraph_node *node,
355 clause_t possible_truths,
356 clause_t nonspec_possible_truths,
357 vec<inline_param_summary> inline_param_summary,
358 ipa_auto_call_arg_values *arg_values);
359 ipa_call_context ()
360 : m_node(NULL)
363 void estimate_size_and_time (ipa_call_estimates *estimates,
364 bool est_times = true, bool est_hints = true);
365 bool equal_to (const ipa_call_context &);
366 bool exists_p ()
368 return m_node != NULL;
370 private:
371 /* Called function. */
372 cgraph_node *m_node;
373 /* Clause describing what predicate conditionals can be satisfied
374 in this context if function is inlined/specialized. */
375 clause_t m_possible_truths;
376 /* Clause describing what predicate conditionals can be satisfied
377 in this context if function is kept offline. */
378 clause_t m_nonspec_possible_truths;
379 /* Inline summary maintains info about change probabilities. */
380 vec<inline_param_summary> m_inline_param_summary;
382 /* Even after having calculated clauses, the information about argument
383 values is used to resolve indirect calls. */
384 ipa_call_arg_values m_avals;
386 friend ipa_cached_call_context;
389 /* Variant of ipa_call_context that is stored in a cache over a longer period
390 of time. */
392 class ipa_cached_call_context : public ipa_call_context
394 public:
395 void duplicate_from (const ipa_call_context &ctx);
396 void release ();
399 extern fast_call_summary <ipa_call_summary *, va_heap> *ipa_call_summaries;
401 /* In ipa-fnsummary.c */
402 void ipa_debug_fn_summary (struct cgraph_node *);
403 void ipa_dump_fn_summaries (FILE *f);
404 void ipa_dump_fn_summary (FILE *f, struct cgraph_node *node);
405 void ipa_dump_hints (FILE *f, ipa_hints);
406 void ipa_free_fn_summary (void);
407 void ipa_free_size_summary (void);
408 void inline_analyze_function (struct cgraph_node *node);
409 void estimate_ipcp_clone_size_and_time (struct cgraph_node *node,
410 ipa_auto_call_arg_values *avals,
411 ipa_call_estimates *estimates);
412 void ipa_merge_fn_summary_after_inlining (struct cgraph_edge *edge);
413 void ipa_update_overall_fn_summary (struct cgraph_node *node, bool reset = true);
414 void compute_fn_summary (struct cgraph_node *, bool);
415 bool refs_local_or_readonly_memory_p (tree);
416 bool points_to_local_or_readonly_memory_p (tree);
419 void evaluate_properties_for_edge (struct cgraph_edge *e,
420 bool inline_p,
421 clause_t *clause_ptr,
422 clause_t *nonspec_clause_ptr,
423 ipa_auto_call_arg_values *avals,
424 bool compute_contexts);
426 void ipa_fnsummary_c_finalize (void);
427 HOST_WIDE_INT ipa_get_stack_frame_offset (struct cgraph_node *node);
428 void ipa_remove_from_growth_caches (struct cgraph_edge *edge);
430 /* Return true if EDGE is a cross module call. */
432 static inline bool
433 cross_module_call_p (struct cgraph_edge *edge)
435 /* Here we do not want to walk to alias target becuase ICF may create
436 cross-unit aliases. */
437 if (edge->caller->unit_id == edge->callee->unit_id)
438 return false;
439 /* If the call is to a (former) comdat function or s symbol with mutiple
440 extern inline definitions then treat is as in-module call. */
441 if (edge->callee->merged_extern_inline || edge->callee->merged_comdat
442 || DECL_COMDAT (edge->callee->decl))
443 return false;
444 return true;
447 #endif /* GCC_IPA_FNSUMMARY_H */