1 /* Callgraph based analysis of static variables.
2 Copyright (C) 2004-2016 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 /* Lattice values for const and pure functions. Everything starts out
61 being const, then may drop to pure and then neither depending on
63 enum pure_const_state_e
70 const char *pure_const_names[3] = {"const", "pure", "neither"};
72 /* Holder for the const_state. There is one of these per function
77 enum pure_const_state_e pure_const_state;
78 /* What user set here; we can be always sure about this. */
79 enum pure_const_state_e state_previously_known;
80 bool looping_previously_known;
82 /* True if the function could possibly infinite loop. There are a
83 lot of ways that this could be determined. We are pretty
84 conservative here. While it is possible to cse pure and const
85 calls, it is not legal to have dce get rid of the call if there
86 is a possibility that the call could infinite loop since this is
87 a behavioral change. */
92 /* If function can call free, munmap or otherwise make previously
93 non-trapping memory accesses trapping. */
97 /* State used when we know nothing about function. */
98 static struct funct_state_d varying_state
99 = { IPA_NEITHER, IPA_NEITHER, true, true, true, true };
102 typedef struct funct_state_d * funct_state;
104 /* The storage of the funct_state is abstracted because there is the
105 possibility that it may be desirable to move this to the cgraph
108 /* Array, indexed by cgraph node uid, of function states. */
110 static vec<funct_state> funct_state_vec;
112 static bool gate_pure_const (void);
116 const pass_data pass_data_ipa_pure_const =
119 "pure-const", /* name */
120 OPTGROUP_NONE, /* optinfo_flags */
121 TV_IPA_PURE_CONST, /* tv_id */
122 0, /* properties_required */
123 0, /* properties_provided */
124 0, /* properties_destroyed */
125 0, /* todo_flags_start */
126 0, /* todo_flags_finish */
129 class pass_ipa_pure_const : public ipa_opt_pass_d
132 pass_ipa_pure_const(gcc::context *ctxt);
134 /* opt_pass methods: */
135 bool gate (function *) { return gate_pure_const (); }
136 unsigned int execute (function *fun);
138 void register_hooks (void);
143 /* Holders of ipa cgraph hooks: */
144 struct cgraph_node_hook_list *function_insertion_hook_holder;
145 struct cgraph_2node_hook_list *node_duplication_hook_holder;
146 struct cgraph_node_hook_list *node_removal_hook_holder;
148 }; // class pass_ipa_pure_const
152 /* Try to guess if function body will always be visible to compiler
153 when compiling the call and whether compiler will be able
154 to propagate the information by itself. */
157 function_always_visible_to_compiler_p (tree decl)
159 return (!TREE_PUBLIC (decl) || DECL_DECLARED_INLINE_P (decl));
162 /* Emit suggestion about attribute ATTRIB_NAME for DECL. KNOWN_FINITE
163 is true if the function is known to be finite. The diagnostic is
164 controlled by OPTION. WARNED_ABOUT is a hash_set<tree> unique for
165 OPTION, this function may initialize it and it is always returned
168 static hash_set<tree> *
169 suggest_attribute (int option, tree decl, bool known_finite,
170 hash_set<tree> *warned_about,
171 const char * attrib_name)
173 if (!option_enabled (option, &global_options))
175 if (TREE_THIS_VOLATILE (decl)
176 || (known_finite && function_always_visible_to_compiler_p (decl)))
180 warned_about = new hash_set<tree>;
181 if (warned_about->contains (decl))
183 warned_about->add (decl);
184 warning_at (DECL_SOURCE_LOCATION (decl),
187 ? _("function might be candidate for attribute %<%s%>")
188 : _("function might be candidate for attribute %<%s%>"
189 " if it is known to return normally"), attrib_name);
193 /* Emit suggestion about __attribute_((pure)) for DECL. KNOWN_FINITE
194 is true if the function is known to be finite. */
197 warn_function_pure (tree decl, bool known_finite)
199 static hash_set<tree> *warned_about;
202 = suggest_attribute (OPT_Wsuggest_attribute_pure, decl,
203 known_finite, warned_about, "pure");
206 /* Emit suggestion about __attribute_((const)) for DECL. KNOWN_FINITE
207 is true if the function is known to be finite. */
210 warn_function_const (tree decl, bool known_finite)
212 static hash_set<tree> *warned_about;
214 = suggest_attribute (OPT_Wsuggest_attribute_const, decl,
215 known_finite, warned_about, "const");
219 warn_function_noreturn (tree decl)
221 static hash_set<tree> *warned_about;
222 if (!lang_hooks.missing_noreturn_ok_p (decl)
223 && targetm.warn_func_return (decl))
225 = suggest_attribute (OPT_Wsuggest_attribute_noreturn, decl,
226 true, warned_about, "noreturn");
229 /* Return true if we have a function state for NODE. */
232 has_function_state (struct cgraph_node *node)
234 if (!funct_state_vec.exists ()
235 || funct_state_vec.length () <= (unsigned int)node->uid)
237 return funct_state_vec[node->uid] != NULL;
240 /* Return the function state from NODE. */
242 static inline funct_state
243 get_function_state (struct cgraph_node *node)
245 if (!funct_state_vec.exists ()
246 || funct_state_vec.length () <= (unsigned int)node->uid
247 || !funct_state_vec[node->uid])
248 /* We might want to put correct previously_known state into varying. */
249 return &varying_state;
250 return funct_state_vec[node->uid];
253 /* Set the function state S for NODE. */
256 set_function_state (struct cgraph_node *node, funct_state s)
258 if (!funct_state_vec.exists ()
259 || funct_state_vec.length () <= (unsigned int)node->uid)
260 funct_state_vec.safe_grow_cleared (node->uid + 1);
261 funct_state_vec[node->uid] = s;
264 /* Check to see if the use (or definition when CHECKING_WRITE is true)
265 variable T is legal in a function that is either pure or const. */
268 check_decl (funct_state local,
269 tree t, bool checking_write, bool ipa)
271 /* Do not want to do anything with volatile except mark any
272 function that uses one to be not const or pure. */
273 if (TREE_THIS_VOLATILE (t))
275 local->pure_const_state = IPA_NEITHER;
277 fprintf (dump_file, " Volatile operand is not const/pure");
281 /* Do not care about a local automatic that is not static. */
282 if (!TREE_STATIC (t) && !DECL_EXTERNAL (t))
285 /* If the variable has the "used" attribute, treat it as if it had a
286 been touched by the devil. */
287 if (DECL_PRESERVE_P (t))
289 local->pure_const_state = IPA_NEITHER;
291 fprintf (dump_file, " Used static/global variable is not const/pure\n");
295 /* In IPA mode we are not interested in checking actual loads and stores;
296 they will be processed at propagation time using ipa_ref. */
300 /* Since we have dealt with the locals and params cases above, if we
301 are CHECKING_WRITE, this cannot be a pure or constant
305 local->pure_const_state = IPA_NEITHER;
307 fprintf (dump_file, " static/global memory write is not const/pure\n");
311 if (DECL_EXTERNAL (t) || TREE_PUBLIC (t))
313 /* Readonly reads are safe. */
314 if (TREE_READONLY (t) && !TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (t)))
315 return; /* Read of a constant, do not change the function state. */
319 fprintf (dump_file, " global memory read is not const\n");
320 /* Just a regular read. */
321 if (local->pure_const_state == IPA_CONST)
322 local->pure_const_state = IPA_PURE;
327 /* Compilation level statics can be read if they are readonly
329 if (TREE_READONLY (t))
333 fprintf (dump_file, " static memory read is not const\n");
334 /* Just a regular read. */
335 if (local->pure_const_state == IPA_CONST)
336 local->pure_const_state = IPA_PURE;
341 /* Check to see if the use (or definition when CHECKING_WRITE is true)
342 variable T is legal in a function that is either pure or const. */
345 check_op (funct_state local, tree t, bool checking_write)
347 t = get_base_address (t);
348 if (t && TREE_THIS_VOLATILE (t))
350 local->pure_const_state = IPA_NEITHER;
352 fprintf (dump_file, " Volatile indirect ref is not const/pure\n");
356 && (INDIRECT_REF_P (t) || TREE_CODE (t) == MEM_REF)
357 && TREE_CODE (TREE_OPERAND (t, 0)) == SSA_NAME
358 && !ptr_deref_may_alias_global_p (TREE_OPERAND (t, 0)))
361 fprintf (dump_file, " Indirect ref to local memory is OK\n");
364 else if (checking_write)
366 local->pure_const_state = IPA_NEITHER;
368 fprintf (dump_file, " Indirect ref write is not const/pure\n");
374 fprintf (dump_file, " Indirect ref read is not const\n");
375 if (local->pure_const_state == IPA_CONST)
376 local->pure_const_state = IPA_PURE;
380 /* compute state based on ECF FLAGS and store to STATE and LOOPING. */
383 state_from_flags (enum pure_const_state_e *state, bool *looping,
384 int flags, bool cannot_lead_to_return)
387 if (flags & ECF_LOOPING_CONST_OR_PURE)
390 if (dump_file && (dump_flags & TDF_DETAILS))
391 fprintf (dump_file, " looping");
393 if (flags & ECF_CONST)
396 if (dump_file && (dump_flags & TDF_DETAILS))
397 fprintf (dump_file, " const\n");
399 else if (flags & ECF_PURE)
402 if (dump_file && (dump_flags & TDF_DETAILS))
403 fprintf (dump_file, " pure\n");
405 else if (cannot_lead_to_return)
409 if (dump_file && (dump_flags & TDF_DETAILS))
410 fprintf (dump_file, " ignoring side effects->pure looping\n");
414 if (dump_file && (dump_flags & TDF_DETAILS))
415 fprintf (dump_file, " neither\n");
416 *state = IPA_NEITHER;
421 /* Merge STATE and STATE2 and LOOPING and LOOPING2 and store
422 into STATE and LOOPING better of the two variants.
423 Be sure to merge looping correctly. IPA_NEITHER functions
424 have looping 0 even if they don't have to return. */
427 better_state (enum pure_const_state_e *state, bool *looping,
428 enum pure_const_state_e state2, bool looping2)
432 if (*state == IPA_NEITHER)
435 *looping = MIN (*looping, looping2);
438 else if (state2 != IPA_NEITHER)
439 *looping = MIN (*looping, looping2);
442 /* Merge STATE and STATE2 and LOOPING and LOOPING2 and store
443 into STATE and LOOPING worse of the two variants. */
446 worse_state (enum pure_const_state_e *state, bool *looping,
447 enum pure_const_state_e state2, bool looping2)
449 *state = MAX (*state, state2);
450 *looping = MAX (*looping, looping2);
453 /* Recognize special cases of builtins that are by themselves not pure or const
454 but function using them is. */
456 special_builtin_state (enum pure_const_state_e *state, bool *looping,
459 if (DECL_BUILT_IN_CLASS (callee) == BUILT_IN_NORMAL)
460 switch (DECL_FUNCTION_CODE (callee))
462 case BUILT_IN_RETURN:
463 case BUILT_IN_UNREACHABLE:
464 case BUILT_IN_ALLOCA:
465 case BUILT_IN_ALLOCA_WITH_ALIGN:
466 case BUILT_IN_STACK_SAVE:
467 case BUILT_IN_STACK_RESTORE:
468 case BUILT_IN_EH_POINTER:
469 case BUILT_IN_EH_FILTER:
470 case BUILT_IN_UNWIND_RESUME:
471 case BUILT_IN_CXA_END_CLEANUP:
472 case BUILT_IN_EH_COPY_VALUES:
473 case BUILT_IN_FRAME_ADDRESS:
475 case BUILT_IN_APPLY_ARGS:
479 case BUILT_IN_PREFETCH:
489 /* Check the parameters of a function call to CALL_EXPR to see if
490 there are any references in the parameters that are not allowed for
491 pure or const functions. Also check to see if this is either an
492 indirect call, a call outside the compilation unit, or has special
493 attributes that may also effect the purity. The CALL_EXPR node for
494 the entire call expression. */
497 check_call (funct_state local, gcall *call, bool ipa)
499 int flags = gimple_call_flags (call);
500 tree callee_t = gimple_call_fndecl (call);
501 bool possibly_throws = stmt_could_throw_p (call);
502 bool possibly_throws_externally = (possibly_throws
503 && stmt_can_throw_external (call));
508 for (i = 0; i < gimple_num_ops (call); i++)
509 if (gimple_op (call, i)
510 && tree_could_throw_p (gimple_op (call, i)))
512 if (possibly_throws && cfun->can_throw_non_call_exceptions)
515 fprintf (dump_file, " operand can throw; looping\n");
516 local->looping = true;
518 if (possibly_throws_externally)
521 fprintf (dump_file, " operand can throw externally\n");
522 local->can_throw = true;
527 /* The const and pure flags are set by a variety of places in the
528 compiler (including here). If someone has already set the flags
529 for the callee, (such as for some of the builtins) we will use
530 them, otherwise we will compute our own information.
532 Const and pure functions have less clobber effects than other
533 functions so we process these first. Otherwise if it is a call
534 outside the compilation unit or an indirect call we punt. This
535 leaves local calls which will be processed by following the call
539 enum pure_const_state_e call_state;
542 if (gimple_call_builtin_p (call, BUILT_IN_NORMAL)
543 && !nonfreeing_call_p (call))
544 local->can_free = true;
546 if (special_builtin_state (&call_state, &call_looping, callee_t))
548 worse_state (&local->pure_const_state, &local->looping,
549 call_state, call_looping);
552 /* When bad things happen to bad functions, they cannot be const
554 if (setjmp_call_p (callee_t))
557 fprintf (dump_file, " setjmp is not const/pure\n");
558 local->looping = true;
559 local->pure_const_state = IPA_NEITHER;
562 if (DECL_BUILT_IN_CLASS (callee_t) == BUILT_IN_NORMAL)
563 switch (DECL_FUNCTION_CODE (callee_t))
565 case BUILT_IN_LONGJMP:
566 case BUILT_IN_NONLOCAL_GOTO:
568 fprintf (dump_file, " longjmp and nonlocal goto is not const/pure\n");
569 local->pure_const_state = IPA_NEITHER;
570 local->looping = true;
576 else if (gimple_call_internal_p (call) && !nonfreeing_call_p (call))
577 local->can_free = true;
579 /* When not in IPA mode, we can still handle self recursion. */
581 && recursive_call_p (current_function_decl, callee_t))
584 fprintf (dump_file, " Recursive call can loop.\n");
585 local->looping = true;
587 /* Either callee is unknown or we are doing local analysis.
588 Look to see if there are any bits available for the callee (such as by
589 declaration or because it is builtin) and process solely on the basis of
593 enum pure_const_state_e call_state;
595 if (possibly_throws && cfun->can_throw_non_call_exceptions)
598 fprintf (dump_file, " can throw; looping\n");
599 local->looping = true;
601 if (possibly_throws_externally)
605 fprintf (dump_file, " can throw externally to lp %i\n",
606 lookup_stmt_eh_lp (call));
608 fprintf (dump_file, " callee:%s\n",
609 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (callee_t)));
611 local->can_throw = true;
613 if (dump_file && (dump_flags & TDF_DETAILS))
614 fprintf (dump_file, " checking flags for call:");
615 state_from_flags (&call_state, &call_looping, flags,
616 ((flags & (ECF_NORETURN | ECF_NOTHROW))
617 == (ECF_NORETURN | ECF_NOTHROW))
618 || (!flag_exceptions && (flags & ECF_NORETURN)));
619 worse_state (&local->pure_const_state, &local->looping,
620 call_state, call_looping);
622 /* Direct functions calls are handled by IPA propagation. */
625 /* Wrapper around check_decl for loads in local more. */
628 check_load (gimple *, tree op, tree, void *data)
631 check_decl ((funct_state)data, op, false, false);
633 check_op ((funct_state)data, op, false);
637 /* Wrapper around check_decl for stores in local more. */
640 check_store (gimple *, tree op, tree, void *data)
643 check_decl ((funct_state)data, op, true, false);
645 check_op ((funct_state)data, op, true);
649 /* Wrapper around check_decl for loads in ipa mode. */
652 check_ipa_load (gimple *, tree op, tree, void *data)
655 check_decl ((funct_state)data, op, false, true);
657 check_op ((funct_state)data, op, false);
661 /* Wrapper around check_decl for stores in ipa mode. */
664 check_ipa_store (gimple *, tree op, tree, void *data)
667 check_decl ((funct_state)data, op, true, true);
669 check_op ((funct_state)data, op, true);
673 /* Look into pointer pointed to by GSIP and figure out what interesting side
676 check_stmt (gimple_stmt_iterator *gsip, funct_state local, bool ipa)
678 gimple *stmt = gsi_stmt (*gsip);
680 if (is_gimple_debug (stmt))
683 /* Do consider clobber as side effects before IPA, so we rather inline
684 C++ destructors and keep clobber semantics than eliminate them.
686 TODO: We may get smarter during early optimizations on these and let
687 functions containing only clobbers to be optimized more. This is a common
688 case of C++ destructors. */
690 if ((ipa || cfun->after_inlining) && gimple_clobber_p (stmt))
695 fprintf (dump_file, " scanning: ");
696 print_gimple_stmt (dump_file, stmt, 0, 0);
699 if (gimple_has_volatile_ops (stmt)
700 && !gimple_clobber_p (stmt))
702 local->pure_const_state = IPA_NEITHER;
704 fprintf (dump_file, " Volatile stmt is not const/pure\n");
707 /* Look for loads and stores. */
708 walk_stmt_load_store_ops (stmt, local,
709 ipa ? check_ipa_load : check_load,
710 ipa ? check_ipa_store : check_store);
712 if (gimple_code (stmt) != GIMPLE_CALL
713 && stmt_could_throw_p (stmt))
715 if (cfun->can_throw_non_call_exceptions)
718 fprintf (dump_file, " can throw; looping\n");
719 local->looping = true;
721 if (stmt_can_throw_external (stmt))
724 fprintf (dump_file, " can throw externally\n");
725 local->can_throw = true;
729 fprintf (dump_file, " can throw\n");
731 switch (gimple_code (stmt))
734 check_call (local, as_a <gcall *> (stmt), ipa);
737 if (DECL_NONLOCAL (gimple_label_label (as_a <glabel *> (stmt))))
738 /* Target of long jump. */
741 fprintf (dump_file, " nonlocal label is not const/pure\n");
742 local->pure_const_state = IPA_NEITHER;
746 if (gimple_asm_clobbers_memory_p (as_a <gasm *> (stmt)))
749 fprintf (dump_file, " memory asm clobber is not const/pure\n");
750 /* Abandon all hope, ye who enter here. */
751 local->pure_const_state = IPA_NEITHER;
752 local->can_free = true;
754 if (gimple_asm_volatile_p (as_a <gasm *> (stmt)))
757 fprintf (dump_file, " volatile is not const/pure\n");
758 /* Abandon all hope, ye who enter here. */
759 local->pure_const_state = IPA_NEITHER;
760 local->looping = true;
761 local->can_free = true;
770 /* This is the main routine for finding the reference patterns for
771 global variables within a function FN. */
774 analyze_function (struct cgraph_node *fn, bool ipa)
776 tree decl = fn->decl;
778 basic_block this_block;
780 l = XCNEW (struct funct_state_d);
781 l->pure_const_state = IPA_CONST;
782 l->state_previously_known = IPA_NEITHER;
783 l->looping_previously_known = true;
785 l->can_throw = false;
787 state_from_flags (&l->state_previously_known, &l->looping_previously_known,
788 flags_from_decl_or_type (fn->decl),
789 fn->cannot_return_p ());
791 if (fn->thunk.thunk_p || fn->alias)
793 /* Thunk gets propagated through, so nothing interesting happens. */
795 if (fn->thunk.thunk_p && fn->thunk.virtual_offset_p)
796 l->pure_const_state = IPA_NEITHER;
802 fprintf (dump_file, "\n\n local analysis of %s\n ",
806 push_cfun (DECL_STRUCT_FUNCTION (decl));
808 FOR_EACH_BB_FN (this_block, cfun)
810 gimple_stmt_iterator gsi;
811 struct walk_stmt_info wi;
813 memset (&wi, 0, sizeof (wi));
814 for (gsi = gsi_start_bb (this_block);
818 check_stmt (&gsi, l, ipa);
819 if (l->pure_const_state == IPA_NEITHER
828 if (l->pure_const_state != IPA_NEITHER)
830 /* Const functions cannot have back edges (an
831 indication of possible infinite loop side
833 if (mark_dfs_back_edges ())
835 /* Preheaders are needed for SCEV to work.
836 Simple latches and recorded exits improve chances that loop will
837 proved to be finite in testcases such as in loop-15.c
839 loop_optimizer_init (LOOPS_HAVE_PREHEADERS
840 | LOOPS_HAVE_SIMPLE_LATCHES
841 | LOOPS_HAVE_RECORDED_EXITS);
842 if (dump_file && (dump_flags & TDF_DETAILS))
843 flow_loops_dump (dump_file, NULL, 0);
844 if (mark_irreducible_loops ())
847 fprintf (dump_file, " has irreducible loops\n");
854 FOR_EACH_LOOP (loop, 0)
855 if (!finite_loop_p (loop))
858 fprintf (dump_file, " can not prove finiteness of "
859 "loop %i\n", loop->num);
865 loop_optimizer_finalize ();
869 if (dump_file && (dump_flags & TDF_DETAILS))
870 fprintf (dump_file, " checking previously known:");
872 better_state (&l->pure_const_state, &l->looping,
873 l->state_previously_known,
874 l->looping_previously_known);
875 if (TREE_NOTHROW (decl))
876 l->can_throw = false;
882 fprintf (dump_file, "Function is locally looping.\n");
884 fprintf (dump_file, "Function is locally throwing.\n");
885 if (l->pure_const_state == IPA_CONST)
886 fprintf (dump_file, "Function is locally const.\n");
887 if (l->pure_const_state == IPA_PURE)
888 fprintf (dump_file, "Function is locally pure.\n");
890 fprintf (dump_file, "Function can locally free.\n");
895 /* Called when new function is inserted to callgraph late. */
897 add_new_function (struct cgraph_node *node, void *data ATTRIBUTE_UNUSED)
899 if (node->get_availability () < AVAIL_INTERPOSABLE)
901 /* There are some shared nodes, in particular the initializers on
902 static declarations. We do not need to scan them more than once
903 since all we would be interested in are the addressof
905 if (node->get_availability () > AVAIL_INTERPOSABLE
906 && opt_for_fn (node->decl, flag_ipa_pure_const))
907 set_function_state (node, analyze_function (node, true));
910 /* Called when new clone is inserted to callgraph late. */
913 duplicate_node_data (struct cgraph_node *src, struct cgraph_node *dst,
914 void *data ATTRIBUTE_UNUSED)
916 if (has_function_state (src))
918 funct_state l = XNEW (struct funct_state_d);
919 gcc_assert (!has_function_state (dst));
920 memcpy (l, get_function_state (src), sizeof (*l));
921 set_function_state (dst, l);
925 /* Called when new clone is inserted to callgraph late. */
928 remove_node_data (struct cgraph_node *node, void *data ATTRIBUTE_UNUSED)
930 if (has_function_state (node))
932 funct_state l = get_function_state (node);
933 if (l != &varying_state)
935 set_function_state (node, NULL);
941 pass_ipa_pure_const::
942 register_hooks (void)
949 node_removal_hook_holder =
950 symtab->add_cgraph_removal_hook (&remove_node_data, NULL);
951 node_duplication_hook_holder =
952 symtab->add_cgraph_duplication_hook (&duplicate_node_data, NULL);
953 function_insertion_hook_holder =
954 symtab->add_cgraph_insertion_hook (&add_new_function, NULL);
958 /* Analyze each function in the cgraph to see if it is locally PURE or
962 pure_const_generate_summary (void)
964 struct cgraph_node *node;
966 pass_ipa_pure_const *pass = static_cast <pass_ipa_pure_const *> (current_pass);
967 pass->register_hooks ();
969 /* Process all of the functions.
971 We process AVAIL_INTERPOSABLE functions. We can not use the results
972 by default, but the info can be used at LTO with -fwhole-program or
973 when function got cloned and the clone is AVAILABLE. */
975 FOR_EACH_DEFINED_FUNCTION (node)
976 if (node->get_availability () >= AVAIL_INTERPOSABLE
977 && opt_for_fn (node->decl, flag_ipa_pure_const))
978 set_function_state (node, analyze_function (node, true));
982 /* Serialize the ipa info for lto. */
985 pure_const_write_summary (void)
987 struct cgraph_node *node;
988 struct lto_simple_output_block *ob
989 = lto_create_simple_output_block (LTO_section_ipa_pure_const);
990 unsigned int count = 0;
991 lto_symtab_encoder_iterator lsei;
992 lto_symtab_encoder_t encoder;
994 encoder = lto_get_out_decl_state ()->symtab_node_encoder;
996 for (lsei = lsei_start_function_in_partition (encoder); !lsei_end_p (lsei);
997 lsei_next_function_in_partition (&lsei))
999 node = lsei_cgraph_node (lsei);
1000 if (node->definition && has_function_state (node))
1004 streamer_write_uhwi_stream (ob->main_stream, count);
1006 /* Process all of the functions. */
1007 for (lsei = lsei_start_function_in_partition (encoder); !lsei_end_p (lsei);
1008 lsei_next_function_in_partition (&lsei))
1010 node = lsei_cgraph_node (lsei);
1011 if (node->definition && has_function_state (node))
1013 struct bitpack_d bp;
1016 lto_symtab_encoder_t encoder;
1018 fs = get_function_state (node);
1020 encoder = ob->decl_state->symtab_node_encoder;
1021 node_ref = lto_symtab_encoder_encode (encoder, node);
1022 streamer_write_uhwi_stream (ob->main_stream, node_ref);
1024 /* Note that flags will need to be read in the opposite
1025 order as we are pushing the bitflags into FLAGS. */
1026 bp = bitpack_create (ob->main_stream);
1027 bp_pack_value (&bp, fs->pure_const_state, 2);
1028 bp_pack_value (&bp, fs->state_previously_known, 2);
1029 bp_pack_value (&bp, fs->looping_previously_known, 1);
1030 bp_pack_value (&bp, fs->looping, 1);
1031 bp_pack_value (&bp, fs->can_throw, 1);
1032 bp_pack_value (&bp, fs->can_free, 1);
1033 streamer_write_bitpack (&bp);
1037 lto_destroy_simple_output_block (ob);
1041 /* Deserialize the ipa info for lto. */
1044 pure_const_read_summary (void)
1046 struct lto_file_decl_data **file_data_vec = lto_get_file_decl_data ();
1047 struct lto_file_decl_data *file_data;
1050 pass_ipa_pure_const *pass = static_cast <pass_ipa_pure_const *> (current_pass);
1051 pass->register_hooks ();
1053 while ((file_data = file_data_vec[j++]))
1057 struct lto_input_block *ib
1058 = lto_create_simple_input_block (file_data,
1059 LTO_section_ipa_pure_const,
1064 unsigned int count = streamer_read_uhwi (ib);
1066 for (i = 0; i < count; i++)
1069 struct cgraph_node *node;
1070 struct bitpack_d bp;
1072 lto_symtab_encoder_t encoder;
1074 fs = XCNEW (struct funct_state_d);
1075 index = streamer_read_uhwi (ib);
1076 encoder = file_data->symtab_node_encoder;
1077 node = dyn_cast<cgraph_node *> (lto_symtab_encoder_deref (encoder,
1079 set_function_state (node, fs);
1081 /* Note that the flags must be read in the opposite
1082 order in which they were written (the bitflags were
1083 pushed into FLAGS). */
1084 bp = streamer_read_bitpack (ib);
1085 fs->pure_const_state
1086 = (enum pure_const_state_e) bp_unpack_value (&bp, 2);
1087 fs->state_previously_known
1088 = (enum pure_const_state_e) bp_unpack_value (&bp, 2);
1089 fs->looping_previously_known = bp_unpack_value (&bp, 1);
1090 fs->looping = bp_unpack_value (&bp, 1);
1091 fs->can_throw = bp_unpack_value (&bp, 1);
1092 fs->can_free = bp_unpack_value (&bp, 1);
1095 int flags = flags_from_decl_or_type (node->decl);
1096 fprintf (dump_file, "Read info for %s/%i ",
1099 if (flags & ECF_CONST)
1100 fprintf (dump_file, " const");
1101 if (flags & ECF_PURE)
1102 fprintf (dump_file, " pure");
1103 if (flags & ECF_NOTHROW)
1104 fprintf (dump_file, " nothrow");
1105 fprintf (dump_file, "\n pure const state: %s\n",
1106 pure_const_names[fs->pure_const_state]);
1107 fprintf (dump_file, " previously known state: %s\n",
1108 pure_const_names[fs->looping_previously_known]);
1110 fprintf (dump_file," function is locally looping\n");
1111 if (fs->looping_previously_known)
1112 fprintf (dump_file," function is previously known looping\n");
1114 fprintf (dump_file," function is locally throwing\n");
1116 fprintf (dump_file," function can locally free\n");
1120 lto_destroy_simple_input_block (file_data,
1121 LTO_section_ipa_pure_const,
1127 /* We only propagate across edges that can throw externally and their callee
1128 is not interposable. */
1131 ignore_edge_for_nothrow (struct cgraph_edge *e)
1133 if (!e->can_throw_external || TREE_NOTHROW (e->callee->decl))
1136 enum availability avail;
1137 cgraph_node *n = e->callee->function_or_virtual_thunk_symbol (&avail);
1138 return (avail <= AVAIL_INTERPOSABLE || TREE_NOTHROW (n->decl));
1141 /* Return true if NODE is self recursive function.
1142 Indirectly recursive functions appears as non-trivial strongly
1143 connected components, so we need to care about self recursion
1147 self_recursive_p (struct cgraph_node *node)
1149 struct cgraph_edge *e;
1150 for (e = node->callees; e; e = e->next_callee)
1151 if (e->callee->function_symbol () == node)
1156 /* Return true if N is cdtor that is not const or pure. In this case we may
1157 need to remove unreachable function if it is marked const/pure. */
1160 cdtor_p (cgraph_node *n, void *)
1162 if (DECL_STATIC_CONSTRUCTOR (n->decl) || DECL_STATIC_DESTRUCTOR (n->decl))
1163 return ((!TREE_READONLY (n->decl) && !DECL_PURE_P (n->decl))
1164 || DECL_LOOPING_CONST_OR_PURE_P (n->decl));
1168 /* We only propagate across edges with non-interposable callee. */
1171 ignore_edge_for_pure_const (struct cgraph_edge *e)
1173 enum availability avail;
1174 e->callee->function_or_virtual_thunk_symbol (&avail);
1175 return (avail <= AVAIL_INTERPOSABLE);
1179 /* Produce transitive closure over the callgraph and compute pure/const
1183 propagate_pure_const (void)
1185 struct cgraph_node *node;
1186 struct cgraph_node *w;
1187 struct cgraph_node **order =
1188 XCNEWVEC (struct cgraph_node *, symtab->cgraph_count);
1191 struct ipa_dfs_info * w_info;
1192 bool remove_p = false;
1194 order_pos = ipa_reduced_postorder (order, true, false,
1195 ignore_edge_for_pure_const);
1198 cgraph_node::dump_cgraph (dump_file);
1199 ipa_print_order (dump_file, "reduced", order, order_pos);
1202 /* Propagate the local information through the call graph to produce
1203 the global information. All the nodes within a cycle will have
1204 the same info so we collapse cycles first. Then we can do the
1205 propagation in one pass from the leaves to the roots. */
1206 for (i = 0; i < order_pos; i++ )
1208 enum pure_const_state_e pure_const_state = IPA_CONST;
1209 bool looping = false;
1216 if (dump_file && (dump_flags & TDF_DETAILS))
1217 fprintf (dump_file, "Starting cycle\n");
1219 /* Find the worst state for any node in the cycle. */
1221 while (w && pure_const_state != IPA_NEITHER)
1223 struct cgraph_edge *e;
1224 struct cgraph_edge *ie;
1226 struct ipa_ref *ref = NULL;
1228 funct_state w_l = get_function_state (w);
1229 if (dump_file && (dump_flags & TDF_DETAILS))
1230 fprintf (dump_file, " Visiting %s/%i state:%s looping %i\n",
1233 pure_const_names[w_l->pure_const_state],
1236 /* First merge in function body properties. */
1237 worse_state (&pure_const_state, &looping,
1238 w_l->pure_const_state, w_l->looping);
1239 if (pure_const_state == IPA_NEITHER)
1242 /* For interposable nodes we can not assume anything. */
1243 if (w->get_availability () == AVAIL_INTERPOSABLE)
1245 worse_state (&pure_const_state, &looping,
1246 w_l->state_previously_known,
1247 w_l->looping_previously_known);
1248 if (dump_file && (dump_flags & TDF_DETAILS))
1251 " Interposable. state %s looping %i\n",
1252 pure_const_names[w_l->state_previously_known],
1253 w_l->looping_previously_known);
1260 /* We consider recursive cycles as possibly infinite.
1261 This might be relaxed since infinite recursion leads to stack
1266 /* Now walk the edges and merge in callee properties. */
1267 for (e = w->callees; e && pure_const_state != IPA_NEITHER;
1270 enum availability avail;
1271 struct cgraph_node *y = e->callee->
1272 function_or_virtual_thunk_symbol (&avail);
1273 enum pure_const_state_e edge_state = IPA_CONST;
1274 bool edge_looping = false;
1276 if (dump_file && (dump_flags & TDF_DETAILS))
1283 if (avail > AVAIL_INTERPOSABLE)
1285 funct_state y_l = get_function_state (y);
1286 if (dump_file && (dump_flags & TDF_DETAILS))
1289 " state:%s looping:%i\n",
1290 pure_const_names[y_l->pure_const_state],
1293 if (y_l->pure_const_state > IPA_PURE
1294 && e->cannot_lead_to_return_p ())
1296 if (dump_file && (dump_flags & TDF_DETAILS))
1298 " Ignoring side effects"
1299 " -> pure, looping\n");
1300 edge_state = IPA_PURE;
1301 edge_looping = true;
1305 edge_state = y_l->pure_const_state;
1306 edge_looping = y_l->looping;
1309 else if (special_builtin_state (&edge_state, &edge_looping,
1313 state_from_flags (&edge_state, &edge_looping,
1314 flags_from_decl_or_type (y->decl),
1315 e->cannot_lead_to_return_p ());
1317 /* Merge the results with what we already know. */
1318 better_state (&edge_state, &edge_looping,
1319 w_l->state_previously_known,
1320 w_l->looping_previously_known);
1321 worse_state (&pure_const_state, &looping,
1322 edge_state, edge_looping);
1323 if (pure_const_state == IPA_NEITHER)
1327 /* Now process the indirect call. */
1328 for (ie = w->indirect_calls;
1329 ie && pure_const_state != IPA_NEITHER; ie = ie->next_callee)
1331 enum pure_const_state_e edge_state = IPA_CONST;
1332 bool edge_looping = false;
1334 if (dump_file && (dump_flags & TDF_DETAILS))
1335 fprintf (dump_file, " Indirect call");
1336 state_from_flags (&edge_state, &edge_looping,
1337 ie->indirect_info->ecf_flags,
1338 ie->cannot_lead_to_return_p ());
1339 /* Merge the results with what we already know. */
1340 better_state (&edge_state, &edge_looping,
1341 w_l->state_previously_known,
1342 w_l->looping_previously_known);
1343 worse_state (&pure_const_state, &looping,
1344 edge_state, edge_looping);
1345 if (pure_const_state == IPA_NEITHER)
1349 /* And finally all loads and stores. */
1350 for (i = 0; w->iterate_reference (i, ref)
1351 && pure_const_state != IPA_NEITHER; i++)
1353 enum pure_const_state_e ref_state = IPA_CONST;
1354 bool ref_looping = false;
1358 /* readonly reads are safe. */
1359 if (TREE_READONLY (ref->referred->decl))
1361 if (dump_file && (dump_flags & TDF_DETAILS))
1362 fprintf (dump_file, " nonreadonly global var read\n");
1363 ref_state = IPA_PURE;
1366 if (ref->cannot_lead_to_return ())
1368 ref_state = IPA_NEITHER;
1369 if (dump_file && (dump_flags & TDF_DETAILS))
1370 fprintf (dump_file, " global var write\n");
1378 better_state (&ref_state, &ref_looping,
1379 w_l->state_previously_known,
1380 w_l->looping_previously_known);
1381 worse_state (&pure_const_state, &looping,
1382 ref_state, ref_looping);
1383 if (pure_const_state == IPA_NEITHER)
1386 w_info = (struct ipa_dfs_info *) w->aux;
1387 w = w_info->next_cycle;
1389 if (dump_file && (dump_flags & TDF_DETAILS))
1390 fprintf (dump_file, "Result %s looping %i\n",
1391 pure_const_names [pure_const_state],
1394 /* Find the worst state of can_free for any node in the cycle. */
1395 bool can_free = false;
1397 while (w && !can_free)
1399 struct cgraph_edge *e;
1400 funct_state w_l = get_function_state (w);
1403 || w->get_availability () == AVAIL_INTERPOSABLE
1404 || w->indirect_calls)
1407 for (e = w->callees; e && !can_free; e = e->next_callee)
1409 enum availability avail;
1410 struct cgraph_node *y = e->callee->
1411 function_or_virtual_thunk_symbol (&avail);
1413 if (avail > AVAIL_INTERPOSABLE)
1414 can_free = get_function_state (y)->can_free;
1418 w_info = (struct ipa_dfs_info *) w->aux;
1419 w = w_info->next_cycle;
1422 /* Copy back the region's pure_const_state which is shared by
1423 all nodes in the region. */
1427 funct_state w_l = get_function_state (w);
1428 enum pure_const_state_e this_state = pure_const_state;
1429 bool this_looping = looping;
1431 w_l->can_free = can_free;
1432 w->nonfreeing_fn = !can_free;
1433 if (!can_free && dump_file)
1434 fprintf (dump_file, "Function found not to call free: %s\n",
1437 if (w_l->state_previously_known != IPA_NEITHER
1438 && this_state > w_l->state_previously_known)
1440 this_state = w_l->state_previously_known;
1441 if (this_state == IPA_NEITHER)
1442 this_looping = w_l->looping_previously_known;
1444 if (!this_looping && self_recursive_p (w))
1445 this_looping = true;
1446 if (!w_l->looping_previously_known)
1447 this_looping = false;
1449 /* All nodes within a cycle share the same info. */
1450 w_l->pure_const_state = this_state;
1451 w_l->looping = this_looping;
1453 /* Inline clones share declaration with their offline copies;
1454 do not modify their declarations since the offline copy may
1456 if (!w->global.inlined_to)
1460 if (!TREE_READONLY (w->decl))
1462 warn_function_const (w->decl, !this_looping);
1464 fprintf (dump_file, "Function found to be %sconst: %s\n",
1465 this_looping ? "looping " : "",
1468 remove_p |= w->call_for_symbol_and_aliases (cdtor_p,
1470 w->set_const_flag (true, this_looping);
1474 if (!DECL_PURE_P (w->decl))
1476 warn_function_pure (w->decl, !this_looping);
1478 fprintf (dump_file, "Function found to be %spure: %s\n",
1479 this_looping ? "looping " : "",
1482 remove_p |= w->call_for_symbol_and_aliases (cdtor_p,
1484 w->set_pure_flag (true, this_looping);
1490 w_info = (struct ipa_dfs_info *) w->aux;
1491 w = w_info->next_cycle;
1495 ipa_free_postorder_info ();
1500 /* Produce transitive closure over the callgraph and compute nothrow
1504 propagate_nothrow (void)
1506 struct cgraph_node *node;
1507 struct cgraph_node *w;
1508 struct cgraph_node **order =
1509 XCNEWVEC (struct cgraph_node *, symtab->cgraph_count);
1512 struct ipa_dfs_info * w_info;
1514 order_pos = ipa_reduced_postorder (order, true, false,
1515 ignore_edge_for_nothrow);
1518 cgraph_node::dump_cgraph (dump_file);
1519 ipa_print_order (dump_file, "reduced for nothrow", order, order_pos);
1522 /* Propagate the local information through the call graph to produce
1523 the global information. All the nodes within a cycle will have
1524 the same info so we collapse cycles first. Then we can do the
1525 propagation in one pass from the leaves to the roots. */
1526 for (i = 0; i < order_pos; i++ )
1528 bool can_throw = false;
1534 /* Find the worst state for any node in the cycle. */
1536 while (w && !can_throw)
1538 struct cgraph_edge *e, *ie;
1540 if (!TREE_NOTHROW (w->decl))
1542 funct_state w_l = get_function_state (w);
1545 || w->get_availability () == AVAIL_INTERPOSABLE)
1548 for (e = w->callees; e && !can_throw; e = e->next_callee)
1550 enum availability avail;
1552 if (!e->can_throw_external || TREE_NOTHROW (e->callee->decl))
1555 struct cgraph_node *y = e->callee->
1556 function_or_virtual_thunk_symbol (&avail);
1558 /* We can use info about the callee only if we know it can
1559 not be interposed. */
1560 if (avail <= AVAIL_INTERPOSABLE
1561 || (!TREE_NOTHROW (y->decl)
1562 && get_function_state (y)->can_throw))
1565 for (ie = w->indirect_calls; ie && !can_throw;
1566 ie = ie->next_callee)
1567 if (ie->can_throw_external
1568 && !(ie->indirect_info->ecf_flags & ECF_NOTHROW))
1571 w_info = (struct ipa_dfs_info *) w->aux;
1572 w = w_info->next_cycle;
1575 /* Copy back the region's pure_const_state which is shared by
1576 all nodes in the region. */
1580 funct_state w_l = get_function_state (w);
1581 if (!can_throw && !TREE_NOTHROW (w->decl))
1583 /* Inline clones share declaration with their offline copies;
1584 do not modify their declarations since the offline copy may
1586 if (!w->global.inlined_to)
1588 w->set_nothrow_flag (true);
1590 fprintf (dump_file, "Function found to be nothrow: %s\n",
1594 else if (can_throw && !TREE_NOTHROW (w->decl))
1595 w_l->can_throw = true;
1596 w_info = (struct ipa_dfs_info *) w->aux;
1597 w = w_info->next_cycle;
1601 ipa_free_postorder_info ();
1606 /* Produce the global information by preforming a transitive closure
1607 on the local information that was produced by generate_summary. */
1610 pass_ipa_pure_const::
1611 execute (function *)
1613 struct cgraph_node *node;
1616 symtab->remove_cgraph_insertion_hook (function_insertion_hook_holder);
1617 symtab->remove_cgraph_duplication_hook (node_duplication_hook_holder);
1618 symtab->remove_cgraph_removal_hook (node_removal_hook_holder);
1620 /* Nothrow makes more function to not lead to return and improve
1622 propagate_nothrow ();
1623 remove_p = propagate_pure_const ();
1626 FOR_EACH_FUNCTION (node)
1627 if (has_function_state (node))
1628 free (get_function_state (node));
1629 funct_state_vec.release ();
1630 return remove_p ? TODO_remove_functions : 0;
1634 gate_pure_const (void)
1636 return flag_ipa_pure_const || in_lto_p;
1639 pass_ipa_pure_const::pass_ipa_pure_const(gcc::context *ctxt)
1640 : ipa_opt_pass_d(pass_data_ipa_pure_const, ctxt,
1641 pure_const_generate_summary, /* generate_summary */
1642 pure_const_write_summary, /* write_summary */
1643 pure_const_read_summary, /* read_summary */
1644 NULL, /* write_optimization_summary */
1645 NULL, /* read_optimization_summary */
1646 NULL, /* stmt_fixup */
1647 0, /* function_transform_todo_flags_start */
1648 NULL, /* function_transform */
1649 NULL), /* variable_transform */
1651 function_insertion_hook_holder(NULL),
1652 node_duplication_hook_holder(NULL),
1653 node_removal_hook_holder(NULL)
1658 make_pass_ipa_pure_const (gcc::context *ctxt)
1660 return new pass_ipa_pure_const (ctxt);
1663 /* Return true if function should be skipped for local pure const analysis. */
1666 skip_function_for_local_pure_const (struct cgraph_node *node)
1668 /* Because we do not schedule pass_fixup_cfg over whole program after early optimizations
1669 we must not promote functions that are called by already processed functions. */
1671 if (function_called_by_processed_nodes_p ())
1674 fprintf (dump_file, "Function called in recursive cycle; ignoring\n");
1677 if (node->get_availability () <= AVAIL_INTERPOSABLE)
1680 fprintf (dump_file, "Function is not available or interposable; not analyzing.\n");
1686 /* Simple local pass for pure const discovery reusing the analysis from
1687 ipa_pure_const. This pass is effective when executed together with
1688 other optimization passes in early optimization pass queue. */
1692 const pass_data pass_data_local_pure_const =
1694 GIMPLE_PASS, /* type */
1695 "local-pure-const", /* name */
1696 OPTGROUP_NONE, /* optinfo_flags */
1697 TV_IPA_PURE_CONST, /* tv_id */
1698 0, /* properties_required */
1699 0, /* properties_provided */
1700 0, /* properties_destroyed */
1701 0, /* todo_flags_start */
1702 0, /* todo_flags_finish */
1705 class pass_local_pure_const : public gimple_opt_pass
1708 pass_local_pure_const (gcc::context *ctxt)
1709 : gimple_opt_pass (pass_data_local_pure_const, ctxt)
1712 /* opt_pass methods: */
1713 opt_pass * clone () { return new pass_local_pure_const (m_ctxt); }
1714 virtual bool gate (function *) { return gate_pure_const (); }
1715 virtual unsigned int execute (function *);
1717 }; // class pass_local_pure_const
1720 pass_local_pure_const::execute (function *fun)
1722 bool changed = false;
1725 struct cgraph_node *node;
1727 node = cgraph_node::get (current_function_decl);
1728 skip = skip_function_for_local_pure_const (node);
1729 if (!warn_suggest_attribute_const
1730 && !warn_suggest_attribute_pure
1734 l = analyze_function (node, false);
1736 /* Do NORETURN discovery. */
1737 if (!skip && !TREE_THIS_VOLATILE (current_function_decl)
1738 && EDGE_COUNT (EXIT_BLOCK_PTR_FOR_FN (fun)->preds) == 0)
1740 warn_function_noreturn (fun->decl);
1742 fprintf (dump_file, "Function found to be noreturn: %s\n",
1743 current_function_name ());
1745 /* Update declaration and reduce profile to executed once. */
1746 TREE_THIS_VOLATILE (current_function_decl) = 1;
1747 if (node->frequency > NODE_FREQUENCY_EXECUTED_ONCE)
1748 node->frequency = NODE_FREQUENCY_EXECUTED_ONCE;
1753 switch (l->pure_const_state)
1756 if (!TREE_READONLY (current_function_decl))
1758 warn_function_const (current_function_decl, !l->looping);
1761 node->set_const_flag (true, l->looping);
1765 fprintf (dump_file, "Function found to be %sconst: %s\n",
1766 l->looping ? "looping " : "",
1767 current_function_name ());
1769 else if (DECL_LOOPING_CONST_OR_PURE_P (current_function_decl)
1774 node->set_const_flag (true, false);
1778 fprintf (dump_file, "Function found to be non-looping: %s\n",
1779 current_function_name ());
1784 if (!DECL_PURE_P (current_function_decl))
1788 node->set_pure_flag (true, l->looping);
1791 warn_function_pure (current_function_decl, !l->looping);
1793 fprintf (dump_file, "Function found to be %spure: %s\n",
1794 l->looping ? "looping " : "",
1795 current_function_name ());
1797 else if (DECL_LOOPING_CONST_OR_PURE_P (current_function_decl)
1802 node->set_pure_flag (true, false);
1806 fprintf (dump_file, "Function found to be non-looping: %s\n",
1807 current_function_name ());
1814 if (!l->can_throw && !TREE_NOTHROW (current_function_decl))
1816 node->set_nothrow_flag (true);
1819 fprintf (dump_file, "Function found to be nothrow: %s\n",
1820 current_function_name ());
1824 return execute_fixup_cfg ();
1832 make_pass_local_pure_const (gcc::context *ctxt)
1834 return new pass_local_pure_const (ctxt);
1837 /* Emit noreturn warnings. */
1841 const pass_data pass_data_warn_function_noreturn =
1843 GIMPLE_PASS, /* type */
1844 "*warn_function_noreturn", /* name */
1845 OPTGROUP_NONE, /* optinfo_flags */
1846 TV_NONE, /* tv_id */
1847 PROP_cfg, /* properties_required */
1848 0, /* properties_provided */
1849 0, /* properties_destroyed */
1850 0, /* todo_flags_start */
1851 0, /* todo_flags_finish */
1854 class pass_warn_function_noreturn : public gimple_opt_pass
1857 pass_warn_function_noreturn (gcc::context *ctxt)
1858 : gimple_opt_pass (pass_data_warn_function_noreturn, ctxt)
1861 /* opt_pass methods: */
1862 virtual bool gate (function *) { return warn_suggest_attribute_noreturn; }
1863 virtual unsigned int execute (function *fun)
1865 if (!TREE_THIS_VOLATILE (current_function_decl)
1866 && EDGE_COUNT (EXIT_BLOCK_PTR_FOR_FN (fun)->preds) == 0)
1867 warn_function_noreturn (current_function_decl);
1871 }; // class pass_warn_function_noreturn
1876 make_pass_warn_function_noreturn (gcc::context *ctxt)
1878 return new pass_warn_function_noreturn (ctxt);
1881 /* Simple local pass for pure const discovery reusing the analysis from
1882 ipa_pure_const. This pass is effective when executed together with
1883 other optimization passes in early optimization pass queue. */
1887 const pass_data pass_data_nothrow =
1889 GIMPLE_PASS, /* type */
1890 "nothrow", /* name */
1891 OPTGROUP_NONE, /* optinfo_flags */
1892 TV_IPA_PURE_CONST, /* tv_id */
1893 0, /* properties_required */
1894 0, /* properties_provided */
1895 0, /* properties_destroyed */
1896 0, /* todo_flags_start */
1897 0, /* todo_flags_finish */
1900 class pass_nothrow : public gimple_opt_pass
1903 pass_nothrow (gcc::context *ctxt)
1904 : gimple_opt_pass (pass_data_nothrow, ctxt)
1907 /* opt_pass methods: */
1908 opt_pass * clone () { return new pass_nothrow (m_ctxt); }
1909 virtual bool gate (function *) { return optimize; }
1910 virtual unsigned int execute (function *);
1912 }; // class pass_nothrow
1915 pass_nothrow::execute (function *)
1917 struct cgraph_node *node;
1918 basic_block this_block;
1920 if (TREE_NOTHROW (current_function_decl))
1923 node = cgraph_node::get (current_function_decl);
1925 /* We run during lowering, we can not really use availability yet. */
1926 if (cgraph_node::get (current_function_decl)->get_availability ()
1927 <= AVAIL_INTERPOSABLE)
1930 fprintf (dump_file, "Function is interposable;"
1931 " not analyzing.\n");
1935 FOR_EACH_BB_FN (this_block, cfun)
1937 for (gimple_stmt_iterator gsi = gsi_start_bb (this_block);
1940 if (stmt_can_throw_external (gsi_stmt (gsi)))
1942 if (is_gimple_call (gsi_stmt (gsi)))
1944 tree callee_t = gimple_call_fndecl (gsi_stmt (gsi));
1945 if (callee_t && recursive_call_p (current_function_decl,
1952 fprintf (dump_file, "Statement can throw: ");
1953 print_gimple_stmt (dump_file, gsi_stmt (gsi), 0, 0);
1959 node->set_nothrow_flag (true);
1961 bool cfg_changed = false;
1962 if (self_recursive_p (node))
1963 FOR_EACH_BB_FN (this_block, cfun)
1964 if (gimple *g = last_stmt (this_block))
1965 if (is_gimple_call (g))
1967 tree callee_t = gimple_call_fndecl (g);
1969 && recursive_call_p (current_function_decl, callee_t)
1970 && maybe_clean_eh_stmt (g)
1971 && gimple_purge_dead_eh_edges (this_block))
1976 fprintf (dump_file, "Function found to be nothrow: %s\n",
1977 current_function_name ());
1978 return cfg_changed ? TODO_cleanup_cfg : 0;
1984 make_pass_nothrow (gcc::context *ctxt)
1986 return new pass_nothrow (ctxt);