/* Holder for the const_state. There is one of these per function
decl. */
-struct funct_state_d
+class funct_state_d
{
+public:
+ funct_state_d (): pure_const_state (IPA_NEITHER),
+ state_previously_known (IPA_NEITHER), looping_previously_known (true),
+ looping (true), can_throw (true), can_free (true),
+ malloc_state (STATE_MALLOC_BOTTOM) {}
+
+ funct_state_d (const funct_state_d &s): pure_const_state (s.pure_const_state),
+ state_previously_known (s.state_previously_known),
+ looping_previously_known (s.looping_previously_known),
+ looping (s.looping), can_throw (s.can_throw), can_free (s.can_free),
+ malloc_state (s.malloc_state) {}
+
/* See above. */
enum pure_const_state_e pure_const_state;
/* What user set here; we can be always sure about this. */
enum malloc_state_e malloc_state;
};
-/* State used when we know nothing about function. */
-static struct funct_state_d varying_state
- = { IPA_NEITHER, IPA_NEITHER, true, true, true, true, STATE_MALLOC_BOTTOM };
-
-
typedef struct funct_state_d * funct_state;
/* 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. */
-/* Array, indexed by cgraph node uid, of function states. */
+class funct_state_summary_t: public function_summary <funct_state_d *>
+{
+public:
+ funct_state_summary_t (symbol_table *symtab):
+ function_summary <funct_state_d *> (symtab) {}
+
+ virtual void insert (cgraph_node *, funct_state_d *state);
+ virtual void duplicate (cgraph_node *src_node, cgraph_node *dst_node,
+ funct_state_d *src_data,
+ funct_state_d *dst_data);
+};
-static vec<funct_state> funct_state_vec;
+static funct_state_summary_t *funct_state_summaries = NULL;
static bool gate_pure_const (void);
private:
bool init_p;
-
- /* Holders of ipa cgraph hooks: */
- struct cgraph_node_hook_list *function_insertion_hook_holder;
- struct cgraph_2node_hook_list *node_duplication_hook_holder;
- struct cgraph_node_hook_list *node_removal_hook_holder;
-
}; // class pass_ipa_pure_const
} // anon namespace
true, warned_about, "cold");
}
-/* 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.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.exists ()
- || funct_state_vec.length () <= (unsigned int)node->uid)
- funct_state_vec.safe_grow_cleared (node->uid + 1);
-
- /* If funct_state_vec already contains a funct_state, we have to release
- it before it's going to be ovewritten. */
- if (funct_state_vec[node->uid] != NULL
- && funct_state_vec[node->uid] != &varying_state)
- free (funct_state_vec[node->uid]);
-
- funct_state_vec[node->uid] = s;
-}
-
/* 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. */
return l;
}
-/* Called when new function is inserted to callgraph late. */
-static void
-add_new_function (struct cgraph_node *node, void *data ATTRIBUTE_UNUSED)
+void
+funct_state_summary_t::insert (cgraph_node *node, funct_state_d *state)
{
/* 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. */
if (opt_for_fn (node->decl, flag_ipa_pure_const))
- set_function_state (node, analyze_function (node, true));
-}
-
-/* Called when new clone is inserted to callgraph late. */
-
-static void
-duplicate_node_data (struct cgraph_node *src, struct cgraph_node *dst,
- void *data ATTRIBUTE_UNUSED)
-{
- if (has_function_state (src))
{
- funct_state l = XNEW (struct funct_state_d);
- gcc_assert (!has_function_state (dst));
- memcpy (l, get_function_state (src), sizeof (*l));
- set_function_state (dst, l);
+ funct_state_d *a = analyze_function (node, true);
+ new (state) funct_state_d (*a);
+ free (a);
}
}
/* Called when new clone is inserted to callgraph late. */
-static void
-remove_node_data (struct cgraph_node *node, void *data ATTRIBUTE_UNUSED)
+void
+funct_state_summary_t::duplicate (cgraph_node *, cgraph_node *,
+ funct_state_d *src_data,
+ funct_state_d *dst_data)
{
- if (has_function_state (node))
- set_function_state (node, NULL);
+ new (dst_data) funct_state_d (*src_data);
}
\f
init_p = true;
- node_removal_hook_holder =
- symtab->add_cgraph_removal_hook (&remove_node_data, NULL);
- node_duplication_hook_holder =
- symtab->add_cgraph_duplication_hook (&duplicate_node_data, NULL);
- function_insertion_hook_holder =
- symtab->add_cgraph_insertion_hook (&add_new_function, NULL);
+ funct_state_summaries = new funct_state_summary_t (symtab);
}
FOR_EACH_DEFINED_FUNCTION (node)
if (opt_for_fn (node->decl, flag_ipa_pure_const))
- set_function_state (node, analyze_function (node, true));
+ {
+ funct_state_d *a = analyze_function (node, true);
+ new (funct_state_summaries->get_create (node)) funct_state_d (*a);
+ free (a);
+ }
}
lsei_next_function_in_partition (&lsei))
{
node = lsei_cgraph_node (lsei);
- if (node->definition && has_function_state (node))
+ if (node->definition && funct_state_summaries->exists (node))
count++;
}
lsei_next_function_in_partition (&lsei))
{
node = lsei_cgraph_node (lsei);
- if (node->definition && has_function_state (node))
+ funct_state_d *fs = funct_state_summaries->get (node);
+ if (node->definition && fs != NULL)
{
struct bitpack_d bp;
- funct_state fs;
int node_ref;
lto_symtab_encoder_t encoder;
- fs = get_function_state (node);
-
encoder = ob->decl_state->symtab_node_encoder;
node_ref = lto_symtab_encoder_encode (encoder, node);
streamer_write_uhwi_stream (ob->main_stream, node_ref);
funct_state fs;
lto_symtab_encoder_t encoder;
- fs = XCNEW (struct funct_state_d);
index = streamer_read_uhwi (ib);
encoder = file_data->symtab_node_encoder;
node = dyn_cast<cgraph_node *> (lto_symtab_encoder_deref (encoder,
index));
- set_function_state (node, fs);
+ fs = funct_state_summaries->get_create (node);
/* Note that the flags must be read in the opposite
order in which they were written (the bitflags were
pushed into FLAGS). */
int i;
struct ipa_ref *ref = NULL;
- funct_state w_l = get_function_state (w);
+ funct_state w_l = funct_state_summaries->get_create (w);
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, " Visiting %s state:%s looping %i\n",
w->dump_name (),
}
if (avail > AVAIL_INTERPOSABLE)
{
- funct_state y_l = get_function_state (y);
+ funct_state y_l = funct_state_summaries->get_create (y);
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file,
while (w && !can_free)
{
struct cgraph_edge *e;
- funct_state w_l = get_function_state (w);
+ funct_state w_l = funct_state_summaries->get_create (w);
if (w_l->can_free
|| w->get_availability () == AVAIL_INTERPOSABLE
e->caller);
if (avail > AVAIL_INTERPOSABLE)
- can_free = get_function_state (y)->can_free;
+ can_free = funct_state_summaries->get_create (y)->can_free;
else
can_free = true;
}
w = node;
while (w)
{
- funct_state w_l = get_function_state (w);
+ funct_state w_l = funct_state_summaries->get_create (w);
enum pure_const_state_e this_state = pure_const_state;
bool this_looping = looping;
if (!TREE_NOTHROW (w->decl))
{
- funct_state w_l = get_function_state (w);
+ funct_state w_l = funct_state_summaries->get_create (w);
if (w_l->can_throw
|| w->get_availability () == AVAIL_INTERPOSABLE)
throw. */
if (avail <= AVAIL_INTERPOSABLE
|| (!TREE_NOTHROW (y->decl)
- && (get_function_state (y)->can_throw
+ && (funct_state_summaries->get_create (y)->can_throw
|| (opt_for_fn (y->decl, flag_non_call_exceptions)
&& !e->callee->binds_to_current_def_p (w)))))
can_throw = true;
w = node;
while (w)
{
- funct_state w_l = get_function_state (w);
+ funct_state w_l = funct_state_summaries->get_create (w);
if (!can_throw && !TREE_NOTHROW (w->decl))
{
/* Inline clones share declaration with their offline copies;
cgraph_node *node;
FOR_EACH_FUNCTION (node)
{
- funct_state fs = get_function_state (node);
+ funct_state fs = funct_state_summaries->get_create (node);
malloc_state_e state = fs->malloc_state;
fprintf (dump_file, "%s: %s\n", node->name (), malloc_state_names[state]);
}
FOR_EACH_FUNCTION (node)
{
if (DECL_IS_MALLOC (node->decl))
- if (!has_function_state (node))
+ if (!funct_state_summaries->exists (node))
{
- funct_state l = XCNEW (struct funct_state_d);
- *l = varying_state;
- l->malloc_state = STATE_MALLOC;
- set_function_state (node, l);
+ funct_state fs = funct_state_summaries->get_create (node);
+ fs->malloc_state = STATE_MALLOC;
}
}
cgraph_node *node = order[i];
if (node->alias
|| !node->definition
- || !has_function_state (node))
+ || !funct_state_summaries->exists (node))
continue;
- funct_state l = get_function_state (node);
+ funct_state l = funct_state_summaries->get_create (node);
/* FIXME: add support for indirect-calls. */
if (node->indirect_calls)
for (unsigned j = 0; j < callees.length (); j++)
{
cgraph_node *callee = callees[j];
- if (!has_function_state (callee))
+ if (!funct_state_summaries->exists (node))
{
new_state = STATE_MALLOC_BOTTOM;
break;
}
- malloc_state_e callee_state = get_function_state (callee)->malloc_state;
+ malloc_state_e callee_state
+ = funct_state_summaries->get_create (callee)->malloc_state;
if (new_state < callee_state)
new_state = callee_state;
}
}
FOR_EACH_DEFINED_FUNCTION (node)
- if (has_function_state (node))
+ if (funct_state_summaries->exists (node))
{
- funct_state l = get_function_state (node);
+ funct_state l = funct_state_summaries->get_create (node);
if (!node->alias
&& l->malloc_state == STATE_MALLOC
&& !node->global.inlined_to)
pass_ipa_pure_const::
execute (function *)
{
- struct cgraph_node *node;
bool remove_p;
- symtab->remove_cgraph_insertion_hook (function_insertion_hook_holder);
- symtab->remove_cgraph_duplication_hook (node_duplication_hook_holder);
- symtab->remove_cgraph_removal_hook (node_removal_hook_holder);
-
/* Nothrow makes more function to not lead to return and improve
later analysis. */
propagate_nothrow ();
propagate_malloc ();
remove_p = propagate_pure_const ();
- /* Cleanup. */
- FOR_EACH_FUNCTION (node)
- if (has_function_state (node))
- free (get_function_state (node));
- funct_state_vec.release ();
+ delete funct_state_summaries;
return remove_p ? TODO_remove_functions : 0;
}
0, /* function_transform_todo_flags_start */
NULL, /* function_transform */
NULL), /* variable_transform */
- init_p(false),
- function_insertion_hook_holder(NULL),
- node_duplication_hook_holder(NULL),
- node_removal_hook_holder(NULL)
-{
-}
+ init_p (false) {}
ipa_opt_pass_d *
make_pass_ipa_pure_const (gcc::context *ctxt)
projects / gcc.git / commitdiff