1 /* Callgraph based analysis of static variables.
2 Copyright (C) 2004-2020 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 class 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
:
132 public fast_function_summary
<funct_state_d
*, va_heap
>
135 funct_state_summary_t (symbol_table
*symtab
):
136 fast_function_summary
<funct_state_d
*, va_heap
> (symtab
) {}
138 virtual void insert (cgraph_node
*, funct_state_d
*state
);
139 virtual void duplicate (cgraph_node
*src_node
, cgraph_node
*dst_node
,
140 funct_state_d
*src_data
,
141 funct_state_d
*dst_data
);
144 static funct_state_summary_t
*funct_state_summaries
= NULL
;
146 static bool gate_pure_const (void);
150 const pass_data pass_data_ipa_pure_const
=
153 "pure-const", /* name */
154 OPTGROUP_NONE
, /* optinfo_flags */
155 TV_IPA_PURE_CONST
, /* tv_id */
156 0, /* properties_required */
157 0, /* properties_provided */
158 0, /* properties_destroyed */
159 0, /* todo_flags_start */
160 0, /* todo_flags_finish */
163 class pass_ipa_pure_const
: public ipa_opt_pass_d
166 pass_ipa_pure_const(gcc::context
*ctxt
);
168 /* opt_pass methods: */
169 bool gate (function
*) { return gate_pure_const (); }
170 unsigned int execute (function
*fun
);
172 void register_hooks (void);
176 }; // class pass_ipa_pure_const
180 /* Try to guess if function body will always be visible to compiler
181 when compiling the call and whether compiler will be able
182 to propagate the information by itself. */
185 function_always_visible_to_compiler_p (tree decl
)
187 return (!TREE_PUBLIC (decl
) || DECL_DECLARED_INLINE_P (decl
)
188 || DECL_COMDAT (decl
));
191 /* Emit suggestion about attribute ATTRIB_NAME for DECL. KNOWN_FINITE
192 is true if the function is known to be finite. The diagnostic is
193 controlled by OPTION. WARNED_ABOUT is a hash_set<tree> unique for
194 OPTION, this function may initialize it and it is always returned
197 static hash_set
<tree
> *
198 suggest_attribute (int option
, tree decl
, bool known_finite
,
199 hash_set
<tree
> *warned_about
,
200 const char * attrib_name
)
202 if (!option_enabled (option
, lang_hooks
.option_lang_mask (), &global_options
))
204 if (TREE_THIS_VOLATILE (decl
)
205 || (known_finite
&& function_always_visible_to_compiler_p (decl
)))
209 warned_about
= new hash_set
<tree
>;
210 if (warned_about
->contains (decl
))
212 warned_about
->add (decl
);
213 warning_at (DECL_SOURCE_LOCATION (decl
),
216 ? G_("function might be candidate for attribute %qs")
217 : G_("function might be candidate for attribute %qs"
218 " if it is known to return normally"), attrib_name
);
222 /* Emit suggestion about __attribute_((pure)) for DECL. KNOWN_FINITE
223 is true if the function is known to be finite. */
226 warn_function_pure (tree decl
, bool known_finite
)
228 /* Declaring a void function pure makes no sense and is diagnosed
229 by -Wattributes because calling it would have no effect. */
230 if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl
))))
233 static hash_set
<tree
> *warned_about
;
235 = suggest_attribute (OPT_Wsuggest_attribute_pure
, decl
,
236 known_finite
, warned_about
, "pure");
239 /* Emit suggestion about __attribute_((const)) for DECL. KNOWN_FINITE
240 is true if the function is known to be finite. */
243 warn_function_const (tree decl
, bool known_finite
)
245 /* Declaring a void function const makes no sense is diagnosed
246 by -Wattributes because calling it would have no effect. */
247 if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl
))))
250 static hash_set
<tree
> *warned_about
;
252 = suggest_attribute (OPT_Wsuggest_attribute_const
, decl
,
253 known_finite
, warned_about
, "const");
256 /* Emit suggestion about __attribute__((malloc)) for DECL. */
259 warn_function_malloc (tree decl
)
261 static hash_set
<tree
> *warned_about
;
263 = suggest_attribute (OPT_Wsuggest_attribute_malloc
, decl
,
264 true, warned_about
, "malloc");
267 /* Emit suggestion about __attribute__((noreturn)) for DECL. */
270 warn_function_noreturn (tree decl
)
272 tree original_decl
= decl
;
274 static hash_set
<tree
> *warned_about
;
275 if (!lang_hooks
.missing_noreturn_ok_p (decl
)
276 && targetm
.warn_func_return (decl
))
278 = suggest_attribute (OPT_Wsuggest_attribute_noreturn
, original_decl
,
279 true, warned_about
, "noreturn");
283 warn_function_cold (tree decl
)
285 tree original_decl
= decl
;
287 static hash_set
<tree
> *warned_about
;
289 = suggest_attribute (OPT_Wsuggest_attribute_cold
, original_decl
,
290 true, warned_about
, "cold");
293 /* Check to see if the use (or definition when CHECKING_WRITE is true)
294 variable T is legal in a function that is either pure or const. */
297 check_decl (funct_state local
,
298 tree t
, bool checking_write
, bool ipa
)
300 /* Do not want to do anything with volatile except mark any
301 function that uses one to be not const or pure. */
302 if (TREE_THIS_VOLATILE (t
))
304 local
->pure_const_state
= IPA_NEITHER
;
306 fprintf (dump_file
, " Volatile operand is not const/pure\n");
310 /* Do not care about a local automatic that is not static. */
311 if (!TREE_STATIC (t
) && !DECL_EXTERNAL (t
))
314 /* If the variable has the "used" attribute, treat it as if it had a
315 been touched by the devil. */
316 if (DECL_PRESERVE_P (t
))
318 local
->pure_const_state
= IPA_NEITHER
;
320 fprintf (dump_file
, " Used static/global variable is not const/pure\n");
324 /* In IPA mode we are not interested in checking actual loads and stores;
325 they will be processed at propagation time using ipa_ref. */
329 /* Since we have dealt with the locals and params cases above, if we
330 are CHECKING_WRITE, this cannot be a pure or constant
334 local
->pure_const_state
= IPA_NEITHER
;
336 fprintf (dump_file
, " static/global memory write is not const/pure\n");
340 if (DECL_EXTERNAL (t
) || TREE_PUBLIC (t
))
342 /* Readonly reads are safe. */
343 if (TREE_READONLY (t
))
344 return; /* Read of a constant, do not change the function state. */
348 fprintf (dump_file
, " global memory read is not const\n");
349 /* Just a regular read. */
350 if (local
->pure_const_state
== IPA_CONST
)
351 local
->pure_const_state
= IPA_PURE
;
356 /* Compilation level statics can be read if they are readonly
358 if (TREE_READONLY (t
))
362 fprintf (dump_file
, " static memory read is not const\n");
363 /* Just a regular read. */
364 if (local
->pure_const_state
== IPA_CONST
)
365 local
->pure_const_state
= IPA_PURE
;
370 /* Check to see if the use (or definition when CHECKING_WRITE is true)
371 variable T is legal in a function that is either pure or const. */
374 check_op (funct_state local
, tree t
, bool checking_write
)
376 t
= get_base_address (t
);
377 if (t
&& TREE_THIS_VOLATILE (t
))
379 local
->pure_const_state
= IPA_NEITHER
;
381 fprintf (dump_file
, " Volatile indirect ref is not const/pure\n");
385 && (INDIRECT_REF_P (t
) || TREE_CODE (t
) == MEM_REF
)
386 && TREE_CODE (TREE_OPERAND (t
, 0)) == SSA_NAME
387 && !ptr_deref_may_alias_global_p (TREE_OPERAND (t
, 0)))
390 fprintf (dump_file
, " Indirect ref to local memory is OK\n");
393 else if (checking_write
)
395 local
->pure_const_state
= IPA_NEITHER
;
397 fprintf (dump_file
, " Indirect ref write is not const/pure\n");
403 fprintf (dump_file
, " Indirect ref read is not const\n");
404 if (local
->pure_const_state
== IPA_CONST
)
405 local
->pure_const_state
= IPA_PURE
;
409 /* compute state based on ECF FLAGS and store to STATE and LOOPING. */
412 state_from_flags (enum pure_const_state_e
*state
, bool *looping
,
413 int flags
, bool cannot_lead_to_return
)
416 if (flags
& ECF_LOOPING_CONST_OR_PURE
)
419 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
420 fprintf (dump_file
, " looping\n");
422 if (flags
& ECF_CONST
)
425 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
426 fprintf (dump_file
, " const\n");
428 else if (flags
& ECF_PURE
)
431 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
432 fprintf (dump_file
, " pure\n");
434 else if (cannot_lead_to_return
)
438 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
439 fprintf (dump_file
, " ignoring side effects->pure looping\n");
443 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
444 fprintf (dump_file
, " neither\n");
445 *state
= IPA_NEITHER
;
450 /* Merge STATE and STATE2 and LOOPING and LOOPING2 and store
451 into STATE and LOOPING better of the two variants.
452 Be sure to merge looping correctly. IPA_NEITHER functions
453 have looping 0 even if they don't have to return. */
456 better_state (enum pure_const_state_e
*state
, bool *looping
,
457 enum pure_const_state_e state2
, bool looping2
)
461 if (*state
== IPA_NEITHER
)
464 *looping
= MIN (*looping
, looping2
);
467 else if (state2
!= IPA_NEITHER
)
468 *looping
= MIN (*looping
, looping2
);
471 /* Merge STATE and STATE2 and LOOPING and LOOPING2 and store
472 into STATE and LOOPING worse of the two variants.
473 N is the actual node called. */
476 worse_state (enum pure_const_state_e
*state
, bool *looping
,
477 enum pure_const_state_e state2
, bool looping2
,
478 struct symtab_node
*from
,
479 struct symtab_node
*to
)
481 /* Consider function:
488 During early optimization we will turn this into:
495 Now if this function will be detected as CONST however when interposed it
496 may end up being just pure. We always must assume the worst scenario here.
498 if (*state
== IPA_CONST
&& state2
== IPA_CONST
499 && to
&& !TREE_READONLY (to
->decl
) && !to
->binds_to_current_def_p (from
))
501 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
502 fprintf (dump_file
, "Dropping state to PURE because call to %s may not "
503 "bind to current def.\n", to
->dump_name ());
506 *state
= MAX (*state
, state2
);
507 *looping
= MAX (*looping
, looping2
);
510 /* Recognize special cases of builtins that are by themselves not pure or const
511 but function using them is. */
513 special_builtin_state (enum pure_const_state_e
*state
, bool *looping
,
516 if (DECL_BUILT_IN_CLASS (callee
) == BUILT_IN_NORMAL
)
517 switch (DECL_FUNCTION_CODE (callee
))
519 case BUILT_IN_RETURN
:
520 case BUILT_IN_UNREACHABLE
:
521 CASE_BUILT_IN_ALLOCA
:
522 case BUILT_IN_STACK_SAVE
:
523 case BUILT_IN_STACK_RESTORE
:
524 case BUILT_IN_EH_POINTER
:
525 case BUILT_IN_EH_FILTER
:
526 case BUILT_IN_UNWIND_RESUME
:
527 case BUILT_IN_CXA_END_CLEANUP
:
528 case BUILT_IN_EH_COPY_VALUES
:
529 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 (cfun
, call
);
559 bool possibly_throws_externally
= (possibly_throws
560 && stmt_can_throw_external (cfun
, 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
:
627 " longjmp and nonlocal goto is not const/pure\n");
628 local
->pure_const_state
= IPA_NEITHER
;
629 local
->looping
= true;
635 else if (gimple_call_internal_p (call
) && !nonfreeing_call_p (call
))
636 local
->can_free
= true;
638 /* When not in IPA mode, we can still handle self recursion. */
640 && recursive_call_p (current_function_decl
, callee_t
))
643 fprintf (dump_file
, " Recursive call can loop.\n");
644 local
->looping
= true;
646 /* Either callee is unknown or we are doing local analysis.
647 Look to see if there are any bits available for the callee (such as by
648 declaration or because it is builtin) and process solely on the basis of
649 those bits. Handle internal calls always, those calls don't have
650 corresponding cgraph edges and thus aren't processed during
652 else if (!ipa
|| gimple_call_internal_p (call
))
654 enum pure_const_state_e call_state
;
656 if (possibly_throws
&& cfun
->can_throw_non_call_exceptions
)
659 fprintf (dump_file
, " can throw; looping\n");
660 local
->looping
= true;
662 if (possibly_throws_externally
)
666 fprintf (dump_file
, " can throw externally to lp %i\n",
667 lookup_stmt_eh_lp (call
));
669 fprintf (dump_file
, " callee:%s\n",
670 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (callee_t
)));
672 local
->can_throw
= true;
674 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
675 fprintf (dump_file
, " checking flags for call:");
676 state_from_flags (&call_state
, &call_looping
, flags
,
677 ((flags
& (ECF_NORETURN
| ECF_NOTHROW
))
678 == (ECF_NORETURN
| ECF_NOTHROW
))
679 || (!flag_exceptions
&& (flags
& ECF_NORETURN
)));
680 worse_state (&local
->pure_const_state
, &local
->looping
,
681 call_state
, call_looping
, NULL
, NULL
);
683 /* Direct functions calls are handled by IPA propagation. */
686 /* Wrapper around check_decl for loads in local more. */
689 check_load (gimple
*, tree op
, tree
, void *data
)
692 check_decl ((funct_state
)data
, op
, false, false);
694 check_op ((funct_state
)data
, op
, false);
698 /* Wrapper around check_decl for stores in local more. */
701 check_store (gimple
*, tree op
, tree
, void *data
)
704 check_decl ((funct_state
)data
, op
, true, false);
706 check_op ((funct_state
)data
, op
, true);
710 /* Wrapper around check_decl for loads in ipa mode. */
713 check_ipa_load (gimple
*, tree op
, tree
, void *data
)
716 check_decl ((funct_state
)data
, op
, false, true);
718 check_op ((funct_state
)data
, op
, false);
722 /* Wrapper around check_decl for stores in ipa mode. */
725 check_ipa_store (gimple
*, tree op
, tree
, void *data
)
728 check_decl ((funct_state
)data
, op
, true, true);
730 check_op ((funct_state
)data
, op
, true);
734 /* Look into pointer pointed to by GSIP and figure out what interesting side
737 check_stmt (gimple_stmt_iterator
*gsip
, funct_state local
, bool ipa
)
739 gimple
*stmt
= gsi_stmt (*gsip
);
741 if (is_gimple_debug (stmt
))
744 /* Do consider clobber as side effects before IPA, so we rather inline
745 C++ destructors and keep clobber semantics than eliminate them.
747 TODO: We may get smarter during early optimizations on these and let
748 functions containing only clobbers to be optimized more. This is a common
749 case of C++ destructors. */
751 if ((ipa
|| cfun
->after_inlining
) && gimple_clobber_p (stmt
))
756 fprintf (dump_file
, " scanning: ");
757 print_gimple_stmt (dump_file
, stmt
, 0);
760 if (gimple_has_volatile_ops (stmt
)
761 && !gimple_clobber_p (stmt
))
763 local
->pure_const_state
= IPA_NEITHER
;
765 fprintf (dump_file
, " Volatile stmt is not const/pure\n");
768 /* Look for loads and stores. */
769 walk_stmt_load_store_ops (stmt
, local
,
770 ipa
? check_ipa_load
: check_load
,
771 ipa
? check_ipa_store
: check_store
);
773 if (gimple_code (stmt
) != GIMPLE_CALL
774 && stmt_could_throw_p (cfun
, stmt
))
776 if (cfun
->can_throw_non_call_exceptions
)
779 fprintf (dump_file
, " can throw; looping\n");
780 local
->looping
= true;
782 if (stmt_can_throw_external (cfun
, stmt
))
785 fprintf (dump_file
, " can throw externally\n");
786 local
->can_throw
= true;
790 fprintf (dump_file
, " can throw\n");
792 switch (gimple_code (stmt
))
795 check_call (local
, as_a
<gcall
*> (stmt
), ipa
);
798 if (DECL_NONLOCAL (gimple_label_label (as_a
<glabel
*> (stmt
))))
799 /* Target of long jump. */
802 fprintf (dump_file
, " nonlocal label is not const/pure\n");
803 local
->pure_const_state
= IPA_NEITHER
;
807 if (gimple_asm_clobbers_memory_p (as_a
<gasm
*> (stmt
)))
810 fprintf (dump_file
, " memory asm clobber is not const/pure\n");
811 /* Abandon all hope, ye who enter here. */
812 local
->pure_const_state
= IPA_NEITHER
;
813 local
->can_free
= true;
815 if (gimple_asm_volatile_p (as_a
<gasm
*> (stmt
)))
818 fprintf (dump_file
, " volatile is not const/pure\n");
819 /* Abandon all hope, ye who enter here. */
820 local
->pure_const_state
= IPA_NEITHER
;
821 local
->looping
= true;
822 local
->can_free
= true;
830 /* Check that RETVAL is used only in STMT and in comparisons against 0.
831 RETVAL is return value of the function and STMT is return stmt. */
834 check_retval_uses (tree retval
, gimple
*stmt
)
836 imm_use_iterator use_iter
;
839 FOR_EACH_IMM_USE_STMT (use_stmt
, use_iter
, retval
)
840 if (gcond
*cond
= dyn_cast
<gcond
*> (use_stmt
))
842 tree op2
= gimple_cond_rhs (cond
);
843 if (!integer_zerop (op2
))
844 RETURN_FROM_IMM_USE_STMT (use_iter
, false);
846 else if (gassign
*ga
= dyn_cast
<gassign
*> (use_stmt
))
848 enum tree_code code
= gimple_assign_rhs_code (ga
);
849 if (TREE_CODE_CLASS (code
) != tcc_comparison
)
850 RETURN_FROM_IMM_USE_STMT (use_iter
, false);
851 if (!integer_zerop (gimple_assign_rhs2 (ga
)))
852 RETURN_FROM_IMM_USE_STMT (use_iter
, false);
854 else if (is_gimple_debug (use_stmt
))
856 else if (use_stmt
!= stmt
)
857 RETURN_FROM_IMM_USE_STMT (use_iter
, false);
862 /* malloc_candidate_p() checks if FUN can possibly be annotated with malloc
863 attribute. Currently this function does a very conservative analysis.
864 FUN is considered to be a candidate if
865 1) It returns a value of pointer type.
866 2) SSA_NAME_DEF_STMT (return_value) is either a function call or
867 a phi, and element of phi is either NULL or
868 SSA_NAME_DEF_STMT(element) is function call.
869 3) The return-value has immediate uses only within comparisons (gcond or gassign)
870 and return_stmt (and likewise a phi arg has immediate use only within comparison
873 #define DUMP_AND_RETURN(reason) \
875 if (dump_file && (dump_flags & TDF_DETAILS)) \
876 fprintf (dump_file, "\n%s is not a malloc candidate, reason: %s\n", \
877 (node->dump_name ()), (reason)); \
882 malloc_candidate_p_1 (function
*fun
, tree retval
, gimple
*ret_stmt
, bool ipa
,
885 cgraph_node
*node
= cgraph_node::get_create (fun
->decl
);
886 if (!bitmap_set_bit (visited
, SSA_NAME_VERSION (retval
)))
889 if (!check_retval_uses (retval
, ret_stmt
))
890 DUMP_AND_RETURN("Return value has uses outside return stmt"
891 " and comparisons against 0.")
893 gimple
*def
= SSA_NAME_DEF_STMT (retval
);
895 if (gcall
*call_stmt
= dyn_cast
<gcall
*> (def
))
897 tree callee_decl
= gimple_call_fndecl (call_stmt
);
901 if (!ipa
&& !DECL_IS_MALLOC (callee_decl
))
902 DUMP_AND_RETURN("callee_decl does not have malloc attribute for"
905 cgraph_edge
*cs
= node
->get_edge (call_stmt
);
908 ipa_call_summary
*es
= ipa_call_summaries
->get_create (cs
);
909 es
->is_return_callee_uncaptured
= true;
913 else if (gphi
*phi
= dyn_cast
<gphi
*> (def
))
915 bool all_args_zero
= true;
916 for (unsigned i
= 0; i
< gimple_phi_num_args (phi
); ++i
)
918 tree arg
= gimple_phi_arg_def (phi
, i
);
919 if (integer_zerop (arg
))
922 all_args_zero
= false;
923 if (TREE_CODE (arg
) != SSA_NAME
)
924 DUMP_AND_RETURN ("phi arg is not SSA_NAME.");
925 if (!check_retval_uses (arg
, phi
))
926 DUMP_AND_RETURN ("phi arg has uses outside phi"
927 " and comparisons against 0.")
929 gimple
*arg_def
= SSA_NAME_DEF_STMT (arg
);
930 if (is_a
<gphi
*> (arg_def
))
932 if (!malloc_candidate_p_1 (fun
, arg
, phi
, ipa
, visited
))
933 DUMP_AND_RETURN ("nested phi fail")
937 gcall
*call_stmt
= dyn_cast
<gcall
*> (arg_def
);
939 DUMP_AND_RETURN ("phi arg is a not a call_stmt.")
941 tree callee_decl
= gimple_call_fndecl (call_stmt
);
944 if (!ipa
&& !DECL_IS_MALLOC (callee_decl
))
945 DUMP_AND_RETURN("callee_decl does not have malloc attribute"
946 " for non-ipa mode.")
948 cgraph_edge
*cs
= node
->get_edge (call_stmt
);
951 ipa_call_summary
*es
= ipa_call_summaries
->get_create (cs
);
952 es
->is_return_callee_uncaptured
= true;
957 DUMP_AND_RETURN ("Return value is a phi with all args equal to 0.")
961 DUMP_AND_RETURN("def_stmt of return value is not a call or phi-stmt.")
967 malloc_candidate_p (function
*fun
, bool ipa
)
969 basic_block exit_block
= EXIT_BLOCK_PTR_FOR_FN (fun
);
972 cgraph_node
*node
= cgraph_node::get_create (fun
->decl
);
974 if (EDGE_COUNT (exit_block
->preds
) == 0
975 || !flag_delete_null_pointer_checks
)
979 FOR_EACH_EDGE (e
, ei
, exit_block
->preds
)
981 gimple_stmt_iterator gsi
= gsi_last_bb (e
->src
);
982 greturn
*ret_stmt
= dyn_cast
<greturn
*> (gsi_stmt (gsi
));
987 tree retval
= gimple_return_retval (ret_stmt
);
989 DUMP_AND_RETURN("No return value.")
991 if (TREE_CODE (retval
) != SSA_NAME
992 || TREE_CODE (TREE_TYPE (retval
)) != POINTER_TYPE
)
993 DUMP_AND_RETURN("Return value is not SSA_NAME or not a pointer type.")
995 if (!malloc_candidate_p_1 (fun
, retval
, ret_stmt
, ipa
, visited
))
999 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1000 fprintf (dump_file
, "\nFound %s to be candidate for malloc attribute\n",
1001 IDENTIFIER_POINTER (DECL_NAME (fun
->decl
)));
1005 #undef DUMP_AND_RETURN
1007 /* This is the main routine for finding the reference patterns for
1008 global variables within a function FN. */
1011 analyze_function (struct cgraph_node
*fn
, bool ipa
)
1013 tree decl
= fn
->decl
;
1015 basic_block this_block
;
1017 l
= XCNEW (class funct_state_d
);
1018 l
->pure_const_state
= IPA_CONST
;
1019 l
->state_previously_known
= IPA_NEITHER
;
1020 l
->looping_previously_known
= true;
1022 l
->can_throw
= false;
1023 l
->can_free
= false;
1024 state_from_flags (&l
->state_previously_known
, &l
->looping_previously_known
,
1025 flags_from_decl_or_type (fn
->decl
),
1026 fn
->cannot_return_p ());
1028 if (fn
->thunk
.thunk_p
|| fn
->alias
)
1030 /* Thunk gets propagated through, so nothing interesting happens. */
1032 if (fn
->thunk
.thunk_p
&& fn
->thunk
.virtual_offset_p
)
1033 l
->pure_const_state
= IPA_NEITHER
;
1039 fprintf (dump_file
, "\n\n local analysis of %s\n ",
1043 push_cfun (DECL_STRUCT_FUNCTION (decl
));
1045 FOR_EACH_BB_FN (this_block
, cfun
)
1047 gimple_stmt_iterator gsi
;
1048 struct walk_stmt_info wi
;
1050 memset (&wi
, 0, sizeof (wi
));
1051 for (gsi
= gsi_start_bb (this_block
);
1055 check_stmt (&gsi
, l
, ipa
);
1056 if (l
->pure_const_state
== IPA_NEITHER
1065 if (l
->pure_const_state
!= IPA_NEITHER
)
1067 /* Const functions cannot have back edges (an
1068 indication of possible infinite loop side
1070 if (mark_dfs_back_edges ())
1072 /* Preheaders are needed for SCEV to work.
1073 Simple latches and recorded exits improve chances that loop will
1074 proved to be finite in testcases such as in loop-15.c
1076 loop_optimizer_init (LOOPS_HAVE_PREHEADERS
1077 | LOOPS_HAVE_SIMPLE_LATCHES
1078 | LOOPS_HAVE_RECORDED_EXITS
);
1079 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1080 flow_loops_dump (dump_file
, NULL
, 0);
1081 if (mark_irreducible_loops ())
1084 fprintf (dump_file
, " has irreducible loops\n");
1091 FOR_EACH_LOOP (loop
, 0)
1092 if (!finite_loop_p (loop
))
1095 fprintf (dump_file
, " cannot prove finiteness of "
1096 "loop %i\n", loop
->num
);
1102 loop_optimizer_finalize ();
1106 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1107 fprintf (dump_file
, " checking previously known:");
1109 better_state (&l
->pure_const_state
, &l
->looping
,
1110 l
->state_previously_known
,
1111 l
->looping_previously_known
);
1112 if (TREE_NOTHROW (decl
))
1113 l
->can_throw
= false;
1115 l
->malloc_state
= STATE_MALLOC_BOTTOM
;
1116 if (DECL_IS_MALLOC (decl
))
1117 l
->malloc_state
= STATE_MALLOC
;
1118 else if (ipa
&& malloc_candidate_p (DECL_STRUCT_FUNCTION (decl
), true))
1119 l
->malloc_state
= STATE_MALLOC_TOP
;
1120 else if (malloc_candidate_p (DECL_STRUCT_FUNCTION (decl
), false))
1121 l
->malloc_state
= STATE_MALLOC
;
1127 fprintf (dump_file
, "Function is locally looping.\n");
1129 fprintf (dump_file
, "Function is locally throwing.\n");
1130 if (l
->pure_const_state
== IPA_CONST
)
1131 fprintf (dump_file
, "Function is locally const.\n");
1132 if (l
->pure_const_state
== IPA_PURE
)
1133 fprintf (dump_file
, "Function is locally pure.\n");
1135 fprintf (dump_file
, "Function can locally free.\n");
1136 if (l
->malloc_state
== STATE_MALLOC
)
1137 fprintf (dump_file
, "Function is locally malloc.\n");
1143 funct_state_summary_t::insert (cgraph_node
*node
, funct_state_d
*state
)
1145 /* There are some shared nodes, in particular the initializers on
1146 static declarations. We do not need to scan them more than once
1147 since all we would be interested in are the addressof
1149 if (opt_for_fn (node
->decl
, flag_ipa_pure_const
))
1151 funct_state_d
*a
= analyze_function (node
, true);
1152 new (state
) funct_state_d (*a
);
1157 /* Called when new clone is inserted to callgraph late. */
1160 funct_state_summary_t::duplicate (cgraph_node
*, cgraph_node
*dst
,
1161 funct_state_d
*src_data
,
1162 funct_state_d
*dst_data
)
1164 new (dst_data
) funct_state_d (*src_data
);
1165 if (dst_data
->malloc_state
== STATE_MALLOC
1166 && VOID_TYPE_P (TREE_TYPE (TREE_TYPE (dst
->decl
))))
1167 dst_data
->malloc_state
= STATE_MALLOC_BOTTOM
;
1172 pass_ipa_pure_const::
1173 register_hooks (void)
1180 funct_state_summaries
= new funct_state_summary_t (symtab
);
1184 /* Analyze each function in the cgraph to see if it is locally PURE or
1188 pure_const_generate_summary (void)
1190 struct cgraph_node
*node
;
1192 pass_ipa_pure_const
*pass
= static_cast <pass_ipa_pure_const
*> (current_pass
);
1193 pass
->register_hooks ();
1195 /* Process all of the functions.
1197 We process AVAIL_INTERPOSABLE functions. We cannot use the results
1198 by default, but the info can be used at LTO with -fwhole-program or
1199 when function got cloned and the clone is AVAILABLE. */
1201 FOR_EACH_DEFINED_FUNCTION (node
)
1202 if (opt_for_fn (node
->decl
, flag_ipa_pure_const
))
1204 funct_state_d
*a
= analyze_function (node
, true);
1205 new (funct_state_summaries
->get_create (node
)) funct_state_d (*a
);
1211 /* Serialize the ipa info for lto. */
1214 pure_const_write_summary (void)
1216 struct cgraph_node
*node
;
1217 struct lto_simple_output_block
*ob
1218 = lto_create_simple_output_block (LTO_section_ipa_pure_const
);
1219 unsigned int count
= 0;
1220 lto_symtab_encoder_iterator lsei
;
1221 lto_symtab_encoder_t encoder
;
1223 encoder
= lto_get_out_decl_state ()->symtab_node_encoder
;
1225 for (lsei
= lsei_start_function_in_partition (encoder
); !lsei_end_p (lsei
);
1226 lsei_next_function_in_partition (&lsei
))
1228 node
= lsei_cgraph_node (lsei
);
1229 if (node
->definition
&& funct_state_summaries
->exists (node
))
1233 streamer_write_uhwi_stream (ob
->main_stream
, count
);
1235 /* Process all of the functions. */
1236 for (lsei
= lsei_start_function_in_partition (encoder
); !lsei_end_p (lsei
);
1237 lsei_next_function_in_partition (&lsei
))
1239 node
= lsei_cgraph_node (lsei
);
1240 funct_state_d
*fs
= funct_state_summaries
->get (node
);
1241 if (node
->definition
&& fs
!= NULL
)
1243 struct bitpack_d bp
;
1245 lto_symtab_encoder_t encoder
;
1247 encoder
= ob
->decl_state
->symtab_node_encoder
;
1248 node_ref
= lto_symtab_encoder_encode (encoder
, node
);
1249 streamer_write_uhwi_stream (ob
->main_stream
, node_ref
);
1251 /* Note that flags will need to be read in the opposite
1252 order as we are pushing the bitflags into FLAGS. */
1253 bp
= bitpack_create (ob
->main_stream
);
1254 bp_pack_value (&bp
, fs
->pure_const_state
, 2);
1255 bp_pack_value (&bp
, fs
->state_previously_known
, 2);
1256 bp_pack_value (&bp
, fs
->looping_previously_known
, 1);
1257 bp_pack_value (&bp
, fs
->looping
, 1);
1258 bp_pack_value (&bp
, fs
->can_throw
, 1);
1259 bp_pack_value (&bp
, fs
->can_free
, 1);
1260 bp_pack_value (&bp
, fs
->malloc_state
, 2);
1261 streamer_write_bitpack (&bp
);
1265 lto_destroy_simple_output_block (ob
);
1269 /* Deserialize the ipa info for lto. */
1272 pure_const_read_summary (void)
1274 struct lto_file_decl_data
**file_data_vec
= lto_get_file_decl_data ();
1275 struct lto_file_decl_data
*file_data
;
1278 pass_ipa_pure_const
*pass
= static_cast <pass_ipa_pure_const
*> (current_pass
);
1279 pass
->register_hooks ();
1281 while ((file_data
= file_data_vec
[j
++]))
1285 class lto_input_block
*ib
1286 = lto_create_simple_input_block (file_data
,
1287 LTO_section_ipa_pure_const
,
1292 unsigned int count
= streamer_read_uhwi (ib
);
1294 for (i
= 0; i
< count
; i
++)
1297 struct cgraph_node
*node
;
1298 struct bitpack_d bp
;
1300 lto_symtab_encoder_t encoder
;
1302 index
= streamer_read_uhwi (ib
);
1303 encoder
= file_data
->symtab_node_encoder
;
1304 node
= dyn_cast
<cgraph_node
*> (lto_symtab_encoder_deref (encoder
,
1307 fs
= funct_state_summaries
->get_create (node
);
1308 /* Note that the flags must be read in the opposite
1309 order in which they were written (the bitflags were
1310 pushed into FLAGS). */
1311 bp
= streamer_read_bitpack (ib
);
1312 fs
->pure_const_state
1313 = (enum pure_const_state_e
) bp_unpack_value (&bp
, 2);
1314 fs
->state_previously_known
1315 = (enum pure_const_state_e
) bp_unpack_value (&bp
, 2);
1316 fs
->looping_previously_known
= bp_unpack_value (&bp
, 1);
1317 fs
->looping
= bp_unpack_value (&bp
, 1);
1318 fs
->can_throw
= bp_unpack_value (&bp
, 1);
1319 fs
->can_free
= bp_unpack_value (&bp
, 1);
1321 = (enum malloc_state_e
) bp_unpack_value (&bp
, 2);
1325 int flags
= flags_from_decl_or_type (node
->decl
);
1326 fprintf (dump_file
, "Read info for %s ", node
->dump_name ());
1327 if (flags
& ECF_CONST
)
1328 fprintf (dump_file
, " const");
1329 if (flags
& ECF_PURE
)
1330 fprintf (dump_file
, " pure");
1331 if (flags
& ECF_NOTHROW
)
1332 fprintf (dump_file
, " nothrow");
1333 fprintf (dump_file
, "\n pure const state: %s\n",
1334 pure_const_names
[fs
->pure_const_state
]);
1335 fprintf (dump_file
, " previously known state: %s\n",
1336 pure_const_names
[fs
->state_previously_known
]);
1338 fprintf (dump_file
," function is locally looping\n");
1339 if (fs
->looping_previously_known
)
1340 fprintf (dump_file
," function is previously known looping\n");
1342 fprintf (dump_file
," function is locally throwing\n");
1344 fprintf (dump_file
," function can locally free\n");
1345 fprintf (dump_file
, "\n malloc state: %s\n",
1346 malloc_state_names
[fs
->malloc_state
]);
1350 lto_destroy_simple_input_block (file_data
,
1351 LTO_section_ipa_pure_const
,
1357 /* We only propagate across edges that can throw externally and their callee
1358 is not interposable. */
1361 ignore_edge_for_nothrow (struct cgraph_edge
*e
)
1363 if (!e
->can_throw_external
|| TREE_NOTHROW (e
->callee
->decl
))
1366 enum availability avail
;
1367 cgraph_node
*ultimate_target
1368 = e
->callee
->function_or_virtual_thunk_symbol (&avail
, e
->caller
);
1369 if (avail
<= AVAIL_INTERPOSABLE
|| TREE_NOTHROW (ultimate_target
->decl
))
1371 return ((opt_for_fn (e
->callee
->decl
, flag_non_call_exceptions
)
1372 && !e
->callee
->binds_to_current_def_p (e
->caller
))
1373 || !opt_for_fn (e
->caller
->decl
, flag_ipa_pure_const
)
1374 || !opt_for_fn (ultimate_target
->decl
, flag_ipa_pure_const
));
1377 /* Return true if NODE is self recursive function.
1378 Indirectly recursive functions appears as non-trivial strongly
1379 connected components, so we need to care about self recursion
1383 self_recursive_p (struct cgraph_node
*node
)
1385 struct cgraph_edge
*e
;
1386 for (e
= node
->callees
; e
; e
= e
->next_callee
)
1387 if (e
->callee
->function_symbol () == node
)
1392 /* Return true if N is cdtor that is not const or pure. In this case we may
1393 need to remove unreachable function if it is marked const/pure. */
1396 cdtor_p (cgraph_node
*n
, void *)
1398 if (DECL_STATIC_CONSTRUCTOR (n
->decl
) || DECL_STATIC_DESTRUCTOR (n
->decl
))
1399 return ((!TREE_READONLY (n
->decl
) && !DECL_PURE_P (n
->decl
))
1400 || DECL_LOOPING_CONST_OR_PURE_P (n
->decl
));
1404 /* Skip edges from and to nodes without ipa_pure_const enabled.
1405 Ignore not available symbols. */
1408 ignore_edge_for_pure_const (struct cgraph_edge
*e
)
1410 enum availability avail
;
1411 cgraph_node
*ultimate_target
1412 = e
->callee
->function_or_virtual_thunk_symbol (&avail
, e
->caller
);
1414 return (avail
<= AVAIL_INTERPOSABLE
1415 || !opt_for_fn (e
->caller
->decl
, flag_ipa_pure_const
)
1416 || !opt_for_fn (ultimate_target
->decl
,
1417 flag_ipa_pure_const
));
1420 /* Produce transitive closure over the callgraph and compute pure/const
1424 propagate_pure_const (void)
1426 struct cgraph_node
*node
;
1427 struct cgraph_node
*w
;
1428 struct cgraph_node
**order
=
1429 XCNEWVEC (struct cgraph_node
*, symtab
->cgraph_count
);
1432 struct ipa_dfs_info
* w_info
;
1433 bool remove_p
= false;
1436 order_pos
= ipa_reduced_postorder (order
, true,
1437 ignore_edge_for_pure_const
);
1440 cgraph_node::dump_cgraph (dump_file
);
1441 ipa_print_order (dump_file
, "reduced", order
, order_pos
);
1444 /* Propagate the local information through the call graph to produce
1445 the global information. All the nodes within a cycle will have
1446 the same info so we collapse cycles first. Then we can do the
1447 propagation in one pass from the leaves to the roots. */
1448 for (i
= 0; i
< order_pos
; i
++ )
1450 enum pure_const_state_e pure_const_state
= IPA_CONST
;
1451 bool looping
= false;
1458 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1459 fprintf (dump_file
, "Starting cycle\n");
1461 /* Find the worst state for any node in the cycle. */
1463 while (w
&& pure_const_state
!= IPA_NEITHER
)
1465 struct cgraph_edge
*e
;
1466 struct cgraph_edge
*ie
;
1468 struct ipa_ref
*ref
= NULL
;
1470 funct_state w_l
= funct_state_summaries
->get_create (w
);
1471 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1472 fprintf (dump_file
, " Visiting %s state:%s looping %i\n",
1474 pure_const_names
[w_l
->pure_const_state
],
1477 /* First merge in function body properties.
1478 We are safe to pass NULL as FROM and TO because we will take care
1479 of possible interposition when walking callees. */
1480 worse_state (&pure_const_state
, &looping
,
1481 w_l
->pure_const_state
, w_l
->looping
,
1483 if (pure_const_state
== IPA_NEITHER
)
1488 /* We consider recursive cycles as possibly infinite.
1489 This might be relaxed since infinite recursion leads to stack
1494 /* Now walk the edges and merge in callee properties. */
1495 for (e
= w
->callees
; e
&& pure_const_state
!= IPA_NEITHER
;
1498 enum availability avail
;
1499 struct cgraph_node
*y
= e
->callee
->
1500 function_or_virtual_thunk_symbol (&avail
,
1502 enum pure_const_state_e edge_state
= IPA_CONST
;
1503 bool edge_looping
= false;
1505 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1507 fprintf (dump_file
, " Call to %s",
1508 e
->callee
->dump_name ());
1510 if (avail
> AVAIL_INTERPOSABLE
)
1512 funct_state y_l
= funct_state_summaries
->get_create (y
);
1514 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1517 " state:%s looping:%i\n",
1518 pure_const_names
[y_l
->pure_const_state
],
1521 if (y_l
->pure_const_state
> IPA_PURE
1522 && e
->cannot_lead_to_return_p ())
1524 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1526 " Ignoring side effects"
1527 " -> pure, looping\n");
1528 edge_state
= IPA_PURE
;
1529 edge_looping
= true;
1533 edge_state
= y_l
->pure_const_state
;
1534 edge_looping
= y_l
->looping
;
1537 else if (special_builtin_state (&edge_state
, &edge_looping
,
1541 state_from_flags (&edge_state
, &edge_looping
,
1542 flags_from_decl_or_type (y
->decl
),
1543 e
->cannot_lead_to_return_p ());
1545 /* Merge the results with what we already know. */
1546 better_state (&edge_state
, &edge_looping
,
1547 w_l
->state_previously_known
,
1548 w_l
->looping_previously_known
);
1549 worse_state (&pure_const_state
, &looping
,
1550 edge_state
, edge_looping
, e
->caller
, e
->callee
);
1551 if (pure_const_state
== IPA_NEITHER
)
1555 /* Now process the indirect call. */
1556 for (ie
= w
->indirect_calls
;
1557 ie
&& pure_const_state
!= IPA_NEITHER
; ie
= ie
->next_callee
)
1559 enum pure_const_state_e edge_state
= IPA_CONST
;
1560 bool edge_looping
= false;
1562 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1563 fprintf (dump_file
, " Indirect call");
1564 state_from_flags (&edge_state
, &edge_looping
,
1565 ie
->indirect_info
->ecf_flags
,
1566 ie
->cannot_lead_to_return_p ());
1567 /* Merge the results with what we already know. */
1568 better_state (&edge_state
, &edge_looping
,
1569 w_l
->state_previously_known
,
1570 w_l
->looping_previously_known
);
1571 worse_state (&pure_const_state
, &looping
,
1572 edge_state
, edge_looping
, NULL
, NULL
);
1573 if (pure_const_state
== IPA_NEITHER
)
1577 /* And finally all loads and stores. */
1578 for (i
= 0; w
->iterate_reference (i
, ref
)
1579 && pure_const_state
!= IPA_NEITHER
; i
++)
1581 enum pure_const_state_e ref_state
= IPA_CONST
;
1582 bool ref_looping
= false;
1586 /* readonly reads are safe. */
1587 if (TREE_READONLY (ref
->referred
->decl
))
1589 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1590 fprintf (dump_file
, " nonreadonly global var read\n");
1591 ref_state
= IPA_PURE
;
1594 if (ref
->cannot_lead_to_return ())
1596 ref_state
= IPA_NEITHER
;
1597 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1598 fprintf (dump_file
, " global var write\n");
1605 better_state (&ref_state
, &ref_looping
,
1606 w_l
->state_previously_known
,
1607 w_l
->looping_previously_known
);
1608 worse_state (&pure_const_state
, &looping
,
1609 ref_state
, ref_looping
, NULL
, NULL
);
1610 if (pure_const_state
== IPA_NEITHER
)
1613 w_info
= (struct ipa_dfs_info
*) w
->aux
;
1614 w
= w_info
->next_cycle
;
1616 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1617 fprintf (dump_file
, "Result %s looping %i\n",
1618 pure_const_names
[pure_const_state
],
1621 /* Find the worst state of can_free for any node in the cycle. */
1622 bool can_free
= false;
1624 while (w
&& !can_free
)
1626 struct cgraph_edge
*e
;
1627 funct_state w_l
= funct_state_summaries
->get (w
);
1630 || w
->get_availability () == AVAIL_INTERPOSABLE
1631 || w
->indirect_calls
)
1634 for (e
= w
->callees
; e
&& !can_free
; e
= e
->next_callee
)
1636 enum availability avail
;
1637 struct cgraph_node
*y
= e
->callee
->
1638 function_or_virtual_thunk_symbol (&avail
,
1641 if (avail
> AVAIL_INTERPOSABLE
)
1642 can_free
= funct_state_summaries
->get (y
)->can_free
;
1646 w_info
= (struct ipa_dfs_info
*) w
->aux
;
1647 w
= w_info
->next_cycle
;
1650 /* Copy back the region's pure_const_state which is shared by
1651 all nodes in the region. */
1655 funct_state w_l
= funct_state_summaries
->get (w
);
1656 enum pure_const_state_e this_state
= pure_const_state
;
1657 bool this_looping
= looping
;
1659 w_l
->can_free
= can_free
;
1660 w
->nonfreeing_fn
= !can_free
;
1661 if (!can_free
&& dump_file
)
1662 fprintf (dump_file
, "Function found not to call free: %s\n",
1665 if (w_l
->state_previously_known
!= IPA_NEITHER
1666 && this_state
> w_l
->state_previously_known
)
1668 this_state
= w_l
->state_previously_known
;
1669 if (this_state
== IPA_NEITHER
)
1670 this_looping
= w_l
->looping_previously_known
;
1672 if (!this_looping
&& self_recursive_p (w
))
1673 this_looping
= true;
1674 if (!w_l
->looping_previously_known
)
1675 this_looping
= false;
1677 /* All nodes within a cycle share the same info. */
1678 w_l
->pure_const_state
= this_state
;
1679 w_l
->looping
= this_looping
;
1681 /* Inline clones share declaration with their offline copies;
1682 do not modify their declarations since the offline copy may
1688 if (!TREE_READONLY (w
->decl
))
1690 warn_function_const (w
->decl
, !this_looping
);
1692 fprintf (dump_file
, "Function found to be %sconst: %s\n",
1693 this_looping
? "looping " : "",
1696 /* Turning constructor or destructor to non-looping const/pure
1697 enables us to possibly remove the function completely. */
1701 has_cdtor
= w
->call_for_symbol_and_aliases (cdtor_p
,
1703 if (w
->set_const_flag (true, this_looping
))
1707 "Declaration updated to be %sconst: %s\n",
1708 this_looping
? "looping " : "",
1710 remove_p
|= has_cdtor
;
1715 if (!DECL_PURE_P (w
->decl
))
1717 warn_function_pure (w
->decl
, !this_looping
);
1719 fprintf (dump_file
, "Function found to be %spure: %s\n",
1720 this_looping
? "looping " : "",
1726 has_cdtor
= w
->call_for_symbol_and_aliases (cdtor_p
,
1728 if (w
->set_pure_flag (true, this_looping
))
1732 "Declaration updated to be %spure: %s\n",
1733 this_looping
? "looping " : "",
1735 remove_p
|= has_cdtor
;
1742 w_info
= (struct ipa_dfs_info
*) w
->aux
;
1743 w
= w_info
->next_cycle
;
1747 ipa_free_postorder_info ();
1752 /* Produce transitive closure over the callgraph and compute nothrow
1756 propagate_nothrow (void)
1758 struct cgraph_node
*node
;
1759 struct cgraph_node
*w
;
1760 struct cgraph_node
**order
=
1761 XCNEWVEC (struct cgraph_node
*, symtab
->cgraph_count
);
1764 struct ipa_dfs_info
* w_info
;
1766 order_pos
= ipa_reduced_postorder (order
, true,
1767 ignore_edge_for_nothrow
);
1770 cgraph_node::dump_cgraph (dump_file
);
1771 ipa_print_order (dump_file
, "reduced for nothrow", order
, order_pos
);
1774 /* Propagate the local information through the call graph to produce
1775 the global information. All the nodes within a cycle will have
1776 the same info so we collapse cycles first. Then we can do the
1777 propagation in one pass from the leaves to the roots. */
1778 for (i
= 0; i
< order_pos
; i
++ )
1780 bool can_throw
= false;
1786 /* Find the worst state for any node in the cycle. */
1788 while (w
&& !can_throw
)
1790 struct cgraph_edge
*e
, *ie
;
1792 if (!TREE_NOTHROW (w
->decl
))
1794 funct_state w_l
= funct_state_summaries
->get_create (w
);
1797 || w
->get_availability () == AVAIL_INTERPOSABLE
)
1800 for (e
= w
->callees
; e
&& !can_throw
; e
= e
->next_callee
)
1802 enum availability avail
;
1804 if (!e
->can_throw_external
|| TREE_NOTHROW (e
->callee
->decl
))
1807 struct cgraph_node
*y
= e
->callee
->
1808 function_or_virtual_thunk_symbol (&avail
,
1811 /* We can use info about the callee only if we know it
1812 cannot be interposed.
1813 When callee is compiled with non-call exceptions we also
1814 must check that the declaration is bound to current
1815 body as other semantically equivalent body may still
1817 if (avail
<= AVAIL_INTERPOSABLE
1818 || (!TREE_NOTHROW (y
->decl
)
1819 && (funct_state_summaries
->get_create (y
)->can_throw
1820 || (opt_for_fn (y
->decl
, flag_non_call_exceptions
)
1821 && !e
->callee
->binds_to_current_def_p (w
)))))
1824 for (ie
= w
->indirect_calls
; ie
&& !can_throw
;
1825 ie
= ie
->next_callee
)
1826 if (ie
->can_throw_external
1827 && !(ie
->indirect_info
->ecf_flags
& ECF_NOTHROW
))
1830 w_info
= (struct ipa_dfs_info
*) w
->aux
;
1831 w
= w_info
->next_cycle
;
1834 /* Copy back the region's pure_const_state which is shared by
1835 all nodes in the region. */
1839 funct_state w_l
= funct_state_summaries
->get_create (w
);
1840 if (!can_throw
&& !TREE_NOTHROW (w
->decl
))
1842 /* Inline clones share declaration with their offline copies;
1843 do not modify their declarations since the offline copy may
1847 w
->set_nothrow_flag (true);
1849 fprintf (dump_file
, "Function found to be nothrow: %s\n",
1853 else if (can_throw
&& !TREE_NOTHROW (w
->decl
))
1854 w_l
->can_throw
= true;
1855 w_info
= (struct ipa_dfs_info
*) w
->aux
;
1856 w
= w_info
->next_cycle
;
1860 ipa_free_postorder_info ();
1864 /* Debugging function to dump state of malloc lattice. */
1868 dump_malloc_lattice (FILE *dump_file
, const char *s
)
1873 fprintf (dump_file
, "\n\nMALLOC LATTICE %s:\n", s
);
1875 FOR_EACH_FUNCTION (node
)
1877 funct_state fs
= funct_state_summaries
->get (node
);
1879 fprintf (dump_file
, "%s: %s\n", node
->dump_name (),
1880 malloc_state_names
[fs
->malloc_state
]);
1884 /* Propagate malloc attribute across the callgraph. */
1887 propagate_malloc (void)
1890 FOR_EACH_FUNCTION (node
)
1892 if (DECL_IS_MALLOC (node
->decl
))
1893 if (!funct_state_summaries
->exists (node
))
1895 funct_state fs
= funct_state_summaries
->get_create (node
);
1896 fs
->malloc_state
= STATE_MALLOC
;
1900 dump_malloc_lattice (dump_file
, "Initial");
1901 struct cgraph_node
**order
1902 = XNEWVEC (struct cgraph_node
*, symtab
->cgraph_count
);
1903 int order_pos
= ipa_reverse_postorder (order
);
1904 bool changed
= true;
1909 /* Walk in postorder. */
1910 for (int i
= order_pos
- 1; i
>= 0; --i
)
1912 cgraph_node
*node
= order
[i
];
1914 || !node
->definition
1915 || !funct_state_summaries
->exists (node
))
1918 funct_state l
= funct_state_summaries
->get (node
);
1920 /* FIXME: add support for indirect-calls. */
1921 if (node
->indirect_calls
)
1923 l
->malloc_state
= STATE_MALLOC_BOTTOM
;
1927 if (node
->get_availability () <= AVAIL_INTERPOSABLE
)
1929 l
->malloc_state
= STATE_MALLOC_BOTTOM
;
1933 if (l
->malloc_state
== STATE_MALLOC_BOTTOM
)
1936 vec
<cgraph_node
*> callees
= vNULL
;
1937 for (cgraph_edge
*cs
= node
->callees
; cs
; cs
= cs
->next_callee
)
1939 ipa_call_summary
*es
= ipa_call_summaries
->get_create (cs
);
1940 if (es
&& es
->is_return_callee_uncaptured
)
1941 callees
.safe_push (cs
->callee
);
1944 malloc_state_e new_state
= l
->malloc_state
;
1945 for (unsigned j
= 0; j
< callees
.length (); j
++)
1947 cgraph_node
*callee
= callees
[j
];
1948 if (!funct_state_summaries
->exists (node
))
1950 new_state
= STATE_MALLOC_BOTTOM
;
1953 malloc_state_e callee_state
1954 = funct_state_summaries
->get_create (callee
)->malloc_state
;
1955 if (new_state
< callee_state
)
1956 new_state
= callee_state
;
1958 if (new_state
!= l
->malloc_state
)
1961 l
->malloc_state
= new_state
;
1966 FOR_EACH_DEFINED_FUNCTION (node
)
1967 if (funct_state_summaries
->exists (node
))
1969 funct_state l
= funct_state_summaries
->get (node
);
1971 && l
->malloc_state
== STATE_MALLOC
1972 && !node
->inlined_to
)
1974 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1975 fprintf (dump_file
, "Function %s found to be malloc\n",
1976 node
->dump_name ());
1978 bool malloc_decl_p
= DECL_IS_MALLOC (node
->decl
);
1979 node
->set_malloc_flag (true);
1980 if (!malloc_decl_p
&& warn_suggest_attribute_malloc
)
1981 warn_function_malloc (node
->decl
);
1985 dump_malloc_lattice (dump_file
, "after propagation");
1986 ipa_free_postorder_info ();
1990 /* Produce the global information by preforming a transitive closure
1991 on the local information that was produced by generate_summary. */
1994 pass_ipa_pure_const::
1995 execute (function
*)
1999 /* Nothrow makes more function to not lead to return and improve
2001 propagate_nothrow ();
2002 propagate_malloc ();
2003 remove_p
= propagate_pure_const ();
2005 delete funct_state_summaries
;
2006 return remove_p
? TODO_remove_functions
: 0;
2010 gate_pure_const (void)
2012 return flag_ipa_pure_const
|| in_lto_p
;
2015 pass_ipa_pure_const::pass_ipa_pure_const(gcc::context
*ctxt
)
2016 : ipa_opt_pass_d(pass_data_ipa_pure_const
, ctxt
,
2017 pure_const_generate_summary
, /* generate_summary */
2018 pure_const_write_summary
, /* write_summary */
2019 pure_const_read_summary
, /* read_summary */
2020 NULL
, /* write_optimization_summary */
2021 NULL
, /* read_optimization_summary */
2022 NULL
, /* stmt_fixup */
2023 0, /* function_transform_todo_flags_start */
2024 NULL
, /* function_transform */
2025 NULL
), /* variable_transform */
2029 make_pass_ipa_pure_const (gcc::context
*ctxt
)
2031 return new pass_ipa_pure_const (ctxt
);
2034 /* Return true if function should be skipped for local pure const analysis. */
2037 skip_function_for_local_pure_const (struct cgraph_node
*node
)
2039 /* Because we do not schedule pass_fixup_cfg over whole program after early
2040 optimizations we must not promote functions that are called by already
2041 processed functions. */
2043 if (function_called_by_processed_nodes_p ())
2046 fprintf (dump_file
, "Function called in recursive cycle; ignoring\n");
2049 /* Save some work and do not analyze functions which are interposable and
2050 do not have any non-interposable aliases. */
2051 if (node
->get_availability () <= AVAIL_INTERPOSABLE
2052 && !node
->has_aliases_p ())
2056 "Function is interposable; not analyzing.\n");
2062 /* Simple local pass for pure const discovery reusing the analysis from
2063 ipa_pure_const. This pass is effective when executed together with
2064 other optimization passes in early optimization pass queue. */
2068 const pass_data pass_data_local_pure_const
=
2070 GIMPLE_PASS
, /* type */
2071 "local-pure-const", /* name */
2072 OPTGROUP_NONE
, /* optinfo_flags */
2073 TV_IPA_PURE_CONST
, /* tv_id */
2074 0, /* properties_required */
2075 0, /* properties_provided */
2076 0, /* properties_destroyed */
2077 0, /* todo_flags_start */
2078 0, /* todo_flags_finish */
2081 class pass_local_pure_const
: public gimple_opt_pass
2084 pass_local_pure_const (gcc::context
*ctxt
)
2085 : gimple_opt_pass (pass_data_local_pure_const
, ctxt
)
2088 /* opt_pass methods: */
2089 opt_pass
* clone () { return new pass_local_pure_const (m_ctxt
); }
2090 virtual bool gate (function
*) { return gate_pure_const (); }
2091 virtual unsigned int execute (function
*);
2093 }; // class pass_local_pure_const
2096 pass_local_pure_const::execute (function
*fun
)
2098 bool changed
= false;
2101 struct cgraph_node
*node
;
2103 node
= cgraph_node::get (current_function_decl
);
2104 skip
= skip_function_for_local_pure_const (node
);
2106 if (!warn_suggest_attribute_const
2107 && !warn_suggest_attribute_pure
2111 l
= analyze_function (node
, false);
2113 /* Do NORETURN discovery. */
2114 if (!skip
&& !TREE_THIS_VOLATILE (current_function_decl
)
2115 && EDGE_COUNT (EXIT_BLOCK_PTR_FOR_FN (fun
)->preds
) == 0)
2117 warn_function_noreturn (fun
->decl
);
2119 fprintf (dump_file
, "Function found to be noreturn: %s\n",
2120 current_function_name ());
2122 /* Update declaration and reduce profile to executed once. */
2123 TREE_THIS_VOLATILE (current_function_decl
) = 1;
2124 if (node
->frequency
> NODE_FREQUENCY_EXECUTED_ONCE
)
2125 node
->frequency
= NODE_FREQUENCY_EXECUTED_ONCE
;
2130 switch (l
->pure_const_state
)
2133 if (!TREE_READONLY (current_function_decl
))
2135 warn_function_const (current_function_decl
, !l
->looping
);
2137 fprintf (dump_file
, "Function found to be %sconst: %s\n",
2138 l
->looping
? "looping " : "",
2139 current_function_name ());
2141 else if (DECL_LOOPING_CONST_OR_PURE_P (current_function_decl
)
2145 fprintf (dump_file
, "Function found to be non-looping: %s\n",
2146 current_function_name ());
2148 if (!skip
&& node
->set_const_flag (true, l
->looping
))
2151 fprintf (dump_file
, "Declaration updated to be %sconst: %s\n",
2152 l
->looping
? "looping " : "",
2153 current_function_name ());
2159 if (!DECL_PURE_P (current_function_decl
))
2161 warn_function_pure (current_function_decl
, !l
->looping
);
2163 fprintf (dump_file
, "Function found to be %spure: %s\n",
2164 l
->looping
? "looping " : "",
2165 current_function_name ());
2167 else if (DECL_LOOPING_CONST_OR_PURE_P (current_function_decl
)
2171 fprintf (dump_file
, "Function found to be non-looping: %s\n",
2172 current_function_name ());
2174 if (!skip
&& node
->set_pure_flag (true, l
->looping
))
2177 fprintf (dump_file
, "Declaration updated to be %spure: %s\n",
2178 l
->looping
? "looping " : "",
2179 current_function_name ());
2187 if (!l
->can_throw
&& !TREE_NOTHROW (current_function_decl
))
2189 node
->set_nothrow_flag (true);
2192 fprintf (dump_file
, "Function found to be nothrow: %s\n",
2193 current_function_name ());
2196 if (l
->malloc_state
== STATE_MALLOC
2197 && !DECL_IS_MALLOC (current_function_decl
))
2199 node
->set_malloc_flag (true);
2200 if (warn_suggest_attribute_malloc
)
2201 warn_function_malloc (node
->decl
);
2204 fprintf (dump_file
, "Function found to be malloc: %s\n",
2205 node
->dump_name ());
2210 return execute_fixup_cfg ();
2218 make_pass_local_pure_const (gcc::context
*ctxt
)
2220 return new pass_local_pure_const (ctxt
);
2223 /* Emit noreturn warnings. */
2227 const pass_data pass_data_warn_function_noreturn
=
2229 GIMPLE_PASS
, /* type */
2230 "*warn_function_noreturn", /* name */
2231 OPTGROUP_NONE
, /* optinfo_flags */
2232 TV_NONE
, /* tv_id */
2233 PROP_cfg
, /* properties_required */
2234 0, /* properties_provided */
2235 0, /* properties_destroyed */
2236 0, /* todo_flags_start */
2237 0, /* todo_flags_finish */
2240 class pass_warn_function_noreturn
: public gimple_opt_pass
2243 pass_warn_function_noreturn (gcc::context
*ctxt
)
2244 : gimple_opt_pass (pass_data_warn_function_noreturn
, ctxt
)
2247 /* opt_pass methods: */
2248 virtual bool gate (function
*) { return warn_suggest_attribute_noreturn
; }
2249 virtual unsigned int execute (function
*fun
)
2251 if (!TREE_THIS_VOLATILE (current_function_decl
)
2252 && EDGE_COUNT (EXIT_BLOCK_PTR_FOR_FN (fun
)->preds
) == 0)
2253 warn_function_noreturn (current_function_decl
);
2257 }; // class pass_warn_function_noreturn
2262 make_pass_warn_function_noreturn (gcc::context
*ctxt
)
2264 return new pass_warn_function_noreturn (ctxt
);
2267 /* Simple local pass for pure const discovery reusing the analysis from
2268 ipa_pure_const. This pass is effective when executed together with
2269 other optimization passes in early optimization pass queue. */
2273 const pass_data pass_data_nothrow
=
2275 GIMPLE_PASS
, /* type */
2276 "nothrow", /* name */
2277 OPTGROUP_NONE
, /* optinfo_flags */
2278 TV_IPA_PURE_CONST
, /* tv_id */
2279 0, /* properties_required */
2280 0, /* properties_provided */
2281 0, /* properties_destroyed */
2282 0, /* todo_flags_start */
2283 0, /* todo_flags_finish */
2286 class pass_nothrow
: public gimple_opt_pass
2289 pass_nothrow (gcc::context
*ctxt
)
2290 : gimple_opt_pass (pass_data_nothrow
, ctxt
)
2293 /* opt_pass methods: */
2294 opt_pass
* clone () { return new pass_nothrow (m_ctxt
); }
2295 virtual bool gate (function
*) { return optimize
; }
2296 virtual unsigned int execute (function
*);
2298 }; // class pass_nothrow
2301 pass_nothrow::execute (function
*)
2303 struct cgraph_node
*node
;
2304 basic_block this_block
;
2306 if (TREE_NOTHROW (current_function_decl
))
2309 node
= cgraph_node::get (current_function_decl
);
2311 /* We run during lowering, we cannot really use availability yet. */
2312 if (cgraph_node::get (current_function_decl
)->get_availability ()
2313 <= AVAIL_INTERPOSABLE
)
2316 fprintf (dump_file
, "Function is interposable;"
2317 " not analyzing.\n");
2321 FOR_EACH_BB_FN (this_block
, cfun
)
2323 for (gimple_stmt_iterator gsi
= gsi_start_bb (this_block
);
2326 if (stmt_can_throw_external (cfun
, gsi_stmt (gsi
)))
2328 if (is_gimple_call (gsi_stmt (gsi
)))
2330 tree callee_t
= gimple_call_fndecl (gsi_stmt (gsi
));
2331 if (callee_t
&& recursive_call_p (current_function_decl
,
2338 fprintf (dump_file
, "Statement can throw: ");
2339 print_gimple_stmt (dump_file
, gsi_stmt (gsi
), 0);
2345 node
->set_nothrow_flag (true);
2347 bool cfg_changed
= false;
2348 if (self_recursive_p (node
))
2349 FOR_EACH_BB_FN (this_block
, cfun
)
2350 if (gimple
*g
= last_stmt (this_block
))
2351 if (is_gimple_call (g
))
2353 tree callee_t
= gimple_call_fndecl (g
);
2355 && recursive_call_p (current_function_decl
, callee_t
)
2356 && maybe_clean_eh_stmt (g
)
2357 && gimple_purge_dead_eh_edges (this_block
))
2362 fprintf (dump_file
, "Function found to be nothrow: %s\n",
2363 current_function_name ());
2364 return cfg_changed
? TODO_cleanup_cfg
: 0;
2370 make_pass_nothrow (gcc::context
*ctxt
)
2372 return new pass_nothrow (ctxt
);