/* Callgraph based analysis of static variables.
- Copyright (C) 2004, 2005, 2007, 2008, 2009 Free Software Foundation, Inc.
+ Copyright (C) 2004-2014 Free Software Foundation, Inc.
Contributed by Kenneth Zadeck <zadeck@naturalbridge.com>
This file is part of GCC.
#include "coretypes.h"
#include "tm.h"
#include "tree.h"
-#include "tree-flow.h"
+#include "print-tree.h"
+#include "calls.h"
+#include "basic-block.h"
+#include "tree-ssa-alias.h"
+#include "internal-fn.h"
+#include "tree-eh.h"
+#include "gimple-expr.h"
+#include "is-a.h"
+#include "gimple.h"
+#include "gimple-iterator.h"
+#include "gimple-walk.h"
+#include "tree-cfg.h"
+#include "tree-ssa-loop-niter.h"
#include "tree-inline.h"
#include "tree-pass.h"
#include "langhooks.h"
-#include "pointer-set.h"
-#include "ggc.h"
#include "ipa-utils.h"
-#include "gimple.h"
-#include "cgraph.h"
-#include "output.h"
#include "flags.h"
-#include "timevar.h"
#include "diagnostic.h"
+#include "gimple-pretty-print.h"
#include "langhooks.h"
#include "target.h"
#include "lto-streamer.h"
+#include "data-streamer.h"
+#include "tree-streamer.h"
#include "cfgloop.h"
#include "tree-scalar-evolution.h"
+#include "intl.h"
+#include "opts.h"
static struct pointer_set_t *visited_nodes;
IPA_NEITHER
};
+const char *pure_const_names[3] = {"const", "pure", "neither"};
+
/* Holder for the const_state. There is one of these per function
decl. */
struct funct_state_d
bool can_throw;
};
+/* State used when we know nothing about function. */
+static struct funct_state_d varying_state
+ = { IPA_NEITHER, IPA_NEITHER, true, true, true };
+
+
typedef struct funct_state_d * funct_state;
/* The storage of the funct_state is abstracted because there is the
/* Array, indexed by cgraph node uid, of function states. */
-DEF_VEC_P (funct_state);
-DEF_VEC_ALLOC_P (funct_state, heap);
-static VEC (funct_state, heap) *funct_state_vec;
+static vec<funct_state> funct_state_vec;
/* Holders of ipa cgraph hooks: */
static struct cgraph_node_hook_list *function_insertion_hook_holder;
static struct cgraph_2node_hook_list *node_duplication_hook_holder;
static struct cgraph_node_hook_list *node_removal_hook_holder;
-/* Init the function state. */
+/* Try to guess if function body will always be visible to compiler
+ when compiling the call and whether compiler will be able
+ to propagate the information by itself. */
+
+static bool
+function_always_visible_to_compiler_p (tree decl)
+{
+ return (!TREE_PUBLIC (decl) || DECL_DECLARED_INLINE_P (decl));
+}
+
+/* Emit suggestion about attribute ATTRIB_NAME for DECL. KNOWN_FINITE
+ is true if the function is known to be finite. The diagnostic is
+ controlled by OPTION. WARNED_ABOUT is a pointer_set unique for
+ OPTION, this function may initialize it and it is always returned
+ by the function. */
+
+static struct pointer_set_t *
+suggest_attribute (int option, tree decl, bool known_finite,
+ struct pointer_set_t *warned_about,
+ const char * attrib_name)
+{
+ if (!option_enabled (option, &global_options))
+ return warned_about;
+ if (TREE_THIS_VOLATILE (decl)
+ || (known_finite && function_always_visible_to_compiler_p (decl)))
+ return warned_about;
+
+ if (!warned_about)
+ warned_about = pointer_set_create ();
+ if (pointer_set_contains (warned_about, decl))
+ return warned_about;
+ pointer_set_insert (warned_about, decl);
+ warning_at (DECL_SOURCE_LOCATION (decl),
+ option,
+ known_finite
+ ? _("function might be candidate for attribute %<%s%>")
+ : _("function might be candidate for attribute %<%s%>"
+ " if it is known to return normally"), attrib_name);
+ return warned_about;
+}
+
+/* Emit suggestion about __attribute_((pure)) for DECL. KNOWN_FINITE
+ is true if the function is known to be finite. */
static void
-finish_state (void)
+warn_function_pure (tree decl, bool known_finite)
{
- free (funct_state_vec);
+ static struct pointer_set_t *warned_about;
+
+ warned_about
+ = suggest_attribute (OPT_Wsuggest_attribute_pure, decl,
+ known_finite, warned_about, "pure");
}
+/* Emit suggestion about __attribute_((const)) for DECL. KNOWN_FINITE
+ is true if the function is known to be finite. */
+
+static void
+warn_function_const (tree decl, bool known_finite)
+{
+ static struct pointer_set_t *warned_about;
+ warned_about
+ = suggest_attribute (OPT_Wsuggest_attribute_const, decl,
+ known_finite, warned_about, "const");
+}
+
+static void
+warn_function_noreturn (tree decl)
+{
+ static struct pointer_set_t *warned_about;
+ if (!lang_hooks.missing_noreturn_ok_p (decl)
+ && targetm.warn_func_return (decl))
+ warned_about
+ = suggest_attribute (OPT_Wsuggest_attribute_noreturn, decl,
+ true, warned_about, "noreturn");
+}
+
+/* Return true if we have a function state for NODE. */
+
+static inline bool
+has_function_state (struct cgraph_node *node)
+{
+ if (!funct_state_vec.exists ()
+ || funct_state_vec.length () <= (unsigned int)node->uid)
+ return false;
+ return funct_state_vec[node->uid] != NULL;
+}
/* Return the function state from NODE. */
static inline funct_state
get_function_state (struct cgraph_node *node)
{
- if (!funct_state_vec
- || VEC_length (funct_state, funct_state_vec) <= (unsigned int)node->uid)
- return NULL;
- return VEC_index (funct_state, funct_state_vec, node->uid);
+ if (!funct_state_vec.exists ()
+ || funct_state_vec.length () <= (unsigned int)node->uid
+ || !funct_state_vec[node->uid])
+ /* We might want to put correct previously_known state into varying. */
+ return &varying_state;
+ return funct_state_vec[node->uid];
}
/* Set the function state S for NODE. */
static inline void
set_function_state (struct cgraph_node *node, funct_state s)
{
- if (!funct_state_vec
- || VEC_length (funct_state, funct_state_vec) <= (unsigned int)node->uid)
- VEC_safe_grow_cleared (funct_state, heap, funct_state_vec, node->uid + 1);
- VEC_replace (funct_state, funct_state_vec, node->uid, s);
+ if (!funct_state_vec.exists ()
+ || funct_state_vec.length () <= (unsigned int)node->uid)
+ funct_state_vec.safe_grow_cleared (node->uid + 1);
+ funct_state_vec[node->uid] = s;
}
/* Check to see if the use (or definition when CHECKING_WRITE is true)
static inline void
check_decl (funct_state local,
- tree t, bool checking_write)
+ tree t, bool checking_write, bool ipa)
{
/* Do not want to do anything with volatile except mark any
function that uses one to be not const or pure. */
/* If the variable has the "used" attribute, treat it as if it had a
been touched by the devil. */
- if (lookup_attribute ("used", DECL_ATTRIBUTES (t)))
+ if (DECL_PRESERVE_P (t))
{
local->pure_const_state = IPA_NEITHER;
if (dump_file)
return;
}
+ /* In IPA mode we are not interested in checking actual loads and stores;
+ they will be processed at propagation time using ipa_ref. */
+ if (ipa)
+ return;
+
/* Since we have dealt with the locals and params cases above, if we
are CHECKING_WRITE, this cannot be a pure or constant
function. */
return;
}
else if (t
- && INDIRECT_REF_P (t)
+ && (INDIRECT_REF_P (t) || TREE_CODE (t) == MEM_REF)
&& TREE_CODE (TREE_OPERAND (t, 0)) == SSA_NAME
&& !ptr_deref_may_alias_global_p (TREE_OPERAND (t, 0)))
{
}
}
+/* compute state based on ECF FLAGS and store to STATE and LOOPING. */
+
+static void
+state_from_flags (enum pure_const_state_e *state, bool *looping,
+ int flags, bool cannot_lead_to_return)
+{
+ *looping = false;
+ if (flags & ECF_LOOPING_CONST_OR_PURE)
+ {
+ *looping = true;
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ fprintf (dump_file, " looping");
+ }
+ if (flags & ECF_CONST)
+ {
+ *state = IPA_CONST;
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ fprintf (dump_file, " const\n");
+ }
+ else if (flags & ECF_PURE)
+ {
+ *state = IPA_PURE;
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ fprintf (dump_file, " pure\n");
+ }
+ else if (cannot_lead_to_return)
+ {
+ *state = IPA_PURE;
+ *looping = true;
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ fprintf (dump_file, " ignoring side effects->pure looping\n");
+ }
+ else
+ {
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ fprintf (dump_file, " neither\n");
+ *state = IPA_NEITHER;
+ *looping = true;
+ }
+}
+
+/* Merge STATE and STATE2 and LOOPING and LOOPING2 and store
+ into STATE and LOOPING better of the two variants.
+ Be sure to merge looping correctly. IPA_NEITHER functions
+ have looping 0 even if they don't have to return. */
+
+static inline void
+better_state (enum pure_const_state_e *state, bool *looping,
+ enum pure_const_state_e state2, bool looping2)
+{
+ if (state2 < *state)
+ {
+ if (*state == IPA_NEITHER)
+ *looping = looping2;
+ else
+ *looping = MIN (*looping, looping2);
+ *state = state2;
+ }
+ else if (state2 != IPA_NEITHER)
+ *looping = MIN (*looping, looping2);
+}
+
+/* Merge STATE and STATE2 and LOOPING and LOOPING2 and store
+ into STATE and LOOPING worse of the two variants. */
+
+static inline void
+worse_state (enum pure_const_state_e *state, bool *looping,
+ enum pure_const_state_e state2, bool looping2)
+{
+ *state = MAX (*state, state2);
+ *looping = MAX (*looping, looping2);
+}
+
+/* Recognize special cases of builtins that are by themselves not pure or const
+ but function using them is. */
+static bool
+special_builtin_state (enum pure_const_state_e *state, bool *looping,
+ tree callee)
+{
+ if (DECL_BUILT_IN_CLASS (callee) == BUILT_IN_NORMAL)
+ switch (DECL_FUNCTION_CODE (callee))
+ {
+ case BUILT_IN_RETURN:
+ case BUILT_IN_UNREACHABLE:
+ case BUILT_IN_ALLOCA:
+ case BUILT_IN_ALLOCA_WITH_ALIGN:
+ case BUILT_IN_STACK_SAVE:
+ case BUILT_IN_STACK_RESTORE:
+ case BUILT_IN_EH_POINTER:
+ case BUILT_IN_EH_FILTER:
+ case BUILT_IN_UNWIND_RESUME:
+ case BUILT_IN_CXA_END_CLEANUP:
+ case BUILT_IN_EH_COPY_VALUES:
+ case BUILT_IN_FRAME_ADDRESS:
+ case BUILT_IN_APPLY:
+ case BUILT_IN_APPLY_ARGS:
+ *looping = false;
+ *state = IPA_CONST;
+ return true;
+ case BUILT_IN_PREFETCH:
+ *looping = true;
+ *state = IPA_CONST;
+ return true;
+ }
+ return false;
+}
+
/* Check the parameters of a function call to CALL_EXPR to see if
there are any references in the parameters that are not allowed for
pure or const functions. Also check to see if this is either an
{
int flags = gimple_call_flags (call);
tree callee_t = gimple_call_fndecl (call);
- struct cgraph_node* callee;
- enum availability avail = AVAIL_NOT_AVAILABLE;
bool possibly_throws = stmt_could_throw_p (call);
bool possibly_throws_externally = (possibly_throws
&& stmt_can_throw_external (call));
if (gimple_op (call, i)
&& tree_could_throw_p (gimple_op (call, i)))
{
- if (possibly_throws && flag_non_call_exceptions)
+ if (possibly_throws && cfun->can_throw_non_call_exceptions)
{
if (dump_file)
fprintf (dump_file, " operand can throw; looping\n");
graph. */
if (callee_t)
{
- callee = cgraph_node(callee_t);
- avail = cgraph_function_body_availability (callee);
+ enum pure_const_state_e call_state;
+ bool call_looping;
+ if (special_builtin_state (&call_state, &call_looping, callee_t))
+ {
+ worse_state (&local->pure_const_state, &local->looping,
+ call_state, call_looping);
+ return;
+ }
/* When bad things happen to bad functions, they cannot be const
or pure. */
if (setjmp_call_p (callee_t))
}
/* When not in IPA mode, we can still handle self recursion. */
- if (!ipa && callee_t == current_function_decl)
- local->looping = true;
- /* Either calle is unknown or we are doing local analysis.
+ if (!ipa && callee_t
+ && recursive_call_p (current_function_decl, callee_t))
+ {
+ if (dump_file)
+ fprintf (dump_file, " Recursive call can loop.\n");
+ local->looping = true;
+ }
+ /* Either callee is unknown or we are doing local analysis.
Look to see if there are any bits available for the callee (such as by
declaration or because it is builtin) and process solely on the basis of
those bits. */
- else if (!ipa || !callee_t)
+ else if (!ipa)
{
- if (possibly_throws && flag_non_call_exceptions)
+ enum pure_const_state_e call_state;
+ bool call_looping;
+ if (possibly_throws && cfun->can_throw_non_call_exceptions)
{
if (dump_file)
fprintf (dump_file, " can throw; looping\n");
}
local->can_throw = true;
}
- if (flags & ECF_CONST)
- {
- if (callee_t && DECL_LOOPING_CONST_OR_PURE_P (callee_t))
- local->looping = true;
- }
- else if (flags & ECF_PURE)
- {
- if (callee_t && DECL_LOOPING_CONST_OR_PURE_P (callee_t))
- local->looping = true;
- if (dump_file)
- fprintf (dump_file, " pure function call in not const\n");
- if (local->pure_const_state == IPA_CONST)
- local->pure_const_state = IPA_PURE;
- }
- else
- {
- if (dump_file)
- fprintf (dump_file, " uknown function call is not const/pure\n");
- local->pure_const_state = IPA_NEITHER;
- local->looping = true;
- }
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ fprintf (dump_file, " checking flags for call:");
+ state_from_flags (&call_state, &call_looping, flags,
+ ((flags & (ECF_NORETURN | ECF_NOTHROW))
+ == (ECF_NORETURN | ECF_NOTHROW))
+ || (!flag_exceptions && (flags & ECF_NORETURN)));
+ worse_state (&local->pure_const_state, &local->looping,
+ call_state, call_looping);
}
/* Direct functions calls are handled by IPA propagation. */
}
-/* Wrapper around check_decl for loads. */
+/* Wrapper around check_decl for loads in local more. */
static bool
-check_load (gimple stmt ATTRIBUTE_UNUSED, tree op, void *data)
+check_load (gimple, tree op, tree, void *data)
{
if (DECL_P (op))
- check_decl ((funct_state)data, op, false);
+ check_decl ((funct_state)data, op, false, false);
else
check_op ((funct_state)data, op, false);
return false;
}
-/* Wrapper around check_decl for stores. */
+/* Wrapper around check_decl for stores in local more. */
static bool
-check_store (gimple stmt ATTRIBUTE_UNUSED, tree op, void *data)
+check_store (gimple, tree op, tree, void *data)
{
if (DECL_P (op))
- check_decl ((funct_state)data, op, true);
+ check_decl ((funct_state)data, op, true, false);
+ else
+ check_op ((funct_state)data, op, true);
+ return false;
+}
+
+/* Wrapper around check_decl for loads in ipa mode. */
+
+static bool
+check_ipa_load (gimple, tree op, tree, void *data)
+{
+ if (DECL_P (op))
+ check_decl ((funct_state)data, op, false, true);
+ else
+ check_op ((funct_state)data, op, false);
+ return false;
+}
+
+/* Wrapper around check_decl for stores in ipa mode. */
+
+static bool
+check_ipa_store (gimple, tree op, tree, void *data)
+{
+ if (DECL_P (op))
+ check_decl ((funct_state)data, op, true, true);
else
check_op ((funct_state)data, op, true);
return false;
check_stmt (gimple_stmt_iterator *gsip, funct_state local, bool ipa)
{
gimple stmt = gsi_stmt (*gsip);
- unsigned int i = 0;
if (is_gimple_debug (stmt))
return;
print_gimple_stmt (dump_file, stmt, 0, 0);
}
+ if (gimple_has_volatile_ops (stmt)
+ && !gimple_clobber_p (stmt))
+ {
+ local->pure_const_state = IPA_NEITHER;
+ if (dump_file)
+ fprintf (dump_file, " Volatile stmt is not const/pure\n");
+ }
+
/* Look for loads and stores. */
- walk_stmt_load_store_ops (stmt, local, check_load, check_store);
+ walk_stmt_load_store_ops (stmt, local,
+ ipa ? check_ipa_load : check_load,
+ ipa ? check_ipa_store : check_store);
if (gimple_code (stmt) != GIMPLE_CALL
&& stmt_could_throw_p (stmt))
{
- if (flag_non_call_exceptions)
+ if (cfun->can_throw_non_call_exceptions)
{
if (dump_file)
- fprintf (dump_file, " can throw; looping");
+ fprintf (dump_file, " can throw; looping\n");
local->looping = true;
}
if (stmt_can_throw_external (stmt))
{
if (dump_file)
- fprintf (dump_file, " can throw externally");
+ fprintf (dump_file, " can throw externally\n");
local->can_throw = true;
}
+ else
+ if (dump_file)
+ fprintf (dump_file, " can throw\n");
}
switch (gimple_code (stmt))
{
/* Target of long jump. */
{
if (dump_file)
- fprintf (dump_file, " nonlocal label is not const/pure");
+ fprintf (dump_file, " nonlocal label is not const/pure\n");
local->pure_const_state = IPA_NEITHER;
}
break;
case GIMPLE_ASM:
- for (i = 0; i < gimple_asm_nclobbers (stmt); i++)
+ if (gimple_asm_clobbers_memory_p (stmt))
{
- tree op = gimple_asm_clobber_op (stmt, i);
- if (simple_cst_equal(TREE_VALUE (op), memory_identifier_string) == 1)
- {
- if (dump_file)
- fprintf (dump_file, " memory asm clobber is not const/pure");
- /* Abandon all hope, ye who enter here. */
- local->pure_const_state = IPA_NEITHER;
- }
+ if (dump_file)
+ fprintf (dump_file, " memory asm clobber is not const/pure\n");
+ /* Abandon all hope, ye who enter here. */
+ local->pure_const_state = IPA_NEITHER;
}
if (gimple_asm_volatile_p (stmt))
{
if (dump_file)
- fprintf (dump_file, " volatile is not const/pure");
+ fprintf (dump_file, " volatile is not const/pure\n");
/* Abandon all hope, ye who enter here. */
local->pure_const_state = IPA_NEITHER;
local->looping = true;
analyze_function (struct cgraph_node *fn, bool ipa)
{
tree decl = fn->decl;
- tree old_decl = current_function_decl;
funct_state l;
basic_block this_block;
l->looping_previously_known = true;
l->looping = false;
l->can_throw = false;
+ state_from_flags (&l->state_previously_known, &l->looping_previously_known,
+ flags_from_decl_or_type (fn->decl),
+ cgraph_node_cannot_return (fn));
+
+ if (fn->thunk.thunk_p || fn->alias)
+ {
+ /* Thunk gets propagated through, so nothing interesting happens. */
+ gcc_assert (ipa);
+ return l;
+ }
if (dump_file)
{
fprintf (dump_file, "\n\n local analysis of %s\n ",
- cgraph_node_name (fn));
+ fn->name ());
}
push_cfun (DECL_STRUCT_FUNCTION (decl));
- current_function_decl = decl;
- FOR_EACH_BB (this_block)
+ FOR_EACH_BB_FN (this_block, cfun)
{
gimple_stmt_iterator gsi;
struct walk_stmt_info wi;
- memset (&wi, 0, sizeof(wi));
+ memset (&wi, 0, sizeof (wi));
for (gsi = gsi_start_bb (this_block);
!gsi_end_p (gsi);
gsi_next (&gsi))
if (mark_dfs_back_edges ())
{
/* Preheaders are needed for SCEV to work.
- Simple lateches and recorded exits improve chances that loop will
- proved to be finite in testcases such as in loop-15.c and loop-24.c */
- loop_optimizer_init (LOOPS_NORMAL
+ Simple latches and recorded exits improve chances that loop will
+ proved to be finite in testcases such as in loop-15.c
+ and loop-24.c */
+ loop_optimizer_init (LOOPS_HAVE_PREHEADERS
+ | LOOPS_HAVE_SIMPLE_LATCHES
| LOOPS_HAVE_RECORDED_EXITS);
if (dump_file && (dump_flags & TDF_DETAILS))
flow_loops_dump (dump_file, NULL, 0);
}
else
{
- loop_iterator li;
struct loop *loop;
scev_initialize ();
- FOR_EACH_LOOP (li, loop, 0)
+ FOR_EACH_LOOP (loop, 0)
if (!finite_loop_p (loop))
{
if (dump_file)
- fprintf (dump_file, " can not prove finiteness of loop %i\n", loop->num);
+ fprintf (dump_file, " can not prove finiteness of "
+ "loop %i\n", loop->num);
l->looping =true;
break;
}
}
}
- if (TREE_READONLY (decl))
- {
- l->pure_const_state = IPA_CONST;
- l->state_previously_known = IPA_CONST;
- if (!DECL_LOOPING_CONST_OR_PURE_P (decl))
- l->looping = false, l->looping_previously_known = false;
- }
- if (DECL_PURE_P (decl))
- {
- if (l->pure_const_state != IPA_CONST)
- l->pure_const_state = IPA_PURE;
- l->state_previously_known = IPA_PURE;
- if (!DECL_LOOPING_CONST_OR_PURE_P (decl))
- l->looping = false, l->looping_previously_known = false;
- }
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ fprintf (dump_file, " checking previously known:");
+
+ better_state (&l->pure_const_state, &l->looping,
+ l->state_previously_known,
+ l->looping_previously_known);
if (TREE_NOTHROW (decl))
l->can_throw = false;
pop_cfun ();
- current_function_decl = old_decl;
if (dump_file)
{
if (l->looping)
since all we would be interested in are the addressof
operations. */
visited_nodes = pointer_set_create ();
- set_function_state (node, analyze_function (node, true));
+ if (cgraph_function_body_availability (node) > AVAIL_OVERWRITABLE)
+ set_function_state (node, analyze_function (node, true));
pointer_set_destroy (visited_nodes);
visited_nodes = NULL;
}
duplicate_node_data (struct cgraph_node *src, struct cgraph_node *dst,
void *data ATTRIBUTE_UNUSED)
{
- if (get_function_state (src))
+ if (has_function_state (src))
{
funct_state l = XNEW (struct funct_state_d);
- gcc_assert (!get_function_state (dst));
+ gcc_assert (!has_function_state (dst));
memcpy (l, get_function_state (src), sizeof (*l));
set_function_state (dst, l);
}
static void
remove_node_data (struct cgraph_node *node, void *data ATTRIBUTE_UNUSED)
{
- if (get_function_state (node))
+ if (has_function_state (node))
{
- free (get_function_state (node));
+ funct_state l = get_function_state (node);
+ if (l != &varying_state)
+ free (l);
set_function_state (node, NULL);
}
}
CONST. */
static void
-generate_summary (void)
+pure_const_generate_summary (void)
{
struct cgraph_node *node;
We process AVAIL_OVERWRITABLE functions. We can not use the results
by default, but the info can be used at LTO with -fwhole-program or
- when function got clonned and the clone is AVAILABLE. */
+ when function got cloned and the clone is AVAILABLE. */
- for (node = cgraph_nodes; node; node = node->next)
+ FOR_EACH_DEFINED_FUNCTION (node)
if (cgraph_function_body_availability (node) >= AVAIL_OVERWRITABLE)
set_function_state (node, analyze_function (node, true));
/* Serialize the ipa info for lto. */
static void
-pure_const_write_summary (cgraph_node_set set)
+pure_const_write_summary (void)
{
struct cgraph_node *node;
struct lto_simple_output_block *ob
= lto_create_simple_output_block (LTO_section_ipa_pure_const);
unsigned int count = 0;
- cgraph_node_set_iterator csi;
+ lto_symtab_encoder_iterator lsei;
+ lto_symtab_encoder_t encoder;
+
+ encoder = lto_get_out_decl_state ()->symtab_node_encoder;
- for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
+ for (lsei = lsei_start_function_in_partition (encoder); !lsei_end_p (lsei);
+ lsei_next_function_in_partition (&lsei))
{
- node = csi_node (csi);
- if (node->analyzed && get_function_state (node) != NULL)
+ node = lsei_cgraph_node (lsei);
+ if (node->definition && has_function_state (node))
count++;
}
- lto_output_uleb128_stream (ob->main_stream, count);
+ streamer_write_uhwi_stream (ob->main_stream, count);
/* Process all of the functions. */
- for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
+ for (lsei = lsei_start_function_in_partition (encoder); !lsei_end_p (lsei);
+ lsei_next_function_in_partition (&lsei))
{
- node = csi_node (csi);
- if (node->analyzed && get_function_state (node) != NULL)
+ node = lsei_cgraph_node (lsei);
+ if (node->definition && has_function_state (node))
{
- struct bitpack_d *bp;
+ struct bitpack_d bp;
funct_state fs;
int node_ref;
- lto_cgraph_encoder_t encoder;
+ lto_symtab_encoder_t encoder;
fs = get_function_state (node);
- encoder = ob->decl_state->cgraph_node_encoder;
- node_ref = lto_cgraph_encoder_encode (encoder, node);
- lto_output_uleb128_stream (ob->main_stream, node_ref);
+ encoder = ob->decl_state->symtab_node_encoder;
+ node_ref = lto_symtab_encoder_encode (encoder, node);
+ streamer_write_uhwi_stream (ob->main_stream, node_ref);
/* Note that flags will need to be read in the opposite
order as we are pushing the bitflags into FLAGS. */
- bp = bitpack_create ();
- bp_pack_value (bp, fs->pure_const_state, 2);
- bp_pack_value (bp, fs->state_previously_known, 2);
- bp_pack_value (bp, fs->looping_previously_known, 1);
- bp_pack_value (bp, fs->looping, 1);
- bp_pack_value (bp, fs->can_throw, 1);
- lto_output_bitpack (ob->main_stream, bp);
- bitpack_delete (bp);
+ bp = bitpack_create (ob->main_stream);
+ bp_pack_value (&bp, fs->pure_const_state, 2);
+ bp_pack_value (&bp, fs->state_previously_known, 2);
+ bp_pack_value (&bp, fs->looping_previously_known, 1);
+ bp_pack_value (&bp, fs->looping, 1);
+ bp_pack_value (&bp, fs->can_throw, 1);
+ streamer_write_bitpack (&bp);
}
}
if (ib)
{
unsigned int i;
- unsigned int count = lto_input_uleb128 (ib);
+ unsigned int count = streamer_read_uhwi (ib);
for (i = 0; i < count; i++)
{
unsigned int index;
struct cgraph_node *node;
- struct bitpack_d *bp;
+ struct bitpack_d bp;
funct_state fs;
- lto_cgraph_encoder_t encoder;
+ lto_symtab_encoder_t encoder;
fs = XCNEW (struct funct_state_d);
- index = lto_input_uleb128 (ib);
- encoder = file_data->cgraph_node_encoder;
- node = lto_cgraph_encoder_deref (encoder, index);
+ index = streamer_read_uhwi (ib);
+ encoder = file_data->symtab_node_encoder;
+ node = cgraph (lto_symtab_encoder_deref (encoder, index));
set_function_state (node, fs);
/* Note that the flags must be read in the opposite
order in which they were written (the bitflags were
pushed into FLAGS). */
- bp = lto_input_bitpack (ib);
+ bp = streamer_read_bitpack (ib);
fs->pure_const_state
- = (enum pure_const_state_e) bp_unpack_value (bp, 2);
+ = (enum pure_const_state_e) bp_unpack_value (&bp, 2);
fs->state_previously_known
- = (enum pure_const_state_e) bp_unpack_value (bp, 2);
- fs->looping_previously_known = bp_unpack_value (bp, 1);
- fs->looping = bp_unpack_value (bp, 1);
- fs->can_throw = bp_unpack_value (bp, 1);
- bitpack_delete (bp);
+ = (enum pure_const_state_e) bp_unpack_value (&bp, 2);
+ fs->looping_previously_known = bp_unpack_value (&bp, 1);
+ fs->looping = bp_unpack_value (&bp, 1);
+ fs->can_throw = bp_unpack_value (&bp, 1);
+ if (dump_file)
+ {
+ int flags = flags_from_decl_or_type (node->decl);
+ fprintf (dump_file, "Read info for %s/%i ",
+ node->name (),
+ node->order);
+ if (flags & ECF_CONST)
+ fprintf (dump_file, " const");
+ if (flags & ECF_PURE)
+ fprintf (dump_file, " pure");
+ if (flags & ECF_NOTHROW)
+ fprintf (dump_file, " nothrow");
+ fprintf (dump_file, "\n pure const state: %s\n",
+ pure_const_names[fs->pure_const_state]);
+ fprintf (dump_file, " previously known state: %s\n",
+ pure_const_names[fs->looping_previously_known]);
+ if (fs->looping)
+ fprintf (dump_file," function is locally looping\n");
+ if (fs->looping_previously_known)
+ fprintf (dump_file," function is previously known looping\n");
+ if (fs->can_throw)
+ fprintf (dump_file," function is locally throwing\n");
+ }
}
lto_destroy_simple_input_block (file_data,
return (!e->can_throw_external);
}
-/* Return true if NODE is self recursive function. */
+/* Return true if NODE is self recursive function.
+ Indirectly recursive functions appears as non-trivial strongly
+ connected components, so we need to care about self recursion
+ only. */
static bool
self_recursive_p (struct cgraph_node *node)
{
struct cgraph_edge *e;
for (e = node->callees; e; e = e->next_callee)
- if (e->callee == node)
+ if (cgraph_function_node (e->callee, NULL) == node)
return true;
return false;
}
-/* Produce the global information by preforming a transitive closure
- on the local information that was produced by generate_summary.
- Note that there is no function_transform pass since this only
- updates the function_decl. */
+/* Produce transitive closure over the callgraph and compute pure/const
+ attributes. */
-static unsigned int
-propagate (void)
+static void
+propagate_pure_const (void)
{
struct cgraph_node *node;
struct cgraph_node *w;
int i;
struct ipa_dfs_info * w_info;
- cgraph_remove_function_insertion_hook (function_insertion_hook_holder);
- cgraph_remove_node_duplication_hook (node_duplication_hook_holder);
- cgraph_remove_node_removal_hook (node_removal_hook_holder);
- order_pos = ipa_utils_reduced_inorder (order, true, false, NULL);
+ order_pos = ipa_reduced_postorder (order, true, false, NULL);
if (dump_file)
{
dump_cgraph (dump_file);
- ipa_utils_print_order(dump_file, "reduced", order, order_pos);
+ ipa_print_order (dump_file, "reduced", order, order_pos);
}
- /* Propagate the local information thru the call graph to produce
+ /* Propagate the local information through the call graph to produce
the global information. All the nodes within a cycle will have
the same info so we collapse cycles first. Then we can do the
propagation in one pass from the leaves to the roots. */
int count = 0;
node = order[i];
+ if (node->alias)
+ continue;
+
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ fprintf (dump_file, "Starting cycle\n");
+
/* Find the worst state for any node in the cycle. */
w = node;
- while (w)
+ while (w && pure_const_state != IPA_NEITHER)
{
struct cgraph_edge *e;
+ struct cgraph_edge *ie;
+ int i;
+ struct ipa_ref *ref;
+
funct_state w_l = get_function_state (w);
- if (pure_const_state < w_l->pure_const_state)
- pure_const_state = w_l->pure_const_state;
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ fprintf (dump_file, " Visiting %s/%i state:%s looping %i\n",
+ w->name (),
+ w->order,
+ pure_const_names[w_l->pure_const_state],
+ w_l->looping);
+
+ /* First merge in function body properties. */
+ worse_state (&pure_const_state, &looping,
+ w_l->pure_const_state, w_l->looping);
+ if (pure_const_state == IPA_NEITHER)
+ break;
- if (w_l->looping)
- looping = true;
+ /* For overwritable nodes we can not assume anything. */
if (cgraph_function_body_availability (w) == AVAIL_OVERWRITABLE)
{
- looping |= w_l->looping_previously_known;
- if (pure_const_state < w_l->state_previously_known)
- pure_const_state = w_l->state_previously_known;
+ worse_state (&pure_const_state, &looping,
+ w_l->state_previously_known,
+ w_l->looping_previously_known);
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ {
+ fprintf (dump_file,
+ " Overwritable. state %s looping %i\n",
+ pure_const_names[w_l->state_previously_known],
+ w_l->looping_previously_known);
+ }
+ break;
}
- if (pure_const_state == IPA_NEITHER)
- break;
-
count++;
+ /* We consider recursive cycles as possibly infinite.
+ This might be relaxed since infinite recursion leads to stack
+ overflow. */
if (count > 1)
looping = true;
+ /* Now walk the edges and merge in callee properties. */
for (e = w->callees; e; e = e->next_callee)
{
- struct cgraph_node *y = e->callee;
+ enum availability avail;
+ struct cgraph_node *y = cgraph_function_node (e->callee, &avail);
+ enum pure_const_state_e edge_state = IPA_CONST;
+ bool edge_looping = false;
- if (cgraph_function_body_availability (y) > AVAIL_OVERWRITABLE)
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ {
+ fprintf (dump_file,
+ " Call to %s/%i",
+ e->callee->name (),
+ e->callee->order);
+ }
+ if (avail > AVAIL_OVERWRITABLE)
{
funct_state y_l = get_function_state (y);
- if (pure_const_state < y_l->pure_const_state)
- pure_const_state = y_l->pure_const_state;
- if (pure_const_state == IPA_NEITHER)
- break;
- if (y_l->looping)
- looping = true;
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ {
+ fprintf (dump_file,
+ " state:%s looping:%i\n",
+ pure_const_names[y_l->pure_const_state],
+ y_l->looping);
+ }
+ if (y_l->pure_const_state > IPA_PURE
+ && cgraph_edge_cannot_lead_to_return (e))
+ {
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ fprintf (dump_file,
+ " Ignoring side effects"
+ " -> pure, looping\n");
+ edge_state = IPA_PURE;
+ edge_looping = true;
+ }
+ else
+ {
+ edge_state = y_l->pure_const_state;
+ edge_looping = y_l->looping;
+ }
}
+ else if (special_builtin_state (&edge_state, &edge_looping,
+ y->decl))
+ ;
else
- {
- int flags = flags_from_decl_or_type (y->decl);
+ state_from_flags (&edge_state, &edge_looping,
+ flags_from_decl_or_type (y->decl),
+ cgraph_edge_cannot_lead_to_return (e));
+
+ /* Merge the results with what we already know. */
+ better_state (&edge_state, &edge_looping,
+ w_l->state_previously_known,
+ w_l->looping_previously_known);
+ worse_state (&pure_const_state, &looping,
+ edge_state, edge_looping);
+ if (pure_const_state == IPA_NEITHER)
+ break;
+ }
+ if (pure_const_state == IPA_NEITHER)
+ break;
- if (flags & ECF_LOOPING_CONST_OR_PURE)
- looping = true;
- if (flags & ECF_CONST)
- ;
- else if ((flags & ECF_PURE) && pure_const_state == IPA_CONST)
- pure_const_state = IPA_PURE;
- else
- pure_const_state = IPA_NEITHER, looping = true;
+ /* Now process the indirect call. */
+ for (ie = w->indirect_calls; ie; ie = ie->next_callee)
+ {
+ enum pure_const_state_e edge_state = IPA_CONST;
+ bool edge_looping = false;
+
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ fprintf (dump_file, " Indirect call");
+ state_from_flags (&edge_state, &edge_looping,
+ ie->indirect_info->ecf_flags,
+ cgraph_edge_cannot_lead_to_return (ie));
+ /* Merge the results with what we already know. */
+ better_state (&edge_state, &edge_looping,
+ w_l->state_previously_known,
+ w_l->looping_previously_known);
+ worse_state (&pure_const_state, &looping,
+ edge_state, edge_looping);
+ if (pure_const_state == IPA_NEITHER)
+ break;
+ }
+ if (pure_const_state == IPA_NEITHER)
+ break;
+ /* And finally all loads and stores. */
+ for (i = 0; ipa_ref_list_reference_iterate (&w->ref_list, i, ref); i++)
+ {
+ enum pure_const_state_e ref_state = IPA_CONST;
+ bool ref_looping = false;
+ switch (ref->use)
+ {
+ case IPA_REF_LOAD:
+ /* readonly reads are safe. */
+ if (TREE_READONLY (ipa_ref_varpool_node (ref)->decl))
+ break;
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ fprintf (dump_file, " nonreadonly global var read\n");
+ ref_state = IPA_PURE;
+ break;
+ case IPA_REF_STORE:
+ if (ipa_ref_cannot_lead_to_return (ref))
+ break;
+ ref_state = IPA_NEITHER;
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ fprintf (dump_file, " global var write\n");
+ break;
+ case IPA_REF_ADDR:
+ break;
}
+ better_state (&ref_state, &ref_looping,
+ w_l->state_previously_known,
+ w_l->looping_previously_known);
+ worse_state (&pure_const_state, &looping,
+ ref_state, ref_looping);
+ if (pure_const_state == IPA_NEITHER)
+ break;
}
w_info = (struct ipa_dfs_info *) w->aux;
w = w_info->next_cycle;
}
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ fprintf (dump_file, "Result %s looping %i\n",
+ pure_const_names [pure_const_state],
+ looping);
/* Copy back the region's pure_const_state which is shared by
all nodes in the region. */
if (w_l->state_previously_known != IPA_NEITHER
&& this_state > w_l->state_previously_known)
- this_state = w_l->state_previously_known;
+ {
+ this_state = w_l->state_previously_known;
+ this_looping |= w_l->looping_previously_known;
+ }
if (!this_looping && self_recursive_p (w))
this_looping = true;
if (!w_l->looping_previously_known)
w_l->pure_const_state = this_state;
w_l->looping = this_looping;
- switch (this_state)
- {
- case IPA_CONST:
- if (!TREE_READONLY (w->decl) && dump_file)
- fprintf (dump_file, "Function found to be %sconst: %s\n",
- this_looping ? "looping " : "",
- cgraph_node_name (w));
- TREE_READONLY (w->decl) = 1;
- DECL_LOOPING_CONST_OR_PURE_P (w->decl) = this_looping;
- break;
+ /* Inline clones share declaration with their offline copies;
+ do not modify their declarations since the offline copy may
+ be different. */
+ if (!w->global.inlined_to)
+ switch (this_state)
+ {
+ case IPA_CONST:
+ if (!TREE_READONLY (w->decl))
+ {
+ warn_function_const (w->decl, !this_looping);
+ if (dump_file)
+ fprintf (dump_file, "Function found to be %sconst: %s\n",
+ this_looping ? "looping " : "",
+ w->name ());
+ }
+ cgraph_set_const_flag (w, true, this_looping);
+ break;
- case IPA_PURE:
- if (!DECL_PURE_P (w->decl) && dump_file)
- fprintf (dump_file, "Function found to be %spure: %s\n",
- this_looping ? "looping " : "",
- cgraph_node_name (w));
- DECL_PURE_P (w->decl) = 1;
- DECL_LOOPING_CONST_OR_PURE_P (w->decl) = this_looping;
- break;
+ case IPA_PURE:
+ if (!DECL_PURE_P (w->decl))
+ {
+ warn_function_pure (w->decl, !this_looping);
+ if (dump_file)
+ fprintf (dump_file, "Function found to be %spure: %s\n",
+ this_looping ? "looping " : "",
+ w->name ());
+ }
+ cgraph_set_pure_flag (w, true, this_looping);
+ break;
- default:
- break;
- }
+ default:
+ break;
+ }
w_info = (struct ipa_dfs_info *) w->aux;
w = w_info->next_cycle;
}
}
- /* Cleanup. */
- for (node = cgraph_nodes; node; node = node->next)
- {
- /* Get rid of the aux information. */
- if (node->aux)
- {
- w_info = (struct ipa_dfs_info *) node->aux;
- free (node->aux);
- node->aux = NULL;
- }
- }
- order_pos = ipa_utils_reduced_inorder (order, true, false, ignore_edge);
+ ipa_free_postorder_info ();
+ free (order);
+}
+
+/* Produce transitive closure over the callgraph and compute nothrow
+ attributes. */
+
+static void
+propagate_nothrow (void)
+{
+ struct cgraph_node *node;
+ struct cgraph_node *w;
+ struct cgraph_node **order =
+ XCNEWVEC (struct cgraph_node *, cgraph_n_nodes);
+ int order_pos;
+ int i;
+ struct ipa_dfs_info * w_info;
+
+ order_pos = ipa_reduced_postorder (order, true, false, ignore_edge);
if (dump_file)
{
dump_cgraph (dump_file);
- ipa_utils_print_order(dump_file, "reduced for nothrow", order, order_pos);
+ ipa_print_order (dump_file, "reduced for nothrow", order, order_pos);
}
- /* Propagate the local information thru the call graph to produce
+
+ /* Propagate the local information through the call graph to produce
the global information. All the nodes within a cycle will have
the same info so we collapse cycles first. Then we can do the
propagation in one pass from the leaves to the roots. */
bool can_throw = false;
node = order[i];
+ if (node->alias)
+ continue;
+
/* Find the worst state for any node in the cycle. */
w = node;
while (w)
{
- struct cgraph_edge *e;
+ struct cgraph_edge *e, *ie;
funct_state w_l = get_function_state (w);
if (w_l->can_throw
for (e = w->callees; e; e = e->next_callee)
{
- struct cgraph_node *y = e->callee;
+ enum availability avail;
+ struct cgraph_node *y = cgraph_function_node (e->callee, &avail);
- if (cgraph_function_body_availability (y) > AVAIL_OVERWRITABLE)
+ if (avail > AVAIL_OVERWRITABLE)
{
funct_state y_l = get_function_state (y);
else if (e->can_throw_external && !TREE_NOTHROW (y->decl))
can_throw = true;
}
+ for (ie = node->indirect_calls; ie; ie = ie->next_callee)
+ if (ie->can_throw_external)
+ {
+ can_throw = true;
+ break;
+ }
w_info = (struct ipa_dfs_info *) w->aux;
w = w_info->next_cycle;
}
funct_state w_l = get_function_state (w);
if (!can_throw && !TREE_NOTHROW (w->decl))
{
- struct cgraph_edge *e;
- TREE_NOTHROW (w->decl) = true;
- for (e = w->callers; e; e = e->next_caller)
- e->can_throw_external = false;
- if (dump_file)
- fprintf (dump_file, "Function found to be nothrow: %s\n",
- cgraph_node_name (w));
+ /* Inline clones share declaration with their offline copies;
+ do not modify their declarations since the offline copy may
+ be different. */
+ if (!w->global.inlined_to)
+ {
+ cgraph_set_nothrow_flag (w, true);
+ if (dump_file)
+ fprintf (dump_file, "Function found to be nothrow: %s\n",
+ w->name ());
+ }
}
else if (can_throw && !TREE_NOTHROW (w->decl))
w_l->can_throw = true;
}
}
- /* Cleanup. */
- for (node = cgraph_nodes; node; node = node->next)
- {
- /* Get rid of the aux information. */
- if (node->aux)
- {
- w_info = (struct ipa_dfs_info *) node->aux;
- free (node->aux);
- node->aux = NULL;
- }
- if (cgraph_function_body_availability (node) >= AVAIL_OVERWRITABLE)
- free (get_function_state (node));
- }
-
+ ipa_free_postorder_info ();
free (order);
- VEC_free (funct_state, heap, funct_state_vec);
- finish_state ();
+}
+
+
+/* Produce the global information by preforming a transitive closure
+ on the local information that was produced by generate_summary. */
+
+static unsigned int
+propagate (void)
+{
+ struct cgraph_node *node;
+
+ cgraph_remove_function_insertion_hook (function_insertion_hook_holder);
+ cgraph_remove_node_duplication_hook (node_duplication_hook_holder);
+ cgraph_remove_node_removal_hook (node_removal_hook_holder);
+
+ /* Nothrow makes more function to not lead to return and improve
+ later analysis. */
+ propagate_nothrow ();
+ propagate_pure_const ();
+
+ /* Cleanup. */
+ FOR_EACH_FUNCTION (node)
+ if (has_function_state (node))
+ free (get_function_state (node));
+ funct_state_vec.release ();
return 0;
}
{
return (flag_ipa_pure_const
/* Don't bother doing anything if the program has errors. */
- && !(errorcount || sorrycount));
+ && !seen_error ());
}
-struct ipa_opt_pass_d pass_ipa_pure_const =
+namespace {
+
+const pass_data pass_data_ipa_pure_const =
{
- {
- IPA_PASS,
- "pure-const", /* name */
- gate_pure_const, /* gate */
- propagate, /* execute */
- NULL, /* sub */
- NULL, /* next */
- 0, /* static_pass_number */
- TV_IPA_PURE_CONST, /* tv_id */
- 0, /* properties_required */
- 0, /* properties_provided */
- 0, /* properties_destroyed */
- 0, /* todo_flags_start */
- 0 /* todo_flags_finish */
- },
- generate_summary, /* generate_summary */
- pure_const_write_summary, /* write_summary */
- pure_const_read_summary, /* read_summary */
- NULL, /* function_read_summary */
- NULL, /* stmt_fixup */
- 0, /* TODOs */
- NULL, /* function_transform */
- NULL /* variable_transform */
+ IPA_PASS, /* type */
+ "pure-const", /* name */
+ OPTGROUP_NONE, /* optinfo_flags */
+ true, /* has_gate */
+ true, /* has_execute */
+ TV_IPA_PURE_CONST, /* tv_id */
+ 0, /* properties_required */
+ 0, /* properties_provided */
+ 0, /* properties_destroyed */
+ 0, /* todo_flags_start */
+ 0, /* todo_flags_finish */
};
-/* Simple local pass for pure const discovery reusing the analysis from
- ipa_pure_const. This pass is effective when executed together with
- other optimization passes in early optimization pass queue. */
-
-static unsigned int
-local_pure_const (void)
+class pass_ipa_pure_const : public ipa_opt_pass_d
{
- bool changed = false;
- funct_state l;
+public:
+ pass_ipa_pure_const (gcc::context *ctxt)
+ : ipa_opt_pass_d (pass_data_ipa_pure_const, ctxt,
+ pure_const_generate_summary, /* generate_summary */
+ pure_const_write_summary, /* write_summary */
+ pure_const_read_summary, /* read_summary */
+ NULL, /* write_optimization_summary */
+ NULL, /* read_optimization_summary */
+ NULL, /* stmt_fixup */
+ 0, /* function_transform_todo_flags_start */
+ NULL, /* function_transform */
+ NULL) /* variable_transform */
+ {}
+
+ /* opt_pass methods: */
+ bool gate () { return gate_pure_const (); }
+ unsigned int execute () { return propagate (); }
+
+}; // class pass_ipa_pure_const
+
+} // anon namespace
+
+ipa_opt_pass_d *
+make_pass_ipa_pure_const (gcc::context *ctxt)
+{
+ return new pass_ipa_pure_const (ctxt);
+}
+
+/* Return true if function should be skipped for local pure const analysis. */
+static bool
+skip_function_for_local_pure_const (struct cgraph_node *node)
+{
/* Because we do not schedule pass_fixup_cfg over whole program after early optimizations
we must not promote functions that are called by already processed functions. */
{
if (dump_file)
fprintf (dump_file, "Function called in recursive cycle; ignoring\n");
- return 0;
+ return true;
}
- if (cgraph_function_body_availability (cgraph_node (current_function_decl))
- <= AVAIL_OVERWRITABLE)
+ if (cgraph_function_body_availability (node) <= AVAIL_OVERWRITABLE)
{
if (dump_file)
- fprintf (dump_file, "Function has wrong visibility; ignoring\n");
- return 0;
+ fprintf (dump_file, "Function is not available or overwritable; not analyzing.\n");
+ return true;
}
+ return false;
+}
- l = analyze_function (cgraph_node (current_function_decl), false);
+/* Simple local pass for pure const discovery reusing the analysis from
+ ipa_pure_const. This pass is effective when executed together with
+ other optimization passes in early optimization pass queue. */
+
+static unsigned int
+local_pure_const (void)
+{
+ bool changed = false;
+ funct_state l;
+ bool skip;
+ struct cgraph_node *node;
+
+ node = cgraph_get_node (current_function_decl);
+ skip = skip_function_for_local_pure_const (node);
+ if (!warn_suggest_attribute_const
+ && !warn_suggest_attribute_pure
+ && skip)
+ return 0;
+
+ l = analyze_function (node, false);
+
+ /* Do NORETURN discovery. */
+ if (!skip && !TREE_THIS_VOLATILE (current_function_decl)
+ && EDGE_COUNT (EXIT_BLOCK_PTR_FOR_FN (cfun)->preds) == 0)
+ {
+ warn_function_noreturn (cfun->decl);
+ if (dump_file)
+ fprintf (dump_file, "Function found to be noreturn: %s\n",
+ current_function_name ());
+
+ /* Update declaration and reduce profile to executed once. */
+ TREE_THIS_VOLATILE (current_function_decl) = 1;
+ if (node->frequency > NODE_FREQUENCY_EXECUTED_ONCE)
+ node->frequency = NODE_FREQUENCY_EXECUTED_ONCE;
+
+ changed = true;
+ }
switch (l->pure_const_state)
{
case IPA_CONST:
if (!TREE_READONLY (current_function_decl))
{
- TREE_READONLY (current_function_decl) = 1;
- DECL_LOOPING_CONST_OR_PURE_P (current_function_decl) = l->looping;
- changed = true;
+ warn_function_const (current_function_decl, !l->looping);
+ if (!skip)
+ {
+ cgraph_set_const_flag (node, true, l->looping);
+ changed = true;
+ }
if (dump_file)
fprintf (dump_file, "Function found to be %sconst: %s\n",
l->looping ? "looping " : "",
- lang_hooks.decl_printable_name (current_function_decl,
- 2));
+ current_function_name ());
}
else if (DECL_LOOPING_CONST_OR_PURE_P (current_function_decl)
&& !l->looping)
{
- DECL_LOOPING_CONST_OR_PURE_P (current_function_decl) = false;
- changed = true;
+ if (!skip)
+ {
+ cgraph_set_const_flag (node, true, false);
+ changed = true;
+ }
if (dump_file)
fprintf (dump_file, "Function found to be non-looping: %s\n",
- lang_hooks.decl_printable_name (current_function_decl,
- 2));
+ current_function_name ());
}
break;
case IPA_PURE:
- if (!TREE_READONLY (current_function_decl))
+ if (!DECL_PURE_P (current_function_decl))
{
- DECL_PURE_P (current_function_decl) = 1;
- DECL_LOOPING_CONST_OR_PURE_P (current_function_decl) = l->looping;
- changed = true;
+ if (!skip)
+ {
+ cgraph_set_pure_flag (node, true, l->looping);
+ changed = true;
+ }
+ warn_function_pure (current_function_decl, !l->looping);
if (dump_file)
fprintf (dump_file, "Function found to be %spure: %s\n",
l->looping ? "looping " : "",
- lang_hooks.decl_printable_name (current_function_decl,
- 2));
+ current_function_name ());
}
else if (DECL_LOOPING_CONST_OR_PURE_P (current_function_decl)
&& !l->looping)
{
- DECL_LOOPING_CONST_OR_PURE_P (current_function_decl) = false;
- changed = true;
+ if (!skip)
+ {
+ cgraph_set_pure_flag (node, true, false);
+ changed = true;
+ }
if (dump_file)
fprintf (dump_file, "Function found to be non-looping: %s\n",
- lang_hooks.decl_printable_name (current_function_decl,
- 2));
+ current_function_name ());
}
break;
}
if (!l->can_throw && !TREE_NOTHROW (current_function_decl))
{
- struct cgraph_edge *e;
-
- TREE_NOTHROW (current_function_decl) = true;
- for (e = cgraph_node (current_function_decl)->callers;
- e; e = e->next_caller)
- e->can_throw_external = false;
+ cgraph_set_nothrow_flag (node, true);
changed = true;
if (dump_file)
fprintf (dump_file, "Function found to be nothrow: %s\n",
- lang_hooks.decl_printable_name (current_function_decl,
- 2));
+ current_function_name ());
}
- if (l)
- free (l);
+ free (l);
if (changed)
return execute_fixup_cfg ();
else
return 0;
}
-struct gimple_opt_pass pass_local_pure_const =
+namespace {
+
+const pass_data pass_data_local_pure_const =
+{
+ GIMPLE_PASS, /* type */
+ "local-pure-const", /* name */
+ OPTGROUP_NONE, /* optinfo_flags */
+ true, /* has_gate */
+ true, /* has_execute */
+ TV_IPA_PURE_CONST, /* tv_id */
+ 0, /* properties_required */
+ 0, /* properties_provided */
+ 0, /* properties_destroyed */
+ 0, /* todo_flags_start */
+ 0, /* todo_flags_finish */
+};
+
+class pass_local_pure_const : public gimple_opt_pass
+{
+public:
+ pass_local_pure_const (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_local_pure_const, ctxt)
+ {}
+
+ /* opt_pass methods: */
+ opt_pass * clone () { return new pass_local_pure_const (m_ctxt); }
+ bool gate () { return gate_pure_const (); }
+ unsigned int execute () { return local_pure_const (); }
+
+}; // class pass_local_pure_const
+
+} // anon namespace
+
+gimple_opt_pass *
+make_pass_local_pure_const (gcc::context *ctxt)
+{
+ return new pass_local_pure_const (ctxt);
+}
+
+/* Emit noreturn warnings. */
+
+static unsigned int
+execute_warn_function_noreturn (void)
+{
+ if (!TREE_THIS_VOLATILE (current_function_decl)
+ && EDGE_COUNT (EXIT_BLOCK_PTR_FOR_FN (cfun)->preds) == 0)
+ warn_function_noreturn (current_function_decl);
+ return 0;
+}
+
+static bool
+gate_warn_function_noreturn (void)
+{
+ return warn_suggest_attribute_noreturn;
+}
+
+namespace {
+
+const pass_data pass_data_warn_function_noreturn =
{
- {
- GIMPLE_PASS,
- "local-pure-const", /* name */
- gate_pure_const, /* gate */
- local_pure_const, /* execute */
- NULL, /* sub */
- NULL, /* next */
- 0, /* static_pass_number */
- TV_IPA_PURE_CONST, /* tv_id */
- 0, /* properties_required */
- 0, /* properties_provided */
- 0, /* properties_destroyed */
- 0, /* todo_flags_start */
- 0 /* todo_flags_finish */
- }
+ GIMPLE_PASS, /* type */
+ "*warn_function_noreturn", /* name */
+ OPTGROUP_NONE, /* optinfo_flags */
+ true, /* has_gate */
+ true, /* has_execute */
+ TV_NONE, /* tv_id */
+ PROP_cfg, /* properties_required */
+ 0, /* properties_provided */
+ 0, /* properties_destroyed */
+ 0, /* todo_flags_start */
+ 0, /* todo_flags_finish */
};
+
+class pass_warn_function_noreturn : public gimple_opt_pass
+{
+public:
+ pass_warn_function_noreturn (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_warn_function_noreturn, ctxt)
+ {}
+
+ /* opt_pass methods: */
+ bool gate () { return gate_warn_function_noreturn (); }
+ unsigned int execute () { return execute_warn_function_noreturn (); }
+
+}; // class pass_warn_function_noreturn
+
+} // anon namespace
+
+gimple_opt_pass *
+make_pass_warn_function_noreturn (gcc::context *ctxt)
+{
+ return new pass_warn_function_noreturn (ctxt);
+}
+
+
projects / gcc.git / blobdiff