/* Callgraph based analysis of static variables.
- Copyright (C) 2004, 2005, 2007 Free Software Foundation, Inc.
+ Copyright (C) 2004-2015 Free Software Foundation, Inc.
Contributed by Kenneth Zadeck <zadeck@naturalbridge.com>
This file is part of GCC.
<http://www.gnu.org/licenses/>. */
/* This file gathers information about how variables whose scope is
- confined to the compilation unit are used.
+ 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 "coretypes.h"
#include "tm.h"
+#include "alias.h"
+#include "symtab.h"
+#include "options.h"
#include "tree.h"
-#include "tree-flow.h"
+#include "fold-const.h"
+#include "calls.h"
+#include "predict.h"
+#include "hard-reg-set.h"
+#include "function.h"
+#include "basic-block.h"
+#include "tree-ssa-alias.h"
+#include "internal-fn.h"
+#include "gimple-expr.h"
+#include "gimple.h"
#include "tree-inline.h"
#include "tree-pass.h"
-#include "langhooks.h"
-#include "pointer-set.h"
-#include "ggc.h"
+#include "splay-tree.h"
+#include "cgraph.h"
#include "ipa-utils.h"
+#include "bitmap.h"
#include "ipa-reference.h"
-#include "c-common.h"
-#include "gimple.h"
-#include "cgraph.h"
-#include "output.h"
#include "flags.h"
-#include "timevar.h"
#include "diagnostic.h"
-#include "langhooks.h"
-
-/* 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;
-
-/* 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. */
-static bitmap all_module_statics;
+#include "data-streamer.h"
+#include "lto-streamer.h"
-static struct pointer_set_t *visited_nodes;
+static void remove_node_data (struct cgraph_node *node,
+ void *data ATTRIBUTE_UNUSED);
+static void duplicate_node_data (struct cgraph_node *src,
+ struct cgraph_node *dst,
+ void *data ATTRIBUTE_UNUSED);
-static bitmap_obstack ipa_obstack;
+/* The static variables defined within the compilation unit that are
+ loaded or stored directly by function that owns this structure. */
-enum initialization_status_t
+struct ipa_reference_local_vars_info_d
{
- UNINITIALIZED,
- RUNNING,
- FINISHED
+ bitmap statics_read;
+ bitmap statics_written;
};
-tree memory_identifier_string;
+/* 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. */
-/* Return the ipa_reference_vars structure starting from the cgraph NODE. */
-static inline ipa_reference_vars_info_t
-get_reference_vars_info_from_cgraph (struct cgraph_node * node)
+struct ipa_reference_global_vars_info_d
{
- return get_function_ann (node->decl)->reference_vars_info;
-}
+ bitmap statics_read;
+ bitmap statics_written;
+};
-/* Get a bitmap that contains all of the locally referenced static
- variables for function FN. */
-static ipa_reference_local_vars_info_t
-get_local_reference_vars_info (tree fn)
+/* Information we save about every function after ipa-reference is completed. */
+
+struct ipa_reference_optimization_summary_d
{
- ipa_reference_vars_info_t info = get_function_ann (fn)->reference_vars_info;
+ bitmap statics_not_read;
+ bitmap statics_not_written;
+};
- if (info)
- return info->local;
- else
- /* This phase was not run. */
- return NULL;
-}
+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;
-/* 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 (tree fn)
+struct ipa_reference_vars_info_d
{
- ipa_reference_vars_info_t info = get_function_ann (fn)->reference_vars_info;
+ struct ipa_reference_local_vars_info_d local;
+ struct ipa_reference_global_vars_info_d global;
+};
- if (info)
- return info->global;
- else
- /* This phase was not run. */
- return NULL;
-}
+typedef struct ipa_reference_vars_info_d *ipa_reference_vars_info_t;
-/* Return a bitmap indexed by VAR_DECL uid for the static variables
- that may be read locally by the execution of the function fn.
- Returns NULL if no data is available. */
+/* This splay tree contains all of the static variables that are
+ being considered by the compilation level alias analysis. */
+static splay_tree reference_vars_to_consider;
-bitmap
-ipa_reference_get_read_local (tree fn)
-{
- ipa_reference_local_vars_info_t l = get_local_reference_vars_info (fn);
- if (l)
- return l->statics_read;
- else
- return NULL;
-}
+/* Set of all interesting module statics. A bit is set for every module
+ static we are considering. This is added to the local info when asm
+ code is found that clobbers all memory. */
+static bitmap all_module_statics;
+/* Set of all statics that should be ignored becuase they are touched by
+ -fno-ipa-reference code. */
+static bitmap ignore_module_statics;
+
+/* Obstack holding bitmaps of local analysis (live from analysis to
+ propagation) */
+static bitmap_obstack local_info_obstack;
+/* Obstack holding global analysis live forever. */
+static bitmap_obstack optimization_summary_obstack;
-/* Return a bitmap indexed by VAR_DECL uid for the static variables
- that may be written locally by the execution of the function fn.
- Returns NULL if no data is available. */
+/* 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;
-bitmap
-ipa_reference_get_written_local (tree fn)
+/* Vector where the reference var infos are actually stored.
+ Indexed by UID of call graph nodes. */
+static vec<ipa_reference_vars_info_t> ipa_reference_vars_vector;
+
+/* TODO: find a place where we should release the vector. */
+static vec<ipa_reference_optimization_summary_t> 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)
{
- ipa_reference_local_vars_info_t l = get_local_reference_vars_info (fn);
- if (l)
- return l->statics_written;
- else
+ if (!ipa_reference_vars_vector.exists ()
+ || ipa_reference_vars_vector.length () <= (unsigned int) node->uid)
return NULL;
+ return ipa_reference_vars_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 (tree fn)
+/* Return the ipa_reference_vars structure starting from the cgraph NODE. */
+static inline ipa_reference_optimization_summary_t
+get_reference_optimization_summary (struct cgraph_node *node)
{
- ipa_reference_global_vars_info_t g = get_global_reference_vars_info (fn);
- if (g)
- return g->statics_read;
- else
+ if (!ipa_reference_opt_sum_vector.exists ()
+ || (ipa_reference_opt_sum_vector.length () <= (unsigned int) node->uid))
return NULL;
+ return ipa_reference_opt_sum_vector[node->uid];
}
-/* 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. */
+/* 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.exists ()
+ || ipa_reference_vars_vector.length () <= (unsigned int) node->uid)
+ ipa_reference_vars_vector.safe_grow_cleared (node->uid + 1);
+ ipa_reference_vars_vector[node->uid] = info;
+}
-bitmap
-ipa_reference_get_written_global (tree 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.exists ()
+ || (ipa_reference_opt_sum_vector.length () <= (unsigned int) node->uid))
+ ipa_reference_opt_sum_vector.safe_grow_cleared (node->uid + 1);
+ ipa_reference_opt_sum_vector[node->uid] = info;
}
-/* Return a bitmap indexed by_DECL_UID uid for the static variables
- that are not read during the execution of the function FN. Returns
+/* Return a bitmap indexed by DECL_UID for the static variables that
+ are *not* read during the execution of the function FN. Returns
NULL if no data is available. */
-bitmap
-ipa_reference_get_not_read_global (tree fn)
+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;
+ if (!opt_for_fn (fn->decl, flag_ipa_reference)
+ || !opt_for_fn (current_function_decl, flag_ipa_reference))
+ return NULL;
+ ipa_reference_optimization_summary_t info =
+ get_reference_optimization_summary (fn->function_symbol (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;
}
-/* Return a bitmap indexed by DECL_UID uid for the static variables
- that are not written during the execution of the function FN. Note
+/* Return a bitmap indexed by DECL_UID for the static variables that
+ are *not* 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_not_written_global (tree fn)
+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;
+ if (!opt_for_fn (fn->decl, flag_ipa_reference)
+ || !opt_for_fn (current_function_decl, flag_ipa_reference))
+ return NULL;
+ ipa_reference_optimization_summary_t 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;
}
\f
-
-/* Add VAR to all_module_statics and the two
- reference_vars_to_consider* sets. */
-
-static inline void
-add_static_var (tree var)
-{
- int uid = DECL_UID (var);
- 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);
- }
-}
-
/* Return true if the variable T is the right kind of static variable to
perform compilation unit scope escape analysis. */
-static inline bool
-has_proper_scope_for_analysis (tree t)
+static inline bool
+is_proper_for_analysis (tree t)
{
/* 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))
return false;
/* 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))
return false;
- /* Do not care about a local automatic that is not static. */
- if (!TREE_STATIC (t) && !DECL_EXTERNAL (t))
+ /* We do not need to analyze readonly vars, we already know they do not
+ alias. */
+ if (TREE_READONLY (t))
return false;
- if (DECL_EXTERNAL (t) || TREE_PUBLIC (t))
+ /* We can not track variables with address taken. */
+ if (TREE_ADDRESSABLE (t))
return false;
- /* We cannot touch decls where the type needs constructing. */
- if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (t)))
+ /* TODO: We could track public variables that are not addressable, but currently
+ frontends don't give us those. */
+ if (TREE_PUBLIC (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)))
- add_static_var (t);
+ /* TODO: Check aliases. */
+ if (bitmap_bit_p (ignore_module_statics, DECL_UID (t)))
+ return false;
return true;
}
-/* If T is a VAR_DECL for a static that we are interested in, add the
- uid to the bitmap. */
+/* Lookup the tree node for the static variable that has UID and
+ convert the name to a string for debugging. */
-static void
-check_operand (ipa_reference_local_vars_info_t local,
- tree t, bool checking_write)
+static const char *
+get_static_name (int index)
{
- if (!t) return;
-
- if ((TREE_CODE (t) == VAR_DECL || TREE_CODE (t) == FUNCTION_DECL)
- && (has_proper_scope_for_analysis (t)))
- {
- if (checking_write)
- {
- if (local)
- bitmap_set_bit (local->statics_written, DECL_UID (t));
- /* Mark the write so we can tell which statics are
- readonly. */
- bitmap_set_bit (module_statics_written, DECL_UID (t));
- }
- else if (local)
- bitmap_set_bit (local->statics_read, DECL_UID (t));
- }
+ splay_tree_node stn =
+ splay_tree_lookup (reference_vars_to_consider, index);
+ return fndecl_name ((tree)(stn->value));
}
-/* Examine tree T for references to static variables. All internal
- references like array references or indirect references are added
- to the READ_BM. Direct references are added to either READ_BM or
- WRITE_BM depending on the value of CHECKING_WRITE. */
-
+/* Dump a set of static vars to FILE. */
static void
-check_tree (ipa_reference_local_vars_info_t local, tree t, bool checking_write)
+dump_static_vars_set_to_file (FILE *f, bitmap set)
{
- if ((TREE_CODE (t) == EXC_PTR_EXPR) || (TREE_CODE (t) == FILTER_EXPR))
+ unsigned int index;
+ bitmap_iterator bi;
+ if (set == NULL)
return;
-
- while (TREE_CODE (t) == REALPART_EXPR
- || TREE_CODE (t) == IMAGPART_EXPR
- || handled_component_p (t))
- {
- if (TREE_CODE (t) == ARRAY_REF)
- check_operand (local, TREE_OPERAND (t, 1), false);
- t = TREE_OPERAND (t, 0);
- }
-
- /* The bottom of an indirect reference can only be read, not
- written. So just recurse and whatever we find, check it against
- the read bitmaps. */
-
- /* if (INDIRECT_REF_P (t) || TREE_CODE (t) == MEM_REF) */
- /* FIXME when we have array_ref's of pointers. */
- if (INDIRECT_REF_P (t))
- check_tree (local, TREE_OPERAND (t, 0), false);
-
- if (SSA_VAR_P (t))
- check_operand (local, t, checking_write);
+ else if (set == all_module_statics)
+ fprintf (f, "ALL");
+ else
+ EXECUTE_IF_SET_IN_BITMAP (set, 0, index, bi)
+ {
+ fprintf (f, "%s ", get_static_name (index));
+ }
}
-/* Scan tree T to see if there are any addresses taken in within T. */
+/* Compute X |= Y, taking into account the possibility that
+ either X or Y is already the maximum set.
+ Return true if X is the maximum set after taking the union with Y. */
-static void
-look_for_address_of (tree t)
+static bool
+union_static_var_sets (bitmap &x, bitmap y)
{
- if (TREE_CODE (t) == ADDR_EXPR)
+ if (x != all_module_statics)
{
- tree x = get_base_var (t);
- if (TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == FUNCTION_DECL)
- if (has_proper_scope_for_analysis (x))
- bitmap_set_bit (module_statics_escape, DECL_UID (x));
+ if (y == all_module_statics)
+ {
+ BITMAP_FREE (x);
+ x = all_module_statics;
+ }
+ else if (bitmap_ior_into (x, y))
+ {
+ /* The union may have reduced X to the maximum set.
+ In that case, we want to make that visible explicitly.
+ Even though bitmap_equal_p can be very expensive, it
+ turns out to be an overall win to check this here for
+ an LTO bootstrap of GCC itself. Liberally extrapoliate
+ that result to be applicable to all cases. */
+ if (bitmap_equal_p (x, all_module_statics))
+ {
+ BITMAP_FREE (x);
+ x = all_module_statics;
+ }
+ }
}
+ return x == all_module_statics;
}
-/* Check to see if T is a read or address of operation on a static var
- we are interested in analyzing. LOCAL is passed in to get access
- to its bit vectors. Local is NULL if this is called from a static
- initializer. */
+/* Return a copy of SET on the bitmap obstack containing SET.
+ But if SET is NULL or the maximum set, return that instead. */
-static void
-check_rhs_var (ipa_reference_local_vars_info_t local, tree t)
+static bitmap
+copy_static_var_set (bitmap set)
{
- look_for_address_of (t);
-
- if (local == NULL)
- return;
-
- check_tree(local, t, false);
+ if (set == NULL || set == all_module_statics)
+ return set;
+ bitmap_obstack *o = set->obstack;
+ gcc_checking_assert (o);
+ bitmap copy = BITMAP_ALLOC (o);
+ bitmap_copy (copy, set);
+ return copy;
}
-/* Check to see if T is an assignment to a static var we are
- interested in analyzing. LOCAL is passed in to get access to its bit
- vectors. */
+/* Compute the union all of the statics read and written by every callee of X
+ into X_GLOBAL->statics_read and X_GLOBAL->statics_written. X_GLOBAL is
+ actually the set representing the cycle containing X. If the read and
+ written sets of X_GLOBAL has been reduced to the maximum set, we don't
+ have to look at the remaining callees. */
static void
-check_lhs_var (ipa_reference_local_vars_info_t local, tree t)
+propagate_bits (ipa_reference_global_vars_info_t x_global, struct cgraph_node *x)
{
- if (local == NULL)
- return;
-
- check_tree(local, t, true);
-}
-
-/* This is a scaled down version of get_asm_expr_operands from
- tree_ssa_operands.c. The version there runs much later and assumes
- that aliasing information is already available. Here we are just
- trying to find if the set of inputs and outputs contain references
- or address of operations to local static variables. FN is the
- function being analyzed and STMT is the actual asm statement. */
-
-static void
-get_asm_stmt_operands (ipa_reference_local_vars_info_t local, gimple stmt)
-{
- size_t noutputs = gimple_asm_noutputs (stmt);
- const char **oconstraints
- = (const char **) alloca ((noutputs) * sizeof (const char *));
- size_t i;
- tree op;
- const char *constraint;
- bool allows_mem, allows_reg, is_inout;
-
- for (i = 0; i < noutputs; i++)
- {
- op = gimple_asm_output_op (stmt, i);
- oconstraints[i] = constraint
- = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (op)));
- parse_output_constraint (&constraint, i, 0, 0,
- &allows_mem, &allows_reg, &is_inout);
-
- check_lhs_var (local, TREE_VALUE (op));
- }
-
- for (i = 0; i < gimple_asm_ninputs (stmt); i++)
- {
- op = gimple_asm_input_op (stmt, i);
- constraint
- = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (op)));
- parse_input_constraint (&constraint, 0, 0, noutputs, 0,
- oconstraints, &allows_mem, &allows_reg);
-
- check_rhs_var (local, TREE_VALUE (op));
- }
-
- for (i = 0; i < gimple_asm_nclobbers (stmt); i++)
+ struct cgraph_edge *e;
+ bool read_all = x_global->statics_read == all_module_statics;
+ bool write_all = x_global->statics_written == all_module_statics;
+ for (e = x->callees;
+ e && !(read_all && write_all);
+ e = e->next_callee)
{
- op = gimple_asm_clobber_op (stmt, i);
- if (simple_cst_equal(TREE_VALUE (op), memory_identifier_string) == 1)
+ enum availability avail;
+ struct cgraph_node *y = e->callee->function_symbol (&avail);
+ if (!y)
+ continue;
+
+ /* Only look into nodes we can propagate something. */
+ int flags = flags_from_decl_or_type (y->decl);
+ if (opt_for_fn (y->decl, flag_ipa_reference)
+ && (avail > AVAIL_INTERPOSABLE
+ || (avail == AVAIL_INTERPOSABLE && (flags & ECF_LEAF))))
{
- /* Abandon all hope, ye who enter here. */
- local->calls_read_all = true;
- local->calls_write_all = true;
- }
- }
-}
+ 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;
-/* Check the parameters of a function call from CALLER to CALL_EXPR to
- see if any of them are static vars. Also check to see if this is
- either an indirect call, a call outside the compilation unit, or
- has special attributes that effect the clobbers. The caller
- parameter is the tree node for the caller and the second operand is
- the tree node for the entire call expression. */
+ /* Calls in the current cycle do not have their global set
+ computed yet (but everything else does because we're
+ visiting nodes in topological order). */
+ if (!y_global->statics_read)
+ continue;
-static void
-check_call (ipa_reference_local_vars_info_t local, gimple stmt)
-{
- int flags = gimple_call_flags (stmt);
- tree operand;
- tree callee_t = gimple_call_fndecl (stmt);
- enum availability avail = AVAIL_NOT_AVAILABLE;
- size_t i;
+ /* If the function is const, it reads no memory even if it
+ seems so to local analysis. */
+ if (flags & ECF_CONST)
+ continue;
- if ((operand = gimple_call_lhs (stmt)) != NULL)
- check_lhs_var (local, operand);
+ union_static_var_sets (x_global->statics_read,
+ y_global->statics_read);
- for (i = 0; i < gimple_call_num_args (stmt); i++)
- check_rhs_var (local, gimple_call_arg (stmt, i));
+ /* If the function is pure, it has no stores even if it
+ seems so to local analysis. If we cannot return from
+ the function, we can safely ignore the call. */
+ if ((flags & ECF_PURE)
+ || e->cannot_lead_to_return_p ())
+ continue;
- if (callee_t)
- {
- struct cgraph_node* callee = cgraph_node(callee_t);
- avail = cgraph_function_body_availability (callee);
+ union_static_var_sets (x_global->statics_written,
+ y_global->statics_written);
+ }
+ else
+ gcc_unreachable ();
+ }
}
-
- if (avail == AVAIL_NOT_AVAILABLE || avail == AVAIL_OVERWRITABLE)
- if (local)
- {
- if (flags & ECF_PURE)
- local->calls_read_all = true;
- else
- {
- local->calls_read_all = true;
- local->calls_write_all = true;
- }
- }
}
-/* TP is the part of the tree currently under the microscope.
- WALK_SUBTREES is part of the walk_tree api but is unused here.
- DATA is cgraph_node of the function being walked. */
+static bool ipa_init_p = false;
-/* FIXME: When this is converted to run over SSA form, this code
- should be converted to use the operand scanner. */
-
-static tree
-scan_stmt_for_static_refs (gimple_stmt_iterator *gsip, bool *handled_ops_p,
- struct walk_stmt_info *data)
+/* The init routine for analyzing global static variable usage. See
+ comments at top for description. */
+static void
+ipa_init (void)
{
- struct cgraph_node *fn = (struct cgraph_node *) data->info;
- gimple stmt = gsi_stmt (*gsip);
- ipa_reference_local_vars_info_t local = NULL;
- if (fn)
- local = get_reference_vars_info_from_cgraph (fn)->local;
-
- switch (gimple_code (stmt))
- {
- case GIMPLE_ASSIGN:
- {
- /* First look on the lhs and see what variable is stored to */
- tree lhs = gimple_assign_lhs (stmt);
- tree rhs1 = gimple_assign_rhs1 (stmt);
- tree rhs2 = gimple_assign_rhs2 (stmt);
- enum tree_code code = gimple_assign_rhs_code (stmt);
-
- check_lhs_var (local, lhs);
-
- /* For the purposes of figuring out what the cast affects */
-
- /* Next check the operands on the rhs to see if they are ok. */
- switch (TREE_CODE_CLASS (code))
- {
- case tcc_binary:
- case tcc_comparison:
- check_rhs_var (local, rhs1);
- check_rhs_var (local, rhs2);
- break;
+ if (ipa_init_p)
+ return;
- case tcc_unary:
- case tcc_reference:
- case tcc_declaration:
- check_rhs_var (local, rhs1);
- break;
+ ipa_init_p = true;
- case tcc_expression:
- switch (code)
- {
- case ADDR_EXPR:
- check_rhs_var (local, rhs1);
- break;
- default:
- break;
- }
- break;
- default:
- break;
- }
- *handled_ops_p = true;
- }
- break;
-
- case GIMPLE_LABEL:
- if (DECL_NONLOCAL (gimple_label_label (stmt)))
- {
- /* Target of long jump. */
- local->calls_read_all = true;
- local->calls_write_all = true;
- }
- break;
-
- case GIMPLE_CALL:
- check_call (local, stmt);
- *handled_ops_p = true;
- break;
-
- case GIMPLE_ASM:
- get_asm_stmt_operands (local, stmt);
- *handled_ops_p = true;
- break;
-
- default:
- break;
- }
- return NULL;
-}
+ if (dump_file)
+ reference_vars_to_consider = splay_tree_new (splay_tree_compare_ints, 0, 0);
-/* Call-back to scan GIMPLE operands for static references. This is supposed
- to work with scan_stmt_for_static_refs so the real call-back data is stored
- inside a walk_stmt_info struct. Callers using the walk_tree interface must
- also wrap the call-back data in a walk_stmt_info struct. */
+ bitmap_obstack_initialize (&local_info_obstack);
+ bitmap_obstack_initialize (&optimization_summary_obstack);
+ all_module_statics = BITMAP_ALLOC (&optimization_summary_obstack);
+ ignore_module_statics = BITMAP_ALLOC (&optimization_summary_obstack);
-static tree
-scan_op_for_static_refs (tree *tp, int *walk_subtrees, void *data)
-{
- struct walk_stmt_info *wi = (struct walk_stmt_info*) data;
- struct cgraph_node *fn = (struct cgraph_node *) wi->info;
- tree t = *tp;
- ipa_reference_local_vars_info_t local = NULL;
- if (fn)
- local = get_reference_vars_info_from_cgraph (fn)->local;
-
- switch (TREE_CODE (t))
- {
- case VAR_DECL:
- if (DECL_INITIAL (t))
- walk_tree (&DECL_INITIAL (t), scan_op_for_static_refs, data,
- wi->pset);
- *walk_subtrees = 0;
- break;
-
- case ADDR_EXPR:
- /* This case is here to find addresses on rhs of constructors in
- decl_initial of static variables. */
- check_rhs_var (local, t);
- *walk_subtrees = 0;
- break;
-
- default:
- break;
- }
- return NULL;
+ 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);
}
-/* 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. */
+/* Set up the persistent info for FN. */
-static const char *
-get_static_name (int index)
+static ipa_reference_local_vars_info_t
+init_function_info (struct cgraph_node *fn)
{
- splay_tree_node stn =
- splay_tree_lookup (reference_vars_to_consider, index);
- if (stn)
- return lang_hooks.decl_printable_name ((tree)(stn->value), 2);
- return NULL;
-}
+ ipa_reference_vars_info_t info
+ = XCNEW (struct ipa_reference_vars_info_d);
-/* Or in all of the bits from every callee into X, the caller's, bit
- vector. There are several cases to check to avoid the sparse
- bitmap oring. */
+ /* Add the info to the tree's annotation. */
+ set_reference_vars_info (fn, info);
-static void
-propagate_bits (struct cgraph_node *x)
-{
- ipa_reference_vars_info_t x_info = get_reference_vars_info_from_cgraph (x);
- ipa_reference_global_vars_info_t x_global = x_info->global;
+ info->local.statics_read = BITMAP_ALLOC (&local_info_obstack);
+ info->local.statics_written = BITMAP_ALLOC (&local_info_obstack);
- struct cgraph_edge *e;
- for (e = x->callees; e; e = e->next_callee)
- {
- struct cgraph_node *y = e->callee;
-
- /* Only look at the master nodes and skip external nodes. */
- y = cgraph_master_clone (y);
- if (y)
- {
- if (get_reference_vars_info_from_cgraph (y))
- {
- ipa_reference_vars_info_t y_info = get_reference_vars_info_from_cgraph (y);
- ipa_reference_global_vars_info_t y_global = y_info->global;
-
- if (x_global->statics_read
- != all_module_statics)
- {
- if (y_global->statics_read
- == all_module_statics)
- {
- BITMAP_FREE (x_global->statics_read);
- x_global->statics_read
- = all_module_statics;
- }
- /* Skip bitmaps that are pointer equal to node's bitmap
- (no reason to spin within the cycle). */
- else if (x_global->statics_read
- != y_global->statics_read)
- bitmap_ior_into (x_global->statics_read,
- y_global->statics_read);
- }
-
- if (x_global->statics_written
- != all_module_statics)
- {
- if (y_global->statics_written
- == all_module_statics)
- {
- BITMAP_FREE (x_global->statics_written);
- x_global->statics_written
- = all_module_statics;
- }
- /* Skip bitmaps that are pointer equal to node's bitmap
- (no reason to spin within the cycle). */
- else if (x_global->statics_written
- != y_global->statics_written)
- bitmap_ior_into (x_global->statics_written,
- y_global->statics_written);
- }
- }
- else
- {
- gcc_unreachable ();
- }
- }
- }
+ return &info->local;
}
-/* Look at all of the callees of X to see which ones represent inlined
- calls. For each of these callees, merge their local info into
- TARGET and check their children recursively.
- This function goes away when Jan changes the inliner and IPA
- analysis so that this is not run between the time when inlining
- decisions are made and when the inlining actually occurs. */
+/* This is the main routine for finding the reference patterns for
+ global variables within a function FN. */
-static void
-merge_callee_local_info (struct cgraph_node *target,
- struct cgraph_node *x)
+static void
+analyze_function (struct cgraph_node *fn)
{
- struct cgraph_edge *e;
- ipa_reference_local_vars_info_t x_l =
- get_reference_vars_info_from_cgraph (target)->local;
+ ipa_reference_local_vars_info_t local;
+ struct ipa_ref *ref = NULL;
+ int i;
+ tree var;
- /* Make the world safe for tail recursion. */
- struct ipa_dfs_info *node_info = (struct ipa_dfs_info *) x->aux;
-
- if (node_info->aux)
+ if (!opt_for_fn (fn->decl, flag_ipa_reference))
return;
-
- node_info->aux = x;
-
- for (e = x->callees; e; e = e->next_callee)
+ local = init_function_info (fn);
+ for (i = 0; fn->iterate_reference (i, ref); i++)
{
- struct cgraph_node *y = e->callee;
- if (y->global.inlined_to)
+ if (!is_a <varpool_node *> (ref->referred))
+ continue;
+ var = ref->referred->decl;
+ if (!is_proper_for_analysis (var))
+ continue;
+ /* 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 (all_module_statics
+ && bitmap_set_bit (all_module_statics, DECL_UID (var)))
{
- ipa_reference_vars_info_t y_info;
- ipa_reference_local_vars_info_t y_l;
- struct cgraph_node* orig_y = y;
-
- y = cgraph_master_clone (y);
- if (y)
- {
- y_info = get_reference_vars_info_from_cgraph (y);
- y_l = y_info->local;
- if (x_l != y_l)
- {
- bitmap_ior_into (x_l->statics_read,
- y_l->statics_read);
- bitmap_ior_into (x_l->statics_written,
- y_l->statics_written);
- }
- x_l->calls_read_all |= y_l->calls_read_all;
- x_l->calls_write_all |= y_l->calls_write_all;
- merge_callee_local_info (target, y);
- }
- else
- {
- fprintf(stderr, "suspect inlining of ");
- dump_cgraph_node (stderr, orig_y);
- fprintf(stderr, "\ninto ");
- dump_cgraph_node (stderr, target);
- dump_cgraph (stderr);
- gcc_assert(false);
- }
+ if (dump_file)
+ splay_tree_insert (reference_vars_to_consider,
+ DECL_UID (var), (splay_tree_value)var);
+ }
+ switch (ref->use)
+ {
+ case IPA_REF_LOAD:
+ bitmap_set_bit (local->statics_read, DECL_UID (var));
+ break;
+ case IPA_REF_STORE:
+ if (ref->cannot_lead_to_return ())
+ break;
+ bitmap_set_bit (local->statics_written, DECL_UID (var));
+ break;
+ case IPA_REF_ADDR:
+ break;
+ default:
+ gcc_unreachable ();
}
}
- node_info->aux = NULL;
+ if (fn->cannot_return_p ())
+ bitmap_clear (local->statics_written);
}
-/* The init routine for analyzing global static variable usage. See
- comments at top for description. */
-static void
-ipa_init (void)
-{
- struct cgraph_node *node;
- memory_identifier_string = build_string(7, "memory");
-
- reference_vars_to_consider =
- splay_tree_new_ggc (splay_tree_compare_ints);
- bitmap_obstack_initialize (&ipa_obstack);
- module_statics_escape = BITMAP_ALLOC (&ipa_obstack);
- module_statics_written = BITMAP_ALLOC (&ipa_obstack);
- all_module_statics = BITMAP_ALLOC (&ipa_obstack);
+/* Called when new clone is inserted to callgraph late. */
- /* This will add NODE->DECL to the splay trees. */
- for (node = cgraph_nodes; node; node = node->next)
- has_proper_scope_for_analysis (node->decl);
+static void
+duplicate_node_data (struct cgraph_node *src, struct cgraph_node *dst,
+ void *data ATTRIBUTE_UNUSED)
+{
+ ipa_reference_optimization_summary_t ginfo;
+ ipa_reference_optimization_summary_t dst_ginfo;
- /* 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 ();
+ ginfo = get_reference_optimization_summary (src);
+ if (!ginfo)
+ return;
+ dst_ginfo = XCNEW (struct ipa_reference_optimization_summary_d);
+ set_reference_optimization_summary (dst, dst_ginfo);
+ dst_ginfo->statics_not_read =
+ copy_static_var_set (ginfo->statics_not_read);
+ dst_ginfo->statics_not_written =
+ copy_static_var_set (ginfo->statics_not_written);
}
-/* 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. */
+/* Called when node is removed. */
-static void
-analyze_variable (struct varpool_node *vnode)
+static void
+remove_node_data (struct cgraph_node *node, void *data ATTRIBUTE_UNUSED)
{
- struct walk_stmt_info wi;
- tree global = vnode->decl;
-
- memset (&wi, 0, sizeof (wi));
- wi.pset = visited_nodes;
- walk_tree (&DECL_INITIAL (global), scan_op_for_static_refs,
- &wi, wi.pset);
+ 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);
+ }
}
-/* This is the main routine for finding the reference patterns for
- global variables within a function FN. */
+/* Analyze each function in the cgraph to see which global or statics
+ are read or written. */
static void
-analyze_function (struct cgraph_node *fn)
+generate_summary (void)
{
- 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);
- tree decl = fn->decl;
- struct walk_stmt_info wi;
-
- /* Add the info to the tree's annotation. */
- get_function_ann (fn->decl)->reference_vars_info = info;
-
- info->local = l;
- l->statics_read = BITMAP_ALLOC (&ipa_obstack);
- l->statics_written = BITMAP_ALLOC (&ipa_obstack);
+ struct cgraph_node *node;
+ unsigned int index;
+ bitmap_iterator bi;
- if (dump_file)
- fprintf (dump_file, "\n local analysis of %s\n", cgraph_node_name (fn));
-
- {
- struct function *this_cfun = DECL_STRUCT_FUNCTION (decl);
- basic_block this_block;
+ ipa_init ();
- FOR_EACH_BB_FN (this_block, this_cfun)
+ /* Process all of the functions next. */
+ FOR_EACH_DEFINED_FUNCTION (node)
+ if (!node->alias && !opt_for_fn (node->decl, flag_ipa_reference))
{
- gimple_stmt_iterator gsi;
- gimple phi;
- tree op;
- use_operand_p use;
- ssa_op_iter iter;
-
- /* Find the addresses taken in phi node arguments. */
- for (gsi = gsi_start_phis (this_block);
- !gsi_end_p (gsi);
- gsi_next (&gsi))
+ struct ipa_ref *ref = NULL;
+ int i;
+ tree var;
+ for (i = 0; node->iterate_reference (i, ref); i++)
{
- phi = gsi_stmt (gsi);
- FOR_EACH_PHI_ARG (use, phi, iter, SSA_OP_USE)
- {
- op = USE_FROM_PTR (use);
- if (TREE_CODE (op) == ADDR_EXPR)
- check_rhs_var (l, op);
- }
+ if (!is_a <varpool_node *> (ref->referred))
+ continue;
+ var = ref->referred->decl;
+ if (!is_proper_for_analysis (var))
+ continue;
+ bitmap_set_bit (ignore_module_statics, DECL_UID (var));
}
+ }
+ FOR_EACH_DEFINED_FUNCTION (node)
+ analyze_function (node);
- memset (&wi, 0, sizeof (wi));
- wi.info = fn;
- wi.pset = visited_nodes;
- for (gsi = gsi_start_bb (this_block); !gsi_end_p (gsi); gsi_next (&gsi))
- walk_gimple_stmt (&gsi, scan_stmt_for_static_refs,
- scan_op_for_static_refs, &wi);
+ if (dump_file)
+ EXECUTE_IF_SET_IN_BITMAP (all_module_statics, 0, index, bi)
+ {
+ fprintf (dump_file, "\nPromotable global:%s (uid=%u)\n",
+ get_static_name (index), index);
}
- }
- /* There may be const decls with interesting right hand sides. */
- if (DECL_STRUCT_FUNCTION (decl))
- {
- tree step;
- for (step = DECL_STRUCT_FUNCTION (decl)->local_decls;
- step;
- step = TREE_CHAIN (step))
+ if (dump_file)
+ FOR_EACH_DEFINED_FUNCTION (node)
+ if (node->get_availability () >= AVAIL_INTERPOSABLE
+ && opt_for_fn (node->decl, flag_ipa_reference))
{
- tree var = TREE_VALUE (step);
- if (TREE_CODE (var) == VAR_DECL
- && DECL_INITIAL (var)
- && !TREE_STATIC (var))
- {
- memset (&wi, 0, sizeof (wi));
- wi.info = fn;
- wi.pset = visited_nodes;
- walk_tree (&DECL_INITIAL (var), scan_op_for_static_refs,
- &wi, wi.pset);
- }
+ ipa_reference_local_vars_info_t l;
+ unsigned int index;
+ bitmap_iterator bi;
+
+ l = &get_reference_vars_info (node)->local;
+ fprintf (dump_file,
+ "\nFunction name:%s/%i:",
+ node->asm_name (), node->order);
+ fprintf (dump_file, "\n locals read: ");
+ if (l->statics_read)
+ EXECUTE_IF_SET_IN_BITMAP (l->statics_read,
+ 0, index, bi)
+ {
+ fprintf (dump_file, "%s ",
+ get_static_name (index));
+ }
+ fprintf (dump_file, "\n locals written: ");
+ if (l->statics_written)
+ EXECUTE_IF_SET_IN_BITMAP (l->statics_written,
+ 0, index, bi)
+ {
+ fprintf (dump_file, "%s ", get_static_name (index));
+ }
}
- }
}
-
-/* If FN is avail == AVAIL_OVERWRITABLE, replace the effects bit
- vectors with worst case bit vectors. We had to analyze it above to
- find out if it took the address of any statics. However, now that
- we know that, we can get rid of all of the other side effects. */
+\f
+/* Set READ_ALL/WRITE_ALL based on decl flags of NODE. */
static void
-clean_function (struct cgraph_node *fn)
+read_write_all_from_decl (struct cgraph_node *node,
+ bool &read_all, bool &write_all)
{
- ipa_reference_vars_info_t info = get_reference_vars_info_from_cgraph (fn);
- ipa_reference_local_vars_info_t l = info->local;
- ipa_reference_global_vars_info_t g = info->global;
-
- if (l)
+ tree decl = node->decl;
+ int flags = flags_from_decl_or_type (decl);
+ if ((flags & ECF_LEAF)
+ && node->get_availability () < AVAIL_INTERPOSABLE)
+ ;
+ else if (flags & ECF_CONST)
+ ;
+ else if ((flags & ECF_PURE) || node->cannot_return_p ())
{
- 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);
+ read_all = true;
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ fprintf (dump_file, " %s/%i -> read all\n",
+ node->asm_name (), node->order);
}
-
- if (g)
+ else
{
- 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);
+ /* TODO: To be able to produce sane results, we should also handle
+ common builtins, in particular throw. */
+ read_all = true;
+ write_all = true;
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ fprintf (dump_file, " %s/%i -> read all, write all\n",
+ node->asm_name (), node->order);
}
-
-
- free (get_function_ann (fn->decl)->reference_vars_info);
- get_function_ann (fn->decl)->reference_vars_info = NULL;
}
-\f
-/* Produce the global information by preforming a transitive closure
- on the local information that was produced by ipa_analyze_function
- and ipa_analyze_variable. */
+/* Set READ_ALL/WRITE_ALL based on decl flags of NODE or any member
+ in the cycle of NODE. */
-static unsigned int
-static_execute (void)
+static void
+get_read_write_all_from_node (struct cgraph_node *node,
+ bool &read_all, bool &write_all)
{
- struct cgraph_node *node;
- struct varpool_node *vnode;
- 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);
- int i;
-
- ipa_init ();
+ struct cgraph_edge *e, *ie;
- /* Process all of the variables first. */
- FOR_EACH_STATIC_INITIALIZER (vnode)
- analyze_variable (vnode);
-
- /* Process all of the functions next.
-
- We do not want to process any of the clones so we check that this
- is a master clone. However, we do need to process any
- AVAIL_OVERWRITABLE functions (these are never clones) because
- they may cause a static variable to escape. The code that can
- overwrite such a function cannot access the statics because it
- would not be in the same compilation unit. When the analysis is
- finished, the computed information of these AVAIL_OVERWRITABLE is
- replaced with worst case info.
- */
- for (node = cgraph_nodes; node; node = node->next)
- if (node->analyzed
- && (cgraph_is_master_clone (node)
- || (cgraph_function_body_availability (node)
- == AVAIL_OVERWRITABLE)))
- analyze_function (node);
-
- pointer_set_destroy (visited_nodes);
- visited_nodes = NULL;
- if (dump_file)
- dump_cgraph (dump_file);
-
- /* Prune out the variables that were found to behave badly
- (i.e. have their address taken). */
- {
- unsigned int index;
- bitmap_iterator bi;
- bitmap module_statics_readonly = BITMAP_ALLOC (&ipa_obstack);
- bitmap bm_temp = BITMAP_ALLOC (&ipa_obstack);
-
- 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);
+ /* When function is overwritable, we can not assume anything. */
+ if (node->get_availability () <= AVAIL_INTERPOSABLE
+ || (node->analyzed && !opt_for_fn (node->decl, flag_ipa_reference)))
+ read_write_all_from_decl (node, read_all, write_all);
- /* 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. */
+ for (e = node->callees;
+ e && !(read_all && write_all);
+ e = e->next_callee)
+ {
+ enum availability avail;
+ struct cgraph_node *callee = e->callee->function_symbol (&avail);
+ gcc_checking_assert (callee);
+ if (avail <= AVAIL_INTERPOSABLE
+ || (callee->analyzed && !opt_for_fn (callee->decl, flag_ipa_reference)))
+ read_write_all_from_decl (callee, read_all, write_all);
+ }
- bitmap_and_compl (module_statics_readonly, all_module_statics,
- module_statics_written);
- EXECUTE_IF_SET_IN_BITMAP (module_statics_readonly, 0, index, bi)
+ for (ie = node->indirect_calls;
+ ie && !(read_all && write_all);
+ ie = ie->next_callee)
+ if (!(ie->indirect_info->ecf_flags & ECF_CONST))
{
- tree var = get_static_decl (index);
-
- /* Readonly on a function decl is very different from the
- variable. */
- if (TREE_CODE (var) == FUNCTION_DECL)
- continue;
-
- /* 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)
+ read_all = true;
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ fprintf (dump_file, " indirect call -> read all\n");
+ if (!ie->cannot_lead_to_return_p ()
+ && !(ie->indirect_info->ecf_flags & ECF_PURE))
{
- TREE_READONLY (var) = 1;
- if (dump_file)
- fprintf (dump_file, "read-only var %s\n",
- get_static_name (index));
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ fprintf (dump_file, " indirect call -> write all\n");
+ write_all = true;
}
}
+}
- BITMAP_FREE(module_statics_escape);
- BITMAP_FREE(module_statics_written);
+/* Skip edges from and to nodes without ipa_reference enables. This leave
+ them out of strongy connected coponents and makes them easyto skip in the
+ propagation loop bellow. */
- if (dump_file)
- EXECUTE_IF_SET_IN_BITMAP (all_module_statics, 0, index, bi)
- {
- fprintf (dump_file, "\nPromotable global:%s",
- get_static_name (index));
- }
+static bool
+ignore_edge_p (cgraph_edge *e)
+{
+ return (!opt_for_fn (e->caller->decl, flag_ipa_reference)
+ || !opt_for_fn (e->callee->function_symbol ()->decl,
+ flag_ipa_reference));
+}
- for (i = 0; i < order_pos; i++ )
- {
- ipa_reference_local_vars_info_t l;
- node = order[i];
- l = get_reference_vars_info_from_cgraph (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. */
- bitmap_and_into (l->statics_read,
- all_module_statics);
- bitmap_and_into (l->statics_written,
- all_module_statics);
- }
+/* Produce the global information by preforming a transitive closure
+ on the local information that was produced by ipa_analyze_function. */
- BITMAP_FREE(module_statics_readonly);
- BITMAP_FREE(bm_temp);
- }
+static unsigned int
+propagate (void)
+{
+ struct cgraph_node *node;
+ struct cgraph_node **order =
+ XCNEWVEC (struct cgraph_node *, symtab->cgraph_count);
+ int order_pos;
+ int i;
+ bool remove_p;
if (dump_file)
- {
- for (i = 0; i < order_pos; i++ )
- {
- unsigned int index;
- ipa_reference_local_vars_info_t l;
- bitmap_iterator bi;
+ cgraph_node::dump_cgraph (dump_file);
- node = order[i];
- l = get_reference_vars_info_from_cgraph (node)->local;
- fprintf (dump_file,
- "\nFunction name:%s/%i:",
- cgraph_node_name (node), node->uid);
- fprintf (dump_file, "\n locals read: ");
- EXECUTE_IF_SET_IN_BITMAP (l->statics_read,
- 0, index, bi)
- {
- fprintf (dump_file, "%s ",
- get_static_name (index));
- }
- fprintf (dump_file, "\n locals written: ");
- EXECUTE_IF_SET_IN_BITMAP (l->statics_written,
- 0, index, bi)
- {
- fprintf(dump_file, "%s ",
- get_static_name (index));
- }
- }
- }
+ remove_p = ipa_discover_readonly_nonaddressable_vars ();
+ generate_summary ();
- /* 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. */
- order_pos = ipa_utils_reduced_inorder (order, true, true);
+ order_pos = ipa_reduced_postorder (order, true, true, ignore_edge_p);
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++ )
{
+ unsigned x;
+ struct cgraph_node *w;
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;
-
- bool read_all;
- bool write_all;
- struct ipa_dfs_info * w_info;
+ bool read_all = false;
+ bool write_all = false;
node = order[i];
- node_info = get_reference_vars_info_from_cgraph (node);
- if (!node_info)
- {
- dump_cgraph_node (stderr, node);
- dump_cgraph (stderr);
- gcc_unreachable ();
- }
+ if (node->alias || !opt_for_fn (node->decl, flag_ipa_reference))
+ continue;
- node_info->global = node_g;
- node_l = node_info->local;
+ node_info = get_reference_vars_info (node);
+ gcc_assert (node_info);
+ node_l = &node_info->local;
+ node_g = &node_info->global;
- 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",
+ node->asm_name (), node->order);
- /* If any node in a cycle is calls_read_all or calls_write_all
- they all are. */
- w_info = (struct ipa_dfs_info *) node->aux;
- w = w_info->next_cycle;
- while (w)
- {
- ipa_reference_local_vars_info_t w_l =
- get_reference_vars_info_from_cgraph (w)->local;
- read_all |= w_l->calls_read_all;
- write_all |= w_l->calls_write_all;
-
- w_info = (struct ipa_dfs_info *) w->aux;
- w = w_info->next_cycle;
- }
+ vec<cgraph_node *> cycle_nodes = ipa_get_nodes_in_cycle (node);
- /* Initialized the bitmaps for the reduced nodes */
- if (read_all)
- node_g->statics_read = all_module_statics;
- else
+ /* If any node in a cycle is read_all or write_all, they all are. */
+ FOR_EACH_VEC_ELT (cycle_nodes, x, w)
{
- node_g->statics_read = BITMAP_ALLOC (&ipa_obstack);
- bitmap_copy (node_g->statics_read,
- node_l->statics_read);
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ fprintf (dump_file, " Visiting %s/%i\n",
+ w->asm_name (), w->order);
+ get_read_write_all_from_node (w, read_all, write_all);
+ if (read_all && write_all)
+ break;
}
- if (write_all)
+ /* Initialized the bitmaps global sets for the reduced node. */
+ if (read_all)
+ node_g->statics_read = all_module_statics;
+ else
+ node_g->statics_read = copy_static_var_set (node_l->statics_read);
+ if (write_all)
node_g->statics_written = all_module_statics;
else
- {
- node_g->statics_written = BITMAP_ALLOC (&ipa_obstack);
- bitmap_copy (node_g->statics_written,
- node_l->statics_written);
- }
+ node_g->statics_written = copy_static_var_set (node_l->statics_written);
- w_info = (struct ipa_dfs_info *) node->aux;
- w = w_info->next_cycle;
- while (w)
+ /* Merge the sets of this cycle with all sets of callees reached
+ from this cycle. */
+ FOR_EACH_VEC_ELT (cycle_nodes, x, w)
{
- ipa_reference_vars_info_t w_ri =
- get_reference_vars_info_from_cgraph (w);
- ipa_reference_local_vars_info_t w_l = w_ri->local;
-
- /* All nodes within a cycle share the same global info bitmaps. */
- w_ri->global = node_g;
-
- /* 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)
- bitmap_ior_into (node_g->statics_read,
- w_l->statics_read);
- if (!write_all)
- bitmap_ior_into (node_g->statics_written,
- w_l->statics_written);
- w_info = (struct ipa_dfs_info *) w->aux;
- w = w_info->next_cycle;
- }
+ if (read_all && write_all)
+ break;
- w = node;
- while (w)
- {
- propagate_bits (w);
- w_info = (struct ipa_dfs_info *) w->aux;
- w = w_info->next_cycle;
+ if (w != node)
+ {
+ ipa_reference_vars_info_t w_ri = get_reference_vars_info (w);
+ ipa_reference_local_vars_info_t w_l = &w_ri->local;
+ int flags = flags_from_decl_or_type (w->decl);
+
+ if (!(flags & ECF_CONST))
+ read_all = union_static_var_sets (node_g->statics_read,
+ w_l->statics_read);
+ if (!(flags & ECF_PURE)
+ && !w->cannot_return_p ())
+ write_all = union_static_var_sets (node_g->statics_written,
+ w_l->statics_written);
+ }
+
+ propagate_bits (node_g, w);
}
- }
- /* Need to fix up the local information sets. The information that
- has been gathered so far is preinlining. However, the
- compilation will progress post inlining so the local sets for the
- inlined calls need to be merged into the callers. Note that the
- local sets are not shared between all of the nodes in a cycle so
- those nodes in the cycle must be processed explicitly. */
- for (i = 0; i < order_pos; i++ )
- {
- struct ipa_dfs_info * w_info;
- node = order[i];
- merge_callee_local_info (node, node);
-
- w_info = (struct ipa_dfs_info *) node->aux;
- w = w_info->next_cycle;
- while (w)
+ /* All nodes within a cycle have the same global info bitmaps. */
+ FOR_EACH_VEC_ELT (cycle_nodes, x, w)
{
- merge_callee_local_info (w, w);
- w_info = (struct ipa_dfs_info *) w->aux;
- w = w_info->next_cycle;
+ ipa_reference_vars_info_t w_ri = get_reference_vars_info (w);
+ w_ri->global = *node_g;
}
+
+ cycle_nodes.release ();
}
if (dump_file)
{
- for (i = 0; i < order_pos; i++ )
+ for (i = 0; i < order_pos; i++)
{
- ipa_reference_vars_info_t node_info;
- ipa_reference_global_vars_info_t node_g;
- ipa_reference_local_vars_info_t node_l;
- unsigned int index;
- bitmap_iterator bi;
- struct ipa_dfs_info * w_info;
+ unsigned x;
+ struct cgraph_node *w;
node = order[i];
- node_info = get_reference_vars_info_from_cgraph (node);
- node_g = node_info->global;
- node_l = node_info->local;
- fprintf (dump_file,
- "\nFunction name:%s/%i:",
- cgraph_node_name (node), node->uid);
- fprintf (dump_file, "\n locals read: ");
- EXECUTE_IF_SET_IN_BITMAP (node_l->statics_read,
- 0, index, bi)
- {
- fprintf (dump_file, "%s ",
- get_static_name (index));
- }
- fprintf (dump_file, "\n locals written: ");
- EXECUTE_IF_SET_IN_BITMAP (node_l->statics_written,
- 0, index, bi)
- {
- fprintf(dump_file, "%s ",
- get_static_name (index));
- }
+ if (node->alias || !opt_for_fn (node->decl, flag_ipa_reference))
+ continue;
- 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_from_cgraph (w);
- 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: ");
- EXECUTE_IF_SET_IN_BITMAP (w_l->statics_read,
- 0, index, bi)
- {
- fprintf (dump_file, "%s ",
- get_static_name (index));
- }
+ fprintf (dump_file,
+ "\nFunction name:%s/%i:",
+ node->asm_name (), node->order);
- fprintf (dump_file, "\n locals written: ");
- EXECUTE_IF_SET_IN_BITMAP (w_l->statics_written,
- 0, index, bi)
- {
- fprintf(dump_file, "%s ",
- get_static_name (index));
- }
-
+ ipa_reference_vars_info_t node_info = get_reference_vars_info (node);
+ ipa_reference_global_vars_info_t node_g = &node_info->global;
- w_info = (struct ipa_dfs_info *) w->aux;
- w = w_info->next_cycle;
- }
- fprintf (dump_file, "\n globals read: ");
- EXECUTE_IF_SET_IN_BITMAP (node_g->statics_read,
- 0, index, bi)
+ vec<cgraph_node *> cycle_nodes = ipa_get_nodes_in_cycle (node);
+ FOR_EACH_VEC_ELT (cycle_nodes, x, w)
{
- fprintf (dump_file, "%s ",
- get_static_name (index));
+ ipa_reference_vars_info_t w_ri = get_reference_vars_info (w);
+ ipa_reference_local_vars_info_t w_l = &w_ri->local;
+ if (w != node)
+ fprintf (dump_file, "\n next cycle: %s/%i ",
+ w->asm_name (), w->order);
+ fprintf (dump_file, "\n locals read: ");
+ dump_static_vars_set_to_file (dump_file, w_l->statics_read);
+ fprintf (dump_file, "\n locals written: ");
+ dump_static_vars_set_to_file (dump_file, w_l->statics_written);
}
+ cycle_nodes.release ();
+
+ fprintf (dump_file, "\n globals read: ");
+ dump_static_vars_set_to_file (dump_file, node_g->statics_read);
fprintf (dump_file, "\n globals written: ");
- EXECUTE_IF_SET_IN_BITMAP (node_g->statics_written,
- 0, index, bi)
- {
- fprintf (dump_file, "%s ",
- get_static_name (index));
- }
+ dump_static_vars_set_to_file (dump_file, node_g->statics_written);
+ fprintf (dump_file, "\n");
}
}
/* Cleanup. */
- for (i = 0; i < order_pos; i++ )
+ FOR_EACH_DEFINED_FUNCTION (node)
{
ipa_reference_vars_info_t node_info;
ipa_reference_global_vars_info_t node_g;
- node = order[i];
- node_info = get_reference_vars_info_from_cgraph (node);
- node_g = node_info->global;
-
- /* Create the complimentary sets. These are more useful for
- certain apis. */
- node_g->statics_not_read = BITMAP_ALLOC (&ipa_obstack);
- node_g->statics_not_written = BITMAP_ALLOC (&ipa_obstack);
-
- if (node_g->statics_read != all_module_statics)
+ ipa_reference_optimization_summary_t opt;
+
+ node_info = get_reference_vars_info (node);
+ if (!node->alias && opt_for_fn (node->decl, flag_ipa_reference)
+ && (node->get_availability () > AVAIL_INTERPOSABLE
+ || (flags_from_decl_or_type (node->decl) & ECF_LEAF)))
{
- bitmap_and_compl (node_g->statics_not_read,
- all_module_statics,
- node_g->statics_read);
- }
+ node_g = &node_info->global;
+
+ opt = XCNEW (struct ipa_reference_optimization_summary_d);
+ set_reference_optimization_summary (node, opt);
- if (node_g->statics_written
- != all_module_statics)
- bitmap_and_compl (node_g->statics_not_written,
- all_module_statics,
- node_g->statics_written);
+ /* 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);
+ ipa_reference_vars_vector.release ();
+ if (dump_file)
+ splay_tree_delete (reference_vars_to_consider);
+ reference_vars_to_consider = NULL;
+ return remove_p ? TODO_remove_functions : 0;
+}
+
+/* Return true if we need to write summary of NODE. */
+
+static bool
+write_node_summary_p (struct cgraph_node *node,
+ lto_symtab_encoder_t encoder,
+ bitmap ltrans_statics)
+{
+ ipa_reference_optimization_summary_t info;
+
+ /* See if we have (non-empty) info. */
+ if (!node->definition || 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, encoder)
+ && !referenced_from_this_partition_p (node, encoder))
+ 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)
+ {
+ 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. */
+
+static void
+ipa_reference_write_optimization_summary (void)
+{
+ 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_symtab_encoder_t encoder = ob->decl_state->symtab_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_symtab_encoder_size (encoder); i++)
{
- /* Get rid of the aux information. */
-
- if (node->aux)
+ symtab_node *snode = lto_symtab_encoder_deref (encoder, i);
+ varpool_node *vnode = dyn_cast <varpool_node *> (snode);
+ if (vnode
+ && bitmap_bit_p (all_module_statics, DECL_UID (vnode->decl))
+ && referenced_from_this_partition_p (vnode, encoder))
{
- 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 (node->analyzed
- && (cgraph_function_body_availability (node) == AVAIL_OVERWRITABLE))
- clean_function (node);
}
- return 0;
+
+
+ if (ltrans_statics_bitcount)
+ for (i = 0; i < lto_symtab_encoder_size (encoder); i++)
+ {
+ symtab_node *snode = lto_symtab_encoder_deref (encoder, i);
+ cgraph_node *cnode = dyn_cast <cgraph_node *> (snode);
+ if (cnode && write_node_summary_p (cnode, encoder, 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_symtab_encoder_size (encoder); i++)
+ {
+ symtab_node *snode = lto_symtab_encoder_deref (encoder, i);
+ cgraph_node *cnode = dyn_cast <cgraph_node *> (snode);
+ if (cnode && write_node_summary_p (cnode, encoder, ltrans_statics))
+ {
+ ipa_reference_optimization_summary_t info;
+ int node_ref;
+
+ info = get_reference_optimization_summary (cnode);
+ node_ref = lto_symtab_encoder_encode (encoder, snode);
+ 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 bool
-gate_reference (void)
+static void
+ipa_reference_read_optimization_summary (void)
{
- return (flag_ipa_reference
- /* Don't bother doing anything if the program has errors. */
- && !(errorcount || sorrycount));
+ 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 =
+ symtab->add_cgraph_removal_hook (&remove_node_data, NULL);
+ node_duplication_hook_holder =
+ symtab->add_cgraph_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", fndecl_name (v_decl));
+ }
+
+ 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_symtab_encoder_t encoder;
+
+ index = streamer_read_uhwi (ib);
+ encoder = file_data->symtab_node_encoder;
+ node = dyn_cast<cgraph_node *> (lto_symtab_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:",
+ node->asm_name (), node->order);
+
+ /* 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", fndecl_name (v_decl));
+ }
+
+ 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", fndecl_name (v_decl));
+ }
+ 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 (input_location,
+ "ipa reference summary is missing in ltrans unit");
+ }
}
-struct simple_ipa_opt_pass pass_ipa_reference =
+namespace {
+
+const pass_data pass_data_ipa_reference =
{
- {
- SIMPLE_IPA_PASS,
- "static-var", /* name */
- gate_reference, /* gate */
- static_execute, /* execute */
- NULL, /* sub */
- NULL, /* next */
- 0, /* static_pass_number */
- TV_IPA_REFERENCE, /* tv_id */
- 0, /* properties_required */
- 0, /* properties_provided */
- 0, /* properties_destroyed */
- 0, /* todo_flags_start */
- 0 /* todo_flags_finish */
- }
+ IPA_PASS, /* type */
+ "static-var", /* name */
+ OPTGROUP_NONE, /* optinfo_flags */
+ TV_IPA_REFERENCE, /* tv_id */
+ 0, /* properties_required */
+ 0, /* properties_provided */
+ 0, /* properties_destroyed */
+ 0, /* todo_flags_start */
+ 0, /* todo_flags_finish */
};
-#include "gt-ipa-reference.h"
+class pass_ipa_reference : public ipa_opt_pass_d
+{
+public:
+ pass_ipa_reference (gcc::context *ctxt)
+ : ipa_opt_pass_d (pass_data_ipa_reference, ctxt,
+ NULL, /* generate_summary */
+ NULL, /* write_summary */
+ NULL, /* read_summary */
+ ipa_reference_write_optimization_summary, /*
+ write_optimization_summary */
+ ipa_reference_read_optimization_summary, /*
+ read_optimization_summary */
+ NULL, /* stmt_fixup */
+ 0, /* function_transform_todo_flags_start */
+ NULL, /* function_transform */
+ NULL) /* variable_transform */
+ {}
+
+ /* opt_pass methods: */
+ virtual bool gate (function *)
+ {
+ return ((in_lto_p || flag_ipa_reference)
+ /* Don't bother doing anything if the program has errors. */
+ && !seen_error ());
+ }
+
+ virtual unsigned int execute (function *) { return propagate (); }
+
+}; // class pass_ipa_reference
+
+} // anon namespace
+
+ipa_opt_pass_d *
+make_pass_ipa_reference (gcc::context *ctxt)
+{
+ return new pass_ipa_reference (ctxt);
+}
+
+/* Reset all state within ipa-reference.c so that we can rerun the compiler
+ within the same process. For use by toplev::finalize. */
+
+void
+ipa_reference_c_finalize (void)
+{
+ if (ipa_init_p)
+ {
+ bitmap_obstack_release (&optimization_summary_obstack);
+ ipa_init_p = false;
+ }
+
+ if (node_removal_hook_holder)
+ {
+ symtab->remove_cgraph_removal_hook (node_removal_hook_holder);
+ node_removal_hook_holder = NULL;
+ }
+ if (node_duplication_hook_holder)
+ {
+ symtab->remove_cgraph_duplication_hook (node_duplication_hook_holder);
+ node_duplication_hook_holder = NULL;
+ }
+}
projects / gcc.git / blobdiff