Daily bump.
[official-gcc.git] / gcc / ipa-pure-const.c
blobb00ae2374a3a6c460fb0aa16bdcddc7b849d1667
1 /* Callgraph based analysis of static variables.
2 Copyright (C) 2004-2013 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
10 version.
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15 for more details.
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. */
34 #include "config.h"
35 #include "system.h"
36 #include "coretypes.h"
37 #include "tm.h"
38 #include "tree.h"
39 #include "tree-flow.h"
40 #include "tree-inline.h"
41 #include "tree-pass.h"
42 #include "langhooks.h"
43 #include "pointer-set.h"
44 #include "ggc.h"
45 #include "ipa-utils.h"
46 #include "gimple.h"
47 #include "cgraph.h"
48 #include "flags.h"
49 #include "diagnostic.h"
50 #include "gimple-pretty-print.h"
51 #include "langhooks.h"
52 #include "target.h"
53 #include "lto-streamer.h"
54 #include "data-streamer.h"
55 #include "tree-streamer.h"
56 #include "cfgloop.h"
57 #include "tree-scalar-evolution.h"
58 #include "intl.h"
59 #include "opts.h"
61 static struct pointer_set_t *visited_nodes;
63 /* Lattice values for const and pure functions. Everything starts out
64 being const, then may drop to pure and then neither depending on
65 what is found. */
66 enum pure_const_state_e
68 IPA_CONST,
69 IPA_PURE,
70 IPA_NEITHER
73 const char *pure_const_names[3] = {"const", "pure", "neither"};
75 /* Holder for the const_state. There is one of these per function
76 decl. */
77 struct funct_state_d
79 /* See above. */
80 enum pure_const_state_e pure_const_state;
81 /* What user set here; we can be always sure about this. */
82 enum pure_const_state_e state_previously_known;
83 bool looping_previously_known;
85 /* True if the function could possibly infinite loop. There are a
86 lot of ways that this could be determined. We are pretty
87 conservative here. While it is possible to cse pure and const
88 calls, it is not legal to have dce get rid of the call if there
89 is a possibility that the call could infinite loop since this is
90 a behavioral change. */
91 bool looping;
93 bool can_throw;
96 /* State used when we know nothing about function. */
97 static struct funct_state_d varying_state
98 = { IPA_NEITHER, IPA_NEITHER, true, true, true };
101 typedef struct funct_state_d * funct_state;
103 /* The storage of the funct_state is abstracted because there is the
104 possibility that it may be desirable to move this to the cgraph
105 local info. */
107 /* Array, indexed by cgraph node uid, of function states. */
109 static vec<funct_state> funct_state_vec;
111 /* Holders of ipa cgraph hooks: */
112 static struct cgraph_node_hook_list *function_insertion_hook_holder;
113 static struct cgraph_2node_hook_list *node_duplication_hook_holder;
114 static struct cgraph_node_hook_list *node_removal_hook_holder;
116 /* Try to guess if function body will always be visible to compiler
117 when compiling the call and whether compiler will be able
118 to propagate the information by itself. */
120 static bool
121 function_always_visible_to_compiler_p (tree decl)
123 return (!TREE_PUBLIC (decl) || DECL_DECLARED_INLINE_P (decl));
126 /* Emit suggestion about attribute ATTRIB_NAME for DECL. KNOWN_FINITE
127 is true if the function is known to be finite. The diagnostic is
128 controlled by OPTION. WARNED_ABOUT is a pointer_set unique for
129 OPTION, this function may initialize it and it is always returned
130 by the function. */
132 static struct pointer_set_t *
133 suggest_attribute (int option, tree decl, bool known_finite,
134 struct pointer_set_t *warned_about,
135 const char * attrib_name)
137 if (!option_enabled (option, &global_options))
138 return warned_about;
139 if (TREE_THIS_VOLATILE (decl)
140 || (known_finite && function_always_visible_to_compiler_p (decl)))
141 return warned_about;
143 if (!warned_about)
144 warned_about = pointer_set_create ();
145 if (pointer_set_contains (warned_about, decl))
146 return warned_about;
147 pointer_set_insert (warned_about, decl);
148 warning_at (DECL_SOURCE_LOCATION (decl),
149 option,
150 known_finite
151 ? _("function might be candidate for attribute %<%s%>")
152 : _("function might be candidate for attribute %<%s%>"
153 " if it is known to return normally"), attrib_name);
154 return warned_about;
157 /* Emit suggestion about __attribute_((pure)) for DECL. KNOWN_FINITE
158 is true if the function is known to be finite. */
160 static void
161 warn_function_pure (tree decl, bool known_finite)
163 static struct pointer_set_t *warned_about;
165 warned_about
166 = suggest_attribute (OPT_Wsuggest_attribute_pure, decl,
167 known_finite, warned_about, "pure");
170 /* Emit suggestion about __attribute_((const)) for DECL. KNOWN_FINITE
171 is true if the function is known to be finite. */
173 static void
174 warn_function_const (tree decl, bool known_finite)
176 static struct pointer_set_t *warned_about;
177 warned_about
178 = suggest_attribute (OPT_Wsuggest_attribute_const, decl,
179 known_finite, warned_about, "const");
182 void
183 warn_function_noreturn (tree decl)
185 static struct pointer_set_t *warned_about;
186 if (!lang_hooks.missing_noreturn_ok_p (decl)
187 && targetm.warn_func_return (decl))
188 warned_about
189 = suggest_attribute (OPT_Wsuggest_attribute_noreturn, decl,
190 true, warned_about, "noreturn");
193 /* Init the function state. */
195 static void
196 finish_state (void)
198 funct_state_vec.release ();
202 /* Return true if we have a function state for NODE. */
204 static inline bool
205 has_function_state (struct cgraph_node *node)
207 if (!funct_state_vec.exists ()
208 || funct_state_vec.length () <= (unsigned int)node->uid)
209 return false;
210 return funct_state_vec[node->uid] != NULL;
213 /* Return the function state from NODE. */
215 static inline funct_state
216 get_function_state (struct cgraph_node *node)
218 if (!funct_state_vec.exists ()
219 || funct_state_vec.length () <= (unsigned int)node->uid
220 || !funct_state_vec[node->uid])
221 /* We might want to put correct previously_known state into varying. */
222 return &varying_state;
223 return funct_state_vec[node->uid];
226 /* Set the function state S for NODE. */
228 static inline void
229 set_function_state (struct cgraph_node *node, funct_state s)
231 if (!funct_state_vec.exists ()
232 || funct_state_vec.length () <= (unsigned int)node->uid)
233 funct_state_vec.safe_grow_cleared (node->uid + 1);
234 funct_state_vec[node->uid] = s;
237 /* Check to see if the use (or definition when CHECKING_WRITE is true)
238 variable T is legal in a function that is either pure or const. */
240 static inline void
241 check_decl (funct_state local,
242 tree t, bool checking_write, bool ipa)
244 /* Do not want to do anything with volatile except mark any
245 function that uses one to be not const or pure. */
246 if (TREE_THIS_VOLATILE (t))
248 local->pure_const_state = IPA_NEITHER;
249 if (dump_file)
250 fprintf (dump_file, " Volatile operand is not const/pure");
251 return;
254 /* Do not care about a local automatic that is not static. */
255 if (!TREE_STATIC (t) && !DECL_EXTERNAL (t))
256 return;
258 /* If the variable has the "used" attribute, treat it as if it had a
259 been touched by the devil. */
260 if (DECL_PRESERVE_P (t))
262 local->pure_const_state = IPA_NEITHER;
263 if (dump_file)
264 fprintf (dump_file, " Used static/global variable is not const/pure\n");
265 return;
268 /* In IPA mode we are not interested in checking actual loads and stores;
269 they will be processed at propagation time using ipa_ref. */
270 if (ipa)
271 return;
273 /* Since we have dealt with the locals and params cases above, if we
274 are CHECKING_WRITE, this cannot be a pure or constant
275 function. */
276 if (checking_write)
278 local->pure_const_state = IPA_NEITHER;
279 if (dump_file)
280 fprintf (dump_file, " static/global memory write is not const/pure\n");
281 return;
284 if (DECL_EXTERNAL (t) || TREE_PUBLIC (t))
286 /* Readonly reads are safe. */
287 if (TREE_READONLY (t) && !TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (t)))
288 return; /* Read of a constant, do not change the function state. */
289 else
291 if (dump_file)
292 fprintf (dump_file, " global memory read is not const\n");
293 /* Just a regular read. */
294 if (local->pure_const_state == IPA_CONST)
295 local->pure_const_state = IPA_PURE;
298 else
300 /* Compilation level statics can be read if they are readonly
301 variables. */
302 if (TREE_READONLY (t))
303 return;
305 if (dump_file)
306 fprintf (dump_file, " static memory read is not const\n");
307 /* Just a regular read. */
308 if (local->pure_const_state == IPA_CONST)
309 local->pure_const_state = IPA_PURE;
314 /* Check to see if the use (or definition when CHECKING_WRITE is true)
315 variable T is legal in a function that is either pure or const. */
317 static inline void
318 check_op (funct_state local, tree t, bool checking_write)
320 t = get_base_address (t);
321 if (t && TREE_THIS_VOLATILE (t))
323 local->pure_const_state = IPA_NEITHER;
324 if (dump_file)
325 fprintf (dump_file, " Volatile indirect ref is not const/pure\n");
326 return;
328 else if (t
329 && (INDIRECT_REF_P (t) || TREE_CODE (t) == MEM_REF)
330 && TREE_CODE (TREE_OPERAND (t, 0)) == SSA_NAME
331 && !ptr_deref_may_alias_global_p (TREE_OPERAND (t, 0)))
333 if (dump_file)
334 fprintf (dump_file, " Indirect ref to local memory is OK\n");
335 return;
337 else if (checking_write)
339 local->pure_const_state = IPA_NEITHER;
340 if (dump_file)
341 fprintf (dump_file, " Indirect ref write is not const/pure\n");
342 return;
344 else
346 if (dump_file)
347 fprintf (dump_file, " Indirect ref read is not const\n");
348 if (local->pure_const_state == IPA_CONST)
349 local->pure_const_state = IPA_PURE;
353 /* compute state based on ECF FLAGS and store to STATE and LOOPING. */
355 static void
356 state_from_flags (enum pure_const_state_e *state, bool *looping,
357 int flags, bool cannot_lead_to_return)
359 *looping = false;
360 if (flags & ECF_LOOPING_CONST_OR_PURE)
362 *looping = true;
363 if (dump_file && (dump_flags & TDF_DETAILS))
364 fprintf (dump_file, " looping");
366 if (flags & ECF_CONST)
368 *state = IPA_CONST;
369 if (dump_file && (dump_flags & TDF_DETAILS))
370 fprintf (dump_file, " const\n");
372 else if (flags & ECF_PURE)
374 *state = IPA_PURE;
375 if (dump_file && (dump_flags & TDF_DETAILS))
376 fprintf (dump_file, " pure\n");
378 else if (cannot_lead_to_return)
380 *state = IPA_PURE;
381 *looping = true;
382 if (dump_file && (dump_flags & TDF_DETAILS))
383 fprintf (dump_file, " ignoring side effects->pure looping\n");
385 else
387 if (dump_file && (dump_flags & TDF_DETAILS))
388 fprintf (dump_file, " neither\n");
389 *state = IPA_NEITHER;
390 *looping = true;
394 /* Merge STATE and STATE2 and LOOPING and LOOPING2 and store
395 into STATE and LOOPING better of the two variants.
396 Be sure to merge looping correctly. IPA_NEITHER functions
397 have looping 0 even if they don't have to return. */
399 static inline void
400 better_state (enum pure_const_state_e *state, bool *looping,
401 enum pure_const_state_e state2, bool looping2)
403 if (state2 < *state)
405 if (*state == IPA_NEITHER)
406 *looping = looping2;
407 else
408 *looping = MIN (*looping, looping2);
410 else if (state2 != IPA_NEITHER)
411 *looping = MIN (*looping, looping2);
414 /* Merge STATE and STATE2 and LOOPING and LOOPING2 and store
415 into STATE and LOOPING worse of the two variants. */
417 static inline void
418 worse_state (enum pure_const_state_e *state, bool *looping,
419 enum pure_const_state_e state2, bool looping2)
421 *state = MAX (*state, state2);
422 *looping = MAX (*looping, looping2);
425 /* Recognize special cases of builtins that are by themselves not pure or const
426 but function using them is. */
427 static bool
428 special_builtin_state (enum pure_const_state_e *state, bool *looping,
429 tree callee)
431 if (DECL_BUILT_IN_CLASS (callee) == BUILT_IN_NORMAL)
432 switch (DECL_FUNCTION_CODE (callee))
434 case BUILT_IN_RETURN:
435 case BUILT_IN_UNREACHABLE:
436 case BUILT_IN_ALLOCA:
437 case BUILT_IN_ALLOCA_WITH_ALIGN:
438 case BUILT_IN_STACK_SAVE:
439 case BUILT_IN_STACK_RESTORE:
440 case BUILT_IN_EH_POINTER:
441 case BUILT_IN_EH_FILTER:
442 case BUILT_IN_UNWIND_RESUME:
443 case BUILT_IN_CXA_END_CLEANUP:
444 case BUILT_IN_EH_COPY_VALUES:
445 case BUILT_IN_FRAME_ADDRESS:
446 case BUILT_IN_APPLY:
447 case BUILT_IN_APPLY_ARGS:
448 *looping = false;
449 *state = IPA_CONST;
450 return true;
451 case BUILT_IN_PREFETCH:
452 *looping = true;
453 *state = IPA_CONST;
454 return true;
456 return false;
459 /* Check the parameters of a function call to CALL_EXPR to see if
460 there are any references in the parameters that are not allowed for
461 pure or const functions. Also check to see if this is either an
462 indirect call, a call outside the compilation unit, or has special
463 attributes that may also effect the purity. The CALL_EXPR node for
464 the entire call expression. */
466 static void
467 check_call (funct_state local, gimple call, bool ipa)
469 int flags = gimple_call_flags (call);
470 tree callee_t = gimple_call_fndecl (call);
471 bool possibly_throws = stmt_could_throw_p (call);
472 bool possibly_throws_externally = (possibly_throws
473 && stmt_can_throw_external (call));
475 if (possibly_throws)
477 unsigned int i;
478 for (i = 0; i < gimple_num_ops (call); i++)
479 if (gimple_op (call, i)
480 && tree_could_throw_p (gimple_op (call, i)))
482 if (possibly_throws && cfun->can_throw_non_call_exceptions)
484 if (dump_file)
485 fprintf (dump_file, " operand can throw; looping\n");
486 local->looping = true;
488 if (possibly_throws_externally)
490 if (dump_file)
491 fprintf (dump_file, " operand can throw externally\n");
492 local->can_throw = true;
497 /* The const and pure flags are set by a variety of places in the
498 compiler (including here). If someone has already set the flags
499 for the callee, (such as for some of the builtins) we will use
500 them, otherwise we will compute our own information.
502 Const and pure functions have less clobber effects than other
503 functions so we process these first. Otherwise if it is a call
504 outside the compilation unit or an indirect call we punt. This
505 leaves local calls which will be processed by following the call
506 graph. */
507 if (callee_t)
509 enum pure_const_state_e call_state;
510 bool call_looping;
512 if (special_builtin_state (&call_state, &call_looping, callee_t))
514 worse_state (&local->pure_const_state, &local->looping,
515 call_state, call_looping);
516 return;
518 /* When bad things happen to bad functions, they cannot be const
519 or pure. */
520 if (setjmp_call_p (callee_t))
522 if (dump_file)
523 fprintf (dump_file, " setjmp is not const/pure\n");
524 local->looping = true;
525 local->pure_const_state = IPA_NEITHER;
528 if (DECL_BUILT_IN_CLASS (callee_t) == BUILT_IN_NORMAL)
529 switch (DECL_FUNCTION_CODE (callee_t))
531 case BUILT_IN_LONGJMP:
532 case BUILT_IN_NONLOCAL_GOTO:
533 if (dump_file)
534 fprintf (dump_file, " longjmp and nonlocal goto is not const/pure\n");
535 local->pure_const_state = IPA_NEITHER;
536 local->looping = true;
537 break;
538 default:
539 break;
543 /* When not in IPA mode, we can still handle self recursion. */
544 if (!ipa && callee_t == current_function_decl)
546 if (dump_file)
547 fprintf (dump_file, " Recursive call can loop.\n");
548 local->looping = true;
550 /* Either callee is unknown or we are doing local analysis.
551 Look to see if there are any bits available for the callee (such as by
552 declaration or because it is builtin) and process solely on the basis of
553 those bits. */
554 else if (!ipa)
556 enum pure_const_state_e call_state;
557 bool call_looping;
558 if (possibly_throws && cfun->can_throw_non_call_exceptions)
560 if (dump_file)
561 fprintf (dump_file, " can throw; looping\n");
562 local->looping = true;
564 if (possibly_throws_externally)
566 if (dump_file)
568 fprintf (dump_file, " can throw externally to lp %i\n",
569 lookup_stmt_eh_lp (call));
570 if (callee_t)
571 fprintf (dump_file, " callee:%s\n",
572 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (callee_t)));
574 local->can_throw = true;
576 if (dump_file && (dump_flags & TDF_DETAILS))
577 fprintf (dump_file, " checking flags for call:");
578 state_from_flags (&call_state, &call_looping, flags,
579 ((flags & (ECF_NORETURN | ECF_NOTHROW))
580 == (ECF_NORETURN | ECF_NOTHROW))
581 || (!flag_exceptions && (flags & ECF_NORETURN)));
582 worse_state (&local->pure_const_state, &local->looping,
583 call_state, call_looping);
585 /* Direct functions calls are handled by IPA propagation. */
588 /* Wrapper around check_decl for loads in local more. */
590 static bool
591 check_load (gimple stmt ATTRIBUTE_UNUSED, tree op, void *data)
593 if (DECL_P (op))
594 check_decl ((funct_state)data, op, false, false);
595 else
596 check_op ((funct_state)data, op, false);
597 return false;
600 /* Wrapper around check_decl for stores in local more. */
602 static bool
603 check_store (gimple stmt ATTRIBUTE_UNUSED, tree op, void *data)
605 if (DECL_P (op))
606 check_decl ((funct_state)data, op, true, false);
607 else
608 check_op ((funct_state)data, op, true);
609 return false;
612 /* Wrapper around check_decl for loads in ipa mode. */
614 static bool
615 check_ipa_load (gimple stmt ATTRIBUTE_UNUSED, tree op, void *data)
617 if (DECL_P (op))
618 check_decl ((funct_state)data, op, false, true);
619 else
620 check_op ((funct_state)data, op, false);
621 return false;
624 /* Wrapper around check_decl for stores in ipa mode. */
626 static bool
627 check_ipa_store (gimple stmt ATTRIBUTE_UNUSED, tree op, void *data)
629 if (DECL_P (op))
630 check_decl ((funct_state)data, op, true, true);
631 else
632 check_op ((funct_state)data, op, true);
633 return false;
636 /* Look into pointer pointed to by GSIP and figure out what interesting side
637 effects it has. */
638 static void
639 check_stmt (gimple_stmt_iterator *gsip, funct_state local, bool ipa)
641 gimple stmt = gsi_stmt (*gsip);
643 if (is_gimple_debug (stmt))
644 return;
646 if (dump_file)
648 fprintf (dump_file, " scanning: ");
649 print_gimple_stmt (dump_file, stmt, 0, 0);
652 if (gimple_has_volatile_ops (stmt)
653 && !gimple_clobber_p (stmt))
655 local->pure_const_state = IPA_NEITHER;
656 if (dump_file)
657 fprintf (dump_file, " Volatile stmt is not const/pure\n");
660 /* Look for loads and stores. */
661 walk_stmt_load_store_ops (stmt, local,
662 ipa ? check_ipa_load : check_load,
663 ipa ? check_ipa_store : check_store);
665 if (gimple_code (stmt) != GIMPLE_CALL
666 && stmt_could_throw_p (stmt))
668 if (cfun->can_throw_non_call_exceptions)
670 if (dump_file)
671 fprintf (dump_file, " can throw; looping\n");
672 local->looping = true;
674 if (stmt_can_throw_external (stmt))
676 if (dump_file)
677 fprintf (dump_file, " can throw externally\n");
678 local->can_throw = true;
680 else
681 if (dump_file)
682 fprintf (dump_file, " can throw\n");
684 switch (gimple_code (stmt))
686 case GIMPLE_CALL:
687 check_call (local, stmt, ipa);
688 break;
689 case GIMPLE_LABEL:
690 if (DECL_NONLOCAL (gimple_label_label (stmt)))
691 /* Target of long jump. */
693 if (dump_file)
694 fprintf (dump_file, " nonlocal label is not const/pure\n");
695 local->pure_const_state = IPA_NEITHER;
697 break;
698 case GIMPLE_ASM:
699 if (gimple_asm_clobbers_memory_p (stmt))
701 if (dump_file)
702 fprintf (dump_file, " memory asm clobber is not const/pure\n");
703 /* Abandon all hope, ye who enter here. */
704 local->pure_const_state = IPA_NEITHER;
706 if (gimple_asm_volatile_p (stmt))
708 if (dump_file)
709 fprintf (dump_file, " volatile is not const/pure\n");
710 /* Abandon all hope, ye who enter here. */
711 local->pure_const_state = IPA_NEITHER;
712 local->looping = true;
714 return;
715 default:
716 break;
721 /* This is the main routine for finding the reference patterns for
722 global variables within a function FN. */
724 static funct_state
725 analyze_function (struct cgraph_node *fn, bool ipa)
727 tree decl = fn->symbol.decl;
728 funct_state l;
729 basic_block this_block;
731 l = XCNEW (struct funct_state_d);
732 l->pure_const_state = IPA_CONST;
733 l->state_previously_known = IPA_NEITHER;
734 l->looping_previously_known = true;
735 l->looping = false;
736 l->can_throw = false;
737 state_from_flags (&l->state_previously_known, &l->looping_previously_known,
738 flags_from_decl_or_type (fn->symbol.decl),
739 cgraph_node_cannot_return (fn));
741 if (fn->thunk.thunk_p || fn->symbol.alias)
743 /* Thunk gets propagated through, so nothing interesting happens. */
744 gcc_assert (ipa);
745 return l;
748 if (dump_file)
750 fprintf (dump_file, "\n\n local analysis of %s\n ",
751 cgraph_node_name (fn));
754 push_cfun (DECL_STRUCT_FUNCTION (decl));
756 FOR_EACH_BB (this_block)
758 gimple_stmt_iterator gsi;
759 struct walk_stmt_info wi;
761 memset (&wi, 0, sizeof(wi));
762 for (gsi = gsi_start_bb (this_block);
763 !gsi_end_p (gsi);
764 gsi_next (&gsi))
766 check_stmt (&gsi, l, ipa);
767 if (l->pure_const_state == IPA_NEITHER && l->looping && l->can_throw)
768 goto end;
772 end:
773 if (l->pure_const_state != IPA_NEITHER)
775 /* Const functions cannot have back edges (an
776 indication of possible infinite loop side
777 effect. */
778 if (mark_dfs_back_edges ())
780 /* Preheaders are needed for SCEV to work.
781 Simple latches and recorded exits improve chances that loop will
782 proved to be finite in testcases such as in loop-15.c
783 and loop-24.c */
784 loop_optimizer_init (LOOPS_HAVE_PREHEADERS
785 | LOOPS_HAVE_SIMPLE_LATCHES
786 | LOOPS_HAVE_RECORDED_EXITS);
787 if (dump_file && (dump_flags & TDF_DETAILS))
788 flow_loops_dump (dump_file, NULL, 0);
789 if (mark_irreducible_loops ())
791 if (dump_file)
792 fprintf (dump_file, " has irreducible loops\n");
793 l->looping = true;
795 else
797 loop_iterator li;
798 struct loop *loop;
799 scev_initialize ();
800 FOR_EACH_LOOP (li, loop, 0)
801 if (!finite_loop_p (loop))
803 if (dump_file)
804 fprintf (dump_file, " can not prove finiteness of "
805 "loop %i\n", loop->num);
806 l->looping =true;
807 FOR_EACH_LOOP_BREAK (li);
809 scev_finalize ();
811 loop_optimizer_finalize ();
815 if (dump_file && (dump_flags & TDF_DETAILS))
816 fprintf (dump_file, " checking previously known:");
818 better_state (&l->pure_const_state, &l->looping,
819 l->state_previously_known,
820 l->looping_previously_known);
821 if (TREE_NOTHROW (decl))
822 l->can_throw = false;
824 pop_cfun ();
825 if (dump_file)
827 if (l->looping)
828 fprintf (dump_file, "Function is locally looping.\n");
829 if (l->can_throw)
830 fprintf (dump_file, "Function is locally throwing.\n");
831 if (l->pure_const_state == IPA_CONST)
832 fprintf (dump_file, "Function is locally const.\n");
833 if (l->pure_const_state == IPA_PURE)
834 fprintf (dump_file, "Function is locally pure.\n");
836 return l;
839 /* Called when new function is inserted to callgraph late. */
840 static void
841 add_new_function (struct cgraph_node *node, void *data ATTRIBUTE_UNUSED)
843 if (cgraph_function_body_availability (node) < AVAIL_OVERWRITABLE)
844 return;
845 /* There are some shared nodes, in particular the initializers on
846 static declarations. We do not need to scan them more than once
847 since all we would be interested in are the addressof
848 operations. */
849 visited_nodes = pointer_set_create ();
850 if (cgraph_function_body_availability (node) > AVAIL_OVERWRITABLE)
851 set_function_state (node, analyze_function (node, true));
852 pointer_set_destroy (visited_nodes);
853 visited_nodes = NULL;
856 /* Called when new clone is inserted to callgraph late. */
858 static void
859 duplicate_node_data (struct cgraph_node *src, struct cgraph_node *dst,
860 void *data ATTRIBUTE_UNUSED)
862 if (has_function_state (src))
864 funct_state l = XNEW (struct funct_state_d);
865 gcc_assert (!has_function_state (dst));
866 memcpy (l, get_function_state (src), sizeof (*l));
867 set_function_state (dst, l);
871 /* Called when new clone is inserted to callgraph late. */
873 static void
874 remove_node_data (struct cgraph_node *node, void *data ATTRIBUTE_UNUSED)
876 if (has_function_state (node))
878 funct_state l = get_function_state (node);
879 if (l != &varying_state)
880 free (l);
881 set_function_state (node, NULL);
886 static void
887 register_hooks (void)
889 static bool init_p = false;
891 if (init_p)
892 return;
894 init_p = true;
896 node_removal_hook_holder =
897 cgraph_add_node_removal_hook (&remove_node_data, NULL);
898 node_duplication_hook_holder =
899 cgraph_add_node_duplication_hook (&duplicate_node_data, NULL);
900 function_insertion_hook_holder =
901 cgraph_add_function_insertion_hook (&add_new_function, NULL);
905 /* Analyze each function in the cgraph to see if it is locally PURE or
906 CONST. */
908 static void
909 pure_const_generate_summary (void)
911 struct cgraph_node *node;
913 register_hooks ();
915 /* There are some shared nodes, in particular the initializers on
916 static declarations. We do not need to scan them more than once
917 since all we would be interested in are the addressof
918 operations. */
919 visited_nodes = pointer_set_create ();
921 /* Process all of the functions.
923 We process AVAIL_OVERWRITABLE functions. We can not use the results
924 by default, but the info can be used at LTO with -fwhole-program or
925 when function got cloned and the clone is AVAILABLE. */
927 FOR_EACH_DEFINED_FUNCTION (node)
928 if (cgraph_function_body_availability (node) >= AVAIL_OVERWRITABLE)
929 set_function_state (node, analyze_function (node, true));
931 pointer_set_destroy (visited_nodes);
932 visited_nodes = NULL;
936 /* Serialize the ipa info for lto. */
938 static void
939 pure_const_write_summary (void)
941 struct cgraph_node *node;
942 struct lto_simple_output_block *ob
943 = lto_create_simple_output_block (LTO_section_ipa_pure_const);
944 unsigned int count = 0;
945 lto_symtab_encoder_iterator lsei;
946 lto_symtab_encoder_t encoder;
948 encoder = lto_get_out_decl_state ()->symtab_node_encoder;
950 for (lsei = lsei_start_function_in_partition (encoder); !lsei_end_p (lsei);
951 lsei_next_function_in_partition (&lsei))
953 node = lsei_cgraph_node (lsei);
954 if (node->symbol.definition && has_function_state (node))
955 count++;
958 streamer_write_uhwi_stream (ob->main_stream, count);
960 /* Process all of the functions. */
961 for (lsei = lsei_start_function_in_partition (encoder); !lsei_end_p (lsei);
962 lsei_next_function_in_partition (&lsei))
964 node = lsei_cgraph_node (lsei);
965 if (node->symbol.definition && has_function_state (node))
967 struct bitpack_d bp;
968 funct_state fs;
969 int node_ref;
970 lto_symtab_encoder_t encoder;
972 fs = get_function_state (node);
974 encoder = ob->decl_state->symtab_node_encoder;
975 node_ref = lto_symtab_encoder_encode (encoder, (symtab_node)node);
976 streamer_write_uhwi_stream (ob->main_stream, node_ref);
978 /* Note that flags will need to be read in the opposite
979 order as we are pushing the bitflags into FLAGS. */
980 bp = bitpack_create (ob->main_stream);
981 bp_pack_value (&bp, fs->pure_const_state, 2);
982 bp_pack_value (&bp, fs->state_previously_known, 2);
983 bp_pack_value (&bp, fs->looping_previously_known, 1);
984 bp_pack_value (&bp, fs->looping, 1);
985 bp_pack_value (&bp, fs->can_throw, 1);
986 streamer_write_bitpack (&bp);
990 lto_destroy_simple_output_block (ob);
994 /* Deserialize the ipa info for lto. */
996 static void
997 pure_const_read_summary (void)
999 struct lto_file_decl_data **file_data_vec = lto_get_file_decl_data ();
1000 struct lto_file_decl_data *file_data;
1001 unsigned int j = 0;
1003 register_hooks ();
1004 while ((file_data = file_data_vec[j++]))
1006 const char *data;
1007 size_t len;
1008 struct lto_input_block *ib
1009 = lto_create_simple_input_block (file_data,
1010 LTO_section_ipa_pure_const,
1011 &data, &len);
1012 if (ib)
1014 unsigned int i;
1015 unsigned int count = streamer_read_uhwi (ib);
1017 for (i = 0; i < count; i++)
1019 unsigned int index;
1020 struct cgraph_node *node;
1021 struct bitpack_d bp;
1022 funct_state fs;
1023 lto_symtab_encoder_t encoder;
1025 fs = XCNEW (struct funct_state_d);
1026 index = streamer_read_uhwi (ib);
1027 encoder = file_data->symtab_node_encoder;
1028 node = cgraph (lto_symtab_encoder_deref (encoder, index));
1029 set_function_state (node, fs);
1031 /* Note that the flags must be read in the opposite
1032 order in which they were written (the bitflags were
1033 pushed into FLAGS). */
1034 bp = streamer_read_bitpack (ib);
1035 fs->pure_const_state
1036 = (enum pure_const_state_e) bp_unpack_value (&bp, 2);
1037 fs->state_previously_known
1038 = (enum pure_const_state_e) bp_unpack_value (&bp, 2);
1039 fs->looping_previously_known = bp_unpack_value (&bp, 1);
1040 fs->looping = bp_unpack_value (&bp, 1);
1041 fs->can_throw = bp_unpack_value (&bp, 1);
1042 if (dump_file)
1044 int flags = flags_from_decl_or_type (node->symbol.decl);
1045 fprintf (dump_file, "Read info for %s/%i ",
1046 cgraph_node_name (node),
1047 node->symbol.order);
1048 if (flags & ECF_CONST)
1049 fprintf (dump_file, " const");
1050 if (flags & ECF_PURE)
1051 fprintf (dump_file, " pure");
1052 if (flags & ECF_NOTHROW)
1053 fprintf (dump_file, " nothrow");
1054 fprintf (dump_file, "\n pure const state: %s\n",
1055 pure_const_names[fs->pure_const_state]);
1056 fprintf (dump_file, " previously known state: %s\n",
1057 pure_const_names[fs->looping_previously_known]);
1058 if (fs->looping)
1059 fprintf (dump_file," function is locally looping\n");
1060 if (fs->looping_previously_known)
1061 fprintf (dump_file," function is previously known looping\n");
1062 if (fs->can_throw)
1063 fprintf (dump_file," function is locally throwing\n");
1067 lto_destroy_simple_input_block (file_data,
1068 LTO_section_ipa_pure_const,
1069 ib, data, len);
1075 static bool
1076 ignore_edge (struct cgraph_edge *e)
1078 return (!e->can_throw_external);
1081 /* Return true if NODE is self recursive function.
1082 ??? self recursive and indirectly recursive funcions should
1083 be the same, so this function seems unnecessary. */
1085 static bool
1086 self_recursive_p (struct cgraph_node *node)
1088 struct cgraph_edge *e;
1089 for (e = node->callees; e; e = e->next_callee)
1090 if (cgraph_function_node (e->callee, NULL) == node)
1091 return true;
1092 return false;
1095 /* Produce transitive closure over the callgraph and compute pure/const
1096 attributes. */
1098 static void
1099 propagate_pure_const (void)
1101 struct cgraph_node *node;
1102 struct cgraph_node *w;
1103 struct cgraph_node **order =
1104 XCNEWVEC (struct cgraph_node *, cgraph_n_nodes);
1105 int order_pos;
1106 int i;
1107 struct ipa_dfs_info * w_info;
1109 order_pos = ipa_reduced_postorder (order, true, false, NULL);
1110 if (dump_file)
1112 dump_cgraph (dump_file);
1113 ipa_print_order (dump_file, "reduced", order, order_pos);
1116 /* Propagate the local information through the call graph to produce
1117 the global information. All the nodes within a cycle will have
1118 the same info so we collapse cycles first. Then we can do the
1119 propagation in one pass from the leaves to the roots. */
1120 for (i = 0; i < order_pos; i++ )
1122 enum pure_const_state_e pure_const_state = IPA_CONST;
1123 bool looping = false;
1124 int count = 0;
1125 node = order[i];
1127 if (node->symbol.alias)
1128 continue;
1130 if (dump_file && (dump_flags & TDF_DETAILS))
1131 fprintf (dump_file, "Starting cycle\n");
1133 /* Find the worst state for any node in the cycle. */
1134 w = node;
1135 while (w && pure_const_state != IPA_NEITHER)
1137 struct cgraph_edge *e;
1138 struct cgraph_edge *ie;
1139 int i;
1140 struct ipa_ref *ref;
1142 funct_state w_l = get_function_state (w);
1143 if (dump_file && (dump_flags & TDF_DETAILS))
1144 fprintf (dump_file, " Visiting %s/%i state:%s looping %i\n",
1145 cgraph_node_name (w),
1146 w->symbol.order,
1147 pure_const_names[w_l->pure_const_state],
1148 w_l->looping);
1150 /* First merge in function body properties. */
1151 worse_state (&pure_const_state, &looping,
1152 w_l->pure_const_state, w_l->looping);
1153 if (pure_const_state == IPA_NEITHER)
1154 break;
1156 /* For overwritable nodes we can not assume anything. */
1157 if (cgraph_function_body_availability (w) == AVAIL_OVERWRITABLE)
1159 worse_state (&pure_const_state, &looping,
1160 w_l->state_previously_known,
1161 w_l->looping_previously_known);
1162 if (dump_file && (dump_flags & TDF_DETAILS))
1164 fprintf (dump_file,
1165 " Overwritable. state %s looping %i\n",
1166 pure_const_names[w_l->state_previously_known],
1167 w_l->looping_previously_known);
1169 break;
1172 count++;
1174 /* We consider recursive cycles as possibly infinite.
1175 This might be relaxed since infinite recursion leads to stack
1176 overflow. */
1177 if (count > 1)
1178 looping = true;
1180 /* Now walk the edges and merge in callee properties. */
1181 for (e = w->callees; e; e = e->next_callee)
1183 enum availability avail;
1184 struct cgraph_node *y = cgraph_function_node (e->callee, &avail);
1185 enum pure_const_state_e edge_state = IPA_CONST;
1186 bool edge_looping = false;
1188 if (dump_file && (dump_flags & TDF_DETAILS))
1190 fprintf (dump_file,
1191 " Call to %s/%i",
1192 cgraph_node_name (e->callee),
1193 e->callee->symbol.order);
1195 if (avail > AVAIL_OVERWRITABLE)
1197 funct_state y_l = get_function_state (y);
1198 if (dump_file && (dump_flags & TDF_DETAILS))
1200 fprintf (dump_file,
1201 " state:%s looping:%i\n",
1202 pure_const_names[y_l->pure_const_state],
1203 y_l->looping);
1205 if (y_l->pure_const_state > IPA_PURE
1206 && cgraph_edge_cannot_lead_to_return (e))
1208 if (dump_file && (dump_flags & TDF_DETAILS))
1209 fprintf (dump_file,
1210 " Ignoring side effects"
1211 " -> pure, looping\n");
1212 edge_state = IPA_PURE;
1213 edge_looping = true;
1215 else
1217 edge_state = y_l->pure_const_state;
1218 edge_looping = y_l->looping;
1221 else if (special_builtin_state (&edge_state, &edge_looping,
1222 y->symbol.decl))
1224 else
1225 state_from_flags (&edge_state, &edge_looping,
1226 flags_from_decl_or_type (y->symbol.decl),
1227 cgraph_edge_cannot_lead_to_return (e));
1229 /* Merge the results with what we already know. */
1230 better_state (&edge_state, &edge_looping,
1231 w_l->state_previously_known,
1232 w_l->looping_previously_known);
1233 worse_state (&pure_const_state, &looping,
1234 edge_state, edge_looping);
1235 if (pure_const_state == IPA_NEITHER)
1236 break;
1238 if (pure_const_state == IPA_NEITHER)
1239 break;
1241 /* Now process the indirect call. */
1242 for (ie = w->indirect_calls; ie; ie = ie->next_callee)
1244 enum pure_const_state_e edge_state = IPA_CONST;
1245 bool edge_looping = false;
1247 if (dump_file && (dump_flags & TDF_DETAILS))
1248 fprintf (dump_file, " Indirect call");
1249 state_from_flags (&edge_state, &edge_looping,
1250 ie->indirect_info->ecf_flags,
1251 cgraph_edge_cannot_lead_to_return (ie));
1252 /* Merge the results with what we already know. */
1253 better_state (&edge_state, &edge_looping,
1254 w_l->state_previously_known,
1255 w_l->looping_previously_known);
1256 worse_state (&pure_const_state, &looping,
1257 edge_state, edge_looping);
1258 if (pure_const_state == IPA_NEITHER)
1259 break;
1261 if (pure_const_state == IPA_NEITHER)
1262 break;
1264 /* And finally all loads and stores. */
1265 for (i = 0; ipa_ref_list_reference_iterate (&w->symbol.ref_list, i, ref); i++)
1267 enum pure_const_state_e ref_state = IPA_CONST;
1268 bool ref_looping = false;
1269 switch (ref->use)
1271 case IPA_REF_LOAD:
1272 /* readonly reads are safe. */
1273 if (TREE_READONLY (ipa_ref_varpool_node (ref)->symbol.decl))
1274 break;
1275 if (dump_file && (dump_flags & TDF_DETAILS))
1276 fprintf (dump_file, " nonreadonly global var read\n");
1277 ref_state = IPA_PURE;
1278 break;
1279 case IPA_REF_STORE:
1280 if (ipa_ref_cannot_lead_to_return (ref))
1281 break;
1282 ref_state = IPA_NEITHER;
1283 if (dump_file && (dump_flags & TDF_DETAILS))
1284 fprintf (dump_file, " global var write\n");
1285 break;
1286 case IPA_REF_ADDR:
1287 break;
1289 better_state (&ref_state, &ref_looping,
1290 w_l->state_previously_known,
1291 w_l->looping_previously_known);
1292 worse_state (&pure_const_state, &looping,
1293 ref_state, ref_looping);
1294 if (pure_const_state == IPA_NEITHER)
1295 break;
1297 w_info = (struct ipa_dfs_info *) w->symbol.aux;
1298 w = w_info->next_cycle;
1300 if (dump_file && (dump_flags & TDF_DETAILS))
1301 fprintf (dump_file, "Result %s looping %i\n",
1302 pure_const_names [pure_const_state],
1303 looping);
1305 /* Copy back the region's pure_const_state which is shared by
1306 all nodes in the region. */
1307 w = node;
1308 while (w)
1310 funct_state w_l = get_function_state (w);
1311 enum pure_const_state_e this_state = pure_const_state;
1312 bool this_looping = looping;
1314 if (w_l->state_previously_known != IPA_NEITHER
1315 && this_state > w_l->state_previously_known)
1317 this_state = w_l->state_previously_known;
1318 this_looping |= w_l->looping_previously_known;
1320 if (!this_looping && self_recursive_p (w))
1321 this_looping = true;
1322 if (!w_l->looping_previously_known)
1323 this_looping = false;
1325 /* All nodes within a cycle share the same info. */
1326 w_l->pure_const_state = this_state;
1327 w_l->looping = this_looping;
1329 switch (this_state)
1331 case IPA_CONST:
1332 if (!TREE_READONLY (w->symbol.decl))
1334 warn_function_const (w->symbol.decl, !this_looping);
1335 if (dump_file)
1336 fprintf (dump_file, "Function found to be %sconst: %s\n",
1337 this_looping ? "looping " : "",
1338 cgraph_node_name (w));
1340 cgraph_set_const_flag (w, true, this_looping);
1341 break;
1343 case IPA_PURE:
1344 if (!DECL_PURE_P (w->symbol.decl))
1346 warn_function_pure (w->symbol.decl, !this_looping);
1347 if (dump_file)
1348 fprintf (dump_file, "Function found to be %spure: %s\n",
1349 this_looping ? "looping " : "",
1350 cgraph_node_name (w));
1352 cgraph_set_pure_flag (w, true, this_looping);
1353 break;
1355 default:
1356 break;
1358 w_info = (struct ipa_dfs_info *) w->symbol.aux;
1359 w = w_info->next_cycle;
1363 ipa_free_postorder_info ();
1364 free (order);
1367 /* Produce transitive closure over the callgraph and compute nothrow
1368 attributes. */
1370 static void
1371 propagate_nothrow (void)
1373 struct cgraph_node *node;
1374 struct cgraph_node *w;
1375 struct cgraph_node **order =
1376 XCNEWVEC (struct cgraph_node *, cgraph_n_nodes);
1377 int order_pos;
1378 int i;
1379 struct ipa_dfs_info * w_info;
1381 order_pos = ipa_reduced_postorder (order, true, false, ignore_edge);
1382 if (dump_file)
1384 dump_cgraph (dump_file);
1385 ipa_print_order (dump_file, "reduced for nothrow", order, order_pos);
1388 /* Propagate the local information through the call graph to produce
1389 the global information. All the nodes within a cycle will have
1390 the same info so we collapse cycles first. Then we can do the
1391 propagation in one pass from the leaves to the roots. */
1392 for (i = 0; i < order_pos; i++ )
1394 bool can_throw = false;
1395 node = order[i];
1397 if (node->symbol.alias)
1398 continue;
1400 /* Find the worst state for any node in the cycle. */
1401 w = node;
1402 while (w)
1404 struct cgraph_edge *e, *ie;
1405 funct_state w_l = get_function_state (w);
1407 if (w_l->can_throw
1408 || cgraph_function_body_availability (w) == AVAIL_OVERWRITABLE)
1409 can_throw = true;
1411 if (can_throw)
1412 break;
1414 for (e = w->callees; e; e = e->next_callee)
1416 enum availability avail;
1417 struct cgraph_node *y = cgraph_function_node (e->callee, &avail);
1419 if (avail > AVAIL_OVERWRITABLE)
1421 funct_state y_l = get_function_state (y);
1423 if (can_throw)
1424 break;
1425 if (y_l->can_throw && !TREE_NOTHROW (w->symbol.decl)
1426 && e->can_throw_external)
1427 can_throw = true;
1429 else if (e->can_throw_external && !TREE_NOTHROW (y->symbol.decl))
1430 can_throw = true;
1432 for (ie = node->indirect_calls; ie; ie = ie->next_callee)
1433 if (ie->can_throw_external)
1435 can_throw = true;
1436 break;
1438 w_info = (struct ipa_dfs_info *) w->symbol.aux;
1439 w = w_info->next_cycle;
1442 /* Copy back the region's pure_const_state which is shared by
1443 all nodes in the region. */
1444 w = node;
1445 while (w)
1447 funct_state w_l = get_function_state (w);
1448 if (!can_throw && !TREE_NOTHROW (w->symbol.decl))
1450 cgraph_set_nothrow_flag (w, true);
1451 if (dump_file)
1452 fprintf (dump_file, "Function found to be nothrow: %s\n",
1453 cgraph_node_name (w));
1455 else if (can_throw && !TREE_NOTHROW (w->symbol.decl))
1456 w_l->can_throw = true;
1457 w_info = (struct ipa_dfs_info *) w->symbol.aux;
1458 w = w_info->next_cycle;
1462 ipa_free_postorder_info ();
1463 free (order);
1467 /* Produce the global information by preforming a transitive closure
1468 on the local information that was produced by generate_summary. */
1470 static unsigned int
1471 propagate (void)
1473 struct cgraph_node *node;
1475 cgraph_remove_function_insertion_hook (function_insertion_hook_holder);
1476 cgraph_remove_node_duplication_hook (node_duplication_hook_holder);
1477 cgraph_remove_node_removal_hook (node_removal_hook_holder);
1479 /* Nothrow makes more function to not lead to return and improve
1480 later analysis. */
1481 propagate_nothrow ();
1482 propagate_pure_const ();
1484 /* Cleanup. */
1485 FOR_EACH_FUNCTION (node)
1486 if (has_function_state (node))
1487 free (get_function_state (node));
1488 funct_state_vec.release ();
1489 finish_state ();
1490 return 0;
1493 static bool
1494 gate_pure_const (void)
1496 return (flag_ipa_pure_const
1497 /* Don't bother doing anything if the program has errors. */
1498 && !seen_error ());
1501 struct ipa_opt_pass_d pass_ipa_pure_const =
1504 IPA_PASS,
1505 "pure-const", /* name */
1506 OPTGROUP_NONE, /* optinfo_flags */
1507 gate_pure_const, /* gate */
1508 propagate, /* execute */
1509 NULL, /* sub */
1510 NULL, /* next */
1511 0, /* static_pass_number */
1512 TV_IPA_PURE_CONST, /* tv_id */
1513 0, /* properties_required */
1514 0, /* properties_provided */
1515 0, /* properties_destroyed */
1516 0, /* todo_flags_start */
1517 0 /* todo_flags_finish */
1519 pure_const_generate_summary, /* generate_summary */
1520 pure_const_write_summary, /* write_summary */
1521 pure_const_read_summary, /* read_summary */
1522 NULL, /* write_optimization_summary */
1523 NULL, /* read_optimization_summary */
1524 NULL, /* stmt_fixup */
1525 0, /* TODOs */
1526 NULL, /* function_transform */
1527 NULL /* variable_transform */
1530 /* Return true if function should be skipped for local pure const analysis. */
1532 static bool
1533 skip_function_for_local_pure_const (struct cgraph_node *node)
1535 /* Because we do not schedule pass_fixup_cfg over whole program after early optimizations
1536 we must not promote functions that are called by already processed functions. */
1538 if (function_called_by_processed_nodes_p ())
1540 if (dump_file)
1541 fprintf (dump_file, "Function called in recursive cycle; ignoring\n");
1542 return true;
1544 if (cgraph_function_body_availability (node) <= AVAIL_OVERWRITABLE)
1546 if (dump_file)
1547 fprintf (dump_file, "Function is not available or overwritable; not analyzing.\n");
1548 return true;
1550 return false;
1553 /* Simple local pass for pure const discovery reusing the analysis from
1554 ipa_pure_const. This pass is effective when executed together with
1555 other optimization passes in early optimization pass queue. */
1557 static unsigned int
1558 local_pure_const (void)
1560 bool changed = false;
1561 funct_state l;
1562 bool skip;
1563 struct cgraph_node *node;
1565 node = cgraph_get_node (current_function_decl);
1566 skip = skip_function_for_local_pure_const (node);
1567 if (!warn_suggest_attribute_const
1568 && !warn_suggest_attribute_pure
1569 && skip)
1570 return 0;
1572 l = analyze_function (node, false);
1574 /* Do NORETURN discovery. */
1575 if (!skip && !TREE_THIS_VOLATILE (current_function_decl)
1576 && EDGE_COUNT (EXIT_BLOCK_PTR->preds) == 0)
1578 warn_function_noreturn (cfun->decl);
1579 if (dump_file)
1580 fprintf (dump_file, "Function found to be noreturn: %s\n",
1581 current_function_name ());
1583 /* Update declaration and reduce profile to executed once. */
1584 TREE_THIS_VOLATILE (current_function_decl) = 1;
1585 if (node->frequency > NODE_FREQUENCY_EXECUTED_ONCE)
1586 node->frequency = NODE_FREQUENCY_EXECUTED_ONCE;
1588 changed = true;
1591 switch (l->pure_const_state)
1593 case IPA_CONST:
1594 if (!TREE_READONLY (current_function_decl))
1596 warn_function_const (current_function_decl, !l->looping);
1597 if (!skip)
1599 cgraph_set_const_flag (node, true, l->looping);
1600 changed = true;
1602 if (dump_file)
1603 fprintf (dump_file, "Function found to be %sconst: %s\n",
1604 l->looping ? "looping " : "",
1605 current_function_name ());
1607 else if (DECL_LOOPING_CONST_OR_PURE_P (current_function_decl)
1608 && !l->looping)
1610 if (!skip)
1612 cgraph_set_const_flag (node, true, false);
1613 changed = true;
1615 if (dump_file)
1616 fprintf (dump_file, "Function found to be non-looping: %s\n",
1617 current_function_name ());
1619 break;
1621 case IPA_PURE:
1622 if (!DECL_PURE_P (current_function_decl))
1624 if (!skip)
1626 cgraph_set_pure_flag (node, true, l->looping);
1627 changed = true;
1629 warn_function_pure (current_function_decl, !l->looping);
1630 if (dump_file)
1631 fprintf (dump_file, "Function found to be %spure: %s\n",
1632 l->looping ? "looping " : "",
1633 current_function_name ());
1635 else if (DECL_LOOPING_CONST_OR_PURE_P (current_function_decl)
1636 && !l->looping)
1638 if (!skip)
1640 cgraph_set_pure_flag (node, true, false);
1641 changed = true;
1643 if (dump_file)
1644 fprintf (dump_file, "Function found to be non-looping: %s\n",
1645 current_function_name ());
1647 break;
1649 default:
1650 break;
1652 if (!l->can_throw && !TREE_NOTHROW (current_function_decl))
1654 cgraph_set_nothrow_flag (node, true);
1655 changed = true;
1656 if (dump_file)
1657 fprintf (dump_file, "Function found to be nothrow: %s\n",
1658 current_function_name ());
1660 free (l);
1661 if (changed)
1662 return execute_fixup_cfg ();
1663 else
1664 return 0;
1667 struct gimple_opt_pass pass_local_pure_const =
1670 GIMPLE_PASS,
1671 "local-pure-const", /* name */
1672 OPTGROUP_NONE, /* optinfo_flags */
1673 gate_pure_const, /* gate */
1674 local_pure_const, /* execute */
1675 NULL, /* sub */
1676 NULL, /* next */
1677 0, /* static_pass_number */
1678 TV_IPA_PURE_CONST, /* tv_id */
1679 0, /* properties_required */
1680 0, /* properties_provided */
1681 0, /* properties_destroyed */
1682 0, /* todo_flags_start */
1683 0 /* todo_flags_finish */