/* This file gathers information about how variables whose scope is
confined to the compilation unit are used.
- There are two categories of information produced by this pass:
-
- 1) The addressable (TREE_ADDRESSABLE) bit and readonly
- (TREE_READONLY) bit associated with these variables is properly set
- based on scanning all of the code withing the compilation unit.
-
- 2) The transitive call site specific clobber effects are computed
+ The transitive call site specific clobber effects are computed
for the variables whose scope is contained within this compilation
unit.
side effects of each call. In later parts of the compiler, these
local and global sets are examined to make the call clobbering less
traumatic, promote some statics to registers, and improve aliasing
- information.
-
- Currently must be run after inlining decisions have been made since
- otherwise, the local sets will not contain information that is
- consistent with post inlined state. The global sets are not prone
- to this problem since they are by definition transitive. */
+ information. */
#include "config.h"
#include "system.h"
#include "timevar.h"
#include "diagnostic.h"
#include "langhooks.h"
+#include "data-streamer.h"
#include "lto-streamer.h"
static void remove_node_data (struct cgraph_node *node,
{
bitmap statics_read;
bitmap statics_written;
-
- /* Set when this function calls another function external to the
- compilation unit or if the function has a asm clobber of memory.
- In general, such calls are modeled as reading and writing all
- variables (both bits on) but sometime there are attributes on the
- called function so we can do better. */
- bool calls_read_all;
- bool calls_write_all;
};
/* Statics that are read and written by some set of functions. The
local ones are based on the loads and stores local to the function.
The global ones are based on the local info as well as the
- transitive closure of the functions that are called. The
- structures are separated to allow the global structures to be
- shared between several functions since every function within a
- strongly connected component will have the same information. This
- sharing saves both time and space in the computation of the vectors
- as well as their translation from decl_uid form to ann_uid
- form. */
+ transitive closure of the functions that are called. */
struct ipa_reference_global_vars_info_d
{
bitmap statics_read;
bitmap statics_written;
+};
+
+/* Information we save about every function after ipa-reference is completed. */
+
+struct ipa_reference_optimization_summary_d
+{
bitmap statics_not_read;
bitmap statics_not_written;
};
typedef struct ipa_reference_local_vars_info_d *ipa_reference_local_vars_info_t;
typedef struct ipa_reference_global_vars_info_d *ipa_reference_global_vars_info_t;
+typedef struct ipa_reference_optimization_summary_d *ipa_reference_optimization_summary_t;
+
struct ipa_reference_vars_info_d
{
- ipa_reference_local_vars_info_t local;
- ipa_reference_global_vars_info_t global;
+ struct ipa_reference_local_vars_info_d local;
+ struct ipa_reference_global_vars_info_d global;
};
typedef struct ipa_reference_vars_info_d *ipa_reference_vars_info_t;
/* This splay tree contains all of the static variables that are
- being considered by the compilation level alias analysis. For
- module_at_a_time compilation, this is the set of static but not
- public variables. Any variables that either have their address
- taken or participate in otherwise unsavory operations are deleted
- from this list. */
-static GTY((param1_is(int), param2_is(tree)))
- splay_tree reference_vars_to_consider;
-
-/* This bitmap is used to knock out the module static variables whose
- addresses have been taken and passed around. */
-static bitmap module_statics_escape;
-
-/* This bitmap is used to knock out the module static variables that
- are not readonly. */
-static bitmap module_statics_written;
+ being considered by the compilation level alias analysis. */
+static splay_tree reference_vars_to_consider;
/* A bit is set for every module static we are considering. This is
ored into the local info when asm code is found that clobbers all
propagation) */
static bitmap_obstack local_info_obstack;
/* Obstack holding global analysis live forever. */
-static bitmap_obstack global_info_obstack;
+static bitmap_obstack optimization_summary_obstack;
/* Holders of ipa cgraph hooks: */
static struct cgraph_2node_hook_list *node_duplication_hook_holder;
static struct cgraph_node_hook_list *node_removal_hook_holder;
-enum initialization_status_t
-{
- UNINITIALIZED,
- RUNNING,
- FINISHED
-};
-
-tree memory_identifier_string;
-
/* Vector where the reference var infos are actually stored. */
DEF_VEC_P (ipa_reference_vars_info_t);
DEF_VEC_ALLOC_P (ipa_reference_vars_info_t, heap);
static VEC (ipa_reference_vars_info_t, heap) *ipa_reference_vars_vector;
+DEF_VEC_P (ipa_reference_optimization_summary_t);
+DEF_VEC_ALLOC_P (ipa_reference_optimization_summary_t, heap);
+static VEC (ipa_reference_optimization_summary_t, heap) *ipa_reference_opt_sum_vector;
/* Return the ipa_reference_vars structure starting from the cgraph NODE. */
static inline ipa_reference_vars_info_t
get_reference_vars_info (struct cgraph_node *node)
{
if (!ipa_reference_vars_vector
- || VEC_length (ipa_reference_vars_info_t, ipa_reference_vars_vector) <= (unsigned int)node->uid)
+ || VEC_length (ipa_reference_vars_info_t,
+ ipa_reference_vars_vector) <= (unsigned int) node->uid)
return NULL;
- return VEC_index (ipa_reference_vars_info_t, ipa_reference_vars_vector, node->uid);
+ return VEC_index (ipa_reference_vars_info_t, ipa_reference_vars_vector,
+ node->uid);
}
/* Return the ipa_reference_vars structure starting from the cgraph NODE. */
-static inline void
-set_reference_vars_info (struct cgraph_node *node, ipa_reference_vars_info_t info)
-{
- if (!ipa_reference_vars_vector
- || VEC_length (ipa_reference_vars_info_t, ipa_reference_vars_vector) <= (unsigned int)node->uid)
- VEC_safe_grow_cleared (ipa_reference_vars_info_t, heap, ipa_reference_vars_vector, node->uid + 1);
- VEC_replace (ipa_reference_vars_info_t, ipa_reference_vars_vector, node->uid, info);
-}
-
-/* Get a bitmap that contains all of the globally referenced static
- variables for function FN. */
-
-static ipa_reference_global_vars_info_t
-get_global_reference_vars_info (struct cgraph_node *fn)
+static inline ipa_reference_optimization_summary_t
+get_reference_optimization_summary (struct cgraph_node *node)
{
- ipa_reference_vars_info_t info = get_reference_vars_info (fn);
-
- if (info)
- return info->global;
- else
- /* This phase was not run. */
+ if (!ipa_reference_opt_sum_vector
+ || (VEC_length (ipa_reference_optimization_summary_t,
+ ipa_reference_opt_sum_vector)
+ <= (unsigned int) node->uid))
return NULL;
+ return VEC_index (ipa_reference_optimization_summary_t, ipa_reference_opt_sum_vector,
+ node->uid);
}
-/* Return a bitmap indexed by VAR_DECL uid for the static variables
- that are read during the execution of the function FN. Returns
- NULL if no data is available. */
-
-bitmap
-ipa_reference_get_read_global (struct cgraph_node *fn)
+/* Return the ipa_reference_vars structure starting from the cgraph NODE. */
+static inline void
+set_reference_vars_info (struct cgraph_node *node,
+ ipa_reference_vars_info_t info)
{
- ipa_reference_global_vars_info_t g = get_global_reference_vars_info (fn);
- if (g)
- return g->statics_read;
- else
- return NULL;
+ if (!ipa_reference_vars_vector
+ || VEC_length (ipa_reference_vars_info_t,
+ ipa_reference_vars_vector) <= (unsigned int) node->uid)
+ VEC_safe_grow_cleared (ipa_reference_vars_info_t, heap,
+ ipa_reference_vars_vector, node->uid + 1);
+ VEC_replace (ipa_reference_vars_info_t, ipa_reference_vars_vector,
+ node->uid, info);
}
-/* Return a bitmap indexed by VAR_DECL uid for the static variables
- that are written during the execution of the function FN. Note
- that variables written may or may not be read during the function
- call. Returns NULL if no data is available. */
-
-bitmap
-ipa_reference_get_written_global (struct cgraph_node *fn)
+/* Return the ipa_reference_vars structure starting from the cgraph NODE. */
+static inline void
+set_reference_optimization_summary (struct cgraph_node *node,
+ ipa_reference_optimization_summary_t info)
{
- ipa_reference_global_vars_info_t g = get_global_reference_vars_info (fn);
- if (g)
- return g->statics_written;
- else
- return NULL;
+ if (!ipa_reference_opt_sum_vector
+ || (VEC_length (ipa_reference_optimization_summary_t,
+ ipa_reference_opt_sum_vector)
+ <= (unsigned int) node->uid))
+ VEC_safe_grow_cleared (ipa_reference_optimization_summary_t,
+ heap, ipa_reference_opt_sum_vector, node->uid + 1);
+ VEC_replace (ipa_reference_optimization_summary_t,
+ ipa_reference_opt_sum_vector, node->uid, info);
}
/* Return a bitmap indexed by_DECL_UID uid for the static variables
bitmap
ipa_reference_get_not_read_global (struct cgraph_node *fn)
{
- ipa_reference_global_vars_info_t g = get_global_reference_vars_info (fn);
- if (g)
- return g->statics_not_read;
+ ipa_reference_optimization_summary_t info;
+
+ info = get_reference_optimization_summary (cgraph_function_node (fn, NULL));
+ if (info)
+ return info->statics_not_read;
+ else if (flags_from_decl_or_type (fn->decl) & ECF_LEAF)
+ return all_module_statics;
else
return NULL;
}
bitmap
ipa_reference_get_not_written_global (struct cgraph_node *fn)
{
- ipa_reference_global_vars_info_t g = get_global_reference_vars_info (fn);
- if (g)
- return g->statics_not_written;
+ ipa_reference_optimization_summary_t info;
+
+ info = get_reference_optimization_summary (fn);
+ if (info)
+ return info->statics_not_written;
+ else if (flags_from_decl_or_type (fn->decl) & ECF_LEAF)
+ return all_module_statics;
else
return NULL;
}
{
int uid = DECL_UID (var);
gcc_assert (TREE_CODE (var) == VAR_DECL);
- if (!bitmap_bit_p (all_module_statics, uid))
- {
- splay_tree_insert (reference_vars_to_consider,
- uid, (splay_tree_value)var);
- bitmap_set_bit (all_module_statics, uid);
- }
+ if (dump_file)
+ splay_tree_insert (reference_vars_to_consider,
+ uid, (splay_tree_value)var);
+ bitmap_set_bit (all_module_statics, uid);
}
/* Return true if the variable T is the right kind of static variable to
static inline bool
is_proper_for_analysis (tree t)
{
+ /* We handle only variables whose address is never taken. */
+ if (TREE_ADDRESSABLE (t))
+ return false;
+
/* If the variable has the "used" attribute, treat it as if it had a
been touched by the devil. */
if (DECL_PRESERVE_P (t))
if (TREE_THIS_VOLATILE (t))
return false;
+ /* We do not need to analyze readonly vars, we already know they do not
+ alias. */
+ if (TREE_READONLY (t))
+ return false;
+
/* We cannot touch decls where the type needs constructing. */
if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (t)))
return false;
/* This is a variable we care about. Check if we have seen it
before, and if not add it the set of variables we care about. */
- if (!bitmap_bit_p (all_module_statics, DECL_UID (t)))
+ if (all_module_statics
+ && !bitmap_bit_p (all_module_statics, DECL_UID (t)))
add_static_var (t);
return true;
}
-/* Lookup the tree node for the static variable that has UID. */
-static tree
-get_static_decl (int index)
-{
- splay_tree_node stn =
- splay_tree_lookup (reference_vars_to_consider, index);
- if (stn)
- return (tree)stn->value;
- return NULL;
-}
-
/* Lookup the tree node for the static variable that has UID and
convert the name to a string for debugging. */
struct cgraph_edge *e;
for (e = x->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 (!y)
+ continue;
/* Only look into nodes we can propagate something. */
- if (cgraph_function_body_availability (e->callee) > AVAIL_OVERWRITABLE)
+ if (avail > AVAIL_OVERWRITABLE
+ || (avail == AVAIL_OVERWRITABLE
+ && (flags_from_decl_or_type (y->decl) & ECF_LEAF)))
{
+ int flags = flags_from_decl_or_type (y->decl);
if (get_reference_vars_info (y))
{
ipa_reference_vars_info_t y_info
= get_reference_vars_info (y);
- ipa_reference_global_vars_info_t y_global = y_info->global;
+ ipa_reference_global_vars_info_t y_global = &y_info->global;
/* Calls in current cycle do not have global computed yet. */
- if (!y_info->global)
+ if (!y_global->statics_read)
+ continue;
+
+ /* If function is declared const, it reads no memory even if it
+ seems so to local analysis. */
+ if (flags & ECF_CONST)
continue;
if (x_global->statics_read
y_global->statics_read);
}
+ /* If function is declared pure, it has no stores even if it
+ seems so to local analysis; If we can not return from here,
+ we can safely ignore the call. */
+ if ((flags & ECF_PURE)
+ || cgraph_edge_cannot_lead_to_return (e))
+ continue;
+
if (x_global->statics_written
!= all_module_statics)
{
init_p = true;
- memory_identifier_string = build_string(7, "memory");
-
- reference_vars_to_consider =
- splay_tree_new_ggc (splay_tree_compare_ints);
+ if (dump_file)
+ reference_vars_to_consider = splay_tree_new (splay_tree_compare_ints, 0, 0);
bitmap_obstack_initialize (&local_info_obstack);
- bitmap_obstack_initialize (&global_info_obstack);
- module_statics_escape = BITMAP_ALLOC (&local_info_obstack);
- module_statics_written = BITMAP_ALLOC (&local_info_obstack);
- all_module_statics = BITMAP_ALLOC (&global_info_obstack);
+ bitmap_obstack_initialize (&optimization_summary_obstack);
+ all_module_statics = BITMAP_ALLOC (&optimization_summary_obstack);
node_removal_hook_holder =
cgraph_add_node_removal_hook (&remove_node_data, NULL);
cgraph_add_node_duplication_hook (&duplicate_node_data, NULL);
}
-/* Check out the rhs of a static or global initialization VNODE to see
- if any of them contain addressof operations. Note that some of
- these variables may not even be referenced in the code in this
- compilation unit but their right hand sides may contain references
- to variables defined within this unit. */
-
-static void
-analyze_variable (struct varpool_node *vnode)
-{
- int i;
- struct ipa_ref *ref;
- for (i = 0; ipa_ref_list_reference_iterate (&vnode->ref_list, i, ref); i++)
- {
- tree var;
- if (ref->refered_type != IPA_REF_VARPOOL)
- continue;
- var = ipa_ref_varpool_node (ref)->decl;
- if (ipa_ref_varpool_node (ref)->externally_visible
- || !ipa_ref_varpool_node (ref)->analyzed
- || !is_proper_for_analysis (var))
- continue;
- switch (ref->use)
- {
- case IPA_REF_LOAD:
- case IPA_REF_STORE:
- gcc_unreachable ();
- break;
- case IPA_REF_ADDR:
- bitmap_set_bit (module_statics_escape, DECL_UID (var));
- break;
- }
- }
-}
-
/* Set up the persistent info for FN. */
{
ipa_reference_vars_info_t info
= XCNEW (struct ipa_reference_vars_info_d);
- ipa_reference_local_vars_info_t l
- = XCNEW (struct ipa_reference_local_vars_info_d);
/* Add the info to the tree's annotation. */
set_reference_vars_info (fn, info);
- info->local = l;
- l->statics_read = BITMAP_ALLOC (&local_info_obstack);
- l->statics_written = BITMAP_ALLOC (&local_info_obstack);
+ info->local.statics_read = BITMAP_ALLOC (&local_info_obstack);
+ info->local.statics_written = BITMAP_ALLOC (&local_info_obstack);
- return l;
+ return &info->local;
}
struct ipa_ref *ref;
int i;
tree var;
- struct cgraph_edge *ie;
local = init_function_info (fn);
- /* Process indirect calls. All direct calles are handled at propagation
- time. */
- for (ie = fn->indirect_calls; ie; ie = ie->next_callee)
- if (!(ie->indirect_info->ecf_flags & ECF_CONST))
- {
- local->calls_read_all = true;
- if (!(ie->indirect_info->ecf_flags & ECF_PURE)
- && ((ie->indirect_info->ecf_flags & (ECF_NOTHROW | ECF_NORETURN))
- != (ECF_NOTHROW | ECF_NORETURN)))
- local->calls_write_all = true;
- }
for (i = 0; ipa_ref_list_reference_iterate (&fn->ref_list, i, ref); i++)
{
if (ref->refered_type != IPA_REF_VARPOOL)
bitmap_set_bit (local->statics_read, DECL_UID (var));
break;
case IPA_REF_STORE:
+ if (ipa_ref_cannot_lead_to_return (ref))
+ break;
bitmap_set_bit (local->statics_written, DECL_UID (var));
- bitmap_set_bit (module_statics_written, DECL_UID (var));
break;
case IPA_REF_ADDR:
- bitmap_set_bit (module_statics_escape, DECL_UID (var));
+ gcc_unreachable ();
break;
}
}
- if ((flags_from_decl_or_type (fn->decl) & (ECF_NOTHROW | ECF_NORETURN))
- == (ECF_NOTHROW | ECF_NORETURN))
- {
- local->calls_write_all = false;
- bitmap_clear (local->statics_written);
- }
-
- /* Free bitmaps of direct references if we can not use them anyway. */
- if (local->calls_write_all)
- BITMAP_FREE (local->statics_written);
- if (local->calls_read_all)
- BITMAP_FREE (local->statics_read);
-}
-
-/* Remove local data associated with function FN. */
-static void
-clean_function_local_data (struct cgraph_node *fn)
-{
- ipa_reference_vars_info_t info = get_reference_vars_info (fn);
- ipa_reference_local_vars_info_t l = info->local;
- if (l)
- {
- if (l->statics_read
- && l->statics_read != all_module_statics)
- BITMAP_FREE (l->statics_read);
- if (l->statics_written
- &&l->statics_written != all_module_statics)
- BITMAP_FREE (l->statics_written);
- free (l);
- info->local = NULL;
- }
-}
-
-/* Remove all data associated with function FN. */
-
-static void
-clean_function (struct cgraph_node *fn)
-{
- ipa_reference_vars_info_t info = get_reference_vars_info (fn);
- ipa_reference_global_vars_info_t g = info->global;
-
- clean_function_local_data (fn);
- if (g)
- {
- if (g->statics_read
- && g->statics_read != all_module_statics)
- BITMAP_FREE (g->statics_read);
-
- if (g->statics_written
- && g->statics_written != all_module_statics)
- BITMAP_FREE (g->statics_written);
-
- if (g->statics_not_read
- && g->statics_not_read != all_module_statics)
- BITMAP_FREE (g->statics_not_read);
-
- if (g->statics_not_written
- && g->statics_not_written != all_module_statics)
- BITMAP_FREE (g->statics_not_written);
- free (g);
- info->global = NULL;
- }
-
- free (get_reference_vars_info (fn));
- set_reference_vars_info (fn, NULL);
+ if (cgraph_node_cannot_return (fn))
+ bitmap_clear (local->statics_written);
}
static bitmap
return NULL;
if (src == all_module_statics)
return all_module_statics;
- dst = BITMAP_ALLOC (&global_info_obstack);
+ dst = BITMAP_ALLOC (&optimization_summary_obstack);
bitmap_copy (dst, src);
return dst;
}
duplicate_node_data (struct cgraph_node *src, struct cgraph_node *dst,
void *data ATTRIBUTE_UNUSED)
{
- ipa_reference_global_vars_info_t ginfo;
- ipa_reference_global_vars_info_t dst_ginfo;
+ ipa_reference_optimization_summary_t ginfo;
+ ipa_reference_optimization_summary_t dst_ginfo;
- ginfo = get_global_reference_vars_info (src);
+ ginfo = get_reference_optimization_summary (src);
if (!ginfo)
return;
- init_function_info (dst);
- if (ginfo)
- {
- get_reference_vars_info (dst)->global = XCNEW (struct ipa_reference_global_vars_info_d);
- dst_ginfo = get_global_reference_vars_info (dst);
- dst_ginfo->statics_read = copy_global_bitmap (ginfo->statics_read);
- dst_ginfo->statics_written = copy_global_bitmap (ginfo->statics_written);
- dst_ginfo->statics_not_read = copy_global_bitmap (ginfo->statics_not_read);
- dst_ginfo->statics_not_written = copy_global_bitmap (ginfo->statics_not_written);
- }
+ dst_ginfo = XCNEW (struct ipa_reference_optimization_summary_d);
+ set_reference_optimization_summary (dst, dst_ginfo);
+ dst_ginfo->statics_not_read = copy_global_bitmap (ginfo->statics_not_read);
+ dst_ginfo->statics_not_written = copy_global_bitmap (ginfo->statics_not_written);
}
/* Called when node is removed. */
static void
remove_node_data (struct cgraph_node *node, void *data ATTRIBUTE_UNUSED)
{
- if (get_reference_vars_info (node))
- clean_function (node);
+ ipa_reference_optimization_summary_t ginfo;
+ ginfo = get_reference_optimization_summary (node);
+ if (ginfo)
+ {
+ if (ginfo->statics_not_read
+ && ginfo->statics_not_read != all_module_statics)
+ BITMAP_FREE (ginfo->statics_not_read);
+
+ if (ginfo->statics_not_written
+ && ginfo->statics_not_written != all_module_statics)
+ BITMAP_FREE (ginfo->statics_not_written);
+ free (ginfo);
+ set_reference_optimization_summary (node, NULL);
+ }
}
/* Analyze each function in the cgraph to see which global or statics
generate_summary (void)
{
struct cgraph_node *node;
- struct varpool_node *vnode;
unsigned int index;
bitmap_iterator bi;
- bitmap module_statics_readonly;
bitmap bm_temp;
ipa_init ();
- module_statics_readonly = BITMAP_ALLOC (&local_info_obstack);
bm_temp = BITMAP_ALLOC (&local_info_obstack);
- /* Process all of the variables first. */
- FOR_EACH_STATIC_INITIALIZER (vnode)
- analyze_variable (vnode);
-
/* Process all of the functions next. */
for (node = cgraph_nodes; node; node = node->next)
if (node->analyzed)
analyze_function (node);
- /* Prune out the variables that were found to behave badly
- (i.e. have their address taken). */
- EXECUTE_IF_SET_IN_BITMAP (module_statics_escape, 0, index, bi)
- {
- splay_tree_remove (reference_vars_to_consider, index);
- }
-
- bitmap_and_compl_into (all_module_statics,
- module_statics_escape);
-
- bitmap_and_compl (module_statics_readonly, all_module_statics,
- module_statics_written);
-
- /* If the address is not taken, we can unset the addressable bit
- on this variable. */
- EXECUTE_IF_SET_IN_BITMAP (all_module_statics, 0, index, bi)
- {
- tree var = get_static_decl (index);
- TREE_ADDRESSABLE (var) = 0;
- if (dump_file)
- fprintf (dump_file, "Not TREE_ADDRESSABLE var %s\n",
- get_static_name (index));
- }
-
- /* If the variable is never written, we can set the TREE_READONLY
- flag. Additionally if it has a DECL_INITIAL that is made up of
- constants we can treat the entire global as a constant. */
-
- bitmap_and_compl (module_statics_readonly, all_module_statics,
- module_statics_written);
- EXECUTE_IF_SET_IN_BITMAP (module_statics_readonly, 0, index, bi)
- {
- tree var = get_static_decl (index);
-
- /* Ignore variables in named sections - changing TREE_READONLY
- changes the section flags, potentially causing conflicts with
- other variables in the same named section. */
- if (DECL_SECTION_NAME (var) == NULL_TREE)
- {
- TREE_READONLY (var) = 1;
- if (dump_file)
- fprintf (dump_file, "read-only var %s\n",
- get_static_name (index));
- }
- }
-
- BITMAP_FREE(module_statics_escape);
- BITMAP_FREE(module_statics_written);
- module_statics_escape = NULL;
- module_statics_written = NULL;
-
if (dump_file)
EXECUTE_IF_SET_IN_BITMAP (all_module_statics, 0, index, bi)
{
get_static_name (index));
}
- for (node = cgraph_nodes; node; node = node->next)
- if (cgraph_function_body_availability (node) >= AVAIL_OVERWRITABLE)
- {
- ipa_reference_local_vars_info_t l;
- l = get_reference_vars_info (node)->local;
-
- /* Any variables that are not in all_module_statics are
- removed from the local maps. This will include all of the
- variables that were found to escape in the function
- scanning. */
- if (l->statics_read)
- bitmap_and_into (l->statics_read,
- all_module_statics);
- if (l->statics_written)
- bitmap_and_into (l->statics_written,
- all_module_statics);
- }
-
- BITMAP_FREE(module_statics_readonly);
BITMAP_FREE(bm_temp);
if (dump_file)
unsigned int index;
bitmap_iterator bi;
- l = get_reference_vars_info (node)->local;
+ l = &get_reference_vars_info (node)->local;
fprintf (dump_file,
"\nFunction name:%s/%i:",
cgraph_node_name (node), node->uid);
fprintf(dump_file, "%s ",
get_static_name (index));
}
- if (l->calls_read_all)
- fprintf (dump_file, "\n calls read all: ");
- if (l->calls_write_all)
- fprintf (dump_file, "\n calls read all: ");
}
}
\f
-/* Set READ_ALL/WRITE_ALL based on DECL flags. */
+/* Set READ_ALL/WRITE_ALL based on decl flags of NODE. */
+
static void
-read_write_all_from_decl (tree decl, bool * read_all, bool * write_all)
+read_write_all_from_decl (struct cgraph_node *node, bool * read_all,
+ bool * write_all)
{
+ tree decl = node->decl;
int flags = flags_from_decl_or_type (decl);
- if (flags & ECF_CONST)
+ if ((flags & ECF_LEAF)
+ && cgraph_function_body_availability (node) <= AVAIL_OVERWRITABLE)
+ ;
+ else if (flags & ECF_CONST)
;
- else if (flags & ECF_PURE)
- *read_all = true;
+ else if ((flags & ECF_PURE)
+ || cgraph_node_cannot_return (node))
+ {
+ *read_all = true;
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ fprintf (dump_file, " %s/%i -> read all\n",
+ cgraph_node_name (node), node->uid);
+ }
else
{
/* TODO: To be able to produce sane results, we should also handle
- common builtins, in particular throw.
- Indirect calls hsould be only counted and as inliner is replacing them
- by direct calls, we can conclude if any indirect calls are left in body */
+ common builtins, in particular throw. */
*read_all = true;
- /* When function does not reutrn, it is safe to ignore anythign it writes
- to, because the effect will never happen. */
- if ((flags & (ECF_NOTHROW | ECF_NORETURN))
- != (ECF_NOTHROW | ECF_NORETURN))
- *write_all = true;
+ *write_all = true;
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ fprintf (dump_file, " %s/%i -> read all, write all\n",
+ cgraph_node_name (node), node->uid);
}
}
/* Produce the global information by preforming a transitive closure
- on the local information that was produced by ipa_analyze_function
- and ipa_analyze_variable. */
+ on the local information that was produced by ipa_analyze_function */
static unsigned int
propagate (void)
struct cgraph_node *w;
struct cgraph_node **order =
XCNEWVEC (struct cgraph_node *, cgraph_n_nodes);
- int order_pos = ipa_utils_reduced_inorder (order, false, true, NULL);
+ int order_pos;
int i;
if (dump_file)
dump_cgraph (dump_file);
+ ipa_discover_readonly_nonaddressable_vars ();
generate_summary ();
/* Propagate the local information thru 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. */
- order_pos = ipa_utils_reduced_inorder (order, true, true, NULL);
+ order_pos = ipa_reduced_postorder (order, true, true, NULL);
if (dump_file)
- ipa_utils_print_order(dump_file, "reduced", order, order_pos);
+ ipa_print_order (dump_file, "reduced", order, order_pos);
for (i = 0; i < order_pos; i++ )
{
ipa_reference_vars_info_t node_info;
- ipa_reference_global_vars_info_t node_g =
- XCNEW (struct ipa_reference_global_vars_info_d);
+ ipa_reference_global_vars_info_t node_g;
ipa_reference_local_vars_info_t node_l;
- struct cgraph_edge *e;
+ struct cgraph_edge *e, *ie;
bool read_all;
bool write_all;
struct ipa_dfs_info * w_info;
node = order[i];
+ if (node->alias)
+ continue;
node_info = get_reference_vars_info (node);
- if (!node_info)
- {
- dump_cgraph_node (stderr, node);
- dump_cgraph (stderr);
- gcc_unreachable ();
- }
+ gcc_assert (node_info);
- gcc_assert (!node_info->global);
- node_l = node_info->local;
- read_all = node_l->calls_read_all;
- write_all = node_l->calls_write_all;
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ fprintf (dump_file, "Starting cycle with %s/%i\n",
+ cgraph_node_name (node), node->uid);
- /* When function is overwrittable, we can not assume anything. */
+ node_l = &node_info->local;
+ node_g = &node_info->global;
+
+ read_all = false;
+ write_all = false;
+
+ /* When function is overwritable, we can not assume anything. */
if (cgraph_function_body_availability (node) <= AVAIL_OVERWRITABLE)
- read_write_all_from_decl (node->decl, &read_all, &write_all);
+ read_write_all_from_decl (node, &read_all, &write_all);
for (e = node->callees; e; e = e->next_callee)
- if (cgraph_function_body_availability (e->callee) <= AVAIL_OVERWRITABLE)
- read_write_all_from_decl (e->callee->decl, &read_all, &write_all);
+ {
+ enum availability avail;
+ struct cgraph_node *callee = cgraph_function_node (e->callee, &avail);
+ if (!callee || avail <= AVAIL_OVERWRITABLE)
+ read_write_all_from_decl (callee, &read_all, &write_all);
+ }
+
+ for (ie = node->indirect_calls; ie; ie = ie->next_callee)
+ if (!(ie->indirect_info->ecf_flags & ECF_CONST))
+ {
+ read_all = true;
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ fprintf (dump_file, " indirect call -> read all\n");
+ if (!cgraph_edge_cannot_lead_to_return (ie)
+ && !(ie->indirect_info->ecf_flags & ECF_PURE))
+ {
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ fprintf (dump_file, " indirect call -> write all\n");
+ write_all = true;
+ }
+ }
- /* If any node in a cycle is calls_read_all or calls_write_all
+ /* If any node in a cycle is read_all or write_all
they all are. */
w_info = (struct ipa_dfs_info *) node->aux;
w = w_info->next_cycle;
- while (w)
+ while (w && (!read_all || !write_all))
{
- ipa_reference_local_vars_info_t w_l =
- get_reference_vars_info (w)->local;
-
- /* When function is overwrittable, we can not assume anything. */
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ fprintf (dump_file, " Visiting %s/%i\n",
+ cgraph_node_name (w), w->uid);
+ /* When function is overwritable, we can not assume anything. */
if (cgraph_function_body_availability (w) <= AVAIL_OVERWRITABLE)
- read_write_all_from_decl (w->decl, &read_all, &write_all);
+ read_write_all_from_decl (w, &read_all, &write_all);
for (e = w->callees; e; e = e->next_callee)
- if (cgraph_function_body_availability (e->callee) <= AVAIL_OVERWRITABLE)
- read_write_all_from_decl (e->callee->decl, &read_all, &write_all);
+ {
+ enum availability avail;
+ struct cgraph_node *callee = cgraph_function_node (e->callee, &avail);
+
+ if (avail <= AVAIL_OVERWRITABLE)
+ read_write_all_from_decl (callee, &read_all, &write_all);
+ }
- read_all |= w_l->calls_read_all;
- write_all |= w_l->calls_write_all;
+ for (ie = w->indirect_calls; ie; ie = ie->next_callee)
+ if (!(ie->indirect_info->ecf_flags & ECF_CONST))
+ {
+ read_all = true;
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ fprintf (dump_file, " indirect call -> read all\n");
+ if (!cgraph_edge_cannot_lead_to_return (ie)
+ && !(ie->indirect_info->ecf_flags & ECF_PURE))
+ {
+ write_all = true;
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ fprintf (dump_file, " indirect call -> write all\n");
+ }
+ }
w_info = (struct ipa_dfs_info *) w->aux;
w = w_info->next_cycle;
node_g->statics_read = all_module_statics;
else
{
- node_g->statics_read = BITMAP_ALLOC (&global_info_obstack);
+ node_g->statics_read = BITMAP_ALLOC (&local_info_obstack);
bitmap_copy (node_g->statics_read,
node_l->statics_read);
}
node_g->statics_written = all_module_statics;
else
{
- node_g->statics_written = BITMAP_ALLOC (&global_info_obstack);
+ node_g->statics_written = BITMAP_ALLOC (&local_info_obstack);
bitmap_copy (node_g->statics_written,
node_l->statics_written);
}
propagate_bits (node_g, node);
w_info = (struct ipa_dfs_info *) node->aux;
w = w_info->next_cycle;
- while (w)
+ while (w && (!read_all || !write_all))
{
ipa_reference_vars_info_t w_ri =
get_reference_vars_info (w);
- ipa_reference_local_vars_info_t w_l = w_ri->local;
+ ipa_reference_local_vars_info_t w_l = &w_ri->local;
+ int flags = flags_from_decl_or_type (w->decl);
/* These global bitmaps are initialized from the local info
of all of the nodes in the region. However there is no
need to do any work if the bitmaps were set to
all_module_statics. */
- if (!read_all)
+ if (!read_all && !(flags & ECF_CONST))
bitmap_ior_into (node_g->statics_read,
w_l->statics_read);
- if (!write_all)
+ if (!write_all
+ && !(flags & ECF_PURE)
+ && !cgraph_node_cannot_return (w))
bitmap_ior_into (node_g->statics_written,
w_l->statics_written);
propagate_bits (node_g, w);
}
/* All nodes within a cycle have the same global info bitmaps. */
- node_info->global = node_g;
+ node_info->global = *node_g;
w_info = (struct ipa_dfs_info *) node->aux;
w = w_info->next_cycle;
while (w)
ipa_reference_vars_info_t w_ri =
get_reference_vars_info (w);
- gcc_assert (!w_ri->global);
- w_ri->global = XCNEW (struct ipa_reference_global_vars_info_d);
- w_ri->global->statics_read = copy_global_bitmap (node_g->statics_read);
- w_ri->global->statics_written = copy_global_bitmap (node_g->statics_written);
+ w_ri->global = *node_g;
w_info = (struct ipa_dfs_info *) w->aux;
w = w_info->next_cycle;
struct ipa_dfs_info * w_info;
node = order[i];
+ if (node->alias)
+ continue;
node_info = get_reference_vars_info (node);
- node_g = node_info->global;
- node_l = node_info->local;
+ node_g = &node_info->global;
+ node_l = &node_info->local;
fprintf (dump_file,
"\nFunction name:%s/%i:",
cgraph_node_name (node), node->uid);
{
ipa_reference_vars_info_t w_ri =
get_reference_vars_info (w);
- ipa_reference_local_vars_info_t w_l = w_ri->local;
+ ipa_reference_local_vars_info_t w_l = &w_ri->local;
fprintf (dump_file, "\n next cycle: %s/%i ",
cgraph_node_name (w), w->uid);
fprintf (dump_file, "\n locals read: ");
}
/* Cleanup. */
- for (i = 0; i < order_pos; i++ )
+ for (node = cgraph_nodes; node; node = node->next)
{
ipa_reference_vars_info_t node_info;
ipa_reference_global_vars_info_t node_g;
- node = order[i];
+ ipa_reference_optimization_summary_t opt;
+
+ if (!node->analyzed || node->alias)
+ continue;
+
node_info = get_reference_vars_info (node);
- node_g = node_info->global;
-
- /* Create the complimentary sets. These are more useful for
- certain apis. */
- node_g->statics_not_read = BITMAP_ALLOC (&global_info_obstack);
- node_g->statics_not_written = BITMAP_ALLOC (&global_info_obstack);
-
- if (node_g->statics_read != all_module_statics)
- bitmap_and_compl (node_g->statics_not_read,
- all_module_statics,
- node_g->statics_read);
-
- if (node_g->statics_written
- != all_module_statics)
- bitmap_and_compl (node_g->statics_not_written,
- all_module_statics,
- node_g->statics_written);
+ if (cgraph_function_body_availability (node) > AVAIL_OVERWRITABLE
+ || (flags_from_decl_or_type (node->decl) & ECF_LEAF))
+ {
+ node_g = &node_info->global;
+
+ opt = XCNEW (struct ipa_reference_optimization_summary_d);
+ set_reference_optimization_summary (node, opt);
+
+ /* Create the complimentary sets. */
+
+ if (bitmap_empty_p (node_g->statics_read))
+ opt->statics_not_read = all_module_statics;
+ else
+ {
+ opt->statics_not_read
+ = BITMAP_ALLOC (&optimization_summary_obstack);
+ if (node_g->statics_read != all_module_statics)
+ bitmap_and_compl (opt->statics_not_read,
+ all_module_statics,
+ node_g->statics_read);
+ }
+
+ if (bitmap_empty_p (node_g->statics_written))
+ opt->statics_not_written = all_module_statics;
+ else
+ {
+ opt->statics_not_written
+ = BITMAP_ALLOC (&optimization_summary_obstack);
+ if (node_g->statics_written != all_module_statics)
+ bitmap_and_compl (opt->statics_not_written,
+ all_module_statics,
+ node_g->statics_written);
+ }
+ }
+ free (node_info);
}
+ ipa_free_postorder_info ();
free (order);
- for (node = cgraph_nodes; node; node = node->next)
+ bitmap_obstack_release (&local_info_obstack);
+ VEC_free (ipa_reference_vars_info_t, heap, ipa_reference_vars_vector);
+ ipa_reference_vars_vector = NULL;
+ if (dump_file)
+ splay_tree_delete (reference_vars_to_consider);
+ reference_vars_to_consider = NULL;
+ return 0;
+}
+
+/* Return true if we need to write summary of NODE. */
+
+static bool
+write_node_summary_p (struct cgraph_node *node,
+ cgraph_node_set set,
+ varpool_node_set vset,
+ bitmap ltrans_statics)
+{
+ ipa_reference_optimization_summary_t info;
+
+ /* See if we have (non-empty) info. */
+ if (!node->analyzed || node->global.inlined_to)
+ return false;
+ info = get_reference_optimization_summary (node);
+ if (!info || (bitmap_empty_p (info->statics_not_read)
+ && bitmap_empty_p (info->statics_not_written)))
+ return false;
+
+ /* See if we want to encode it.
+ Encode also referenced functions since constant folding might turn it into
+ a direct call.
+
+ In future we might also want to include summaries of functions references
+ by initializers of constant variables references in current unit. */
+ if (!reachable_from_this_partition_p (node, set)
+ && !referenced_from_this_partition_p (&node->ref_list, set, vset))
+ return false;
+
+ /* See if the info has non-empty intersections with vars we want to encode. */
+ if (!bitmap_intersect_p (info->statics_not_read, ltrans_statics)
+ && !bitmap_intersect_p (info->statics_not_written, ltrans_statics))
+ return false;
+ return true;
+}
+
+/* Stream out BITS<RANS_STATICS as list of decls to OB.
+ LTRANS_STATICS_BITCOUNT specify number of bits in LTRANS_STATICS
+ or -1. When it is positive, just output -1 when
+ BITS<RANS_STATICS == BITS<RANS_STATICS. */
+
+static void
+stream_out_bitmap (struct lto_simple_output_block *ob,
+ bitmap bits, bitmap ltrans_statics,
+ int ltrans_statics_bitcount)
+{
+ int count = 0;
+ unsigned int index;
+ bitmap_iterator bi;
+ if (bits == all_module_statics)
{
- ipa_reference_vars_info_t node_info;
- node_info = get_reference_vars_info (node);
- /* Get rid of the aux information. */
+ streamer_write_hwi_stream (ob->main_stream, -1);
+ return;
+ }
+ EXECUTE_IF_AND_IN_BITMAP (bits, ltrans_statics, 0, index, bi)
+ count ++;
+ if (count == ltrans_statics_bitcount)
+ {
+ streamer_write_hwi_stream (ob->main_stream, -1);
+ return;
+ }
+ streamer_write_hwi_stream (ob->main_stream, count);
+ if (!count)
+ return;
+ EXECUTE_IF_AND_IN_BITMAP (bits, ltrans_statics, 0, index, bi)
+ {
+ tree decl = (tree)splay_tree_lookup (reference_vars_to_consider, index)->value;
+ lto_output_var_decl_index(ob->decl_state, ob->main_stream, decl);
+ }
+}
+
+/* Serialize the ipa info for lto. */
- if (node->aux)
+static void
+ipa_reference_write_optimization_summary (cgraph_node_set set,
+ varpool_node_set vset)
+{
+ struct cgraph_node *node;
+ struct lto_simple_output_block *ob
+ = lto_create_simple_output_block (LTO_section_ipa_reference);
+ unsigned int count = 0;
+ int ltrans_statics_bitcount = 0;
+ lto_cgraph_encoder_t encoder = ob->decl_state->cgraph_node_encoder;
+ lto_varpool_encoder_t varpool_encoder = ob->decl_state->varpool_node_encoder;
+ bitmap ltrans_statics = BITMAP_ALLOC (NULL);
+ int i;
+
+ reference_vars_to_consider = splay_tree_new (splay_tree_compare_ints, 0, 0);
+
+ /* See what variables we are interested in. */
+ for (i = 0; i < lto_varpool_encoder_size (varpool_encoder); i++)
+ {
+ struct varpool_node *vnode = lto_varpool_encoder_deref (varpool_encoder, i);
+ if (!vnode->externally_visible
+ && vnode->analyzed
+ && bitmap_bit_p (all_module_statics, DECL_UID (vnode->decl))
+ && referenced_from_this_partition_p (&vnode->ref_list, set, vset))
{
- free (node->aux);
- node->aux = NULL;
+ tree decl = vnode->decl;
+ bitmap_set_bit (ltrans_statics, DECL_UID (decl));
+ splay_tree_insert (reference_vars_to_consider,
+ DECL_UID (decl), (splay_tree_value)decl);
+ ltrans_statics_bitcount ++;
}
-
- if (cgraph_function_body_availability (node) == AVAIL_OVERWRITABLE)
- clean_function (node);
- else if (node_info)
- clean_function_local_data (node);
}
- bitmap_obstack_release (&local_info_obstack);
- return 0;
+
+
+ if (ltrans_statics_bitcount)
+ for (i = 0; i < lto_cgraph_encoder_size (encoder); i++)
+ if (write_node_summary_p (lto_cgraph_encoder_deref (encoder, i),
+ set, vset, ltrans_statics))
+ count++;
+
+ streamer_write_uhwi_stream (ob->main_stream, count);
+ if (count)
+ stream_out_bitmap (ob, ltrans_statics, ltrans_statics,
+ -1);
+
+ /* Process all of the functions. */
+ if (ltrans_statics_bitcount)
+ for (i = 0; i < lto_cgraph_encoder_size (encoder); i++)
+ {
+ node = lto_cgraph_encoder_deref (encoder, i);
+ if (write_node_summary_p (node, set, vset, ltrans_statics))
+ {
+ ipa_reference_optimization_summary_t info;
+ int node_ref;
+
+ info = get_reference_optimization_summary (node);
+ node_ref = lto_cgraph_encoder_encode (encoder, node);
+ streamer_write_uhwi_stream (ob->main_stream, node_ref);
+
+ stream_out_bitmap (ob, info->statics_not_read, ltrans_statics,
+ ltrans_statics_bitcount);
+ stream_out_bitmap (ob, info->statics_not_written, ltrans_statics,
+ ltrans_statics_bitcount);
+ }
+ }
+ BITMAP_FREE (ltrans_statics);
+ lto_destroy_simple_output_block (ob);
+ splay_tree_delete (reference_vars_to_consider);
}
+/* Deserialize the ipa info for lto. */
+
+static void
+ipa_reference_read_optimization_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;
+ bitmap_obstack_initialize (&optimization_summary_obstack);
+
+ node_removal_hook_holder =
+ cgraph_add_node_removal_hook (&remove_node_data, NULL);
+ node_duplication_hook_holder =
+ cgraph_add_node_duplication_hook (&duplicate_node_data, NULL);
+ all_module_statics = BITMAP_ALLOC (&optimization_summary_obstack);
+
+ 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_reference,
+ &data, &len);
+ if (ib)
+ {
+ unsigned int i;
+ unsigned int f_count = streamer_read_uhwi (ib);
+ int b_count;
+ if (!f_count)
+ continue;
+ b_count = streamer_read_hwi (ib);
+ if (dump_file)
+ fprintf (dump_file, "all module statics:");
+ for (i = 0; i < (unsigned int)b_count; i++)
+ {
+ unsigned int var_index = streamer_read_uhwi (ib);
+ tree v_decl = lto_file_decl_data_get_var_decl (file_data,
+ var_index);
+ bitmap_set_bit (all_module_statics, DECL_UID (v_decl));
+ if (dump_file)
+ fprintf (dump_file, " %s",
+ lang_hooks.decl_printable_name (v_decl, 2));
+ }
+
+ for (i = 0; i < f_count; i++)
+ {
+ unsigned int j, index;
+ struct cgraph_node *node;
+ ipa_reference_optimization_summary_t info;
+ int v_count;
+ lto_cgraph_encoder_t encoder;
+
+ index = streamer_read_uhwi (ib);
+ encoder = file_data->cgraph_node_encoder;
+ node = lto_cgraph_encoder_deref (encoder, index);
+ info = XCNEW (struct ipa_reference_optimization_summary_d);
+ set_reference_optimization_summary (node, info);
+ info->statics_not_read = BITMAP_ALLOC (&optimization_summary_obstack);
+ info->statics_not_written = BITMAP_ALLOC (&optimization_summary_obstack);
+ if (dump_file)
+ fprintf (dump_file,
+ "\nFunction name:%s/%i:\n static not read:",
+ cgraph_node_name (node), node->uid);
+
+ /* Set the statics not read. */
+ v_count = streamer_read_hwi (ib);
+ if (v_count == -1)
+ {
+ info->statics_not_read = all_module_statics;
+ if (dump_file)
+ fprintf (dump_file, " all module statics");
+ }
+ else
+ for (j = 0; j < (unsigned int)v_count; j++)
+ {
+ unsigned int var_index = streamer_read_uhwi (ib);
+ tree v_decl = lto_file_decl_data_get_var_decl (file_data,
+ var_index);
+ bitmap_set_bit (info->statics_not_read, DECL_UID (v_decl));
+ if (dump_file)
+ fprintf (dump_file, " %s",
+ lang_hooks.decl_printable_name (v_decl, 2));
+ }
+
+ if (dump_file)
+ fprintf (dump_file,
+ "\n static not written:");
+ /* Set the statics not written. */
+ v_count = streamer_read_hwi (ib);
+ if (v_count == -1)
+ {
+ info->statics_not_written = all_module_statics;
+ if (dump_file)
+ fprintf (dump_file, " all module statics");
+ }
+ else
+ for (j = 0; j < (unsigned int)v_count; j++)
+ {
+ unsigned int var_index = streamer_read_uhwi (ib);
+ tree v_decl = lto_file_decl_data_get_var_decl (file_data,
+ var_index);
+ bitmap_set_bit (info->statics_not_written, DECL_UID (v_decl));
+ if (dump_file)
+ fprintf (dump_file, " %s",
+ lang_hooks.decl_printable_name (v_decl, 2));
+ }
+ if (dump_file)
+ fprintf (dump_file, "\n");
+ }
+
+ lto_destroy_simple_input_block (file_data,
+ LTO_section_ipa_reference,
+ ib, data, len);
+ }
+ else
+ /* Fatal error here. We do not want to support compiling ltrans units with
+ different version of compiler or different flags than the WPA unit, so
+ this should never happen. */
+ fatal_error ("ipa reference summary is missing in ltrans unit");
+ }
+}
static bool
gate_reference (void)
{
return (flag_ipa_reference
/* Don't bother doing anything if the program has errors. */
- && !(errorcount || sorrycount));
+ && !seen_error ());
}
struct ipa_opt_pass_d pass_ipa_reference =
NULL, /* generate_summary */
NULL, /* write_summary */
NULL, /* read_summary */
- NULL, /* write_optimization_summary */
- NULL, /* read_optimization_summary */
+ ipa_reference_write_optimization_summary,/* write_optimization_summary */
+ ipa_reference_read_optimization_summary,/* read_optimization_summary */
NULL, /* stmt_fixup */
0, /* TODOs */
NULL, /* function_transform */
NULL /* variable_transform */
};
-
-#include "gt-ipa-reference.h"
OSDN Git Service
