/* Callgraph based analysis of static variables.
- Copyright (C) 2004, 2005, 2007, 2008, 2009 Free Software Foundation, Inc.
+ Copyright (C) 2004, 2005, 2007, 2008, 2009, 2010
+ Free Software Foundation, Inc.
Contributed by Kenneth Zadeck <zadeck@naturalbridge.com>
This file is part of GCC.
#include "output.h"
#include "flags.h"
#include "timevar.h"
+#include "toplev.h"
#include "diagnostic.h"
#include "langhooks.h"
#include "target.h"
+#include "lto-streamer.h"
#include "cfgloop.h"
#include "tree-scalar-evolution.h"
+#include "intl.h"
+#include "opts.h"
static struct pointer_set_t *visited_nodes;
/* Holder for the const_state. There is one of these per function
decl. */
-struct funct_state_d
+struct funct_state_d
{
/* See above. */
enum pure_const_state_e pure_const_state;
/* What user set here; we can be always sure about this. */
- enum pure_const_state_e state_previously_known;
- bool looping_previously_known;
+ enum pure_const_state_e state_previously_known;
+ bool looping_previously_known;
/* True if the function could possibly infinite loop. There are a
lot of ways that this could be determined. We are pretty
/* The storage of the funct_state is abstracted because there is the
possibility that it may be desirable to move this to the cgraph
- local info. */
+ local info. */
/* Array, indexed by cgraph node uid, of function states. */
static struct cgraph_2node_hook_list *node_duplication_hook_holder;
static struct cgraph_node_hook_list *node_removal_hook_holder;
+/* 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))
+ 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
+warn_function_pure (tree decl, bool known_finite)
+{
+ 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");
+}
/* Init the function state. */
static void
}
-/* Return the function state from NODE. */
+/* Return the function state from NODE. */
static inline funct_state
get_function_state (struct cgraph_node *node)
/* Check to see if the use (or definition when CHECKING_WRITE is true)
variable T is legal in a function that is either pure or const. */
-static inline void
-check_decl (funct_state local,
+static inline void
+check_decl (funct_state local,
tree t, bool checking_write)
{
/* Do not want to do anything with volatile except mark any
function that uses one to be not const or pure. */
- if (TREE_THIS_VOLATILE (t))
- {
+ if (TREE_THIS_VOLATILE (t))
+ {
local->pure_const_state = IPA_NEITHER;
if (dump_file)
fprintf (dump_file, " Volatile operand is not const/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)
/* Since we have dealt with the locals and params cases above, if we
are CHECKING_WRITE, this cannot be a pure or constant
function. */
- if (checking_write)
+ if (checking_write)
{
local->pure_const_state = IPA_NEITHER;
if (dump_file)
/* Readonly reads are safe. */
if (TREE_READONLY (t) && !TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (t)))
return; /* Read of a constant, do not change the function state. */
- else
+ else
{
if (dump_file)
fprintf (dump_file, " global memory read is not const\n");
/* Check to see if the use (or definition when CHECKING_WRITE is true)
variable T is legal in a function that is either pure or const. */
-static inline void
+static inline void
check_op (funct_state local, tree t, bool checking_write)
{
t = get_base_address (t);
{
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));
}
}
}
-
+
/* The const and pure flags are set by a variety of places in the
compiler (including here). If someone has already set the flags
for the callee, (such as for some of the builtins) we will use
- them, otherwise we will compute our own information.
-
+ them, otherwise we will compute our own information.
+
Const and pure functions have less clobber effects than other
functions so we process these first. Otherwise if it is a call
outside the compilation unit or an indirect call we punt. This
leaves local calls which will be processed by following the call
- graph. */
+ graph. */
if (callee_t)
{
- callee = cgraph_node(callee_t);
- avail = cgraph_function_body_availability (callee);
-
/* 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;
- /* The callee is either unknown (indirect call) or there is just no
- scannable code for it (external call) . We 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 (avail <= AVAIL_OVERWRITABLE || !ipa)
+ {
+ if (dump_file)
+ fprintf (dump_file, " Recursive call can loop.\n");
+ local->looping = true;
+ }
+ /* Either calle 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)
{
if (possibly_throws && flag_non_call_exceptions)
{
}
local->can_throw = true;
}
- if (flags & ECF_CONST)
+ if (flags & ECF_CONST)
{
if (callee_t && DECL_LOOPING_CONST_OR_PURE_P (callee_t))
- local->looping = true;
+ {
+ if (dump_file)
+ fprintf (dump_file, " calls looping pure.\n");
+ local->looping = true;
+ }
}
- else if (flags & ECF_PURE)
+ 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, " calls looping const.\n");
+ 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
+ else
{
if (dump_file)
fprintf (dump_file, " uknown function call is not const/pure\n");
for (i = 0; i < gimple_asm_nclobbers (stmt); i++)
{
tree op = gimple_asm_clobber_op (stmt, i);
- if (simple_cst_equal(TREE_VALUE (op), memory_identifier_string) == 1)
+ if (simple_cst_equal(TREE_VALUE (op), memory_identifier_string) == 1)
{
if (dump_file)
fprintf (dump_file, " memory asm clobber is not const/pure");
funct_state l;
basic_block this_block;
- if (cgraph_function_body_availability (fn) <= AVAIL_OVERWRITABLE)
- {
- if (dump_file)
- fprintf (dump_file, "Function is not available or overwrittable; not analyzing.\n");
- return NULL;
- }
-
l = XCNEW (struct funct_state_d);
l->pure_const_state = IPA_CONST;
l->state_previously_known = IPA_NEITHER;
if (dump_file)
{
- fprintf (dump_file, "\n\n local analysis of %s\n ",
+ fprintf (dump_file, "\n\n local analysis of %s\n ",
cgraph_node_name (fn));
}
-
+
push_cfun (DECL_STRUCT_FUNCTION (decl));
current_function_decl = decl;
-
+
FOR_EACH_BB (this_block)
{
gimple_stmt_iterator gsi;
fprintf (dump_file, " has irreducible loops\n");
l->looping = true;
}
- else
+ else
{
loop_iterator li;
struct loop *loop;
static void
add_new_function (struct cgraph_node *node, void *data ATTRIBUTE_UNUSED)
{
- if (cgraph_function_body_availability (node) <= AVAIL_OVERWRITABLE)
+ if (cgraph_function_body_availability (node) < AVAIL_OVERWRITABLE)
return;
/* There are some shared nodes, in particular the initializers on
static declarations. We do not need to scan them more than once
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;
}
}
\f
-/* Analyze each function in the cgraph to see if it is locally PURE or
- CONST. */
-
-static void
-generate_summary (void)
+static void
+register_hooks (void)
{
- struct cgraph_node *node;
+ static bool init_p = false;
+
+ if (init_p)
+ return;
+
+ init_p = true;
node_removal_hook_holder =
cgraph_add_node_removal_hook (&remove_node_data, NULL);
cgraph_add_node_duplication_hook (&duplicate_node_data, NULL);
function_insertion_hook_holder =
cgraph_add_function_insertion_hook (&add_new_function, NULL);
+}
+
+
+/* Analyze each function in the cgraph to see if it is locally PURE or
+ CONST. */
+
+static void
+generate_summary (void)
+{
+ struct cgraph_node *node;
+
+ register_hooks ();
+
/* There are some shared nodes, in particular the initializers on
static declarations. We do not need to scan them more than once
since all we would be interested in are the addressof
operations. */
visited_nodes = pointer_set_create ();
- /* Process all of the functions.
+ /* Process all of the functions.
+
+ 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. */
- We do NOT process any AVAIL_OVERWRITABLE functions, we cannot
- guarantee that what we learn about the one we see will be true
- for the one that overrides it.
- */
for (node = cgraph_nodes; node; node = node->next)
- if (cgraph_function_body_availability (node) > AVAIL_OVERWRITABLE)
+ if (cgraph_function_body_availability (node) >= AVAIL_OVERWRITABLE)
set_function_state (node, analyze_function (node, true));
pointer_set_destroy (visited_nodes);
visited_nodes = NULL;
}
+
+/* Serialize the ipa info for lto. */
+
+static void
+pure_const_write_summary (cgraph_node_set set,
+ varpool_node_set vset ATTRIBUTE_UNUSED)
+{
+ 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;
+
+ for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
+ {
+ node = csi_node (csi);
+ if (node->analyzed && get_function_state (node) != NULL)
+ count++;
+ }
+
+ lto_output_uleb128_stream (ob->main_stream, count);
+
+ /* Process all of the functions. */
+ for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
+ {
+ node = csi_node (csi);
+ if (node->analyzed && get_function_state (node) != NULL)
+ {
+ struct bitpack_d *bp;
+ funct_state fs;
+ int node_ref;
+ lto_cgraph_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);
+
+ /* 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);
+ }
+ }
+
+ lto_destroy_simple_output_block (ob);
+}
+
+
+/* Deserialize the ipa info for lto. */
+
+static void
+pure_const_read_summary (void)
+{
+ struct lto_file_decl_data **file_data_vec = lto_get_file_decl_data ();
+ struct lto_file_decl_data *file_data;
+ unsigned int j = 0;
+
+ register_hooks ();
+ while ((file_data = file_data_vec[j++]))
+ {
+ const char *data;
+ size_t len;
+ struct lto_input_block *ib
+ = lto_create_simple_input_block (file_data,
+ LTO_section_ipa_pure_const,
+ &data, &len);
+ if (ib)
+ {
+ unsigned int i;
+ unsigned int count = lto_input_uleb128 (ib);
+
+ for (i = 0; i < count; i++)
+ {
+ unsigned int index;
+ struct cgraph_node *node;
+ struct bitpack_d *bp;
+ funct_state fs;
+ lto_cgraph_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);
+ 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);
+ fs->pure_const_state
+ = (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);
+ }
+
+ lto_destroy_simple_input_block (file_data,
+ LTO_section_ipa_pure_const,
+ ib, data, len);
+ }
+ }
+}
+
+
static bool
ignore_edge (struct cgraph_edge *e)
{
if (w_l->looping)
looping = true;
+ 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;
+ }
if (pure_const_state == IPA_NEITHER)
break;
if (count > 1)
looping = true;
-
- for (e = w->callees; e; e = e->next_callee)
+
+ for (e = w->callees; e; e = e->next_callee)
{
struct cgraph_node *y = e->callee;
if (y_l->looping)
looping = true;
}
+ else
+ {
+ int flags = flags_from_decl_or_type (y->decl);
+
+ 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;
+
+ }
}
w_info = (struct ipa_dfs_info *) w->aux;
w = w_info->next_cycle;
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;
+ 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 " : "",
+ cgraph_node_name (w));
+ }
+ cgraph_set_readonly_flag (w, true);
+ cgraph_set_looping_const_or_pure_flag (w, 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;
+ 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 " : "",
+ cgraph_node_name (w));
+ }
+ cgraph_set_pure_flag (w, true);
+ cgraph_set_looping_const_or_pure_flag (w, this_looping);
break;
-
+
default:
break;
}
struct cgraph_edge *e;
funct_state w_l = get_function_state (w);
- if (w_l->can_throw)
+ if (w_l->can_throw
+ || cgraph_function_body_availability (w) == AVAIL_OVERWRITABLE)
can_throw = true;
if (can_throw)
break;
-
- for (e = w->callees; e; e = e->next_callee)
+
+ for (e = w->callees; e; e = e->next_callee)
{
struct cgraph_node *y = e->callee;
{
funct_state y_l = get_function_state (y);
- if (can_throw)
+ if (can_throw)
break;
if (y_l->can_throw && !TREE_NOTHROW (w->decl)
&& e->can_throw_external)
can_throw = true;
}
+ else if (e->can_throw_external && !TREE_NOTHROW (y->decl))
+ can_throw = true;
}
w_info = (struct ipa_dfs_info *) w->aux;
w = w_info->next_cycle;
if (!can_throw && !TREE_NOTHROW (w->decl))
{
struct cgraph_edge *e;
- TREE_NOTHROW (w->decl) = true;
+ cgraph_set_nothrow_flag (w, 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",
+ fprintf (dump_file, "Function found to be nothrow: %s\n",
cgraph_node_name (w));
}
else if (can_throw && !TREE_NOTHROW (w->decl))
free (node->aux);
node->aux = NULL;
}
- if (cgraph_function_body_availability (node) > AVAIL_OVERWRITABLE)
+ if (cgraph_function_body_availability (node) >= AVAIL_OVERWRITABLE)
free (get_function_state (node));
}
-
+
free (order);
VEC_free (funct_state, heap, funct_state_vec);
finish_state ();
0 /* todo_flags_finish */
},
generate_summary, /* generate_summary */
- NULL, /* write_summary */
- NULL, /* read_summary */
- NULL, /* function_read_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, /* TODOs */
NULL, /* function_transform */
NULL /* variable_transform */
};
-/* 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. */
+/* Return true if function should be skipped for local pure const analysis. */
-static unsigned int
-local_pure_const (void)
+static bool
+skip_function_for_local_pure_const (struct cgraph_node *node)
{
- bool changed = false;
- funct_state l;
-
/* 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;
}
-
- l = analyze_function (cgraph_node (current_function_decl), false);
- if (!l)
+ 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 overwrittable; not analyzing.\n");
+ return true;
}
+ return 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_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);
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_readonly_flag (node, true);
+ cgraph_set_looping_const_or_pure_flag (node, l->looping);
+ changed = true;
+ }
if (dump_file)
fprintf (dump_file, "Function found to be %sconst: %s\n",
l->looping ? "looping " : "",
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_looping_const_or_pure_flag (node, 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,
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);
+ cgraph_set_looping_const_or_pure_flag (node, 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 " : "",
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_looping_const_or_pure_flag (node, 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,
{
struct cgraph_edge *e;
- TREE_NOTHROW (current_function_decl) = true;
- for (e = cgraph_node (current_function_decl)->callers;
- e; e = e->next_caller)
+ cgraph_set_nothrow_flag (node, true);
+ for (e = node->callers; e; e = e->next_caller)
e->can_throw_external = false;
changed = true;
if (dump_file)