Branch data Line data Source code
1 : : /* Callgraph based analysis of static variables.
2 : : Copyright (C) 2004-2024 Free Software Foundation, Inc.
3 : : Contributed by Kenneth Zadeck <zadeck@naturalbridge.com>
4 : :
5 : : This file is part of GCC.
6 : :
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.
11 : :
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.
16 : :
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/>. */
20 : :
21 : : /* This file marks functions as being either const (TREE_READONLY) or
22 : : pure (DECL_PURE_P). It can also set a variant of these that
23 : : are allowed to loop indefinitely (DECL_LOOPING_CONST_PURE_P).
24 : :
25 : : This must be run after inlining decisions have been made since
26 : : otherwise, the local sets will not contain information that is
27 : : consistent with post inlined state. The global sets are not prone
28 : : to this problem since they are by definition transitive. */
29 : :
30 : : /* The code in this module is called by the ipa pass manager. It
31 : : should be one of the later passes since it's information is used by
32 : : the rest of the compilation. */
33 : :
34 : : #include "config.h"
35 : : #include "system.h"
36 : : #include "coretypes.h"
37 : : #include "backend.h"
38 : : #include "target.h"
39 : : #include "tree.h"
40 : : #include "gimple.h"
41 : : #include "tree-pass.h"
42 : : #include "tree-streamer.h"
43 : : #include "cgraph.h"
44 : : #include "diagnostic.h"
45 : : #include "calls.h"
46 : : #include "cfganal.h"
47 : : #include "tree-eh.h"
48 : : #include "gimple-iterator.h"
49 : : #include "gimple-walk.h"
50 : : #include "tree-cfg.h"
51 : : #include "tree-ssa-loop-niter.h"
52 : : #include "langhooks.h"
53 : : #include "ipa-utils.h"
54 : : #include "gimple-pretty-print.h"
55 : : #include "cfgloop.h"
56 : : #include "tree-scalar-evolution.h"
57 : : #include "intl.h"
58 : : #include "opts.h"
59 : : #include "ssa.h"
60 : : #include "alloc-pool.h"
61 : : #include "symbol-summary.h"
62 : : #include "sreal.h"
63 : : #include "ipa-cp.h"
64 : : #include "ipa-prop.h"
65 : : #include "ipa-fnsummary.h"
66 : : #include "symtab-thunks.h"
67 : : #include "dbgcnt.h"
68 : :
69 : : /* Lattice values for const and pure functions. Everything starts out
70 : : being const, then may drop to pure and then neither depending on
71 : : what is found. */
72 : : enum pure_const_state_e
73 : : {
74 : : IPA_CONST,
75 : : IPA_PURE,
76 : : IPA_NEITHER
77 : : };
78 : :
79 : : static const char *pure_const_names[3] = {"const", "pure", "neither"};
80 : :
81 : : enum malloc_state_e
82 : : {
83 : : STATE_MALLOC_TOP,
84 : : STATE_MALLOC,
85 : : STATE_MALLOC_BOTTOM
86 : : };
87 : :
88 : : static const char *malloc_state_names[] = {"malloc_top", "malloc", "malloc_bottom"};
89 : :
90 : : /* Holder for the const_state. There is one of these per function
91 : : decl. */
92 : : class funct_state_d
93 : : {
94 : : public:
95 : 2449802 : funct_state_d (): pure_const_state (IPA_NEITHER),
96 : 2449802 : state_previously_known (IPA_NEITHER), looping_previously_known (true),
97 : 2449802 : looping (true), can_throw (true), can_free (true),
98 : 0 : malloc_state (STATE_MALLOC_BOTTOM) {}
99 : :
100 : 2343937 : funct_state_d (const funct_state_d &s): pure_const_state (s.pure_const_state),
101 : 2343937 : state_previously_known (s.state_previously_known),
102 : 2343937 : looping_previously_known (s.looping_previously_known),
103 : 2343937 : looping (s.looping), can_throw (s.can_throw), can_free (s.can_free),
104 : 2343937 : malloc_state (s.malloc_state) {}
105 : :
106 : : /* See above. */
107 : : enum pure_const_state_e pure_const_state;
108 : : /* What user set here; we can be always sure about this. */
109 : : enum pure_const_state_e state_previously_known;
110 : : bool looping_previously_known;
111 : :
112 : : /* True if the function could possibly infinite loop. There are a
113 : : lot of ways that this could be determined. We are pretty
114 : : conservative here. While it is possible to cse pure and const
115 : : calls, it is not legal to have dce get rid of the call if there
116 : : is a possibility that the call could infinite loop since this is
117 : : a behavioral change. */
118 : : bool looping;
119 : :
120 : : bool can_throw;
121 : :
122 : : /* If function can call free, munmap or otherwise make previously
123 : : non-trapping memory accesses trapping. */
124 : : bool can_free;
125 : :
126 : : enum malloc_state_e malloc_state;
127 : : };
128 : :
129 : : typedef class funct_state_d * funct_state;
130 : :
131 : : /* The storage of the funct_state is abstracted because there is the
132 : : possibility that it may be desirable to move this to the cgraph
133 : : local info. */
134 : :
135 : : class funct_state_summary_t:
136 : : public fast_function_summary <funct_state_d *, va_heap>
137 : : {
138 : : public:
139 : 153686 : funct_state_summary_t (symbol_table *symtab):
140 : 307372 : fast_function_summary <funct_state_d *, va_heap> (symtab) {}
141 : :
142 : : void insert (cgraph_node *, funct_state_d *state) final override;
143 : : void duplicate (cgraph_node *src_node, cgraph_node *dst_node,
144 : : funct_state_d *src_data,
145 : : funct_state_d *dst_data) final override;
146 : : };
147 : :
148 : : static funct_state_summary_t *funct_state_summaries = NULL;
149 : :
150 : : static bool gate_pure_const (void);
151 : :
152 : : namespace {
153 : :
154 : : const pass_data pass_data_ipa_pure_const =
155 : : {
156 : : IPA_PASS, /* type */
157 : : "pure-const", /* name */
158 : : OPTGROUP_NONE, /* optinfo_flags */
159 : : TV_IPA_PURE_CONST, /* tv_id */
160 : : 0, /* properties_required */
161 : : 0, /* properties_provided */
162 : : 0, /* properties_destroyed */
163 : : 0, /* todo_flags_start */
164 : : 0, /* todo_flags_finish */
165 : : };
166 : :
167 : : class pass_ipa_pure_const : public ipa_opt_pass_d
168 : : {
169 : : public:
170 : : pass_ipa_pure_const(gcc::context *ctxt);
171 : :
172 : : /* opt_pass methods: */
173 : 1130554 : bool gate (function *) final override { return gate_pure_const (); }
174 : : unsigned int execute (function *fun) final override;
175 : :
176 : : void register_hooks (void);
177 : :
178 : : private:
179 : : bool init_p;
180 : : }; // class pass_ipa_pure_const
181 : :
182 : : } // anon namespace
183 : :
184 : : /* Try to guess if function body will always be visible to compiler
185 : : when compiling the call and whether compiler will be able
186 : : to propagate the information by itself. */
187 : :
188 : : static bool
189 : 26 : function_always_visible_to_compiler_p (tree decl)
190 : : {
191 : 22 : return (!TREE_PUBLIC (decl) || DECL_DECLARED_INLINE_P (decl)
192 : 48 : || DECL_COMDAT (decl));
193 : : }
194 : :
195 : : /* Emit suggestion about attribute ATTRIB_NAME for DECL. KNOWN_FINITE
196 : : is true if the function is known to be finite. The diagnostic is
197 : : controlled by OPTION. WARNED_ABOUT is a hash_set<tree> unique for
198 : : OPTION, this function may initialize it and it is always returned
199 : : by the function. */
200 : :
201 : : static hash_set<tree> *
202 : 1131798 : suggest_attribute (diagnostic_option_id option, tree decl, bool known_finite,
203 : : hash_set<tree> *warned_about,
204 : : const char * attrib_name)
205 : : {
206 : 1131798 : if (!option_enabled (option.m_idx, lang_hooks.option_lang_mask (),
207 : : &global_options))
208 : : return warned_about;
209 : 30 : if (TREE_THIS_VOLATILE (decl)
210 : 30 : || (known_finite && function_always_visible_to_compiler_p (decl)))
211 : : return warned_about;
212 : :
213 : 26 : if (!warned_about)
214 : 14 : warned_about = new hash_set<tree>;
215 : 26 : if (warned_about->contains (decl))
216 : : return warned_about;
217 : 26 : warned_about->add (decl);
218 : 30 : warning_at (DECL_SOURCE_LOCATION (decl),
219 : : option,
220 : : known_finite
221 : : ? G_("function might be candidate for attribute %qs")
222 : : : G_("function might be candidate for attribute %qs"
223 : : " if it is known to return normally"), attrib_name);
224 : 26 : return warned_about;
225 : : }
226 : :
227 : : /* Emit suggestion about __attribute_((pure)) for DECL. KNOWN_FINITE
228 : : is true if the function is known to be finite. */
229 : :
230 : : static void
231 : 321398 : warn_function_pure (tree decl, bool known_finite)
232 : : {
233 : : /* Declaring a void function pure makes no sense and is diagnosed
234 : : by -Wattributes because calling it would have no effect. */
235 : 321398 : if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl))))
236 : : return;
237 : :
238 : 294487 : static hash_set<tree> *warned_about;
239 : 294487 : warned_about
240 : 294487 : = suggest_attribute (OPT_Wsuggest_attribute_pure, decl,
241 : : known_finite, warned_about, "pure");
242 : : }
243 : :
244 : : /* Emit suggestion about __attribute_((const)) for DECL. KNOWN_FINITE
245 : : is true if the function is known to be finite. */
246 : :
247 : : static void
248 : 880752 : warn_function_const (tree decl, bool known_finite)
249 : : {
250 : : /* Declaring a void function const makes no sense is diagnosed
251 : : by -Wattributes because calling it would have no effect. */
252 : 880752 : if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl))))
253 : : return;
254 : :
255 : 621223 : static hash_set<tree> *warned_about;
256 : 621223 : warned_about
257 : 621223 : = suggest_attribute (OPT_Wsuggest_attribute_const, decl,
258 : : known_finite, warned_about, "const");
259 : : }
260 : :
261 : : /* Emit suggestion about __attribute__((malloc)) for DECL. */
262 : :
263 : : static void
264 : 3 : warn_function_malloc (tree decl)
265 : : {
266 : 3 : static hash_set<tree> *warned_about;
267 : 3 : warned_about
268 : 3 : = suggest_attribute (OPT_Wsuggest_attribute_malloc, decl,
269 : : true, warned_about, "malloc");
270 : 3 : }
271 : :
272 : : /* Emit suggestion about __attribute__((noreturn)) for DECL. */
273 : :
274 : : static void
275 : 29802 : warn_function_noreturn (tree decl)
276 : : {
277 : 29802 : tree original_decl = decl;
278 : :
279 : 29802 : static hash_set<tree> *warned_about;
280 : 29802 : if (!lang_hooks.missing_noreturn_ok_p (decl)
281 : 29802 : && targetm.warn_func_return (decl))
282 : 18265 : warned_about
283 : 18265 : = suggest_attribute (OPT_Wsuggest_attribute_noreturn, original_decl,
284 : : true, warned_about, "noreturn");
285 : 29802 : }
286 : :
287 : : void
288 : 12998 : warn_function_cold (tree decl)
289 : : {
290 : 12998 : tree original_decl = decl;
291 : :
292 : 12998 : static hash_set<tree> *warned_about;
293 : 12998 : warned_about
294 : 12998 : = suggest_attribute (OPT_Wsuggest_attribute_cold, original_decl,
295 : : true, warned_about, "cold");
296 : 12998 : }
297 : :
298 : : void
299 : 184822 : warn_function_returns_nonnull (tree decl)
300 : : {
301 : 184822 : static hash_set<tree> *warned_about;
302 : 184822 : warned_about
303 : 184822 : = suggest_attribute (OPT_Wsuggest_attribute_returns_nonnull, decl,
304 : : true, warned_about, "returns_nonnull");
305 : 184822 : }
306 : :
307 : : /* Check to see if the use (or definition when CHECKING_WRITE is true)
308 : : variable T is legal in a function that is either pure or const. */
309 : :
310 : : static inline void
311 : 20178548 : check_decl (funct_state local,
312 : : tree t, bool checking_write, bool ipa)
313 : : {
314 : : /* Do not want to do anything with volatile except mark any
315 : : function that uses one to be not const or pure. */
316 : 20178548 : if (TREE_THIS_VOLATILE (t))
317 : : {
318 : 1440240 : local->pure_const_state = IPA_NEITHER;
319 : 1440240 : if (dump_file)
320 : 30 : fprintf (dump_file, " Volatile operand is not const/pure\n");
321 : 1440240 : return;
322 : : }
323 : :
324 : : /* Do not care about a local automatic that is not static. */
325 : 18738308 : if (!TREE_STATIC (t) && !DECL_EXTERNAL (t))
326 : : return;
327 : :
328 : : /* If the variable has the "used" attribute, treat it as if it had a
329 : : been touched by the devil. */
330 : 3352192 : if (DECL_PRESERVE_P (t))
331 : : {
332 : 2990 : local->pure_const_state = IPA_NEITHER;
333 : 2990 : if (dump_file)
334 : 0 : fprintf (dump_file, " Used static/global variable is not const/pure\n");
335 : 2990 : return;
336 : : }
337 : :
338 : : /* In IPA mode we are not interested in checking actual loads and stores;
339 : : they will be processed at propagation time using ipa_ref. */
340 : 3349202 : if (ipa)
341 : : return;
342 : :
343 : : /* Since we have dealt with the locals and params cases above, if we
344 : : are CHECKING_WRITE, this cannot be a pure or constant
345 : : function. */
346 : 2155809 : if (checking_write)
347 : : {
348 : 779956 : local->pure_const_state = IPA_NEITHER;
349 : 779956 : if (dump_file)
350 : 1 : fprintf (dump_file, " static/global memory write is not const/pure\n");
351 : 779956 : return;
352 : : }
353 : :
354 : 1375853 : if (DECL_EXTERNAL (t) || TREE_PUBLIC (t))
355 : : {
356 : : /* Readonly reads are safe. */
357 : 791819 : if (TREE_READONLY (t))
358 : : return; /* Read of a constant, do not change the function state. */
359 : : else
360 : : {
361 : 788285 : if (dump_file)
362 : 0 : fprintf (dump_file, " global memory read is not const\n");
363 : : /* Just a regular read. */
364 : 788285 : if (local->pure_const_state == IPA_CONST)
365 : 160729 : local->pure_const_state = IPA_PURE;
366 : : }
367 : : }
368 : : else
369 : : {
370 : : /* Compilation level statics can be read if they are readonly
371 : : variables. */
372 : 584034 : if (TREE_READONLY (t))
373 : : return;
374 : :
375 : 558321 : if (dump_file)
376 : 1 : fprintf (dump_file, " static memory read is not const\n");
377 : : /* Just a regular read. */
378 : 558321 : if (local->pure_const_state == IPA_CONST)
379 : 31537 : local->pure_const_state = IPA_PURE;
380 : : }
381 : : }
382 : :
383 : :
384 : : /* Check to see if the use (or definition when CHECKING_WRITE is true)
385 : : variable T is legal in a function that is either pure or const. */
386 : :
387 : : static inline void
388 : 16173753 : check_op (funct_state local, tree t, bool checking_write)
389 : : {
390 : 16173753 : t = get_base_address (t);
391 : 16173753 : if (t && TREE_THIS_VOLATILE (t))
392 : : {
393 : 32453 : local->pure_const_state = IPA_NEITHER;
394 : 32453 : if (dump_file)
395 : 2 : fprintf (dump_file, " Volatile indirect ref is not const/pure\n");
396 : 32453 : return;
397 : : }
398 : 16141300 : else if (refs_local_or_readonly_memory_p (t))
399 : : {
400 : 3504162 : if (dump_file)
401 : 10 : fprintf (dump_file, " Indirect ref to local or readonly "
402 : : "memory is OK\n");
403 : 3504162 : return;
404 : : }
405 : 12637138 : else if (checking_write)
406 : : {
407 : 4453519 : local->pure_const_state = IPA_NEITHER;
408 : 4453519 : if (dump_file)
409 : 65 : fprintf (dump_file, " Indirect ref write is not const/pure\n");
410 : 4453519 : return;
411 : : }
412 : : else
413 : : {
414 : 8183619 : if (dump_file)
415 : 175 : fprintf (dump_file, " Indirect ref read is not const\n");
416 : 8183619 : if (local->pure_const_state == IPA_CONST)
417 : 1179142 : local->pure_const_state = IPA_PURE;
418 : : }
419 : : }
420 : :
421 : : /* compute state based on ECF FLAGS and store to STATE and LOOPING. */
422 : :
423 : : static void
424 : 14757682 : state_from_flags (enum pure_const_state_e *state, bool *looping,
425 : : int flags, bool cannot_lead_to_return)
426 : : {
427 : 14757682 : *looping = false;
428 : 14757682 : if (flags & ECF_LOOPING_CONST_OR_PURE)
429 : : {
430 : 192525 : *looping = true;
431 : 192525 : if (dump_file && (dump_flags & TDF_DETAILS))
432 : 0 : fprintf (dump_file, " looping\n");
433 : : }
434 : 14757682 : if (flags & ECF_CONST)
435 : : {
436 : 1044620 : *state = IPA_CONST;
437 : 1044620 : if (dump_file && (dump_flags & TDF_DETAILS))
438 : 3 : fprintf (dump_file, " const\n");
439 : : }
440 : 13713062 : else if (flags & ECF_PURE)
441 : : {
442 : 1148727 : *state = IPA_PURE;
443 : 1148727 : if (dump_file && (dump_flags & TDF_DETAILS))
444 : 3 : fprintf (dump_file, " pure\n");
445 : : }
446 : 12564335 : else if (cannot_lead_to_return)
447 : : {
448 : 886645 : *state = IPA_PURE;
449 : 886645 : *looping = true;
450 : 886645 : if (dump_file && (dump_flags & TDF_DETAILS))
451 : 1 : fprintf (dump_file, " ignoring side effects->pure looping\n");
452 : : }
453 : : else
454 : : {
455 : 11677690 : if (dump_file && (dump_flags & TDF_DETAILS))
456 : 42 : fprintf (dump_file, " neither\n");
457 : 11677690 : *state = IPA_NEITHER;
458 : 11677690 : *looping = true;
459 : : }
460 : 14757682 : }
461 : :
462 : : /* Merge STATE and STATE2 and LOOPING and LOOPING2 and store
463 : : into STATE and LOOPING better of the two variants.
464 : : Be sure to merge looping correctly. IPA_NEITHER functions
465 : : have looping 0 even if they don't have to return. */
466 : :
467 : : static inline void
468 : 6405428 : better_state (enum pure_const_state_e *state, bool *looping,
469 : : enum pure_const_state_e state2, bool looping2)
470 : : {
471 : 6405428 : if (state2 < *state)
472 : : {
473 : 30131 : if (*state == IPA_NEITHER)
474 : 29410 : *looping = looping2;
475 : : else
476 : 1442 : *looping = MIN (*looping, looping2);
477 : 30131 : *state = state2;
478 : : }
479 : 6375297 : else if (state2 != IPA_NEITHER)
480 : 1867202 : *looping = MIN (*looping, looping2);
481 : 6405428 : }
482 : :
483 : : /* Merge STATE and STATE2 and LOOPING and LOOPING2 and store
484 : : into STATE and LOOPING worse of the two variants.
485 : : N is the actual node called. */
486 : :
487 : : static inline void
488 : 13661034 : worse_state (enum pure_const_state_e *state, bool *looping,
489 : : enum pure_const_state_e state2, bool looping2,
490 : : struct symtab_node *from,
491 : : struct symtab_node *to)
492 : : {
493 : : /* Consider function:
494 : :
495 : : bool a(int *p)
496 : : {
497 : : return *p==*p;
498 : : }
499 : :
500 : : During early optimization we will turn this into:
501 : :
502 : : bool a(int *p)
503 : : {
504 : : return true;
505 : : }
506 : :
507 : : Now if this function will be detected as CONST however when interposed it
508 : : may end up being just pure. We always must assume the worst scenario here.
509 : : */
510 : 13661034 : if (*state == IPA_CONST && state2 == IPA_CONST
511 : 13661034 : && to && !TREE_READONLY (to->decl) && !to->binds_to_current_def_p (from))
512 : : {
513 : 2679 : if (dump_file && (dump_flags & TDF_DETAILS))
514 : 0 : fprintf (dump_file, "Dropping state to PURE because call to %s may not "
515 : : "bind to current def.\n", to->dump_name ());
516 : : state2 = IPA_PURE;
517 : : }
518 : 13661034 : *state = MAX (*state, state2);
519 : 13661034 : *looping = MAX (*looping, looping2);
520 : 13661034 : }
521 : :
522 : : /* Recognize special cases of builtins that are by themselves not const
523 : : but function using them is. */
524 : : bool
525 : 22194602 : builtin_safe_for_const_function_p (bool *looping, tree callee)
526 : : {
527 : 22194602 : if (DECL_BUILT_IN_CLASS (callee) == BUILT_IN_NORMAL)
528 : 5929980 : switch (DECL_FUNCTION_CODE (callee))
529 : : {
530 : 531565 : case BUILT_IN_RETURN:
531 : 531565 : case BUILT_IN_UNREACHABLE:
532 : 531565 : CASE_BUILT_IN_ALLOCA:
533 : 531565 : case BUILT_IN_STACK_SAVE:
534 : 531565 : case BUILT_IN_STACK_RESTORE:
535 : 531565 : case BUILT_IN_EH_POINTER:
536 : 531565 : case BUILT_IN_EH_FILTER:
537 : 531565 : case BUILT_IN_UNWIND_RESUME:
538 : 531565 : case BUILT_IN_CXA_END_CLEANUP:
539 : 531565 : case BUILT_IN_EH_COPY_VALUES:
540 : 531565 : case BUILT_IN_FRAME_ADDRESS:
541 : 531565 : case BUILT_IN_APPLY_ARGS:
542 : 531565 : case BUILT_IN_ASAN_BEFORE_DYNAMIC_INIT:
543 : 531565 : case BUILT_IN_ASAN_AFTER_DYNAMIC_INIT:
544 : 531565 : case BUILT_IN_DWARF_CFA:
545 : 531565 : case BUILT_IN_RETURN_ADDRESS:
546 : 531565 : *looping = false;
547 : 531565 : return true;
548 : 10103 : case BUILT_IN_PREFETCH:
549 : 10103 : *looping = true;
550 : 10103 : return true;
551 : : default:
552 : : break;
553 : : }
554 : : return false;
555 : : }
556 : :
557 : : /* Check the parameters of a function call to CALL_EXPR to see if
558 : : there are any references in the parameters that are not allowed for
559 : : pure or const functions. Also check to see if this is either an
560 : : indirect call, a call outside the compilation unit, or has special
561 : : attributes that may also effect the purity. The CALL_EXPR node for
562 : : the entire call expression. */
563 : :
564 : : static void
565 : 14438659 : check_call (funct_state local, gcall *call, bool ipa)
566 : : {
567 : 14438659 : int flags = gimple_call_flags (call);
568 : 14438659 : tree callee_t = gimple_call_fndecl (call);
569 : 14438659 : bool possibly_throws = stmt_could_throw_p (cfun, call);
570 : 14438659 : bool possibly_throws_externally = (possibly_throws
571 : 14438659 : && stmt_can_throw_external (cfun, call));
572 : :
573 : 5400058 : if (possibly_throws)
574 : : {
575 : : unsigned int i;
576 : 32381806 : for (i = 0; i < gimple_num_ops (call); i++)
577 : 26981748 : if (gimple_op (call, i)
578 : 26981748 : && tree_could_throw_p (gimple_op (call, i)))
579 : : {
580 : 80180 : if (possibly_throws && cfun->can_throw_non_call_exceptions)
581 : : {
582 : 80180 : if (dump_file)
583 : 0 : fprintf (dump_file, " operand can throw; looping\n");
584 : 80180 : local->looping = true;
585 : : }
586 : 80180 : if (possibly_throws_externally)
587 : : {
588 : 66824 : if (dump_file)
589 : 0 : fprintf (dump_file, " operand can throw externally\n");
590 : 66824 : local->can_throw = true;
591 : : }
592 : : }
593 : : }
594 : :
595 : : /* The const and pure flags are set by a variety of places in the
596 : : compiler (including here). If someone has already set the flags
597 : : for the callee, (such as for some of the builtins) we will use
598 : : them, otherwise we will compute our own information.
599 : :
600 : : Const and pure functions have less clobber effects than other
601 : : functions so we process these first. Otherwise if it is a call
602 : : outside the compilation unit or an indirect call we punt. This
603 : : leaves local calls which will be processed by following the call
604 : : graph. */
605 : 14438659 : if (callee_t)
606 : : {
607 : 13529954 : bool call_looping;
608 : :
609 : 13529954 : if (gimple_call_builtin_p (call, BUILT_IN_NORMAL)
610 : 13529954 : && !nonfreeing_call_p (call))
611 : 641928 : local->can_free = true;
612 : :
613 : 13529954 : if (builtin_safe_for_const_function_p (&call_looping, callee_t))
614 : : {
615 : 176432 : worse_state (&local->pure_const_state, &local->looping,
616 : : IPA_CONST, call_looping,
617 : : NULL, NULL);
618 : 176432 : return;
619 : : }
620 : : /* When bad things happen to bad functions, they cannot be const
621 : : or pure. */
622 : 13353522 : if (setjmp_call_p (callee_t))
623 : : {
624 : 2474 : if (dump_file)
625 : 0 : fprintf (dump_file, " setjmp is not const/pure\n");
626 : 2474 : local->looping = true;
627 : 2474 : local->pure_const_state = IPA_NEITHER;
628 : : }
629 : :
630 : 13353522 : if (DECL_BUILT_IN_CLASS (callee_t) == BUILT_IN_NORMAL)
631 : 3093583 : switch (DECL_FUNCTION_CODE (callee_t))
632 : : {
633 : 1856 : case BUILT_IN_LONGJMP:
634 : 1856 : case BUILT_IN_NONLOCAL_GOTO:
635 : 1856 : if (dump_file)
636 : 0 : fprintf (dump_file,
637 : : " longjmp and nonlocal goto is not const/pure\n");
638 : 1856 : local->pure_const_state = IPA_NEITHER;
639 : 1856 : local->looping = true;
640 : 1856 : break;
641 : : default:
642 : : break;
643 : : }
644 : : }
645 : 908705 : else if (gimple_call_internal_p (call) && !nonfreeing_call_p (call))
646 : 139129 : local->can_free = true;
647 : :
648 : : /* When not in IPA mode, we can still handle self recursion. */
649 : 14262227 : if (!ipa && callee_t
650 : 14262227 : && recursive_call_p (current_function_decl, callee_t))
651 : : {
652 : 19048 : if (dump_file)
653 : 0 : fprintf (dump_file, " Recursive call can loop.\n");
654 : 19048 : local->looping = true;
655 : : }
656 : : /* Either callee is unknown or we are doing local analysis.
657 : : Look to see if there are any bits available for the callee (such as by
658 : : declaration or because it is builtin) and process solely on the basis of
659 : : those bits. Handle internal calls always, those calls don't have
660 : : corresponding cgraph edges and thus aren't processed during
661 : : the propagation. */
662 : 14243179 : else if (!ipa || gimple_call_internal_p (call))
663 : : {
664 : 9314900 : enum pure_const_state_e call_state;
665 : 9314900 : bool call_looping;
666 : 9314900 : if (possibly_throws && cfun->can_throw_non_call_exceptions)
667 : : {
668 : 2147013 : if (dump_file)
669 : 0 : fprintf (dump_file, " can throw; looping\n");
670 : 2147013 : local->looping = true;
671 : : }
672 : 9314900 : if (possibly_throws_externally)
673 : : {
674 : 2509755 : if (dump_file)
675 : : {
676 : 0 : fprintf (dump_file, " can throw externally to lp %i\n",
677 : : lookup_stmt_eh_lp (call));
678 : 0 : if (callee_t)
679 : 0 : fprintf (dump_file, " callee:%s\n",
680 : 0 : IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (callee_t)));
681 : : }
682 : 2509755 : local->can_throw = true;
683 : : }
684 : 9314900 : if (dump_file && (dump_flags & TDF_DETAILS))
685 : 22 : fprintf (dump_file, " checking flags for call:");
686 : 9314900 : state_from_flags (&call_state, &call_looping, flags,
687 : 9314900 : ((flags & (ECF_NORETURN | ECF_NOTHROW))
688 : : == (ECF_NORETURN | ECF_NOTHROW))
689 : 9314900 : || (!flag_exceptions && (flags & ECF_NORETURN)));
690 : 9314900 : worse_state (&local->pure_const_state, &local->looping,
691 : : call_state, call_looping, NULL, NULL);
692 : : }
693 : : /* Direct functions calls are handled by IPA propagation. */
694 : : }
695 : :
696 : : /* Wrapper around check_decl for loads in local more. */
697 : :
698 : : static bool
699 : 11677775 : check_load (gimple *, tree op, tree, void *data)
700 : : {
701 : 11677775 : if (DECL_P (op))
702 : 5252322 : check_decl ((funct_state)data, op, false, false);
703 : : else
704 : 6425453 : check_op ((funct_state)data, op, false);
705 : 11677775 : return false;
706 : : }
707 : :
708 : : /* Wrapper around check_decl for stores in local more. */
709 : :
710 : : static bool
711 : 12776746 : check_store (gimple *, tree op, tree, void *data)
712 : : {
713 : 12776746 : if (DECL_P (op))
714 : 7781422 : check_decl ((funct_state)data, op, true, false);
715 : : else
716 : 4995324 : check_op ((funct_state)data, op, true);
717 : 12776746 : return false;
718 : : }
719 : :
720 : : /* Wrapper around check_decl for loads in ipa mode. */
721 : :
722 : : static bool
723 : 5855085 : check_ipa_load (gimple *, tree op, tree, void *data)
724 : : {
725 : 5855085 : if (DECL_P (op))
726 : 2990370 : check_decl ((funct_state)data, op, false, true);
727 : : else
728 : 2864715 : check_op ((funct_state)data, op, false);
729 : 5855085 : return false;
730 : : }
731 : :
732 : : /* Wrapper around check_decl for stores in ipa mode. */
733 : :
734 : : static bool
735 : 6042695 : check_ipa_store (gimple *, tree op, tree, void *data)
736 : : {
737 : 6042695 : if (DECL_P (op))
738 : 4154434 : check_decl ((funct_state)data, op, true, true);
739 : : else
740 : 1888261 : check_op ((funct_state)data, op, true);
741 : 6042695 : return false;
742 : : }
743 : :
744 : : /* Look into pointer pointed to by GSIP and figure out what interesting side
745 : : effects it has. */
746 : : static void
747 : 162467504 : check_stmt (gimple_stmt_iterator *gsip, funct_state local, bool ipa)
748 : : {
749 : 162467504 : gimple *stmt = gsi_stmt (*gsip);
750 : :
751 : 162467504 : if (is_gimple_debug (stmt))
752 : : return;
753 : :
754 : : /* Do consider clobber as side effects before IPA, so we rather inline
755 : : C++ destructors and keep clobber semantics than eliminate them.
756 : :
757 : : Similar logic is in ipa-modref.
758 : :
759 : : TODO: We may get smarter during early optimizations on these and let
760 : : functions containing only clobbers to be optimized more. This is a common
761 : : case of C++ destructors. */
762 : :
763 : 86383600 : if ((ipa || cfun->after_inlining) && gimple_clobber_p (stmt))
764 : : return;
765 : :
766 : 84113882 : if (dump_file)
767 : : {
768 : 1711 : fprintf (dump_file, " scanning: ");
769 : 1711 : print_gimple_stmt (dump_file, stmt, 0);
770 : : }
771 : :
772 : 84113882 : if (gimple_has_volatile_ops (stmt)
773 : 71836130 : && !gimple_clobber_p (stmt))
774 : : {
775 : 1483006 : local->pure_const_state = IPA_NEITHER;
776 : 1483006 : if (dump_file)
777 : 33 : fprintf (dump_file, " Volatile stmt is not const/pure\n");
778 : : }
779 : :
780 : : /* Look for loads and stores. */
781 : 140921877 : walk_stmt_load_store_ops (stmt, local,
782 : : ipa ? check_ipa_load : check_load,
783 : : ipa ? check_ipa_store : check_store);
784 : :
785 : 84113882 : if (gimple_code (stmt) != GIMPLE_CALL
786 : 84113882 : && stmt_could_throw_p (cfun, stmt))
787 : : {
788 : 2519184 : if (cfun->can_throw_non_call_exceptions)
789 : : {
790 : 2213224 : if (dump_file)
791 : 0 : fprintf (dump_file, " can throw; looping\n");
792 : 2213224 : local->looping = true;
793 : : }
794 : 2519184 : if (stmt_can_throw_external (cfun, stmt))
795 : : {
796 : 2083001 : if (dump_file)
797 : 6 : fprintf (dump_file, " can throw externally\n");
798 : 2083001 : local->can_throw = true;
799 : : }
800 : : else
801 : 436183 : if (dump_file)
802 : 0 : fprintf (dump_file, " can throw\n");
803 : : }
804 : 84113882 : switch (gimple_code (stmt))
805 : : {
806 : 14438659 : case GIMPLE_CALL:
807 : 14438659 : check_call (local, as_a <gcall *> (stmt), ipa);
808 : 14438659 : break;
809 : 1657989 : case GIMPLE_LABEL:
810 : 1657989 : if (DECL_NONLOCAL (gimple_label_label (as_a <glabel *> (stmt))))
811 : : /* Target of long jump. */
812 : : {
813 : 812 : if (dump_file)
814 : 0 : fprintf (dump_file, " nonlocal label is not const/pure\n");
815 : 812 : local->pure_const_state = IPA_NEITHER;
816 : : }
817 : : break;
818 : 258740 : case GIMPLE_ASM:
819 : 258740 : if (gimple_asm_clobbers_memory_p (as_a <gasm *> (stmt)))
820 : : {
821 : 118181 : if (dump_file)
822 : 3 : fprintf (dump_file, " memory asm clobber is not const/pure\n");
823 : : /* Abandon all hope, ye who enter here. */
824 : 118181 : local->pure_const_state = IPA_NEITHER;
825 : 118181 : local->can_free = true;
826 : : }
827 : 258740 : if (gimple_asm_volatile_p (as_a <gasm *> (stmt)))
828 : : {
829 : 236480 : if (dump_file)
830 : 3 : fprintf (dump_file, " volatile is not const/pure\n");
831 : : /* Abandon all hope, ye who enter here. */
832 : 236480 : local->pure_const_state = IPA_NEITHER;
833 : 236480 : local->looping = true;
834 : 236480 : local->can_free = true;
835 : : }
836 : : return;
837 : : default:
838 : : break;
839 : : }
840 : : }
841 : :
842 : : /* Check that RETVAL is used only in STMT and in comparisons against 0.
843 : : RETVAL is return value of the function and STMT is return stmt. */
844 : :
845 : : static bool
846 : 413988 : check_retval_uses (tree retval, gimple *stmt)
847 : : {
848 : 413988 : imm_use_iterator use_iter;
849 : 413988 : gimple *use_stmt;
850 : :
851 : 890004 : FOR_EACH_IMM_USE_STMT (use_stmt, use_iter, retval)
852 : 594034 : if (gcond *cond = dyn_cast<gcond *> (use_stmt))
853 : : {
854 : 12909 : tree op2 = gimple_cond_rhs (cond);
855 : 12909 : if (!integer_zerop (op2))
856 : : return false;
857 : : }
858 : 581125 : else if (gassign *ga = dyn_cast<gassign *> (use_stmt))
859 : : {
860 : 78329 : enum tree_code code = gimple_assign_rhs_code (ga);
861 : 78329 : if (TREE_CODE_CLASS (code) != tcc_comparison)
862 : : return false;
863 : 2662 : if (!integer_zerop (gimple_assign_rhs2 (ga)))
864 : : return false;
865 : : }
866 : 502796 : else if (is_gimple_debug (use_stmt))
867 : : ;
868 : 408389 : else if (use_stmt != stmt)
869 : 413988 : return false;
870 : :
871 : 295970 : return true;
872 : : }
873 : :
874 : : /* malloc_candidate_p() checks if FUN can possibly be annotated with malloc
875 : : attribute. Currently this function does a very conservative analysis.
876 : : FUN is considered to be a candidate if
877 : : 1) It returns a value of pointer type.
878 : : 2) SSA_NAME_DEF_STMT (return_value) is either a function call or
879 : : a phi, and element of phi is either NULL or
880 : : SSA_NAME_DEF_STMT(element) is function call.
881 : : 3) The return-value has immediate uses only within comparisons (gcond or gassign)
882 : : and return_stmt (and likewise a phi arg has immediate use only within comparison
883 : : or the phi stmt). */
884 : :
885 : : #define DUMP_AND_RETURN(reason) \
886 : : { \
887 : : if (dump_file && (dump_flags & TDF_DETAILS)) \
888 : : fprintf (dump_file, "\n%s is not a malloc candidate, reason: %s\n", \
889 : : (node->dump_name ()), (reason)); \
890 : : return false; \
891 : : }
892 : :
893 : : static bool
894 : 354887 : malloc_candidate_p_1 (function *fun, tree retval, gimple *ret_stmt, bool ipa,
895 : : bitmap visited)
896 : : {
897 : 354887 : cgraph_node *node = cgraph_node::get_create (fun->decl);
898 : 354887 : if (!bitmap_set_bit (visited, SSA_NAME_VERSION (retval)))
899 : : return true;
900 : :
901 : 354887 : if (!check_retval_uses (retval, ret_stmt))
902 : 92087 : DUMP_AND_RETURN("Return value has uses outside return stmt"
903 : : " and comparisons against 0.")
904 : :
905 : 262800 : gimple *def = SSA_NAME_DEF_STMT (retval);
906 : :
907 : 262800 : if (gcall *call_stmt = dyn_cast<gcall *> (def))
908 : : {
909 : 61773 : tree callee_decl = gimple_call_fndecl (call_stmt);
910 : 61773 : if (!callee_decl)
911 : : return false;
912 : :
913 : 111696 : if (!ipa && !DECL_IS_MALLOC (callee_decl))
914 : 33431 : DUMP_AND_RETURN("callee_decl does not have malloc attribute for"
915 : : " non-ipa mode.")
916 : :
917 : 26962 : cgraph_edge *cs = node->get_edge (call_stmt);
918 : 26962 : if (cs)
919 : : {
920 : 9090 : ipa_call_summary *es = ipa_call_summaries->get_create (cs);
921 : 9090 : es->is_return_callee_uncaptured = true;
922 : : }
923 : : }
924 : :
925 : 201027 : else if (gphi *phi = dyn_cast<gphi *> (def))
926 : : {
927 : : bool all_args_zero = true;
928 : 82363 : for (unsigned i = 0; i < gimple_phi_num_args (phi); ++i)
929 : : {
930 : 78110 : tree arg = gimple_phi_arg_def (phi, i);
931 : 78110 : if (integer_zerop (arg))
932 : 16431 : continue;
933 : :
934 : 61679 : all_args_zero = false;
935 : 61679 : if (TREE_CODE (arg) != SSA_NAME)
936 : 2578 : DUMP_AND_RETURN ("phi arg is not SSA_NAME.");
937 : 59101 : if (!check_retval_uses (arg, phi))
938 : 25931 : DUMP_AND_RETURN ("phi arg has uses outside phi"
939 : : " and comparisons against 0.")
940 : :
941 : 33170 : gimple *arg_def = SSA_NAME_DEF_STMT (arg);
942 : 33170 : if (is_a<gphi *> (arg_def))
943 : : {
944 : 3394 : if (!malloc_candidate_p_1 (fun, arg, phi, ipa, visited))
945 : 3310 : DUMP_AND_RETURN ("nested phi fail")
946 : 84 : continue;
947 : : }
948 : :
949 : 29776 : gcall *call_stmt = dyn_cast<gcall *> (arg_def);
950 : 29776 : if (!call_stmt)
951 : 15196 : DUMP_AND_RETURN ("phi arg is a not a call_stmt.")
952 : :
953 : 14580 : tree callee_decl = gimple_call_fndecl (call_stmt);
954 : 14580 : if (!callee_decl)
955 : : return false;
956 : 18637 : if (!ipa && !DECL_IS_MALLOC (callee_decl))
957 : 4013 : DUMP_AND_RETURN("callee_decl does not have malloc attribute"
958 : : " for non-ipa mode.")
959 : :
960 : 7706 : cgraph_edge *cs = node->get_edge (call_stmt);
961 : 7706 : if (cs)
962 : : {
963 : 4951 : ipa_call_summary *es = ipa_call_summaries->get_create (cs);
964 : 4951 : es->is_return_callee_uncaptured = true;
965 : : }
966 : : }
967 : :
968 : 4253 : if (all_args_zero)
969 : 4 : DUMP_AND_RETURN ("Return value is a phi with all args equal to 0.")
970 : : }
971 : :
972 : : else
973 : 142885 : DUMP_AND_RETURN("def_stmt of return value is not a call or phi-stmt.")
974 : :
975 : : return true;
976 : : }
977 : :
978 : : static bool
979 : 5608381 : malloc_candidate_p (function *fun, bool ipa)
980 : : {
981 : 5608381 : basic_block exit_block = EXIT_BLOCK_PTR_FOR_FN (fun);
982 : 5608381 : edge e;
983 : 5608381 : edge_iterator ei;
984 : 5608381 : cgraph_node *node = cgraph_node::get_create (fun->decl);
985 : :
986 : 5608381 : if (EDGE_COUNT (exit_block->preds) == 0
987 : 5606099 : || !flag_delete_null_pointer_checks)
988 : : return false;
989 : :
990 : 5478622 : auto_bitmap visited;
991 : 5509749 : FOR_EACH_EDGE (e, ei, exit_block->preds)
992 : : {
993 : 5478622 : gimple_stmt_iterator gsi = gsi_last_bb (e->src);
994 : 10924866 : greturn *ret_stmt = dyn_cast<greturn *> (gsi_stmt (gsi));
995 : :
996 : 5477371 : if (!ret_stmt)
997 : 5478622 : return false;
998 : :
999 : 5477371 : tree retval = gimple_return_retval (ret_stmt);
1000 : 5477371 : if (!retval)
1001 : 2476405 : DUMP_AND_RETURN("No return value.")
1002 : :
1003 : 3000966 : if (TREE_CODE (retval) != SSA_NAME
1004 : 3000966 : || TREE_CODE (TREE_TYPE (retval)) != POINTER_TYPE)
1005 : 2649473 : DUMP_AND_RETURN("Return value is not SSA_NAME or not a pointer type.")
1006 : :
1007 : 351493 : if (!malloc_candidate_p_1 (fun, retval, ret_stmt, ipa, visited))
1008 : : return false;
1009 : : }
1010 : :
1011 : 31127 : if (dump_file && (dump_flags & TDF_DETAILS))
1012 : 8 : fprintf (dump_file, "\nFound %s to be candidate for malloc attribute\n",
1013 : 4 : IDENTIFIER_POINTER (DECL_NAME (fun->decl)));
1014 : : return true;
1015 : 5478622 : }
1016 : :
1017 : : #undef DUMP_AND_RETURN
1018 : :
1019 : : /* Return true if function is known to be finite. */
1020 : :
1021 : : bool
1022 : 3966455 : finite_function_p ()
1023 : : {
1024 : : /* Const functions cannot have back edges (an
1025 : : indication of possible infinite loop side
1026 : : effect. */
1027 : 3966455 : bool finite = true;
1028 : 3966455 : if (mark_dfs_back_edges ())
1029 : : {
1030 : : /* Preheaders are needed for SCEV to work.
1031 : : Simple latches and recorded exits improve chances that loop will
1032 : : proved to be finite in testcases such as in loop-15.c
1033 : : and loop-24.c */
1034 : 380186 : loop_optimizer_init (LOOPS_HAVE_PREHEADERS
1035 : : | LOOPS_HAVE_SIMPLE_LATCHES
1036 : : | LOOPS_HAVE_RECORDED_EXITS);
1037 : 380186 : if (dump_file && (dump_flags & TDF_DETAILS))
1038 : 0 : flow_loops_dump (dump_file, NULL, 0);
1039 : 380186 : if (mark_irreducible_loops ())
1040 : : {
1041 : 1872 : if (dump_file)
1042 : 0 : fprintf (dump_file, " has irreducible loops\n");
1043 : : finite = false;
1044 : : }
1045 : : else
1046 : : {
1047 : 378314 : scev_initialize ();
1048 : 1884656 : for (auto loop : loops_list (cfun, 0))
1049 : 821792 : if (!finite_loop_p (loop))
1050 : : {
1051 : 72078 : if (dump_file)
1052 : 1 : fprintf (dump_file, " cannot prove finiteness of "
1053 : : "loop %i\n", loop->num);
1054 : : finite =false;
1055 : : break;
1056 : 378314 : }
1057 : 378314 : scev_finalize ();
1058 : : }
1059 : 380186 : loop_optimizer_finalize ();
1060 : : }
1061 : 3966455 : return finite;
1062 : : }
1063 : :
1064 : : /* This is the main routine for finding the reference patterns for
1065 : : global variables within a function FN. */
1066 : :
1067 : : static funct_state
1068 : 4414290 : analyze_function (struct cgraph_node *fn, bool ipa)
1069 : : {
1070 : 4414290 : tree decl = fn->decl;
1071 : 4414290 : funct_state l;
1072 : 4414290 : basic_block this_block;
1073 : :
1074 : 4414290 : l = XCNEW (class funct_state_d);
1075 : 4414290 : l->pure_const_state = IPA_CONST;
1076 : 4414290 : l->state_previously_known = IPA_NEITHER;
1077 : 4414290 : l->looping_previously_known = true;
1078 : 4414290 : l->looping = false;
1079 : 4414290 : l->can_throw = false;
1080 : 4414290 : l->can_free = false;
1081 : 4414290 : state_from_flags (&l->state_previously_known, &l->looping_previously_known,
1082 : 4414290 : flags_from_decl_or_type (fn->decl),
1083 : 4414290 : fn->cannot_return_p ());
1084 : :
1085 : 4414290 : if (fn->thunk || fn->alias)
1086 : : {
1087 : : /* Thunk gets propagated through, so nothing interesting happens. */
1088 : 62303 : gcc_assert (ipa);
1089 : 62303 : if (fn->thunk && thunk_info::get (fn)->virtual_offset_p)
1090 : 739 : l->pure_const_state = IPA_NEITHER;
1091 : 62303 : return l;
1092 : : }
1093 : :
1094 : 4351987 : if (dump_file)
1095 : : {
1096 : 189 : fprintf (dump_file, "\n\n local analysis of %s\n ",
1097 : : fn->dump_name ());
1098 : : }
1099 : :
1100 : 4351987 : push_cfun (DECL_STRUCT_FUNCTION (decl));
1101 : :
1102 : 33390894 : FOR_EACH_BB_FN (this_block, cfun)
1103 : : {
1104 : 29103418 : gimple_stmt_iterator gsi;
1105 : 29103418 : struct walk_stmt_info wi;
1106 : :
1107 : 29103418 : memset (&wi, 0, sizeof (wi));
1108 : 58206836 : for (gsi = gsi_start_bb (this_block);
1109 : 191506411 : !gsi_end_p (gsi);
1110 : 162402993 : gsi_next (&gsi))
1111 : : {
1112 : : /* NULL memory accesses terminates BB. These accesses are known
1113 : : to trip undefined behaviour. gimple-ssa-isolate-paths turns them
1114 : : to volatile accesses and adds builtin_trap call which would
1115 : : confuse us otherwise. */
1116 : 162469645 : if (infer_nonnull_range_by_dereference (gsi_stmt (gsi),
1117 : : null_pointer_node))
1118 : : {
1119 : 2141 : if (dump_file)
1120 : 0 : fprintf (dump_file, " NULL memory access; terminating BB%s\n",
1121 : 0 : flag_non_call_exceptions ? "; looping" : "");
1122 : 2141 : if (flag_non_call_exceptions)
1123 : : {
1124 : 401 : l->looping = true;
1125 : 401 : if (stmt_can_throw_external (cfun, gsi_stmt (gsi)))
1126 : : {
1127 : 305 : if (dump_file)
1128 : 0 : fprintf (dump_file, " can throw externally\n");
1129 : 305 : l->can_throw = true;
1130 : : }
1131 : : }
1132 : : break;
1133 : : }
1134 : 162467504 : check_stmt (&gsi, l, ipa);
1135 : 162467504 : if (l->pure_const_state == IPA_NEITHER
1136 : 105822411 : && l->looping
1137 : 85868839 : && l->can_throw
1138 : 42330303 : && l->can_free)
1139 : 64511 : goto end;
1140 : : }
1141 : : }
1142 : :
1143 : 4287476 : end:
1144 : 4351987 : if (l->pure_const_state != IPA_NEITHER
1145 : 1910914 : && !l->looping
1146 : 6083854 : && !finite_function_p ())
1147 : 23243 : l->looping = true;
1148 : :
1149 : 4351987 : if (dump_file && (dump_flags & TDF_DETAILS))
1150 : 22 : fprintf (dump_file, " checking previously known:");
1151 : :
1152 : 4351987 : better_state (&l->pure_const_state, &l->looping,
1153 : : l->state_previously_known,
1154 : 4351987 : l->looping_previously_known);
1155 : 4351987 : if (TREE_NOTHROW (decl))
1156 : 2957409 : l->can_throw = false;
1157 : :
1158 : 4351987 : l->malloc_state = STATE_MALLOC_BOTTOM;
1159 : 4351987 : if (DECL_IS_MALLOC (decl))
1160 : 6113 : l->malloc_state = STATE_MALLOC;
1161 : 4345874 : else if (ipa && malloc_candidate_p (DECL_STRUCT_FUNCTION (decl), true))
1162 : 10849 : l->malloc_state = STATE_MALLOC_TOP;
1163 : 4335025 : else if (malloc_candidate_p (DECL_STRUCT_FUNCTION (decl), false))
1164 : 20278 : l->malloc_state = STATE_MALLOC;
1165 : :
1166 : 4351987 : pop_cfun ();
1167 : 4351987 : if (dump_file)
1168 : : {
1169 : 189 : if (l->looping)
1170 : 50 : fprintf (dump_file, "Function is locally looping.\n");
1171 : 189 : if (l->can_throw)
1172 : 6 : fprintf (dump_file, "Function is locally throwing.\n");
1173 : 189 : if (l->pure_const_state == IPA_CONST)
1174 : 102 : fprintf (dump_file, "Function is locally const.\n");
1175 : 189 : if (l->pure_const_state == IPA_PURE)
1176 : 7 : fprintf (dump_file, "Function is locally pure.\n");
1177 : 189 : if (l->can_free)
1178 : 3 : fprintf (dump_file, "Function can locally free.\n");
1179 : 189 : if (l->malloc_state == STATE_MALLOC)
1180 : 8 : fprintf (dump_file, "Function is locally malloc.\n");
1181 : : }
1182 : : return l;
1183 : : }
1184 : :
1185 : : void
1186 : 18253 : funct_state_summary_t::insert (cgraph_node *node, funct_state_d *state)
1187 : : {
1188 : : /* There are some shared nodes, in particular the initializers on
1189 : : static declarations. We do not need to scan them more than once
1190 : : since all we would be interested in are the addressof
1191 : : operations. */
1192 : 18253 : if (opt_for_fn (node->decl, flag_ipa_pure_const))
1193 : : {
1194 : 18252 : funct_state_d *a = analyze_function (node, true);
1195 : 18252 : new (state) funct_state_d (*a);
1196 : 18252 : free (a);
1197 : : }
1198 : : else
1199 : : /* Do not keep stale summaries. */
1200 : 1 : funct_state_summaries->remove (node);
1201 : 18253 : }
1202 : :
1203 : : /* Called when new clone is inserted to callgraph late. */
1204 : :
1205 : : void
1206 : 1002818 : funct_state_summary_t::duplicate (cgraph_node *, cgraph_node *dst,
1207 : : funct_state_d *src_data,
1208 : : funct_state_d *dst_data)
1209 : : {
1210 : 1002818 : new (dst_data) funct_state_d (*src_data);
1211 : 1002818 : if (dst_data->malloc_state == STATE_MALLOC
1212 : 1002818 : && VOID_TYPE_P (TREE_TYPE (TREE_TYPE (dst->decl))))
1213 : 11 : dst_data->malloc_state = STATE_MALLOC_BOTTOM;
1214 : 1002818 : }
1215 : :
1216 : :
1217 : : void
1218 : 153686 : pass_ipa_pure_const::
1219 : : register_hooks (void)
1220 : : {
1221 : 153686 : if (init_p)
1222 : : return;
1223 : :
1224 : 153686 : init_p = true;
1225 : :
1226 : 153686 : funct_state_summaries = new funct_state_summary_t (symtab);
1227 : : }
1228 : :
1229 : :
1230 : : /* Analyze each function in the cgraph to see if it is locally PURE or
1231 : : CONST. */
1232 : :
1233 : : static void
1234 : 141914 : pure_const_generate_summary (void)
1235 : : {
1236 : 141914 : struct cgraph_node *node;
1237 : :
1238 : 141914 : pass_ipa_pure_const *pass = static_cast <pass_ipa_pure_const *> (current_pass);
1239 : 141914 : pass->register_hooks ();
1240 : :
1241 : : /* Process all of the functions.
1242 : :
1243 : : We process AVAIL_INTERPOSABLE functions. We cannot use the results
1244 : : by default, but the info can be used at LTO with -fwhole-program or
1245 : : when function got cloned and the clone is AVAILABLE. */
1246 : :
1247 : 1464948 : FOR_EACH_DEFINED_FUNCTION (node)
1248 : 1323034 : if (opt_for_fn (node->decl, flag_ipa_pure_const))
1249 : : {
1250 : 1322867 : funct_state_d *a = analyze_function (node, true);
1251 : 1322867 : new (funct_state_summaries->get_create (node)) funct_state_d (*a);
1252 : 1322867 : free (a);
1253 : : }
1254 : 141914 : }
1255 : :
1256 : :
1257 : : /* Serialize the ipa info for lto. */
1258 : :
1259 : : static void
1260 : 18801 : pure_const_write_summary (void)
1261 : : {
1262 : 18801 : struct cgraph_node *node;
1263 : 18801 : struct lto_simple_output_block *ob
1264 : 18801 : = lto_create_simple_output_block (LTO_section_ipa_pure_const);
1265 : 18801 : unsigned int count = 0;
1266 : 18801 : lto_symtab_encoder_iterator lsei;
1267 : 18801 : lto_symtab_encoder_t encoder;
1268 : :
1269 : 18801 : encoder = lto_get_out_decl_state ()->symtab_node_encoder;
1270 : :
1271 : 216842 : for (lsei = lsei_start_function_in_partition (encoder); !lsei_end_p (lsei);
1272 : 89717 : lsei_next_function_in_partition (&lsei))
1273 : : {
1274 : 89717 : node = lsei_cgraph_node (lsei);
1275 : 89717 : if (node->definition && funct_state_summaries->exists (node))
1276 : 89564 : count++;
1277 : : }
1278 : :
1279 : 18801 : streamer_write_uhwi_stream (ob->main_stream, count);
1280 : :
1281 : : /* Process all of the functions. */
1282 : 216842 : for (lsei = lsei_start_function_in_partition (encoder); !lsei_end_p (lsei);
1283 : 89717 : lsei_next_function_in_partition (&lsei))
1284 : : {
1285 : 89717 : node = lsei_cgraph_node (lsei);
1286 : 89717 : funct_state_d *fs = funct_state_summaries->get (node);
1287 : 89717 : if (node->definition && fs != NULL)
1288 : : {
1289 : 89564 : struct bitpack_d bp;
1290 : 89564 : int node_ref;
1291 : 89564 : lto_symtab_encoder_t encoder;
1292 : :
1293 : 89564 : encoder = ob->decl_state->symtab_node_encoder;
1294 : 89564 : node_ref = lto_symtab_encoder_encode (encoder, node);
1295 : 89564 : streamer_write_uhwi_stream (ob->main_stream, node_ref);
1296 : :
1297 : : /* Note that flags will need to be read in the opposite
1298 : : order as we are pushing the bitflags into FLAGS. */
1299 : 89564 : bp = bitpack_create (ob->main_stream);
1300 : 89564 : bp_pack_value (&bp, fs->pure_const_state, 2);
1301 : 89564 : bp_pack_value (&bp, fs->state_previously_known, 2);
1302 : 89564 : bp_pack_value (&bp, fs->looping_previously_known, 1);
1303 : 89564 : bp_pack_value (&bp, fs->looping, 1);
1304 : 89564 : bp_pack_value (&bp, fs->can_throw, 1);
1305 : 89564 : bp_pack_value (&bp, fs->can_free, 1);
1306 : 89564 : bp_pack_value (&bp, fs->malloc_state, 2);
1307 : 89564 : streamer_write_bitpack (&bp);
1308 : : }
1309 : : }
1310 : :
1311 : 18801 : lto_destroy_simple_output_block (ob);
1312 : 18801 : }
1313 : :
1314 : :
1315 : : /* Deserialize the ipa info for lto. */
1316 : :
1317 : : static void
1318 : 11772 : pure_const_read_summary (void)
1319 : : {
1320 : 11772 : struct lto_file_decl_data **file_data_vec = lto_get_file_decl_data ();
1321 : 11772 : struct lto_file_decl_data *file_data;
1322 : 11772 : unsigned int j = 0;
1323 : :
1324 : 11772 : pass_ipa_pure_const *pass = static_cast <pass_ipa_pure_const *> (current_pass);
1325 : 11772 : pass->register_hooks ();
1326 : :
1327 : 36326 : while ((file_data = file_data_vec[j++]))
1328 : : {
1329 : 12782 : const char *data;
1330 : 12782 : size_t len;
1331 : 12782 : class lto_input_block *ib
1332 : 12782 : = lto_create_simple_input_block (file_data,
1333 : : LTO_section_ipa_pure_const,
1334 : : &data, &len);
1335 : 12782 : if (ib)
1336 : : {
1337 : 10220 : unsigned int i;
1338 : 10220 : unsigned int count = streamer_read_uhwi (ib);
1339 : :
1340 : 84919 : for (i = 0; i < count; i++)
1341 : : {
1342 : 74699 : unsigned int index;
1343 : 74699 : struct cgraph_node *node;
1344 : 74699 : struct bitpack_d bp;
1345 : 74699 : funct_state fs;
1346 : 74699 : lto_symtab_encoder_t encoder;
1347 : :
1348 : 74699 : index = streamer_read_uhwi (ib);
1349 : 74699 : encoder = file_data->symtab_node_encoder;
1350 : 74699 : node = dyn_cast<cgraph_node *> (lto_symtab_encoder_deref (encoder,
1351 : : index));
1352 : :
1353 : 74699 : fs = funct_state_summaries->get_create (node);
1354 : : /* Note that the flags must be read in the opposite
1355 : : order in which they were written (the bitflags were
1356 : : pushed into FLAGS). */
1357 : 74699 : bp = streamer_read_bitpack (ib);
1358 : 74699 : fs->pure_const_state
1359 : 74699 : = (enum pure_const_state_e) bp_unpack_value (&bp, 2);
1360 : 74699 : fs->state_previously_known
1361 : 74699 : = (enum pure_const_state_e) bp_unpack_value (&bp, 2);
1362 : 74699 : fs->looping_previously_known = bp_unpack_value (&bp, 1);
1363 : 74699 : fs->looping = bp_unpack_value (&bp, 1);
1364 : 74699 : fs->can_throw = bp_unpack_value (&bp, 1);
1365 : 74699 : fs->can_free = bp_unpack_value (&bp, 1);
1366 : 74699 : fs->malloc_state
1367 : 74699 : = (enum malloc_state_e) bp_unpack_value (&bp, 2);
1368 : :
1369 : 74699 : if (dump_file)
1370 : : {
1371 : 0 : int flags = flags_from_decl_or_type (node->decl);
1372 : 0 : fprintf (dump_file, "Read info for %s ", node->dump_name ());
1373 : 0 : if (flags & ECF_CONST)
1374 : 0 : fprintf (dump_file, " const");
1375 : 0 : if (flags & ECF_PURE)
1376 : 0 : fprintf (dump_file, " pure");
1377 : 0 : if (flags & ECF_NOTHROW)
1378 : 0 : fprintf (dump_file, " nothrow");
1379 : 0 : fprintf (dump_file, "\n pure const state: %s\n",
1380 : 0 : pure_const_names[fs->pure_const_state]);
1381 : 0 : fprintf (dump_file, " previously known state: %s\n",
1382 : 0 : pure_const_names[fs->state_previously_known]);
1383 : 0 : if (fs->looping)
1384 : 0 : fprintf (dump_file," function is locally looping\n");
1385 : 0 : if (fs->looping_previously_known)
1386 : 0 : fprintf (dump_file," function is previously known looping\n");
1387 : 0 : if (fs->can_throw)
1388 : 0 : fprintf (dump_file," function is locally throwing\n");
1389 : 0 : if (fs->can_free)
1390 : 0 : fprintf (dump_file," function can locally free\n");
1391 : 0 : fprintf (dump_file, "\n malloc state: %s\n",
1392 : 0 : malloc_state_names[fs->malloc_state]);
1393 : : }
1394 : : }
1395 : :
1396 : 10220 : lto_destroy_simple_input_block (file_data,
1397 : : LTO_section_ipa_pure_const,
1398 : : ib, data, len);
1399 : : }
1400 : : }
1401 : 11772 : }
1402 : :
1403 : : /* We only propagate across edges that can throw externally and their callee
1404 : : is not interposable. */
1405 : :
1406 : : static bool
1407 : 6516173 : ignore_edge_for_nothrow (struct cgraph_edge *e)
1408 : : {
1409 : 6516173 : if (!e->can_throw_external || TREE_NOTHROW (e->callee->decl))
1410 : : return true;
1411 : :
1412 : 1925935 : enum availability avail;
1413 : 1925935 : cgraph_node *ultimate_target
1414 : 1925935 : = e->callee->function_or_virtual_thunk_symbol (&avail, e->caller);
1415 : 1925935 : if (avail <= AVAIL_INTERPOSABLE || TREE_NOTHROW (ultimate_target->decl))
1416 : : return true;
1417 : 630313 : return ((opt_for_fn (e->callee->decl, flag_non_call_exceptions)
1418 : 201703 : && !e->callee->binds_to_current_def_p (e->caller))
1419 : 630265 : || !opt_for_fn (e->caller->decl, flag_ipa_pure_const)
1420 : 1259554 : || !opt_for_fn (ultimate_target->decl, flag_ipa_pure_const));
1421 : : }
1422 : :
1423 : : /* Return true if NODE is self recursive function.
1424 : : Indirectly recursive functions appears as non-trivial strongly
1425 : : connected components, so we need to care about self recursion
1426 : : only. */
1427 : :
1428 : : static bool
1429 : 1851984 : self_recursive_p (struct cgraph_node *node)
1430 : : {
1431 : 1851984 : struct cgraph_edge *e;
1432 : 7118841 : for (e = node->callees; e; e = e->next_callee)
1433 : 5270194 : if (e->callee->function_symbol () == node)
1434 : : return true;
1435 : : return false;
1436 : : }
1437 : :
1438 : : /* Return true if N is cdtor that is not const or pure. In this case we may
1439 : : need to remove unreachable function if it is marked const/pure. */
1440 : :
1441 : : static bool
1442 : 48662 : cdtor_p (cgraph_node *n, void *)
1443 : : {
1444 : 48662 : if (DECL_STATIC_CONSTRUCTOR (n->decl) || DECL_STATIC_DESTRUCTOR (n->decl))
1445 : 3 : return ((!TREE_READONLY (n->decl) && !DECL_PURE_P (n->decl))
1446 : 3 : || DECL_LOOPING_CONST_OR_PURE_P (n->decl));
1447 : : return false;
1448 : : }
1449 : :
1450 : : /* Skip edges from and to nodes without ipa_pure_const enabled.
1451 : : Ignore not available symbols. */
1452 : :
1453 : : static bool
1454 : 6516173 : ignore_edge_for_pure_const (struct cgraph_edge *e)
1455 : : {
1456 : 6516173 : enum availability avail;
1457 : 6516173 : cgraph_node *ultimate_target
1458 : 6516173 : = e->callee->function_or_virtual_thunk_symbol (&avail, e->caller);
1459 : :
1460 : 6516173 : return (avail <= AVAIL_INTERPOSABLE
1461 : 2256653 : || !opt_for_fn (e->caller->decl, flag_ipa_pure_const)
1462 : 8764074 : || !opt_for_fn (ultimate_target->decl,
1463 : 6516173 : flag_ipa_pure_const));
1464 : : }
1465 : :
1466 : : /* Return true if function should be skipped for local pure const analysis. */
1467 : :
1468 : : static bool
1469 : 4376386 : skip_function_for_local_pure_const (struct cgraph_node *node)
1470 : : {
1471 : : /* Because we do not schedule pass_fixup_cfg over whole program after early
1472 : : optimizations we must not promote functions that are called by already
1473 : : processed functions. */
1474 : :
1475 : 4376386 : if (function_called_by_processed_nodes_p ())
1476 : : {
1477 : 4772 : if (dump_file)
1478 : 1 : fprintf (dump_file, "Function called in recursive cycle; ignoring\n");
1479 : 4772 : return true;
1480 : : }
1481 : : /* Save some work and do not analyze functions which are interposable and
1482 : : do not have any non-interposable aliases. */
1483 : 4371614 : if (node->get_availability () <= AVAIL_INTERPOSABLE
1484 : 200195 : && !flag_lto
1485 : 4565467 : && !node->has_aliases_p ())
1486 : : {
1487 : 184138 : if (dump_file)
1488 : 0 : fprintf (dump_file,
1489 : : "Function is interposable; not analyzing.\n");
1490 : 184138 : return true;
1491 : : }
1492 : : return false;
1493 : : }
1494 : :
1495 : : /* Make function const and output warning. If LOCAL is true,
1496 : : return true if anything changed. Otherwise return true if
1497 : : we may have introduced removale ctors. */
1498 : :
1499 : : bool
1500 : 1494116 : ipa_make_function_const (struct cgraph_node *node, bool looping, bool local)
1501 : : {
1502 : 1494116 : bool cdtor = false;
1503 : :
1504 : 1494116 : if (TREE_READONLY (node->decl)
1505 : 1494116 : && (looping || !DECL_LOOPING_CONST_OR_PURE_P (node->decl)))
1506 : : return false;
1507 : 880752 : warn_function_const (node->decl, !looping);
1508 : 880752 : if (local && skip_function_for_local_pure_const (node))
1509 : : return false;
1510 : 862174 : if (dump_file)
1511 : 58 : fprintf (dump_file, "Function found to be %sconst: %s\n",
1512 : : looping ? "looping " : "",
1513 : : node->dump_name ());
1514 : 862174 : if (!local && !looping)
1515 : 42504 : cdtor = node->call_for_symbol_and_aliases (cdtor_p, NULL, true);
1516 : 862174 : if (!dbg_cnt (ipa_attr))
1517 : : return false;
1518 : 862174 : if (node->set_const_flag (true, looping))
1519 : : {
1520 : 485151 : if (dump_file)
1521 : 58 : fprintf (dump_file,
1522 : : "Declaration updated to be %sconst: %s\n",
1523 : : looping ? "looping " : "",
1524 : : node->dump_name ());
1525 : 485151 : if (local)
1526 : : return true;
1527 : 2577 : return cdtor;
1528 : : }
1529 : : return false;
1530 : : }
1531 : :
1532 : : /* Make function const and output warning. If LOCAL is true,
1533 : : return true if anything changed. Otherwise return true if
1534 : : we may have introduced removale ctors. */
1535 : :
1536 : : bool
1537 : 942281 : ipa_make_function_pure (struct cgraph_node *node, bool looping, bool local)
1538 : : {
1539 : 942281 : bool cdtor = false;
1540 : :
1541 : 942281 : if (TREE_READONLY (node->decl)
1542 : 942281 : || (DECL_PURE_P (node->decl)
1543 : 620463 : && (looping || !DECL_LOOPING_CONST_OR_PURE_P (node->decl))))
1544 : : return false;
1545 : 321398 : warn_function_pure (node->decl, !looping);
1546 : 321398 : if (local && skip_function_for_local_pure_const (node))
1547 : : return false;
1548 : 312690 : if (dump_file)
1549 : 8 : fprintf (dump_file, "Function found to be %spure: %s\n",
1550 : : looping ? "looping " : "",
1551 : : node->dump_name ());
1552 : 312690 : if (!local && !looping)
1553 : 3202 : cdtor = node->call_for_symbol_and_aliases (cdtor_p, NULL, true);
1554 : 312690 : if (!dbg_cnt (ipa_attr))
1555 : : return false;
1556 : 312690 : if (node->set_pure_flag (true, looping))
1557 : : {
1558 : 301547 : if (dump_file)
1559 : 8 : fprintf (dump_file,
1560 : : "Declaration updated to be %spure: %s\n",
1561 : : looping ? "looping " : "",
1562 : : node->dump_name ());
1563 : 301547 : if (local)
1564 : : return true;
1565 : 7311 : return cdtor;
1566 : : }
1567 : : return false;
1568 : : }
1569 : :
1570 : : /* Produce transitive closure over the callgraph and compute pure/const
1571 : : attributes. */
1572 : :
1573 : : static bool
1574 : 144942 : propagate_pure_const (void)
1575 : : {
1576 : 144942 : struct cgraph_node *node;
1577 : 144942 : struct cgraph_node *w;
1578 : 144942 : struct cgraph_node **order =
1579 : 144942 : XCNEWVEC (struct cgraph_node *, symtab->cgraph_count);
1580 : 144942 : int order_pos;
1581 : 144942 : int i;
1582 : 144942 : struct ipa_dfs_info * w_info;
1583 : 144942 : bool remove_p = false;
1584 : :
1585 : 144942 : order_pos = ipa_reduced_postorder (order, true,
1586 : : ignore_edge_for_pure_const);
1587 : 144942 : if (dump_file)
1588 : : {
1589 : 29 : cgraph_node::dump_cgraph (dump_file);
1590 : 29 : ipa_print_order (dump_file, "reduced", order, order_pos);
1591 : : }
1592 : :
1593 : : /* Propagate the local information through the call graph to produce
1594 : : the global information. All the nodes within a cycle will have
1595 : : the same info so we collapse cycles first. Then we can do the
1596 : : propagation in one pass from the leaves to the roots. */
1597 : 2295775 : for (i = 0; i < order_pos; i++ )
1598 : : {
1599 : 2150833 : enum pure_const_state_e pure_const_state = IPA_CONST;
1600 : 2150833 : bool looping = false;
1601 : 2150833 : int count = 0;
1602 : 2150833 : node = order[i];
1603 : :
1604 : 2150833 : if (node->alias)
1605 : 37348 : continue;
1606 : :
1607 : 2113485 : if (dump_file && (dump_flags & TDF_DETAILS))
1608 : 5 : fprintf (dump_file, "Starting cycle\n");
1609 : :
1610 : : /* Find the worst state for any node in the cycle. */
1611 : : w = node;
1612 : 3572560 : while (w && pure_const_state != IPA_NEITHER)
1613 : : {
1614 : 2116261 : struct cgraph_edge *e;
1615 : 2116261 : struct cgraph_edge *ie;
1616 : 2116261 : int i;
1617 : 2116261 : struct ipa_ref *ref = NULL;
1618 : :
1619 : 2116261 : funct_state w_l = funct_state_summaries->get_create (w);
1620 : 2116261 : if (dump_file && (dump_flags & TDF_DETAILS))
1621 : 6 : fprintf (dump_file, " Visiting %s state:%s looping %i\n",
1622 : : w->dump_name (),
1623 : 6 : pure_const_names[w_l->pure_const_state],
1624 : 6 : w_l->looping);
1625 : :
1626 : : /* First merge in function body properties.
1627 : : We are safe to pass NULL as FROM and TO because we will take care
1628 : : of possible interposition when walking callees. */
1629 : 2116261 : worse_state (&pure_const_state, &looping,
1630 : 2116261 : w_l->pure_const_state, w_l->looping,
1631 : : NULL, NULL);
1632 : 2116261 : if (pure_const_state == IPA_NEITHER)
1633 : : break;
1634 : :
1635 : 1459075 : count++;
1636 : :
1637 : : /* We consider recursive cycles as possibly infinite.
1638 : : This might be relaxed since infinite recursion leads to stack
1639 : : overflow. */
1640 : 1459075 : if (count > 1)
1641 : 2776 : looping = true;
1642 : :
1643 : : /* Now walk the edges and merge in callee properties. */
1644 : 2181683 : for (e = w->callees; e && pure_const_state != IPA_NEITHER;
1645 : 722608 : e = e->next_callee)
1646 : : {
1647 : 1693011 : enum availability avail;
1648 : 1693011 : struct cgraph_node *y = e->callee->
1649 : 3386022 : function_or_virtual_thunk_symbol (&avail,
1650 : 1693011 : e->caller);
1651 : 1693011 : enum pure_const_state_e edge_state = IPA_CONST;
1652 : 1693011 : bool edge_looping = false;
1653 : :
1654 : 1693011 : if (e->recursive_p ())
1655 : 5797 : looping = true;
1656 : :
1657 : 1693011 : if (dump_file && (dump_flags & TDF_DETAILS))
1658 : : {
1659 : 7 : fprintf (dump_file, " Call to %s",
1660 : 7 : e->callee->dump_name ());
1661 : : }
1662 : 1693011 : if (avail > AVAIL_INTERPOSABLE)
1663 : : {
1664 : 579118 : funct_state y_l = funct_state_summaries->get_create (y);
1665 : :
1666 : 579118 : if (dump_file && (dump_flags & TDF_DETAILS))
1667 : : {
1668 : 2 : fprintf (dump_file,
1669 : : " state:%s looping:%i\n",
1670 : 2 : pure_const_names[y_l->pure_const_state],
1671 : 2 : y_l->looping);
1672 : : }
1673 : 579118 : if (y_l->pure_const_state > IPA_PURE
1674 : 579118 : && e->cannot_lead_to_return_p ())
1675 : : {
1676 : 8091 : if (dump_file && (dump_flags & TDF_DETAILS))
1677 : 0 : fprintf (dump_file,
1678 : : " Ignoring side effects"
1679 : : " -> pure, looping\n");
1680 : 8091 : edge_state = IPA_PURE;
1681 : 8091 : edge_looping = true;
1682 : : }
1683 : : else
1684 : : {
1685 : 571027 : edge_state = y_l->pure_const_state;
1686 : 571027 : edge_looping = y_l->looping;
1687 : : }
1688 : : }
1689 : 1113893 : else if (builtin_safe_for_const_function_p (&edge_looping,
1690 : : y->decl))
1691 : : edge_state = IPA_CONST;
1692 : : else
1693 : 1002858 : state_from_flags (&edge_state, &edge_looping,
1694 : 1002858 : flags_from_decl_or_type (y->decl),
1695 : 1002858 : e->cannot_lead_to_return_p ());
1696 : :
1697 : : /* Merge the results with what we already know. */
1698 : 1693011 : better_state (&edge_state, &edge_looping,
1699 : : w_l->state_previously_known,
1700 : 1693011 : w_l->looping_previously_known);
1701 : 1693011 : worse_state (&pure_const_state, &looping,
1702 : 1693011 : edge_state, edge_looping, e->caller, e->callee);
1703 : 1693011 : if (pure_const_state == IPA_NEITHER)
1704 : : break;
1705 : : }
1706 : :
1707 : : /* Now process the indirect call. */
1708 : 1459075 : for (ie = w->indirect_calls;
1709 : 1459775 : ie && pure_const_state != IPA_NEITHER; ie = ie->next_callee)
1710 : : {
1711 : 25634 : enum pure_const_state_e edge_state = IPA_CONST;
1712 : 25634 : bool edge_looping = false;
1713 : :
1714 : 25634 : if (dump_file && (dump_flags & TDF_DETAILS))
1715 : 0 : fprintf (dump_file, " Indirect call");
1716 : 51268 : state_from_flags (&edge_state, &edge_looping,
1717 : 25634 : ie->indirect_info->ecf_flags,
1718 : 25634 : ie->cannot_lead_to_return_p ());
1719 : : /* Merge the results with what we already know. */
1720 : 25634 : better_state (&edge_state, &edge_looping,
1721 : : w_l->state_previously_known,
1722 : 25634 : w_l->looping_previously_known);
1723 : 25634 : worse_state (&pure_const_state, &looping,
1724 : : edge_state, edge_looping, NULL, NULL);
1725 : 25634 : if (pure_const_state == IPA_NEITHER)
1726 : : break;
1727 : : }
1728 : :
1729 : : /* And finally all loads and stores. */
1730 : 308704 : for (i = 0; w->iterate_reference (i, ref)
1731 : 2386515 : && pure_const_state != IPA_NEITHER; i++)
1732 : : {
1733 : 334796 : enum pure_const_state_e ref_state = IPA_CONST;
1734 : 334796 : bool ref_looping = false;
1735 : 334796 : switch (ref->use)
1736 : : {
1737 : 212304 : case IPA_REF_LOAD:
1738 : : /* readonly reads are safe. */
1739 : 212304 : if (TREE_READONLY (ref->referred->decl))
1740 : : break;
1741 : 199110 : if (dump_file && (dump_flags & TDF_DETAILS))
1742 : 0 : fprintf (dump_file, " nonreadonly global var read\n");
1743 : 199110 : ref_state = IPA_PURE;
1744 : 199110 : break;
1745 : 87711 : case IPA_REF_STORE:
1746 : 87711 : if (ref->cannot_lead_to_return ())
1747 : : break;
1748 : 26150 : ref_state = IPA_NEITHER;
1749 : 26150 : if (dump_file && (dump_flags & TDF_DETAILS))
1750 : 0 : fprintf (dump_file, " global var write\n");
1751 : : break;
1752 : : case IPA_REF_ADDR:
1753 : : break;
1754 : 0 : default:
1755 : 0 : gcc_unreachable ();
1756 : : }
1757 : 334796 : better_state (&ref_state, &ref_looping,
1758 : : w_l->state_previously_known,
1759 : 334796 : w_l->looping_previously_known);
1760 : 334796 : worse_state (&pure_const_state, &looping,
1761 : : ref_state, ref_looping, NULL, NULL);
1762 : 334796 : if (pure_const_state == IPA_NEITHER)
1763 : : break;
1764 : : }
1765 : 1459075 : w_info = (struct ipa_dfs_info *) w->aux;
1766 : 1459075 : w = w_info->next_cycle;
1767 : : }
1768 : 2113485 : if (dump_file && (dump_flags & TDF_DETAILS))
1769 : 5 : fprintf (dump_file, "Result %s looping %i\n",
1770 : 5 : pure_const_names [pure_const_state],
1771 : : looping);
1772 : :
1773 : : /* Find the worst state of can_free for any node in the cycle. */
1774 : : bool can_free = false;
1775 : : w = node;
1776 : 4230237 : while (w && !can_free)
1777 : : {
1778 : 2116752 : struct cgraph_edge *e;
1779 : 2116752 : funct_state w_l = funct_state_summaries->get (w);
1780 : :
1781 : 2116752 : if (w_l->can_free
1782 : 1940731 : || w->get_availability () == AVAIL_INTERPOSABLE
1783 : 3981525 : || w->indirect_calls)
1784 : : can_free = true;
1785 : :
1786 : 3650535 : for (e = w->callees; e && !can_free; e = e->next_callee)
1787 : : {
1788 : 1533783 : enum availability avail;
1789 : 1533783 : struct cgraph_node *y = e->callee->
1790 : 3067566 : function_or_virtual_thunk_symbol (&avail,
1791 : 1533783 : e->caller);
1792 : :
1793 : 1533783 : if (avail > AVAIL_INTERPOSABLE)
1794 : 708838 : can_free = funct_state_summaries->get (y)->can_free;
1795 : : else
1796 : : can_free = true;
1797 : : }
1798 : 2116752 : w_info = (struct ipa_dfs_info *) w->aux;
1799 : 2116752 : w = w_info->next_cycle;
1800 : : }
1801 : :
1802 : : /* Copy back the region's pure_const_state which is shared by
1803 : : all nodes in the region. */
1804 : : w = node;
1805 : 4247671 : while (w)
1806 : : {
1807 : 2134186 : funct_state w_l = funct_state_summaries->get (w);
1808 : 2134186 : enum pure_const_state_e this_state = pure_const_state;
1809 : 2134186 : bool this_looping = looping;
1810 : :
1811 : 2134186 : w_l->can_free = can_free;
1812 : 2134186 : w->nonfreeing_fn = !can_free;
1813 : 2134186 : if (!can_free && dump_file)
1814 : 28 : fprintf (dump_file, "Function found not to call free: %s\n",
1815 : : w->dump_name ());
1816 : :
1817 : 2134186 : if (w_l->state_previously_known != IPA_NEITHER
1818 : 350470 : && this_state > w_l->state_previously_known)
1819 : : {
1820 : 940 : if (this_state == IPA_NEITHER)
1821 : 50 : this_looping = w_l->looping_previously_known;
1822 : : this_state = w_l->state_previously_known;
1823 : : }
1824 : 2134186 : if (!this_looping && self_recursive_p (w))
1825 : : this_looping = true;
1826 : 2134186 : if (!w_l->looping_previously_known)
1827 : 267485 : this_looping = false;
1828 : :
1829 : : /* All nodes within a cycle share the same info. */
1830 : 2134186 : w_l->pure_const_state = this_state;
1831 : 2134186 : w_l->looping = this_looping;
1832 : :
1833 : : /* Inline clones share declaration with their offline copies;
1834 : : do not modify their declarations since the offline copy may
1835 : : be different. */
1836 : 2134186 : if (!w->inlined_to)
1837 : 999885 : switch (this_state)
1838 : : {
1839 : 155651 : case IPA_CONST:
1840 : 155651 : remove_p |= ipa_make_function_const (w, this_looping, false);
1841 : 155651 : break;
1842 : :
1843 : 94415 : case IPA_PURE:
1844 : 94415 : remove_p |= ipa_make_function_pure (w, this_looping, false);
1845 : 94415 : break;
1846 : :
1847 : : default:
1848 : : break;
1849 : : }
1850 : 2134186 : w_info = (struct ipa_dfs_info *) w->aux;
1851 : 2134186 : w = w_info->next_cycle;
1852 : : }
1853 : : }
1854 : :
1855 : 144942 : ipa_free_postorder_info ();
1856 : 144942 : free (order);
1857 : 144942 : return remove_p;
1858 : : }
1859 : :
1860 : : /* Produce transitive closure over the callgraph and compute nothrow
1861 : : attributes. */
1862 : :
1863 : : static void
1864 : 144942 : propagate_nothrow (void)
1865 : : {
1866 : 144942 : struct cgraph_node *node;
1867 : 144942 : struct cgraph_node *w;
1868 : 144942 : struct cgraph_node **order =
1869 : 144942 : XCNEWVEC (struct cgraph_node *, symtab->cgraph_count);
1870 : 144942 : int order_pos;
1871 : 144942 : int i;
1872 : 144942 : struct ipa_dfs_info * w_info;
1873 : :
1874 : 144942 : order_pos = ipa_reduced_postorder (order, true,
1875 : : ignore_edge_for_nothrow);
1876 : 144942 : if (dump_file)
1877 : : {
1878 : 29 : cgraph_node::dump_cgraph (dump_file);
1879 : 29 : ipa_print_order (dump_file, "reduced for nothrow", order, order_pos);
1880 : : }
1881 : :
1882 : : /* Propagate the local information through the call graph to produce
1883 : : the global information. All the nodes within a cycle will have
1884 : : the same info so we collapse cycles first. Then we can do the
1885 : : propagation in one pass from the leaves to the roots. */
1886 : 2311548 : for (i = 0; i < order_pos; i++ )
1887 : : {
1888 : 2166606 : bool can_throw = false;
1889 : 2166606 : node = order[i];
1890 : :
1891 : 2166606 : if (node->alias)
1892 : 37348 : continue;
1893 : :
1894 : : /* Find the worst state for any node in the cycle. */
1895 : : w = node;
1896 : 4258669 : while (w && !can_throw)
1897 : : {
1898 : 2129411 : struct cgraph_edge *e, *ie;
1899 : :
1900 : 2129411 : if (!TREE_NOTHROW (w->decl))
1901 : : {
1902 : 849678 : funct_state w_l = funct_state_summaries->get_create (w);
1903 : :
1904 : 849678 : if (w_l->can_throw
1905 : 849678 : || w->get_availability () == AVAIL_INTERPOSABLE)
1906 : : can_throw = true;
1907 : :
1908 : 1543729 : for (e = w->callees; e && !can_throw; e = e->next_callee)
1909 : : {
1910 : 694051 : enum availability avail;
1911 : :
1912 : 694051 : if (!e->can_throw_external || TREE_NOTHROW (e->callee->decl))
1913 : 164465 : continue;
1914 : :
1915 : 529586 : struct cgraph_node *y = e->callee->
1916 : 1059172 : function_or_virtual_thunk_symbol (&avail,
1917 : 529586 : e->caller);
1918 : :
1919 : : /* We can use info about the callee only if we know it
1920 : : cannot be interposed.
1921 : : When callee is compiled with non-call exceptions we also
1922 : : must check that the declaration is bound to current
1923 : : body as other semantically equivalent body may still
1924 : : throw. */
1925 : 529586 : if (avail <= AVAIL_INTERPOSABLE
1926 : 529586 : || (!TREE_NOTHROW (y->decl)
1927 : 254115 : && (funct_state_summaries->get_create (y)->can_throw
1928 : 2085 : || (opt_for_fn (y->decl, flag_non_call_exceptions)
1929 : 485 : && !e->callee->binds_to_current_def_p (w)))))
1930 : : can_throw = true;
1931 : : }
1932 : 863407 : for (ie = w->indirect_calls; ie && !can_throw;
1933 : 13729 : ie = ie->next_callee)
1934 : 13729 : if (ie->can_throw_external
1935 : 12313 : && !(ie->indirect_info->ecf_flags & ECF_NOTHROW))
1936 : 13729 : can_throw = true;
1937 : : }
1938 : 2129411 : w_info = (struct ipa_dfs_info *) w->aux;
1939 : 2129411 : w = w_info->next_cycle;
1940 : : }
1941 : :
1942 : : /* Copy back the region's pure_const_state which is shared by
1943 : : all nodes in the region. */
1944 : : w = node;
1945 : 4263444 : while (w)
1946 : : {
1947 : 2134186 : funct_state w_l = funct_state_summaries->get_create (w);
1948 : 2134186 : if (!can_throw && !TREE_NOTHROW (w->decl))
1949 : : {
1950 : : /* Inline clones share declaration with their offline copies;
1951 : : do not modify their declarations since the offline copy may
1952 : : be different. */
1953 : 12280 : if (!w->inlined_to)
1954 : : {
1955 : 2833 : w->set_nothrow_flag (true);
1956 : 2833 : if (dump_file)
1957 : 0 : fprintf (dump_file, "Function found to be nothrow: %s\n",
1958 : : w->dump_name ());
1959 : : }
1960 : : }
1961 : 842137 : else if (can_throw && !TREE_NOTHROW (w->decl))
1962 : 842137 : w_l->can_throw = true;
1963 : 2134186 : w_info = (struct ipa_dfs_info *) w->aux;
1964 : 2134186 : w = w_info->next_cycle;
1965 : : }
1966 : : }
1967 : :
1968 : 144942 : ipa_free_postorder_info ();
1969 : 144942 : free (order);
1970 : 144942 : }
1971 : :
1972 : : /* Debugging function to dump state of malloc lattice. */
1973 : :
1974 : : DEBUG_FUNCTION
1975 : : static void
1976 : 289884 : dump_malloc_lattice (FILE *dump_file, const char *s)
1977 : : {
1978 : 289884 : if (!dump_file)
1979 : : return;
1980 : :
1981 : 58 : fprintf (dump_file, "\n\nMALLOC LATTICE %s:\n", s);
1982 : 58 : cgraph_node *node;
1983 : 580 : FOR_EACH_FUNCTION (node)
1984 : : {
1985 : 232 : funct_state fs = funct_state_summaries->get (node);
1986 : 232 : if (fs)
1987 : 156 : fprintf (dump_file, "%s: %s\n", node->dump_name (),
1988 : 156 : malloc_state_names[fs->malloc_state]);
1989 : : }
1990 : : }
1991 : :
1992 : : /* Propagate malloc attribute across the callgraph. */
1993 : :
1994 : : static void
1995 : 144942 : propagate_malloc (void)
1996 : : {
1997 : 144942 : cgraph_node *node;
1998 : 7387282 : FOR_EACH_FUNCTION (node)
1999 : : {
2000 : 3548699 : if (DECL_IS_MALLOC (node->decl))
2001 : 41720 : if (!funct_state_summaries->exists (node))
2002 : : {
2003 : 20714 : funct_state fs = funct_state_summaries->get_create (node);
2004 : 20714 : fs->malloc_state = STATE_MALLOC;
2005 : : }
2006 : : }
2007 : :
2008 : 144942 : dump_malloc_lattice (dump_file, "Initial");
2009 : 144942 : struct cgraph_node **order
2010 : 144942 : = XNEWVEC (struct cgraph_node *, symtab->cgraph_count);
2011 : 144942 : int order_pos = ipa_reverse_postorder (order);
2012 : 144942 : bool changed = true;
2013 : :
2014 : 436619 : while (changed)
2015 : : {
2016 : 146735 : changed = false;
2017 : : /* Walk in postorder. */
2018 : 4355812 : for (int i = order_pos - 1; i >= 0; --i)
2019 : : {
2020 : 4209077 : cgraph_node *node = order[i];
2021 : 5771234 : if (node->alias
2022 : 4209077 : || !node->definition
2023 : 4209077 : || !funct_state_summaries->exists (node))
2024 : 4159922 : continue;
2025 : :
2026 : 2646920 : funct_state l = funct_state_summaries->get (node);
2027 : :
2028 : : /* FIXME: add support for indirect-calls. */
2029 : 2646920 : if (node->indirect_calls)
2030 : : {
2031 : 139548 : l->malloc_state = STATE_MALLOC_BOTTOM;
2032 : 139548 : continue;
2033 : : }
2034 : :
2035 : 2507372 : if (node->get_availability () <= AVAIL_INTERPOSABLE)
2036 : : {
2037 : 90035 : l->malloc_state = STATE_MALLOC_BOTTOM;
2038 : 90035 : continue;
2039 : : }
2040 : :
2041 : 2417337 : if (l->malloc_state == STATE_MALLOC_BOTTOM)
2042 : 2368182 : continue;
2043 : :
2044 : 49155 : auto_vec<cgraph_node *, 16> callees;
2045 : 186356 : for (cgraph_edge *cs = node->callees; cs; cs = cs->next_callee)
2046 : : {
2047 : 137201 : ipa_call_summary *es = ipa_call_summaries->get_create (cs);
2048 : 137201 : if (es && es->is_return_callee_uncaptured)
2049 : 12032 : callees.safe_push (cs->callee);
2050 : : }
2051 : :
2052 : 49155 : malloc_state_e new_state = l->malloc_state;
2053 : 122374 : for (unsigned j = 0; j < callees.length (); j++)
2054 : : {
2055 : 12032 : cgraph_node *callee = callees[j];
2056 : 12032 : if (!funct_state_summaries->exists (node))
2057 : : {
2058 : : new_state = STATE_MALLOC_BOTTOM;
2059 : : break;
2060 : : }
2061 : 12032 : malloc_state_e callee_state
2062 : 12032 : = funct_state_summaries->get_create (callee)->malloc_state;
2063 : 12032 : if (new_state < callee_state)
2064 : 10146 : new_state = callee_state;
2065 : : }
2066 : 49155 : if (new_state != l->malloc_state)
2067 : : {
2068 : 10128 : changed = true;
2069 : 10128 : l->malloc_state = new_state;
2070 : : }
2071 : 49155 : }
2072 : : }
2073 : :
2074 : 2316480 : FOR_EACH_DEFINED_FUNCTION (node)
2075 : 2171538 : if (funct_state_summaries->exists (node))
2076 : : {
2077 : 2159277 : funct_state l = funct_state_summaries->get (node);
2078 : 2159277 : if (!node->alias
2079 : 2134186 : && l->malloc_state == STATE_MALLOC
2080 : 16054 : && !node->inlined_to
2081 : 2159667 : && !VOID_TYPE_P (TREE_TYPE (TREE_TYPE (node->decl))))
2082 : : {
2083 : 390 : if (dump_file && (dump_flags & TDF_DETAILS))
2084 : 6 : fprintf (dump_file, "Function %s found to be malloc\n",
2085 : : node->dump_name ());
2086 : :
2087 : 390 : bool malloc_decl_p = DECL_IS_MALLOC (node->decl);
2088 : 390 : node->set_malloc_flag (true);
2089 : 390 : if (!malloc_decl_p && warn_suggest_attribute_malloc)
2090 : 0 : warn_function_malloc (node->decl);
2091 : : }
2092 : : }
2093 : :
2094 : 144942 : dump_malloc_lattice (dump_file, "after propagation");
2095 : 144942 : ipa_free_postorder_info ();
2096 : 144942 : free (order);
2097 : 144942 : }
2098 : :
2099 : : /* Produce the global information by preforming a transitive closure
2100 : : on the local information that was produced by generate_summary. */
2101 : :
2102 : : unsigned int
2103 : 144942 : pass_ipa_pure_const::
2104 : : execute (function *)
2105 : : {
2106 : 144942 : bool remove_p;
2107 : :
2108 : : /* Nothrow makes more function to not lead to return and improve
2109 : : later analysis. */
2110 : 144942 : propagate_nothrow ();
2111 : 144942 : propagate_malloc ();
2112 : 144942 : remove_p = propagate_pure_const ();
2113 : :
2114 : 144942 : delete funct_state_summaries;
2115 : 144942 : return remove_p ? TODO_remove_functions : 0;
2116 : : }
2117 : :
2118 : : static bool
2119 : 3800370 : gate_pure_const (void)
2120 : : {
2121 : 565525 : return flag_ipa_pure_const || in_lto_p;
2122 : : }
2123 : :
2124 : 273196 : pass_ipa_pure_const::pass_ipa_pure_const(gcc::context *ctxt)
2125 : : : ipa_opt_pass_d(pass_data_ipa_pure_const, ctxt,
2126 : : pure_const_generate_summary, /* generate_summary */
2127 : : pure_const_write_summary, /* write_summary */
2128 : : pure_const_read_summary, /* read_summary */
2129 : : NULL, /* write_optimization_summary */
2130 : : NULL, /* read_optimization_summary */
2131 : : NULL, /* stmt_fixup */
2132 : : 0, /* function_transform_todo_flags_start */
2133 : : NULL, /* function_transform */
2134 : : NULL), /* variable_transform */
2135 : 273196 : init_p (false) {}
2136 : :
2137 : : ipa_opt_pass_d *
2138 : 273196 : make_pass_ipa_pure_const (gcc::context *ctxt)
2139 : : {
2140 : 273196 : return new pass_ipa_pure_const (ctxt);
2141 : : }
2142 : :
2143 : : /* Simple local pass for pure const discovery reusing the analysis from
2144 : : ipa_pure_const. This pass is effective when executed together with
2145 : : other optimization passes in early optimization pass queue. */
2146 : :
2147 : : namespace {
2148 : :
2149 : : const pass_data pass_data_local_pure_const =
2150 : : {
2151 : : GIMPLE_PASS, /* type */
2152 : : "local-pure-const", /* name */
2153 : : OPTGROUP_NONE, /* optinfo_flags */
2154 : : TV_IPA_PURE_CONST, /* tv_id */
2155 : : 0, /* properties_required */
2156 : : 0, /* properties_provided */
2157 : : 0, /* properties_destroyed */
2158 : : 0, /* todo_flags_start */
2159 : : 0, /* todo_flags_finish */
2160 : : };
2161 : :
2162 : : class pass_local_pure_const : public gimple_opt_pass
2163 : : {
2164 : : public:
2165 : 546392 : pass_local_pure_const (gcc::context *ctxt)
2166 : 1092784 : : gimple_opt_pass (pass_data_local_pure_const, ctxt)
2167 : : {}
2168 : :
2169 : : /* opt_pass methods: */
2170 : 273196 : opt_pass * clone () final override
2171 : : {
2172 : 273196 : return new pass_local_pure_const (m_ctxt);
2173 : : }
2174 : 3235093 : bool gate (function *) final override { return gate_pure_const (); }
2175 : : unsigned int execute (function *) final override;
2176 : :
2177 : : }; // class pass_local_pure_const
2178 : :
2179 : : unsigned int
2180 : 3234795 : pass_local_pure_const::execute (function *fun)
2181 : : {
2182 : 3234795 : bool changed = false;
2183 : 3234795 : funct_state l;
2184 : 3234795 : bool skip;
2185 : 3234795 : struct cgraph_node *node;
2186 : :
2187 : 3234795 : node = cgraph_node::get (current_function_decl);
2188 : 3234795 : skip = skip_function_for_local_pure_const (node);
2189 : :
2190 : 3234795 : if (!warn_suggest_attribute_const
2191 : 3234772 : && !warn_suggest_attribute_pure
2192 : 3234751 : && skip)
2193 : : return 0;
2194 : :
2195 : 3073171 : l = analyze_function (node, false);
2196 : :
2197 : : /* Do NORETURN discovery. */
2198 : 3073171 : if (!skip && !TREE_THIS_VOLATILE (current_function_decl)
2199 : 6120997 : && EDGE_COUNT (EXIT_BLOCK_PTR_FOR_FN (fun)->preds) == 0)
2200 : : {
2201 : 29798 : warn_function_noreturn (fun->decl);
2202 : 29798 : if (dump_file)
2203 : 1 : fprintf (dump_file, "Function found to be noreturn: %s\n",
2204 : : current_function_name ());
2205 : :
2206 : : /* Update declaration and reduce profile to executed once. */
2207 : 29798 : if (cgraph_node::get (current_function_decl)->set_noreturn_flag (true))
2208 : : changed = true;
2209 : 29798 : if (node->frequency > NODE_FREQUENCY_EXECUTED_ONCE)
2210 : 11212 : node->frequency = NODE_FREQUENCY_EXECUTED_ONCE;
2211 : : }
2212 : :
2213 : 3073171 : switch (l->pure_const_state)
2214 : : {
2215 : 625111 : case IPA_CONST:
2216 : 1250222 : changed |= ipa_make_function_const
2217 : 625111 : (cgraph_node::get (current_function_decl), l->looping, true);
2218 : 625111 : break;
2219 : :
2220 : 374774 : case IPA_PURE:
2221 : 749548 : changed |= ipa_make_function_pure
2222 : 374774 : (cgraph_node::get (current_function_decl), l->looping, true);
2223 : 374774 : break;
2224 : :
2225 : : default:
2226 : : break;
2227 : : }
2228 : 3073171 : if (!l->can_throw && !TREE_NOTHROW (current_function_decl))
2229 : : {
2230 : 21004 : node->set_nothrow_flag (true);
2231 : 21004 : changed = true;
2232 : 21004 : if (dump_file)
2233 : 2 : fprintf (dump_file, "Function found to be nothrow: %s\n",
2234 : : current_function_name ());
2235 : : }
2236 : :
2237 : 3073171 : if (l->malloc_state == STATE_MALLOC
2238 : 3073171 : && !DECL_IS_MALLOC (current_function_decl))
2239 : : {
2240 : 20278 : node->set_malloc_flag (true);
2241 : 20278 : if (warn_suggest_attribute_malloc)
2242 : 3 : warn_function_malloc (node->decl);
2243 : 20278 : changed = true;
2244 : 20278 : if (dump_file)
2245 : 2 : fprintf (dump_file, "Function found to be malloc: %s\n",
2246 : : node->dump_name ());
2247 : : }
2248 : :
2249 : 3073171 : free (l);
2250 : 3073171 : if (changed)
2251 : 824437 : return execute_fixup_cfg ();
2252 : : else
2253 : : return 0;
2254 : : }
2255 : :
2256 : : } // anon namespace
2257 : :
2258 : : gimple_opt_pass *
2259 : 273196 : make_pass_local_pure_const (gcc::context *ctxt)
2260 : : {
2261 : 273196 : return new pass_local_pure_const (ctxt);
2262 : : }
2263 : :
2264 : : /* Emit noreturn warnings. */
2265 : :
2266 : : namespace {
2267 : :
2268 : : const pass_data pass_data_warn_function_noreturn =
2269 : : {
2270 : : GIMPLE_PASS, /* type */
2271 : : "*warn_function_noreturn", /* name */
2272 : : OPTGROUP_NONE, /* optinfo_flags */
2273 : : TV_NONE, /* tv_id */
2274 : : PROP_cfg, /* properties_required */
2275 : : 0, /* properties_provided */
2276 : : 0, /* properties_destroyed */
2277 : : 0, /* todo_flags_start */
2278 : : 0, /* todo_flags_finish */
2279 : : };
2280 : :
2281 : : class pass_warn_function_noreturn : public gimple_opt_pass
2282 : : {
2283 : : public:
2284 : 273196 : pass_warn_function_noreturn (gcc::context *ctxt)
2285 : 546392 : : gimple_opt_pass (pass_data_warn_function_noreturn, ctxt)
2286 : : {}
2287 : :
2288 : : /* opt_pass methods: */
2289 : 1422113 : bool gate (function *) final override
2290 : : {
2291 : 1422113 : return warn_suggest_attribute_noreturn;
2292 : : }
2293 : 27 : unsigned int execute (function *fun) final override
2294 : : {
2295 : 27 : if (!TREE_THIS_VOLATILE (current_function_decl)
2296 : 27 : && EDGE_COUNT (EXIT_BLOCK_PTR_FOR_FN (fun)->preds) == 0)
2297 : 4 : warn_function_noreturn (current_function_decl);
2298 : 27 : return 0;
2299 : : }
2300 : :
2301 : : }; // class pass_warn_function_noreturn
2302 : :
2303 : : } // anon namespace
2304 : :
2305 : : gimple_opt_pass *
2306 : 273196 : make_pass_warn_function_noreturn (gcc::context *ctxt)
2307 : : {
2308 : 273196 : return new pass_warn_function_noreturn (ctxt);
2309 : : }
2310 : :
2311 : : /* Simple local pass for pure const discovery reusing the analysis from
2312 : : ipa_pure_const. This pass is effective when executed together with
2313 : : other optimization passes in early optimization pass queue. */
2314 : :
2315 : : namespace {
2316 : :
2317 : : const pass_data pass_data_nothrow =
2318 : : {
2319 : : GIMPLE_PASS, /* type */
2320 : : "nothrow", /* name */
2321 : : OPTGROUP_NONE, /* optinfo_flags */
2322 : : TV_IPA_PURE_CONST, /* tv_id */
2323 : : 0, /* properties_required */
2324 : : 0, /* properties_provided */
2325 : : 0, /* properties_destroyed */
2326 : : 0, /* todo_flags_start */
2327 : : 0, /* todo_flags_finish */
2328 : : };
2329 : :
2330 : : class pass_nothrow : public gimple_opt_pass
2331 : : {
2332 : : public:
2333 : 273196 : pass_nothrow (gcc::context *ctxt)
2334 : 546392 : : gimple_opt_pass (pass_data_nothrow, ctxt)
2335 : : {}
2336 : :
2337 : : /* opt_pass methods: */
2338 : 0 : opt_pass * clone () final override { return new pass_nothrow (m_ctxt); }
2339 : 2671760 : bool gate (function *) final override { return optimize; }
2340 : : unsigned int execute (function *) final override;
2341 : :
2342 : : }; // class pass_nothrow
2343 : :
2344 : : unsigned int
2345 : 2240915 : pass_nothrow::execute (function *)
2346 : : {
2347 : 2240915 : struct cgraph_node *node;
2348 : 2240915 : basic_block this_block;
2349 : :
2350 : 2240915 : if (TREE_NOTHROW (current_function_decl))
2351 : : return 0;
2352 : :
2353 : 1393768 : node = cgraph_node::get (current_function_decl);
2354 : :
2355 : : /* We run during lowering, we cannot really use availability yet. */
2356 : 1393768 : if (cgraph_node::get (current_function_decl)->get_availability ()
2357 : : <= AVAIL_INTERPOSABLE)
2358 : : {
2359 : 78534 : if (dump_file)
2360 : 0 : fprintf (dump_file, "Function is interposable;"
2361 : : " not analyzing.\n");
2362 : 78534 : return true;
2363 : : }
2364 : :
2365 : 10141872 : FOR_EACH_BB_FN (this_block, cfun)
2366 : : {
2367 : 18742400 : for (gimple_stmt_iterator gsi = gsi_start_bb (this_block);
2368 : 45901109 : !gsi_end_p (gsi);
2369 : 36529909 : gsi_next (&gsi))
2370 : 37074471 : if (stmt_can_throw_external (cfun, gsi_stmt (gsi)))
2371 : : {
2372 : 545860 : if (is_gimple_call (gsi_stmt (gsi)))
2373 : : {
2374 : 341383 : tree callee_t = gimple_call_fndecl (gsi_stmt (gsi));
2375 : 341383 : if (callee_t && recursive_call_p (current_function_decl,
2376 : : callee_t))
2377 : 1298 : continue;
2378 : : }
2379 : :
2380 : 544562 : if (dump_file)
2381 : : {
2382 : 0 : fprintf (dump_file, "Statement can throw: ");
2383 : 0 : print_gimple_stmt (dump_file, gsi_stmt (gsi), 0);
2384 : : }
2385 : 544562 : return 0;
2386 : : }
2387 : : }
2388 : :
2389 : 770672 : node->set_nothrow_flag (true);
2390 : :
2391 : 770672 : bool cfg_changed = false;
2392 : 770672 : if (self_recursive_p (node))
2393 : 29247 : FOR_EACH_BB_FN (this_block, cfun)
2394 : 79198 : if (gcall *g = safe_dyn_cast <gcall *> (*gsi_last_bb (this_block)))
2395 : : {
2396 : 1957 : tree callee_t = gimple_call_fndecl (g);
2397 : 1957 : if (callee_t
2398 : 1857 : && recursive_call_p (current_function_decl, callee_t)
2399 : 553 : && maybe_clean_eh_stmt (g)
2400 : 1960 : && gimple_purge_dead_eh_edges (this_block))
2401 : : cfg_changed = true;
2402 : : }
2403 : :
2404 : 770672 : if (dump_file)
2405 : 33 : fprintf (dump_file, "Function found to be nothrow: %s\n",
2406 : : current_function_name ());
2407 : 770672 : return cfg_changed ? TODO_cleanup_cfg : 0;
2408 : : }
2409 : :
2410 : : } // anon namespace
2411 : :
2412 : : gimple_opt_pass *
2413 : 273196 : make_pass_nothrow (gcc::context *ctxt)
2414 : : {
2415 : 273196 : return new pass_nothrow (ctxt);
2416 : : }
|
