1 /* Callgraph based analysis of static variables.
2 Copyright (C) 2004-2018 Free Software Foundation, Inc.
3 Contributed by Kenneth Zadeck <zadeck@naturalbridge.com>
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
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
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 /* 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).
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. */
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. */
36 #include "coretypes.h"
41 #include "tree-pass.h"
42 #include "tree-streamer.h"
44 #include "diagnostic.h"
48 #include "gimple-iterator.h"
49 #include "gimple-walk.h"
51 #include "tree-ssa-loop-niter.h"
52 #include "langhooks.h"
53 #include "ipa-utils.h"
54 #include "gimple-pretty-print.h"
56 #include "tree-scalar-evolution.h"
60 #include "alloc-pool.h"
61 #include "symbol-summary.h"
63 #include "ipa-fnsummary.h"
65 /* Lattice values for const and pure functions. Everything starts out
66 being const, then may drop to pure and then neither depending on
68 enum pure_const_state_e
75 static const char *pure_const_names
[3] = {"const", "pure", "neither"};
84 static const char *malloc_state_names
[] = {"malloc_top", "malloc", "malloc_bottom"};
86 /* Holder for the const_state. There is one of these per function
91 funct_state_d (): pure_const_state (IPA_NEITHER
),
92 state_previously_known (IPA_NEITHER
), looping_previously_known (true),
93 looping (true), can_throw (true), can_free (true),
94 malloc_state (STATE_MALLOC_BOTTOM
) {}
96 funct_state_d (const funct_state_d
&s
): pure_const_state (s
.pure_const_state
),
97 state_previously_known (s
.state_previously_known
),
98 looping_previously_known (s
.looping_previously_known
),
99 looping (s
.looping
), can_throw (s
.can_throw
), can_free (s
.can_free
),
100 malloc_state (s
.malloc_state
) {}
103 enum pure_const_state_e pure_const_state
;
104 /* What user set here; we can be always sure about this. */
105 enum pure_const_state_e state_previously_known
;
106 bool looping_previously_known
;
108 /* True if the function could possibly infinite loop. There are a
109 lot of ways that this could be determined. We are pretty
110 conservative here. While it is possible to cse pure and const
111 calls, it is not legal to have dce get rid of the call if there
112 is a possibility that the call could infinite loop since this is
113 a behavioral change. */
118 /* If function can call free, munmap or otherwise make previously
119 non-trapping memory accesses trapping. */
122 enum malloc_state_e malloc_state
;
125 typedef struct funct_state_d
* funct_state
;
127 /* The storage of the funct_state is abstracted because there is the
128 possibility that it may be desirable to move this to the cgraph
131 class funct_state_summary_t
: public function_summary
<funct_state_d
*>
134 funct_state_summary_t (symbol_table
*symtab
):
135 function_summary
<funct_state_d
*> (symtab
) {}
137 virtual void insert (cgraph_node
*, funct_state_d
*state
);
138 virtual void duplicate (cgraph_node
*src_node
, cgraph_node
*dst_node
,
139 funct_state_d
*src_data
,
140 funct_state_d
*dst_data
);
143 static funct_state_summary_t
*funct_state_summaries
= NULL
;
145 static bool gate_pure_const (void);
149 const pass_data pass_data_ipa_pure_const
=
152 "pure-const", /* name */
153 OPTGROUP_NONE
, /* optinfo_flags */
154 TV_IPA_PURE_CONST
, /* tv_id */
155 0, /* properties_required */
156 0, /* properties_provided */
157 0, /* properties_destroyed */
158 0, /* todo_flags_start */
159 0, /* todo_flags_finish */
162 class pass_ipa_pure_const
: public ipa_opt_pass_d
165 pass_ipa_pure_const(gcc::context
*ctxt
);
167 /* opt_pass methods: */
168 bool gate (function
*) { return gate_pure_const (); }
169 unsigned int execute (function
*fun
);
171 void register_hooks (void);
175 }; // class pass_ipa_pure_const
179 /* Try to guess if function body will always be visible to compiler
180 when compiling the call and whether compiler will be able
181 to propagate the information by itself. */
184 function_always_visible_to_compiler_p (tree decl
)
186 return (!TREE_PUBLIC (decl
) || DECL_DECLARED_INLINE_P (decl
)
187 || DECL_COMDAT (decl
));
190 /* Emit suggestion about attribute ATTRIB_NAME for DECL. KNOWN_FINITE
191 is true if the function is known to be finite. The diagnostic is
192 controlled by OPTION. WARNED_ABOUT is a hash_set<tree> unique for
193 OPTION, this function may initialize it and it is always returned
196 static hash_set
<tree
> *
197 suggest_attribute (int option
, tree decl
, bool known_finite
,
198 hash_set
<tree
> *warned_about
,
199 const char * attrib_name
)
201 if (!option_enabled (option
, &global_options
))
203 if (TREE_THIS_VOLATILE (decl
)
204 || (known_finite
&& function_always_visible_to_compiler_p (decl
)))
208 warned_about
= new hash_set
<tree
>;
209 if (warned_about
->contains (decl
))
211 warned_about
->add (decl
);
212 warning_at (DECL_SOURCE_LOCATION (decl
),
215 ? G_("function might be candidate for attribute %qs")
216 : G_("function might be candidate for attribute %qs"
217 " if it is known to return normally"), attrib_name
);
221 /* Emit suggestion about __attribute_((pure)) for DECL. KNOWN_FINITE
222 is true if the function is known to be finite. */
225 warn_function_pure (tree decl
, bool known_finite
)
227 /* Declaring a void function pure makes no sense and is diagnosed
228 by -Wattributes because calling it would have no effect. */
229 if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl
))))
232 static hash_set
<tree
> *warned_about
;
234 = suggest_attribute (OPT_Wsuggest_attribute_pure
, decl
,
235 known_finite
, warned_about
, "pure");
238 /* Emit suggestion about __attribute_((const)) for DECL. KNOWN_FINITE
239 is true if the function is known to be finite. */
242 warn_function_const (tree decl
, bool known_finite
)
244 /* Declaring a void function const makes no sense is diagnosed
245 by -Wattributes because calling it would have no effect. */
246 if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl
))))
249 static hash_set
<tree
> *warned_about
;
251 = suggest_attribute (OPT_Wsuggest_attribute_const
, decl
,
252 known_finite
, warned_about
, "const");
255 /* Emit suggestion about __attribute__((malloc)) for DECL. */
258 warn_function_malloc (tree decl
)
260 static hash_set
<tree
> *warned_about
;
262 = suggest_attribute (OPT_Wsuggest_attribute_malloc
, decl
,
263 true, warned_about
, "malloc");
266 /* Emit suggestion about __attribute__((noreturn)) for DECL. */
269 warn_function_noreturn (tree decl
)
271 tree original_decl
= decl
;
273 static hash_set
<tree
> *warned_about
;
274 if (!lang_hooks
.missing_noreturn_ok_p (decl
)
275 && targetm
.warn_func_return (decl
))
277 = suggest_attribute (OPT_Wsuggest_attribute_noreturn
, original_decl
,
278 true, warned_about
, "noreturn");
282 warn_function_cold (tree decl
)
284 tree original_decl
= decl
;
286 static hash_set
<tree
> *warned_about
;
288 = suggest_attribute (OPT_Wsuggest_attribute_cold
, original_decl
,
289 true, warned_about
, "cold");
292 /* Check to see if the use (or definition when CHECKING_WRITE is true)
293 variable T is legal in a function that is either pure or const. */
296 check_decl (funct_state local
,
297 tree t
, bool checking_write
, bool ipa
)
299 /* Do not want to do anything with volatile except mark any
300 function that uses one to be not const or pure. */
301 if (TREE_THIS_VOLATILE (t
))
303 local
->pure_const_state
= IPA_NEITHER
;
305 fprintf (dump_file
, " Volatile operand is not const/pure\n");
309 /* Do not care about a local automatic that is not static. */
310 if (!TREE_STATIC (t
) && !DECL_EXTERNAL (t
))
313 /* If the variable has the "used" attribute, treat it as if it had a
314 been touched by the devil. */
315 if (DECL_PRESERVE_P (t
))
317 local
->pure_const_state
= IPA_NEITHER
;
319 fprintf (dump_file
, " Used static/global variable is not const/pure\n");
323 /* In IPA mode we are not interested in checking actual loads and stores;
324 they will be processed at propagation time using ipa_ref. */
328 /* Since we have dealt with the locals and params cases above, if we
329 are CHECKING_WRITE, this cannot be a pure or constant
333 local
->pure_const_state
= IPA_NEITHER
;
335 fprintf (dump_file
, " static/global memory write is not const/pure\n");
339 if (DECL_EXTERNAL (t
) || TREE_PUBLIC (t
))
341 /* Readonly reads are safe. */
342 if (TREE_READONLY (t
) && !TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (t
)))
343 return; /* Read of a constant, do not change the function state. */
347 fprintf (dump_file
, " global memory read is not const\n");
348 /* Just a regular read. */
349 if (local
->pure_const_state
== IPA_CONST
)
350 local
->pure_const_state
= IPA_PURE
;
355 /* Compilation level statics can be read if they are readonly
357 if (TREE_READONLY (t
))
361 fprintf (dump_file
, " static memory read is not const\n");
362 /* Just a regular read. */
363 if (local
->pure_const_state
== IPA_CONST
)
364 local
->pure_const_state
= IPA_PURE
;
369 /* Check to see if the use (or definition when CHECKING_WRITE is true)
370 variable T is legal in a function that is either pure or const. */
373 check_op (funct_state local
, tree t
, bool checking_write
)
375 t
= get_base_address (t
);
376 if (t
&& TREE_THIS_VOLATILE (t
))
378 local
->pure_const_state
= IPA_NEITHER
;
380 fprintf (dump_file
, " Volatile indirect ref is not const/pure\n");
384 && (INDIRECT_REF_P (t
) || TREE_CODE (t
) == MEM_REF
)
385 && TREE_CODE (TREE_OPERAND (t
, 0)) == SSA_NAME
386 && !ptr_deref_may_alias_global_p (TREE_OPERAND (t
, 0)))
389 fprintf (dump_file
, " Indirect ref to local memory is OK\n");
392 else if (checking_write
)
394 local
->pure_const_state
= IPA_NEITHER
;
396 fprintf (dump_file
, " Indirect ref write is not const/pure\n");
402 fprintf (dump_file
, " Indirect ref read is not const\n");
403 if (local
->pure_const_state
== IPA_CONST
)
404 local
->pure_const_state
= IPA_PURE
;
408 /* compute state based on ECF FLAGS and store to STATE and LOOPING. */
411 state_from_flags (enum pure_const_state_e
*state
, bool *looping
,
412 int flags
, bool cannot_lead_to_return
)
415 if (flags
& ECF_LOOPING_CONST_OR_PURE
)
418 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
419 fprintf (dump_file
, " looping\n");
421 if (flags
& ECF_CONST
)
424 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
425 fprintf (dump_file
, " const\n");
427 else if (flags
& ECF_PURE
)
430 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
431 fprintf (dump_file
, " pure\n");
433 else if (cannot_lead_to_return
)
437 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
438 fprintf (dump_file
, " ignoring side effects->pure looping\n");
442 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
443 fprintf (dump_file
, " neither\n");
444 *state
= IPA_NEITHER
;
449 /* Merge STATE and STATE2 and LOOPING and LOOPING2 and store
450 into STATE and LOOPING better of the two variants.
451 Be sure to merge looping correctly. IPA_NEITHER functions
452 have looping 0 even if they don't have to return. */
455 better_state (enum pure_const_state_e
*state
, bool *looping
,
456 enum pure_const_state_e state2
, bool looping2
)
460 if (*state
== IPA_NEITHER
)
463 *looping
= MIN (*looping
, looping2
);
466 else if (state2
!= IPA_NEITHER
)
467 *looping
= MIN (*looping
, looping2
);
470 /* Merge STATE and STATE2 and LOOPING and LOOPING2 and store
471 into STATE and LOOPING worse of the two variants.
472 N is the actual node called. */
475 worse_state (enum pure_const_state_e
*state
, bool *looping
,
476 enum pure_const_state_e state2
, bool looping2
,
477 struct symtab_node
*from
,
478 struct symtab_node
*to
)
480 /* Consider function:
487 During early optimization we will turn this into:
494 Now if this function will be detected as CONST however when interposed it
495 may end up being just pure. We always must assume the worst scenario here.
497 if (*state
== IPA_CONST
&& state2
== IPA_CONST
498 && to
&& !TREE_READONLY (to
->decl
) && !to
->binds_to_current_def_p (from
))
500 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
501 fprintf (dump_file
, "Dropping state to PURE because call to %s may not "
502 "bind to current def.\n", to
->name ());
505 *state
= MAX (*state
, state2
);
506 *looping
= MAX (*looping
, looping2
);
509 /* Recognize special cases of builtins that are by themselves not pure or const
510 but function using them is. */
512 special_builtin_state (enum pure_const_state_e
*state
, bool *looping
,
515 if (DECL_BUILT_IN_CLASS (callee
) == BUILT_IN_NORMAL
)
516 switch (DECL_FUNCTION_CODE (callee
))
518 case BUILT_IN_RETURN
:
519 case BUILT_IN_UNREACHABLE
:
520 CASE_BUILT_IN_ALLOCA
:
521 case BUILT_IN_STACK_SAVE
:
522 case BUILT_IN_STACK_RESTORE
:
523 case BUILT_IN_EH_POINTER
:
524 case BUILT_IN_EH_FILTER
:
525 case BUILT_IN_UNWIND_RESUME
:
526 case BUILT_IN_CXA_END_CLEANUP
:
527 case BUILT_IN_EH_COPY_VALUES
:
528 case BUILT_IN_FRAME_ADDRESS
:
530 case BUILT_IN_APPLY_ARGS
:
531 case BUILT_IN_ASAN_BEFORE_DYNAMIC_INIT
:
532 case BUILT_IN_ASAN_AFTER_DYNAMIC_INIT
:
536 case BUILT_IN_PREFETCH
:
546 /* Check the parameters of a function call to CALL_EXPR to see if
547 there are any references in the parameters that are not allowed for
548 pure or const functions. Also check to see if this is either an
549 indirect call, a call outside the compilation unit, or has special
550 attributes that may also effect the purity. The CALL_EXPR node for
551 the entire call expression. */
554 check_call (funct_state local
, gcall
*call
, bool ipa
)
556 int flags
= gimple_call_flags (call
);
557 tree callee_t
= gimple_call_fndecl (call
);
558 bool possibly_throws
= stmt_could_throw_p (call
);
559 bool possibly_throws_externally
= (possibly_throws
560 && stmt_can_throw_external (call
));
565 for (i
= 0; i
< gimple_num_ops (call
); i
++)
566 if (gimple_op (call
, i
)
567 && tree_could_throw_p (gimple_op (call
, i
)))
569 if (possibly_throws
&& cfun
->can_throw_non_call_exceptions
)
572 fprintf (dump_file
, " operand can throw; looping\n");
573 local
->looping
= true;
575 if (possibly_throws_externally
)
578 fprintf (dump_file
, " operand can throw externally\n");
579 local
->can_throw
= true;
584 /* The const and pure flags are set by a variety of places in the
585 compiler (including here). If someone has already set the flags
586 for the callee, (such as for some of the builtins) we will use
587 them, otherwise we will compute our own information.
589 Const and pure functions have less clobber effects than other
590 functions so we process these first. Otherwise if it is a call
591 outside the compilation unit or an indirect call we punt. This
592 leaves local calls which will be processed by following the call
596 enum pure_const_state_e call_state
;
599 if (gimple_call_builtin_p (call
, BUILT_IN_NORMAL
)
600 && !nonfreeing_call_p (call
))
601 local
->can_free
= true;
603 if (special_builtin_state (&call_state
, &call_looping
, callee_t
))
605 worse_state (&local
->pure_const_state
, &local
->looping
,
606 call_state
, call_looping
,
610 /* When bad things happen to bad functions, they cannot be const
612 if (setjmp_call_p (callee_t
))
615 fprintf (dump_file
, " setjmp is not const/pure\n");
616 local
->looping
= true;
617 local
->pure_const_state
= IPA_NEITHER
;
620 if (DECL_BUILT_IN_CLASS (callee_t
) == BUILT_IN_NORMAL
)
621 switch (DECL_FUNCTION_CODE (callee_t
))
623 case BUILT_IN_LONGJMP
:
624 case BUILT_IN_NONLOCAL_GOTO
:
626 fprintf (dump_file
, " longjmp and nonlocal goto is not const/pure\n");
627 local
->pure_const_state
= IPA_NEITHER
;
628 local
->looping
= true;
634 else if (gimple_call_internal_p (call
) && !nonfreeing_call_p (call
))
635 local
->can_free
= true;
637 /* When not in IPA mode, we can still handle self recursion. */
639 && recursive_call_p (current_function_decl
, callee_t
))
642 fprintf (dump_file
, " Recursive call can loop.\n");
643 local
->looping
= true;
645 /* Either callee is unknown or we are doing local analysis.
646 Look to see if there are any bits available for the callee (such as by
647 declaration or because it is builtin) and process solely on the basis of
648 those bits. Handle internal calls always, those calls don't have
649 corresponding cgraph edges and thus aren't processed during
651 else if (!ipa
|| gimple_call_internal_p (call
))
653 enum pure_const_state_e call_state
;
655 if (possibly_throws
&& cfun
->can_throw_non_call_exceptions
)
658 fprintf (dump_file
, " can throw; looping\n");
659 local
->looping
= true;
661 if (possibly_throws_externally
)
665 fprintf (dump_file
, " can throw externally to lp %i\n",
666 lookup_stmt_eh_lp (call
));
668 fprintf (dump_file
, " callee:%s\n",
669 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (callee_t
)));
671 local
->can_throw
= true;
673 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
674 fprintf (dump_file
, " checking flags for call:");
675 state_from_flags (&call_state
, &call_looping
, flags
,
676 ((flags
& (ECF_NORETURN
| ECF_NOTHROW
))
677 == (ECF_NORETURN
| ECF_NOTHROW
))
678 || (!flag_exceptions
&& (flags
& ECF_NORETURN
)));
679 worse_state (&local
->pure_const_state
, &local
->looping
,
680 call_state
, call_looping
, NULL
, NULL
);
682 /* Direct functions calls are handled by IPA propagation. */
685 /* Wrapper around check_decl for loads in local more. */
688 check_load (gimple
*, tree op
, tree
, void *data
)
691 check_decl ((funct_state
)data
, op
, false, false);
693 check_op ((funct_state
)data
, op
, false);
697 /* Wrapper around check_decl for stores in local more. */
700 check_store (gimple
*, tree op
, tree
, void *data
)
703 check_decl ((funct_state
)data
, op
, true, false);
705 check_op ((funct_state
)data
, op
, true);
709 /* Wrapper around check_decl for loads in ipa mode. */
712 check_ipa_load (gimple
*, tree op
, tree
, void *data
)
715 check_decl ((funct_state
)data
, op
, false, true);
717 check_op ((funct_state
)data
, op
, false);
721 /* Wrapper around check_decl for stores in ipa mode. */
724 check_ipa_store (gimple
*, tree op
, tree
, void *data
)
727 check_decl ((funct_state
)data
, op
, true, true);
729 check_op ((funct_state
)data
, op
, true);
733 /* Look into pointer pointed to by GSIP and figure out what interesting side
736 check_stmt (gimple_stmt_iterator
*gsip
, funct_state local
, bool ipa
)
738 gimple
*stmt
= gsi_stmt (*gsip
);
740 if (is_gimple_debug (stmt
))
743 /* Do consider clobber as side effects before IPA, so we rather inline
744 C++ destructors and keep clobber semantics than eliminate them.
746 TODO: We may get smarter during early optimizations on these and let
747 functions containing only clobbers to be optimized more. This is a common
748 case of C++ destructors. */
750 if ((ipa
|| cfun
->after_inlining
) && gimple_clobber_p (stmt
))
755 fprintf (dump_file
, " scanning: ");
756 print_gimple_stmt (dump_file
, stmt
, 0);
759 if (gimple_has_volatile_ops (stmt
)
760 && !gimple_clobber_p (stmt
))
762 local
->pure_const_state
= IPA_NEITHER
;
764 fprintf (dump_file
, " Volatile stmt is not const/pure\n");
767 /* Look for loads and stores. */
768 walk_stmt_load_store_ops (stmt
, local
,
769 ipa
? check_ipa_load
: check_load
,
770 ipa
? check_ipa_store
: check_store
);
772 if (gimple_code (stmt
) != GIMPLE_CALL
773 && stmt_could_throw_p (stmt
))
775 if (cfun
->can_throw_non_call_exceptions
)
778 fprintf (dump_file
, " can throw; looping\n");
779 local
->looping
= true;
781 if (stmt_can_throw_external (stmt
))
784 fprintf (dump_file
, " can throw externally\n");
785 local
->can_throw
= true;
789 fprintf (dump_file
, " can throw\n");
791 switch (gimple_code (stmt
))
794 check_call (local
, as_a
<gcall
*> (stmt
), ipa
);
797 if (DECL_NONLOCAL (gimple_label_label (as_a
<glabel
*> (stmt
))))
798 /* Target of long jump. */
801 fprintf (dump_file
, " nonlocal label is not const/pure\n");
802 local
->pure_const_state
= IPA_NEITHER
;
806 if (gimple_asm_clobbers_memory_p (as_a
<gasm
*> (stmt
)))
809 fprintf (dump_file
, " memory asm clobber is not const/pure\n");
810 /* Abandon all hope, ye who enter here. */
811 local
->pure_const_state
= IPA_NEITHER
;
812 local
->can_free
= true;
814 if (gimple_asm_volatile_p (as_a
<gasm
*> (stmt
)))
817 fprintf (dump_file
, " volatile is not const/pure\n");
818 /* Abandon all hope, ye who enter here. */
819 local
->pure_const_state
= IPA_NEITHER
;
820 local
->looping
= true;
821 local
->can_free
= true;
829 /* Check that RETVAL is used only in STMT and in comparisons against 0.
830 RETVAL is return value of the function and STMT is return stmt. */
833 check_retval_uses (tree retval
, gimple
*stmt
)
835 imm_use_iterator use_iter
;
838 FOR_EACH_IMM_USE_STMT (use_stmt
, use_iter
, retval
)
839 if (gcond
*cond
= dyn_cast
<gcond
*> (use_stmt
))
841 tree op2
= gimple_cond_rhs (cond
);
842 if (!integer_zerop (op2
))
843 RETURN_FROM_IMM_USE_STMT (use_iter
, false);
845 else if (gassign
*ga
= dyn_cast
<gassign
*> (use_stmt
))
847 enum tree_code code
= gimple_assign_rhs_code (ga
);
848 if (TREE_CODE_CLASS (code
) != tcc_comparison
)
849 RETURN_FROM_IMM_USE_STMT (use_iter
, false);
850 if (!integer_zerop (gimple_assign_rhs2 (ga
)))
851 RETURN_FROM_IMM_USE_STMT (use_iter
, false);
853 else if (is_gimple_debug (use_stmt
))
855 else if (use_stmt
!= stmt
)
856 RETURN_FROM_IMM_USE_STMT (use_iter
, false);
861 /* malloc_candidate_p() checks if FUN can possibly be annotated with malloc
862 attribute. Currently this function does a very conservative analysis.
863 FUN is considered to be a candidate if
864 1) It returns a value of pointer type.
865 2) SSA_NAME_DEF_STMT (return_value) is either a function call or
866 a phi, and element of phi is either NULL or
867 SSA_NAME_DEF_STMT(element) is function call.
868 3) The return-value has immediate uses only within comparisons (gcond or gassign)
869 and return_stmt (and likewise a phi arg has immediate use only within comparison
873 malloc_candidate_p (function
*fun
, bool ipa
)
875 basic_block exit_block
= EXIT_BLOCK_PTR_FOR_FN (fun
);
878 cgraph_node
*node
= cgraph_node::get_create (fun
->decl
);
880 #define DUMP_AND_RETURN(reason) \
882 if (dump_file && (dump_flags & TDF_DETAILS)) \
883 fprintf (dump_file, "\n%s is not a malloc candidate, reason: %s\n", \
884 (node->name()), (reason)); \
888 if (EDGE_COUNT (exit_block
->preds
) == 0
889 || !flag_delete_null_pointer_checks
)
892 FOR_EACH_EDGE (e
, ei
, exit_block
->preds
)
894 gimple_stmt_iterator gsi
= gsi_last_bb (e
->src
);
895 greturn
*ret_stmt
= dyn_cast
<greturn
*> (gsi_stmt (gsi
));
900 tree retval
= gimple_return_retval (ret_stmt
);
902 DUMP_AND_RETURN("No return value.")
904 if (TREE_CODE (retval
) != SSA_NAME
905 || TREE_CODE (TREE_TYPE (retval
)) != POINTER_TYPE
)
906 DUMP_AND_RETURN("Return value is not SSA_NAME or not a pointer type.")
908 if (!check_retval_uses (retval
, ret_stmt
))
909 DUMP_AND_RETURN("Return value has uses outside return stmt"
910 " and comparisons against 0.")
912 gimple
*def
= SSA_NAME_DEF_STMT (retval
);
913 if (gcall
*call_stmt
= dyn_cast
<gcall
*> (def
))
915 tree callee_decl
= gimple_call_fndecl (call_stmt
);
919 if (!ipa
&& !DECL_IS_MALLOC (callee_decl
))
920 DUMP_AND_RETURN("callee_decl does not have malloc attribute for"
923 cgraph_edge
*cs
= node
->get_edge (call_stmt
);
926 ipa_call_summary
*es
= ipa_call_summaries
->get_create (cs
);
927 es
->is_return_callee_uncaptured
= true;
931 else if (gphi
*phi
= dyn_cast
<gphi
*> (def
))
933 bool all_args_zero
= true;
934 for (unsigned i
= 0; i
< gimple_phi_num_args (phi
); ++i
)
936 tree arg
= gimple_phi_arg_def (phi
, i
);
937 if (integer_zerop (arg
))
940 all_args_zero
= false;
941 if (TREE_CODE (arg
) != SSA_NAME
)
942 DUMP_AND_RETURN ("phi arg is not SSA_NAME.");
943 if (!check_retval_uses (arg
, phi
))
944 DUMP_AND_RETURN ("phi arg has uses outside phi"
945 " and comparisons against 0.")
947 gimple
*arg_def
= SSA_NAME_DEF_STMT (arg
);
948 gcall
*call_stmt
= dyn_cast
<gcall
*> (arg_def
);
951 tree callee_decl
= gimple_call_fndecl (call_stmt
);
954 if (!ipa
&& !DECL_IS_MALLOC (callee_decl
))
955 DUMP_AND_RETURN("callee_decl does not have malloc attribute"
956 " for non-ipa mode.")
958 cgraph_edge
*cs
= node
->get_edge (call_stmt
);
961 ipa_call_summary
*es
= ipa_call_summaries
->get (cs
);
963 es
->is_return_callee_uncaptured
= true;
968 DUMP_AND_RETURN ("Return value is a phi with all args equal to 0.");
972 DUMP_AND_RETURN("def_stmt of return value is not a call or phi-stmt.")
975 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
976 fprintf (dump_file
, "\nFound %s to be candidate for malloc attribute\n",
977 IDENTIFIER_POINTER (DECL_NAME (fun
->decl
)));
980 #undef DUMP_AND_RETURN
984 /* This is the main routine for finding the reference patterns for
985 global variables within a function FN. */
988 analyze_function (struct cgraph_node
*fn
, bool ipa
)
990 tree decl
= fn
->decl
;
992 basic_block this_block
;
994 l
= XCNEW (struct funct_state_d
);
995 l
->pure_const_state
= IPA_CONST
;
996 l
->state_previously_known
= IPA_NEITHER
;
997 l
->looping_previously_known
= true;
999 l
->can_throw
= false;
1000 l
->can_free
= false;
1001 state_from_flags (&l
->state_previously_known
, &l
->looping_previously_known
,
1002 flags_from_decl_or_type (fn
->decl
),
1003 fn
->cannot_return_p ());
1005 if (fn
->thunk
.thunk_p
|| fn
->alias
)
1007 /* Thunk gets propagated through, so nothing interesting happens. */
1009 if (fn
->thunk
.thunk_p
&& fn
->thunk
.virtual_offset_p
)
1010 l
->pure_const_state
= IPA_NEITHER
;
1016 fprintf (dump_file
, "\n\n local analysis of %s\n ",
1020 push_cfun (DECL_STRUCT_FUNCTION (decl
));
1022 FOR_EACH_BB_FN (this_block
, cfun
)
1024 gimple_stmt_iterator gsi
;
1025 struct walk_stmt_info wi
;
1027 memset (&wi
, 0, sizeof (wi
));
1028 for (gsi
= gsi_start_bb (this_block
);
1032 check_stmt (&gsi
, l
, ipa
);
1033 if (l
->pure_const_state
== IPA_NEITHER
1042 if (l
->pure_const_state
!= IPA_NEITHER
)
1044 /* Const functions cannot have back edges (an
1045 indication of possible infinite loop side
1047 if (mark_dfs_back_edges ())
1049 /* Preheaders are needed for SCEV to work.
1050 Simple latches and recorded exits improve chances that loop will
1051 proved to be finite in testcases such as in loop-15.c
1053 loop_optimizer_init (LOOPS_HAVE_PREHEADERS
1054 | LOOPS_HAVE_SIMPLE_LATCHES
1055 | LOOPS_HAVE_RECORDED_EXITS
);
1056 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1057 flow_loops_dump (dump_file
, NULL
, 0);
1058 if (mark_irreducible_loops ())
1061 fprintf (dump_file
, " has irreducible loops\n");
1068 FOR_EACH_LOOP (loop
, 0)
1069 if (!finite_loop_p (loop
))
1072 fprintf (dump_file
, " can not prove finiteness of "
1073 "loop %i\n", loop
->num
);
1079 loop_optimizer_finalize ();
1083 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1084 fprintf (dump_file
, " checking previously known:");
1086 better_state (&l
->pure_const_state
, &l
->looping
,
1087 l
->state_previously_known
,
1088 l
->looping_previously_known
);
1089 if (TREE_NOTHROW (decl
))
1090 l
->can_throw
= false;
1092 l
->malloc_state
= STATE_MALLOC_BOTTOM
;
1093 if (DECL_IS_MALLOC (decl
))
1094 l
->malloc_state
= STATE_MALLOC
;
1095 else if (ipa
&& malloc_candidate_p (DECL_STRUCT_FUNCTION (decl
), true))
1096 l
->malloc_state
= STATE_MALLOC_TOP
;
1097 else if (malloc_candidate_p (DECL_STRUCT_FUNCTION (decl
), false))
1098 l
->malloc_state
= STATE_MALLOC
;
1104 fprintf (dump_file
, "Function is locally looping.\n");
1106 fprintf (dump_file
, "Function is locally throwing.\n");
1107 if (l
->pure_const_state
== IPA_CONST
)
1108 fprintf (dump_file
, "Function is locally const.\n");
1109 if (l
->pure_const_state
== IPA_PURE
)
1110 fprintf (dump_file
, "Function is locally pure.\n");
1112 fprintf (dump_file
, "Function can locally free.\n");
1113 if (l
->malloc_state
== STATE_MALLOC
)
1114 fprintf (dump_file
, "Function is locally malloc.\n");
1120 funct_state_summary_t::insert (cgraph_node
*node
, funct_state_d
*state
)
1122 /* There are some shared nodes, in particular the initializers on
1123 static declarations. We do not need to scan them more than once
1124 since all we would be interested in are the addressof
1126 if (opt_for_fn (node
->decl
, flag_ipa_pure_const
))
1128 funct_state_d
*a
= analyze_function (node
, true);
1129 new (state
) funct_state_d (*a
);
1134 /* Called when new clone is inserted to callgraph late. */
1137 funct_state_summary_t::duplicate (cgraph_node
*, cgraph_node
*,
1138 funct_state_d
*src_data
,
1139 funct_state_d
*dst_data
)
1141 new (dst_data
) funct_state_d (*src_data
);
1146 pass_ipa_pure_const::
1147 register_hooks (void)
1154 funct_state_summaries
= new funct_state_summary_t (symtab
);
1158 /* Analyze each function in the cgraph to see if it is locally PURE or
1162 pure_const_generate_summary (void)
1164 struct cgraph_node
*node
;
1166 pass_ipa_pure_const
*pass
= static_cast <pass_ipa_pure_const
*> (current_pass
);
1167 pass
->register_hooks ();
1169 /* Process all of the functions.
1171 We process AVAIL_INTERPOSABLE functions. We can not use the results
1172 by default, but the info can be used at LTO with -fwhole-program or
1173 when function got cloned and the clone is AVAILABLE. */
1175 FOR_EACH_DEFINED_FUNCTION (node
)
1176 if (opt_for_fn (node
->decl
, flag_ipa_pure_const
))
1178 funct_state_d
*a
= analyze_function (node
, true);
1179 new (funct_state_summaries
->get_create (node
)) funct_state_d (*a
);
1185 /* Serialize the ipa info for lto. */
1188 pure_const_write_summary (void)
1190 struct cgraph_node
*node
;
1191 struct lto_simple_output_block
*ob
1192 = lto_create_simple_output_block (LTO_section_ipa_pure_const
);
1193 unsigned int count
= 0;
1194 lto_symtab_encoder_iterator lsei
;
1195 lto_symtab_encoder_t encoder
;
1197 encoder
= lto_get_out_decl_state ()->symtab_node_encoder
;
1199 for (lsei
= lsei_start_function_in_partition (encoder
); !lsei_end_p (lsei
);
1200 lsei_next_function_in_partition (&lsei
))
1202 node
= lsei_cgraph_node (lsei
);
1203 if (node
->definition
&& funct_state_summaries
->exists (node
))
1207 streamer_write_uhwi_stream (ob
->main_stream
, count
);
1209 /* Process all of the functions. */
1210 for (lsei
= lsei_start_function_in_partition (encoder
); !lsei_end_p (lsei
);
1211 lsei_next_function_in_partition (&lsei
))
1213 node
= lsei_cgraph_node (lsei
);
1214 funct_state_d
*fs
= funct_state_summaries
->get (node
);
1215 if (node
->definition
&& fs
!= NULL
)
1217 struct bitpack_d bp
;
1219 lto_symtab_encoder_t encoder
;
1221 encoder
= ob
->decl_state
->symtab_node_encoder
;
1222 node_ref
= lto_symtab_encoder_encode (encoder
, node
);
1223 streamer_write_uhwi_stream (ob
->main_stream
, node_ref
);
1225 /* Note that flags will need to be read in the opposite
1226 order as we are pushing the bitflags into FLAGS. */
1227 bp
= bitpack_create (ob
->main_stream
);
1228 bp_pack_value (&bp
, fs
->pure_const_state
, 2);
1229 bp_pack_value (&bp
, fs
->state_previously_known
, 2);
1230 bp_pack_value (&bp
, fs
->looping_previously_known
, 1);
1231 bp_pack_value (&bp
, fs
->looping
, 1);
1232 bp_pack_value (&bp
, fs
->can_throw
, 1);
1233 bp_pack_value (&bp
, fs
->can_free
, 1);
1234 bp_pack_value (&bp
, fs
->malloc_state
, 2);
1235 streamer_write_bitpack (&bp
);
1239 lto_destroy_simple_output_block (ob
);
1243 /* Deserialize the ipa info for lto. */
1246 pure_const_read_summary (void)
1248 struct lto_file_decl_data
**file_data_vec
= lto_get_file_decl_data ();
1249 struct lto_file_decl_data
*file_data
;
1252 pass_ipa_pure_const
*pass
= static_cast <pass_ipa_pure_const
*> (current_pass
);
1253 pass
->register_hooks ();
1255 while ((file_data
= file_data_vec
[j
++]))
1259 struct lto_input_block
*ib
1260 = lto_create_simple_input_block (file_data
,
1261 LTO_section_ipa_pure_const
,
1266 unsigned int count
= streamer_read_uhwi (ib
);
1268 for (i
= 0; i
< count
; i
++)
1271 struct cgraph_node
*node
;
1272 struct bitpack_d bp
;
1274 lto_symtab_encoder_t encoder
;
1276 index
= streamer_read_uhwi (ib
);
1277 encoder
= file_data
->symtab_node_encoder
;
1278 node
= dyn_cast
<cgraph_node
*> (lto_symtab_encoder_deref (encoder
,
1281 fs
= funct_state_summaries
->get_create (node
);
1282 /* Note that the flags must be read in the opposite
1283 order in which they were written (the bitflags were
1284 pushed into FLAGS). */
1285 bp
= streamer_read_bitpack (ib
);
1286 fs
->pure_const_state
1287 = (enum pure_const_state_e
) bp_unpack_value (&bp
, 2);
1288 fs
->state_previously_known
1289 = (enum pure_const_state_e
) bp_unpack_value (&bp
, 2);
1290 fs
->looping_previously_known
= bp_unpack_value (&bp
, 1);
1291 fs
->looping
= bp_unpack_value (&bp
, 1);
1292 fs
->can_throw
= bp_unpack_value (&bp
, 1);
1293 fs
->can_free
= bp_unpack_value (&bp
, 1);
1295 = (enum malloc_state_e
) bp_unpack_value (&bp
, 2);
1299 int flags
= flags_from_decl_or_type (node
->decl
);
1300 fprintf (dump_file
, "Read info for %s ", node
->dump_name ());
1301 if (flags
& ECF_CONST
)
1302 fprintf (dump_file
, " const");
1303 if (flags
& ECF_PURE
)
1304 fprintf (dump_file
, " pure");
1305 if (flags
& ECF_NOTHROW
)
1306 fprintf (dump_file
, " nothrow");
1307 fprintf (dump_file
, "\n pure const state: %s\n",
1308 pure_const_names
[fs
->pure_const_state
]);
1309 fprintf (dump_file
, " previously known state: %s\n",
1310 pure_const_names
[fs
->state_previously_known
]);
1312 fprintf (dump_file
," function is locally looping\n");
1313 if (fs
->looping_previously_known
)
1314 fprintf (dump_file
," function is previously known looping\n");
1316 fprintf (dump_file
," function is locally throwing\n");
1318 fprintf (dump_file
," function can locally free\n");
1319 fprintf (dump_file
, "\n malloc state: %s\n",
1320 malloc_state_names
[fs
->malloc_state
]);
1324 lto_destroy_simple_input_block (file_data
,
1325 LTO_section_ipa_pure_const
,
1331 /* We only propagate across edges that can throw externally and their callee
1332 is not interposable. */
1335 ignore_edge_for_nothrow (struct cgraph_edge
*e
)
1337 if (!e
->can_throw_external
|| TREE_NOTHROW (e
->callee
->decl
))
1340 enum availability avail
;
1341 cgraph_node
*n
= e
->callee
->function_or_virtual_thunk_symbol (&avail
,
1343 if (avail
<= AVAIL_INTERPOSABLE
|| TREE_NOTHROW (n
->decl
))
1345 return opt_for_fn (e
->callee
->decl
, flag_non_call_exceptions
)
1346 && !e
->callee
->binds_to_current_def_p (e
->caller
);
1349 /* Return true if NODE is self recursive function.
1350 Indirectly recursive functions appears as non-trivial strongly
1351 connected components, so we need to care about self recursion
1355 self_recursive_p (struct cgraph_node
*node
)
1357 struct cgraph_edge
*e
;
1358 for (e
= node
->callees
; e
; e
= e
->next_callee
)
1359 if (e
->callee
->function_symbol () == node
)
1364 /* Return true if N is cdtor that is not const or pure. In this case we may
1365 need to remove unreachable function if it is marked const/pure. */
1368 cdtor_p (cgraph_node
*n
, void *)
1370 if (DECL_STATIC_CONSTRUCTOR (n
->decl
) || DECL_STATIC_DESTRUCTOR (n
->decl
))
1371 return ((!TREE_READONLY (n
->decl
) && !DECL_PURE_P (n
->decl
))
1372 || DECL_LOOPING_CONST_OR_PURE_P (n
->decl
));
1376 /* We only propagate across edges with non-interposable callee. */
1379 ignore_edge_for_pure_const (struct cgraph_edge
*e
)
1381 enum availability avail
;
1382 e
->callee
->function_or_virtual_thunk_symbol (&avail
, e
->caller
);
1383 return (avail
<= AVAIL_INTERPOSABLE
);
1387 /* Produce transitive closure over the callgraph and compute pure/const
1391 propagate_pure_const (void)
1393 struct cgraph_node
*node
;
1394 struct cgraph_node
*w
;
1395 struct cgraph_node
**order
=
1396 XCNEWVEC (struct cgraph_node
*, symtab
->cgraph_count
);
1399 struct ipa_dfs_info
* w_info
;
1400 bool remove_p
= false;
1403 order_pos
= ipa_reduced_postorder (order
, true, false,
1404 ignore_edge_for_pure_const
);
1407 cgraph_node::dump_cgraph (dump_file
);
1408 ipa_print_order (dump_file
, "reduced", order
, order_pos
);
1411 /* Propagate the local information through the call graph to produce
1412 the global information. All the nodes within a cycle will have
1413 the same info so we collapse cycles first. Then we can do the
1414 propagation in one pass from the leaves to the roots. */
1415 for (i
= 0; i
< order_pos
; i
++ )
1417 enum pure_const_state_e pure_const_state
= IPA_CONST
;
1418 bool looping
= false;
1425 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1426 fprintf (dump_file
, "Starting cycle\n");
1428 /* Find the worst state for any node in the cycle. */
1430 while (w
&& pure_const_state
!= IPA_NEITHER
)
1432 struct cgraph_edge
*e
;
1433 struct cgraph_edge
*ie
;
1435 struct ipa_ref
*ref
= NULL
;
1437 funct_state w_l
= funct_state_summaries
->get_create (w
);
1438 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1439 fprintf (dump_file
, " Visiting %s state:%s looping %i\n",
1441 pure_const_names
[w_l
->pure_const_state
],
1444 /* First merge in function body properties.
1445 We are safe to pass NULL as FROM and TO because we will take care
1446 of possible interposition when walking callees. */
1447 worse_state (&pure_const_state
, &looping
,
1448 w_l
->pure_const_state
, w_l
->looping
,
1450 if (pure_const_state
== IPA_NEITHER
)
1455 /* We consider recursive cycles as possibly infinite.
1456 This might be relaxed since infinite recursion leads to stack
1461 /* Now walk the edges and merge in callee properties. */
1462 for (e
= w
->callees
; e
&& pure_const_state
!= IPA_NEITHER
;
1465 enum availability avail
;
1466 struct cgraph_node
*y
= e
->callee
->
1467 function_or_virtual_thunk_symbol (&avail
,
1469 enum pure_const_state_e edge_state
= IPA_CONST
;
1470 bool edge_looping
= false;
1472 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1474 fprintf (dump_file
, " Call to %s",
1475 e
->callee
->dump_name ());
1477 if (avail
> AVAIL_INTERPOSABLE
)
1479 funct_state y_l
= funct_state_summaries
->get (y
);
1480 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1483 " state:%s looping:%i\n",
1484 pure_const_names
[y_l
->pure_const_state
],
1487 if (y_l
->pure_const_state
> IPA_PURE
1488 && e
->cannot_lead_to_return_p ())
1490 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1492 " Ignoring side effects"
1493 " -> pure, looping\n");
1494 edge_state
= IPA_PURE
;
1495 edge_looping
= true;
1499 edge_state
= y_l
->pure_const_state
;
1500 edge_looping
= y_l
->looping
;
1503 else if (special_builtin_state (&edge_state
, &edge_looping
,
1507 state_from_flags (&edge_state
, &edge_looping
,
1508 flags_from_decl_or_type (y
->decl
),
1509 e
->cannot_lead_to_return_p ());
1511 /* Merge the results with what we already know. */
1512 better_state (&edge_state
, &edge_looping
,
1513 w_l
->state_previously_known
,
1514 w_l
->looping_previously_known
);
1515 worse_state (&pure_const_state
, &looping
,
1516 edge_state
, edge_looping
, e
->caller
, e
->callee
);
1517 if (pure_const_state
== IPA_NEITHER
)
1521 /* Now process the indirect call. */
1522 for (ie
= w
->indirect_calls
;
1523 ie
&& pure_const_state
!= IPA_NEITHER
; ie
= ie
->next_callee
)
1525 enum pure_const_state_e edge_state
= IPA_CONST
;
1526 bool edge_looping
= false;
1528 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1529 fprintf (dump_file
, " Indirect call");
1530 state_from_flags (&edge_state
, &edge_looping
,
1531 ie
->indirect_info
->ecf_flags
,
1532 ie
->cannot_lead_to_return_p ());
1533 /* Merge the results with what we already know. */
1534 better_state (&edge_state
, &edge_looping
,
1535 w_l
->state_previously_known
,
1536 w_l
->looping_previously_known
);
1537 worse_state (&pure_const_state
, &looping
,
1538 edge_state
, edge_looping
, NULL
, NULL
);
1539 if (pure_const_state
== IPA_NEITHER
)
1543 /* And finally all loads and stores. */
1544 for (i
= 0; w
->iterate_reference (i
, ref
)
1545 && pure_const_state
!= IPA_NEITHER
; i
++)
1547 enum pure_const_state_e ref_state
= IPA_CONST
;
1548 bool ref_looping
= false;
1552 /* readonly reads are safe. */
1553 if (TREE_READONLY (ref
->referred
->decl
))
1555 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1556 fprintf (dump_file
, " nonreadonly global var read\n");
1557 ref_state
= IPA_PURE
;
1560 if (ref
->cannot_lead_to_return ())
1562 ref_state
= IPA_NEITHER
;
1563 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1564 fprintf (dump_file
, " global var write\n");
1571 better_state (&ref_state
, &ref_looping
,
1572 w_l
->state_previously_known
,
1573 w_l
->looping_previously_known
);
1574 worse_state (&pure_const_state
, &looping
,
1575 ref_state
, ref_looping
, NULL
, NULL
);
1576 if (pure_const_state
== IPA_NEITHER
)
1579 w_info
= (struct ipa_dfs_info
*) w
->aux
;
1580 w
= w_info
->next_cycle
;
1582 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1583 fprintf (dump_file
, "Result %s looping %i\n",
1584 pure_const_names
[pure_const_state
],
1587 /* Find the worst state of can_free for any node in the cycle. */
1588 bool can_free
= false;
1590 while (w
&& !can_free
)
1592 struct cgraph_edge
*e
;
1593 funct_state w_l
= funct_state_summaries
->get (w
);
1596 || w
->get_availability () == AVAIL_INTERPOSABLE
1597 || w
->indirect_calls
)
1600 for (e
= w
->callees
; e
&& !can_free
; e
= e
->next_callee
)
1602 enum availability avail
;
1603 struct cgraph_node
*y
= e
->callee
->
1604 function_or_virtual_thunk_symbol (&avail
,
1607 if (avail
> AVAIL_INTERPOSABLE
)
1608 can_free
= funct_state_summaries
->get (y
)->can_free
;
1612 w_info
= (struct ipa_dfs_info
*) w
->aux
;
1613 w
= w_info
->next_cycle
;
1616 /* Copy back the region's pure_const_state which is shared by
1617 all nodes in the region. */
1621 funct_state w_l
= funct_state_summaries
->get (w
);
1622 enum pure_const_state_e this_state
= pure_const_state
;
1623 bool this_looping
= looping
;
1625 w_l
->can_free
= can_free
;
1626 w
->nonfreeing_fn
= !can_free
;
1627 if (!can_free
&& dump_file
)
1628 fprintf (dump_file
, "Function found not to call free: %s\n",
1631 if (w_l
->state_previously_known
!= IPA_NEITHER
1632 && this_state
> w_l
->state_previously_known
)
1634 this_state
= w_l
->state_previously_known
;
1635 if (this_state
== IPA_NEITHER
)
1636 this_looping
= w_l
->looping_previously_known
;
1638 if (!this_looping
&& self_recursive_p (w
))
1639 this_looping
= true;
1640 if (!w_l
->looping_previously_known
)
1641 this_looping
= false;
1643 /* All nodes within a cycle share the same info. */
1644 w_l
->pure_const_state
= this_state
;
1645 w_l
->looping
= this_looping
;
1647 /* Inline clones share declaration with their offline copies;
1648 do not modify their declarations since the offline copy may
1650 if (!w
->global
.inlined_to
)
1654 if (!TREE_READONLY (w
->decl
))
1656 warn_function_const (w
->decl
, !this_looping
);
1658 fprintf (dump_file
, "Function found to be %sconst: %s\n",
1659 this_looping
? "looping " : "",
1662 /* Turning constructor or destructor to non-looping const/pure
1663 enables us to possibly remove the function completely. */
1667 has_cdtor
= w
->call_for_symbol_and_aliases (cdtor_p
,
1669 if (w
->set_const_flag (true, this_looping
))
1673 "Declaration updated to be %sconst: %s\n",
1674 this_looping
? "looping " : "",
1676 remove_p
|= has_cdtor
;
1681 if (!DECL_PURE_P (w
->decl
))
1683 warn_function_pure (w
->decl
, !this_looping
);
1685 fprintf (dump_file
, "Function found to be %spure: %s\n",
1686 this_looping
? "looping " : "",
1692 has_cdtor
= w
->call_for_symbol_and_aliases (cdtor_p
,
1694 if (w
->set_pure_flag (true, this_looping
))
1698 "Declaration updated to be %spure: %s\n",
1699 this_looping
? "looping " : "",
1701 remove_p
|= has_cdtor
;
1708 w_info
= (struct ipa_dfs_info
*) w
->aux
;
1709 w
= w_info
->next_cycle
;
1713 ipa_free_postorder_info ();
1718 /* Produce transitive closure over the callgraph and compute nothrow
1722 propagate_nothrow (void)
1724 struct cgraph_node
*node
;
1725 struct cgraph_node
*w
;
1726 struct cgraph_node
**order
=
1727 XCNEWVEC (struct cgraph_node
*, symtab
->cgraph_count
);
1730 struct ipa_dfs_info
* w_info
;
1732 order_pos
= ipa_reduced_postorder (order
, true, false,
1733 ignore_edge_for_nothrow
);
1736 cgraph_node::dump_cgraph (dump_file
);
1737 ipa_print_order (dump_file
, "reduced for nothrow", order
, order_pos
);
1740 /* Propagate the local information through the call graph to produce
1741 the global information. All the nodes within a cycle will have
1742 the same info so we collapse cycles first. Then we can do the
1743 propagation in one pass from the leaves to the roots. */
1744 for (i
= 0; i
< order_pos
; i
++ )
1746 bool can_throw
= false;
1752 /* Find the worst state for any node in the cycle. */
1754 while (w
&& !can_throw
)
1756 struct cgraph_edge
*e
, *ie
;
1758 if (!TREE_NOTHROW (w
->decl
))
1760 funct_state w_l
= funct_state_summaries
->get_create (w
);
1763 || w
->get_availability () == AVAIL_INTERPOSABLE
)
1766 for (e
= w
->callees
; e
&& !can_throw
; e
= e
->next_callee
)
1768 enum availability avail
;
1770 if (!e
->can_throw_external
|| TREE_NOTHROW (e
->callee
->decl
))
1773 struct cgraph_node
*y
= e
->callee
->
1774 function_or_virtual_thunk_symbol (&avail
,
1777 /* We can use info about the callee only if we know it can
1779 When callee is compiled with non-call exceptions we also
1780 must check that the declaration is bound to current
1781 body as other semantically equivalent body may still
1783 if (avail
<= AVAIL_INTERPOSABLE
1784 || (!TREE_NOTHROW (y
->decl
)
1785 && (funct_state_summaries
->get_create (y
)->can_throw
1786 || (opt_for_fn (y
->decl
, flag_non_call_exceptions
)
1787 && !e
->callee
->binds_to_current_def_p (w
)))))
1790 for (ie
= w
->indirect_calls
; ie
&& !can_throw
;
1791 ie
= ie
->next_callee
)
1792 if (ie
->can_throw_external
1793 && !(ie
->indirect_info
->ecf_flags
& ECF_NOTHROW
))
1796 w_info
= (struct ipa_dfs_info
*) w
->aux
;
1797 w
= w_info
->next_cycle
;
1800 /* Copy back the region's pure_const_state which is shared by
1801 all nodes in the region. */
1805 funct_state w_l
= funct_state_summaries
->get_create (w
);
1806 if (!can_throw
&& !TREE_NOTHROW (w
->decl
))
1808 /* Inline clones share declaration with their offline copies;
1809 do not modify their declarations since the offline copy may
1811 if (!w
->global
.inlined_to
)
1813 w
->set_nothrow_flag (true);
1815 fprintf (dump_file
, "Function found to be nothrow: %s\n",
1819 else if (can_throw
&& !TREE_NOTHROW (w
->decl
))
1820 w_l
->can_throw
= true;
1821 w_info
= (struct ipa_dfs_info
*) w
->aux
;
1822 w
= w_info
->next_cycle
;
1826 ipa_free_postorder_info ();
1830 /* Debugging function to dump state of malloc lattice. */
1834 dump_malloc_lattice (FILE *dump_file
, const char *s
)
1839 fprintf (dump_file
, "\n\nMALLOC LATTICE %s:\n", s
);
1841 FOR_EACH_FUNCTION (node
)
1843 funct_state fs
= funct_state_summaries
->get (node
);
1845 fprintf (dump_file
, "%s: %s\n", node
->name (),
1846 malloc_state_names
[fs
->malloc_state
]);
1850 /* Propagate malloc attribute across the callgraph. */
1853 propagate_malloc (void)
1856 FOR_EACH_FUNCTION (node
)
1858 if (DECL_IS_MALLOC (node
->decl
))
1859 if (!funct_state_summaries
->exists (node
))
1861 funct_state fs
= funct_state_summaries
->get_create (node
);
1862 fs
->malloc_state
= STATE_MALLOC
;
1866 dump_malloc_lattice (dump_file
, "Initial");
1867 struct cgraph_node
**order
1868 = XNEWVEC (struct cgraph_node
*, symtab
->cgraph_count
);
1869 int order_pos
= ipa_reverse_postorder (order
);
1870 bool changed
= true;
1875 /* Walk in postorder. */
1876 for (int i
= order_pos
- 1; i
>= 0; --i
)
1878 cgraph_node
*node
= order
[i
];
1880 || !node
->definition
1881 || !funct_state_summaries
->exists (node
))
1884 funct_state l
= funct_state_summaries
->get (node
);
1886 /* FIXME: add support for indirect-calls. */
1887 if (node
->indirect_calls
)
1889 l
->malloc_state
= STATE_MALLOC_BOTTOM
;
1893 if (node
->get_availability () <= AVAIL_INTERPOSABLE
)
1895 l
->malloc_state
= STATE_MALLOC_BOTTOM
;
1899 if (l
->malloc_state
== STATE_MALLOC_BOTTOM
)
1902 vec
<cgraph_node
*> callees
= vNULL
;
1903 for (cgraph_edge
*cs
= node
->callees
; cs
; cs
= cs
->next_callee
)
1905 ipa_call_summary
*es
= ipa_call_summaries
->get_create (cs
);
1906 if (es
&& es
->is_return_callee_uncaptured
)
1907 callees
.safe_push (cs
->callee
);
1910 malloc_state_e new_state
= l
->malloc_state
;
1911 for (unsigned j
= 0; j
< callees
.length (); j
++)
1913 cgraph_node
*callee
= callees
[j
];
1914 if (!funct_state_summaries
->exists (node
))
1916 new_state
= STATE_MALLOC_BOTTOM
;
1919 malloc_state_e callee_state
1920 = funct_state_summaries
->get_create (callee
)->malloc_state
;
1921 if (new_state
< callee_state
)
1922 new_state
= callee_state
;
1924 if (new_state
!= l
->malloc_state
)
1927 l
->malloc_state
= new_state
;
1932 FOR_EACH_DEFINED_FUNCTION (node
)
1933 if (funct_state_summaries
->exists (node
))
1935 funct_state l
= funct_state_summaries
->get (node
);
1937 && l
->malloc_state
== STATE_MALLOC
1938 && !node
->global
.inlined_to
)
1940 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1941 fprintf (dump_file
, "Function %s found to be malloc\n",
1944 bool malloc_decl_p
= DECL_IS_MALLOC (node
->decl
);
1945 node
->set_malloc_flag (true);
1946 if (!malloc_decl_p
&& warn_suggest_attribute_malloc
)
1947 warn_function_malloc (node
->decl
);
1951 dump_malloc_lattice (dump_file
, "after propagation");
1952 ipa_free_postorder_info ();
1956 /* Produce the global information by preforming a transitive closure
1957 on the local information that was produced by generate_summary. */
1960 pass_ipa_pure_const::
1961 execute (function
*)
1965 /* Nothrow makes more function to not lead to return and improve
1967 propagate_nothrow ();
1968 propagate_malloc ();
1969 remove_p
= propagate_pure_const ();
1971 delete funct_state_summaries
;
1972 return remove_p
? TODO_remove_functions
: 0;
1976 gate_pure_const (void)
1978 return flag_ipa_pure_const
|| in_lto_p
;
1981 pass_ipa_pure_const::pass_ipa_pure_const(gcc::context
*ctxt
)
1982 : ipa_opt_pass_d(pass_data_ipa_pure_const
, ctxt
,
1983 pure_const_generate_summary
, /* generate_summary */
1984 pure_const_write_summary
, /* write_summary */
1985 pure_const_read_summary
, /* read_summary */
1986 NULL
, /* write_optimization_summary */
1987 NULL
, /* read_optimization_summary */
1988 NULL
, /* stmt_fixup */
1989 0, /* function_transform_todo_flags_start */
1990 NULL
, /* function_transform */
1991 NULL
), /* variable_transform */
1995 make_pass_ipa_pure_const (gcc::context
*ctxt
)
1997 return new pass_ipa_pure_const (ctxt
);
2000 /* Return true if function should be skipped for local pure const analysis. */
2003 skip_function_for_local_pure_const (struct cgraph_node
*node
)
2005 /* Because we do not schedule pass_fixup_cfg over whole program after early
2006 optimizations we must not promote functions that are called by already
2007 processed functions. */
2009 if (function_called_by_processed_nodes_p ())
2012 fprintf (dump_file
, "Function called in recursive cycle; ignoring\n");
2015 /* Save some work and do not analyze functions which are interposable and
2016 do not have any non-interposable aliases. */
2017 if (node
->get_availability () <= AVAIL_INTERPOSABLE
2018 && !node
->has_aliases_p ())
2022 "Function is interposable; not analyzing.\n");
2028 /* Simple local pass for pure const discovery reusing the analysis from
2029 ipa_pure_const. This pass is effective when executed together with
2030 other optimization passes in early optimization pass queue. */
2034 const pass_data pass_data_local_pure_const
=
2036 GIMPLE_PASS
, /* type */
2037 "local-pure-const", /* name */
2038 OPTGROUP_NONE
, /* optinfo_flags */
2039 TV_IPA_PURE_CONST
, /* tv_id */
2040 0, /* properties_required */
2041 0, /* properties_provided */
2042 0, /* properties_destroyed */
2043 0, /* todo_flags_start */
2044 0, /* todo_flags_finish */
2047 class pass_local_pure_const
: public gimple_opt_pass
2050 pass_local_pure_const (gcc::context
*ctxt
)
2051 : gimple_opt_pass (pass_data_local_pure_const
, ctxt
)
2054 /* opt_pass methods: */
2055 opt_pass
* clone () { return new pass_local_pure_const (m_ctxt
); }
2056 virtual bool gate (function
*) { return gate_pure_const (); }
2057 virtual unsigned int execute (function
*);
2059 }; // class pass_local_pure_const
2062 pass_local_pure_const::execute (function
*fun
)
2064 bool changed
= false;
2067 struct cgraph_node
*node
;
2069 node
= cgraph_node::get (current_function_decl
);
2070 skip
= skip_function_for_local_pure_const (node
);
2072 if (!warn_suggest_attribute_const
2073 && !warn_suggest_attribute_pure
2077 l
= analyze_function (node
, false);
2079 /* Do NORETURN discovery. */
2080 if (!skip
&& !TREE_THIS_VOLATILE (current_function_decl
)
2081 && EDGE_COUNT (EXIT_BLOCK_PTR_FOR_FN (fun
)->preds
) == 0)
2083 warn_function_noreturn (fun
->decl
);
2085 fprintf (dump_file
, "Function found to be noreturn: %s\n",
2086 current_function_name ());
2088 /* Update declaration and reduce profile to executed once. */
2089 TREE_THIS_VOLATILE (current_function_decl
) = 1;
2090 if (node
->frequency
> NODE_FREQUENCY_EXECUTED_ONCE
)
2091 node
->frequency
= NODE_FREQUENCY_EXECUTED_ONCE
;
2096 switch (l
->pure_const_state
)
2099 if (!TREE_READONLY (current_function_decl
))
2101 warn_function_const (current_function_decl
, !l
->looping
);
2103 fprintf (dump_file
, "Function found to be %sconst: %s\n",
2104 l
->looping
? "looping " : "",
2105 current_function_name ());
2107 else if (DECL_LOOPING_CONST_OR_PURE_P (current_function_decl
)
2111 fprintf (dump_file
, "Function found to be non-looping: %s\n",
2112 current_function_name ());
2114 if (!skip
&& node
->set_const_flag (true, l
->looping
))
2117 fprintf (dump_file
, "Declaration updated to be %sconst: %s\n",
2118 l
->looping
? "looping " : "",
2119 current_function_name ());
2125 if (!DECL_PURE_P (current_function_decl
))
2127 warn_function_pure (current_function_decl
, !l
->looping
);
2129 fprintf (dump_file
, "Function found to be %spure: %s\n",
2130 l
->looping
? "looping " : "",
2131 current_function_name ());
2133 else if (DECL_LOOPING_CONST_OR_PURE_P (current_function_decl
)
2137 fprintf (dump_file
, "Function found to be non-looping: %s\n",
2138 current_function_name ());
2140 if (!skip
&& node
->set_pure_flag (true, l
->looping
))
2143 fprintf (dump_file
, "Declaration updated to be %spure: %s\n",
2144 l
->looping
? "looping " : "",
2145 current_function_name ());
2153 if (!l
->can_throw
&& !TREE_NOTHROW (current_function_decl
))
2155 node
->set_nothrow_flag (true);
2158 fprintf (dump_file
, "Function found to be nothrow: %s\n",
2159 current_function_name ());
2162 if (l
->malloc_state
== STATE_MALLOC
2163 && !DECL_IS_MALLOC (current_function_decl
))
2165 node
->set_malloc_flag (true);
2166 if (warn_suggest_attribute_malloc
)
2167 warn_function_malloc (node
->decl
);
2170 fprintf (dump_file
, "Function found to be malloc: %s\n",
2176 return execute_fixup_cfg ();
2184 make_pass_local_pure_const (gcc::context
*ctxt
)
2186 return new pass_local_pure_const (ctxt
);
2189 /* Emit noreturn warnings. */
2193 const pass_data pass_data_warn_function_noreturn
=
2195 GIMPLE_PASS
, /* type */
2196 "*warn_function_noreturn", /* name */
2197 OPTGROUP_NONE
, /* optinfo_flags */
2198 TV_NONE
, /* tv_id */
2199 PROP_cfg
, /* properties_required */
2200 0, /* properties_provided */
2201 0, /* properties_destroyed */
2202 0, /* todo_flags_start */
2203 0, /* todo_flags_finish */
2206 class pass_warn_function_noreturn
: public gimple_opt_pass
2209 pass_warn_function_noreturn (gcc::context
*ctxt
)
2210 : gimple_opt_pass (pass_data_warn_function_noreturn
, ctxt
)
2213 /* opt_pass methods: */
2214 virtual bool gate (function
*) { return warn_suggest_attribute_noreturn
; }
2215 virtual unsigned int execute (function
*fun
)
2217 if (!TREE_THIS_VOLATILE (current_function_decl
)
2218 && EDGE_COUNT (EXIT_BLOCK_PTR_FOR_FN (fun
)->preds
) == 0)
2219 warn_function_noreturn (current_function_decl
);
2223 }; // class pass_warn_function_noreturn
2228 make_pass_warn_function_noreturn (gcc::context
*ctxt
)
2230 return new pass_warn_function_noreturn (ctxt
);
2233 /* Simple local pass for pure const discovery reusing the analysis from
2234 ipa_pure_const. This pass is effective when executed together with
2235 other optimization passes in early optimization pass queue. */
2239 const pass_data pass_data_nothrow
=
2241 GIMPLE_PASS
, /* type */
2242 "nothrow", /* name */
2243 OPTGROUP_NONE
, /* optinfo_flags */
2244 TV_IPA_PURE_CONST
, /* tv_id */
2245 0, /* properties_required */
2246 0, /* properties_provided */
2247 0, /* properties_destroyed */
2248 0, /* todo_flags_start */
2249 0, /* todo_flags_finish */
2252 class pass_nothrow
: public gimple_opt_pass
2255 pass_nothrow (gcc::context
*ctxt
)
2256 : gimple_opt_pass (pass_data_nothrow
, ctxt
)
2259 /* opt_pass methods: */
2260 opt_pass
* clone () { return new pass_nothrow (m_ctxt
); }
2261 virtual bool gate (function
*) { return optimize
; }
2262 virtual unsigned int execute (function
*);
2264 }; // class pass_nothrow
2267 pass_nothrow::execute (function
*)
2269 struct cgraph_node
*node
;
2270 basic_block this_block
;
2272 if (TREE_NOTHROW (current_function_decl
))
2275 node
= cgraph_node::get (current_function_decl
);
2277 /* We run during lowering, we can not really use availability yet. */
2278 if (cgraph_node::get (current_function_decl
)->get_availability ()
2279 <= AVAIL_INTERPOSABLE
)
2282 fprintf (dump_file
, "Function is interposable;"
2283 " not analyzing.\n");
2287 FOR_EACH_BB_FN (this_block
, cfun
)
2289 for (gimple_stmt_iterator gsi
= gsi_start_bb (this_block
);
2292 if (stmt_can_throw_external (gsi_stmt (gsi
)))
2294 if (is_gimple_call (gsi_stmt (gsi
)))
2296 tree callee_t
= gimple_call_fndecl (gsi_stmt (gsi
));
2297 if (callee_t
&& recursive_call_p (current_function_decl
,
2304 fprintf (dump_file
, "Statement can throw: ");
2305 print_gimple_stmt (dump_file
, gsi_stmt (gsi
), 0);
2311 node
->set_nothrow_flag (true);
2313 bool cfg_changed
= false;
2314 if (self_recursive_p (node
))
2315 FOR_EACH_BB_FN (this_block
, cfun
)
2316 if (gimple
*g
= last_stmt (this_block
))
2317 if (is_gimple_call (g
))
2319 tree callee_t
= gimple_call_fndecl (g
);
2321 && recursive_call_p (current_function_decl
, callee_t
)
2322 && maybe_clean_eh_stmt (g
)
2323 && gimple_purge_dead_eh_edges (this_block
))
2328 fprintf (dump_file
, "Function found to be nothrow: %s\n",
2329 current_function_name ());
2330 return cfg_changed
? TODO_cleanup_cfg
: 0;
2336 make_pass_nothrow (gcc::context
*ctxt
)
2338 return new pass_nothrow (ctxt
);