1 /* Callgraph based analysis of static variables.
2 Copyright (C) 2004, 2005, 2007, 2008, 2009, 2010
3 Free Software Foundation, Inc.
4 Contributed by Kenneth Zadeck <zadeck@naturalbridge.com>
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
22 /* This file marks functions as being either const (TREE_READONLY) or
23 pure (DECL_PURE_P). It can also set a variant of these that
24 are allowed to loop indefinitely (DECL_LOOPING_CONST_PURE_P).
26 This must be run after inlining decisions have been made since
27 otherwise, the local sets will not contain information that is
28 consistent with post inlined state. The global sets are not prone
29 to this problem since they are by definition transitive. */
31 /* The code in this module is called by the ipa pass manager. It
32 should be one of the later passes since it's information is used by
33 the rest of the compilation. */
37 #include "coretypes.h"
40 #include "tree-flow.h"
41 #include "tree-inline.h"
42 #include "tree-pass.h"
43 #include "langhooks.h"
44 #include "pointer-set.h"
46 #include "ipa-utils.h"
53 #include "diagnostic.h"
54 #include "langhooks.h"
56 #include "lto-streamer.h"
58 #include "tree-scalar-evolution.h"
62 static struct pointer_set_t
*visited_nodes
;
64 /* Lattice values for const and pure functions. Everything starts out
65 being const, then may drop to pure and then neither depending on
67 enum pure_const_state_e
74 /* Holder for the const_state. There is one of these per function
79 enum pure_const_state_e pure_const_state
;
80 /* What user set here; we can be always sure about this. */
81 enum pure_const_state_e state_previously_known
;
82 bool looping_previously_known
;
84 /* True if the function could possibly infinite loop. There are a
85 lot of ways that this could be determined. We are pretty
86 conservative here. While it is possible to cse pure and const
87 calls, it is not legal to have dce get rid of the call if there
88 is a possibility that the call could infinite loop since this is
89 a behavioral change. */
95 typedef struct funct_state_d
* funct_state
;
97 /* The storage of the funct_state is abstracted because there is the
98 possibility that it may be desirable to move this to the cgraph
101 /* Array, indexed by cgraph node uid, of function states. */
103 DEF_VEC_P (funct_state
);
104 DEF_VEC_ALLOC_P (funct_state
, heap
);
105 static VEC (funct_state
, heap
) *funct_state_vec
;
107 /* Holders of ipa cgraph hooks: */
108 static struct cgraph_node_hook_list
*function_insertion_hook_holder
;
109 static struct cgraph_2node_hook_list
*node_duplication_hook_holder
;
110 static struct cgraph_node_hook_list
*node_removal_hook_holder
;
112 /* Try to guess if function body will always be visible to compiler
113 when compiling the call and whether compiler will be able
114 to propagate the information by itself. */
117 function_always_visible_to_compiler_p (tree decl
)
119 return (!TREE_PUBLIC (decl
) || DECL_DECLARED_INLINE_P (decl
));
122 /* Emit suggestion about attribute ATTRIB_NAME for DECL. KNOWN_FINITE
123 is true if the function is known to be finite. The diagnostic is
124 controlled by OPTION. WARNED_ABOUT is a pointer_set unique for
125 OPTION, this function may initialize it and it is always returned
128 static struct pointer_set_t
*
129 suggest_attribute (int option
, tree decl
, bool known_finite
,
130 struct pointer_set_t
*warned_about
,
131 const char * attrib_name
)
133 if (!option_enabled (option
))
135 if (TREE_THIS_VOLATILE (decl
)
136 || (known_finite
&& function_always_visible_to_compiler_p (decl
)))
140 warned_about
= pointer_set_create ();
141 if (pointer_set_contains (warned_about
, decl
))
143 pointer_set_insert (warned_about
, decl
);
144 warning_at (DECL_SOURCE_LOCATION (decl
),
147 ? _("function might be candidate for attribute %<%s%>")
148 : _("function might be candidate for attribute %<%s%>"
149 " if it is known to return normally"), attrib_name
);
153 /* Emit suggestion about __attribute_((pure)) for DECL. KNOWN_FINITE
154 is true if the function is known to be finite. */
157 warn_function_pure (tree decl
, bool known_finite
)
159 static struct pointer_set_t
*warned_about
;
162 = suggest_attribute (OPT_Wsuggest_attribute_pure
, decl
,
163 known_finite
, warned_about
, "pure");
166 /* Emit suggestion about __attribute_((const)) for DECL. KNOWN_FINITE
167 is true if the function is known to be finite. */
170 warn_function_const (tree decl
, bool known_finite
)
172 static struct pointer_set_t
*warned_about
;
174 = suggest_attribute (OPT_Wsuggest_attribute_const
, decl
,
175 known_finite
, warned_about
, "const");
177 /* Init the function state. */
182 free (funct_state_vec
);
186 /* Return the function state from NODE. */
188 static inline funct_state
189 get_function_state (struct cgraph_node
*node
)
192 || VEC_length (funct_state
, funct_state_vec
) <= (unsigned int)node
->uid
)
194 return VEC_index (funct_state
, funct_state_vec
, node
->uid
);
197 /* Set the function state S for NODE. */
200 set_function_state (struct cgraph_node
*node
, funct_state s
)
203 || VEC_length (funct_state
, funct_state_vec
) <= (unsigned int)node
->uid
)
204 VEC_safe_grow_cleared (funct_state
, heap
, funct_state_vec
, node
->uid
+ 1);
205 VEC_replace (funct_state
, funct_state_vec
, node
->uid
, s
);
208 /* Check to see if the use (or definition when CHECKING_WRITE is true)
209 variable T is legal in a function that is either pure or const. */
212 check_decl (funct_state local
,
213 tree t
, bool checking_write
)
215 /* Do not want to do anything with volatile except mark any
216 function that uses one to be not const or pure. */
217 if (TREE_THIS_VOLATILE (t
))
219 local
->pure_const_state
= IPA_NEITHER
;
221 fprintf (dump_file
, " Volatile operand is not const/pure");
225 /* Do not care about a local automatic that is not static. */
226 if (!TREE_STATIC (t
) && !DECL_EXTERNAL (t
))
229 /* If the variable has the "used" attribute, treat it as if it had a
230 been touched by the devil. */
231 if (DECL_PRESERVE_P (t
))
233 local
->pure_const_state
= IPA_NEITHER
;
235 fprintf (dump_file
, " Used static/global variable is not const/pure\n");
239 /* Since we have dealt with the locals and params cases above, if we
240 are CHECKING_WRITE, this cannot be a pure or constant
244 local
->pure_const_state
= IPA_NEITHER
;
246 fprintf (dump_file
, " static/global memory write is not const/pure\n");
250 if (DECL_EXTERNAL (t
) || TREE_PUBLIC (t
))
252 /* Readonly reads are safe. */
253 if (TREE_READONLY (t
) && !TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (t
)))
254 return; /* Read of a constant, do not change the function state. */
258 fprintf (dump_file
, " global memory read is not const\n");
259 /* Just a regular read. */
260 if (local
->pure_const_state
== IPA_CONST
)
261 local
->pure_const_state
= IPA_PURE
;
266 /* Compilation level statics can be read if they are readonly
268 if (TREE_READONLY (t
))
272 fprintf (dump_file
, " static memory read is not const\n");
273 /* Just a regular read. */
274 if (local
->pure_const_state
== IPA_CONST
)
275 local
->pure_const_state
= IPA_PURE
;
280 /* Check to see if the use (or definition when CHECKING_WRITE is true)
281 variable T is legal in a function that is either pure or const. */
284 check_op (funct_state local
, tree t
, bool checking_write
)
286 t
= get_base_address (t
);
287 if (t
&& TREE_THIS_VOLATILE (t
))
289 local
->pure_const_state
= IPA_NEITHER
;
291 fprintf (dump_file
, " Volatile indirect ref is not const/pure\n");
295 && INDIRECT_REF_P (t
)
296 && TREE_CODE (TREE_OPERAND (t
, 0)) == SSA_NAME
297 && !ptr_deref_may_alias_global_p (TREE_OPERAND (t
, 0)))
300 fprintf (dump_file
, " Indirect ref to local memory is OK\n");
303 else if (checking_write
)
305 local
->pure_const_state
= IPA_NEITHER
;
307 fprintf (dump_file
, " Indirect ref write is not const/pure\n");
313 fprintf (dump_file
, " Indirect ref read is not const\n");
314 if (local
->pure_const_state
== IPA_CONST
)
315 local
->pure_const_state
= IPA_PURE
;
319 /* Check the parameters of a function call to CALL_EXPR to see if
320 there are any references in the parameters that are not allowed for
321 pure or const functions. Also check to see if this is either an
322 indirect call, a call outside the compilation unit, or has special
323 attributes that may also effect the purity. The CALL_EXPR node for
324 the entire call expression. */
327 check_call (funct_state local
, gimple call
, bool ipa
)
329 int flags
= gimple_call_flags (call
);
330 tree callee_t
= gimple_call_fndecl (call
);
331 bool possibly_throws
= stmt_could_throw_p (call
);
332 bool possibly_throws_externally
= (possibly_throws
333 && stmt_can_throw_external (call
));
338 for (i
= 0; i
< gimple_num_ops (call
); i
++)
339 if (gimple_op (call
, i
)
340 && tree_could_throw_p (gimple_op (call
, i
)))
342 if (possibly_throws
&& flag_non_call_exceptions
)
345 fprintf (dump_file
, " operand can throw; looping\n");
346 local
->looping
= true;
348 if (possibly_throws_externally
)
351 fprintf (dump_file
, " operand can throw externally\n");
352 local
->can_throw
= true;
357 /* The const and pure flags are set by a variety of places in the
358 compiler (including here). If someone has already set the flags
359 for the callee, (such as for some of the builtins) we will use
360 them, otherwise we will compute our own information.
362 Const and pure functions have less clobber effects than other
363 functions so we process these first. Otherwise if it is a call
364 outside the compilation unit or an indirect call we punt. This
365 leaves local calls which will be processed by following the call
369 /* When bad things happen to bad functions, they cannot be const
371 if (setjmp_call_p (callee_t
))
374 fprintf (dump_file
, " setjmp is not const/pure\n");
375 local
->looping
= true;
376 local
->pure_const_state
= IPA_NEITHER
;
379 if (DECL_BUILT_IN_CLASS (callee_t
) == BUILT_IN_NORMAL
)
380 switch (DECL_FUNCTION_CODE (callee_t
))
382 case BUILT_IN_LONGJMP
:
383 case BUILT_IN_NONLOCAL_GOTO
:
385 fprintf (dump_file
, " longjmp and nonlocal goto is not const/pure\n");
386 local
->pure_const_state
= IPA_NEITHER
;
387 local
->looping
= true;
394 /* When not in IPA mode, we can still handle self recursion. */
395 if (!ipa
&& callee_t
== current_function_decl
)
398 fprintf (dump_file
, " Recursive call can loop.\n");
399 local
->looping
= true;
401 /* Either calle is unknown or we are doing local analysis.
402 Look to see if there are any bits available for the callee (such as by
403 declaration or because it is builtin) and process solely on the basis of
405 else if (!ipa
|| !callee_t
)
407 if (possibly_throws
&& flag_non_call_exceptions
)
410 fprintf (dump_file
, " can throw; looping\n");
411 local
->looping
= true;
413 if (possibly_throws_externally
)
417 fprintf (dump_file
, " can throw externally to lp %i\n",
418 lookup_stmt_eh_lp (call
));
420 fprintf (dump_file
, " callee:%s\n",
421 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (callee_t
)));
423 local
->can_throw
= true;
425 if (flags
& ECF_CONST
)
427 if (callee_t
&& DECL_LOOPING_CONST_OR_PURE_P (callee_t
))
430 fprintf (dump_file
, " calls looping pure.\n");
431 local
->looping
= true;
434 else if (flags
& ECF_PURE
)
436 if (callee_t
&& DECL_LOOPING_CONST_OR_PURE_P (callee_t
))
439 fprintf (dump_file
, " calls looping const.\n");
440 local
->looping
= true;
443 fprintf (dump_file
, " pure function call in not const\n");
444 if (local
->pure_const_state
== IPA_CONST
)
445 local
->pure_const_state
= IPA_PURE
;
450 fprintf (dump_file
, " uknown function call is not const/pure\n");
451 local
->pure_const_state
= IPA_NEITHER
;
452 local
->looping
= true;
455 /* Direct functions calls are handled by IPA propagation. */
458 /* Wrapper around check_decl for loads. */
461 check_load (gimple stmt ATTRIBUTE_UNUSED
, tree op
, void *data
)
464 check_decl ((funct_state
)data
, op
, false);
466 check_op ((funct_state
)data
, op
, false);
470 /* Wrapper around check_decl for stores. */
473 check_store (gimple stmt ATTRIBUTE_UNUSED
, tree op
, void *data
)
476 check_decl ((funct_state
)data
, op
, true);
478 check_op ((funct_state
)data
, op
, true);
482 /* Look into pointer pointed to by GSIP and figure out what interesting side
485 check_stmt (gimple_stmt_iterator
*gsip
, funct_state local
, bool ipa
)
487 gimple stmt
= gsi_stmt (*gsip
);
490 if (is_gimple_debug (stmt
))
495 fprintf (dump_file
, " scanning: ");
496 print_gimple_stmt (dump_file
, stmt
, 0, 0);
499 /* Look for loads and stores. */
500 walk_stmt_load_store_ops (stmt
, local
, check_load
, check_store
);
502 if (gimple_code (stmt
) != GIMPLE_CALL
503 && stmt_could_throw_p (stmt
))
505 if (flag_non_call_exceptions
)
508 fprintf (dump_file
, " can throw; looping");
509 local
->looping
= true;
511 if (stmt_can_throw_external (stmt
))
514 fprintf (dump_file
, " can throw externally");
515 local
->can_throw
= true;
518 switch (gimple_code (stmt
))
521 check_call (local
, stmt
, ipa
);
524 if (DECL_NONLOCAL (gimple_label_label (stmt
)))
525 /* Target of long jump. */
528 fprintf (dump_file
, " nonlocal label is not const/pure");
529 local
->pure_const_state
= IPA_NEITHER
;
533 for (i
= 0; i
< gimple_asm_nclobbers (stmt
); i
++)
535 tree op
= gimple_asm_clobber_op (stmt
, i
);
536 if (simple_cst_equal(TREE_VALUE (op
), memory_identifier_string
) == 1)
539 fprintf (dump_file
, " memory asm clobber is not const/pure");
540 /* Abandon all hope, ye who enter here. */
541 local
->pure_const_state
= IPA_NEITHER
;
544 if (gimple_asm_volatile_p (stmt
))
547 fprintf (dump_file
, " volatile is not const/pure");
548 /* Abandon all hope, ye who enter here. */
549 local
->pure_const_state
= IPA_NEITHER
;
550 local
->looping
= true;
559 /* This is the main routine for finding the reference patterns for
560 global variables within a function FN. */
563 analyze_function (struct cgraph_node
*fn
, bool ipa
)
565 tree decl
= fn
->decl
;
568 basic_block this_block
;
570 l
= XCNEW (struct funct_state_d
);
571 l
->state_previously_known
= IPA_NEITHER
;
572 l
->looping_previously_known
= true;
574 l
->can_throw
= false;
575 if (DECL_IS_IFUNC (decl
))
577 l
->pure_const_state
= IPA_NEITHER
;
581 l
->pure_const_state
= IPA_CONST
;
585 fprintf (dump_file
, "\n\n local analysis of %s\n ",
586 cgraph_node_name (fn
));
589 old_decl
= current_function_decl
;
590 push_cfun (DECL_STRUCT_FUNCTION (decl
));
591 current_function_decl
= decl
;
593 FOR_EACH_BB (this_block
)
595 gimple_stmt_iterator gsi
;
596 struct walk_stmt_info wi
;
598 memset (&wi
, 0, sizeof(wi
));
599 for (gsi
= gsi_start_bb (this_block
);
603 check_stmt (&gsi
, l
, ipa
);
604 if (l
->pure_const_state
== IPA_NEITHER
&& l
->looping
&& l
->can_throw
)
610 if (l
->pure_const_state
!= IPA_NEITHER
)
612 /* Const functions cannot have back edges (an
613 indication of possible infinite loop side
615 if (mark_dfs_back_edges ())
617 /* Preheaders are needed for SCEV to work.
618 Simple lateches and recorded exits improve chances that loop will
619 proved to be finite in testcases such as in loop-15.c and loop-24.c */
620 loop_optimizer_init (LOOPS_NORMAL
621 | LOOPS_HAVE_RECORDED_EXITS
);
622 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
623 flow_loops_dump (dump_file
, NULL
, 0);
624 if (mark_irreducible_loops ())
627 fprintf (dump_file
, " has irreducible loops\n");
635 FOR_EACH_LOOP (li
, loop
, 0)
636 if (!finite_loop_p (loop
))
639 fprintf (dump_file
, " can not prove finiteness of loop %i\n", loop
->num
);
645 loop_optimizer_finalize ();
649 if (TREE_READONLY (decl
))
651 l
->pure_const_state
= IPA_CONST
;
652 l
->state_previously_known
= IPA_CONST
;
653 if (!DECL_LOOPING_CONST_OR_PURE_P (decl
))
654 l
->looping
= false, l
->looping_previously_known
= false;
656 if (DECL_PURE_P (decl
))
658 if (l
->pure_const_state
!= IPA_CONST
)
659 l
->pure_const_state
= IPA_PURE
;
660 l
->state_previously_known
= IPA_PURE
;
661 if (!DECL_LOOPING_CONST_OR_PURE_P (decl
))
662 l
->looping
= false, l
->looping_previously_known
= false;
664 if (TREE_NOTHROW (decl
))
665 l
->can_throw
= false;
668 current_function_decl
= old_decl
;
674 fprintf (dump_file
, "Function is locally looping.\n");
676 fprintf (dump_file
, "Function is locally throwing.\n");
677 if (l
->pure_const_state
== IPA_CONST
)
678 fprintf (dump_file
, "Function is locally const.\n");
679 if (l
->pure_const_state
== IPA_PURE
)
680 fprintf (dump_file
, "Function is locally pure.\n");
685 /* Called when new function is inserted to callgraph late. */
687 add_new_function (struct cgraph_node
*node
, void *data ATTRIBUTE_UNUSED
)
689 if (cgraph_function_body_availability (node
) < AVAIL_OVERWRITABLE
)
691 /* There are some shared nodes, in particular the initializers on
692 static declarations. We do not need to scan them more than once
693 since all we would be interested in are the addressof
695 visited_nodes
= pointer_set_create ();
696 if (cgraph_function_body_availability (node
) > AVAIL_OVERWRITABLE
)
697 set_function_state (node
, analyze_function (node
, true));
698 pointer_set_destroy (visited_nodes
);
699 visited_nodes
= NULL
;
702 /* Called when new clone is inserted to callgraph late. */
705 duplicate_node_data (struct cgraph_node
*src
, struct cgraph_node
*dst
,
706 void *data ATTRIBUTE_UNUSED
)
708 if (get_function_state (src
))
710 funct_state l
= XNEW (struct funct_state_d
);
711 gcc_assert (!get_function_state (dst
));
712 memcpy (l
, get_function_state (src
), sizeof (*l
));
713 set_function_state (dst
, l
);
717 /* Called when new clone is inserted to callgraph late. */
720 remove_node_data (struct cgraph_node
*node
, void *data ATTRIBUTE_UNUSED
)
722 if (get_function_state (node
))
724 free (get_function_state (node
));
725 set_function_state (node
, NULL
);
731 register_hooks (void)
733 static bool init_p
= false;
740 node_removal_hook_holder
=
741 cgraph_add_node_removal_hook (&remove_node_data
, NULL
);
742 node_duplication_hook_holder
=
743 cgraph_add_node_duplication_hook (&duplicate_node_data
, NULL
);
744 function_insertion_hook_holder
=
745 cgraph_add_function_insertion_hook (&add_new_function
, NULL
);
749 /* Analyze each function in the cgraph to see if it is locally PURE or
753 generate_summary (void)
755 struct cgraph_node
*node
;
759 /* There are some shared nodes, in particular the initializers on
760 static declarations. We do not need to scan them more than once
761 since all we would be interested in are the addressof
763 visited_nodes
= pointer_set_create ();
765 /* Process all of the functions.
767 We process AVAIL_OVERWRITABLE functions. We can not use the results
768 by default, but the info can be used at LTO with -fwhole-program or
769 when function got clonned and the clone is AVAILABLE. */
771 for (node
= cgraph_nodes
; node
; node
= node
->next
)
772 if (cgraph_function_body_availability (node
) >= AVAIL_OVERWRITABLE
)
773 set_function_state (node
, analyze_function (node
, true));
775 pointer_set_destroy (visited_nodes
);
776 visited_nodes
= NULL
;
780 /* Serialize the ipa info for lto. */
783 pure_const_write_summary (cgraph_node_set set
,
784 varpool_node_set vset ATTRIBUTE_UNUSED
)
786 struct cgraph_node
*node
;
787 struct lto_simple_output_block
*ob
788 = lto_create_simple_output_block (LTO_section_ipa_pure_const
);
789 unsigned int count
= 0;
790 cgraph_node_set_iterator csi
;
792 for (csi
= csi_start (set
); !csi_end_p (csi
); csi_next (&csi
))
794 node
= csi_node (csi
);
795 if (node
->analyzed
&& get_function_state (node
) != NULL
)
799 lto_output_uleb128_stream (ob
->main_stream
, count
);
801 /* Process all of the functions. */
802 for (csi
= csi_start (set
); !csi_end_p (csi
); csi_next (&csi
))
804 node
= csi_node (csi
);
805 if (node
->analyzed
&& get_function_state (node
) != NULL
)
807 struct bitpack_d
*bp
;
810 lto_cgraph_encoder_t encoder
;
812 fs
= get_function_state (node
);
814 encoder
= ob
->decl_state
->cgraph_node_encoder
;
815 node_ref
= lto_cgraph_encoder_encode (encoder
, node
);
816 lto_output_uleb128_stream (ob
->main_stream
, node_ref
);
818 /* Note that flags will need to be read in the opposite
819 order as we are pushing the bitflags into FLAGS. */
820 bp
= bitpack_create ();
821 bp_pack_value (bp
, fs
->pure_const_state
, 2);
822 bp_pack_value (bp
, fs
->state_previously_known
, 2);
823 bp_pack_value (bp
, fs
->looping_previously_known
, 1);
824 bp_pack_value (bp
, fs
->looping
, 1);
825 bp_pack_value (bp
, fs
->can_throw
, 1);
826 lto_output_bitpack (ob
->main_stream
, bp
);
831 lto_destroy_simple_output_block (ob
);
835 /* Deserialize the ipa info for lto. */
838 pure_const_read_summary (void)
840 struct lto_file_decl_data
**file_data_vec
= lto_get_file_decl_data ();
841 struct lto_file_decl_data
*file_data
;
845 while ((file_data
= file_data_vec
[j
++]))
849 struct lto_input_block
*ib
850 = lto_create_simple_input_block (file_data
,
851 LTO_section_ipa_pure_const
,
856 unsigned int count
= lto_input_uleb128 (ib
);
858 for (i
= 0; i
< count
; i
++)
861 struct cgraph_node
*node
;
862 struct bitpack_d
*bp
;
864 lto_cgraph_encoder_t encoder
;
866 fs
= XCNEW (struct funct_state_d
);
867 index
= lto_input_uleb128 (ib
);
868 encoder
= file_data
->cgraph_node_encoder
;
869 node
= lto_cgraph_encoder_deref (encoder
, index
);
870 set_function_state (node
, fs
);
872 /* Note that the flags must be read in the opposite
873 order in which they were written (the bitflags were
874 pushed into FLAGS). */
875 bp
= lto_input_bitpack (ib
);
877 = (enum pure_const_state_e
) bp_unpack_value (bp
, 2);
878 fs
->state_previously_known
879 = (enum pure_const_state_e
) bp_unpack_value (bp
, 2);
880 fs
->looping_previously_known
= bp_unpack_value (bp
, 1);
881 fs
->looping
= bp_unpack_value (bp
, 1);
882 fs
->can_throw
= bp_unpack_value (bp
, 1);
886 lto_destroy_simple_input_block (file_data
,
887 LTO_section_ipa_pure_const
,
895 ignore_edge (struct cgraph_edge
*e
)
897 return (!e
->can_throw_external
);
900 /* Return true if NODE is self recursive function. */
903 self_recursive_p (struct cgraph_node
*node
)
905 struct cgraph_edge
*e
;
906 for (e
= node
->callees
; e
; e
= e
->next_callee
)
907 if (e
->callee
== node
)
912 /* Produce the global information by preforming a transitive closure
913 on the local information that was produced by generate_summary.
914 Note that there is no function_transform pass since this only
915 updates the function_decl. */
920 struct cgraph_node
*node
;
921 struct cgraph_node
*w
;
922 struct cgraph_node
**order
=
923 XCNEWVEC (struct cgraph_node
*, cgraph_n_nodes
);
926 struct ipa_dfs_info
* w_info
;
928 cgraph_remove_function_insertion_hook (function_insertion_hook_holder
);
929 cgraph_remove_node_duplication_hook (node_duplication_hook_holder
);
930 cgraph_remove_node_removal_hook (node_removal_hook_holder
);
931 order_pos
= ipa_utils_reduced_inorder (order
, true, false, NULL
);
934 dump_cgraph (dump_file
);
935 ipa_utils_print_order(dump_file
, "reduced", order
, order_pos
);
938 /* Propagate the local information thru the call graph to produce
939 the global information. All the nodes within a cycle will have
940 the same info so we collapse cycles first. Then we can do the
941 propagation in one pass from the leaves to the roots. */
942 for (i
= 0; i
< order_pos
; i
++ )
944 enum pure_const_state_e pure_const_state
= IPA_CONST
;
945 bool looping
= false;
949 /* Find the worst state for any node in the cycle. */
953 struct cgraph_edge
*e
;
954 funct_state w_l
= get_function_state (w
);
955 if (pure_const_state
< w_l
->pure_const_state
)
956 pure_const_state
= w_l
->pure_const_state
;
960 if (cgraph_function_body_availability (w
) == AVAIL_OVERWRITABLE
)
962 looping
|= w_l
->looping_previously_known
;
963 if (pure_const_state
< w_l
->state_previously_known
)
964 pure_const_state
= w_l
->state_previously_known
;
967 if (pure_const_state
== IPA_NEITHER
)
975 for (e
= w
->callees
; e
; e
= e
->next_callee
)
977 struct cgraph_node
*y
= e
->callee
;
979 if (cgraph_function_body_availability (y
) > AVAIL_OVERWRITABLE
)
981 funct_state y_l
= get_function_state (y
);
982 if (pure_const_state
< y_l
->pure_const_state
)
983 pure_const_state
= y_l
->pure_const_state
;
984 if (pure_const_state
== IPA_NEITHER
)
991 int flags
= flags_from_decl_or_type (y
->decl
);
993 if (flags
& ECF_LOOPING_CONST_OR_PURE
)
995 if (flags
& ECF_CONST
)
997 else if ((flags
& ECF_PURE
) && pure_const_state
== IPA_CONST
)
998 pure_const_state
= IPA_PURE
;
1000 pure_const_state
= IPA_NEITHER
, looping
= true;
1004 w_info
= (struct ipa_dfs_info
*) w
->aux
;
1005 w
= w_info
->next_cycle
;
1008 /* Copy back the region's pure_const_state which is shared by
1009 all nodes in the region. */
1013 funct_state w_l
= get_function_state (w
);
1014 enum pure_const_state_e this_state
= pure_const_state
;
1015 bool this_looping
= looping
;
1017 if (w_l
->state_previously_known
!= IPA_NEITHER
1018 && this_state
> w_l
->state_previously_known
)
1019 this_state
= w_l
->state_previously_known
;
1020 if (!this_looping
&& self_recursive_p (w
))
1021 this_looping
= true;
1022 if (!w_l
->looping_previously_known
)
1023 this_looping
= false;
1025 /* All nodes within a cycle share the same info. */
1026 w_l
->pure_const_state
= this_state
;
1027 w_l
->looping
= this_looping
;
1032 if (!TREE_READONLY (w
->decl
))
1034 warn_function_const (w
->decl
, !this_looping
);
1036 fprintf (dump_file
, "Function found to be %sconst: %s\n",
1037 this_looping
? "looping " : "",
1038 cgraph_node_name (w
));
1040 cgraph_set_readonly_flag (w
, true);
1041 cgraph_set_looping_const_or_pure_flag (w
, this_looping
);
1045 if (!DECL_PURE_P (w
->decl
))
1047 warn_function_pure (w
->decl
, !this_looping
);
1049 fprintf (dump_file
, "Function found to be %spure: %s\n",
1050 this_looping
? "looping " : "",
1051 cgraph_node_name (w
));
1053 cgraph_set_pure_flag (w
, true);
1054 cgraph_set_looping_const_or_pure_flag (w
, this_looping
);
1060 w_info
= (struct ipa_dfs_info
*) w
->aux
;
1061 w
= w_info
->next_cycle
;
1066 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1068 /* Get rid of the aux information. */
1071 w_info
= (struct ipa_dfs_info
*) node
->aux
;
1076 order_pos
= ipa_utils_reduced_inorder (order
, true, false, ignore_edge
);
1079 dump_cgraph (dump_file
);
1080 ipa_utils_print_order(dump_file
, "reduced for nothrow", order
, order_pos
);
1082 /* Propagate the local information thru the call graph to produce
1083 the global information. All the nodes within a cycle will have
1084 the same info so we collapse cycles first. Then we can do the
1085 propagation in one pass from the leaves to the roots. */
1086 for (i
= 0; i
< order_pos
; i
++ )
1088 bool can_throw
= false;
1091 /* Find the worst state for any node in the cycle. */
1095 struct cgraph_edge
*e
;
1096 funct_state w_l
= get_function_state (w
);
1099 || cgraph_function_body_availability (w
) == AVAIL_OVERWRITABLE
)
1105 for (e
= w
->callees
; e
; e
= e
->next_callee
)
1107 struct cgraph_node
*y
= e
->callee
;
1109 if (cgraph_function_body_availability (y
) > AVAIL_OVERWRITABLE
)
1111 funct_state y_l
= get_function_state (y
);
1115 if (y_l
->can_throw
&& !TREE_NOTHROW (w
->decl
)
1116 && e
->can_throw_external
)
1119 else if (e
->can_throw_external
&& !TREE_NOTHROW (y
->decl
))
1122 w_info
= (struct ipa_dfs_info
*) w
->aux
;
1123 w
= w_info
->next_cycle
;
1126 /* Copy back the region's pure_const_state which is shared by
1127 all nodes in the region. */
1131 funct_state w_l
= get_function_state (w
);
1132 if (!can_throw
&& !TREE_NOTHROW (w
->decl
))
1134 struct cgraph_edge
*e
;
1135 cgraph_set_nothrow_flag (w
, true);
1136 for (e
= w
->callers
; e
; e
= e
->next_caller
)
1137 e
->can_throw_external
= false;
1139 fprintf (dump_file
, "Function found to be nothrow: %s\n",
1140 cgraph_node_name (w
));
1142 else if (can_throw
&& !TREE_NOTHROW (w
->decl
))
1143 w_l
->can_throw
= true;
1144 w_info
= (struct ipa_dfs_info
*) w
->aux
;
1145 w
= w_info
->next_cycle
;
1150 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1152 /* Get rid of the aux information. */
1155 w_info
= (struct ipa_dfs_info
*) node
->aux
;
1159 if (cgraph_function_body_availability (node
) >= AVAIL_OVERWRITABLE
)
1160 free (get_function_state (node
));
1164 VEC_free (funct_state
, heap
, funct_state_vec
);
1170 gate_pure_const (void)
1172 return (flag_ipa_pure_const
1173 /* Don't bother doing anything if the program has errors. */
1174 && !(errorcount
|| sorrycount
));
1177 struct ipa_opt_pass_d pass_ipa_pure_const
=
1181 "pure-const", /* name */
1182 gate_pure_const
, /* gate */
1183 propagate
, /* execute */
1186 0, /* static_pass_number */
1187 TV_IPA_PURE_CONST
, /* tv_id */
1188 0, /* properties_required */
1189 0, /* properties_provided */
1190 0, /* properties_destroyed */
1191 0, /* todo_flags_start */
1192 0 /* todo_flags_finish */
1194 generate_summary
, /* generate_summary */
1195 pure_const_write_summary
, /* write_summary */
1196 pure_const_read_summary
, /* read_summary */
1197 NULL
, /* write_optimization_summary */
1198 NULL
, /* read_optimization_summary */
1199 NULL
, /* stmt_fixup */
1201 NULL
, /* function_transform */
1202 NULL
/* variable_transform */
1205 /* Return true if function should be skipped for local pure const analysis. */
1208 skip_function_for_local_pure_const (struct cgraph_node
*node
)
1210 /* Because we do not schedule pass_fixup_cfg over whole program after early optimizations
1211 we must not promote functions that are called by already processed functions. */
1213 if (function_called_by_processed_nodes_p ())
1216 fprintf (dump_file
, "Function called in recursive cycle; ignoring\n");
1219 if (cgraph_function_body_availability (node
) <= AVAIL_OVERWRITABLE
)
1222 fprintf (dump_file
, "Function is not available or overwrittable; not analyzing.\n");
1228 /* Simple local pass for pure const discovery reusing the analysis from
1229 ipa_pure_const. This pass is effective when executed together with
1230 other optimization passes in early optimization pass queue. */
1233 local_pure_const (void)
1235 bool changed
= false;
1238 struct cgraph_node
*node
;
1240 node
= cgraph_node (current_function_decl
);
1241 skip
= skip_function_for_local_pure_const (node
);
1242 if (!warn_suggest_attribute_const
1243 && !warn_suggest_attribute_pure
1246 l
= analyze_function (node
, false);
1248 switch (l
->pure_const_state
)
1251 if (!TREE_READONLY (current_function_decl
))
1253 warn_function_const (current_function_decl
, !l
->looping
);
1256 cgraph_set_readonly_flag (node
, true);
1257 cgraph_set_looping_const_or_pure_flag (node
, l
->looping
);
1261 fprintf (dump_file
, "Function found to be %sconst: %s\n",
1262 l
->looping
? "looping " : "",
1263 lang_hooks
.decl_printable_name (current_function_decl
,
1266 else if (DECL_LOOPING_CONST_OR_PURE_P (current_function_decl
)
1271 cgraph_set_looping_const_or_pure_flag (node
, false);
1275 fprintf (dump_file
, "Function found to be non-looping: %s\n",
1276 lang_hooks
.decl_printable_name (current_function_decl
,
1282 if (!DECL_PURE_P (current_function_decl
))
1286 cgraph_set_pure_flag (node
, true);
1287 cgraph_set_looping_const_or_pure_flag (node
, l
->looping
);
1290 warn_function_pure (current_function_decl
, !l
->looping
);
1292 fprintf (dump_file
, "Function found to be %spure: %s\n",
1293 l
->looping
? "looping " : "",
1294 lang_hooks
.decl_printable_name (current_function_decl
,
1297 else if (DECL_LOOPING_CONST_OR_PURE_P (current_function_decl
)
1302 cgraph_set_looping_const_or_pure_flag (node
, false);
1306 fprintf (dump_file
, "Function found to be non-looping: %s\n",
1307 lang_hooks
.decl_printable_name (current_function_decl
,
1315 if (!l
->can_throw
&& !TREE_NOTHROW (current_function_decl
))
1317 struct cgraph_edge
*e
;
1319 cgraph_set_nothrow_flag (node
, true);
1320 for (e
= node
->callers
; e
; e
= e
->next_caller
)
1321 e
->can_throw_external
= false;
1324 fprintf (dump_file
, "Function found to be nothrow: %s\n",
1325 lang_hooks
.decl_printable_name (current_function_decl
,
1331 return execute_fixup_cfg ();
1336 struct gimple_opt_pass pass_local_pure_const
=
1340 "local-pure-const", /* name */
1341 gate_pure_const
, /* gate */
1342 local_pure_const
, /* execute */
1345 0, /* static_pass_number */
1346 TV_IPA_PURE_CONST
, /* tv_id */
1347 0, /* properties_required */
1348 0, /* properties_provided */
1349 0, /* properties_destroyed */
1350 0, /* todo_flags_start */
1351 0 /* todo_flags_finish */