1 /* Callgraph based analysis of static variables.
2 Copyright (C) 2004-2015 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"
40 #include "hard-reg-set.h"
42 #include "fold-const.h"
43 #include "print-tree.h"
46 #include "internal-fn.h"
48 #include "gimple-iterator.h"
49 #include "gimple-walk.h"
51 #include "tree-ssa-loop-niter.h"
52 #include "tree-inline.h"
53 #include "tree-pass.h"
54 #include "langhooks.h"
56 #include "ipa-utils.h"
58 #include "diagnostic.h"
59 #include "gimple-pretty-print.h"
60 #include "langhooks.h"
62 #include "lto-streamer.h"
63 #include "data-streamer.h"
64 #include "tree-streamer.h"
66 #include "tree-scalar-evolution.h"
71 /* Lattice values for const and pure functions. Everything starts out
72 being const, then may drop to pure and then neither depending on
74 enum pure_const_state_e
81 const char *pure_const_names
[3] = {"const", "pure", "neither"};
83 /* Holder for the const_state. There is one of these per function
88 enum pure_const_state_e pure_const_state
;
89 /* What user set here; we can be always sure about this. */
90 enum pure_const_state_e state_previously_known
;
91 bool looping_previously_known
;
93 /* True if the function could possibly infinite loop. There are a
94 lot of ways that this could be determined. We are pretty
95 conservative here. While it is possible to cse pure and const
96 calls, it is not legal to have dce get rid of the call if there
97 is a possibility that the call could infinite loop since this is
98 a behavioral change. */
103 /* If function can call free, munmap or otherwise make previously
104 non-trapping memory accesses trapping. */
108 /* State used when we know nothing about function. */
109 static struct funct_state_d varying_state
110 = { IPA_NEITHER
, IPA_NEITHER
, true, true, true, true };
113 typedef struct funct_state_d
* funct_state
;
115 /* The storage of the funct_state is abstracted because there is the
116 possibility that it may be desirable to move this to the cgraph
119 /* Array, indexed by cgraph node uid, of function states. */
121 static vec
<funct_state
> funct_state_vec
;
123 static bool gate_pure_const (void);
127 const pass_data pass_data_ipa_pure_const
=
130 "pure-const", /* name */
131 OPTGROUP_NONE
, /* optinfo_flags */
132 TV_IPA_PURE_CONST
, /* tv_id */
133 0, /* properties_required */
134 0, /* properties_provided */
135 0, /* properties_destroyed */
136 0, /* todo_flags_start */
137 0, /* todo_flags_finish */
140 class pass_ipa_pure_const
: public ipa_opt_pass_d
143 pass_ipa_pure_const(gcc::context
*ctxt
);
145 /* opt_pass methods: */
146 bool gate (function
*) { return gate_pure_const (); }
147 unsigned int execute (function
*fun
);
149 void register_hooks (void);
154 /* Holders of ipa cgraph hooks: */
155 struct cgraph_node_hook_list
*function_insertion_hook_holder
;
156 struct cgraph_2node_hook_list
*node_duplication_hook_holder
;
157 struct cgraph_node_hook_list
*node_removal_hook_holder
;
159 }; // class pass_ipa_pure_const
163 /* Try to guess if function body will always be visible to compiler
164 when compiling the call and whether compiler will be able
165 to propagate the information by itself. */
168 function_always_visible_to_compiler_p (tree decl
)
170 return (!TREE_PUBLIC (decl
) || DECL_DECLARED_INLINE_P (decl
));
173 /* Emit suggestion about attribute ATTRIB_NAME for DECL. KNOWN_FINITE
174 is true if the function is known to be finite. The diagnostic is
175 controlled by OPTION. WARNED_ABOUT is a hash_set<tree> unique for
176 OPTION, this function may initialize it and it is always returned
179 static hash_set
<tree
> *
180 suggest_attribute (int option
, tree decl
, bool known_finite
,
181 hash_set
<tree
> *warned_about
,
182 const char * attrib_name
)
184 if (!option_enabled (option
, &global_options
))
186 if (TREE_THIS_VOLATILE (decl
)
187 || (known_finite
&& function_always_visible_to_compiler_p (decl
)))
191 warned_about
= new hash_set
<tree
>;
192 if (warned_about
->contains (decl
))
194 warned_about
->add (decl
);
195 warning_at (DECL_SOURCE_LOCATION (decl
),
198 ? _("function might be candidate for attribute %<%s%>")
199 : _("function might be candidate for attribute %<%s%>"
200 " if it is known to return normally"), attrib_name
);
204 /* Emit suggestion about __attribute_((pure)) for DECL. KNOWN_FINITE
205 is true if the function is known to be finite. */
208 warn_function_pure (tree decl
, bool known_finite
)
210 static hash_set
<tree
> *warned_about
;
213 = suggest_attribute (OPT_Wsuggest_attribute_pure
, decl
,
214 known_finite
, warned_about
, "pure");
217 /* Emit suggestion about __attribute_((const)) for DECL. KNOWN_FINITE
218 is true if the function is known to be finite. */
221 warn_function_const (tree decl
, bool known_finite
)
223 static hash_set
<tree
> *warned_about
;
225 = suggest_attribute (OPT_Wsuggest_attribute_const
, decl
,
226 known_finite
, warned_about
, "const");
230 warn_function_noreturn (tree decl
)
232 static hash_set
<tree
> *warned_about
;
233 if (!lang_hooks
.missing_noreturn_ok_p (decl
)
234 && targetm
.warn_func_return (decl
))
236 = suggest_attribute (OPT_Wsuggest_attribute_noreturn
, decl
,
237 true, warned_about
, "noreturn");
240 /* Return true if we have a function state for NODE. */
243 has_function_state (struct cgraph_node
*node
)
245 if (!funct_state_vec
.exists ()
246 || funct_state_vec
.length () <= (unsigned int)node
->uid
)
248 return funct_state_vec
[node
->uid
] != NULL
;
251 /* Return the function state from NODE. */
253 static inline funct_state
254 get_function_state (struct cgraph_node
*node
)
256 if (!funct_state_vec
.exists ()
257 || funct_state_vec
.length () <= (unsigned int)node
->uid
258 || !funct_state_vec
[node
->uid
])
259 /* We might want to put correct previously_known state into varying. */
260 return &varying_state
;
261 return funct_state_vec
[node
->uid
];
264 /* Set the function state S for NODE. */
267 set_function_state (struct cgraph_node
*node
, funct_state s
)
269 if (!funct_state_vec
.exists ()
270 || funct_state_vec
.length () <= (unsigned int)node
->uid
)
271 funct_state_vec
.safe_grow_cleared (node
->uid
+ 1);
272 funct_state_vec
[node
->uid
] = s
;
275 /* Check to see if the use (or definition when CHECKING_WRITE is true)
276 variable T is legal in a function that is either pure or const. */
279 check_decl (funct_state local
,
280 tree t
, bool checking_write
, bool ipa
)
282 /* Do not want to do anything with volatile except mark any
283 function that uses one to be not const or pure. */
284 if (TREE_THIS_VOLATILE (t
))
286 local
->pure_const_state
= IPA_NEITHER
;
288 fprintf (dump_file
, " Volatile operand is not const/pure");
292 /* Do not care about a local automatic that is not static. */
293 if (!TREE_STATIC (t
) && !DECL_EXTERNAL (t
))
296 /* If the variable has the "used" attribute, treat it as if it had a
297 been touched by the devil. */
298 if (DECL_PRESERVE_P (t
))
300 local
->pure_const_state
= IPA_NEITHER
;
302 fprintf (dump_file
, " Used static/global variable is not const/pure\n");
306 /* In IPA mode we are not interested in checking actual loads and stores;
307 they will be processed at propagation time using ipa_ref. */
311 /* Since we have dealt with the locals and params cases above, if we
312 are CHECKING_WRITE, this cannot be a pure or constant
316 local
->pure_const_state
= IPA_NEITHER
;
318 fprintf (dump_file
, " static/global memory write is not const/pure\n");
322 if (DECL_EXTERNAL (t
) || TREE_PUBLIC (t
))
324 /* Readonly reads are safe. */
325 if (TREE_READONLY (t
) && !TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (t
)))
326 return; /* Read of a constant, do not change the function state. */
330 fprintf (dump_file
, " global memory read is not const\n");
331 /* Just a regular read. */
332 if (local
->pure_const_state
== IPA_CONST
)
333 local
->pure_const_state
= IPA_PURE
;
338 /* Compilation level statics can be read if they are readonly
340 if (TREE_READONLY (t
))
344 fprintf (dump_file
, " static memory read is not const\n");
345 /* Just a regular read. */
346 if (local
->pure_const_state
== IPA_CONST
)
347 local
->pure_const_state
= IPA_PURE
;
352 /* Check to see if the use (or definition when CHECKING_WRITE is true)
353 variable T is legal in a function that is either pure or const. */
356 check_op (funct_state local
, tree t
, bool checking_write
)
358 t
= get_base_address (t
);
359 if (t
&& TREE_THIS_VOLATILE (t
))
361 local
->pure_const_state
= IPA_NEITHER
;
363 fprintf (dump_file
, " Volatile indirect ref is not const/pure\n");
367 && (INDIRECT_REF_P (t
) || TREE_CODE (t
) == MEM_REF
)
368 && TREE_CODE (TREE_OPERAND (t
, 0)) == SSA_NAME
369 && !ptr_deref_may_alias_global_p (TREE_OPERAND (t
, 0)))
372 fprintf (dump_file
, " Indirect ref to local memory is OK\n");
375 else if (checking_write
)
377 local
->pure_const_state
= IPA_NEITHER
;
379 fprintf (dump_file
, " Indirect ref write is not const/pure\n");
385 fprintf (dump_file
, " Indirect ref read is not const\n");
386 if (local
->pure_const_state
== IPA_CONST
)
387 local
->pure_const_state
= IPA_PURE
;
391 /* compute state based on ECF FLAGS and store to STATE and LOOPING. */
394 state_from_flags (enum pure_const_state_e
*state
, bool *looping
,
395 int flags
, bool cannot_lead_to_return
)
398 if (flags
& ECF_LOOPING_CONST_OR_PURE
)
401 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
402 fprintf (dump_file
, " looping");
404 if (flags
& ECF_CONST
)
407 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
408 fprintf (dump_file
, " const\n");
410 else if (flags
& ECF_PURE
)
413 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
414 fprintf (dump_file
, " pure\n");
416 else if (cannot_lead_to_return
)
420 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
421 fprintf (dump_file
, " ignoring side effects->pure looping\n");
425 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
426 fprintf (dump_file
, " neither\n");
427 *state
= IPA_NEITHER
;
432 /* Merge STATE and STATE2 and LOOPING and LOOPING2 and store
433 into STATE and LOOPING better of the two variants.
434 Be sure to merge looping correctly. IPA_NEITHER functions
435 have looping 0 even if they don't have to return. */
438 better_state (enum pure_const_state_e
*state
, bool *looping
,
439 enum pure_const_state_e state2
, bool looping2
)
443 if (*state
== IPA_NEITHER
)
446 *looping
= MIN (*looping
, looping2
);
449 else if (state2
!= IPA_NEITHER
)
450 *looping
= MIN (*looping
, looping2
);
453 /* Merge STATE and STATE2 and LOOPING and LOOPING2 and store
454 into STATE and LOOPING worse of the two variants. */
457 worse_state (enum pure_const_state_e
*state
, bool *looping
,
458 enum pure_const_state_e state2
, bool looping2
)
460 *state
= MAX (*state
, state2
);
461 *looping
= MAX (*looping
, looping2
);
464 /* Recognize special cases of builtins that are by themselves not pure or const
465 but function using them is. */
467 special_builtin_state (enum pure_const_state_e
*state
, bool *looping
,
470 if (DECL_BUILT_IN_CLASS (callee
) == BUILT_IN_NORMAL
)
471 switch (DECL_FUNCTION_CODE (callee
))
473 case BUILT_IN_RETURN
:
474 case BUILT_IN_UNREACHABLE
:
475 case BUILT_IN_ALLOCA
:
476 case BUILT_IN_ALLOCA_WITH_ALIGN
:
477 case BUILT_IN_STACK_SAVE
:
478 case BUILT_IN_STACK_RESTORE
:
479 case BUILT_IN_EH_POINTER
:
480 case BUILT_IN_EH_FILTER
:
481 case BUILT_IN_UNWIND_RESUME
:
482 case BUILT_IN_CXA_END_CLEANUP
:
483 case BUILT_IN_EH_COPY_VALUES
:
484 case BUILT_IN_FRAME_ADDRESS
:
486 case BUILT_IN_APPLY_ARGS
:
490 case BUILT_IN_PREFETCH
:
500 /* Check the parameters of a function call to CALL_EXPR to see if
501 there are any references in the parameters that are not allowed for
502 pure or const functions. Also check to see if this is either an
503 indirect call, a call outside the compilation unit, or has special
504 attributes that may also effect the purity. The CALL_EXPR node for
505 the entire call expression. */
508 check_call (funct_state local
, gcall
*call
, bool ipa
)
510 int flags
= gimple_call_flags (call
);
511 tree callee_t
= gimple_call_fndecl (call
);
512 bool possibly_throws
= stmt_could_throw_p (call
);
513 bool possibly_throws_externally
= (possibly_throws
514 && stmt_can_throw_external (call
));
519 for (i
= 0; i
< gimple_num_ops (call
); i
++)
520 if (gimple_op (call
, i
)
521 && tree_could_throw_p (gimple_op (call
, i
)))
523 if (possibly_throws
&& cfun
->can_throw_non_call_exceptions
)
526 fprintf (dump_file
, " operand can throw; looping\n");
527 local
->looping
= true;
529 if (possibly_throws_externally
)
532 fprintf (dump_file
, " operand can throw externally\n");
533 local
->can_throw
= true;
538 /* The const and pure flags are set by a variety of places in the
539 compiler (including here). If someone has already set the flags
540 for the callee, (such as for some of the builtins) we will use
541 them, otherwise we will compute our own information.
543 Const and pure functions have less clobber effects than other
544 functions so we process these first. Otherwise if it is a call
545 outside the compilation unit or an indirect call we punt. This
546 leaves local calls which will be processed by following the call
550 enum pure_const_state_e call_state
;
553 if (gimple_call_builtin_p (call
, BUILT_IN_NORMAL
)
554 && !nonfreeing_call_p (call
))
555 local
->can_free
= true;
557 if (special_builtin_state (&call_state
, &call_looping
, callee_t
))
559 worse_state (&local
->pure_const_state
, &local
->looping
,
560 call_state
, call_looping
);
563 /* When bad things happen to bad functions, they cannot be const
565 if (setjmp_call_p (callee_t
))
568 fprintf (dump_file
, " setjmp is not const/pure\n");
569 local
->looping
= true;
570 local
->pure_const_state
= IPA_NEITHER
;
573 if (DECL_BUILT_IN_CLASS (callee_t
) == BUILT_IN_NORMAL
)
574 switch (DECL_FUNCTION_CODE (callee_t
))
576 case BUILT_IN_LONGJMP
:
577 case BUILT_IN_NONLOCAL_GOTO
:
579 fprintf (dump_file
, " longjmp and nonlocal goto is not const/pure\n");
580 local
->pure_const_state
= IPA_NEITHER
;
581 local
->looping
= true;
587 else if (gimple_call_internal_p (call
) && !nonfreeing_call_p (call
))
588 local
->can_free
= true;
590 /* When not in IPA mode, we can still handle self recursion. */
592 && recursive_call_p (current_function_decl
, callee_t
))
595 fprintf (dump_file
, " Recursive call can loop.\n");
596 local
->looping
= true;
598 /* Either callee is unknown or we are doing local analysis.
599 Look to see if there are any bits available for the callee (such as by
600 declaration or because it is builtin) and process solely on the basis of
604 enum pure_const_state_e call_state
;
606 if (possibly_throws
&& cfun
->can_throw_non_call_exceptions
)
609 fprintf (dump_file
, " can throw; looping\n");
610 local
->looping
= true;
612 if (possibly_throws_externally
)
616 fprintf (dump_file
, " can throw externally to lp %i\n",
617 lookup_stmt_eh_lp (call
));
619 fprintf (dump_file
, " callee:%s\n",
620 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (callee_t
)));
622 local
->can_throw
= true;
624 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
625 fprintf (dump_file
, " checking flags for call:");
626 state_from_flags (&call_state
, &call_looping
, flags
,
627 ((flags
& (ECF_NORETURN
| ECF_NOTHROW
))
628 == (ECF_NORETURN
| ECF_NOTHROW
))
629 || (!flag_exceptions
&& (flags
& ECF_NORETURN
)));
630 worse_state (&local
->pure_const_state
, &local
->looping
,
631 call_state
, call_looping
);
633 /* Direct functions calls are handled by IPA propagation. */
636 /* Wrapper around check_decl for loads in local more. */
639 check_load (gimple
, tree op
, tree
, void *data
)
642 check_decl ((funct_state
)data
, op
, false, false);
644 check_op ((funct_state
)data
, op
, false);
648 /* Wrapper around check_decl for stores in local more. */
651 check_store (gimple
, tree op
, tree
, void *data
)
654 check_decl ((funct_state
)data
, op
, true, false);
656 check_op ((funct_state
)data
, op
, true);
660 /* Wrapper around check_decl for loads in ipa mode. */
663 check_ipa_load (gimple
, tree op
, tree
, void *data
)
666 check_decl ((funct_state
)data
, op
, false, true);
668 check_op ((funct_state
)data
, op
, false);
672 /* Wrapper around check_decl for stores in ipa mode. */
675 check_ipa_store (gimple
, tree op
, tree
, void *data
)
678 check_decl ((funct_state
)data
, op
, true, true);
680 check_op ((funct_state
)data
, op
, true);
684 /* Look into pointer pointed to by GSIP and figure out what interesting side
687 check_stmt (gimple_stmt_iterator
*gsip
, funct_state local
, bool ipa
)
689 gimple stmt
= gsi_stmt (*gsip
);
691 if (is_gimple_debug (stmt
))
694 /* Do consider clobber as side effects before IPA, so we rather inline
695 C++ destructors and keep clobber semantics than eliminate them.
697 TODO: We may get smarter during early optimizations on these and let
698 functions containing only clobbers to be optimized more. This is a common
699 case of C++ destructors. */
701 if ((ipa
|| cfun
->after_inlining
) && gimple_clobber_p (stmt
))
706 fprintf (dump_file
, " scanning: ");
707 print_gimple_stmt (dump_file
, stmt
, 0, 0);
710 if (gimple_has_volatile_ops (stmt
)
711 && !gimple_clobber_p (stmt
))
713 local
->pure_const_state
= IPA_NEITHER
;
715 fprintf (dump_file
, " Volatile stmt is not const/pure\n");
718 /* Look for loads and stores. */
719 walk_stmt_load_store_ops (stmt
, local
,
720 ipa
? check_ipa_load
: check_load
,
721 ipa
? check_ipa_store
: check_store
);
723 if (gimple_code (stmt
) != GIMPLE_CALL
724 && stmt_could_throw_p (stmt
))
726 if (cfun
->can_throw_non_call_exceptions
)
729 fprintf (dump_file
, " can throw; looping\n");
730 local
->looping
= true;
732 if (stmt_can_throw_external (stmt
))
735 fprintf (dump_file
, " can throw externally\n");
736 local
->can_throw
= true;
740 fprintf (dump_file
, " can throw\n");
742 switch (gimple_code (stmt
))
745 check_call (local
, as_a
<gcall
*> (stmt
), ipa
);
748 if (DECL_NONLOCAL (gimple_label_label (as_a
<glabel
*> (stmt
))))
749 /* Target of long jump. */
752 fprintf (dump_file
, " nonlocal label is not const/pure\n");
753 local
->pure_const_state
= IPA_NEITHER
;
757 if (gimple_asm_clobbers_memory_p (as_a
<gasm
*> (stmt
)))
760 fprintf (dump_file
, " memory asm clobber is not const/pure\n");
761 /* Abandon all hope, ye who enter here. */
762 local
->pure_const_state
= IPA_NEITHER
;
763 local
->can_free
= true;
765 if (gimple_asm_volatile_p (as_a
<gasm
*> (stmt
)))
768 fprintf (dump_file
, " volatile is not const/pure\n");
769 /* Abandon all hope, ye who enter here. */
770 local
->pure_const_state
= IPA_NEITHER
;
771 local
->looping
= true;
772 local
->can_free
= true;
781 /* This is the main routine for finding the reference patterns for
782 global variables within a function FN. */
785 analyze_function (struct cgraph_node
*fn
, bool ipa
)
787 tree decl
= fn
->decl
;
789 basic_block this_block
;
791 l
= XCNEW (struct funct_state_d
);
792 l
->pure_const_state
= IPA_CONST
;
793 l
->state_previously_known
= IPA_NEITHER
;
794 l
->looping_previously_known
= true;
796 l
->can_throw
= false;
798 state_from_flags (&l
->state_previously_known
, &l
->looping_previously_known
,
799 flags_from_decl_or_type (fn
->decl
),
800 fn
->cannot_return_p ());
802 if (fn
->thunk
.thunk_p
|| fn
->alias
)
804 /* Thunk gets propagated through, so nothing interesting happens. */
806 if (fn
->thunk
.thunk_p
&& fn
->thunk
.virtual_offset_p
)
807 l
->pure_const_state
= IPA_NEITHER
;
813 fprintf (dump_file
, "\n\n local analysis of %s\n ",
817 push_cfun (DECL_STRUCT_FUNCTION (decl
));
819 FOR_EACH_BB_FN (this_block
, cfun
)
821 gimple_stmt_iterator gsi
;
822 struct walk_stmt_info wi
;
824 memset (&wi
, 0, sizeof (wi
));
825 for (gsi
= gsi_start_bb (this_block
);
829 check_stmt (&gsi
, l
, ipa
);
830 if (l
->pure_const_state
== IPA_NEITHER
839 if (l
->pure_const_state
!= IPA_NEITHER
)
841 /* Const functions cannot have back edges (an
842 indication of possible infinite loop side
844 if (mark_dfs_back_edges ())
846 /* Preheaders are needed for SCEV to work.
847 Simple latches and recorded exits improve chances that loop will
848 proved to be finite in testcases such as in loop-15.c
850 loop_optimizer_init (LOOPS_HAVE_PREHEADERS
851 | LOOPS_HAVE_SIMPLE_LATCHES
852 | LOOPS_HAVE_RECORDED_EXITS
);
853 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
854 flow_loops_dump (dump_file
, NULL
, 0);
855 if (mark_irreducible_loops ())
858 fprintf (dump_file
, " has irreducible loops\n");
865 FOR_EACH_LOOP (loop
, 0)
866 if (!finite_loop_p (loop
))
869 fprintf (dump_file
, " can not prove finiteness of "
870 "loop %i\n", loop
->num
);
876 loop_optimizer_finalize ();
880 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
881 fprintf (dump_file
, " checking previously known:");
883 better_state (&l
->pure_const_state
, &l
->looping
,
884 l
->state_previously_known
,
885 l
->looping_previously_known
);
886 if (TREE_NOTHROW (decl
))
887 l
->can_throw
= false;
893 fprintf (dump_file
, "Function is locally looping.\n");
895 fprintf (dump_file
, "Function is locally throwing.\n");
896 if (l
->pure_const_state
== IPA_CONST
)
897 fprintf (dump_file
, "Function is locally const.\n");
898 if (l
->pure_const_state
== IPA_PURE
)
899 fprintf (dump_file
, "Function is locally pure.\n");
901 fprintf (dump_file
, "Function can locally free.\n");
906 /* Called when new function is inserted to callgraph late. */
908 add_new_function (struct cgraph_node
*node
, void *data ATTRIBUTE_UNUSED
)
910 if (node
->get_availability () < AVAIL_INTERPOSABLE
)
912 /* There are some shared nodes, in particular the initializers on
913 static declarations. We do not need to scan them more than once
914 since all we would be interested in are the addressof
916 if (node
->get_availability () > AVAIL_INTERPOSABLE
917 && opt_for_fn (node
->decl
, flag_ipa_pure_const
))
918 set_function_state (node
, analyze_function (node
, true));
921 /* Called when new clone is inserted to callgraph late. */
924 duplicate_node_data (struct cgraph_node
*src
, struct cgraph_node
*dst
,
925 void *data ATTRIBUTE_UNUSED
)
927 if (has_function_state (src
))
929 funct_state l
= XNEW (struct funct_state_d
);
930 gcc_assert (!has_function_state (dst
));
931 memcpy (l
, get_function_state (src
), sizeof (*l
));
932 set_function_state (dst
, l
);
936 /* Called when new clone is inserted to callgraph late. */
939 remove_node_data (struct cgraph_node
*node
, void *data ATTRIBUTE_UNUSED
)
941 if (has_function_state (node
))
943 funct_state l
= get_function_state (node
);
944 if (l
!= &varying_state
)
946 set_function_state (node
, NULL
);
952 pass_ipa_pure_const::
953 register_hooks (void)
960 node_removal_hook_holder
=
961 symtab
->add_cgraph_removal_hook (&remove_node_data
, NULL
);
962 node_duplication_hook_holder
=
963 symtab
->add_cgraph_duplication_hook (&duplicate_node_data
, NULL
);
964 function_insertion_hook_holder
=
965 symtab
->add_cgraph_insertion_hook (&add_new_function
, NULL
);
969 /* Analyze each function in the cgraph to see if it is locally PURE or
973 pure_const_generate_summary (void)
975 struct cgraph_node
*node
;
977 pass_ipa_pure_const
*pass
= static_cast <pass_ipa_pure_const
*> (current_pass
);
978 pass
->register_hooks ();
980 /* Process all of the functions.
982 We process AVAIL_INTERPOSABLE functions. We can not use the results
983 by default, but the info can be used at LTO with -fwhole-program or
984 when function got cloned and the clone is AVAILABLE. */
986 FOR_EACH_DEFINED_FUNCTION (node
)
987 if (node
->get_availability () >= AVAIL_INTERPOSABLE
988 && opt_for_fn (node
->decl
, flag_ipa_pure_const
))
989 set_function_state (node
, analyze_function (node
, true));
993 /* Serialize the ipa info for lto. */
996 pure_const_write_summary (void)
998 struct cgraph_node
*node
;
999 struct lto_simple_output_block
*ob
1000 = lto_create_simple_output_block (LTO_section_ipa_pure_const
);
1001 unsigned int count
= 0;
1002 lto_symtab_encoder_iterator lsei
;
1003 lto_symtab_encoder_t encoder
;
1005 encoder
= lto_get_out_decl_state ()->symtab_node_encoder
;
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
))
1015 streamer_write_uhwi_stream (ob
->main_stream
, count
);
1017 /* Process all of the functions. */
1018 for (lsei
= lsei_start_function_in_partition (encoder
); !lsei_end_p (lsei
);
1019 lsei_next_function_in_partition (&lsei
))
1021 node
= lsei_cgraph_node (lsei
);
1022 if (node
->definition
&& has_function_state (node
))
1024 struct bitpack_d bp
;
1027 lto_symtab_encoder_t encoder
;
1029 fs
= get_function_state (node
);
1031 encoder
= ob
->decl_state
->symtab_node_encoder
;
1032 node_ref
= lto_symtab_encoder_encode (encoder
, node
);
1033 streamer_write_uhwi_stream (ob
->main_stream
, node_ref
);
1035 /* Note that flags will need to be read in the opposite
1036 order as we are pushing the bitflags into FLAGS. */
1037 bp
= bitpack_create (ob
->main_stream
);
1038 bp_pack_value (&bp
, fs
->pure_const_state
, 2);
1039 bp_pack_value (&bp
, fs
->state_previously_known
, 2);
1040 bp_pack_value (&bp
, fs
->looping_previously_known
, 1);
1041 bp_pack_value (&bp
, fs
->looping
, 1);
1042 bp_pack_value (&bp
, fs
->can_throw
, 1);
1043 bp_pack_value (&bp
, fs
->can_free
, 1);
1044 streamer_write_bitpack (&bp
);
1048 lto_destroy_simple_output_block (ob
);
1052 /* Deserialize the ipa info for lto. */
1055 pure_const_read_summary (void)
1057 struct lto_file_decl_data
**file_data_vec
= lto_get_file_decl_data ();
1058 struct lto_file_decl_data
*file_data
;
1061 pass_ipa_pure_const
*pass
= static_cast <pass_ipa_pure_const
*> (current_pass
);
1062 pass
->register_hooks ();
1064 while ((file_data
= file_data_vec
[j
++]))
1068 struct lto_input_block
*ib
1069 = lto_create_simple_input_block (file_data
,
1070 LTO_section_ipa_pure_const
,
1075 unsigned int count
= streamer_read_uhwi (ib
);
1077 for (i
= 0; i
< count
; i
++)
1080 struct cgraph_node
*node
;
1081 struct bitpack_d bp
;
1083 lto_symtab_encoder_t encoder
;
1085 fs
= XCNEW (struct funct_state_d
);
1086 index
= streamer_read_uhwi (ib
);
1087 encoder
= file_data
->symtab_node_encoder
;
1088 node
= dyn_cast
<cgraph_node
*> (lto_symtab_encoder_deref (encoder
,
1090 set_function_state (node
, fs
);
1092 /* Note that the flags must be read in the opposite
1093 order in which they were written (the bitflags were
1094 pushed into FLAGS). */
1095 bp
= streamer_read_bitpack (ib
);
1096 fs
->pure_const_state
1097 = (enum pure_const_state_e
) bp_unpack_value (&bp
, 2);
1098 fs
->state_previously_known
1099 = (enum pure_const_state_e
) bp_unpack_value (&bp
, 2);
1100 fs
->looping_previously_known
= bp_unpack_value (&bp
, 1);
1101 fs
->looping
= bp_unpack_value (&bp
, 1);
1102 fs
->can_throw
= bp_unpack_value (&bp
, 1);
1103 fs
->can_free
= bp_unpack_value (&bp
, 1);
1106 int flags
= flags_from_decl_or_type (node
->decl
);
1107 fprintf (dump_file
, "Read info for %s/%i ",
1110 if (flags
& ECF_CONST
)
1111 fprintf (dump_file
, " const");
1112 if (flags
& ECF_PURE
)
1113 fprintf (dump_file
, " pure");
1114 if (flags
& ECF_NOTHROW
)
1115 fprintf (dump_file
, " nothrow");
1116 fprintf (dump_file
, "\n pure const state: %s\n",
1117 pure_const_names
[fs
->pure_const_state
]);
1118 fprintf (dump_file
, " previously known state: %s\n",
1119 pure_const_names
[fs
->looping_previously_known
]);
1121 fprintf (dump_file
," function is locally looping\n");
1122 if (fs
->looping_previously_known
)
1123 fprintf (dump_file
," function is previously known looping\n");
1125 fprintf (dump_file
," function is locally throwing\n");
1127 fprintf (dump_file
," function can locally free\n");
1131 lto_destroy_simple_input_block (file_data
,
1132 LTO_section_ipa_pure_const
,
1140 ignore_edge (struct cgraph_edge
*e
)
1142 return (!e
->can_throw_external
);
1145 /* Return true if NODE is self recursive function.
1146 Indirectly recursive functions appears as non-trivial strongly
1147 connected components, so we need to care about self recursion
1151 self_recursive_p (struct cgraph_node
*node
)
1153 struct cgraph_edge
*e
;
1154 for (e
= node
->callees
; e
; e
= e
->next_callee
)
1155 if (e
->callee
->function_symbol () == node
)
1160 /* Return true if N is cdtor that is not const or pure. In this case we may
1161 need to remove unreachable function if it is marked const/pure. */
1164 cdtor_p (cgraph_node
*n
, void *)
1166 if (DECL_STATIC_CONSTRUCTOR (n
->decl
) || DECL_STATIC_DESTRUCTOR (n
->decl
))
1167 return !TREE_READONLY (n
->decl
) && !DECL_PURE_P (n
->decl
);
1171 /* Produce transitive closure over the callgraph and compute pure/const
1175 propagate_pure_const (void)
1177 struct cgraph_node
*node
;
1178 struct cgraph_node
*w
;
1179 struct cgraph_node
**order
=
1180 XCNEWVEC (struct cgraph_node
*, symtab
->cgraph_count
);
1183 struct ipa_dfs_info
* w_info
;
1184 bool remove_p
= false;
1186 order_pos
= ipa_reduced_postorder (order
, true, false, NULL
);
1189 cgraph_node::dump_cgraph (dump_file
);
1190 ipa_print_order (dump_file
, "reduced", order
, order_pos
);
1193 /* Propagate the local information through the call graph to produce
1194 the global information. All the nodes within a cycle will have
1195 the same info so we collapse cycles first. Then we can do the
1196 propagation in one pass from the leaves to the roots. */
1197 for (i
= 0; i
< order_pos
; i
++ )
1199 enum pure_const_state_e pure_const_state
= IPA_CONST
;
1200 bool looping
= false;
1207 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1208 fprintf (dump_file
, "Starting cycle\n");
1210 /* Find the worst state for any node in the cycle. */
1212 while (w
&& pure_const_state
!= IPA_NEITHER
)
1214 struct cgraph_edge
*e
;
1215 struct cgraph_edge
*ie
;
1217 struct ipa_ref
*ref
= NULL
;
1219 funct_state w_l
= get_function_state (w
);
1220 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1221 fprintf (dump_file
, " Visiting %s/%i state:%s looping %i\n",
1224 pure_const_names
[w_l
->pure_const_state
],
1227 /* First merge in function body properties. */
1228 worse_state (&pure_const_state
, &looping
,
1229 w_l
->pure_const_state
, w_l
->looping
);
1230 if (pure_const_state
== IPA_NEITHER
)
1233 /* For overwritable nodes we can not assume anything. */
1234 if (w
->get_availability () == AVAIL_INTERPOSABLE
)
1236 worse_state (&pure_const_state
, &looping
,
1237 w_l
->state_previously_known
,
1238 w_l
->looping_previously_known
);
1239 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1242 " Overwritable. state %s looping %i\n",
1243 pure_const_names
[w_l
->state_previously_known
],
1244 w_l
->looping_previously_known
);
1251 /* We consider recursive cycles as possibly infinite.
1252 This might be relaxed since infinite recursion leads to stack
1257 /* Now walk the edges and merge in callee properties. */
1258 for (e
= w
->callees
; e
; e
= e
->next_callee
)
1260 enum availability avail
;
1261 struct cgraph_node
*y
= e
->callee
->
1262 function_or_virtual_thunk_symbol (&avail
);
1263 enum pure_const_state_e edge_state
= IPA_CONST
;
1264 bool edge_looping
= false;
1266 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1273 if (avail
> AVAIL_INTERPOSABLE
)
1275 funct_state y_l
= get_function_state (y
);
1276 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1279 " state:%s looping:%i\n",
1280 pure_const_names
[y_l
->pure_const_state
],
1283 if (y_l
->pure_const_state
> IPA_PURE
1284 && e
->cannot_lead_to_return_p ())
1286 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1288 " Ignoring side effects"
1289 " -> pure, looping\n");
1290 edge_state
= IPA_PURE
;
1291 edge_looping
= true;
1295 edge_state
= y_l
->pure_const_state
;
1296 edge_looping
= y_l
->looping
;
1299 else if (special_builtin_state (&edge_state
, &edge_looping
,
1303 state_from_flags (&edge_state
, &edge_looping
,
1304 flags_from_decl_or_type (y
->decl
),
1305 e
->cannot_lead_to_return_p ());
1307 /* Merge the results with what we already know. */
1308 better_state (&edge_state
, &edge_looping
,
1309 w_l
->state_previously_known
,
1310 w_l
->looping_previously_known
);
1311 worse_state (&pure_const_state
, &looping
,
1312 edge_state
, edge_looping
);
1313 if (pure_const_state
== IPA_NEITHER
)
1316 if (pure_const_state
== IPA_NEITHER
)
1319 /* Now process the indirect call. */
1320 for (ie
= w
->indirect_calls
; ie
; ie
= ie
->next_callee
)
1322 enum pure_const_state_e edge_state
= IPA_CONST
;
1323 bool edge_looping
= false;
1325 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1326 fprintf (dump_file
, " Indirect call");
1327 state_from_flags (&edge_state
, &edge_looping
,
1328 ie
->indirect_info
->ecf_flags
,
1329 ie
->cannot_lead_to_return_p ());
1330 /* Merge the results with what we already know. */
1331 better_state (&edge_state
, &edge_looping
,
1332 w_l
->state_previously_known
,
1333 w_l
->looping_previously_known
);
1334 worse_state (&pure_const_state
, &looping
,
1335 edge_state
, edge_looping
);
1336 if (pure_const_state
== IPA_NEITHER
)
1339 if (pure_const_state
== IPA_NEITHER
)
1342 /* And finally all loads and stores. */
1343 for (i
= 0; w
->iterate_reference (i
, ref
); i
++)
1345 enum pure_const_state_e ref_state
= IPA_CONST
;
1346 bool ref_looping
= false;
1350 /* readonly reads are safe. */
1351 if (TREE_READONLY (ref
->referred
->decl
))
1353 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1354 fprintf (dump_file
, " nonreadonly global var read\n");
1355 ref_state
= IPA_PURE
;
1358 if (ref
->cannot_lead_to_return ())
1360 ref_state
= IPA_NEITHER
;
1361 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1362 fprintf (dump_file
, " global var write\n");
1370 better_state (&ref_state
, &ref_looping
,
1371 w_l
->state_previously_known
,
1372 w_l
->looping_previously_known
);
1373 worse_state (&pure_const_state
, &looping
,
1374 ref_state
, ref_looping
);
1375 if (pure_const_state
== IPA_NEITHER
)
1378 w_info
= (struct ipa_dfs_info
*) w
->aux
;
1379 w
= w_info
->next_cycle
;
1381 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1382 fprintf (dump_file
, "Result %s looping %i\n",
1383 pure_const_names
[pure_const_state
],
1386 /* Find the worst state of can_free for any node in the cycle. */
1387 bool can_free
= false;
1389 while (w
&& !can_free
)
1391 struct cgraph_edge
*e
;
1392 funct_state w_l
= get_function_state (w
);
1395 || w
->get_availability () == AVAIL_INTERPOSABLE
1396 || w
->indirect_calls
)
1399 for (e
= w
->callees
; e
&& !can_free
; e
= e
->next_callee
)
1401 enum availability avail
;
1402 struct cgraph_node
*y
= e
->callee
->
1403 function_or_virtual_thunk_symbol (&avail
);
1405 if (avail
> AVAIL_INTERPOSABLE
)
1406 can_free
= get_function_state (y
)->can_free
;
1410 w_info
= (struct ipa_dfs_info
*) w
->aux
;
1411 w
= w_info
->next_cycle
;
1414 /* Copy back the region's pure_const_state which is shared by
1415 all nodes in the region. */
1419 funct_state w_l
= get_function_state (w
);
1420 enum pure_const_state_e this_state
= pure_const_state
;
1421 bool this_looping
= looping
;
1423 w_l
->can_free
= can_free
;
1424 w
->nonfreeing_fn
= !can_free
;
1425 if (!can_free
&& dump_file
)
1426 fprintf (dump_file
, "Function found not to call free: %s\n",
1429 if (w_l
->state_previously_known
!= IPA_NEITHER
1430 && this_state
> w_l
->state_previously_known
)
1432 this_state
= w_l
->state_previously_known
;
1433 this_looping
|= w_l
->looping_previously_known
;
1435 if (!this_looping
&& self_recursive_p (w
))
1436 this_looping
= true;
1437 if (!w_l
->looping_previously_known
)
1438 this_looping
= false;
1440 /* All nodes within a cycle share the same info. */
1441 w_l
->pure_const_state
= this_state
;
1442 w_l
->looping
= this_looping
;
1444 /* Inline clones share declaration with their offline copies;
1445 do not modify their declarations since the offline copy may
1447 if (!w
->global
.inlined_to
)
1451 if (!TREE_READONLY (w
->decl
))
1453 warn_function_const (w
->decl
, !this_looping
);
1455 fprintf (dump_file
, "Function found to be %sconst: %s\n",
1456 this_looping
? "looping " : "",
1459 remove_p
|= w
->call_for_symbol_and_aliases (cdtor_p
,
1461 w
->set_const_flag (true, this_looping
);
1465 if (!DECL_PURE_P (w
->decl
))
1467 warn_function_pure (w
->decl
, !this_looping
);
1469 fprintf (dump_file
, "Function found to be %spure: %s\n",
1470 this_looping
? "looping " : "",
1473 remove_p
|= w
->call_for_symbol_and_aliases (cdtor_p
,
1475 w
->set_pure_flag (true, this_looping
);
1481 w_info
= (struct ipa_dfs_info
*) w
->aux
;
1482 w
= w_info
->next_cycle
;
1486 ipa_free_postorder_info ();
1491 /* Produce transitive closure over the callgraph and compute nothrow
1495 propagate_nothrow (void)
1497 struct cgraph_node
*node
;
1498 struct cgraph_node
*w
;
1499 struct cgraph_node
**order
=
1500 XCNEWVEC (struct cgraph_node
*, symtab
->cgraph_count
);
1503 struct ipa_dfs_info
* w_info
;
1505 order_pos
= ipa_reduced_postorder (order
, true, false, ignore_edge
);
1508 cgraph_node::dump_cgraph (dump_file
);
1509 ipa_print_order (dump_file
, "reduced for nothrow", order
, order_pos
);
1512 /* Propagate the local information through the call graph to produce
1513 the global information. All the nodes within a cycle will have
1514 the same info so we collapse cycles first. Then we can do the
1515 propagation in one pass from the leaves to the roots. */
1516 for (i
= 0; i
< order_pos
; i
++ )
1518 bool can_throw
= false;
1524 /* Find the worst state for any node in the cycle. */
1526 while (w
&& !can_throw
)
1528 struct cgraph_edge
*e
, *ie
;
1529 funct_state w_l
= get_function_state (w
);
1532 || w
->get_availability () == AVAIL_INTERPOSABLE
)
1535 for (e
= w
->callees
; e
&& !can_throw
; e
= e
->next_callee
)
1537 enum availability avail
;
1538 struct cgraph_node
*y
= e
->callee
->
1539 function_or_virtual_thunk_symbol (&avail
);
1541 if (avail
> AVAIL_INTERPOSABLE
)
1543 funct_state y_l
= get_function_state (y
);
1545 if (y_l
->can_throw
&& !TREE_NOTHROW (w
->decl
)
1546 && e
->can_throw_external
)
1549 else if (e
->can_throw_external
&& !TREE_NOTHROW (y
->decl
))
1552 for (ie
= w
->indirect_calls
; ie
&& !can_throw
; ie
= ie
->next_callee
)
1553 if (ie
->can_throw_external
)
1555 w_info
= (struct ipa_dfs_info
*) w
->aux
;
1556 w
= w_info
->next_cycle
;
1559 /* Copy back the region's pure_const_state which is shared by
1560 all nodes in the region. */
1564 funct_state w_l
= get_function_state (w
);
1565 if (!can_throw
&& !TREE_NOTHROW (w
->decl
))
1567 /* Inline clones share declaration with their offline copies;
1568 do not modify their declarations since the offline copy may
1570 if (!w
->global
.inlined_to
)
1572 w
->set_nothrow_flag (true);
1574 fprintf (dump_file
, "Function found to be nothrow: %s\n",
1578 else if (can_throw
&& !TREE_NOTHROW (w
->decl
))
1579 w_l
->can_throw
= true;
1580 w_info
= (struct ipa_dfs_info
*) w
->aux
;
1581 w
= w_info
->next_cycle
;
1585 ipa_free_postorder_info ();
1590 /* Produce the global information by preforming a transitive closure
1591 on the local information that was produced by generate_summary. */
1594 pass_ipa_pure_const::
1595 execute (function
*)
1597 struct cgraph_node
*node
;
1600 symtab
->remove_cgraph_insertion_hook (function_insertion_hook_holder
);
1601 symtab
->remove_cgraph_duplication_hook (node_duplication_hook_holder
);
1602 symtab
->remove_cgraph_removal_hook (node_removal_hook_holder
);
1604 /* Nothrow makes more function to not lead to return and improve
1606 propagate_nothrow ();
1607 remove_p
= propagate_pure_const ();
1610 FOR_EACH_FUNCTION (node
)
1611 if (has_function_state (node
))
1612 free (get_function_state (node
));
1613 funct_state_vec
.release ();
1614 return remove_p
? TODO_remove_functions
: 0;
1618 gate_pure_const (void)
1620 return flag_ipa_pure_const
|| in_lto_p
;
1623 pass_ipa_pure_const::pass_ipa_pure_const(gcc::context
*ctxt
)
1624 : ipa_opt_pass_d(pass_data_ipa_pure_const
, ctxt
,
1625 pure_const_generate_summary
, /* generate_summary */
1626 pure_const_write_summary
, /* write_summary */
1627 pure_const_read_summary
, /* read_summary */
1628 NULL
, /* write_optimization_summary */
1629 NULL
, /* read_optimization_summary */
1630 NULL
, /* stmt_fixup */
1631 0, /* function_transform_todo_flags_start */
1632 NULL
, /* function_transform */
1633 NULL
), /* variable_transform */
1635 function_insertion_hook_holder(NULL
),
1636 node_duplication_hook_holder(NULL
),
1637 node_removal_hook_holder(NULL
)
1642 make_pass_ipa_pure_const (gcc::context
*ctxt
)
1644 return new pass_ipa_pure_const (ctxt
);
1647 /* Return true if function should be skipped for local pure const analysis. */
1650 skip_function_for_local_pure_const (struct cgraph_node
*node
)
1652 /* Because we do not schedule pass_fixup_cfg over whole program after early optimizations
1653 we must not promote functions that are called by already processed functions. */
1655 if (function_called_by_processed_nodes_p ())
1658 fprintf (dump_file
, "Function called in recursive cycle; ignoring\n");
1661 if (node
->get_availability () <= AVAIL_INTERPOSABLE
)
1664 fprintf (dump_file
, "Function is not available or overwritable; not analyzing.\n");
1670 /* Simple local pass for pure const discovery reusing the analysis from
1671 ipa_pure_const. This pass is effective when executed together with
1672 other optimization passes in early optimization pass queue. */
1676 const pass_data pass_data_local_pure_const
=
1678 GIMPLE_PASS
, /* type */
1679 "local-pure-const", /* name */
1680 OPTGROUP_NONE
, /* optinfo_flags */
1681 TV_IPA_PURE_CONST
, /* tv_id */
1682 0, /* properties_required */
1683 0, /* properties_provided */
1684 0, /* properties_destroyed */
1685 0, /* todo_flags_start */
1686 0, /* todo_flags_finish */
1689 class pass_local_pure_const
: public gimple_opt_pass
1692 pass_local_pure_const (gcc::context
*ctxt
)
1693 : gimple_opt_pass (pass_data_local_pure_const
, ctxt
)
1696 /* opt_pass methods: */
1697 opt_pass
* clone () { return new pass_local_pure_const (m_ctxt
); }
1698 virtual bool gate (function
*) { return gate_pure_const (); }
1699 virtual unsigned int execute (function
*);
1701 }; // class pass_local_pure_const
1704 pass_local_pure_const::execute (function
*fun
)
1706 bool changed
= false;
1709 struct cgraph_node
*node
;
1711 node
= cgraph_node::get (current_function_decl
);
1712 skip
= skip_function_for_local_pure_const (node
);
1713 if (!warn_suggest_attribute_const
1714 && !warn_suggest_attribute_pure
1718 l
= analyze_function (node
, false);
1720 /* Do NORETURN discovery. */
1721 if (!skip
&& !TREE_THIS_VOLATILE (current_function_decl
)
1722 && EDGE_COUNT (EXIT_BLOCK_PTR_FOR_FN (fun
)->preds
) == 0)
1724 warn_function_noreturn (fun
->decl
);
1726 fprintf (dump_file
, "Function found to be noreturn: %s\n",
1727 current_function_name ());
1729 /* Update declaration and reduce profile to executed once. */
1730 TREE_THIS_VOLATILE (current_function_decl
) = 1;
1731 if (node
->frequency
> NODE_FREQUENCY_EXECUTED_ONCE
)
1732 node
->frequency
= NODE_FREQUENCY_EXECUTED_ONCE
;
1737 switch (l
->pure_const_state
)
1740 if (!TREE_READONLY (current_function_decl
))
1742 warn_function_const (current_function_decl
, !l
->looping
);
1745 node
->set_const_flag (true, l
->looping
);
1749 fprintf (dump_file
, "Function found to be %sconst: %s\n",
1750 l
->looping
? "looping " : "",
1751 current_function_name ());
1753 else if (DECL_LOOPING_CONST_OR_PURE_P (current_function_decl
)
1758 node
->set_const_flag (true, false);
1762 fprintf (dump_file
, "Function found to be non-looping: %s\n",
1763 current_function_name ());
1768 if (!DECL_PURE_P (current_function_decl
))
1772 node
->set_pure_flag (true, l
->looping
);
1775 warn_function_pure (current_function_decl
, !l
->looping
);
1777 fprintf (dump_file
, "Function found to be %spure: %s\n",
1778 l
->looping
? "looping " : "",
1779 current_function_name ());
1781 else if (DECL_LOOPING_CONST_OR_PURE_P (current_function_decl
)
1786 node
->set_pure_flag (true, false);
1790 fprintf (dump_file
, "Function found to be non-looping: %s\n",
1791 current_function_name ());
1798 if (!l
->can_throw
&& !TREE_NOTHROW (current_function_decl
))
1800 node
->set_nothrow_flag (true);
1803 fprintf (dump_file
, "Function found to be nothrow: %s\n",
1804 current_function_name ());
1808 return execute_fixup_cfg ();
1816 make_pass_local_pure_const (gcc::context
*ctxt
)
1818 return new pass_local_pure_const (ctxt
);
1821 /* Emit noreturn warnings. */
1825 const pass_data pass_data_warn_function_noreturn
=
1827 GIMPLE_PASS
, /* type */
1828 "*warn_function_noreturn", /* name */
1829 OPTGROUP_NONE
, /* optinfo_flags */
1830 TV_NONE
, /* tv_id */
1831 PROP_cfg
, /* properties_required */
1832 0, /* properties_provided */
1833 0, /* properties_destroyed */
1834 0, /* todo_flags_start */
1835 0, /* todo_flags_finish */
1838 class pass_warn_function_noreturn
: public gimple_opt_pass
1841 pass_warn_function_noreturn (gcc::context
*ctxt
)
1842 : gimple_opt_pass (pass_data_warn_function_noreturn
, ctxt
)
1845 /* opt_pass methods: */
1846 virtual bool gate (function
*) { return warn_suggest_attribute_noreturn
; }
1847 virtual unsigned int execute (function
*fun
)
1849 if (!TREE_THIS_VOLATILE (current_function_decl
)
1850 && EDGE_COUNT (EXIT_BLOCK_PTR_FOR_FN (fun
)->preds
) == 0)
1851 warn_function_noreturn (current_function_decl
);
1855 }; // class pass_warn_function_noreturn
1860 make_pass_warn_function_noreturn (gcc::context
*ctxt
)
1862 return new pass_warn_function_noreturn (ctxt
);
1865 /* Simple local pass for pure const discovery reusing the analysis from
1866 ipa_pure_const. This pass is effective when executed together with
1867 other optimization passes in early optimization pass queue. */
1871 const pass_data pass_data_nothrow
=
1873 GIMPLE_PASS
, /* type */
1874 "nothrow", /* name */
1875 OPTGROUP_NONE
, /* optinfo_flags */
1876 TV_IPA_PURE_CONST
, /* tv_id */
1877 0, /* properties_required */
1878 0, /* properties_provided */
1879 0, /* properties_destroyed */
1880 0, /* todo_flags_start */
1881 0, /* todo_flags_finish */
1884 class pass_nothrow
: public gimple_opt_pass
1887 pass_nothrow (gcc::context
*ctxt
)
1888 : gimple_opt_pass (pass_data_nothrow
, ctxt
)
1891 /* opt_pass methods: */
1892 opt_pass
* clone () { return new pass_nothrow (m_ctxt
); }
1893 virtual bool gate (function
*) { return optimize
; }
1894 virtual unsigned int execute (function
*);
1896 }; // class pass_nothrow
1899 pass_nothrow::execute (function
*)
1901 struct cgraph_node
*node
;
1902 basic_block this_block
;
1904 if (TREE_NOTHROW (current_function_decl
))
1907 node
= cgraph_node::get (current_function_decl
);
1909 /* We run during lowering, we can not really use availability yet. */
1910 if (cgraph_node::get (current_function_decl
)->get_availability ()
1911 <= AVAIL_INTERPOSABLE
)
1914 fprintf (dump_file
, "Function is interposable;"
1915 " not analyzing.\n");
1919 FOR_EACH_BB_FN (this_block
, cfun
)
1921 for (gimple_stmt_iterator gsi
= gsi_start_bb (this_block
);
1924 if (stmt_can_throw_external (gsi_stmt (gsi
)))
1926 if (is_gimple_call (gsi_stmt (gsi
)))
1928 tree callee_t
= gimple_call_fndecl (gsi_stmt (gsi
));
1929 if (callee_t
&& recursive_call_p (current_function_decl
,
1936 fprintf (dump_file
, "Statement can throw: ");
1937 print_gimple_stmt (dump_file
, gsi_stmt (gsi
), 0, 0);
1943 node
->set_nothrow_flag (true);
1945 fprintf (dump_file
, "Function found to be nothrow: %s\n",
1946 current_function_name ());
1953 make_pass_nothrow (gcc::context
*ctxt
)
1955 return new pass_nothrow (ctxt
);