/* Interprocedural constant propagation
- Copyright (C) 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
+ Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011
+ Free Software Foundation, Inc.
Contributed by Razya Ladelsky <RAZYA@il.ibm.com>
-
+
This file is part of GCC.
-
+
GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.
-
+
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
-
+
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
{
printf ("value is %d",y);
}
-
+
int f (int x)
{
g (x);
f (3);
h (3);
}
-
-
+
+
The IPCP algorithm will find that g's formal argument y is always called
with the value 3.
The algorithm used is based on "Interprocedural Constant Propagation", by
- Challahan David, Keith D Cooper, Ken Kennedy, Linda Torczon, Comp86, pg
+ David Callahan, Keith D Cooper, Ken Kennedy, Linda Torczon, Comp86, pg
152-161
-
+
The optimization is divided into three stages:
First stage - intraprocedural analysis
=======================================
This phase computes jump_function and modification flags.
-
+
A jump function for a callsite represents the values passed as an actual
arguments of a given callsite. There are three types of values:
Pass through - the caller's formal parameter is passed as an actual argument.
Constant - a constant is passed as an actual argument.
Unknown - neither of the above.
-
+
The jump function info, ipa_jump_func, is stored in ipa_edge_args
structure (defined in ipa_prop.h and pointed to by cgraph_node->aux)
modified_flags are defined in ipa_node_params structure
(defined in ipa_prop.h and pointed to by cgraph_edge->aux).
-
- -ipcp_init_stage() is the first stage driver.
+
+ -ipcp_generate_summary() is the first stage driver.
Second stage - interprocedural analysis
========================================
TOP - unknown.
BOTTOM - non constant.
CONSTANT - constant value.
-
+
Lattice describing a formal parameter p will have a constant value if all
callsites invoking this function have the same constant value passed to p.
-
+
The lattices are stored in ipcp_lattice which is itself in ipa_node_params
structure (defined in ipa_prop.h and pointed to by cgraph_edge->aux).
and many calls redirected back to fit the description above.
-ipcp_insert_stage() is the third phase driver.
-
+
+
+ This pass also performs devirtualization - turns virtual calls into direct
+ ones if it can prove that all invocations of the function call the same
+ callee. This is achieved by building a list of all base types (actually,
+ their BINFOs) that individual parameters can have in an iterative matter
+ just like propagating scalar constants and then examining whether virtual
+ calls which take a parameter as their object fold to the same target for all
+ these types. If we cannot enumerate all types or there is a type which does
+ not have any BINFO associated with it, cannot_devirtualize of the associated
+ parameter descriptor is set which is an equivalent of BOTTOM lattice value
+ in standard IPA constant propagation.
*/
#include "config.h"
#include "coretypes.h"
#include "tree.h"
#include "target.h"
+#include "gimple.h"
#include "cgraph.h"
#include "ipa-prop.h"
#include "tree-flow.h"
#include "flags.h"
#include "timevar.h"
#include "diagnostic.h"
+#include "tree-pretty-print.h"
#include "tree-dump.h"
#include "tree-inline.h"
#include "fibheap.h"
#include "params.h"
+#include "ipa-inline.h"
/* Number of functions identified as candidates for cloning. When not cloning
we can simplify iterate stage not forcing it to go through the decision
ipcp_init_cloned_node (struct cgraph_node *orig_node,
struct cgraph_node *new_node)
{
- ipa_check_create_node_params ();
- ipa_initialize_node_params (new_node);
+ gcc_checking_assert (ipa_node_params_vector
+ && (VEC_length (ipa_node_params_t,
+ ipa_node_params_vector)
+ > (unsigned) cgraph_max_uid));
+ gcc_checking_assert (IPA_NODE_REF (new_node)->params);
IPA_NODE_REF (new_node)->ipcp_orig_node = orig_node;
}
-/* Perform intraprocedrual analysis needed for ipcp. */
-static void
-ipcp_analyze_node (struct cgraph_node *node)
-{
- /* Unreachable nodes should have been eliminated before ipcp. */
- gcc_assert (node->needed || node->reachable);
-
- ipa_initialize_node_params (node);
- ipa_detect_param_modifications (node);
-}
-
/* Return scale for NODE. */
static inline gcov_type
ipcp_get_node_scale (struct cgraph_node *node)
if (lat1->type != lat2->type)
return false;
- if (operand_equal_p (lat1->constant, lat2->constant, 0))
- return true;
-
- return false;
+ if (TREE_CODE (lat1->constant) == ADDR_EXPR
+ && TREE_CODE (lat2->constant) == ADDR_EXPR
+ && TREE_CODE (TREE_OPERAND (lat1->constant, 0)) == CONST_DECL
+ && TREE_CODE (TREE_OPERAND (lat2->constant, 0)) == CONST_DECL)
+ return operand_equal_p (DECL_INITIAL (TREE_OPERAND (lat1->constant, 0)),
+ DECL_INITIAL (TREE_OPERAND (lat2->constant, 0)), 0);
+ else
+ return operand_equal_p (lat1->constant, lat2->constant, 0);
}
/* Compute Meet arithmetics:
res->constant = lat1->constant;
}
-/* Return the lattice corresponding to the Ith formal parameter of the function
- described by INFO. */
-static inline struct ipcp_lattice *
-ipcp_get_lattice (struct ipa_node_params *info, int i)
-{
- return &(info->params[i].ipcp_lattice);
-}
-
-/* Given the jump function JFUNC, compute the lattice LAT that describes the
- value coming down the callsite. INFO describes the caller node so that
- pass-through jump functions can be evaluated. */
-static void
-ipcp_lattice_from_jfunc (struct ipa_node_params *info, struct ipcp_lattice *lat,
- struct ipa_jump_func *jfunc)
-{
- if (jfunc->type == IPA_JF_CONST)
- {
- lat->type = IPA_CONST_VALUE;
- lat->constant = jfunc->value.constant;
- }
- else if (jfunc->type == IPA_JF_PASS_THROUGH)
- {
- struct ipcp_lattice *caller_lat;
-
- caller_lat = ipcp_get_lattice (info, jfunc->value.formal_id);
- lat->type = caller_lat->type;
- lat->constant = caller_lat->constant;
- }
- else
- lat->type = IPA_BOTTOM;
-}
-
/* True when OLD_LAT and NEW_LAT values are not the same. */
static bool
count = ipa_get_param_count (info);
for (i = 0; i < count; i++)
{
- struct ipcp_lattice *lat = ipcp_get_lattice (info, i);
+ struct ipcp_lattice *lat = ipa_get_lattice (info, i);
fprintf (f, " param [%d]: ", i);
if (lat->type == IPA_CONST_VALUE)
{
+ tree cst = lat->constant;
fprintf (f, "type is CONST ");
- print_generic_expr (f, lat->constant, 0);
- fprintf (f, "\n");
+ print_generic_expr (f, cst, 0);
+ if (TREE_CODE (cst) == ADDR_EXPR
+ && TREE_CODE (TREE_OPERAND (cst, 0)) == CONST_DECL)
+ {
+ fprintf (f, " -> ");
+ print_generic_expr (f, DECL_INITIAL (TREE_OPERAND (cst, 0)),
+ 0);
+ }
}
else if (lat->type == IPA_TOP)
- fprintf (f, "type is TOP\n");
+ fprintf (f, "type is TOP");
else
- fprintf (f, "type is BOTTOM\n");
+ fprintf (f, "type is BOTTOM");
+ if (ipa_param_cannot_devirtualize_p (info, i))
+ fprintf (f, " - cannot_devirtualize set\n");
+ else if (ipa_param_types_vec_empty (info, i))
+ fprintf (f, " - type list empty\n");
+ else
+ fprintf (f, "\n");
}
}
}
+/* Return true if ipcp algorithms would allow cloning NODE. */
+
+static bool
+ipcp_versionable_function_p (struct cgraph_node *node)
+{
+ struct cgraph_edge *edge;
+
+ /* There are a number of generic reasons functions cannot be versioned. We
+ also cannot remove parameters if there are type attributes such as fnspec
+ present. */
+ if (!inline_summary (node)->versionable
+ || TYPE_ATTRIBUTES (TREE_TYPE (node->decl)))
+ return false;
+
+ /* Removing arguments doesn't work if the function takes varargs
+ or use __builtin_apply_args. */
+ for (edge = node->callees; edge; edge = edge->next_callee)
+ {
+ tree t = edge->callee->decl;
+ if (DECL_BUILT_IN_CLASS (t) == BUILT_IN_NORMAL
+ && (DECL_FUNCTION_CODE (t) == BUILT_IN_APPLY_ARGS
+ || DECL_FUNCTION_CODE (t) == BUILT_IN_VA_START))
+ return false;
+ }
+
+ return true;
+}
+
/* Return true if this NODE is viable candidate for cloning. */
static bool
ipcp_cloning_candidate_p (struct cgraph_node *node)
FIXME: in future we should clone such functions when they are called with
different constants, but current ipcp implementation is not good on this.
*/
- if (!node->needed || !node->analyzed)
+ if (cgraph_only_called_directly_p (node) || !node->analyzed)
return false;
+ /* When function address is taken, we are pretty sure it will be called in hidden way. */
+ if (node->address_taken)
+ {
+ if (dump_file)
+ fprintf (dump_file, "Not considering %s for cloning; address is taken.\n",
+ cgraph_node_name (node));
+ return false;
+ }
+
if (cgraph_function_body_availability (node) <= AVAIL_OVERWRITABLE)
{
if (dump_file)
- fprintf (dump_file, "Not considering %s for cloning; body is overwrittable.\n",
+ fprintf (dump_file, "Not considering %s for cloning; body is overwritable.\n",
cgraph_node_name (node));
return false;
}
- if (!tree_versionable_function_p (node->decl))
+ if (!ipcp_versionable_function_p (node))
{
if (dump_file)
fprintf (dump_file, "Not considering %s for cloning; body is not versionable.\n",
if (cgraph_maybe_hot_edge_p (e))
n_hot_calls ++;
}
-
+
if (!n_calls)
{
if (dump_file)
cgraph_node_name (node));
return false;
}
- if (node->local.inline_summary.self_size < n_calls)
+ if (inline_summary (node)->self_size < n_calls)
{
if (dump_file)
fprintf (dump_file, "Considering %s for cloning; code would shrink.\n",
cgraph_node_name (node));
return true;
- }
+ }
if (!flag_ipa_cp_clone)
{
/* When profile is available and function is hot, propagate into it even if
calls seems cold; constant propagation can improve function's speed
- significandly. */
+ significantly. */
if (max_count)
{
if (direct_call_sum > node->count * 90 / 100)
return true;
}
+/* Mark parameter with index I of function described by INFO as unsuitable for
+ devirtualization. Return true if it has already been marked so. */
+
+static bool
+ipa_set_param_cannot_devirtualize (struct ipa_node_params *info, int i)
+{
+ bool ret = info->params[i].cannot_devirtualize;
+ info->params[i].cannot_devirtualize = true;
+ if (info->params[i].types)
+ VEC_free (tree, heap, info->params[i].types);
+ return ret;
+}
+
/* Initialize ipcp_lattices array. The lattices corresponding to supported
types (integers, real types and Fortran constants defined as const_decls)
are initialized to IPA_TOP, the rest of them to IPA_BOTTOM. */
if (ipa_is_called_with_var_arguments (info))
type = IPA_BOTTOM;
- else if (!node->needed)
+ else if (node->local.local)
type = IPA_TOP;
/* When cloning is allowed, we can assume that externally visible functions
are not called. We will compensate this by cloning later. */
type = IPA_BOTTOM;
for (i = 0; i < ipa_get_param_count (info) ; i++)
- ipcp_get_lattice (info, i)->type = type;
+ {
+ ipa_get_lattice (info, i)->type = type;
+ if (type == IPA_BOTTOM)
+ ipa_set_param_cannot_devirtualize (info, i);
+ }
}
-/* build INTEGER_CST tree with type TREE_TYPE and value according to LAT.
- Return the tree. */
+/* Build a constant tree with type TREE_TYPE and value according to LAT.
+ Return the tree, or, if it is not possible to convert such value
+ to TREE_TYPE, NULL. */
static tree
build_const_val (struct ipcp_lattice *lat, tree tree_type)
{
{
if (fold_convertible_p (tree_type, val))
return fold_build1 (NOP_EXPR, tree_type, val);
- else
+ else if (TYPE_SIZE (tree_type) == TYPE_SIZE (TREE_TYPE (val)))
return fold_build1 (VIEW_CONVERT_EXPR, tree_type, val);
+ else
+ return NULL;
}
return val;
}
/* Compute the proper scale for NODE. It is the ratio between the number of
direct calls (represented on the incoming cgraph_edges) and sum of all
- invocations of NODE (represented as count in cgraph_node). */
+ invocations of NODE (represented as count in cgraph_node).
+
+ FIXME: This code is wrong. Since the callers can be also clones and
+ the clones are not scaled yet, the sums gets unrealistically high.
+ To properly compute the counts, we would need to do propagation across
+ callgraph (as external call to A might imply call to non-cloned B
+ if A's clone calls cloned B). */
static void
ipcp_compute_node_scale (struct cgraph_node *node)
{
/* Compute sum of all counts of callers. */
for (cs = node->callers; cs != NULL; cs = cs->next_caller)
sum += cs->count;
+ /* Work around the unrealistically high sum problem. We just don't want
+ the non-cloned body to have negative or very low frequency. Since
+ majority of execution time will be spent in clones anyway, this should
+ give good enough profile. */
+ if (sum > node->count * 9 / 10)
+ sum = node->count * 9 / 10;
if (node->count == 0)
ipcp_set_node_scale (node, 0);
else
ipcp_set_node_scale (node, sum * REG_BR_PROB_BASE / node->count);
}
-/* Initialization and computation of IPCP data structures. This is the initial
- intraprocedural analysis of functions, which gathers information to be
- propagated later on. */
-static void
-ipcp_init_stage (void)
-{
- struct cgraph_node *node;
- struct cgraph_edge *cs;
-
- for (node = cgraph_nodes; node; node = node->next)
- if (node->analyzed)
- ipcp_analyze_node (node);
- for (node = cgraph_nodes; node; node = node->next)
- {
- if (!node->analyzed)
- continue;
- /* building jump functions */
- for (cs = node->callees; cs; cs = cs->next_callee)
- {
- if (!cs->callee->analyzed)
- continue;
- ipa_count_arguments (cs);
- if (ipa_get_cs_argument_count (IPA_EDGE_REF (cs))
- != ipa_get_param_count (IPA_NODE_REF (cs->callee)))
- {
- /* Handle cases of functions with
- a variable number of parameters. */
- ipa_set_called_with_variable_arg (IPA_NODE_REF (cs->callee));
- if (flag_indirect_inlining)
- ipa_compute_jump_functions (cs);
- }
- else
- ipa_compute_jump_functions (cs);
- }
- }
-}
-
/* Return true if there are some formal parameters whose value is IPA_TOP (in
the whole compilation unit). Change their values to IPA_BOTTOM, since they
most probably get their values from outside of this compilation unit. */
count = ipa_get_param_count (info);
for (i = 0; i < count; i++)
{
- struct ipcp_lattice *lat = ipcp_get_lattice (info, i);
+ struct ipcp_lattice *lat = ipa_get_lattice (info, i);
if (lat->type == IPA_TOP)
{
prop_again = true;
}
lat->type = IPA_BOTTOM;
}
+ if (!ipa_param_cannot_devirtualize_p (info, i)
+ && ipa_param_types_vec_empty (info, i))
+ {
+ prop_again = true;
+ ipa_set_param_cannot_devirtualize (info, i);
+ if (dump_file)
+ {
+ fprintf (dump_file, "Marking param ");
+ print_generic_expr (dump_file, ipa_get_param (info, i), 0);
+ fprintf (dump_file, " of node %s as unusable for "
+ "devirtualization.\n",
+ cgraph_node_name (node));
+ }
+ }
}
}
return prop_again;
}
+/* Insert BINFO to the list of known types of parameter number I of the
+ function described by CALLEE_INFO. Return true iff the type information
+ associated with the callee parameter changed in any way. */
+
+static bool
+ipcp_add_param_type (struct ipa_node_params *callee_info, int i, tree binfo)
+{
+ int j, count;
+
+ if (ipa_param_cannot_devirtualize_p (callee_info, i))
+ return false;
+
+ if (callee_info->params[i].types)
+ {
+ count = VEC_length (tree, callee_info->params[i].types);
+ for (j = 0; j < count; j++)
+ if (VEC_index (tree, callee_info->params[i].types, j) == binfo)
+ return false;
+ }
+
+ if (VEC_length (tree, callee_info->params[i].types)
+ == (unsigned) PARAM_VALUE (PARAM_DEVIRT_TYPE_LIST_SIZE))
+ return !ipa_set_param_cannot_devirtualize (callee_info, i);
+
+ VEC_safe_push (tree, heap, callee_info->params[i].types, binfo);
+ return true;
+}
+
+/* Copy known types information for parameter number CALLEE_IDX of CALLEE_INFO
+ from a parameter of CALLER_INFO as described by JF. Return true iff the
+ type information changed in any way. JF must be a pass-through or an
+ ancestor jump function. */
+
+static bool
+ipcp_copy_types (struct ipa_node_params *caller_info,
+ struct ipa_node_params *callee_info,
+ int callee_idx, struct ipa_jump_func *jf)
+{
+ int caller_idx, j, count;
+ bool res;
+
+ if (ipa_param_cannot_devirtualize_p (callee_info, callee_idx))
+ return false;
+
+ if (jf->type == IPA_JF_PASS_THROUGH)
+ {
+ if (jf->value.pass_through.operation != NOP_EXPR)
+ {
+ ipa_set_param_cannot_devirtualize (callee_info, callee_idx);
+ return true;
+ }
+ caller_idx = jf->value.pass_through.formal_id;
+ }
+ else
+ caller_idx = jf->value.ancestor.formal_id;
+
+ if (ipa_param_cannot_devirtualize_p (caller_info, caller_idx))
+ {
+ ipa_set_param_cannot_devirtualize (callee_info, callee_idx);
+ return true;
+ }
+
+ if (!caller_info->params[caller_idx].types)
+ return false;
+
+ res = false;
+ count = VEC_length (tree, caller_info->params[caller_idx].types);
+ for (j = 0; j < count; j++)
+ {
+ tree binfo = VEC_index (tree, caller_info->params[caller_idx].types, j);
+ if (jf->type == IPA_JF_ANCESTOR)
+ {
+ binfo = get_binfo_at_offset (binfo, jf->value.ancestor.offset,
+ jf->value.ancestor.type);
+ if (!binfo)
+ {
+ ipa_set_param_cannot_devirtualize (callee_info, callee_idx);
+ return true;
+ }
+ }
+ res |= ipcp_add_param_type (callee_info, callee_idx, binfo);
+ }
+ return res;
+}
+
+/* Propagate type information for parameter of CALLEE_INFO number I as
+ described by JF. CALLER_INFO describes the caller. Return true iff the
+ type information changed in any way. */
+
+static bool
+ipcp_propagate_types (struct ipa_node_params *caller_info,
+ struct ipa_node_params *callee_info,
+ struct ipa_jump_func *jf, int i)
+{
+ switch (jf->type)
+ {
+ case IPA_JF_UNKNOWN:
+ case IPA_JF_CONST_MEMBER_PTR:
+ case IPA_JF_CONST:
+ break;
+
+ case IPA_JF_KNOWN_TYPE:
+ return ipcp_add_param_type (callee_info, i, jf->value.base_binfo);
+
+ case IPA_JF_PASS_THROUGH:
+ case IPA_JF_ANCESTOR:
+ return ipcp_copy_types (caller_info, callee_info, i, jf);
+ }
+
+ /* If we reach this we cannot use this parameter for devirtualization. */
+ return !ipa_set_param_cannot_devirtualize (callee_info, i);
+}
+
/* Interprocedural analysis. The algorithm propagates constants from the
caller's parameters to the callee's arguments. */
static void
struct ipa_node_params *callee_info = IPA_NODE_REF (cs->callee);
struct ipa_edge_args *args = IPA_EDGE_REF (cs);
- if (ipa_is_called_with_var_arguments (callee_info))
+ if (ipa_is_called_with_var_arguments (callee_info)
+ || !cs->callee->analyzed
+ || ipa_is_called_with_var_arguments (callee_info))
continue;
count = ipa_get_cs_argument_count (args);
for (i = 0; i < count; i++)
{
jump_func = ipa_get_ith_jump_func (args, i);
- ipcp_lattice_from_jfunc (info, &inc_lat, jump_func);
- dest_lat = ipcp_get_lattice (callee_info, i);
+ ipa_lattice_from_jfunc (info, &inc_lat, jump_func);
+ dest_lat = ipa_get_lattice (callee_info, i);
ipa_lattice_meet (&new_lat, &inc_lat, dest_lat);
if (ipcp_lattice_changed (&new_lat, dest_lat))
{
dest_lat->constant = new_lat.constant;
ipa_push_func_to_list (&wl, cs->callee);
}
+
+ if (ipcp_propagate_types (info, callee_info, jump_func, i))
+ ipa_push_func_to_list (&wl, cs->callee);
}
}
}
if (dump_file)
fprintf (dump_file, "\nIPA iterate stage:\n\n");
+
+ if (in_lto_p)
+ ipa_update_after_lto_read ();
+
for (node = cgraph_nodes; node; node = node->next)
{
ipcp_initialize_node_lattices (node);
{
/* Once we will be able to do in-place replacement, we can be more
lax here. */
- return tree_versionable_function_p (node->decl);
+ return ipcp_versionable_function_p (node);
}
/* Print count scale data structures. */
struct ipa_replace_map *replace_map;
tree const_val;
- replace_map = GGC_NEW (struct ipa_replace_map);
const_val = build_const_val (lat, TREE_TYPE (parm_tree));
+ if (const_val == NULL_TREE)
+ {
+ if (dump_file)
+ {
+ fprintf (dump_file, " const ");
+ print_generic_expr (dump_file, lat->constant, 0);
+ fprintf (dump_file, " can't be converted to param ");
+ print_generic_expr (dump_file, parm_tree, 0);
+ fprintf (dump_file, "\n");
+ }
+ return NULL;
+ }
+ replace_map = ggc_alloc_ipa_replace_map ();
if (dump_file)
{
fprintf (dump_file, " replacing param ");
{
struct ipa_node_params *orig_callee_info;
int i, count;
- struct ipa_jump_func *jump_func;
struct cgraph_node *node = cs->callee, *orig;
if (!n_cloning_candidates)
return false;
+ /* We can't redirect anything in thunks, yet. */
+ if (cs->caller->thunk.thunk_p)
+ return true;
+
if ((orig = ipcp_get_orig_node (node)) != NULL)
node = orig;
if (ipcp_get_orig_node (cs->caller))
count = ipa_get_param_count (orig_callee_info);
for (i = 0; i < count; i++)
{
- struct ipcp_lattice *lat = ipcp_get_lattice (orig_callee_info, i);
- if (ipcp_lat_is_const (lat))
- {
- jump_func = ipa_get_ith_jump_func (IPA_EDGE_REF (cs), i);
- if (jump_func->type != IPA_JF_CONST)
- return true;
- }
+ struct ipcp_lattice *lat = ipa_get_lattice (orig_callee_info, i);
+ struct ipa_jump_func *jump_func;
+
+ jump_func = ipa_get_ith_jump_func (IPA_EDGE_REF (cs), i);
+ if ((ipcp_lat_is_const (lat)
+ && jump_func->type != IPA_JF_CONST)
+ || (!ipa_param_cannot_devirtualize_p (orig_callee_info, i)
+ && !ipa_param_types_vec_empty (orig_callee_info, i)
+ && jump_func->type != IPA_JF_CONST
+ && jump_func->type != IPA_JF_KNOWN_TYPE))
+ return true;
}
return false;
for (node = cgraph_nodes; node; node = node->next)
if (node->analyzed && ipcp_node_is_clone (node))
{
- bitmap args_to_skip = BITMAP_ALLOC (NULL);
+ bitmap args_to_skip = NULL;
struct cgraph_node *orig_node = ipcp_get_orig_node (node);
struct ipa_node_params *info = IPA_NODE_REF (orig_node);
int i, count = ipa_get_param_count (info);
struct cgraph_edge *cs, *next;
- for (i = 0; i < count; i++)
+ if (node->local.can_change_signature)
{
- struct ipcp_lattice *lat = ipcp_get_lattice (info, i);
- tree parm_tree = ipa_get_param (info, i);
-
- /* We can proactively remove obviously unused arguments. */
- if (is_gimple_reg (parm_tree)
- && !gimple_default_def (DECL_STRUCT_FUNCTION (orig_node->decl),
- parm_tree))
+ args_to_skip = BITMAP_ALLOC (NULL);
+ for (i = 0; i < count; i++)
{
- bitmap_set_bit (args_to_skip, i);
- continue;
- }
+ struct ipcp_lattice *lat = ipa_get_lattice (info, i);
- if (lat->type == IPA_CONST_VALUE)
- bitmap_set_bit (args_to_skip, i);
+ /* We can proactively remove obviously unused arguments. */
+ if (!ipa_is_param_used (info, i))
+ {
+ bitmap_set_bit (args_to_skip, i);
+ continue;
+ }
+
+ if (lat->type == IPA_CONST_VALUE)
+ bitmap_set_bit (args_to_skip, i);
+ }
}
for (cs = node->callers; cs; cs = next)
{
next = cs->next_caller;
if (!ipcp_node_is_clone (cs->caller) && ipcp_need_redirect_p (cs))
- cgraph_redirect_edge_callee (cs, orig_node);
+ {
+ if (dump_file)
+ fprintf (dump_file, "Redirecting edge %s/%i -> %s/%i "
+ "back to %s/%i.",
+ cgraph_node_name (cs->caller), cs->caller->uid,
+ cgraph_node_name (cs->callee), cs->callee->uid,
+ cgraph_node_name (orig_node), orig_node->uid);
+ cgraph_redirect_edge_callee (cs, orig_node);
+ }
}
}
}
scale = ipcp_get_node_scale (orig_node);
node->count = orig_node->count * scale / REG_BR_PROB_BASE;
scale_complement = REG_BR_PROB_BASE - scale;
+
+ gcc_assert (scale_complement >= 0);
orig_node->count =
orig_node->count * scale_complement / REG_BR_PROB_BASE;
for (cs = node->callees; cs; cs = cs->next_callee)
struct cgraph_edge *cs;
int redirectable_node_callers = 0;
int removable_args = 0;
- bool need_original = node->needed;
+ bool need_original
+ = !cgraph_will_be_removed_from_program_if_no_direct_calls (node);
+ VEC (tree, heap) *known_vals = NULL;
struct ipa_node_params *info;
int i, count;
int growth;
else
need_original = true;
- /* If we will be able to fully replace orignal node, we never increase
+ /* If we will be able to fully replace original node, we never increase
program size. */
if (!need_original)
return 0;
info = IPA_NODE_REF (node);
count = ipa_get_param_count (info);
- for (i = 0; i < count; i++)
- {
- struct ipcp_lattice *lat = ipcp_get_lattice (info, i);
- tree parm_tree = ipa_get_param (info, i);
+ VEC_safe_grow_cleared (tree, heap, known_vals, count);
+ if (node->local.can_change_signature)
+ for (i = 0; i < count; i++)
+ {
+ struct ipcp_lattice *lat = ipa_get_lattice (info, i);
- /* We can proactively remove obviously unused arguments. */
- if (is_gimple_reg (parm_tree)
- && !gimple_default_def (DECL_STRUCT_FUNCTION (node->decl),
- parm_tree))
- removable_args++;
+ /* We can proactively remove obviously unused arguments. */
+ if (!ipa_is_param_used (info, i))
+ removable_args++;
- if (lat->type == IPA_CONST_VALUE)
- removable_args++;
- }
+ if (lat->type == IPA_CONST_VALUE)
+ {
+ removable_args++;
+ VEC_replace (tree, known_vals, i, lat->constant);
+ }
+ }
/* We make just very simple estimate of savings for removal of operand from
- call site. Precise cost is dificult to get, as our size metric counts
+ call site. Precise cost is difficult to get, as our size metric counts
constants and moves as free. Generally we are looking for cases that
small function is called very many times. */
- growth = node->local.inline_summary.self_size
+ estimate_ipcp_clone_size_and_time (node, known_vals, &growth, NULL);
+ VEC_free (tree, heap, known_vals);
+ growth = growth
- removable_args * redirectable_node_callers;
if (growth < 0)
return 0;
cost /= freq_sum * 1000 / REG_BR_PROB_BASE + 1;
if (dump_file)
fprintf (dump_file, "Cost of versioning %s is %i, (size: %i, freq: %i)\n",
- cgraph_node_name (node), cost, node->local.inline_summary.self_size,
+ cgraph_node_name (node), cost, inline_summary (node)->self_size,
freq_sum);
return cost + 1;
}
+/* Walk indirect calls of NODE and if any polymorphic can be turned into a
+ direct one now, do so. */
+
+static void
+ipcp_process_devirtualization_opportunities (struct cgraph_node *node)
+{
+ struct ipa_node_params *info = IPA_NODE_REF (node);
+ struct cgraph_edge *ie, *next_ie;
+
+ for (ie = node->indirect_calls; ie; ie = next_ie)
+ {
+ int param_index;
+ HOST_WIDE_INT token, anc_offset;
+ tree target, delta, otr_type;
+ struct ipcp_lattice *lat;
+
+ next_ie = ie->next_callee;
+ if (!ie->indirect_info->polymorphic)
+ continue;
+ param_index = ie->indirect_info->param_index;
+ if (param_index == -1)
+ continue;
+
+ lat = ipa_get_lattice (info, param_index);
+ token = ie->indirect_info->otr_token;
+ anc_offset = ie->indirect_info->anc_offset;
+ otr_type = ie->indirect_info->otr_type;
+ target = NULL_TREE;
+ if (lat->type == IPA_CONST_VALUE)
+ {
+ tree binfo = gimple_extract_devirt_binfo_from_cst (lat->constant);
+ if (!binfo)
+ continue;
+ binfo = get_binfo_at_offset (binfo, anc_offset, otr_type);
+ if (!binfo)
+ continue;
+ target = gimple_get_virt_method_for_binfo (token, binfo, &delta,
+ false);
+ }
+ else
+ {
+ int types_count, j;
+
+ if (ipa_param_cannot_devirtualize_p (info, param_index)
+ || ipa_param_types_vec_empty (info, param_index))
+ continue;
+
+ types_count = VEC_length (tree, info->params[param_index].types);
+ for (j = 0; j < types_count; j++)
+ {
+ tree binfo = VEC_index (tree, info->params[param_index].types, j);
+ tree d, t;
+
+ binfo = get_binfo_at_offset (binfo, anc_offset, otr_type);
+ if (!binfo)
+ {
+ target = NULL_TREE;
+ break;
+ }
+
+ t = gimple_get_virt_method_for_binfo (token, binfo, &d, true);
+ if (!t)
+ {
+ target = NULL_TREE;
+ break;
+ }
+ else if (!target)
+ {
+ target = t;
+ delta = d;
+ }
+ else if (target != t || !tree_int_cst_equal (delta, d))
+ {
+ target = NULL_TREE;
+ break;
+ }
+ }
+ }
+
+ if (target)
+ ipa_make_edge_direct_to_target (ie, target, delta);
+ }
+}
+
/* Return number of live constant parameters. */
static int
ipcp_const_param_count (struct cgraph_node *node)
for (i = 0; i < count; i++)
{
- struct ipcp_lattice *lat = ipcp_get_lattice (info, i);
- tree parm_tree = ipa_get_param (info, i);
- if (ipcp_lat_is_insertable (lat)
+ struct ipcp_lattice *lat = ipa_get_lattice (info, i);
+ if ((ipcp_lat_is_insertable (lat)
/* Do not count obviously unused arguments. */
- && (!is_gimple_reg (parm_tree)
- || gimple_default_def (DECL_STRUCT_FUNCTION (node->decl),
- parm_tree)))
+ && ipa_is_param_used (info, i))
+ || (!ipa_param_cannot_devirtualize_p (info, i)
+ && !ipa_param_types_vec_empty (info, i)))
const_param++;
}
return const_param;
}
+/* Given that a formal parameter of NODE given by INDEX is known to be constant
+ CST, try to find any indirect edges that can be made direct and make them
+ so. Note that INDEX is the number the parameter at the time of analyzing
+ parameter uses and parameter removals should not be considered for it. (In
+ fact, the parameter itself has just been removed.) */
+
+static void
+ipcp_discover_new_direct_edges (struct cgraph_node *node, int index, tree cst)
+{
+ struct cgraph_edge *ie, *next_ie;
+
+ for (ie = node->indirect_calls; ie; ie = next_ie)
+ {
+ struct cgraph_indirect_call_info *ici = ie->indirect_info;
+
+ next_ie = ie->next_callee;
+ if (ici->param_index != index
+ || ici->polymorphic)
+ continue;
+
+ ipa_make_edge_direct_to_target (ie, cst, NULL_TREE);
+ }
+}
+
+
/* Propagate the constant parameters found by ipcp_iterate_stage()
to the function's code. */
static void
{
if (node->count > max_count)
max_count = node->count;
- overall_size += node->local.inline_summary.self_size;
+ overall_size += inline_summary (node)->self_size;
}
max_new_size = overall_size;
max_new_size = PARAM_VALUE (PARAM_LARGE_UNIT_INSNS);
max_new_size = max_new_size * PARAM_VALUE (PARAM_IPCP_UNIT_GROWTH) / 100 + 1;
- /* First collect all functions we proved to have constant arguments to heap. */
+ /* First collect all functions we proved to have constant arguments to
+ heap. */
heap = fibheap_new ();
for (node = cgraph_nodes; node; node = node->next)
{
if (ipa_is_called_with_var_arguments (info))
continue;
if (ipcp_const_param_count (node))
- node->aux = fibheap_insert (heap, ipcp_estimate_cloning_cost (node), node);
+ node->aux = fibheap_insert (heap, ipcp_estimate_cloning_cost (node),
+ node);
}
/* Now clone in priority order until code size growth limits are met or
if (new_size + growth > max_new_size)
break;
if (growth
- && optimize_function_for_size_p (DECL_STRUCT_FUNCTION (node->decl)))
+ && cgraph_optimize_for_size_p (node))
{
if (dump_file)
fprintf (dump_file, "Not versioning, cold code would grow");
continue;
}
- new_size += growth;
-
- /* Look if original function becomes dead after clonning. */
- for (cs = node->callers; cs != NULL; cs = cs->next_caller)
- if (cs->caller == node || ipcp_need_redirect_p (cs))
- break;
- if (!cs && !node->needed)
- bitmap_set_bit (dead_nodes, node->uid);
-
info = IPA_NODE_REF (node);
count = ipa_get_param_count (info);
replace_trees = VEC_alloc (ipa_replace_map_p, gc, 1);
- args_to_skip = BITMAP_GGC_ALLOC ();
+
+ if (node->local.can_change_signature)
+ args_to_skip = BITMAP_GGC_ALLOC ();
+ else
+ args_to_skip = NULL;
for (i = 0; i < count; i++)
{
- struct ipcp_lattice *lat = ipcp_get_lattice (info, i);
+ struct ipcp_lattice *lat = ipa_get_lattice (info, i);
parm_tree = ipa_get_param (info, i);
/* We can proactively remove obviously unused arguments. */
- if (is_gimple_reg (parm_tree)
- && !gimple_default_def (DECL_STRUCT_FUNCTION (node->decl),
- parm_tree))
+ if (!ipa_is_param_used (info, i))
{
- bitmap_set_bit (args_to_skip, i);
+ if (args_to_skip)
+ bitmap_set_bit (args_to_skip, i);
continue;
}
{
replace_param =
ipcp_create_replace_map (parm_tree, lat);
+ if (replace_param == NULL)
+ break;
VEC_safe_push (ipa_replace_map_p, gc, replace_trees, replace_param);
- bitmap_set_bit (args_to_skip, i);
+ if (args_to_skip)
+ bitmap_set_bit (args_to_skip, i);
}
}
+ if (i < count)
+ {
+ if (dump_file)
+ fprintf (dump_file, "Not versioning, some parameters couldn't be replaced");
+ continue;
+ }
+
+ new_size += growth;
+
+ /* Look if original function becomes dead after cloning. */
+ for (cs = node->callers; cs != NULL; cs = cs->next_caller)
+ if (cs->caller == node || ipcp_need_redirect_p (cs))
+ break;
+ if (!cs && cgraph_will_be_removed_from_program_if_no_direct_calls (node))
+ bitmap_set_bit (dead_nodes, node->uid);
/* Compute how many callers node has. */
node_callers = 0;
node_callers++;
redirect_callers = VEC_alloc (cgraph_edge_p, heap, node_callers);
for (cs = node->callers; cs != NULL; cs = cs->next_caller)
- VEC_quick_push (cgraph_edge_p, redirect_callers, cs);
+ if (!cs->indirect_inlining_edge)
+ VEC_quick_push (cgraph_edge_p, redirect_callers, cs);
/* Redirecting all the callers of the node to the
new versioned node. */
node1 =
cgraph_create_virtual_clone (node, redirect_callers, replace_trees,
- args_to_skip);
+ args_to_skip, "constprop");
args_to_skip = NULL;
VEC_free (cgraph_edge_p, heap, redirect_callers);
replace_trees = NULL;
if (node1 == NULL)
continue;
+ ipcp_process_devirtualization_opportunities (node1);
+
if (dump_file)
fprintf (dump_file, "versioned function %s with growth %i, overall %i\n",
cgraph_node_name (node), (int)growth, (int)new_size);
ipcp_init_cloned_node (node, node1);
- /* TODO: We can use indirect inlning info to produce new calls. */
+ info = IPA_NODE_REF (node);
+ for (i = 0; i < count; i++)
+ {
+ struct ipcp_lattice *lat = ipa_get_lattice (info, i);
+ if (lat->type == IPA_CONST_VALUE)
+ ipcp_discover_new_direct_edges (node1, i, lat->constant);
+ }
if (dump_file)
dump_function_to_file (node1->decl, dump_file, dump_flags);
ipa_print_all_params (dump_file);
ipa_print_all_jump_functions (dump_file);
}
+ ipa_check_create_node_params ();
+ ipa_check_create_edge_args ();
/* 2. Do the interprocedural propagation. */
ipcp_iterate_stage ();
/* 3. Insert the constants found to the functions. */
ipcp_print_profile_data (dump_file);
}
/* Free all IPCP structures. */
- free_all_ipa_structures_after_ipa_cp ();
+ ipa_free_all_structures_after_ipa_cp ();
if (dump_file)
fprintf (dump_file, "\nIPA constant propagation end\n");
return 0;
}
-/* Note function body size. */
+/* Initialization and computation of IPCP data structures. This is the initial
+ intraprocedural analysis of functions, which gathers information to be
+ propagated later on. */
+
static void
ipcp_generate_summary (void)
{
+ struct cgraph_node *node;
+
if (dump_file)
fprintf (dump_file, "\nIPA constant propagation start:\n");
- ipa_check_create_node_params ();
- ipa_check_create_edge_args ();
ipa_register_cgraph_hooks ();
- /* 1. Call the init stage to initialize
- the ipa_node_params and ipa_edge_args structures. */
- ipcp_init_stage ();
+
+ /* FIXME: We could propagate through thunks happily and we could be
+ even able to clone them, if needed. Do that later. */
+ FOR_EACH_FUNCTION_WITH_GIMPLE_BODY (node)
+ {
+ /* Unreachable nodes should have been eliminated before ipcp. */
+ gcc_assert (node->needed || node->reachable);
+
+ inline_summary (node)->versionable = tree_versionable_function_p (node->decl);
+ ipa_analyze_node (node);
+ }
+}
+
+/* Write ipcp summary for nodes in SET. */
+static void
+ipcp_write_summary (cgraph_node_set set,
+ varpool_node_set vset ATTRIBUTE_UNUSED)
+{
+ ipa_prop_write_jump_functions (set);
+}
+
+/* Read ipcp summary. */
+static void
+ipcp_read_summary (void)
+{
+ ipa_prop_read_jump_functions ();
}
/* Gate for IPCP optimization. */
static bool
cgraph_gate_cp (void)
{
- return flag_ipa_cp;
+ /* FIXME: We should remove the optimize check after we ensure we never run
+ IPA passes when not optimizing. */
+ return flag_ipa_cp && optimize;
}
-struct ipa_opt_pass pass_ipa_cp =
+struct ipa_opt_pass_d pass_ipa_cp =
{
{
IPA_PASS,
0, /* properties_destroyed */
0, /* todo_flags_start */
TODO_dump_cgraph | TODO_dump_func |
- TODO_remove_functions /* todo_flags_finish */
+ TODO_remove_functions | TODO_ggc_collect /* todo_flags_finish */
},
ipcp_generate_summary, /* generate_summary */
- NULL, /* write_summary */
- NULL, /* read_summary */
- NULL, /* function_read_summary */
+ ipcp_write_summary, /* write_summary */
+ ipcp_read_summary, /* read_summary */
+ NULL, /* write_optimization_summary */
+ NULL, /* read_optimization_summary */
+ NULL, /* stmt_fixup */
0, /* TODOs */
NULL, /* function_transform */
NULL, /* variable_transform */