2010-05-14 Jan Hubicka <jh@suse.cz>
+ * cgraph.h (ipa_discover_readonly_nonaddressable_vars): Declare.
+ (varpool_all_refs_explicit_p): New inline function.
+ * ipa-reference.c: Update comment.
+ (module_statics_written): Remove.
+ (get_static_decl): Remove.
+ (ipa_init): Do not initialize module_statics_written.
+ (analyze_function): Likewise.
+ (generate_summary): Likewise; do not compute module_statics_readonly
+ and do not update variable flags.
+ (propagate): Call ipa_discover_readonly_nonaddressable_vars.
+ * ipa.c: Inlucde flags.h
+ (cgraph_local_node_p): New.
+ (cgraph_remove_unreachable_nodes): Return early when not optimizing;
+ promote functions to local.
+ (ipa_discover_readonly_nonaddressable_vars): New function.
+ (function_and_variable_visibility): Use cgraph_local_node_p.
+ * varpool.c (varpool_finalize_decl): Set force_output for
+ DECL_PRESERVE_P vars.
+
+2010-05-14 Jan Hubicka <jh@suse.cz>
+
* ipa.c (cgraph_remove_unreachable_nodes): Revert accidental commit.
2010-05-14 Richard Guenther <rguenther@suse.de>
void varpool_node_set_remove (varpool_node_set, struct varpool_node *);
void dump_varpool_node_set (FILE *, varpool_node_set);
void debug_varpool_node_set (varpool_node_set);
+void ipa_discover_readonly_nonaddressable_vars (void);
/* In predict.c */
bool cgraph_maybe_hot_edge_p (struct cgraph_edge *e);
return !node->address_taken && cgraph_can_remove_if_no_direct_calls_and_refs_p (node);
}
+/* Return true when all references to VNODE must be visible in ipa_ref_list.
+ i.e. if the variable is not externally visible or not used in some magic
+ way (asm statement or such).
+ The magic uses are all sumarized in force_output flag. */
+
+static inline bool
+varpool_all_refs_explicit_p (struct varpool_node *vnode)
+{
+ return (!vnode->externally_visible
+ && !vnode->used_from_other_partition
+ && !vnode->force_output);
+}
+
/* Constant pool accessor function. */
htab_t constant_pool_htab (void);
/* 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"
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;
-
/* 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
memory. */
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. */
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);
node_removal_hook_holder =
break;
case IPA_REF_STORE:
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));
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. */
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)
all_module_statics);
}
- BITMAP_FREE(module_statics_readonly);
BITMAP_FREE(bm_temp);
if (dump_file)
clean_function_local_data (node);
}
bitmap_obstack_release (&local_info_obstack);
+ ipa_discover_readonly_nonaddressable_vars ();
return 0;
}
#include "timevar.h"
#include "gimple.h"
#include "ggc.h"
+#include "flags.h"
/* Fill array order with all nodes with output flag set in the reverse
topological order. */
&& (DECL_COMDAT (node->decl) || !node->externally_visible));
}
+/* Return true when function can be marked local. */
+
+static bool
+cgraph_local_node_p (struct cgraph_node *node)
+{
+ return (cgraph_only_called_directly_p (node)
+ && node->analyzed
+ && !DECL_EXTERNAL (node->decl)
+ && !node->local.externally_visible
+ && !node->reachable_from_other_partition
+ && !node->in_other_partition);
+}
+
/* Perform reachability analysis and reclaim all unreachable nodes.
If BEFORE_INLINING_P is true this function is called before inlining
decisions has been made. If BEFORE_INLINING_P is false this function also
}
node->aux = NULL;
}
+
if (file)
- fprintf (file, "\nReclaiming variables:");
+ fprintf (file, "\n");
+
+ /* We must release unused extern inlines or sanity checking will fail. Rest of transformations
+ are undesirable at -O0 since we do not want to remove anything. */
+ if (!optimize)
+ return changed;
+
+ if (file)
+ fprintf (file, "Reclaiming variables:");
for (vnode = varpool_nodes; vnode; vnode = vnext)
{
vnext = vnode->next;
if (!vnode->needed)
{
- if (file)
- fprintf (file, " %s", varpool_node_name (vnode));
- varpool_remove_node (vnode);
+ if (file)
+ fprintf (file, " %s", varpool_node_name (vnode));
+ varpool_remove_node (vnode);
+ changed = true;
}
}
+
+ /* Now update address_taken flags and try to promote functions to be local. */
+
if (file)
fprintf (file, "\nClearing address taken flags:");
for (node = cgraph_nodes; node; node = node->next)
bool found = false;
for (i = 0; ipa_ref_list_refering_iterate (&node->ref_list, i, ref)
&& !found; i++)
- found = true;
+ {
+ gcc_assert (ref->use == IPA_REF_ADDR);
+ found = true;
+ }
if (!found)
{
if (file)
fprintf (file, " %s", cgraph_node_name (node));
node->address_taken = false;
+ changed = true;
+ if (cgraph_local_node_p (node))
+ {
+ node->local.local = true;
+ if (file)
+ fprintf (file, " (local)");
+ }
}
}
return changed;
}
+/* Discover variables that have no longer address taken or that are read only
+ and update their flags.
+
+ FIXME: This can not be done in between gimplify and omp_expand since
+ readonly flag plays role on what is shared and what is not. Currently we do
+ this transformation as part of ipa-reference pass, but it would make sense
+ to do it before early optimizations. */
+
+void
+ipa_discover_readonly_nonaddressable_vars (void)
+{
+ struct varpool_node *vnode;
+ if (dump_file)
+ fprintf (dump_file, "Clearing variable flags:");
+ for (vnode = varpool_nodes; vnode; vnode = vnode->next)
+ if (vnode->finalized && varpool_all_refs_explicit_p (vnode)
+ && (TREE_ADDRESSABLE (vnode->decl) || !TREE_READONLY (vnode->decl)))
+ {
+ bool written = false;
+ bool address_taken = false;
+ int i;
+ struct ipa_ref *ref;
+ for (i = 0; ipa_ref_list_refering_iterate (&vnode->ref_list, i, ref)
+ && (!written || !address_taken); i++)
+ switch (ref->use)
+ {
+ case IPA_REF_ADDR:
+ address_taken = true;
+ break;
+ case IPA_REF_LOAD:
+ break;
+ case IPA_REF_STORE:
+ written = true;
+ break;
+ }
+ if (TREE_ADDRESSABLE (vnode->decl) && !address_taken)
+ {
+ if (dump_file)
+ fprintf (dump_file, " %s (addressable)", varpool_node_name (vnode));
+ TREE_ADDRESSABLE (vnode->decl) = 0;
+ }
+ if (!TREE_READONLY (vnode->decl) && !address_taken && !written
+ /* Making variable in explicit section readonly can cause section
+ type conflict.
+ See e.g. gcc.c-torture/compile/pr23237.c */
+ && DECL_SECTION_NAME (vnode->decl) == NULL)
+ {
+ if (dump_file)
+ fprintf (dump_file, " %s (read-only)", varpool_node_name (vnode));
+ TREE_READONLY (vnode->decl) = 1;
+ }
+ }
+ if (dump_file)
+ fprintf (dump_file, "\n");
+}
+
+/* Return true when function NODE should be considered externally visible. */
+
static bool
cgraph_externally_visible_p (struct cgraph_node *node, bool whole_program)
{
segfault though. */
dissolve_same_comdat_group_list (node);
}
- node->local.local = (cgraph_only_called_directly_p (node)
- && node->analyzed
- && !DECL_EXTERNAL (node->decl)
- && !node->local.externally_visible);
+ node->local.local = cgraph_local_node_p (node);
}
for (vnode = varpool_nodes; vnode; vnode = vnode->next)
{
if (node->needed)
varpool_enqueue_needed_node (node);
node->finalized = true;
- if (TREE_THIS_VOLATILE (decl))
+ if (TREE_THIS_VOLATILE (decl) || DECL_PRESERVE_P (decl))
node->force_output = true;
if (decide_is_variable_needed (node, decl))
OSDN Git Service
